Building Your Own Git Assistant with OpenAI and Python

GitHub Copilot is impressive, but what if you could build your own AI-powered Git assistant tailored to your workflow? In this article, we’ll walk step-by-step through building a command-line Git assistant using Python and OpenAI’s API. It will explain diffs, write commit messages, generate .gitignore files, and even suggest semantic version bumps.

This project is perfect for developers looking to integrate LLMs into their local workflows, build internal tools for their teams, or just geek out on the power of automation.

What We'll Build

A Python CLI tool that plugs into your Git repo and:

Explains diffs using natural language
Auto-generates commit messages
Suggests .gitignore entries based on your project
Recommends semver bumps (major, minor, patch) for releases

We'll use:

GitPython to interact with Git repos
argparse for CLI
OpenAI's chat.completion API

Prerequisites

Python 3.9+
OpenAI API key
A Git repo to test with

Install the dependencies:

pip install openai gitpython

Export your OpenAI key:

export OPENAI_API_KEY=sk-...

Project Structure

git-assistant/
├── assistant.py
├── git_helpers.py
├── prompts.py
└── main.py

Step 1: Git Helpers with GitPython

Create git_helpers.py:

from git import Repo

def get_repo(path='.'):
    return Repo(path)

def get_diff(repo):
    return repo.git.diff('HEAD')

def get_staged_diff(repo):
    return repo.git.diff('--cached')

def get_latest_commit(repo):
    return repo.head.commit

Step 2: Define Prompts

Create prompts.py:

def diff_explanation_prompt(diff):
    return f"Explain the following Git diff:\n\n{diff}"

def commit_message_prompt(diff):
    return f"Write a Git commit message for the following change:\n\n{diff}"

def gitignore_prompt(files):
    return f"Generate a .gitignore for a project with these files:\n{files}"

def version_bump_prompt(diff):
    return f"Based on this diff, should the version bump be major, minor, or patch?\n\n{diff}"

Step 3: Core Assistant Logic

Create assistant.py:

import os
import openai
from prompts import (
    diff_explanation_prompt,
    commit_message_prompt,
    gitignore_prompt,
    version_bump_prompt
)

openai.api_key = os.getenv("OPENAI_API_KEY")

def ask_openai(prompt):
    response = openai.ChatCompletion.create(
        model='gpt-4',
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )
    return response['choices'][0]['message']['content']

def explain_diff(diff):
    return ask_openai(diff_explanation_prompt(diff))

def generate_commit_message(diff):
    return ask_openai(commit_message_prompt(diff))

def generate_gitignore(file_list):
    return ask_openai(gitignore_prompt(file_list))

def suggest_version_bump(diff):
    return ask_openai(version_bump_prompt(diff))

Step 4: CLI Interface

Create main.py:

import argparse
from git_helpers import get_repo, get_diff, get_staged_diff
from assistant import (
    explain_diff,
    generate_commit_message,
    generate_gitignore,
    suggest_version_bump
)

repo = get_repo()

parser = argparse.ArgumentParser(description='Your AI Git Assistant')
subparsers = parser.add_subparsers(dest='command')

subparsers.add_parser('explain')
subparsers.add_parser('commit-msg')
subparsers.add_parser('gitignore')
subparsers.add_parser('version-bump')

args = parser.parse_args()

if args.command == 'explain':
    print(explain_diff(get_staged_diff(repo)))

elif args.command == 'commit-msg':
    print(generate_commit_message(get_staged_diff(repo)))

elif args.command == 'gitignore':
    file_list = '\n'.join([f.path for f in repo.tree().traverse()])
    print(generate_gitignore(file_list))

elif args.command == 'version-bump':
    print(suggest_version_bump(get_staged_diff(repo)))

Run it with:

python main.py explain

python main.py commit-msg

Bonus: Aliases and Git Hooks

Want this to run automatically? Add a Git commit hook:

echo '#!/bin/sh
python /path/to/main.py commit-msg > .git/COMMIT_EDITMSG' > .git/hooks/prepare-commit-msg
chmod +x .git/hooks/prepare-commit-msg

Now, every time you commit, your AI assistant writes the commit message for you.

Limitations and Future Enhancements

Prompts may require tuning for large diffs
You could cache OpenAI responses to reduce token costs
Use streaming or function calling for advanced UX
Add unit tests or logging to productionize this for team use

Future features might include:

LLM-powered changelog generation
Release note drafts
Inline PR commenting with LLM feedback
Slack bot integration for Git events

Conclusion

In just a few files of Python, we’ve built a powerful Git assistant that can understand code changes, communicate them in natural language, and accelerate your version control workflow. Best of all, it’s tailored exactly to your stack, your repos, and your rules.

Want to go deeper into Git automation, AI workflows, or infrastructure bots? Explore more at Slaptijack