git-aicommit-message 0.1.0__tar.gz

git_aicommit_message-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: git-aicommit-message
+Version: 0.1.0
+Summary: AI-powered git commit message generator using Ollama
+Author: TRAORE Timothée Rachid
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+
+# git-ai-commit
+
+> Generate smart commit messages using AI — powered by Ollama (local, private).
+
+## Prerequisites
+
+- Python 3.8+
+- Ollama installed and running
+
+## Install everything in one command
+```bash
+curl -fsSL https://raw.githubusercontent.com/rachid-traore/git-ai-commit/main/install.sh | sh
+```
+
+This script will automatically install Ollama, pull the `mistral` model, and install `git-ai-commit`.
+
+## Manual installation
+
+**1. Install Ollama**
+
+| OS | Command |
+|---|---|
+| Mac | `brew install ollama` |
+| Linux | `curl -fsSL https://ollama.com/install.sh \| sh` |
+| Windows | [ollama.com/download](https://ollama.com/download) |
+
+**2. Start Ollama and pull the model**
+```bash
+ollama serve &
+ollama pull mistral
+```
+
+**3. Install git-ai-commit**
+```bash
+pip install git-ai-commit
+```
+
+## Usage
+```bash
+# Stage your changes
+git add .
+
+# Generate and commit
+git ai-commit
+
+# Open message in $EDITOR before committing
+git ai-commit --edit
+```
+
+## Example output
+```
+🤖 Analyse du diff en cours...
+→ feat: add user authentication via JWT
+
+[Y] Valider  [e] Éditer  [n] Annuler :
+```
+
+## How it works
+
+1. Reads your staged diff (`git diff --cached`)
+2. Detects commit type instantly via heuristics (`feat`, `fix`, `chore`...)
+3. Sends diff to local Ollama (`mistral` model)
+4. Proposes a [Conventional Commits](https://www.conventionalcommits.org) message
+5. You validate, edit, or cancel
+
+## Privacy
+
+Your code never leaves your machine. Ollama runs 100% locally.
+
+## License
+
+MIT

git_aicommit_message-0.1.0/README.md

@@ -0,0 +1,72 @@
+# git-ai-commit
+
+> Generate smart commit messages using AI — powered by Ollama (local, private).
+
+## Prerequisites
+
+- Python 3.8+
+- Ollama installed and running
+
+## Install everything in one command
+```bash
+curl -fsSL https://raw.githubusercontent.com/rachid-traore/git-ai-commit/main/install.sh | sh
+```
+
+This script will automatically install Ollama, pull the `mistral` model, and install `git-ai-commit`.
+
+## Manual installation
+
+**1. Install Ollama**
+
+| OS | Command |
+|---|---|
+| Mac | `brew install ollama` |
+| Linux | `curl -fsSL https://ollama.com/install.sh \| sh` |
+| Windows | [ollama.com/download](https://ollama.com/download) |
+
+**2. Start Ollama and pull the model**
+```bash
+ollama serve &
+ollama pull mistral
+```
+
+**3. Install git-ai-commit**
+```bash
+pip install git-ai-commit
+```
+
+## Usage
+```bash
+# Stage your changes
+git add .
+
+# Generate and commit
+git ai-commit
+
+# Open message in $EDITOR before committing
+git ai-commit --edit
+```
+
+## Example output
+```
+🤖 Analyse du diff en cours...
+→ feat: add user authentication via JWT
+
+[Y] Valider  [e] Éditer  [n] Annuler :
+```
+
+## How it works
+
+1. Reads your staged diff (`git diff --cached`)
+2. Detects commit type instantly via heuristics (`feat`, `fix`, `chore`...)
+3. Sends diff to local Ollama (`mistral` model)
+4. Proposes a [Conventional Commits](https://www.conventionalcommits.org) message
+5. You validate, edit, or cancel
+
+## Privacy
+
+Your code never leaves your machine. Ollama runs 100% locally.
+
+## License
+
+MIT

git_aicommit_message-0.1.0/git_aicommit_message.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: git-aicommit-message
+Version: 0.1.0
+Summary: AI-powered git commit message generator using Ollama
+Author: TRAORE Timothée Rachid
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+
+# git-ai-commit
+
+> Generate smart commit messages using AI — powered by Ollama (local, private).
+
+## Prerequisites
+
+- Python 3.8+
+- Ollama installed and running
+
+## Install everything in one command
+```bash
+curl -fsSL https://raw.githubusercontent.com/rachid-traore/git-ai-commit/main/install.sh | sh
+```
+
+This script will automatically install Ollama, pull the `mistral` model, and install `git-ai-commit`.
+
+## Manual installation
+
+**1. Install Ollama**
+
+| OS | Command |
+|---|---|
+| Mac | `brew install ollama` |
+| Linux | `curl -fsSL https://ollama.com/install.sh \| sh` |
+| Windows | [ollama.com/download](https://ollama.com/download) |
+
+**2. Start Ollama and pull the model**
+```bash
+ollama serve &
+ollama pull mistral
+```
+
+**3. Install git-ai-commit**
+```bash
+pip install git-ai-commit
+```
+
+## Usage
+```bash
+# Stage your changes
+git add .
+
+# Generate and commit
+git ai-commit
+
+# Open message in $EDITOR before committing
+git ai-commit --edit
+```
+
+## Example output
+```
+🤖 Analyse du diff en cours...
+→ feat: add user authentication via JWT
+
+[Y] Valider  [e] Éditer  [n] Annuler :
+```
+
+## How it works
+
+1. Reads your staged diff (`git diff --cached`)
+2. Detects commit type instantly via heuristics (`feat`, `fix`, `chore`...)
+3. Sends diff to local Ollama (`mistral` model)
+4. Proposes a [Conventional Commits](https://www.conventionalcommits.org) message
+5. You validate, edit, or cancel
+
+## Privacy
+
+Your code never leaves your machine. Ollama runs 100% locally.
+
+## License
+
+MIT

git_aicommit_message-0.1.0/git_aicommit_message.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+git_aicommit_message.egg-info/PKG-INFO
+git_aicommit_message.egg-info/SOURCES.txt
+git_aicommit_message.egg-info/dependency_links.txt
+git_aicommit_message.egg-info/entry_points.txt
+git_aicommit_message.egg-info/requires.txt
+git_aicommit_message.egg-info/top_level.txt
+src/__init__.py
+src/editor.py
+src/git.py
+src/heuristic.py
+src/main.py
+src/ollama.py

git_aicommit_message-0.1.0/git_aicommit_message.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

git_aicommit_message-0.1.0/git_aicommit_message.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git-aicommit-message = src.main:main

git_aicommit_message-0.1.0/git_aicommit_message.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

git_aicommit_message-0.1.0/git_aicommit_message.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

git_aicommit_message-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "git-aicommit-message"
+version = "0.1.0"
+description = "AI-powered git commit message generator using Ollama"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+  {name = "TRAORE Timothée Rachid"}
+]
+dependencies = [
+  "requests>=2.28.0",
+]
+
+[project.scripts]
+git-aicommit-message = "src.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]

git_aicommit_message-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

git_aicommit_message-0.1.0/src/editor.py

@@ -0,0 +1,40 @@
+import os
+import subprocess
+import tempfile
+import sys
+
+def open_in_editor(message: str) -> str:
+    """
+    Ouvre le message dans $EDITOR pour que l'utilisateur puisse le modifier.
+    Retourne le message modifié.
+    """
+    editor = os.environ.get("EDITOR", _default_editor())
+    # Écrit le message dans un fichier temporaire
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".txt", delete=False, prefix="git_ai_commit_"
+    ) as f:
+        f.write(message)
+        f.write("\n\n# Modifie le message ci-dessus puis sauvegarde et ferme l'éditeur.")
+        f.write("\n# Les lignes commençant par # sont ignorées.")
+        tmp_path = f.name
+    try:
+        subprocess.call([editor, tmp_path])
+        with open(tmp_path, "r") as f:
+            lines = f.readlines()
+        # Ignore les commentaires et lignes vides
+        edited = "".join(
+            line for line in lines
+            if not line.startswith("#")
+        ).strip()
+        if not edited:
+            print("❌ Message vide, commit annulé.")
+            sys.exit(0)
+        return edited
+    finally:
+        os.unlink(tmp_path)
+
+def _default_editor():
+    """Retourne un éditeur par défaut selon l'OS."""
+    if os.name == "nt":  # Windows
+        return "notepad"
+    return "nano"        # Mac / Linux

git_aicommit_message-0.1.0/src/git.py

@@ -0,0 +1,44 @@
+import subprocess
+import sys
+
+def check_git_repo():
+    """Vérifie qu'on est bien dans un repo git."""
+    result = subprocess.run(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        print("❌ Tu n'es pas dans un repo git.")
+        sys.exit(1)
+
+def get_staged_diff():
+    """Récupère le diff des fichiers stagés."""
+    result = subprocess.run(
+        ["git", "diff", "--cached"],
+        capture_output=True, text=True
+    )
+    diff = result.stdout.strip()
+    if not diff:
+        print("❌ Aucun fichier stagé. Fais d'abord un `git add`.")
+        sys.exit(1)
+    return diff
+
+def get_staged_files():
+    """Retourne la liste des fichiers stagés."""
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--name-only"],
+        capture_output=True, text=True
+    )
+    return result.stdout.strip().splitlines()
+
+def do_commit(message):
+    """Exécute le commit avec le message donné."""
+    result = subprocess.run(
+        ["git", "commit", "-m", message],
+        capture_output=True, text=True
+    )
+    if result.returncode == 0:
+        print(f"✅ Commit effectué :\n   {message}")
+    else:
+        print(f"❌ Erreur lors du commit :\n{result.stderr}")
+        sys.exit(1)

git_aicommit_message-0.1.0/src/heuristic.py

@@ -0,0 +1,27 @@
+import os
+from typing import List
+
+# Règles : si un fichier matche → on suggère ce type
+RULES = [
+    (["test_", "_test.", ".spec.", ".test."], "test"),
+    (["package.json", "requirements.txt", "pyproject.toml",
+      "Makefile", "Dockerfile", ".github/", ".gitignore",
+      "setup.cfg", "setup.py"], "chore"),
+    (["README", ".md", "docs/", "CHANGELOG"], "docs"),
+    (["fix", "bug", "hotfix", "patch"], "fix"),
+    (["refactor", "clean", "rename", "move"], "refactor"),
+]
+
+def detect_type(staged_files: List[str]) -> str:
+    """
+    Analyse les noms de fichiers stagés et devine le type Conventional Commit.
+    Retourne 'feat' par défaut si rien ne matche.
+    """
+    for file in staged_files:
+        filename = os.path.basename(file).lower()
+        filepath = file.lower()
+        for patterns, commit_type in RULES:
+            for pattern in patterns:
+                if pattern.lower() in filename or pattern.lower() in filepath:
+                    return commit_type
+    return "feat"  # fallback par défaut

git_aicommit_message-0.1.0/src/main.py

@@ -0,0 +1,64 @@
+import sys
+import argparse
+from src.git import check_git_repo, get_staged_diff, get_staged_files, do_commit
+from src.heuristic import detect_type
+from src.ollama import generate_message
+from src.editor import open_in_editor
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="🤖 Génère un message de commit via Ollama"
+    )
+    parser.add_argument(
+        "--edit", "-e",
+        action="store_true",
+        help="Ouvre le message dans $EDITOR avant de committer"
+    )
+    args = parser.parse_args()
+
+    # 1. Vérifications de base
+    check_git_repo()
+
+    # 2. Récupère les infos git
+    diff = get_staged_diff()
+    staged_files = get_staged_files()
+
+    # 3. Heuristique immédiate (pendant qu'Ollama réfléchit)
+    fallback_type = detect_type(staged_files)
+
+    # 4. Génère le message via Ollama
+    print("🤖 Analyse du diff en cours...")
+    message = generate_message(diff, fallback_type)
+
+    # 5. Si Ollama a échoué → on construit un message minimal avec l'heuristique
+    if not message:
+        staged_names = ", ".join(staged_files[:3])
+        message = f"{fallback_type}: update {staged_names}"
+        print(f"   Message de fallback : {message}")
+
+    # 6. Mode --edit : ouvre dans $EDITOR
+    if args.edit:
+        message = open_in_editor(message)
+
+    # 7. Affiche la proposition
+    print(f"\n→ {message}\n")
+
+    # 8. Demande confirmation
+    try:
+        choice = input("[Y] Valider  [e] Éditer  [n] Annuler : ").strip().lower()
+    except KeyboardInterrupt:
+        print("\n❌ Annulé.")
+        sys.exit(0)
+
+    if choice in ("", "y"):
+        do_commit(message)
+    elif choice == "e":
+        message = open_in_editor(message)
+        print(f"\n→ {message}\n")
+        confirm = input("Valider ce message ? [Y/n] : ").strip().lower()
+        if confirm in ("", "y"):
+            do_commit(message)
+        else:
+            print("❌ Commit annulé.")
+    else:
+        print("❌ Commit annulé.")

git_aicommit_message-0.1.0/src/ollama.py

@@ -0,0 +1,81 @@
+import requests
+import sys
+
+OLLAMA_URL = "http://localhost:11434/api/generate"
+MODEL = "mistral"
+MAX_DIFF_CHARS = 4000  # ~1000 tokens, suffisant pour un diff normal
+
+PROMPT_TEMPLATE = """You are a git commit message assistant.
+Analyze the following git diff and write a commit message.
+
+Rules:
+- Use Conventional Commits format: type: short description
+- Types allowed: feat, fix, chore, docs, refactor, test, style
+- Title only, NO body, NO bullet points
+- Maximum 72 characters total
+- Always write in English
+- Be specific and concise
+
+Git diff:
+{diff}
+
+Respond with ONLY the commit message, nothing else."""
+
+def check_ollama():
+    """Vérifie qu'Ollama est accessible."""
+    try:
+        response = requests.get("http://localhost:11434", timeout=3)
+        return True
+    except requests.exceptions.ConnectionError:
+        print("❌ Ollama n'est pas détecté sur cette machine.")
+        print("")
+        print("   Installe-le :")
+        print("   → Mac   : brew install ollama")
+        print("   → Linux : curl -fsSL https://ollama.com/install.sh | sh")
+        print("   → Win   : https://ollama.com/download")
+        print("")
+        print("   Puis lance :")
+        print("   → ollama serve   (démarre le serveur)")
+        print("   → ollama pull mistral   (télécharge le modèle)")
+        sys.exit(1)
+
+def truncate_diff(diff: str) -> str:
+    """Tronque le diff si trop long, en gardant le début."""
+    if len(diff) <= MAX_DIFF_CHARS:
+        return diff
+    truncated = diff[:MAX_DIFF_CHARS]
+    return truncated + "\n\n[... diff tronqué pour respecter la fenêtre de contexte ...]"
+
+def generate_message(diff: str, fallback_type: str) -> str:
+    """Envoie le diff à Ollama et retourne le message généré."""
+    check_ollama()
+    diff = truncate_diff(diff)
+    prompt = PROMPT_TEMPLATE.format(diff=diff)
+    try:
+        response = requests.post(
+            OLLAMA_URL,
+            json={"model": MODEL, "prompt": prompt, "stream": False},
+            timeout=30
+        )
+        response.raise_for_status()
+        message = response.json().get("response", "").strip()
+        # Nettoyage : enlève les guillemets si l'IA en met
+        message = message.strip('"').strip("'")
+        # Vérifie que le message a un type Conventional Commit
+        # Sinon on préfixe avec le fallback heuristique
+        known_types = ["feat", "fix", "chore", "docs", "refactor", "test", "style"]
+        has_type = any(message.startswith(f"{t}:") or
+                      message.startswith(f"{t}(") for t in known_types)
+        if not has_type:
+            message = f"{fallback_type}: {message}"
+        # Tronque si > 72 caractères
+        if len(message) > 72:
+            message = message[:72]
+        return message
+    except requests.exceptions.Timeout:
+        print("⚠️  Ollama a mis trop de temps à répondre.")
+        print(f"   Utilisation de l'heuristique : type détecté = '{fallback_type}'")
+        return None
+    except Exception as e:
+        print(f"❌ Erreur Ollama : {e}")
+        return None