gac 3.8.1__py3-none-any.whl → 3.10.10__py3-none-any.whl

gac/constants/file_patterns.py

@@ -0,0 +1,110 @@
+"""File pattern constants for identifying special file types and importance weighting."""
+
+
+class FilePatterns:
+    """Patterns for identifying special file types."""
+
+    # Regex patterns to detect binary file changes in git diffs (e.g., images or other non-text files)
+    BINARY: list[str] = [
+        r"Binary files .* differ",
+        r"GIT binary patch",
+    ]
+
+    # Regex patterns to detect minified files in git diffs (e.g., JavaScript or CSS files)
+    MINIFIED_EXTENSIONS: list[str] = [
+        ".min.js",
+        ".min.css",
+        ".bundle.js",
+        ".bundle.css",
+        ".compressed.js",
+        ".compressed.css",
+        ".opt.js",
+        ".opt.css",
+    ]
+
+    # Regex patterns to detect build directories in git diffs (e.g., dist, build, vendor, etc.)
+    BUILD_DIRECTORIES: list[str] = [
+        "/dist/",
+        "/build/",
+        "/vendor/",
+        "/node_modules/",
+        "/assets/vendor/",
+        "/public/build/",
+        "/static/dist/",
+    ]
+
+
+class FileTypeImportance:
+    """Importance multipliers for different file types."""
+
+    EXTENSIONS: dict[str, float] = {
+        # Programming languages
+        ".py": 5.0,  # Python
+        ".js": 4.5,  # JavaScript
+        ".ts": 4.5,  # TypeScript
+        ".jsx": 4.8,  # React JS
+        ".tsx": 4.8,  # React TS
+        ".go": 4.5,  # Go
+        ".rs": 4.5,  # Rust
+        ".java": 4.2,  # Java
+        ".c": 4.2,  # C
+        ".h": 4.2,  # C/C++ header
+        ".cpp": 4.2,  # C++
+        ".rb": 4.2,  # Ruby
+        ".php": 4.0,  # PHP
+        ".scala": 4.0,  # Scala
+        ".swift": 4.0,  # Swift
+        ".kt": 4.0,  # Kotlin
+        # Configuration
+        ".json": 3.5,  # JSON config
+        ".yaml": 3.8,  # YAML config
+        ".yml": 3.8,  # YAML config
+        ".toml": 3.8,  # TOML config
+        ".ini": 3.5,  # INI config
+        ".env": 3.5,  # Environment variables
+        # Documentation
+        ".md": 2.5,  # Markdown (reduced to prioritize code changes)
+        ".rst": 2.5,  # reStructuredText (reduced to prioritize code changes)
+        # Web
+        ".html": 3.5,  # HTML
+        ".css": 3.5,  # CSS
+        ".scss": 3.5,  # SCSS
+        ".svg": 2.5,  # SVG graphics
+        # Build & CI
+        "Dockerfile": 4.0,  # Docker
+        ".github/workflows": 4.0,  # GitHub Actions
+        "CMakeLists.txt": 3.8,  # CMake
+        "Makefile": 3.8,  # Make
+        "package.json": 4.2,  # NPM package
+        "pyproject.toml": 4.2,  # Python project
+        "requirements.txt": 4.0,  # Python requirements
+    }
+
+
+class CodePatternImportance:
+    """Importance multipliers for different code patterns."""
+
+    # Regex patterns to detect code structure changes in git diffs (e.g., class, function, import)
+    # Note: The patterns are prefixed with "+" to match only added and modified lines
+    PATTERNS: dict[str, float] = {
+        # Structure changes
+        r"\+\s*(class|interface|enum)\s+\w+": 1.8,  # Class/interface/enum definitions
+        r"\+\s*(def|function|func)\s+\w+\s*\(": 1.5,  # Function definitions
+        r"\+\s*(import|from .* import)": 1.3,  # Imports
+        r"\+\s*(public|private|protected)\s+\w+": 1.2,  # Access modifiers
+        # Configuration changes
+        r"\+\s*\"(dependencies|devDependencies)\"": 1.4,  # Package dependencies
+        r"\+\s*version[\"\s:=]+[0-9.]+": 1.3,  # Version changes
+        # Logic changes
+        r"\+\s*(if|else|elif|switch|case|for|while)[\s(]": 1.2,  # Control structures
+        r"\+\s*(try|catch|except|finally)[\s:]": 1.2,  # Exception handling
+        r"\+\s*return\s+": 1.1,  # Return statements
+        r"\+\s*await\s+": 1.1,  # Async/await
+        # Comments & docs
+        r"\+\s*(//|#|/\*|\*\*)\s*TODO": 1.2,  # TODOs
+        r"\+\s*(//|#|/\*|\*\*)\s*FIX": 1.3,  # FIXes
+        r"\+\s*(\"\"\"|\'\'\')": 1.1,  # Docstrings
+        # Test code
+        r"\+\s*(test|describe|it|should)\s*\(": 1.1,  # Test definitions
+        r"\+\s*(assert|expect)": 1.0,  # Assertions
+    }

gac/constants/languages.py

@@ -0,0 +1,119 @@
+"""Language code mappings and utilities for internationalization."""
+
+
+class Languages:
+    """Language code mappings and utilities."""
+
+    # Language code to full name mapping
+    # Supports ISO 639-1 codes and common variants
+    CODE_MAP: dict[str, str] = {
+        # English
+        "en": "English",
+        # Chinese
+        "zh": "Simplified Chinese",
+        "zh-cn": "Simplified Chinese",
+        "zh-hans": "Simplified Chinese",
+        "zh-tw": "Traditional Chinese",
+        "zh-hant": "Traditional Chinese",
+        # Japanese
+        "ja": "Japanese",
+        # Korean
+        "ko": "Korean",
+        # Spanish
+        "es": "Spanish",
+        # Portuguese
+        "pt": "Portuguese",
+        # French
+        "fr": "French",
+        # German
+        "de": "German",
+        # Russian
+        "ru": "Russian",
+        # Hindi
+        "hi": "Hindi",
+        # Italian
+        "it": "Italian",
+        # Polish
+        "pl": "Polish",
+        # Turkish
+        "tr": "Turkish",
+        # Dutch
+        "nl": "Dutch",
+        # Vietnamese
+        "vi": "Vietnamese",
+        # Thai
+        "th": "Thai",
+        # Indonesian
+        "id": "Indonesian",
+        # Swedish
+        "sv": "Swedish",
+        # Arabic
+        "ar": "Arabic",
+        # Hebrew
+        "he": "Hebrew",
+        # Greek
+        "el": "Greek",
+        # Danish
+        "da": "Danish",
+        # Norwegian
+        "no": "Norwegian",
+        "nb": "Norwegian",
+        "nn": "Norwegian",
+        # Finnish
+        "fi": "Finnish",
+    }
+
+    # List of languages with display names and English names for CLI selection
+    # Format: (display_name, english_name)
+    LANGUAGES: list[tuple[str, str]] = [
+        ("English", "English"),
+        ("简体中文", "Simplified Chinese"),
+        ("繁體中文", "Traditional Chinese"),
+        ("日本語", "Japanese"),
+        ("한국어", "Korean"),
+        ("Español", "Spanish"),
+        ("Português", "Portuguese"),
+        ("Français", "French"),
+        ("Deutsch", "German"),
+        ("Русский", "Russian"),
+        ("हिन्दी", "Hindi"),
+        ("Italiano", "Italian"),
+        ("Polski", "Polish"),
+        ("Türkçe", "Turkish"),
+        ("Nederlands", "Dutch"),
+        ("Tiếng Việt", "Vietnamese"),
+        ("ไทย", "Thai"),
+        ("Bahasa Indonesia", "Indonesian"),
+        ("Svenska", "Swedish"),
+        ("العربية", "Arabic"),
+        ("עברית", "Hebrew"),
+        ("Ελληνικά", "Greek"),
+        ("Dansk", "Danish"),
+        ("Norsk", "Norwegian"),
+        ("Suomi", "Finnish"),
+        ("Custom", "Custom"),
+    ]
+
+    @staticmethod
+    def resolve_code(language: str) -> str:
+        """Resolve a language code to its full name.
+
+        Args:
+            language: Language name or code (e.g., 'Spanish', 'es', 'zh-CN')
+
+        Returns:
+            Full language name (e.g., 'Spanish', 'Simplified Chinese')
+
+        If the input is already a full language name, it's returned as-is.
+        If it's a recognized code, it's converted to the full name.
+        Otherwise, the input is returned unchanged (for custom languages).
+        """
+        # Normalize the code to lowercase for lookup
+        code_lower = language.lower().strip()
+
+        # Check if it's a recognized code
+        if code_lower in Languages.CODE_MAP:
+            return Languages.CODE_MAP[code_lower]
+
+        # Return as-is (could be a full name or custom language)
+        return language

gac/diff_cli.py

@@ -157,25 +157,3 @@ def diff(
         commit1=commit1,
         commit2=commit2,
     )
-
-
-# Function for testing only
-def _callback_for_testing(
-    filter: bool,
-    truncate: bool,
-    max_tokens: int | None,
-    staged: bool,
-    color: bool,
-    commit1: str | None = None,
-    commit2: str | None = None,
-) -> None:
-    """A version of the diff command callback that can be called directly from tests."""
-    _diff_implementation(
-        filter=filter,
-        truncate=truncate,
-        max_tokens=max_tokens,
-        staged=staged,
-        color=color,
-        commit1=commit1,
-        commit2=commit2,
-    )

gac/errors.py

@@ -3,7 +3,7 @@
 import logging
 import sys
 from collections.abc import Callable
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from rich.console import Console
 
@@ -113,6 +113,12 @@ class SecurityError(GacError):
     exit_code = 6
 
 
+class HookError(GacError):
+    """Error when pre-commit or lefthook hooks fail."""
+
+    exit_code = 1
+
+
 # Simplified error hierarchy - we use a single AIError class with error codes
 # instead of multiple subclasses for better maintainability
 
@@ -216,7 +222,7 @@ def with_error_handling(
     """
 
     def decorator(func: Callable[..., T]) -> Callable[..., T | None]:
-        def wrapper(*args, **kwargs) -> T | None:
+        def wrapper(*args: Any, **kwargs: Any) -> T | None:
             try:
                 return func(*args, **kwargs)
             except Exception as e:

gac/git.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 def run_subprocess_with_encoding_fallback(
     command: list[str], silent: bool = False, timeout: int = 60
-) -> subprocess.CompletedProcess:
+) -> subprocess.CompletedProcess[str]:
     """Run subprocess with encoding fallback, returning full CompletedProcess object.
 
     This is used for cases where we need both stdout and stderr separately,
@@ -57,7 +57,7 @@ def run_subprocess_with_encoding_fallback(
             continue
         except subprocess.TimeoutExpired:
             raise
-        except Exception as e:
+        except (subprocess.SubprocessError, OSError, FileNotFoundError) as e:
             if not silent:
                 logger.debug(f"Command error: {e}")
             # Try next encoding for non-timeout errors
@@ -182,7 +182,7 @@ def get_diff(staged: bool = True, color: bool = True, commit1: str | None = None
 
         output = run_git_command(args)
         return output
-    except Exception as e:
+    except (subprocess.SubprocessError, OSError, FileNotFoundError) as e:
         logger.error(f"Failed to get diff: {str(e)}")
         raise GitError(f"Failed to get diff: {str(e)}") from e
 
@@ -246,7 +246,7 @@ def run_pre_commit_hooks(hook_timeout: int = 120) -> bool:
             else:
                 logger.error(f"Pre-commit hooks failed with exit code {result.returncode}")
             return False
-    except Exception as e:
+    except (subprocess.SubprocessError, OSError, FileNotFoundError, PermissionError) as e:
         logger.debug(f"Error running pre-commit: {e}")
         # If pre-commit isn't available, don't block the commit
         return True
@@ -296,7 +296,7 @@ def run_lefthook_hooks(hook_timeout: int = 120) -> bool:
             else:
                 logger.error(f"Lefthook hooks failed with exit code {result.returncode}")
             return False
-    except Exception as e:
+    except (subprocess.SubprocessError, OSError, FileNotFoundError, PermissionError) as e:
         logger.debug(f"Error running Lefthook: {e}")
         # If lefthook isn't available, don't block the commit
         return True
@@ -320,7 +320,7 @@ def push_changes() -> bool:
         else:
             logger.error(f"Failed to push changes: {error_msg}")
         return False
-    except Exception as e:
+    except (subprocess.SubprocessError, OSError, ConnectionError) as e:
         logger.error(f"Failed to push changes: {e}")
         return False
 

gac/git_state_validator.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Git state validation and management for gac."""
+
+import logging
+import subprocess
+from typing import Any, NamedTuple
+
+from rich.console import Console
+
+from gac.config import GACConfig
+from gac.errors import ConfigError, GitError, handle_error
+from gac.git import get_staged_files, get_staged_status, run_git_command
+from gac.preprocess import preprocess_diff
+from gac.security import get_affected_files, scan_staged_diff
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+class GitState(NamedTuple):
+    """Structured representation of git repository state."""
+
+    repo_root: str
+    staged_files: list[str]
+    status: str
+    diff: str
+    diff_stat: str
+    processed_diff: str
+    has_secrets: bool
+    secrets: list[Any]
+
+
+class GitStateValidator:
+    """Validates and manages git repository state."""
+
+    def __init__(self, config: GACConfig):
+        self.config = config
+
+    def validate_repository(self) -> str:
+        """Validate that we're in a git repository and return the repo root."""
+        try:
+            git_dir = run_git_command(["rev-parse", "--show-toplevel"])
+            if not git_dir:
+                raise GitError("Not in a git repository")
+            return git_dir
+        except (subprocess.SubprocessError, GitError, OSError) as e:
+            logger.error(f"Error checking git repository: {e}")
+            handle_error(GitError("Not in a git repository"), exit_program=True)
+            return ""  # Never reached, but required for type safety
+
+    def stage_all_if_requested(self, stage_all: bool, dry_run: bool) -> None:
+        """Stage all changes if requested and not in dry run mode."""
+        if stage_all and (not dry_run):
+            logger.info("Staging all changes")
+            run_git_command(["add", "--all"])
+
+    def get_git_state(
+        self,
+        stage_all: bool = False,
+        dry_run: bool = False,
+        skip_secret_scan: bool = False,
+        quiet: bool = False,
+        model: str | None = None,
+        hint: str = "",
+        one_liner: bool = False,
+        infer_scope: bool = False,
+        verbose: bool = False,
+        language: str | None = None,
+    ) -> GitState | None:
+        """Get complete git state including validation and processing.
+
+        Returns:
+            GitState if staged changes exist, None if no staged changes found.
+        """
+        from gac.constants import Utility
+
+        # Validate repository
+        repo_root = self.validate_repository()
+
+        # Stage files if requested
+        self.stage_all_if_requested(stage_all, dry_run)
+
+        # Get staged files
+        staged_files = get_staged_files(existing_only=False)
+
+        if not staged_files:
+            console.print(
+                "[yellow]No staged changes found. Stage your changes with git add first or use --add-all.[/yellow]"
+            )
+            return None
+
+        # Get git status and diffs
+        status = get_staged_status()
+        diff = run_git_command(["diff", "--staged"])
+        diff_stat = " " + run_git_command(["diff", "--stat", "--cached"])
+
+        # Scan for secrets
+        has_secrets = False
+        secrets = []
+        if not skip_secret_scan:
+            logger.info("Scanning staged changes for potential secrets...")
+            secrets = scan_staged_diff(diff)
+            has_secrets = bool(secrets)
+
+        # Process diff for AI consumption
+        logger.debug(f"Preprocessing diff ({len(diff)} characters)")
+        if model is None:
+            raise ConfigError("Model must be specified via GAC_MODEL environment variable or --model flag")
+        processed_diff = preprocess_diff(diff, token_limit=Utility.DEFAULT_DIFF_TOKEN_LIMIT, model=model)
+        logger.debug(f"Processed diff ({len(processed_diff)} characters)")
+
+        return GitState(
+            repo_root=repo_root,
+            staged_files=staged_files,
+            status=status,
+            diff=diff,
+            diff_stat=diff_stat,
+            processed_diff=processed_diff,
+            has_secrets=has_secrets,
+            secrets=secrets,
+        )
+
+    def handle_secret_detection(self, secrets: list[Any], quiet: bool = False) -> bool | None:
+        """Handle secret detection and user interaction.
+
+        Returns:
+            True: Continue with commit
+            False: Re-get git state (files were removed)
+            None: Abort workflow
+        """
+        if not secrets:
+            return True
+
+        if not quiet:
+            console.print("\n[bold red]⚠️  SECURITY WARNING: Potential secrets detected![/bold red]")
+            console.print("[red]The following sensitive information was found in your staged changes:[/red]\n")
+
+        for secret in secrets:
+            location = f"{secret.file_path}:{secret.line_number}" if secret.line_number else secret.file_path
+            if not quiet:
+                console.print(f"  • [yellow]{secret.secret_type}[/yellow] in [cyan]{location}[/cyan]")
+                console.print(f"    Match: [dim]{secret.matched_text}[/dim]\n")
+
+        if not quiet:
+            console.print("\n[bold]Options:[/bold]")
+            console.print("  \\[a] Abort commit (recommended)")
+            console.print("  \\[c] [yellow]Continue anyway[/yellow] (not recommended)")
+            console.print("  \\[r] Remove affected file(s) and continue")
+
+        try:
+            import click
+
+            choice = (
+                click.prompt(
+                    "\nChoose an option",
+                    type=click.Choice(["a", "c", "r"], case_sensitive=False),
+                    default="a",
+                    show_choices=True,
+                    show_default=True,
+                )
+                .strip()
+                .lower()
+            )
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[red]Aborted by user.[/red]")
+            return None
+
+        if choice == "a":
+            console.print("[yellow]Commit aborted.[/yellow]")
+            return None
+        elif choice == "c":
+            console.print("[bold yellow]⚠️  Continuing with potential secrets in commit...[/bold yellow]")
+            logger.warning("User chose to continue despite detected secrets")
+            return True
+        elif choice == "r":
+            affected_files = get_affected_files(secrets)
+            for file_path in affected_files:
+                try:
+                    run_git_command(["reset", "HEAD", file_path])
+                    console.print(f"[green]Unstaged: {file_path}[/green]")
+                except GitError as e:
+                    console.print(f"[red]Failed to unstage {file_path}: {e}[/red]")
+
+            # Check if there are still staged files
+            remaining_staged = get_staged_files(existing_only=False)
+            if not remaining_staged:
+                console.print("[yellow]No files remain staged. Commit aborted.[/yellow]")
+                return None
+
+            console.print(f"[green]Continuing with {len(remaining_staged)} staged file(s)...[/green]")
+            return False
+
+        return True