gac 3.10.3__py3-none-any.whl

gac/errors.py

@@ -0,0 +1,231 @@
+"""Error handling module for gac."""
+
+import logging
+import sys
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+console = Console()
+T = TypeVar("T")
+
+
+class GacError(Exception):
+    """Base exception class for all gac errors."""
+
+    exit_code = 1  # Default exit code
+
+    def __init__(
+        self,
+        message: str,
+        details: str | None = None,
+        suggestion: str | None = None,
+        exit_code: int | None = None,
+    ):
+        """
+        Initialize a new GacError.
+
+        Args:
+            message: The error message
+            details: Optional details about the error
+            suggestion: Optional suggestion for the user
+            exit_code: Optional exit code to override the class default
+        """
+        super().__init__(message)
+        self.message = message
+        self.details = details
+        self.suggestion = suggestion
+        if exit_code is not None:
+            self.exit_code = exit_code
+
+
+class ConfigError(GacError):
+    """Error related to configuration issues."""
+
+    exit_code = 2
+
+
+class GitError(GacError):
+    """Error related to Git operations."""
+
+    exit_code = 3
+
+
+class AIError(GacError):
+    """Error related to AI provider or models."""
+
+    exit_code = 4
+
+    def __init__(self, message: str, error_type: str = "unknown", exit_code: int | None = None):
+        """Initialize an AIError with a specific error type.
+
+        Args:
+            message: The error message
+            error_type: The type of AI error (from AI_ERROR_CODES keys)
+            exit_code: Optional exit code to override the default
+        """
+        super().__init__(message, exit_code=exit_code)
+        self.error_type = error_type
+        self.error_code = AI_ERROR_CODES.get(error_type, AI_ERROR_CODES["unknown"])
+
+    @classmethod
+    def authentication_error(cls, message: str) -> "AIError":
+        """Create an authentication error."""
+        return cls(message, error_type="authentication")
+
+    @classmethod
+    def connection_error(cls, message: str) -> "AIError":
+        """Create a connection error."""
+        return cls(message, error_type="connection")
+
+    @classmethod
+    def rate_limit_error(cls, message: str) -> "AIError":
+        """Create a rate limit error."""
+        return cls(message, error_type="rate_limit")
+
+    @classmethod
+    def timeout_error(cls, message: str) -> "AIError":
+        """Create a timeout error."""
+        return cls(message, error_type="timeout")
+
+    @classmethod
+    def model_error(cls, message: str) -> "AIError":
+        """Create a model error."""
+        return cls(message, error_type="model")
+
+    @classmethod
+    def unknown_error(cls, message: str) -> "AIError":
+        """Create an unknown error."""
+        return cls(message, error_type="unknown")
+
+
+class FormattingError(GacError):
+    """Error related to code formatting."""
+
+    exit_code = 5
+
+
+class SecurityError(GacError):
+    """Error related to security issues (e.g., detected secrets)."""
+
+    exit_code = 6
+
+
+# Simplified error hierarchy - we use a single AIError class with error codes
+# instead of multiple subclasses for better maintainability
+
+# Error codes for AI errors
+AI_ERROR_CODES = {
+    "authentication": 401,  # Authentication failures
+    "connection": 503,  # Connection issues
+    "rate_limit": 429,  # Rate limits
+    "timeout": 408,  # Timeouts
+    "model": 400,  # Model-related errors
+    "unknown": 500,  # Unknown errors
+}
+
+
+def handle_error(error: Exception, exit_program: bool = False, quiet: bool = False) -> None:
+    """Handle an error with proper logging and user feedback.
+
+    Args:
+        error: The error to handle
+        exit_program: If True, exit the program after handling the error
+        quiet: If True, suppress non-error output
+    """
+    logger.error(f"Error: {str(error)}")
+
+    if isinstance(error, GitError):
+        logger.error("Git operation failed. Please check your repository status.")
+    elif isinstance(error, AIError):
+        logger.error("AI operation failed. Please check your configuration and API keys.")
+    elif isinstance(error, SecurityError):
+        logger.error("Security scan detected potential secrets in staged changes.")
+    else:
+        logger.error("An unexpected error occurred.")
+
+    if exit_program:
+        logger.error("Exiting program due to error.")
+        sys.exit(error.exit_code if hasattr(error, "exit_code") else 1)
+
+
+def format_error_for_user(error: Exception) -> str:
+    """
+    Format an error message for display to the user.
+
+    Args:
+        error: The exception to format
+
+    Returns:
+        A user-friendly error message with remediation steps if applicable
+    """
+    base_message = str(error)
+
+    # More specific remediation for AI errors based on error type
+    if isinstance(error, AIError):
+        if hasattr(error, "error_type"):
+            if error.error_type == "authentication":
+                return f"{base_message}\n\nPlease check your API key and ensure it is valid."
+            elif error.error_type == "connection":
+                return f"{base_message}\n\nPlease check your internet connection and try again."
+            elif error.error_type == "rate_limit":
+                return f"{base_message}\n\nYou've hit the rate limit for this AI provider. Please wait and try again later."  # noqa: E501
+            elif error.error_type == "timeout":
+                return f"{base_message}\n\nThe request timed out. Please try again or use a different model."
+            elif error.error_type == "model":
+                return f"{base_message}\n\nPlease check that the specified model exists and is available to you."
+        return f"{base_message}\n\nPlease check your API key, model name, and internet connection."
+
+    # Mapping of error types to remediation steps
+    remediation_steps = {
+        ConfigError: "Please check your configuration settings.",
+        GitError: "Please ensure Git is installed and you're in a valid Git repository.",
+        FormattingError: "Please check that required formatters are installed.",
+        SecurityError: "Please remove or secure any detected secrets before committing.",
+    }
+
+    # Generic remediation for unexpected errors
+    if not any(isinstance(error, t) for t in remediation_steps.keys()):
+        return f"{base_message}\n\nIf this issue persists, please report it as a bug."
+
+    # Get remediation steps for the specific error type
+    for error_class, steps in remediation_steps.items():
+        if isinstance(error, error_class):
+            return f"{base_message}\n\n{steps}"
+
+    # Fallback (though we should never reach this)
+    return base_message
+
+
+def with_error_handling(
+    error_type: type[GacError], error_message: str, quiet: bool = False, exit_on_error: bool = True
+) -> Callable[[Callable[..., T]], Callable[..., T | None]]:
+    """
+    A decorator that wraps a function with standardized error handling.
+
+    Args:
+        error_type: The specific error type to raise if an exception occurs
+        error_message: The error message to use
+        quiet: If True, suppress non-error output
+        exit_on_error: If True, exit the program on error
+
+    Returns:
+        A decorator function that handles errors for the wrapped function
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T | None]:
+        def wrapper(*args: Any, **kwargs: Any) -> T | None:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                # Create a specific error with our message and the original error
+                specific_error = error_type(f"{error_message}: {e}")
+                # Handle the error using our standardized handler
+                handle_error(specific_error, quiet=quiet, exit_program=exit_on_error)
+                return None
+
+        return wrapper
+
+    return decorator

gac/git.py

@@ -0,0 +1,372 @@
+"""Git operations for gac.
+
+This module provides a simplified interface to Git commands.
+It focuses on the core operations needed for commit generation.
+"""
+
+import logging
+import os
+import subprocess
+
+from gac.errors import GitError
+from gac.utils import run_subprocess
+
+logger = logging.getLogger(__name__)
+
+
+def run_subprocess_with_encoding_fallback(
+    command: list[str], silent: bool = False, timeout: int = 60
+) -> 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,
+    like pre-commit and lefthook hook execution.
+
+    Args:
+        command: List of command arguments
+        silent: If True, suppress debug logging
+        timeout: Command timeout in seconds
+
+    Returns:
+        CompletedProcess object with stdout, stderr, and returncode
+    """
+    from gac.utils import get_safe_encodings
+
+    encodings = get_safe_encodings()
+    last_exception: Exception | None = None
+
+    for encoding in encodings:
+        try:
+            if not silent:
+                logger.debug(f"Running command: {' '.join(command)} (encoding: {encoding})")
+
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=timeout,
+                encoding=encoding,
+                errors="replace",
+            )
+            return result
+        except UnicodeError as e:
+            last_exception = e
+            if not silent:
+                logger.debug(f"Failed to decode with {encoding}: {e}")
+            continue
+        except subprocess.TimeoutExpired:
+            raise
+        except (subprocess.SubprocessError, OSError, FileNotFoundError) as e:
+            if not silent:
+                logger.debug(f"Command error: {e}")
+            # Try next encoding for non-timeout errors
+            last_exception = e
+            continue
+
+    # If we get here, all encodings failed
+    if last_exception:
+        raise subprocess.CalledProcessError(1, command, "", f"Encoding error: {last_exception}") from last_exception
+    else:
+        raise subprocess.CalledProcessError(1, command, "", "All encoding attempts failed")
+
+
+def run_git_command(args: list[str], silent: bool = False, timeout: int = 30) -> str:
+    """Run a git command and return the output."""
+    command = ["git"] + args
+    return run_subprocess(command, silent=silent, timeout=timeout, raise_on_error=False, strip_output=True)
+
+
+def get_staged_files(file_type: str | None = None, existing_only: bool = False) -> list[str]:
+    """Get list of staged files with optional filtering.
+
+    Args:
+        file_type: Optional file extension to filter by
+        existing_only: If True, only include files that exist on disk
+
+    Returns:
+        List of staged file paths
+    """
+    try:
+        output = run_git_command(["diff", "--name-only", "--cached"])
+        if not output:
+            return []
+
+        # Parse and filter the file list
+        files = [line.strip() for line in output.splitlines() if line.strip()]
+
+        if file_type:
+            files = [f for f in files if f.endswith(file_type)]
+
+        if existing_only:
+            files = [f for f in files if os.path.isfile(f)]
+
+        return files
+    except GitError:
+        # If git command fails, return empty list as a fallback
+        return []
+
+
+def get_staged_status() -> str:
+    """Get formatted status of staged files only, excluding unstaged/untracked files.
+
+    Returns:
+        Formatted status string with M/A/D/R indicators
+    """
+    try:
+        output = run_git_command(["diff", "--name-status", "--staged"])
+        if not output:
+            return "No changes staged for commit."
+
+        status_map = {
+            "M": "modified",
+            "A": "new file",
+            "D": "deleted",
+            "R": "renamed",
+            "C": "copied",
+            "T": "typechange",
+        }
+
+        status_lines = ["Changes to be committed:"]
+        for line in output.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+
+            # Parse status line (e.g., "M\tfile.py" or "R100\told.py\tnew.py")
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+
+            change_type = parts[0][0]  # First char is the status (M, A, D, R, etc.)
+            file_path = parts[-1]  # Last part is the new/current file path
+
+            status_label = status_map.get(change_type, "modified")
+            status_lines.append(f"\t{status_label}:   {file_path}")
+
+        return "\n".join(status_lines)
+    except GitError:
+        return "No changes staged for commit."
+
+
+def get_diff(staged: bool = True, color: bool = True, commit1: str | None = None, commit2: str | None = None) -> str:
+    """Get the diff between commits or working tree.
+
+    Args:
+        staged: If True, show staged changes. If False, show unstaged changes.
+            This is ignored if commit1 and commit2 are provided.
+        color: If True, include ANSI color codes in the output.
+        commit1: First commit hash, branch name, or reference to compare from.
+        commit2: Second commit hash, branch name, or reference to compare to.
+            If only commit1 is provided, compares working tree to commit1.
+
+    Returns:
+        String containing the diff output
+
+    Raises:
+        GitError: If the git command fails
+    """
+    try:
+        args = ["diff"]
+
+        if color:
+            args.append("--color")
+
+        # If specific commits are provided, use them for comparison
+        if commit1 and commit2:
+            args.extend([commit1, commit2])
+        elif commit1:
+            args.append(commit1)
+        elif staged:
+            args.append("--cached")
+
+        output = run_git_command(args)
+        return output
+    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
+
+
+def get_repo_root() -> str:
+    """Get absolute path of repository root."""
+    result = run_git_command(["rev-parse", "--show-toplevel"])
+    return result
+
+
+def get_current_branch() -> str:
+    """Get name of current git branch."""
+    result = run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
+    return result
+
+
+def get_commit_hash() -> str:
+    """Get SHA-1 hash of current commit."""
+    result = run_git_command(["rev-parse", "HEAD"])
+    return result
+
+
+def run_pre_commit_hooks(hook_timeout: int = 120) -> bool:
+    """Run pre-commit hooks if they exist.
+
+    Returns:
+        True if pre-commit hooks passed or don't exist, False if they failed.
+    """
+    # Check if .pre-commit-config.yaml exists
+    if not os.path.exists(".pre-commit-config.yaml"):
+        logger.debug("No .pre-commit-config.yaml found, skipping pre-commit hooks")
+        return True
+
+    # Check if pre-commit is installed and configured
+    try:
+        # First check if pre-commit is installed
+        version_check = run_subprocess(["pre-commit", "--version"], silent=True, raise_on_error=False)
+        if not version_check:
+            logger.debug("pre-commit not installed, skipping hooks")
+            return True
+
+        # Run pre-commit hooks on staged files
+        logger.info(f"Running pre-commit hooks with {hook_timeout}s timeout...")
+        # Run pre-commit and capture both stdout and stderr
+        result = run_subprocess_with_encoding_fallback(["pre-commit", "run"], timeout=hook_timeout)
+
+        if result.returncode == 0:
+            # All hooks passed
+            return True
+        else:
+            # Pre-commit hooks failed - show the output
+            output = result.stdout if result.stdout else ""
+            error = result.stderr if result.stderr else ""
+
+            # Combine outputs (pre-commit usually outputs to stdout)
+            full_output = output + ("\n" + error if error else "")
+
+            if full_output.strip():
+                # Show which hooks failed and why
+                logger.error(f"Pre-commit hooks failed:\n{full_output}")
+            else:
+                logger.error(f"Pre-commit hooks failed with exit code {result.returncode}")
+            return False
+    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
+
+
+def run_lefthook_hooks(hook_timeout: int = 120) -> bool:
+    """Run Lefthook hooks if they exist.
+
+    Returns:
+        True if Lefthook hooks passed or don't exist, False if they failed.
+    """
+    # Check for common Lefthook configuration files
+    lefthook_configs = [".lefthook.yml", "lefthook.yml", ".lefthook.yaml", "lefthook.yaml"]
+    config_exists = any(os.path.exists(config) for config in lefthook_configs)
+
+    if not config_exists:
+        logger.debug("No Lefthook configuration found, skipping Lefthook hooks")
+        return True
+
+    # Check if lefthook is installed and configured
+    try:
+        # First check if lefthook is installed
+        version_check = run_subprocess(["lefthook", "--version"], silent=True, raise_on_error=False)
+        if not version_check:
+            logger.debug("Lefthook not installed, skipping hooks")
+            return True
+
+        # Run lefthook hooks on staged files
+        logger.info(f"Running Lefthook hooks with {hook_timeout}s timeout...")
+        # Run lefthook and capture both stdout and stderr
+        result = run_subprocess_with_encoding_fallback(["lefthook", "run", "pre-commit"], timeout=hook_timeout)
+
+        if result.returncode == 0:
+            # All hooks passed
+            return True
+        else:
+            # Lefthook hooks failed - show the output
+            output = result.stdout if result.stdout else ""
+            error = result.stderr if result.stderr else ""
+
+            # Combine outputs (lefthook usually outputs to stdout)
+            full_output = output + ("\n" + error if error else "")
+
+            if full_output.strip():
+                # Show which hooks failed and why
+                logger.error(f"Lefthook hooks failed:\n{full_output}")
+            else:
+                logger.error(f"Lefthook hooks failed with exit code {result.returncode}")
+            return False
+    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
+
+
+def push_changes() -> bool:
+    """Push committed changes to the remote repository."""
+    remote_exists = run_git_command(["remote"])
+    if not remote_exists:
+        logger.error("No configured remote repository.")
+        return False
+
+    try:
+        # Use raise_on_error=True to properly catch push failures
+        run_subprocess(["git", "push"], raise_on_error=True, strip_output=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        error_msg = e.stderr.strip() if e.stderr else str(e)
+        if "fatal: No configured push destination" in error_msg:
+            logger.error("No configured push destination.")
+        else:
+            logger.error(f"Failed to push changes: {error_msg}")
+        return False
+    except (subprocess.SubprocessError, OSError, ConnectionError) as e:
+        logger.error(f"Failed to push changes: {e}")
+        return False
+
+
+def detect_rename_mappings(staged_diff: str) -> dict[str, str]:
+    """Detect file rename mappings from a staged diff.
+
+    Args:
+        staged_diff: The output of 'git diff --cached --binary'
+
+    Returns:
+        Dictionary mapping new_file_path -> old_file_path for rename operations
+    """
+    rename_mappings = {}
+    lines = staged_diff.split("\n")
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        if line.startswith("diff --git a/"):
+            # Extract old and new file paths from diff header
+            if " b/" in line:
+                parts = line.split(" a/")
+                if len(parts) >= 2:
+                    old_path_part = parts[1]
+                    old_path = old_path_part.split(" b/")[0] if " b/" in old_path_part else old_path_part
+
+                    new_path = line.split(" b/")[-1] if " b/" in line else None
+
+                    # Check if this diff represents a rename by looking at following lines
+                    j = i + 1
+                    is_rename = False
+
+                    while j < len(lines) and not lines[j].startswith("diff --git"):
+                        if lines[j].startswith("similarity index "):
+                            is_rename = True
+                            break
+                        elif lines[j].startswith("rename from "):
+                            is_rename = True
+                            break
+                        j += 1
+
+                    if is_rename and old_path and new_path and old_path != new_path:
+                        rename_mappings[new_path] = old_path
+
+        i += 1
+
+    return rename_mappings