gitai-cli 0.1.0__tar.gz

gitai_cli-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+.venv
+__pycache__/

gitai_cli-0.1.0/CLAUDE.md

@@ -0,0 +1,34 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+# Install for development
+pip install -e .
+
+# Run the CLI
+gitai commit
+gitai config
+
+# No test suite exists yet
+```
+
+## Architecture
+
+Python CLI tool (Typer + Rich) that generates AI-powered git commit messages using local LLMs. Entry point: `gitai/cli.py`, registered as the `gitai` console script.
+
+Flow for `gitai commit`:
+
+1. **`git.py`** — Runs `git diff --cached` via subprocess; `is_diff_meaningful()` filters out whitespace-only diffs by checking for non-trivial `+`/`-` lines
+2. **`prompt.py`** — Builds the prompt: instructs the LLM to return exactly 3 numbered Conventional Commits suggestions, nothing else
+3. **`ai.py`** — POSTs to `{ollama_url}/api/generate` (non-streaming); parses numbered lines from response by detecting lines starting with a digit followed by `.`
+4. **`cli.py`** — Strips the `"1. "` prefix from suggestions, presents them via `questionary.select`, then runs `git commit -m` via subprocess
+
+**Config** (`config.py`): `~/.gitai.toml`, merged over defaults at load time. Defaults: `model=llama3.2`, `provider=ollama`, `ollama_url=http://localhost:11434`, `commit_style=conventional`, `emoji=false`.
+
+**Known gaps to be aware of:**
+- `provider` and `commit_style` config keys are stored but not yet used — `ai.py` hardcodes the Ollama HTTP API regardless of `provider`
+- `emoji` config is stored but not yet applied to suggestions
+- `litellm` is installed and is the intended path for multi-provider support (OpenAI, Anthropic, Gemini), but is not yet wired up

gitai_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jeranguz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gitai_cli-0.1.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: gitai-cli
+Version: 0.1.0
+Summary: AI-powered git commit message generator
+Project-URL: Homepage, https://github.com/Jeranguz/gitai
+Project-URL: Repository, https://github.com/Jeranguz/gitai
+Project-URL: Issues, https://github.com/Jeranguz/gitai/issues
+Author: Jeranguz
+License: MIT
+License-File: LICENSE
+Keywords: ai,cli,commit,conventional-commits,git,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: gitpython
+Requires-Dist: litellm
+Requires-Dist: questionary
+Requires-Dist: rich
+Requires-Dist: tomli-w
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# gitai
+
+<p align="center">
+  <img src="assets/commit-genie.png" alt="The Commit Genie" width="200"/>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/gitai"><img src="https://img.shields.io/pypi/v/gitai" alt="PyPI version"/></a>
+  <a href="https://pypi.org/project/gitai"><img src="https://img.shields.io/pypi/pyversions/gitai" alt="Python versions"/></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"/></a>
+</p>
+
+AI-powered git commit message generator. Analyzes your staged changes and suggests meaningful commit messages — using any LLM you already have access to.
+
+## Features
+
+- Reads your staged `git diff` and generates 3 commit message suggestions
+- Interactive selection: pick a suggestion or write your own
+- Supports multiple providers: Ollama (local), OpenAI, Anthropic, Gemini, and [more](https://docs.litellm.ai/docs/providers)
+- Two commit styles: [Conventional Commits](https://www.conventionalcommits.org/) or free-form
+- Optional emoji (gitmoji) support
+
+## Installation
+
+```bash
+pip install gitai
+```
+
+Requires Python 3.11+.
+
+## Quick start
+
+```bash
+# 1. Stage your changes
+git add .
+
+# 2. Run gitai
+gitai commit
+```
+
+gitai reads the diff, calls your configured LLM, and presents 3 suggestions to choose from.
+
+## Usage
+
+```
+gitai commit      Generate commit message suggestions for staged changes
+gitai config      View and update settings
+gitai --version   Show version
+gitai --help      Show help
+```
+
+## Configuration
+
+Run `gitai config` to update settings interactively. Settings are stored in `~/.gitai.toml`.
+
+| Key | Default | Description |
+|---|---|---|
+| `provider` | `ollama` | LLM provider |
+| `model` | `llama3.2` | Model name |
+| `ollama_url` | `http://localhost:11434` | Ollama API base URL (Ollama only) |
+| `commit_style` | `conventional` | `conventional` or `free-form` |
+| `emoji` | `false` | Prefix suggestions with gitmoji |
+
+### Supported providers
+
+| Provider | `provider` value | Example `model` value | API key env var |
+|---|---|---|---|
+| Ollama (local) | `ollama` | `llama3.2`, `mistral` | — |
+| Anthropic | `anthropic` | `claude-sonnet-4-6`, `claude-haiku-4-5-20251001` | `ANTHROPIC_API_KEY` |
+| OpenAI | `openai` | `gpt-4o`, `gpt-4o-mini` | `OPENAI_API_KEY` |
+| Gemini | `gemini` | `gemini-2.0-flash` | `GEMINI_API_KEY` |
+
+For cloud providers, set the API key in your shell profile:
+
+**bash/zsh** (`~/.bashrc` or `~/.zshrc`):
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+**PowerShell** (`$PROFILE`):
+```powershell
+$env:ANTHROPIC_API_KEY="sk-ant-..."
+```
+
+### Example `~/.gitai.toml`
+
+```toml
+provider = "anthropic"
+model = "claude-haiku-4-5-20251001"
+commit_style = "conventional"
+emoji = false
+ollama_url = "http://localhost:11434"
+```
+
+## Local setup (Ollama)
+
+If you want to run fully offline with Ollama:
+
+1. Install [Ollama](https://ollama.com/)
+2. Pull a model: `ollama pull llama3.2`
+3. Run `gitai commit` — no API key needed
+
+## TODO
+
+- [ ] Allow configuring the number of suggestions generated
+- [ ] Add `--push` flag to commit and push in one step
+- [ ] Support unstaged changes with an optional `--all` flag

gitai_cli-0.1.0/README.md

@@ -0,0 +1,107 @@
+# gitai
+
+<p align="center">
+  <img src="assets/commit-genie.png" alt="The Commit Genie" width="200"/>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/gitai"><img src="https://img.shields.io/pypi/v/gitai" alt="PyPI version"/></a>
+  <a href="https://pypi.org/project/gitai"><img src="https://img.shields.io/pypi/pyversions/gitai" alt="Python versions"/></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"/></a>
+</p>
+
+AI-powered git commit message generator. Analyzes your staged changes and suggests meaningful commit messages — using any LLM you already have access to.
+
+## Features
+
+- Reads your staged `git diff` and generates 3 commit message suggestions
+- Interactive selection: pick a suggestion or write your own
+- Supports multiple providers: Ollama (local), OpenAI, Anthropic, Gemini, and [more](https://docs.litellm.ai/docs/providers)
+- Two commit styles: [Conventional Commits](https://www.conventionalcommits.org/) or free-form
+- Optional emoji (gitmoji) support
+
+## Installation
+
+```bash
+pip install gitai
+```
+
+Requires Python 3.11+.
+
+## Quick start
+
+```bash
+# 1. Stage your changes
+git add .
+
+# 2. Run gitai
+gitai commit
+```
+
+gitai reads the diff, calls your configured LLM, and presents 3 suggestions to choose from.
+
+## Usage
+
+```
+gitai commit      Generate commit message suggestions for staged changes
+gitai config      View and update settings
+gitai --version   Show version
+gitai --help      Show help
+```
+
+## Configuration
+
+Run `gitai config` to update settings interactively. Settings are stored in `~/.gitai.toml`.
+
+| Key | Default | Description |
+|---|---|---|
+| `provider` | `ollama` | LLM provider |
+| `model` | `llama3.2` | Model name |
+| `ollama_url` | `http://localhost:11434` | Ollama API base URL (Ollama only) |
+| `commit_style` | `conventional` | `conventional` or `free-form` |
+| `emoji` | `false` | Prefix suggestions with gitmoji |
+
+### Supported providers
+
+| Provider | `provider` value | Example `model` value | API key env var |
+|---|---|---|---|
+| Ollama (local) | `ollama` | `llama3.2`, `mistral` | — |
+| Anthropic | `anthropic` | `claude-sonnet-4-6`, `claude-haiku-4-5-20251001` | `ANTHROPIC_API_KEY` |
+| OpenAI | `openai` | `gpt-4o`, `gpt-4o-mini` | `OPENAI_API_KEY` |
+| Gemini | `gemini` | `gemini-2.0-flash` | `GEMINI_API_KEY` |
+
+For cloud providers, set the API key in your shell profile:
+
+**bash/zsh** (`~/.bashrc` or `~/.zshrc`):
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+**PowerShell** (`$PROFILE`):
+```powershell
+$env:ANTHROPIC_API_KEY="sk-ant-..."
+```
+
+### Example `~/.gitai.toml`
+
+```toml
+provider = "anthropic"
+model = "claude-haiku-4-5-20251001"
+commit_style = "conventional"
+emoji = false
+ollama_url = "http://localhost:11434"
+```
+
+## Local setup (Ollama)
+
+If you want to run fully offline with Ollama:
+
+1. Install [Ollama](https://ollama.com/)
+2. Pull a model: `ollama pull llama3.2`
+3. Run `gitai commit` — no API key needed
+
+## TODO
+
+- [ ] Allow configuring the number of suggestions generated
+- [ ] Add `--push` flag to commit and push in one step
+- [ ] Support unstaged changes with an optional `--all` flag

gitai_cli-0.1.0/gitai/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

gitai_cli-0.1.0/gitai/ai.py

@@ -0,0 +1,52 @@
+import litellm
+from litellm.exceptions import APIConnectionError, AuthenticationError
+from gitai.config import load_config
+
+def get_commit_suggestions(prompt: str) -> list[str]:
+    config = load_config()
+
+    provider = config["provider"].lower()
+    model = config["model"]
+    model_string = f"{provider}/{model}"
+
+    kwargs = {
+        "model": model_string,
+        "messages": [{"role": "user", "content": prompt}],
+    }
+
+    if provider == "ollama":
+        kwargs["api_base"] = config["ollama_url"]
+
+    try:
+        response = litellm.completion(**kwargs)
+    except APIConnectionError:
+        if provider == "ollama":
+            raise SystemExit(
+                f"[gitai] Could not connect to Ollama at {config['ollama_url']}. "
+                "Is Ollama running? Try: ollama serve"
+            )
+        raise SystemExit(
+            f"[gitai] Could not connect to the {provider} API. "
+            "Check your network connection and try again."
+        )
+    except AuthenticationError:
+        key_map = {
+            "openai": "OPENAI_API_KEY",
+            "anthropic": "ANTHROPIC_API_KEY",
+            "gemini": "GEMINI_API_KEY",
+        }
+        env_var = key_map.get(provider, f"{provider.upper()}_API_KEY")
+        raise SystemExit(
+            f"[gitai] Authentication failed for {provider}. "
+            f"Set the {env_var} environment variable and try again."
+        )
+
+    text = response.choices[0].message.content.strip()
+
+    suggestions = []
+    for line in text.splitlines():
+        line = line.strip()
+        if line and line[0].isdigit() and "." in line:
+            suggestions.append(line)
+
+    return suggestions

gitai_cli-0.1.0/gitai/cli.py

@@ -0,0 +1,132 @@
+from typing import Optional
+import typer
+import questionary
+import subprocess
+from gitai.config import load_config, save_config
+from gitai.git import get_staged_diff, get_repo_name, is_diff_meaningful
+from gitai.prompt import build_commit_prompt
+from gitai.ai import get_commit_suggestions
+from gitai import __version__
+
+VALID_PROVIDERS = {"ollama", "openai", "anthropic", "gemini"}
+VALID_COMMIT_STYLES = {"conventional", "free-form"}
+
+app = typer.Typer()
+
+
+def _version_callback(value: bool):
+    if value:
+        typer.echo(f"gitai {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+):
+    """AI-powered git commit message generator."""
+
+
+@app.command()
+def commit():
+    """Generate AI-powered commit message suggestions for staged changes."""
+    typer.echo("🔍 Reading your git diff...")
+
+    diff = get_staged_diff()
+    if not diff:
+        typer.echo("No staged changes found. Please stage your changes before committing.")
+        raise typer.Exit(code=1)
+
+    if not is_diff_meaningful(diff):
+        typer.echo("Staged file appears to be empty or has no content changes.")
+        chosen = typer.prompt("Enter your commit message")
+        subprocess.run(["git", "commit", "-m", chosen])
+        typer.echo(f"\n Committed: {chosen}")
+        raise typer.Exit()
+
+    config = load_config()
+    repo_name = get_repo_name()
+    prompt = build_commit_prompt(diff, repo_name, emoji=config["emoji"], commit_style=config["commit_style"])
+
+    typer.echo("Generating commit message suggestions...")
+    suggestions = get_commit_suggestions(prompt)
+
+    if not suggestions:
+        typer.echo("No suggestions generated. Please try again.")
+        raise typer.Exit()
+
+    clean = [s.split(". ", 1)[1] if ". " in s else s for s in suggestions]
+    clean.append("Write my own")
+
+    chosen = questionary.select(
+        "Choose a commit message:",
+        choices=clean
+    ).ask()
+
+    if chosen is None:
+        typer.echo("Aborted.")
+        raise typer.Exit()
+
+    if chosen == "Write my own":
+        chosen = typer.prompt("Enter your custom commit message")
+
+    subprocess.run(["git", "commit", "-m", chosen])
+    typer.echo(f"\n Committed: {chosen}")
+
+
+@app.command()
+def config():
+    """View and update gitai settings."""
+    current = load_config()
+
+    typer.echo("Current configuration:\n")
+    for key, value in current.items():
+        typer.echo(f"  {key}: {value}")
+
+    typer.echo("")
+    if not typer.confirm("Do you want to change any settings?"):
+        raise typer.Exit()
+
+    provider = typer.prompt(
+        "Provider (ollama, openai, anthropic, gemini)",
+        default=current["provider"],
+    )
+    if provider not in VALID_PROVIDERS:
+        typer.echo(f"[gitai] Unknown provider '{provider}'. Choose from: {', '.join(sorted(VALID_PROVIDERS))}")
+        raise typer.Exit(code=1)
+
+    model = typer.prompt("Model name", default=current["model"])
+
+    ollama_url = current["ollama_url"]
+    if provider == "ollama":
+        ollama_url = typer.prompt("Ollama URL", default=current["ollama_url"])
+
+    commit_style = typer.prompt(
+        "Commit style (conventional, free-form)",
+        default=current["commit_style"],
+    )
+    if commit_style not in VALID_COMMIT_STYLES:
+        typer.echo(f"[gitai] Unknown commit style '{commit_style}'. Choose from: {', '.join(sorted(VALID_COMMIT_STYLES))}")
+        raise typer.Exit(code=1)
+
+    emoji = typer.confirm("Use emojis in commit messages?", default=current["emoji"])
+
+    new_config = {
+        "model": model,
+        "provider": provider,
+        "ollama_url": ollama_url,
+        "commit_style": commit_style,
+        "emoji": emoji,
+    }
+
+    save_config(new_config)
+    typer.echo("\n✅ Config saved to ~/.gitai.toml")
+
+
+if __name__ == "__main__":
+    app()

gitai_cli-0.1.0/gitai/config.py

@@ -0,0 +1,27 @@
+import tomllib
+import tomli_w
+from pathlib import Path
+
+CONFIG_PATH = Path.home() / ".gitai.toml"
+
+DEFAULT_CONFIG = {
+    "model": "llama3.2",
+    "provider": "ollama",
+    "ollama_url": "http://localhost:11434",
+    "commit_style": "conventional",
+    "emoji": False,
+}
+
+def load_config() -> dict:
+    if not CONFIG_PATH.exists():
+        save_config(DEFAULT_CONFIG)
+        return DEFAULT_CONFIG.copy()
+    
+    with open(CONFIG_PATH, "rb") as f:
+        user_config = tomllib.load(f)
+
+    return {**DEFAULT_CONFIG, **user_config}
+
+def save_config(config: dict) -> None:
+    with open(CONFIG_PATH, "wb") as f:
+        tomli_w.dump(config, f)

gitai_cli-0.1.0/gitai/git.py

@@ -0,0 +1,24 @@
+import subprocess
+from pathlib import Path
+
+def get_staged_diff() -> str:
+    result = subprocess.run(
+        ["git", "diff", "--cached"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+    )
+    return result.stdout
+
+def get_repo_name() -> str:
+    path = Path.cwd()
+    return path.name
+
+def is_diff_meaningful(diff: str) -> bool:
+    meaningful_lines = [
+        line for line in diff.splitlines()
+        if line.startswith(("+", "-"))
+        and not line.startswith(("+++", "---"))
+        and line.strip() not in ("+", "-", "")
+    ]
+    return len(meaningful_lines) > 0

gitai_cli-0.1.0/gitai/prompt.py

@@ -0,0 +1,73 @@
+def build_commit_prompt(diff: str, repo_name: str, emoji: bool = False, commit_style: str = "conventional") -> str:
+    format_rules = _build_format_rules(commit_style, emoji)
+    example = _build_example(commit_style, emoji)
+
+    return f"""You are an expert developer generating git commit messages.
+
+Repository: {repo_name}
+
+Analyze the git diff below and return exactly 3 commit message suggestions.
+
+Rules:
+{format_rules}
+- Each suggestion must offer a meaningfully different angle — vary the type, scope, or emphasis
+- Base suggestions strictly on what you see in the diff — never invent context
+- Output: a numbered list of exactly 3 lines, no intro, no explanation, nothing else
+
+Example output:
+{example}
+
+Git diff:
+{diff}
+"""
+
+
+def _build_format_rules(commit_style: str, emoji: bool) -> str:
+    if commit_style == "free-form":
+        rules = (
+            "- Format: a single clear imperative sentence, no type prefix required\n"
+            "- Keep the message under 72 characters\n"
+            '- Imperative mood ("add" not "added"), lowercase, no trailing period'
+        )
+        if emoji:
+            rules += "\n- Prefix each message with a relevant emoji that reflects the nature of the change"
+    else:  # conventional (default)
+        rules = (
+            "- Format: type(scope): description\n"
+            "- Types: feat, fix, refactor, chore, docs, style, test, perf, ci, build\n"
+            "- Scope: infer from the file paths or module names changed; omit if unclear\n"
+            '- Description: imperative mood ("add" not "added"), lowercase, no trailing period, under 72 characters'
+        )
+        if emoji:
+            rules += (
+                "\n- Prefix each message with the matching gitmoji before the type: "
+                "✨ feat, 🐛 fix, ♻️ refactor, 🔧 chore, 📝 docs, 🎨 style, ✅ test, ⚡ perf, 👷 ci, 📦 build"
+            )
+    return rules
+
+
+def _build_example(commit_style: str, emoji: bool) -> str:
+    if commit_style == "free-form":
+        if emoji:
+            return (
+                "1. ✨ add refresh token rotation on session expiry\n"
+                "2. 🐛 prevent reuse of invalidated tokens\n"
+                "3. ♻️ extract token validation into dedicated service"
+            )
+        return (
+            "1. add refresh token rotation on session expiry\n"
+            "2. prevent reuse of invalidated tokens\n"
+            "3. extract token validation into dedicated service"
+        )
+    else:  # conventional
+        if emoji:
+            return (
+                "1. ✨ feat(auth): add refresh token rotation on expiry\n"
+                "2. 🐛 fix(auth): prevent reuse of invalidated tokens\n"
+                "3. ♻️ refactor(auth): extract token validation into dedicated service"
+            )
+        return (
+            "1. feat(auth): add refresh token rotation on expiry\n"
+            "2. fix(auth): prevent reuse of invalidated tokens\n"
+            "3. refactor(auth): extract token validation into dedicated service"
+        )

gitai_cli-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "gitai-cli"
+version = "0.1.0"
+description = "AI-powered git commit message generator"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Jeranguz" }]
+requires-python = ">=3.11"
+keywords = ["git", "ai", "commit", "cli", "llm", "conventional-commits"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Version Control :: Git",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "typer",
+    "rich",
+    "gitpython",
+    "litellm",
+    "questionary",
+    "tomli-w",
+]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/Jeranguz/gitai"
+Repository = "https://github.com/Jeranguz/gitai"
+Issues = "https://github.com/Jeranguz/gitai/issues"
+
+[project.scripts]
+gitai = "gitai.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["gitai"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

gitai_cli-0.1.0/tests/test_ai.py

@@ -0,0 +1,163 @@
+from unittest.mock import patch, MagicMock
+import pytest
+from gitai.ai import get_commit_suggestions
+from litellm.exceptions import APIConnectionError, AuthenticationError
+
+FAKE_CONFIG_OLLAMA = {
+    "provider": "ollama",
+    "model": "llama3.2",
+    "ollama_url": "http://localhost:11434",
+}
+
+FAKE_CONFIG_OPENAI = {
+    "provider": "openai",
+    "model": "gpt-4o",
+    "ollama_url": "http://localhost:11434",
+}
+
+FAKE_CONFIG_ANTHROPIC = {
+    "provider": "anthropic",
+    "model": "claude-haiku-4-5-20251001",
+    "ollama_url": "http://localhost:11434",
+}
+
+
+def make_response(text: str):
+    response = MagicMock()
+    response.choices[0].message.content = text
+    return response
+
+
+# --- suggestion parsing ---
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_parses_three_numbered_suggestions(mock_completion, _):
+    mock_completion.return_value = make_response(
+        "1. feat(cli): add commit command\n"
+        "2. fix(cli): handle empty diff\n"
+        "3. chore(cli): clean up imports"
+    )
+    result = get_commit_suggestions("prompt")
+    assert len(result) == 3
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_preserves_full_suggestion_text(mock_completion, _):
+    mock_completion.return_value = make_response(
+        "1. feat(cli): add commit command\n"
+        "2. fix(cli): handle empty diff\n"
+        "3. chore(cli): clean up imports"
+    )
+    result = get_commit_suggestions("prompt")
+    assert result[0] == "1. feat(cli): add commit command"
+    assert result[1] == "2. fix(cli): handle empty diff"
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_ignores_preamble_and_trailing_lines(mock_completion, _):
+    mock_completion.return_value = make_response(
+        "Here are your suggestions:\n"
+        "1. feat(cli): add commit command\n"
+        "2. fix(cli): handle empty diff\n"
+        "3. chore(cli): clean up imports\n"
+        "Hope these help!"
+    )
+    result = get_commit_suggestions("prompt")
+    assert len(result) == 3
+    assert all(r[0].isdigit() for r in result)
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_returns_empty_list_when_no_numbered_lines(mock_completion, _):
+    mock_completion.return_value = make_response("Nothing useful here.")
+    result = get_commit_suggestions("prompt")
+    assert result == []
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_strips_whitespace_from_lines(mock_completion, _):
+    mock_completion.return_value = make_response(
+        "  1. feat(cli): add commit command  \n"
+        "  2. fix(cli): handle empty diff  \n"
+        "  3. chore(cli): clean up imports  "
+    )
+    result = get_commit_suggestions("prompt")
+    assert result[0] == "1. feat(cli): add commit command"
+
+
+# --- model string and api_base ---
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_ollama_model_string_format(mock_completion, _):
+    mock_completion.return_value = make_response("1. feat: add thing")
+    get_commit_suggestions("prompt")
+    assert mock_completion.call_args.kwargs["model"] == "ollama/llama3.2"
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OPENAI)
+@patch("gitai.ai.litellm.completion")
+def test_openai_model_string_format(mock_completion, _):
+    mock_completion.return_value = make_response("1. feat: add thing")
+    get_commit_suggestions("prompt")
+    assert mock_completion.call_args.kwargs["model"] == "openai/gpt-4o"
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_ollama_passes_api_base(mock_completion, _):
+    mock_completion.return_value = make_response("1. feat: add thing")
+    get_commit_suggestions("prompt")
+    assert mock_completion.call_args.kwargs.get("api_base") == "http://localhost:11434"
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OPENAI)
+@patch("gitai.ai.litellm.completion")
+def test_non_ollama_omits_api_base(mock_completion, _):
+    mock_completion.return_value = make_response("1. feat: add thing")
+    get_commit_suggestions("prompt")
+    assert "api_base" not in mock_completion.call_args.kwargs
+
+@patch("gitai.ai.load_config", return_value={**FAKE_CONFIG_OLLAMA, "provider": "OLLAMA"})
+@patch("gitai.ai.litellm.completion")
+def test_provider_casing_is_normalized(mock_completion, _):
+    mock_completion.return_value = make_response("1. feat: add thing")
+    get_commit_suggestions("prompt")
+    assert mock_completion.call_args.kwargs["model"].startswith("ollama/")
+
+
+# --- error handling ---
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_ollama_connection_error_mentions_ollama_serve(mock_completion, _):
+    mock_completion.side_effect = APIConnectionError(
+        message="connection refused", llm_provider="ollama", model="llama3.2"
+    )
+    with pytest.raises(SystemExit, match="ollama serve"):
+        get_commit_suggestions("prompt")
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OLLAMA)
+@patch("gitai.ai.litellm.completion")
+def test_ollama_connection_error_mentions_url(mock_completion, _):
+    mock_completion.side_effect = APIConnectionError(
+        message="connection refused", llm_provider="ollama", model="llama3.2"
+    )
+    with pytest.raises(SystemExit, match="localhost:11434"):
+        get_commit_suggestions("prompt")
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_OPENAI)
+@patch("gitai.ai.litellm.completion")
+def test_openai_auth_error_suggests_api_key_var(mock_completion, _):
+    mock_completion.side_effect = AuthenticationError(
+        message="invalid key", llm_provider="openai", model="gpt-4o"
+    )
+    with pytest.raises(SystemExit, match="OPENAI_API_KEY"):
+        get_commit_suggestions("prompt")
+
+@patch("gitai.ai.load_config", return_value=FAKE_CONFIG_ANTHROPIC)
+@patch("gitai.ai.litellm.completion")
+def test_anthropic_auth_error_suggests_api_key_var(mock_completion, _):
+    mock_completion.side_effect = AuthenticationError(
+        message="invalid key", llm_provider="anthropic", model="claude-haiku-4-5-20251001"
+    )
+    with pytest.raises(SystemExit, match="ANTHROPIC_API_KEY"):
+        get_commit_suggestions("prompt")

gitai_cli-0.1.0/tests/test_config.py

@@ -0,0 +1,65 @@
+from unittest.mock import patch
+from gitai.config import load_config, save_config, DEFAULT_CONFIG
+
+
+# --- load_config ---
+
+def test_returns_defaults_when_no_file(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        config = load_config()
+    assert config == DEFAULT_CONFIG
+
+def test_creates_config_file_when_missing(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        load_config()
+    assert config_path.exists()
+
+def test_merges_partial_user_config_with_defaults(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    config_path.write_bytes(b'model = "gpt-4o"\n')
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        config = load_config()
+    assert config["model"] == "gpt-4o"
+    assert config["provider"] == DEFAULT_CONFIG["provider"]
+    assert config["ollama_url"] == DEFAULT_CONFIG["ollama_url"]
+
+def test_user_provider_overrides_default(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    config_path.write_bytes(b'provider = "anthropic"\n')
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        config = load_config()
+    assert config["provider"] == "anthropic"
+
+def test_user_emoji_true_overrides_default(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    config_path.write_bytes(b'emoji = true\n')
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        config = load_config()
+    assert config["emoji"] is True
+
+
+# --- save_config / roundtrip ---
+
+def test_save_and_load_roundtrip(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    custom = {**DEFAULT_CONFIG, "model": "mistral", "emoji": True}
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        save_config(custom)
+        loaded = load_config()
+    assert loaded["model"] == "mistral"
+    assert loaded["emoji"] is True
+
+def test_save_writes_all_default_keys(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        save_config(DEFAULT_CONFIG)
+        loaded = load_config()
+    assert set(loaded.keys()) == set(DEFAULT_CONFIG.keys())
+
+def test_save_creates_file(tmp_path):
+    config_path = tmp_path / ".gitai.toml"
+    with patch("gitai.config.CONFIG_PATH", config_path):
+        save_config(DEFAULT_CONFIG)
+    assert config_path.exists()

gitai_cli-0.1.0/tests/test_git.py

@@ -0,0 +1,81 @@
+from unittest.mock import patch, MagicMock
+from gitai.git import is_diff_meaningful, get_staged_diff, get_repo_name
+
+MEANINGFUL_DIFF = """\
+diff --git a/foo.py b/foo.py
+index abc..def 100644
+--- a/foo.py
++++ b/foo.py
+@@ -1,3 +1,4 @@
+ def foo():
++    return 42
+-    pass
+"""
+
+
+# --- is_diff_meaningful ---
+
+def test_meaningful_diff_returns_true():
+    assert is_diff_meaningful(MEANINGFUL_DIFF) is True
+
+def test_empty_string_returns_false():
+    assert is_diff_meaningful("") is False
+
+def test_only_header_lines_returns_false():
+    diff = "--- a/foo.py\n+++ b/foo.py\n"
+    assert is_diff_meaningful(diff) is False
+
+def test_blank_added_line_returns_false():
+    diff = "--- a/foo.py\n+++ b/foo.py\n+\n"
+    assert is_diff_meaningful(diff) is False
+
+def test_blank_removed_line_returns_false():
+    diff = "--- a/foo.py\n+++ b/foo.py\n-\n"
+    assert is_diff_meaningful(diff) is False
+
+def test_single_added_line_returns_true():
+    diff = "+def new_function(): pass"
+    assert is_diff_meaningful(diff) is True
+
+def test_single_removed_line_returns_true():
+    diff = "-old_code = True"
+    assert is_diff_meaningful(diff) is True
+
+def test_only_whitespace_change_returns_false():
+    diff = "+   \n-  \n"
+    assert is_diff_meaningful(diff) is False
+
+
+# --- get_staged_diff ---
+
+def test_get_staged_diff_returns_stdout():
+    with patch("gitai.git.subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(stdout="diff --git a/foo.py b/foo.py\n+change")
+        result = get_staged_diff()
+    assert result == "diff --git a/foo.py b/foo.py\n+change"
+
+def test_get_staged_diff_calls_correct_command():
+    with patch("gitai.git.subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(stdout="")
+        get_staged_diff()
+    mock_run.assert_called_once_with(
+        ["git", "diff", "--cached"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+    )
+
+def test_get_staged_diff_returns_empty_string_when_nothing_staged():
+    with patch("gitai.git.subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(stdout="")
+        result = get_staged_diff()
+    assert result == ""
+
+
+# --- get_repo_name ---
+
+def test_get_repo_name_returns_string():
+    assert isinstance(get_repo_name(), str)
+
+def test_get_repo_name_returns_non_empty():
+    assert len(get_repo_name()) > 0

gitai_cli-0.1.0/tests/test_prompt.py

@@ -0,0 +1,97 @@
+from gitai.prompt import build_commit_prompt, _build_format_rules, _build_example
+
+SAMPLE_DIFF = "diff --git a/foo.py b/foo.py\n+def bar(): pass"
+
+
+# --- _build_format_rules ---
+
+def test_conventional_no_emoji_has_type_format():
+    rules = _build_format_rules("conventional", False)
+    assert "type(scope): description" in rules
+    assert "feat, fix" in rules
+
+def test_conventional_no_emoji_has_no_gitmoji():
+    rules = _build_format_rules("conventional", False)
+    assert "✨" not in rules
+
+def test_conventional_with_emoji_includes_gitmoji_map():
+    rules = _build_format_rules("conventional", True)
+    assert "✨ feat" in rules
+    assert "🐛 fix" in rules
+    assert "♻️ refactor" in rules
+
+def test_freeform_no_emoji_omits_type_prefix():
+    rules = _build_format_rules("free-form", False)
+    assert "type(scope)" not in rules
+    assert "imperative mood" in rules.lower()
+
+def test_freeform_with_emoji_includes_emoji_instruction():
+    rules = _build_format_rules("free-form", True)
+    assert "emoji" in rules.lower()
+
+def test_freeform_with_emoji_omits_gitmoji_type_map():
+    # free-form emoji rule is generic, not a type→emoji map
+    rules = _build_format_rules("free-form", True)
+    assert "✨ feat" not in rules
+
+
+# --- _build_example ---
+
+def test_conventional_example_uses_type_scope_format():
+    example = _build_example("conventional", False)
+    assert "feat(" in example
+    assert "fix(" in example
+    assert "refactor(" in example
+
+def test_conventional_example_is_numbered():
+    example = _build_example("conventional", False)
+    assert example.startswith("1.")
+
+def test_conventional_emoji_example_has_gitmoji():
+    example = _build_example("conventional", True)
+    assert "✨" in example
+    assert "🐛" in example
+
+def test_freeform_example_has_no_type_scope():
+    example = _build_example("free-form", False)
+    assert "feat(" not in example
+    assert "fix(" not in example
+
+def test_freeform_emoji_example_has_emoji():
+    example = _build_example("free-form", True)
+    assert "✨" in example
+
+
+# --- build_commit_prompt ---
+
+def test_prompt_contains_diff():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo")
+    assert SAMPLE_DIFF in prompt
+
+def test_prompt_contains_repo_name():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo")
+    assert "myrepo" in prompt
+
+def test_prompt_conventional_by_default():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo")
+    assert "type(scope)" in prompt
+
+def test_prompt_freeform_style_omits_type_scope():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo", commit_style="free-form")
+    assert "type(scope)" not in prompt
+
+def test_prompt_emoji_enabled_includes_gitmoji():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo", emoji=True)
+    assert "✨" in prompt
+
+def test_prompt_emoji_disabled_by_default():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo")
+    assert "✨" not in prompt
+
+def test_prompt_requests_exactly_3_suggestions():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo")
+    assert "3" in prompt
+
+def test_prompt_instructs_no_extra_output():
+    prompt = build_commit_prompt(SAMPLE_DIFF, "myrepo")
+    assert "nothing else" in prompt