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

gac/__init__.py

@@ -1,15 +1,13 @@
 """Git Auto Commit (gac) - Generate commit messages using AI."""
 
+from gac import init_cli
 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
+from gac.prompt import build_prompt
 
 __all__ = [
     "__version__",
-    "generate_commit_message",
     "build_prompt",
-    "clean_commit_message",
-    "get_staged_files",
-    "push_changes",
+    "generate_commit_message",
+    "init_cli",
 ]

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "3.8.1"
+__version__ = "3.10.10"

gac/ai_utils.py

@@ -3,11 +3,13 @@
 This module provides utility functions that support the AI provider implementations.
 """
 
+import json
 import logging
 import os
 import time
+from collections.abc import Callable
 from functools import lru_cache
-from typing import Any
+from typing import Any, cast
 
 import tiktoken
 from rich.console import Console
@@ -15,6 +17,8 @@ from rich.status import Status
 
 from gac.constants import EnvDefaults, Utility
 from gac.errors import AIError
+from gac.oauth import QwenOAuthProvider, refresh_token_if_expired
+from gac.oauth.token_store import TokenStore
 from gac.providers import SUPPORTED_PROVIDERS
 
 logger = logging.getLogger(__name__)
@@ -40,7 +44,7 @@ def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: st
     try:
         encoding = get_encoding(model)
         return len(encoding.encode(text))
-    except Exception as e:
+    except (KeyError, UnicodeError, ValueError) as e:
         logger.error(f"Error counting tokens: {e}")
         # Fallback to rough estimation (4 chars per token on average)
         return len(text) // 4
@@ -53,7 +57,7 @@ def extract_text_content(content: str | list[dict[str, str]] | dict[str, Any]) -
     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"]  # type: ignore[no-any-return]
+        return cast(str, content["content"])
     return ""
 
 
@@ -70,36 +74,13 @@ def get_encoding(model: str) -> tiktoken.Encoding:
     except KeyError:
         # Fall back to default encoding if model not found
         return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
-    except Exception:
+    except (OSError, ConnectionError):
         # If there are any network/SSL issues, fall back to default encoding
         return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
 
 
-def _classify_error(error_str: str) -> str:
-    """Classify error types based on error message content."""
-    error_str = error_str.lower()
-
-    if (
-        "api key" in error_str
-        or "unauthorized" in error_str
-        or "authentication" in error_str
-        or "invalid api key" in error_str
-    ):
-        return "authentication"
-    elif "timeout" in error_str or "timed out" in error_str or "request timeout" in error_str:
-        return "timeout"
-    elif "rate limit" in error_str or "too many requests" in error_str or "rate limit exceeded" in error_str:
-        return "rate_limit"
-    elif "connect" in error_str or "network" in error_str or "network connection failed" in error_str:
-        return "connection"
-    elif "model" in error_str or "not found" in error_str or "model not found" in error_str:
-        return "model"
-    else:
-        return "unknown"
-
-
 def generate_with_retries(
-    provider_funcs: dict,
+    provider_funcs: dict[str, Callable[..., str]],
     model: str,
     messages: list[dict[str, str]],
     temperature: float,
@@ -126,9 +107,6 @@ def generate_with_retries(
 
     # Load Claude Code token from TokenStore if needed
     if provider == "claude-code":
-        from gac.oauth import refresh_token_if_expired
-        from gac.oauth.token_store import TokenStore
-
         # Check token expiry and refresh if needed
         if not refresh_token_if_expired(quiet=True):
             raise AIError.authentication_error(
@@ -147,8 +125,6 @@ def generate_with_retries(
 
     # Check Qwen OAuth token expiry and refresh if needed
     if provider == "qwen":
-        from gac.oauth import QwenOAuthProvider, TokenStore
-
         oauth_provider = QwenOAuthProvider(TokenStore())
         token = oauth_provider.get_token()
         if not token:
@@ -166,7 +142,7 @@ def generate_with_retries(
                     console.print("[green]✓ Authentication successful![/green]\n")
             except AIError:
                 raise
-            except Exception as e:
+            except (ValueError, KeyError, json.JSONDecodeError, ConnectionError, OSError) as e:
                 raise AIError.authentication_error(
                     f"Qwen authentication failed: {e}. Run 'gac auth qwen login' to authenticate manually."
                 ) from e
@@ -183,7 +159,7 @@ def generate_with_retries(
         spinner = Status(f"Generating {message_type} with {provider} {model_name}...")
         spinner.start()
 
-    last_exception = None
+    last_exception: Exception | None = None
     last_error_type = "unknown"
 
     for attempt in range(max_retries):
@@ -208,14 +184,14 @@ def generate_with_retries(
                     console.print(f"✓ Generated {message_type} with {provider} {model_name}")
 
             if content is not None and content.strip():
-                return content.strip()  # type: ignore[no-any-return]
+                return content.strip()
             else:
                 logger.warning(f"Empty or None content received from {provider} {model_name}: {repr(content)}")
                 raise AIError.model_error("Empty response from AI model")
 
-        except Exception as e:
+        except AIError as e:
             last_exception = e
-            error_type = _classify_error(str(e))
+            error_type = e.error_type
             last_error_type = error_type
 
             # For authentication and model errors, don't retry
@@ -223,23 +199,16 @@ def generate_with_retries(
                 if spinner and not skip_success_message:
                     spinner.stop()
                     console.print(f"✗ Failed to generate {message_type} with {provider} {model_name}")
-
-                # Create the appropriate error type based on classification
-                if error_type == "authentication":
-                    raise AIError.authentication_error(f"AI generation failed: {str(e)}") from e
-                elif error_type == "model":
-                    raise AIError.model_error(f"AI generation failed: {str(e)}") from e
+                raise
 
             if attempt < max_retries - 1:
                 # Exponential backoff
                 wait_time = 2**attempt
                 if not quiet and not skip_success_message:
                     if attempt == 0:
-                        logger.warning(f"AI generation failed, retrying in {wait_time}s: {str(e)}")
+                        logger.warning(f"AI generation failed, retrying in {wait_time}s: {e}")
                     else:
-                        logger.warning(
-                            f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {str(e)}"
-                        )
+                        logger.warning(f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {e}")
 
                 if spinner and not skip_success_message:
                     for i in range(wait_time, 0, -1):
@@ -250,7 +219,7 @@ def generate_with_retries(
             else:
                 num_retries = max_retries
                 retry_word = "retry" if num_retries == 1 else "retries"
-                logger.error(f"AI generation failed after {num_retries} {retry_word}: {str(e)}")
+                logger.error(f"AI generation failed after {num_retries} {retry_word}: {e}")
 
     if spinner and not skip_success_message:
         spinner.stop()

gac/cli.py

@@ -8,13 +8,14 @@ Defines the Click-based command-line interface and delegates execution to the ma
 import logging
 import os
 import sys
+from typing import Any
 
 import click
 from rich.console import Console
 
 from gac import __version__
 from gac.auth_cli import auth as auth_cli
-from gac.config import load_config
+from gac.config import GACConfig, load_config
 from gac.config_cli import config as config_cli
 from gac.constants import Languages, Logging
 from gac.diff_cli import diff as diff_cli
@@ -24,8 +25,9 @@ from gac.language_cli import language as language_cli
 from gac.main import main
 from gac.model_cli import model as model_cli
 from gac.utils import setup_logging
+from gac.workflow_context import CLIOptions
 
-config = load_config()
+config: GACConfig = load_config()
 logger = logging.getLogger(__name__)
 console = Console()
 
@@ -124,7 +126,7 @@ def cli(
         logger.info("Starting gac")
 
         # Set SSL verification environment variable if flag is used or config is set
-        if no_verify_ssl or config.get("no_verify_ssl", False):
+        if no_verify_ssl or config["no_verify_ssl"]:
             os.environ["GAC_NO_VERIFY_SSL"] = "true"
             logger.info("SSL certificate verification disabled")
 
@@ -136,16 +138,16 @@ def cli(
             sys.exit(1)
 
         # Determine if we should infer scope based on -s flag or always_include_scope setting
-        infer_scope = bool(scope or config.get("always_include_scope", False))
+        infer_scope = bool(scope or config["always_include_scope"])
 
         # Determine if verbose mode should be enabled based on -v flag or verbose config setting
-        use_verbose = bool(verbose or config.get("verbose", False))
+        use_verbose = bool(verbose or config["verbose"])
 
         # Resolve language code to full name if provided
         resolved_language = Languages.resolve_code(language) if language else None
 
         try:
-            main(
+            opts = CLIOptions(
                 stage_all=add_all,
                 group=group,
                 interactive=interactive,
@@ -161,15 +163,17 @@ def cli(
                 message_only=message_only,
                 verbose=use_verbose,
                 no_verify=no_verify,
-                skip_secret_scan=skip_secret_scan or bool(config.get("skip_secret_scan", False)),
+                skip_secret_scan=skip_secret_scan or config["skip_secret_scan"],
                 language=resolved_language,
-                hook_timeout=hook_timeout if hook_timeout > 0 else int(config.get("hook_timeout", 120) or 120),
+                hook_timeout=hook_timeout if hook_timeout > 0 else config["hook_timeout"],
             )
+            exit_code = main(opts)
+            sys.exit(exit_code)
         except Exception as e:
             handle_error(e, exit_program=True)
     else:
         # Determine if we should infer scope based on -s flag or always_include_scope setting
-        infer_scope = bool(scope or config.get("always_include_scope", False))
+        infer_scope = bool(scope or config["always_include_scope"])
 
         ctx.obj = {
             "add_all": add_all,
@@ -206,7 +210,7 @@ cli.add_command(model_cli)
 
 @click.command(context_settings=language_cli.context_settings)
 @click.pass_context
-def lang(ctx):
+def lang(ctx: Any) -> None:
     """Set the language for commit messages interactively. (Alias for 'language')"""
     ctx.forward(language_cli)
 

gac/commit_executor.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Commit execution logic for gac."""
+
+import logging
+
+from rich.console import Console
+
+from gac.errors import GitError
+from gac.git import get_staged_files, push_changes
+from gac.workflow_utils import execute_commit
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+class CommitExecutor:
+    """Handles commit creation and related operations."""
+
+    def __init__(self, dry_run: bool = False, quiet: bool = False, no_verify: bool = False, hook_timeout: int = 120):
+        self.dry_run = dry_run
+        self.quiet = quiet
+        self.no_verify = no_verify
+        self.hook_timeout = hook_timeout
+
+    def create_commit(self, commit_message: str) -> None:
+        """Create a single commit with the given message."""
+        if self.dry_run:
+            console.print("[yellow]Dry run: Commit message generated but not applied[/yellow]")
+            console.print("Would commit with message:")
+            from rich.panel import Panel
+
+            console.print(Panel(commit_message, title="Commit Message", border_style="cyan"))
+            staged_files = get_staged_files(existing_only=False)
+            console.print(f"Would commit {len(staged_files)} files")
+            logger.info(f"Would commit {len(staged_files)} files")
+        else:
+            execute_commit(commit_message, self.no_verify, self.hook_timeout)
+
+    def push_to_remote(self) -> None:
+        """Push changes to remote repository.
+
+        Raises:
+            GitError: If push fails or remote is not configured.
+        """
+        if self.dry_run:
+            staged_files = get_staged_files(existing_only=False)
+            logger.info("Dry run: Would push changes")
+            logger.info(f"Would push {len(staged_files)} files")
+            console.print("[yellow]Dry run: Would push changes[/yellow]")
+            console.print(f"Would push {len(staged_files)} files")
+            return
+
+        if push_changes():
+            logger.info("Changes pushed successfully")
+            if not self.quiet:
+                console.print("[green]Changes pushed successfully[/green]")
+        else:
+            console.print("[red]Failed to push changes. Check your remote configuration and network connection.[/red]")
+            raise GitError("Failed to push changes")

gac/config.py

@@ -5,6 +5,7 @@ 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
 
@@ -12,7 +13,31 @@ from gac.constants import EnvDefaults, Logging
 from gac.errors import ConfigError
 
 
-def validate_config(config: dict[str, str | int | float | bool | None]) -> 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:
@@ -62,7 +87,7 @@ def validate_config(config: dict[str, str | int | float | bool | None]) -> None:
             raise ConfigError(f"hook_timeout must be positive, got {hook_timeout}")
 
 
-def load_config() -> dict[str, str | int | float | bool | None]:
+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():
@@ -74,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)),

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