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

gac/__init__.py

@@ -0,0 +1,15 @@
+"""Git Auto Commit (gac) - Generate commit messages using AI."""
+
+from gac.__version__ import __version__
+from gac.ai import generate_commit_message
+from gac.git import get_staged_files, push_changes
+from gac.prompt import build_prompt, clean_commit_message
+
+__all__ = [
+    "__version__",
+    "generate_commit_message",
+    "build_prompt",
+    "clean_commit_message",
+    "get_staged_files",
+    "push_changes",
+]

gac/__version__.py

@@ -0,0 +1,3 @@
+"""Version information for gac package."""
+
+__version__ = "0.15.2"

gac/ai.py

@@ -0,0 +1,166 @@
+"""AI provider integration for gac.
+
+This module provides core functionality for AI provider interaction.
+It consolidates all AI-related functionality including token counting and commit message generation.
+"""
+
+import logging
+import time
+from functools import lru_cache
+from typing import Any
+
+import aisuite as ai
+import tiktoken
+from halo import Halo
+
+from gac.constants import EnvDefaults, Utility
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: str) -> int:
+    """Count tokens in content using the model's tokenizer."""
+    text = extract_text_content(content)
+    if not text:
+        return 0
+
+    if model.startswith("anthropic"):
+        import anthropic
+
+        return anthropic.Client().messages.count_tokens(
+            model=model,
+            messages=[{"role": "user", "content": text}],
+        )
+
+    try:
+        encoding = get_encoding(model)
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.error(f"Error counting tokens: {e}")
+        return len(text) // 4
+
+
+def extract_text_content(content: str | list[dict[str, str]] | dict[str, Any]) -> str:
+    """Extract text content from various input formats."""
+    if isinstance(content, str):
+        return content
+    elif isinstance(content, list):
+        return "\n".join(msg["content"] for msg in content if isinstance(msg, dict) and "content" in msg)
+    elif isinstance(content, dict) and "content" in content:
+        return content["content"]
+    return ""
+
+
+@lru_cache(maxsize=1)
+def get_encoding(model: str) -> tiktoken.Encoding:
+    """Get the appropriate encoding for a given model."""
+    model_name = model.split(":")[-1] if ":" in model else model
+    try:
+        return tiktoken.encoding_for_model(model_name)
+    except KeyError:
+        return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
+
+
+def generate_commit_message(
+    model: str,
+    prompt: str,
+    temperature: float = EnvDefaults.TEMPERATURE,
+    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
+    max_retries: int = EnvDefaults.MAX_RETRIES,
+    quiet: bool = False,
+) -> str:
+    """Generate a commit message using aisuite.
+
+    Args:
+        model: The model to use in provider:model_name format (e.g., 'anthropic:claude-3-5-haiku-latest')
+        prompt: The formatted prompt containing diff and context
+        temperature: Controls randomness (0.0-1.0), lower values are more deterministic
+        max_tokens: Maximum tokens in the response
+        max_retries: Number of retry attempts if generation fails
+        quiet: If True, suppress progress indicators
+
+    Returns:
+        A formatted commit message string
+
+    Raises:
+        AIError: If generation fails after max_retries attempts
+
+    Example:
+        >>> model = "anthropic:claude-3-5-haiku-latest"
+        >>> prompt = build_prompt("On branch main", "diff --git a/README.md b/README.md")
+        >>> generate_commit_message(model, prompt)
+        'docs: Update README with installation instructions'
+    """
+    try:
+        _, _ = model.split(":", 1)
+    except ValueError as err:
+        raise AIError.model_error(
+            f"Invalid model format: {model}. Please use the format 'provider:model_name'."
+        ) from err
+
+    client = ai.Client()
+
+    if quiet:
+        spinner = None
+    else:
+        spinner = Halo(text=f"Generating commit message with {model}...", spinner="dots")
+        spinner.start()
+
+    last_error = None
+
+    retry_count = 0
+    while retry_count < max_retries:
+        try:
+            logger.debug(f"Trying with model {model} (attempt {retry_count + 1}/{max_retries})")
+            response = client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+
+            message = response.choices[0].message.content if hasattr(response, "choices") else response.content
+
+            if spinner:
+                spinner.succeed(f"Generated commit message with {model}")
+
+            return message
+
+        except Exception as e:
+            last_error = e
+            retry_count += 1
+
+            if retry_count == max_retries:
+                logger.warning(f"Error generating commit message: {e}. Giving up.")
+                break
+
+            wait_time = 2**retry_count
+            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
+            if spinner:
+                for i in range(wait_time, 0, -1):
+                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
+                    time.sleep(1)
+            else:
+                time.sleep(wait_time)
+    if spinner:
+        spinner.fail("Failed to generate commit message")
+
+    error_str = str(last_error).lower()
+
+    if "api key" in error_str or "unauthorized" in error_str or "authentication" in error_str:
+        error_type = "authentication"
+    elif "timeout" in error_str:
+        error_type = "timeout"
+    elif "rate limit" in error_str or "too many requests" in error_str:
+        error_type = "rate_limit"
+    elif "connect" in error_str or "network" in error_str:
+        error_type = "connection"
+    elif "model" in error_str or "not found" in error_str:
+        error_type = "model"
+    else:
+        error_type = "unknown"
+
+    raise AIError(
+        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
+    )

gac/cli.py

@@ -0,0 +1,130 @@
+# flake8: noqa: E304
+
+"""CLI entry point for gac.
+
+Defines the Click-based command-line interface and delegates execution to the main workflow.
+"""
+
+import logging
+import sys
+
+import click
+
+from gac import __version__
+from gac.config import load_config
+from gac.config_cli import config as config_cli
+from gac.constants import Logging
+from gac.diff_cli import diff as diff_cli
+from gac.errors import handle_error
+from gac.init_cli import init as init_cli
+from gac.main import main
+from gac.utils import setup_logging
+
+config = load_config()
+logger = logging.getLogger(__name__)
+
+
+@click.group(invoke_without_command=True, context_settings={"ignore_unknown_options": True})
+# Git workflow options
+@click.option("--add-all", "-a", is_flag=True, help="Stage all changes before committing")
+@click.option("--push", "-p", is_flag=True, help="Push changes to remote after committing")
+@click.option("--dry-run", is_flag=True, help="Dry run the commit workflow")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
+# Commit message options
+@click.option("--one-liner", "-o", is_flag=True, help="Generate a single-line commit message")
+@click.option("--show-prompt", is_flag=True, help="Show the prompt sent to the LLM")
+@click.option(
+    "--scope",
+    "-s",
+    is_flag=False,
+    flag_value="",
+    default=None,
+    help="Add a scope to the commit message. If used without a value, the LLM will determine an appropriate scope.",
+)
+@click.option("--hint", "-h", default="", help="Additional context to include in the prompt")
+# Model options
+@click.option("--model", "-m", help="Override the default model (format: 'provider:model_name')")
+# Output options
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
+@click.option("--verbose", "-v", is_flag=True, help="Increase output verbosity to INFO")
+@click.option(
+    "--log-level",
+    default=config["log_level"],
+    type=click.Choice(Logging.LEVELS, case_sensitive=False),
+    help=f"Set log level (default: {config['log_level']})",
+)
+# Advanced options
+@click.option("--no-verify", is_flag=True, help="Skip pre-commit hooks when committing")
+# Other options
+@click.option("--version", is_flag=True, help="Show the version of the Git Auto Commit (gac) tool")
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    add_all: bool = False,
+    log_level: str = config["log_level"],
+    one_liner: bool = False,
+    push: bool = False,
+    show_prompt: bool = False,
+    scope: str = None,
+    quiet: bool = False,
+    yes: bool = False,
+    hint: str = "",
+    model: str = None,
+    version: bool = False,
+    dry_run: bool = False,
+    verbose: bool = False,
+    no_verify: bool = False,
+) -> None:
+    """Git Auto Commit - Generate commit messages with AI."""
+    if ctx.invoked_subcommand is None:
+        if version:
+            print(f"Git Auto Commit (gac) version: {__version__}")
+            sys.exit(0)
+        effective_log_level = log_level
+        if verbose and log_level not in ("DEBUG", "INFO"):
+            effective_log_level = "INFO"
+        if quiet:
+            effective_log_level = "ERROR"
+        setup_logging(effective_log_level)
+        logger.info("Starting gac")
+        try:
+            main(
+                stage_all=add_all,
+                model=model,
+                hint=hint,
+                one_liner=one_liner,
+                show_prompt=show_prompt,
+                scope=scope,
+                require_confirmation=not yes,
+                push=push,
+                quiet=quiet,
+                dry_run=dry_run,
+                no_verify=no_verify,
+            )
+        except Exception as e:
+            handle_error(e, exit_program=True)
+    else:
+        ctx.obj = {
+            "add_all": add_all,
+            "log_level": log_level,
+            "one_liner": one_liner,
+            "push": push,
+            "show_prompt": show_prompt,
+            "scope": scope,
+            "quiet": quiet,
+            "yes": yes,
+            "hint": hint,
+            "model": model,
+            "version": version,
+            "dry_run": dry_run,
+            "verbose": verbose,
+            "no_verify": no_verify,
+        }
+
+
+cli.add_command(config_cli)
+cli.add_command(init_cli)
+cli.add_command(diff_cli)
+
+if __name__ == "__main__":
+    cli()

gac/config.py

@@ -0,0 +1,32 @@
+"""Configuration loading for gac.
+
+Handles environment variable and .env file precedence for application settings.
+"""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from gac.constants import EnvDefaults, Logging
+
+
+def load_config() -> dict[str, str | int | float | bool]:
+    """Load configuration from $HOME/.gac.env, then ./.env, then environment variables."""
+    user_config = Path.home() / ".gac.env"
+    if user_config.exists():
+        load_dotenv(user_config)
+    project_env = Path(".env")
+    if project_env.exists():
+        load_dotenv(project_env, override=True)
+
+    config = {
+        "model": os.getenv("GAC_MODEL"),
+        "temperature": float(os.getenv("GAC_TEMPERATURE", EnvDefaults.TEMPERATURE)),
+        "max_output_tokens": int(os.getenv("GAC_MAX_OUTPUT_TOKENS", EnvDefaults.MAX_OUTPUT_TOKENS)),
+        "max_retries": int(os.getenv("GAC_RETRIES", EnvDefaults.MAX_RETRIES)),
+        "log_level": os.getenv("GAC_LOG_LEVEL", Logging.DEFAULT_LEVEL),
+        "warning_limit_tokens": int(os.getenv("GAC_WARNING_LIMIT_TOKENS", EnvDefaults.WARNING_LIMIT_TOKENS)),
+    }
+
+    return config

gac/config_cli.py

@@ -0,0 +1,62 @@
+"""CLI for managing gac configuration in $HOME/.gac.env."""
+
+import os
+from pathlib import Path
+
+import click
+from dotenv import load_dotenv, set_key
+
+GAC_ENV_PATH = Path.home() / ".gac.env"
+
+
+@click.group()
+def config():
+    """Manage gac configuration."""
+    pass
+
+
+@config.command()
+def show() -> None:
+    """Show all current config values."""
+    if not GAC_ENV_PATH.exists():
+        click.echo("No $HOME/.gac.env found.")
+        return
+    load_dotenv(GAC_ENV_PATH, override=True)
+    with open(GAC_ENV_PATH) as f:
+        for line in f:
+            click.echo(line.rstrip())
+
+
+@config.command()
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str) -> None:
+    """Set a config KEY to VALUE in $HOME/.gac.env."""
+    GAC_ENV_PATH.touch(exist_ok=True)
+    set_key(str(GAC_ENV_PATH), key, value)
+    click.echo(f"Set {key} in $HOME/.gac.env")
+
+
+@config.command()
+@click.argument("key")
+def get(key: str) -> None:
+    """Get a config value by KEY."""
+    load_dotenv(GAC_ENV_PATH, override=True)
+    value = os.getenv(key)
+    if value is None:
+        click.echo(f"{key} not set.")
+    else:
+        click.echo(value)
+
+
+@config.command()
+@click.argument("key")
+def unset(key: str) -> None:
+    """Remove a config KEY from $HOME/.gac.env."""
+    if not GAC_ENV_PATH.exists():
+        click.echo("No $HOME/.gac.env found.")
+        return
+    lines = GAC_ENV_PATH.read_text().splitlines()
+    new_lines = [line for line in lines if not line.strip().startswith(f"{key}=")]
+    GAC_ENV_PATH.write_text("\n".join(new_lines) + "\n")
+    click.echo(f"Unset {key} in $HOME/.gac.env")

gac/constants.py

@@ -0,0 +1,149 @@
+"""Constants for the Git Auto Commit (gac) project."""
+
+import os
+from enum import Enum
+from re import Pattern
+
+
+class FileStatus(Enum):
+    """File status for Git operations."""
+
+    MODIFIED = "M"
+    ADDED = "A"
+    DELETED = "D"
+    RENAMED = "R"
+    COPIED = "C"
+    UNTRACKED = "?"
+
+
+class EnvDefaults:
+    """Default values for environment variables."""
+
+    MAX_RETRIES: int = 3
+    TEMPERATURE: float = 1
+    MAX_OUTPUT_TOKENS: int = 512
+    WARNING_LIMIT_TOKENS: int = 16384
+
+
+class Logging:
+    """Logging configuration constants."""
+
+    DEFAULT_LEVEL: str = "WARNING"
+    LEVELS: list[str] = ["DEBUG", "INFO", "WARNING", "ERROR"]
+
+
+class Utility:
+    """General utility constants."""
+
+    DEFAULT_ENCODING: str = "cl100k_base"  # llm encoding
+    DEFAULT_DIFF_TOKEN_LIMIT: int = 15000  # Maximum tokens for diff processing
+    MAX_WORKERS: int = os.cpu_count() or 4  # Maximum number of parallel workers
+
+
+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[Pattern[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": 4.0,  # Markdown
+        ".rst": 3.8,  # reStructuredText
+        # 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[Pattern[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
+    }