commit-gen.py

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

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


class CommitAnalyzer:
    """Analyzes git diff and generates commit messages."""
    
    COMMIT_TYPES = {
        'feat': 'New features',
        'fix': 'Bug fixes',
        'docs': 'Documentation changes',
        'style': 'Code style changes',
        'refactor': 'Code refactoring',
        'test': 'Test changes',
        'chore': 'Maintenance tasks',
        'perf': 'Performance improvements',
        'ci': 'CI/CD changes',
        'build': 'Build system changes'
    }
    
    def __init__(self):
        self.staged_files = []
        self.diff_stats = {}
        
    def check_git_repo(self) -> bool:
        """Check if we're in a git repository."""
        try:
            subprocess.run(
                ['git', 'rev-parse', '--git-dir'],
                capture_output=True,
                check=True,
                text=True
            )
            return True
        except subprocess.CalledProcessError:
            return False
    
    def get_staged_changes(self) -> bool:
        """Get list of staged files and their stats."""
        try:
            # Get staged files
            result = subprocess.run(
                ['git', 'diff', '--staged', '--name-status'],
                capture_output=True,
                check=True,
                text=True
            )
            
            if not result.stdout.strip():
                return False
            
            for line in result.stdout.strip().split('\n'):
                parts = line.split('\t')
                if len(parts) >= 2:
                    status = parts[0]
                    filepath = parts[1]
                    self.staged_files.append((status, filepath))
            
            # Get diff stats
            result = subprocess.run(
                ['git', 'diff', '--staged', '--stat'],
                capture_output=True,
                check=True,
                text=True
            )
            self.diff_stats['summary'] = result.stdout
            
            return True
            
        except subprocess.CalledProcessError:
            return False
    
    def detect_commit_type(self) -> str:
        """Detect the most appropriate commit type."""
        new_files = sum(1 for s, _ in self.staged_files if s == 'A')
        modified_files = sum(1 for s, _ in self.staged_files if s == 'M')
        deleted_files = sum(1 for s, _ in self.staged_files if s == 'D')
        
        # Check file patterns
        files = [f for _, f in self.staged_files]
        
        # Documentation
        if all(self._is_doc_file(f) for f in files):
            return 'docs'
        
        # Tests
        if all(self._is_test_file(f) for f in files):
            return 'test'
        
        # CI/CD
        if any(self._is_ci_file(f) for f in files):
            return 'ci'
        
        # Build files
        if any(self._is_build_file(f) for f in files):
            return 'build'
        
        # Config/chore files
        if any(self._is_config_file(f) for f in files):
            return 'chore'
        
        # New features (new files or significant additions)
        if new_files > 0 and new_files >= modified_files:
            return 'feat'
        
        # Bug fixes (look for fix-related keywords in filenames)
        if any('fix' in f.lower() or 'bug' in f.lower() for f in files):
            return 'fix'
        
        # Default to feat for new files, fix for modifications
        if new_files > 0:
            return 'feat'
        elif modified_files > 0:
            return 'fix'
        
        return 'chore'
    
    def detect_scope(self) -> Optional[str]:
        """Detect scope from file paths."""
        files = [f for _, f in self.staged_files]
        
        # Common scope patterns
        common_dirs = {}
        for filepath in files:
            parts = Path(filepath).parts
            if len(parts) > 1:
                # Use first directory as scope
                scope = parts[0]
                common_dirs[scope] = common_dirs.get(scope, 0) + 1
        
        if common_dirs:
            # Return most common directory
            return max(common_dirs, key=common_dirs.get)
        
        return None
    
    def generate_description(self) -> List[str]:
        """Generate bullet points describing changes."""
        descriptions = []
        
        for status, filepath in self.staged_files[:5]:  # Limit to 5 files
            filename = Path(filepath).name
            
            if status == 'A':
                descriptions.append(f"Add {filepath}")
            elif status == 'M':
                descriptions.append(f"Update {filepath}")
            elif status == 'D':
                descriptions.append(f"Remove {filepath}")
            elif status.startswith('R'):
                descriptions.append(f"Rename {filepath}")
        
        if len(self.staged_files) > 5:
            descriptions.append(f"... and {len(self.staged_files) - 5} more files")
        
        return descriptions
    
    def generate_commit_message(self) -> Tuple[str, List[str]]:
        """Generate the full commit message."""
        commit_type = self.detect_commit_type()
        scope = self.detect_scope()
        descriptions = self.generate_description()
        
        # Build subject line
        if scope:
            subject = f"{commit_type}({scope}): "
        else:
            subject = f"{commit_type}: "
        
        # Generate subject description
        if commit_type == 'feat':
            subject += "add new functionality"
        elif commit_type == 'fix':
            subject += "resolve issues"
        elif commit_type == 'docs':
            subject += "update documentation"
        elif commit_type == 'test':
            subject += "add/update tests"
        elif commit_type == 'chore':
            subject += "update configuration"
        else:
            subject += "improve codebase"
        
        return subject, descriptions
    
    @staticmethod
    def _is_doc_file(filepath: str) -> bool:
        """Check if file is documentation."""
        doc_patterns = ['.md', '.txt', '.rst', 'README', 'CHANGELOG', 'LICENSE', 'docs/']
        return any(pattern in filepath for pattern in doc_patterns)
    
    @staticmethod
    def _is_test_file(filepath: str) -> bool:
        """Check if file is a test."""
        test_patterns = ['test_', '_test.', 'tests/', 'spec/', '__tests__/']
        return any(pattern in filepath for pattern in test_patterns)
    
    @staticmethod
    def _is_ci_file(filepath: str) -> bool:
        """Check if file is CI/CD related."""
        ci_patterns = ['.github/', '.gitlab-ci', 'Jenkinsfile', '.circleci/', '.travis.yml']
        return any(pattern in filepath for pattern in ci_patterns)
    
    @staticmethod
    def _is_build_file(filepath: str) -> bool:
        """Check if file is build-related."""
        build_patterns = ['package.json', 'Cargo.toml', 'setup.py', 'pom.xml', 'build.gradle', 'Makefile']
        return any(pattern in filepath for pattern in build_patterns)
    
    @staticmethod
    def _is_config_file(filepath: str) -> bool:
        """Check if file is configuration."""
        config_patterns = ['.env', 'config.', '.yml', '.yaml', '.toml', '.ini', '.conf']
        return any(pattern in filepath for pattern in config_patterns)


def print_commit_message(subject: str, descriptions: List[str]):
    """Pretty print the commit message."""
    print("\nSuggested commit message:")
    print("━" * 80)
    print(subject)
    print()
    for desc in descriptions:
        print(f"- {desc}")
    print("━" * 80)


def main():
    """Main entry point."""
    analyzer = CommitAnalyzer()
    
    # Check if in git repo
    if not analyzer.check_git_repo():
        print("❌ Error: Not in a git repository", file=sys.stderr)
        sys.exit(1)
    
    # Get staged changes
    print("Analyzing staged changes...")
    if not analyzer.get_staged_changes():
        print("❌ No staged changes found. Use 'git add' to stage files first.", file=sys.stderr)
        sys.exit(1)
    
    # Generate commit message
    subject, descriptions = analyzer.generate_commit_message()
    
    # Display the message
    print_commit_message(subject, descriptions)
    
    # Ask for confirmation
    print("\nUse this message? [Y/n/e(dit)]:", end=" ")
    try:
        response = input().strip().lower()
    except (EOFError, KeyboardInterrupt):
        print("\n\nAborted.")
        sys.exit(0)
    
    if response in ['', 'y', 'yes']:
        # Commit with the generated message
        full_message = subject + "\n\n" + "\n".join(f"- {d}" for d in descriptions)
        try:
            subprocess.run(
                ['git', 'commit', '-m', full_message],
                check=True
            )
            print("✅ Committed successfully!")
        except subprocess.CalledProcessError:
            print("❌ Commit failed", file=sys.stderr)
            sys.exit(1)
    elif response in ['e', 'edit']:
        print("\nOpening editor...")
        full_message = subject + "\n\n" + "\n".join(f"- {d}" for d in descriptions)
        try:
            subprocess.run(['git', 'commit', '-e', '-m', full_message], check=True)
            print("✅ Committed successfully!")
        except subprocess.CalledProcessError:
            print("❌ Commit failed", file=sys.stderr)
            sys.exit(1)
    else:
        print("Aborted.")
        sys.exit(0)


if __name__ == '__main__':
    main()