DEV Community: HIMANSHU KUMAR

I Built a CLI Tool That Writes Git Commit Messages Using Local AI (Ollama)

HIMANSHU KUMAR — Wed, 04 Mar 2026 03:21:14 +0000

One of the most common problems developers face is writing good Git commit messages.

After a long coding session, many of us end up writing commit messages like:

fix stuff
update code
changes
final fix

These messages work, but they don't really explain what changed or why the change was made. Over time, this makes project history harder to understand.

So I decided to build a small developer tool to solve this problem.

Introducing AI Commit — a CLI tool that automatically generates meaningful Git commit messages using local AI models.

The Idea

The idea behind AI Commit is simple:

Detect staged Git changes
Send the diff to a local AI model
Generate a structured commit message
Let the developer review and commit

The interesting part is that everything runs locally using Ollama, which means:

No API keys required
No cloud dependency
Works completely offline
Privacy-first workflow

How It Works

The tool analyzes your staged Git changes and sends them to a local language model.

Git diff
   ↓
AI Commit CLI
   ↓
Local Ollama Model
   ↓
Generated Commit Message

The generated commit message can follow different formats such as:

Conventional commits
Semantic commit messages
Detailed commit descriptions

Installation

The tool is available on PyPI and can be installed with pip.

pip install ollama-git-commit

Requirements

Before using the tool, make sure you have:

Python 3.8+
Git installed
Ollama installed and running

Start Ollama:

ollama serve

Pull a model (example):

ollama pull llama3

Usage

Navigate to any Git repository and stage your changes.

git add .

Then run:

ai-commit

The tool will:

Analyze your staged changes
Generate a commit message
Allow you to review or modify it

This makes writing good commit messages fast and consistent.

Why Local AI?

Many AI developer tools rely on cloud APIs.

While this works well, it has a few drawbacks:

API costs
Internet dependency
Privacy concerns

By using local LLMs with Ollama, AI Commit keeps everything on your machine.

This makes it ideal for developers who prefer offline and private AI workflows.

Tech Stack

The project is built with:

Python
Ollama
Git CLI
Local LLM models
Open source tooling

Open Source Project

AI Commit is fully open source and available on GitHub.

GitHub Repository:
https://github.com/himanshu231204/ai-commit

PyPI Package:
https://pypi.org/project/ollama-git-commit/

If you find the project useful, consider giving it a ⭐ on GitHub.

What I Learned Building This

While building this project, I learned several things:

How to build CLI tools with Python
Integrating local LLMs using Ollama
Packaging and publishing Python libraries to PyPI
Designing developer productivity tools

Open source projects like this are a great way to learn by building real tools.

Future Improvements

Some features I'm planning to add:

Git hook support
Better commit style detection
Configuration file support
VS Code integration

Final Thoughts

Good commit messages are an important part of maintaining clean and understandable project history.

AI Commit is a small step toward making that process easier with the help of local AI.

If you're interested in experimenting with AI-powered developer tools, feel free to try it out.

Feedback and contributions are always welcome.

How I Built an AI-Powered Git Commit Tool Using Ollama in a Weekend

HIMANSHU KUMAR — Tue, 03 Mar 2026 21:40:43 +0000

Ever written a commit message like "fix stuff" or "updates"? Yeah, me too. Last weekend, I built a solution: AI Commit - a CLI tool that generates intelligent commit messages using local AI.

The Problem
The Solution
How It Works
Technical Implementation
Demo
Lessons Learned
What's Next

The Problem

We've all been there. You've spent hours writing code, and when it's time to commit:

git commit -m "fix stuff"
git commit -m "updates"
git commit -m "final version"
git commit -m "actually final this time"

This creates several issues:

Unclear history - Good luck finding that bug fix from 3 months ago
Poor collaboration - Team members can't understand what changed
Difficult code reviews - Reviewers waste time deciphering changes
Broken automation - Changelog generators fail without proper commits

The Solution

AI Commit analyzes your git diff and generates meaningful commit messages following best practices.

Features

🤖 AI-Powered - Uses local Ollama models (llama2, codellama, mistral)
🔒 Privacy-First - Everything runs locally, no cloud APIs
💰 Free - No API keys, no costs, unlimited usage
⚡ Fast - Local generation in seconds
🎨 Multiple Styles - Conventional, Semantic, or Detailed formats
🌐 Offline - Works without internet connection

Example Output

Input:

git add src/auth.py
ai-commit

Output:

╔═══════════════════════════════════════════╗
║         🤖 AI Commit Message Tool         ║
╚═══════════════════════════════════════════╝

Generated Commit Message:
──────────────────────────────────────────────────
feat(auth): implement JWT-based authentication

- Add user login and logout endpoints
- Implement token validation middleware
- Create secure session management
- Add password hashing with bcrypt
──────────────────────────────────────────────────

Options:
  y - Accept and commit
  r - Regenerate message
  e - Edit message
  n - Cancel

How It Works

Architecture

┌──────────────┐
│     User     │
└──────┬───────┘
       │
       │ git add .
       │ ai-commit
       │
       ▼
┌──────────────┐
│  GitService  │──┐
└──────────────┘  │
                  │ get diff
       ┌──────────┘
       │
       ▼
┌─────────────────┐
│ CommitGenerator │
└────────┬────────┘
         │
         │ analyze & prompt
         │
         ▼
┌──────────────┐
│ OllamaClient │
└──────┬───────┘
       │
       │ API call
       │
       ▼
┌──────────────┐
│ Local Ollama │
└──────┬───────┘
       │
       │ generated message
       │
       ▼
┌──────────────┐
│     User     │
└──────────────┘
   (review)

Workflow

Stage Changes - User runs git add
Analyze Diff - Tool reads staged changes
Generate Prompt - Creates context for AI
Call Ollama - Sends to local LLM
Parse Response - Cleans up AI output
User Review - Interactive options
Create Commit - Executes git commit

Technical Implementation

1. Git Integration

class GitService:
    @staticmethod
    def get_staged_diff() -> Optional[str]:
        """Get diff of staged changes"""
        try:
            result = subprocess.run(
                ['git', 'diff', '--cached'],
                capture_output=True,
                text=True,
                check=True
            )
            return result.stdout
        except subprocess.CalledProcessError:
            return None

    @staticmethod
    def commit(message: str) -> bool:
        """Create a git commit"""
        try:
            subprocess.run(
                ['git', 'commit', '-m', message],
                check=True
            )
            return True
        except subprocess.CalledProcessError:
            return False

2. Ollama Integration

class OllamaClient:
    def __init__(self, base_url: str = "http://localhost:11434", 
                 model: str = "llama2"):
        self.base_url = base_url.rstrip('/')
        self.model = model

    def generate(self, prompt: str) -> Optional[str]:
        """Generate text using Ollama"""
        try:
            response = requests.post(
                f"{self.base_url}/api/generate",
                json={
                    "model": self.model,
                    "prompt": prompt,
                    "stream": False
                },
                timeout=30
            )

            if response.status_code == 200:
                return response.json().get('response', '').strip()
            return None
        except requests.exceptions.RequestException as e:
            print(f"Error: {e}")
            return None

3. Prompt Engineering

The key to good output is a well-crafted prompt:

prompt = """You are a git commit message expert. Analyze the 
following git diff and generate a commit message following the 
Conventional Commits format.

Rules:
- Use format: <type>(<scope>): <subject>
- Types: feat, fix, docs, style, refactor, test, chore
- Subject should be lowercase, no period at end
- Keep it concise (max 50 characters for subject)
- If needed, add a body explaining what and why (not how)

Git diff:
{diff}

Generate ONLY the commit message, nothing else:"""

4. Interactive CLI

def get_user_choice(message: str) -> str:
    """Get user input"""
    while True:
        choice = input(f"{message} [y/n/r/e]: ").lower()
        if choice in ['y', 'n', 'r', 'e']:
            return choice
        print("Invalid choice")

5. Beautiful Terminal Output

class Colors:
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    CYAN = '\033[96m'
    BOLD = '\033[1m'
    END = '\033[0m'

# Usage
print(f"{Colors.GREEN}✓ Success!{Colors.END}")
print(f"{Colors.RED}✗ Error!{Colors.END}")

Demo

Here's a real example from the development of AI Commit itself:

Changes made:

Added OllamaClient class
Implemented API integration
Added error handling

Traditional commit:

git commit -m "added ollama stuff"

AI Commit generated:

feat(ollama): implement Ollama API client integration

- Add OllamaClient class for API communication
- Implement model listing and availability check
- Add error handling for connection failures
- Support configurable base URL and model selection

Much better, right?

Lessons Learned

1. Subprocess Management

Working with git commands from Python taught me:

Always capture both stdout and stderr
Handle exit codes properly
Use check=True for automatic error handling

2. API Design

The Ollama API is beautifully simple:

POST /api/generate
{
  "model": "llama2",
  "prompt": "your prompt here",
  "stream": false
}

3. User Experience

CLI tools need:

Clear visual feedback
Color-coded output
Progress indicators
Graceful error handling

4. Prompt Engineering

Getting good AI output requires:

Clear, specific instructions
Examples of desired format
Constraints (length, style)
Context about the task

5. Error Handling

Users will do unexpected things:

No git repo? Handle it.
No staged changes? Handle it.
Ollama not running? Handle it.
Network issues? Handle it.

Performance Comparison

Model	Speed	Quality	Memory
llama2	2-3s	⭐⭐⭐⭐⭐	4GB
codellama	2-3s	⭐⭐⭐⭐⭐	4GB
mistral	1-2s	⭐⭐⭐⭐	4GB
phi	<1s	⭐⭐⭐	2GB
llama3	3-4s	⭐⭐⭐⭐⭐	8GB

Recommendation: codellama for best balance of speed and quality.

What's Next

Short-term (1-2 months)

[ ] Configuration file support (.ai-commit.yml)
[ ] Custom prompt templates
[ ] Git hooks integration
[ ] Emoji support in commits

Medium-term (3-6 months)

[ ] VSCode extension
[ ] Batch commit support
[ ] Commit history analysis
[ ] Team collaboration features

Long-term (6+ months)

[ ] Fine-tuned model for commits
[ ] GitHub/GitLab integration
[ ] Multi-language support
[ ] Enterprise features

Try It Yourself

Installation

# 1. Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Pull a model
ollama pull llama2

# 3. Install AI Commit
git clone https://github.com/himanshu231204/ai-commit.git
cd ai-commit
bash install.sh

Usage

# In any git repository
git add .
ai-commit

Contributing

AI Commit is open source and contributions are welcome!

Ways to contribute:

🐛 Report bugs
💡 Suggest features
📝 Improve documentation
🔧 Submit pull requests

GitHub: https://github.com/himanshu231204/ai-commit

Conclusion

Building AI Commit was a fantastic learning experience. I went from idea to working product in a weekend, and I'm excited to see where the community takes it.

Key takeaways:

Local AI is powerful - Privacy + Performance
CLI tools are fun - Direct, no-nonsense UX
Open source rocks - Community collaboration
Scratch your own itch - Build what you need

What commit message format do you prefer? Let me know in the comments!

Connect With Me

🐙 GitHub: @himanshu231204
💼 LinkedIn: himanshu231204
🐦 Twitter/X: @himanshu231204
☕ Buy Me a Coffee

If you found this helpful, please:

⭐ Star the repo
🔄 Share with friends
💬 Leave a comment

Happy coding! 🚀

This is my first major open source project. Feedback and suggestions are more than welcome!

DEV Community: HIMANSHU KUMAR

I Built a CLI Tool That Writes Git Commit Messages Using Local AI (Ollama)

The Idea

How It Works

Installation

Requirements

Usage

Why Local AI?

Tech Stack

Open Source Project

What I Learned Building This

Future Improvements

Final Thoughts

How I Built an AI-Powered Git Commit Tool Using Ollama in a Weekend

Table of Contents

The Problem

The Solution

Features

Example Output

How It Works

Architecture

Workflow

Technical Implementation

1. Git Integration

2. Ollama Integration

3. Prompt Engineering

4. Interactive CLI

5. Beautiful Terminal Output

Demo

Lessons Learned

1. Subprocess Management

2. API Design

3. User Experience

4. Prompt Engineering

5. Error Handling

Performance Comparison

What's Next

Short-term (1-2 months)

Medium-term (3-6 months)

Long-term (6+ months)

Try It Yourself

Installation

Usage

Contributing

Conclusion

Connect With Me