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

gac/config.py

@@ -5,13 +5,89 @@ Handles environment variable and .gac.env file precedence for application settin
 
 import os
 from pathlib import Path
+from typing import TypedDict
 
 from dotenv import load_dotenv
 
 from gac.constants import EnvDefaults, Logging
+from gac.errors import ConfigError
 
 
-def load_config() -> dict[str, str | int | float | bool | None]:
+class GACConfig(TypedDict, total=False):
+    """TypedDict for GAC configuration values.
+
+    Fields that can be None or omitted are marked with total=False.
+    """
+
+    model: str | None
+    temperature: float
+    max_output_tokens: int
+    max_retries: int
+    log_level: str
+    warning_limit_tokens: int
+    always_include_scope: bool
+    skip_secret_scan: bool
+    no_tiktoken: bool
+    no_verify_ssl: bool
+    verbose: bool
+    system_prompt_path: str | None
+    language: str | None
+    translate_prefixes: bool
+    rtl_confirmed: bool
+    hook_timeout: int
+
+
+def validate_config(config: GACConfig) -> None:
+    """Validate configuration values at load time.
+
+    Args:
+        config: Configuration dictionary to validate
+
+    Raises:
+        ConfigError: If any configuration value is invalid
+    """
+    # Validate temperature (0.0 to 2.0)
+    if config.get("temperature") is not None:
+        temp = config["temperature"]
+        if not isinstance(temp, (int, float)):
+            raise ConfigError(f"temperature must be a number, got {type(temp).__name__}")
+        if not 0.0 <= temp <= 2.0:
+            raise ConfigError(f"temperature must be between 0.0 and 2.0, got {temp}")
+
+    # Validate max_output_tokens (1 to 100000)
+    if config.get("max_output_tokens") is not None:
+        tokens = config["max_output_tokens"]
+        if not isinstance(tokens, int):
+            raise ConfigError(f"max_output_tokens must be an integer, got {type(tokens).__name__}")
+        if tokens < 1 or tokens > 100000:
+            raise ConfigError(f"max_output_tokens must be between 1 and 100000, got {tokens}")
+
+    # Validate max_retries (1 to 10)
+    if config.get("max_retries") is not None:
+        retries = config["max_retries"]
+        if not isinstance(retries, int):
+            raise ConfigError(f"max_retries must be an integer, got {type(retries).__name__}")
+        if retries < 1 or retries > 10:
+            raise ConfigError(f"max_retries must be between 1 and 10, got {retries}")
+
+    # Validate warning_limit_tokens (must be positive)
+    if config.get("warning_limit_tokens") is not None:
+        warning_limit = config["warning_limit_tokens"]
+        if not isinstance(warning_limit, int):
+            raise ConfigError(f"warning_limit_tokens must be an integer, got {type(warning_limit).__name__}")
+        if warning_limit < 1:
+            raise ConfigError(f"warning_limit_tokens must be positive, got {warning_limit}")
+
+    # Validate hook_timeout (must be positive)
+    if config.get("hook_timeout") is not None:
+        hook_timeout = config["hook_timeout"]
+        if not isinstance(hook_timeout, int):
+            raise ConfigError(f"hook_timeout must be an integer, got {type(hook_timeout).__name__}")
+        if hook_timeout < 1:
+            raise ConfigError(f"hook_timeout must be positive, got {hook_timeout}")
+
+
+def load_config() -> GACConfig:
     """Load configuration from $HOME/.gac.env, then ./.gac.env, then environment variables."""
     user_config = Path.home() / ".gac.env"
     if user_config.exists():
@@ -23,7 +99,7 @@ def load_config() -> dict[str, str | int | float | bool | None]:
     if project_gac_env.exists():
         load_dotenv(project_gac_env, override=True)
 
-    config = {
+    config: GACConfig = {
         "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)),
@@ -35,6 +111,8 @@ def load_config() -> dict[str, str | int | float | bool | None]:
         "skip_secret_scan": os.getenv("GAC_SKIP_SECRET_SCAN", str(EnvDefaults.SKIP_SECRET_SCAN)).lower()
         in ("true", "1", "yes", "on"),
         "no_tiktoken": os.getenv("GAC_NO_TIKTOKEN", str(EnvDefaults.NO_TIKTOKEN)).lower() in ("true", "1", "yes", "on"),
+        "no_verify_ssl": os.getenv("GAC_NO_VERIFY_SSL", str(EnvDefaults.NO_VERIFY_SSL)).lower()
+        in ("true", "1", "yes", "on"),
         "verbose": os.getenv("GAC_VERBOSE", str(EnvDefaults.VERBOSE)).lower() in ("true", "1", "yes", "on"),
         "system_prompt_path": os.getenv("GAC_SYSTEM_PROMPT_PATH"),
         "language": os.getenv("GAC_LANGUAGE"),
@@ -43,4 +121,5 @@ def load_config() -> dict[str, str | int | float | bool | None]:
         "hook_timeout": int(os.getenv("GAC_HOOK_TIMEOUT", EnvDefaults.HOOK_TIMEOUT)),
     }
 
+    validate_config(config)
     return config

gac/config_cli.py

@@ -10,7 +10,7 @@ GAC_ENV_PATH = Path.home() / ".gac.env"
 
 
 @click.group()
-def config():
+def config() -> None:
     """Manage gac configuration."""
     pass
 
@@ -18,6 +18,8 @@ def config():
 @config.command()
 def show() -> None:
     """Show all current config values."""
+    from dotenv import dotenv_values
+
     project_env_path = Path(".gac.env")
     user_exists = GAC_ENV_PATH.exists()
     project_exists = project_env_path.exists()
@@ -29,9 +31,14 @@ def show() -> None:
 
     if user_exists:
         click.echo(f"User config ({GAC_ENV_PATH}):")
-        with open(GAC_ENV_PATH, encoding="utf-8") as f:
-            for line in f:
-                click.echo(line.rstrip())
+        user_config = dotenv_values(str(GAC_ENV_PATH))
+        for key, value in sorted(user_config.items()):
+            if value is not None:
+                if any(sensitive in key.lower() for sensitive in ["key", "token", "secret"]):
+                    display_value = "***hidden***"
+                else:
+                    display_value = value
+                click.echo(f"  {key}={display_value}")
     else:
         click.echo("No $HOME/.gac.env found.")
 
@@ -39,9 +46,14 @@ def show() -> None:
         if user_exists:
             click.echo("")
         click.echo("Project config (./.gac.env):")
-        with open(project_env_path, encoding="utf-8") as f:
-            for line in f:
-                click.echo(line.rstrip())
+        project_config = dotenv_values(str(project_env_path))
+        for key, value in sorted(project_config.items()):
+            if value is not None:
+                if any(sensitive in key.lower() for sensitive in ["key", "token", "secret"]):
+                    display_value = "***hidden***"
+                else:
+                    display_value = value
+                click.echo(f"  {key}={display_value}")
         click.echo("")
         click.echo("Note: Project-level .gac.env overrides $HOME/.gac.env values for any duplicated variables.")
     else:

gac/constants/__init__.py

@@ -0,0 +1,34 @@
+"""Constants for the Git Auto Commit (gac) project.
+
+This package provides all constants used throughout gac, organized into
+logical modules:
+
+- defaults: Environment defaults, provider defaults, logging, and utility constants
+- file_patterns: File pattern matching and importance weighting
+- languages: Language code mappings for internationalization
+- commit: Git file status and commit message constants
+
+All constants are re-exported from this package for backward compatibility.
+"""
+
+from gac.constants.commit import CommitMessageConstants, FileStatus
+from gac.constants.defaults import EnvDefaults, Logging, ProviderDefaults, Utility
+from gac.constants.file_patterns import CodePatternImportance, FilePatterns, FileTypeImportance
+from gac.constants.languages import Languages
+
+__all__ = [
+    # From defaults
+    "EnvDefaults",
+    "ProviderDefaults",
+    "Logging",
+    "Utility",
+    # From file_patterns
+    "FilePatterns",
+    "FileTypeImportance",
+    "CodePatternImportance",
+    # From languages
+    "Languages",
+    # From commit
+    "FileStatus",
+    "CommitMessageConstants",
+]

gac/constants/commit.py

@@ -0,0 +1,63 @@
+"""Constants for git operations and commit message generation."""
+
+from enum import Enum
+
+
+class FileStatus(Enum):
+    """File status for Git operations."""
+
+    MODIFIED = "M"
+    ADDED = "A"
+    DELETED = "D"
+    RENAMED = "R"
+    COPIED = "C"
+    UNTRACKED = "?"
+
+
+class CommitMessageConstants:
+    """Constants for commit message generation and cleaning."""
+
+    # Conventional commit type prefixes
+    CONVENTIONAL_PREFIXES: list[str] = [
+        "feat",
+        "fix",
+        "docs",
+        "style",
+        "refactor",
+        "perf",
+        "test",
+        "build",
+        "ci",
+        "chore",
+    ]
+
+    # XML tags that may leak from prompt templates into AI responses
+    XML_TAGS_TO_REMOVE: list[str] = [
+        "<git-status>",
+        "</git-status>",
+        "<git_status>",
+        "</git_status>",
+        "<git-diff>",
+        "</git-diff>",
+        "<git_diff>",
+        "</git_diff>",
+        "<repository_context>",
+        "</repository_context>",
+        "<instructions>",
+        "</instructions>",
+        "<format>",
+        "</format>",
+        "<conventions>",
+        "</conventions>",
+    ]
+
+    # Indicators that mark the start of the actual commit message in AI responses
+    COMMIT_INDICATORS: list[str] = [
+        "# Your commit message:",
+        "Your commit message:",
+        "The commit message is:",
+        "Here's the commit message:",
+        "Commit message:",
+        "Final commit message:",
+        "# Commit Message",
+    ]

gac/constants/defaults.py

@@ -0,0 +1,40 @@
+"""Default values for environment variables and provider configurations."""
+
+import os
+
+
+class EnvDefaults:
+    """Default values for environment variables."""
+
+    MAX_RETRIES: int = 3
+    TEMPERATURE: float = 1
+    MAX_OUTPUT_TOKENS: int = 4096  # includes reasoning tokens
+    WARNING_LIMIT_TOKENS: int = 32768
+    ALWAYS_INCLUDE_SCOPE: bool = False
+    SKIP_SECRET_SCAN: bool = False
+    VERBOSE: bool = False
+    NO_TIKTOKEN: bool = False
+    NO_VERIFY_SSL: bool = False  # Skip SSL certificate verification (for corporate proxies)
+    HOOK_TIMEOUT: int = 120  # Timeout for pre-commit and lefthook hooks in seconds
+
+
+class ProviderDefaults:
+    """Default values for provider configurations."""
+
+    HTTP_TIMEOUT: int = 120  # seconds - timeout for HTTP requests to LLM providers
+
+
+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
+    MAX_DISPLAYED_SECRET_LENGTH: int = 50  # Maximum length for displaying secrets

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