Git + IA : automatiser ses commits et reviews

# Voir les hooks disponibles
ls .git/hooks/

# Les hooks sont des scripts avec un nom précis
# pre-commit, pre-push, commit-msg, etc.

#!/bin/bash
# .git/hooks/prepare-commit-msg
# Génère un message de commit intelligent à partir du diff

COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2

# Ne pas modifier les merge commits ou les amend
if [ "$COMMIT_SOURCE" = "merge" ] || [ "$COMMIT_SOURCE" = "squash" ]; then
    exit 0
fi

# Récupérer le diff staged
DIFF=$(git diff --cached --stat)
DIFF_CONTENT=$(git diff --cached -- . ':!*.lock' ':!package-lock.json' | head -200)

if [ -z "$DIFF" ]; then
    exit 0
fi

# Générer le message avec l'IA (via API)
MESSAGE=$(curl -s https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"anthropic/claude-sonnet-4\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": \"Generate a concise git commit message (max 72 chars for title, optional body) for this diff. Use conventional commits format (feat/fix/docs/refactor/chore). Be specific. Respond with ONLY the commit message, nothing else.\n\nFiles changed:\n${DIFF}\n\nDiff:\n${DIFF_CONTENT}\"
    }],
    \"max_tokens\": 200
  }" | jq -r '.choices[0].message.content')

if [ -n "$MESSAGE" ] && [ "$MESSAGE" != "null" ]; then
    echo "$MESSAGE" > "$COMMIT_MSG_FILE"
fi

fix(auth): handle expired JWT tokens in middleware

- Add token expiry check before route handler
- Return 401 with clear error message
- Add unit test for expired token scenario

#!/bin/bash
# .git/hooks/pre-commit
# Vérifie le code avant de committer

set -e

echo "🔍 Pre-commit checks..."

# 1. Pas de secrets dans le code
echo "  Checking for secrets..."
if git diff --cached --diff-filter=ACM | grep -iE "(api_key|password|secret|token)\s*=\s*[\"'][^\"']+[\"']" | grep -v "example\|placeholder\|xxx\|your_"; then
    echo "❌ ERREUR: Possible secret détecté dans le code!"
    echo "   Utilisez des variables d'environnement (.env)"
    exit 1
fi

# 2. Pas de fichiers sensibles
SENSITIVE_FILES=(".env" "id_rsa" ".pem" "credentials.json")
for pattern in "${SENSITIVE_FILES[@]}"; do
    if git diff --cached --name-only | grep -q "$pattern"; then
        echo "❌ ERREUR: Fichier sensible détecté: $pattern"
        echo "   Ajoutez-le à .gitignore"
        exit 1
    fi
done

# 3. Pas de console.log / print de debug
if git diff --cached --diff-filter=ACM -- "*.py" | grep -E "^\+" | grep -q "print("; then
    echo "⚠️  WARNING: print() détecté. Debug oublié ?"
fi

if git diff --cached --diff-filter=ACM -- "*.js" "*.ts" | grep -E "^\+" | grep -q "console.log"; then
    echo "⚠️  WARNING: console.log détecté. Debug oublié ?"
fi

# 4. Fichiers trop gros
MAX_SIZE=1048576  # 1MB
for file in $(git diff --cached --name-only --diff-filter=ACM); do
    if [ -f "$file" ]; then
        SIZE=$(wc -c < "$file")
        if [ "$SIZE" -gt "$MAX_SIZE" ]; then
            echo "❌ ERREUR: $file fait $(($SIZE/1024))KB (max 1MB)"
            exit 1
        fi
    fi
done

echo "✅ Toutes les vérifications passées"

# Rendre les hooks exécutables
chmod +x .git/hooks/pre-commit
chmod +x .git/hooks/prepare-commit-msg

# Pour partager les hooks avec l'équipe
mkdir -p .githooks
cp .git/hooks/pre-commit .githooks/
cp .git/hooks/prepare-commit-msg .githooks/

# Configurer git pour utiliser le dossier partagé
git config core.hooksPath .githooks

#!/bin/bash
# /root/scripts/ai-code-review.sh
# Lance une review IA sur les derniers changements

BRANCH=${1:-$(git branch --show-current)}
BASE=${2:-main}

echo "🔍 AI Code Review: $BRANCH vs $BASE"
echo "=================================="

# Récupérer le diff
DIFF=$(git diff "$BASE"..."$BRANCH" -- . ':!*.lock' ':!*.min.*' ':!dist/' | head -500)

if [ -z "$DIFF" ]; then
    echo "Aucun changement à reviewer."
    exit 0
fi

# Fichiers modifiés
FILES=$(git diff --name-only "$BASE"..."$BRANCH")
echo "Fichiers modifiés :"
echo "$FILES"
echo ""

# Review via API
REVIEW=$(curl -s https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"anthropic/claude-sonnet-4\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": \"Review this code diff. Focus on:\n1. Bugs and logical errors\n2. Security issues\n3. Performance concerns\n4. Code quality\n\nBe specific. Reference line numbers. If the code looks good, say so briefly.\n\nFiles: ${FILES}\n\nDiff:\n${DIFF}\"
    }],
    \"max_tokens\": 1000
  }" | jq -r '.choices[0].message.content')

echo "$REVIEW"

# Option 1 : Hook pre-push
#!/bin/bash
# .git/hooks/pre-push
echo "🤖 Running AI code review before push..."
/root/scripts/ai-code-review.sh
echo ""
echo "Push will continue in 5 seconds. Ctrl+C to cancel."
sleep 5

# Option 2 : Alias git
git config --global alias.review '!/bin/bash /root/scripts/ai-code-review.sh'
# Utilisation : git review
# Ou : git review feature-branch main

# Dans Telegram, envoyez simplement :
Review le code dans /root/projects/mon-app, 
compare la branche feature/auth avec main

## 🤖 Git Auto-Commit

Après chaque session de travail sur un projet git :
1. `git status` pour voir les changements
2. Si des fichiers sont modifiés :
   a. Grouper les changements par logique (pas tout dans un seul commit)
   b. Pour chaque groupe : `git add` les fichiers concernés, puis `git commit` avec un message descriptif
   c. `git push` si on est sur une branche avec remote
3. Ne JAMAIS commit : .env, credentials, fichiers temporaires, node_modules

### Conventions de commit
- feat: nouvelle fonctionnalité
- fix: correction de bug
- docs: documentation
- refactor: restructuration sans changement fonctionnel
- chore: maintenance, dépendances
- test: ajout/modification de tests

#!/bin/bash
# /root/scripts/smart-commit.sh
# Commit intelligent : groupe les changements par type

cd "$1" || exit 1

# Vérifier qu'on est dans un repo git
if ! git rev-parse --is-inside-work-tree &>/dev/null; then
    echo "Pas un repo git"
    exit 1
fi

# Vérifier qu'il y a des changements
if git diff --quiet && git diff --cached --quiet; then
    echo "Rien à committer"
    exit 0
fi

# Séparer par type de fichier
DOCS=$(git diff --name-only | grep -E "\.(md|txt|rst|doc)$")
PYTHON=$(git diff --name-only | grep -E "\.py$")
JS=$(git diff --name-only | grep -E "\.(js|ts|jsx|tsx)$")
CONFIG=$(git diff --name-only | grep -E "\.(yml|yaml|json|toml|ini|cfg)$")
OTHER=$(git diff --name-only | grep -vE "\.(md|txt|rst|doc|py|js|ts|jsx|tsx|yml|yaml|json|toml|ini|cfg)$")

# Committer chaque groupe
commit_group() {
    local files="$1"
    local prefix="$2"

    if [ -n "$files" ]; then
        echo "$files" | xargs git add
        COUNT=$(echo "$files" | wc -l)
        git commit -m "${prefix}: update ${COUNT} file(s)"
    fi
}

commit_group "$DOCS" "docs"
commit_group "$PYTHON" "chore(python)"
commit_group "$JS" "chore(js)"
commit_group "$CONFIG" "chore(config)"
commit_group "$OTHER" "chore"

echo "✅ Smart commit terminé"
git log --oneline -5

# Exemple avec Claude Code
claude "Review the last 3 commits and suggest improvements"
claude "Create a feature branch for user authentication"
claude "Write unit tests for the auth module and commit them"

# Instruction pour l'agent OpenClaw
## 🛡️ Git Guardian

Toutes les heures, vérifie les repos dans /root/projects/ :
1. Pour chaque repo avec des changements non commités :
   - Review les changements
   - Commit avec un message approprié
   - Push si la branche a un remote
2. Pour chaque repo avec des PRs ouvertes :
   - Review le diff
   - Poster un commentaire si des problèmes sont trouvés

# 1. Créer une branche de refactoring
git checkout -b refactor/split-utils

# 2. Demander à l'agent (via OpenClaw ou Claude Code)
# "Refactore utils.py en modules séparés : 
#  string_utils.py, file_utils.py, date_utils.py. 
#  Mets à jour tous les imports dans le projet."

# 3. L'agent produit des commits séparés :
# commit 1: refactor: extract string_utils from utils.py
# commit 2: refactor: extract file_utils from utils.py  
# commit 3: refactor: extract date_utils from utils.py
# commit 4: refactor: update all imports across project
# commit 5: test: verify all modules after split

# 4. Vérifier le résultat
git log --oneline refactor/split-utils
# a1b2c3d test: verify all modules after split
# e4f5g6h refactor: update all imports across project
# i7j8k9l refactor: extract date_utils from utils.py
# m0n1o2p refactor: extract file_utils from utils.py
# q3r4s5t refactor: extract string_utils from utils.py

#!/usr/bin/env python3
"""Génère un changelog à partir des commits git, enrichi par l'IA."""

import subprocess
import json
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-..."
)

def get_commits_since(tag: str) -> list[dict]:
    """Récupère les commits depuis un tag donné."""
    result = subprocess.run(
        ["git", "log", f"{tag}..HEAD", "--pretty=format:%H|%s|%an|%ai"],
        capture_output=True, text=True
    )
    commits = []
    for line in result.stdout.strip().split("\n"):
        if line:
            parts = line.split("|", 3)
            commits.append({
                "hash": parts[0][:7],
                "message": parts[1],
                "author": parts[2],
                "date": parts[3][:10]
            })
    return commits

def generate_changelog(commits: list[dict], version: str) -> str:
    """Utilise l'IA pour générer un changelog lisible."""
    commit_list = "\n".join(
        f"- {c['hash']} {c['message']} ({c['author']})" for c in commits
    )

    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4",
        messages=[{
            "role": "user",
            "content": f"""Génère un changelog professionnel en Markdown 
pour la version {version}.

Commits :
{commit_list}

Organise par catégories :
## 🚀 Nouvelles fonctionnalités
## 🐛 Corrections de bugs
## 🔧 Améliorations
## 📚 Documentation
## 🏗️ Maintenance

Ignore les commits de merge. Rends les descriptions claires 
pour un utilisateur final (pas un développeur)."""
        }],
        max_tokens=1000
    )

    return response.choices[0].message.content

# Utilisation
commits = get_commits_since("v1.2.0")
changelog = generate_changelog(commits, "v1.3.0")

with open("CHANGELOG.md", "a") as f:
    f.write(f"\n\n{changelog}")

print(changelog)

#!/bin/bash
# generate-pr-description.sh
# Génère une description de PR à partir du diff avec main

BRANCH=$(git branch --show-current)
DIFF=$(git diff main..."$BRANCH" --stat)
DIFF_CONTENT=$(git diff main..."$BRANCH" -- . ':!*.lock' | head -300)
COMMITS=$(git log main..."$BRANCH" --pretty=format:"- %s" | head -20)

DESCRIPTION=$(curl -s https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"anthropic/claude-sonnet-4\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": \"Generate a GitHub PR description in Markdown.\n\nBranch: $BRANCH\n\nCommits:\n$COMMITS\n\nFiles changed:\n$DIFF\n\nDiff (partial):\n$DIFF_CONTENT\n\nInclude:\n## Summary\n## Changes\n## Testing\n## Screenshots (if applicable)\n\nBe concise and specific.\"
    }],
    \"max_tokens\": 800
  }" | jq -r '.choices[0].message.content')

echo "$DESCRIPTION"

# Copier dans le presse-papier (si xclip est installé)
echo "$DESCRIPTION" | xclip -selection clipboard 2>/dev/null && echo "📋 Copié dans le presse-papier !"

#!/usr/bin/env python3
"""Détecte les régressions potentielles dans un diff git."""

import subprocess
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-..."
)

def check_regressions(base: str = "main") -> dict:
    branch = subprocess.run(
        ["git", "branch", "--show-current"],
        capture_output=True, text=True
    ).stdout.strip()

    # Récupérer uniquement les fichiers modifiés (pas les ajouts)
    modified = subprocess.run(
        ["git", "diff", "--name-only", "--diff-filter=M", f"{base}...{branch}"],
        capture_output=True, text=True
    ).stdout.strip()

    if not modified:
        return {"regressions": [], "risk": "none"}

    diff = subprocess.run(
        ["git", "diff", f"{base}...{branch}", "--", *modified.split("\n")],
        capture_output=True, text=True
    ).stdout[:3000]

    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4",
        messages=[{
            "role": "user",
            "content": f"""Analyse ce diff git et identifie les régressions potentielles.

Fichiers modifiés : {modified}

Diff :
{diff}

Retourne un JSON :
{{
  "regressions": [
    {{
      "file": "nom_du_fichier",
      "line": "numéro approximatif",
      "description": "description du risque",
      "severity": "low|medium|high"
    }}
  ],
  "risk": "none|low|medium|high",
  "summary": "résumé en 1 phrase"
}}

Cherche : suppressions de validations, catch trop larges,
timeouts supprimés, logs retirés, conditions inversées, etc."""
        }],
        max_tokens=800
    )

    import json
    return json.loads(response.choices[0].message.content)

result = check_regressions()
if result["risk"] in ["medium", "high"]:
    print(f"⚠️ Risque de régression : {result['summary']}")
    for r in result["regressions"]:
        print(f"  [{r['severity']}] {r['file']}:{r['line']} — {r['description']}")
else:
    print("✅ Aucune régression détectée")

# .gitignore essentiel
.env
.env.local
.env.production
*.pem
*.key
id_rsa*
credentials.json
service-account.json

# Vérifier l'historique pour des secrets déjà commités
git log --all --full-history -p | grep -iE "(api_key|password|secret)" | head -20

# Si un secret a été commité, il est dans l'historique POUR TOUJOURS
# Solution : git-filter-repo (ne pas utiliser filter-branch)
pip install git-filter-repo
git filter-repo --path-glob '*.env' --invert-paths

# .gitleaks.toml - Configuration de détection de secrets
title = "Gitleaks config"

[[rules]]
id = "generic-api-key"
description = "Generic API Key"
regex = '''(?i)(api_key|apikey|api-key)\s*[=:]\s*["']\S{20,}["']\s*'''
tags = ["key", "API"]

[[rules]]
id = "generic-secret"
description = "Generic Secret"
regex = '''(?i)(secret|password|passwd|pwd)\s*[=:]\s*["']\S{8,}["']\s*'''
tags = ["secret"]

[allowlist]
description = "Allowlisted files"
paths = [
    '''(.*?)(test|spec|example)(.*?)''',
    '''\.md$'''
]

1. Vous codez normalement
    ↓
2. Pre-commit hook vérifie :
   - Pas de secrets ✓
   - Pas de fichiers interdits ✓
   - Pas de debug oublié ✓
    ↓
3. IA génère le message de commit
   "fix(auth): handle token expiry in middleware"
    ↓
4. Vous validez (ou modifiez) le message
    ↓
5. Pre-push hook lance une review IA
   "⚠️ Possible SQL injection line 42"
    ↓
6. Vous corrigez si nécessaire
    ↓
7. Push ✅
    ↓
8. OpenClaw vérifie périodiquement
   qu'il n'y a pas de travail non commité

# 1. Créer le dossier de hooks partagés
mkdir -p ~/.git-hooks

# 2. Copier les hooks (depuis ce guide)
# pre-commit, prepare-commit-msg, pre-push

# 3. Configurer git globalement
git config --global core.hooksPath ~/.git-hooks

# 4. Installer les outils
pip install gitleaks  # Détection de secrets

# 5. Définir la clé API (pour les messages IA)
echo 'export OPENROUTER_API_KEY="votre_clé"' >> ~/.bashrc
source ~/.bashrc