commit_gen.py

#!/usr/bin/env python3
"""
Git Commit Message Generator
Analyzes staged changes and suggests conventional commit messages.
"""

import subprocess
import sys
import re
from pathlib import Path
from typing import Tuple, List, Dict


def run_git_command(args: List[str]) -> str:
    """Run a git command and return output."""
    try:
        result = subprocess.run(
            ['git'] + args,
            capture_output=True,
            text=True,
            check=True
        )
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        print(f"Error running git command: {e}", file=sys.stderr)
        sys.exit(1)


def get_staged_files() -> Dict[str, List[str]]:
    """Get lists of staged files by change type."""
    output = run_git_command(['diff', '--cached', '--name-status'])
    
    if not output:
        print("No staged changes found. Stage some changes with 'git add' first.")
        sys.exit(0)
    
    changes = {
        'added': [],
        'modified': [],
        'deleted': [],
        'renamed': []
    }
    
    for line in output.split('\n'):
        if not line:
            continue
        parts = line.split('\t')
        status = parts[0]
        filename = parts[1] if len(parts) > 1 else ''
        
        if status.startswith('A'):
            changes['added'].append(filename)
        elif status.startswith('M'):
            changes['modified'].append(filename)
        elif status.startswith('D'):
            changes['deleted'].append(filename)
        elif status.startswith('R'):
            changes['renamed'].append(filename)
    
    return changes


def detect_commit_type(changes: Dict[str, List[str]]) -> str:
    """Detect the appropriate commit type based on changes."""
    all_files = (changes['added'] + changes['modified'] + 
                 changes['deleted'] + changes['renamed'])
    
    # Check for documentation changes
    doc_patterns = ['.md', '.txt', '.rst', 'docs/', 'README']
    if any(any(pattern in f for pattern in doc_patterns) for f in all_files):
        if all(any(pattern in f for pattern in doc_patterns) for f in all_files):
            return 'docs'
    
    # Check for test files
    test_patterns = ['test_', '_test.', 'tests/', 'spec/', '.test.', '.spec.']
    if any(any(pattern in f for pattern in test_patterns) for f in all_files):
        if all(any(pattern in f for pattern in test_patterns) for f in all_files):
            return 'test'
    
    # Check for config/build files
    config_patterns = ['.json', '.yaml', '.yml', '.toml', '.ini', 
                      'Makefile', 'Dockerfile', '.config', 'package.json',
                      'requirements.txt', 'setup.py', 'pyproject.toml']
    if any(any(pattern in f for pattern in config_patterns) for f in all_files):
        if len(changes['added']) == 0 and len(changes['deleted']) == 0:
            return 'chore'
    
    # Check for style-only changes (css, formatting)
    style_patterns = ['.css', '.scss', '.sass', '.less', '.style']
    if any(any(pattern in f for pattern in style_patterns) for f in all_files):
        return 'style'
    
    # New files suggest a feature
    if len(changes['added']) > 0:
        return 'feat'
    
    # Deletions might be refactoring or chore
    if len(changes['deleted']) > 0 and len(changes['modified']) > 0:
        return 'refactor'
    
    # Default to fix for modifications
    if len(changes['modified']) > 0:
        return 'fix'
    
    return 'chore'


def detect_scope(changes: Dict[str, List[str]]) -> str:
    """Detect the scope based on file paths."""
    all_files = (changes['added'] + changes['modified'] + 
                 changes['deleted'] + changes['renamed'])
    
    if not all_files:
        return ''
    
    # Extract common directory or component
    paths = [Path(f) for f in all_files]
    
    # Get first-level directories
    dirs = set()
    for p in paths:
        if len(p.parts) > 1:
            dirs.add(p.parts[0])
    
    # If all changes in one directory, use it as scope
    if len(dirs) == 1:
        scope = list(dirs)[0]
        # Clean up common directory names
        if scope in ['src', 'lib', 'app']:
            if len(paths[0].parts) > 1:
                scope = paths[0].parts[1]
        return scope
    
    # Check for common patterns
    if any('auth' in f.lower() for f in all_files):
        return 'auth'
    if any('api' in f.lower() for f in all_files):
        return 'api'
    if any('ui' in f.lower() or 'component' in f.lower() for f in all_files):
        return 'ui'
    if any('db' in f.lower() or 'database' in f.lower() for f in all_files):
        return 'db'
    
    return ''


def generate_description(changes: Dict[str, List[str]], commit_type: str) -> str:
    """Generate a commit message description."""
    added = len(changes['added'])
    modified = len(changes['modified'])
    deleted = len(changes['deleted'])
    
    # Get primary file for context
    primary_file = ''
    if changes['added']:
        primary_file = Path(changes['added'][0]).stem
    elif changes['modified']:
        primary_file = Path(changes['modified'][0]).stem
    
    descriptions = {
        'feat': f"add {primary_file} functionality" if primary_file else "add new feature",
        'fix': f"resolve issue in {primary_file}" if primary_file else "fix bug",
        'docs': "update documentation",
        'style': "improve code formatting",
        'refactor': f"restructure {primary_file}" if primary_file else "refactor code",
        'test': "add test coverage",
        'chore': "update dependencies" if any('requirements' in f or 'package.json' in f 
                                              for f in changes['modified']) else "update configuration",
        'perf': "optimize performance"
    }
    
    return descriptions.get(commit_type, "update code")


def main():
    """Main entry point."""
    print("🔍 Analyzing staged changes...\n")
    
    # Check if we're in a git repository
    try:
        run_git_command(['rev-parse', '--git-dir'])
    except SystemExit:
        print("Error: Not a git repository")
        sys.exit(1)
    
    # Get staged changes
    changes = get_staged_files()
    
    # Detect commit type and scope
    commit_type = detect_commit_type(changes)
    scope = detect_scope(changes)
    description = generate_description(changes, commit_type)
    
    # Build commit message
    if scope:
        commit_msg = f"{commit_type}({scope}): {description}"
    else:
        commit_msg = f"{commit_type}: {description}"
    
    # Display results
    print("📝 Suggested commit message:")
    print(f"\n  {commit_msg}\n")
    
    print("Changes detected:")
    if changes['added']:
        for f in changes['added']:
            print(f"  + Added: {f}")
    if changes['modified']:
        for f in changes['modified']:
            print(f"  ~ Modified: {f}")
    if changes['deleted']:
        for f in changes['deleted']:
            print(f"  - Deleted: {f}")
    if changes['renamed']:
        for f in changes['renamed']:
            print(f"  → Renamed: {f}")
    
    print("\n💡 To use this message:")
    print(f'  git commit -m "{commit_msg}"')


if __name__ == '__main__':
    main()