Automate Your Git Commits with a Bash Script

If you’re working in a fast-paced development environment, constantly adding, committing, and pushing changes to Git can become a repetitive task. What if you could automate this process with a smart Bash script that not only executes these Git commands for you but also generates simple, relevant commit messages based on file diffs? In this blog post, you’ll learn how to create a robust Bash script that simplifies your Git workflow without sacrificing quality or version control traceability.

1. Why Automate Your Git Workflow?

Automation isn’t just about saving a few seconds per commit. It’s about enforcing consistency, reducing cognitive load, and streamlining your development pipeline. When you automate Git operations:

You reduce manual errors.
You ensure consistent commit messages.
You can quickly push hotfixes or minor changes without leaving the terminal.

Our goal is to craft a Bash script that automates these three stages:

git add .
Generate a smart commit message by analyzing git diff.
git commit -m "Smart commit message" and git push

Let’s begin by outlining the script structure.

2. Setting Up the Bash Script Structure

Create a new file called git-auto.sh and make it executable:

#!/bin/bash

# Auto Git Commit Script

# Step 1: Stage all changes
git add .

# Step 2: Generate commit message (we'll add logic here later)
commit_message="Auto commit"

# Step 3: Commit and push
git commit -m "$commit_message"
git push

Make your script executable with:

chmod +x git-auto.sh

This is our skeleton. Now let’s enhance it to generate smarter commit messages.

3. Generating Smart Commit Messages from File Diffs

We want our script to derive the commit message from what files were changed. We’ll use git diff --cached --name-status to list staged file changes with status flags.

# Fetch staged changes with statuses
changes=$(git diff --cached --name-status)

We’ll parse these changes and generate a message. Here’s a Bash function to do that:

generate_commit_message() {
  local changes="$1"
  local msg=""

  while IFS= read -r line; do
    status=$(echo "$line" | awk '{print $1}')
    file=$(echo "$line" | awk '{print $2}')

    case $status in
      A)
        msg+="Added $file\n"
        ;;
      M)
        msg+="Modified $file\n"
        ;;
      D)
        msg+="Deleted $file\n"
        ;;
      R)
        msg+="Renamed file\n"
        ;;
    esac
  done <<< "$changes"

  echo -e "$msg"
}

Now update your main script to use this generated message:

git add .
staged_changes=$(git diff --cached --name-status)
commit_message=$(generate_commit_message "$staged_changes")

git commit -m "$commit_message"
git push

This adds intelligent awareness to your commit messages, making the Git history more meaningful for fellow developers.

4. Handling Edge Cases and Enhancements

To make our script more resilient, let’s add error handling and empty commit checks:

# Exit if no changes are staged
if git diff --cached --quiet; then
  echo "No changes to commit."
  exit 0
fi

# Proceed with add, message, and push

Optional improvement: ask for user confirmation before pushing:

read -p "Push to remote? (y/n): " confirm
if [[ $confirm == "y" ]]; then
  git push
else
  echo "Push skipped."
fi

You can also append a timestamp or branch name to the message for better traceability.

5. Final Complete Script: git-auto.sh

#!/bin/bash

# Auto Git Commit with Smart Messages

generate_commit_message() {
  local changes="$1"
  local msg=""

  while IFS= read -r line; do
    status=$(echo "$line" | awk '{print $1}')
    file=$(echo "$line" | awk '{print $2}')

    case $status in
      A)
        msg+="Added $file\n"
        ;;
      M)
        msg+="Modified $file\n"
        ;;
      D)
        msg+="Deleted $file\n"
        ;;
      R)
        msg+="Renamed file\n"
        ;;
    esac
  done <<< "$changes"

  echo -e "$msg"
}

# Stage all changes
git add .

# Check for staged changes
if git diff --cached --quiet; then
  echo "No staged changes to commit."
  exit 0
fi

# Generate commit message
staged_changes=$(git diff --cached --name-status)
commit_message=$(generate_commit_message "$staged_changes")

# Commit and push
git commit -m "$commit_message"
read -p "Push to remote? (y/n): " confirm
if [[ $confirm == "y" ]]; then
  git push
else
  echo "Push skipped."
fi

Save the above as git-auto.sh, place it somewhere on your $PATH (like /usr/local/bin), and use it with one command to save time on every context switch.

Conclusion

By integrating smart automation into your Git workflow, you reduce tedium and elevate the clarity of your commit history—a win-win for solo developers and teams alike. This kind of Bash scripting is a powerful way to self-document your processes while maintaining velocity. Want to expand further? Consider integrating GPT or AI APIs to generate natural-language summaries of changes in future versions of this script.

Try it out in your daily workflow and take version control automation to the next level!

Useful links: