gac 0.15.1__py3-none-any.whl → 0.15.2__py3-none-any.whl

gac/diff_cli.py

@@ -0,0 +1,177 @@
+# flake8: noqa: E304
+
+"""Git diff display command for gac.
+
+This module implements the 'gac diff' subcommand which displays git diffs with various
+filtering and formatting options. It provides a convenient way to view staged or unstaged
+changes, compare commits, and apply smart filtering to focus on meaningful code changes.
+
+Key features:
+- Display staged or unstaged changes
+- Compare specific commits or branches
+- Filter out binary files, minified files, and lockfiles
+- Smart truncation of large diffs based on token limits
+- Colored output support for better readability
+- Integration with gac's preprocessing logic for cleaner diffs
+
+The diff command is particularly useful for:
+- Previewing what changes will be included in the commit message
+- Reviewing filtered diffs before committing
+- Comparing code changes between branches or commits
+- Understanding what files have been modified in the staging area
+"""
+
+import logging
+import sys
+
+import click
+
+from gac.errors import GitError, with_error_handling
+from gac.git import get_diff, get_staged_files
+from gac.preprocess import filter_binary_and_minified, smart_truncate_diff, split_diff_into_sections
+from gac.utils import print_message, setup_logging
+
+
+def _diff_implementation(
+    filter: bool,
+    truncate: bool,
+    max_tokens: int | None,
+    staged: bool,
+    color: bool,
+    commit1: str | None = None,
+    commit2: str | None = None,
+) -> None:
+    """Implementation of the diff command logic for easier testing."""
+    setup_logging()
+    # Get a logger for this module instead of using the return value of setup_logging
+    logger = logging.getLogger(__name__)
+    logger.debug("Running diff command")
+
+    # If we're comparing specific commits, don't need to check for staged changes
+    if not (commit1 or commit2):
+        # Check if there are staged changes
+        staged_files = get_staged_files()
+        if not staged_files and staged:
+            print_message("No staged changes found. Use 'git add' to stage changes.", level="error")
+            sys.exit(1)
+
+    try:
+        diff_text = get_diff(staged=staged, color=color, commit1=commit1, commit2=commit2)
+        if not diff_text:
+            print_message("No changes to display.", level="error")
+            sys.exit(1)
+    except GitError as e:
+        print_message(f"Error getting diff: {str(e)}", level="error")
+        sys.exit(1)
+
+    if filter:
+        diff_text = filter_binary_and_minified(diff_text)
+        if not diff_text:
+            print_message("No changes to display after filtering.", level="error")
+            sys.exit(1)
+
+    if truncate:
+        # Convert the diff text to the format expected by smart_truncate_diff
+        # (list of tuples with (section, score))
+        if isinstance(diff_text, str):
+            sections = split_diff_into_sections(diff_text)
+            scored_sections = [(section, 1.0) for section in sections]
+            diff_text = smart_truncate_diff(scored_sections, max_tokens or 1000, "anthropic:claude-3-haiku-latest")
+
+    if color:
+        # Use git's colored diff output
+        print(diff_text)
+    else:
+        # Strip ANSI color codes if color is disabled
+        # This is a simple approach - a more robust solution would use a library like 'strip-ansi'
+        import re
+
+        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+        print(ansi_escape.sub("", diff_text))
+
+
+@click.command(name="diff")
+# Content filtering options
+@click.option(
+    "--filter/--no-filter",
+    default=True,
+    help="Filter out binary files, minified files, and lockfiles",
+)
+# Display options
+@click.option(
+    "--color/--no-color",
+    default=True,
+    help="Show colored diff output",
+)
+# Diff source options
+@click.option(
+    "--staged/--unstaged",
+    default=True,
+    help="Show staged changes (default) or unstaged changes",
+)
+# Size control options
+@click.option(
+    "--truncate/--no-truncate",
+    default=True,
+    help="Truncate large diffs to a reasonable size",
+)
+@click.option(
+    "--max-tokens",
+    default=None,
+    type=int,
+    help="Maximum number of tokens to include in the diff",
+)
+@click.argument("commit1", required=False)
+@click.argument("commit2", required=False)
+@with_error_handling(GitError, "Failed to display diff")
+def diff(
+    filter: bool,
+    truncate: bool,
+    max_tokens: int | None,
+    staged: bool,
+    color: bool,
+    commit1: str | None = None,
+    commit2: str | None = None,
+) -> None:
+    """
+    Display the diff of staged or unstaged changes.
+
+    This command shows the raw diff without generating a commit message.
+
+    You can also compare specific commits or branches by providing one or two arguments:
+        gac diff <commit1> - Shows diff between working tree and <commit1>
+        gac diff <commit1> <commit2> - Shows diff between <commit1> and <commit2>
+
+    Commit references can be commit hashes, branch names, or other Git references.
+    """
+    _diff_implementation(
+        filter=filter,
+        truncate=truncate,
+        max_tokens=max_tokens,
+        staged=staged,
+        color=color,
+        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

@@ -0,0 +1,217 @@
+"""Error handling module for gac."""
+
+import logging
+import sys
+from collections.abc import Callable
+from typing import 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")
+
+
+class FormattingError(GacError):
+    """Error related to code formatting."""
+
+    exit_code = 5
+
+
+# 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.")
+    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.",
+    }
+
+    # 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, **kwargs) -> 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,158 @@
+"""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_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_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 Exception 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 = subprocess.check_output(["git", "rev-parse", "--show-toplevel"])
+    return result.decode().strip()
+
+
+def get_current_branch() -> str:
+    """Get name of current git branch."""
+    result = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+    return result.decode().strip()
+
+
+def get_commit_hash() -> str:
+    """Get SHA-1 hash of current commit."""
+    result = subprocess.check_output(["git", "rev-parse", "HEAD"])
+    return result.decode().strip()
+
+
+def run_pre_commit_hooks() -> 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
+        result = run_subprocess(["pre-commit", "--version"], silent=True, raise_on_error=False)
+        if not result:
+            logger.debug("pre-commit not installed, skipping hooks")
+            return True
+
+        # Run pre-commit hooks on staged files
+        logger.info("Running pre-commit hooks...")
+        try:
+            run_subprocess(["pre-commit", "run"], silent=False, raise_on_error=True)
+            # If we get here, all hooks passed
+            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Pre-commit hooks failed with exit code {e.returncode}")
+            return False
+    except Exception as e:
+        logger.debug(f"Error running pre-commit: {e}")
+        # If pre-commit 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:
+        run_git_command(["push"])
+        return True
+    except GitError as e:
+        if "fatal: No configured push destination" in str(e):
+            logger.error("No configured push destination.")
+        else:
+            logger.error(f"Failed to push changes: {e}")
+        return False

gac/init_cli.py

@@ -0,0 +1,45 @@
+"""CLI for initializing gac configuration interactively."""
+
+from pathlib import Path
+
+import click
+import questionary
+from dotenv import set_key
+
+GAC_ENV_PATH = Path.home() / ".gac.env"
+
+
+@click.command()
+def init() -> None:
+    """Interactively set up $HOME/.gac.env for gac."""
+    click.echo("Welcome to gac initialization!\n")
+    if GAC_ENV_PATH.exists():
+        click.echo(f"$HOME/.gac.env already exists at {GAC_ENV_PATH}. Values will be updated.")
+    else:
+        GAC_ENV_PATH.touch()
+        click.echo(f"Created $HOME/.gac.env at {GAC_ENV_PATH}.")
+
+    providers = [
+        ("Anthropic", "claude-3-5-haiku-latest"),
+        ("Groq", "meta-llama/llama-4-scout-17b-16e-instruct"),
+        ("Ollama", "gemma3"),
+        ("OpenAI", "gpt-4.1-mini"),
+    ]
+    provider_names = [p[0] for p in providers]
+    provider = questionary.select("Select your provider:", choices=provider_names).ask()
+    if not provider:
+        click.echo("Provider selection cancelled. Exiting.")
+        return
+    provider_key = provider.lower()
+    model_suggestion = dict(providers)[provider]
+    model = questionary.text(f"Enter the model (default: {model_suggestion}):", default=model_suggestion).ask()
+    model_to_save = model.strip() if model.strip() else model_suggestion
+    set_key(str(GAC_ENV_PATH), "GAC_MODEL", f"{provider_key}:{model_to_save}")
+    click.echo(f"Set GAC_MODEL={provider_key}:{model_to_save}")
+
+    api_key = questionary.password("Enter your API key (input hidden, can be set later):").ask()
+    if api_key:
+        set_key(str(GAC_ENV_PATH), f"{provider_key.upper()}_API_KEY", api_key)
+        click.echo(f"Set {provider_key.upper()}_API_KEY (hidden)")
+
+    click.echo(f"\ngac environment setup complete. You can edit {GAC_ENV_PATH} to update values later.")