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

gac/cli.py

@@ -6,29 +6,40 @@ Defines the Click-based command-line interface and delegates execution to the ma
 """
 
 import logging
+import os
 import sys
 
 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_cli import config as config_cli
-from gac.constants import Logging
+from gac.constants import Languages, 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.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
 
 config = load_config()
 logger = logging.getLogger(__name__)
+console = Console()
 
 
 @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("--group", "-g", is_flag=True, help="Group changes into multiple logical commits")
+@click.option(
+    "--interactive", "-i", is_flag=True, help="Ask interactive questions to gather more context for the commit message"
+)
 @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("--message-only", is_flag=True, help="Output only the generated commit message without committing")
 @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")
@@ -43,6 +54,9 @@ logger = logging.getLogger(__name__)
 @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')")
+@click.option(
+    "--language", "-l", help="Override the language for commit messages (e.g., 'Spanish', 'es', 'zh-CN', 'ja')"
+)
 # Output options
 @click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
 @click.option(
@@ -60,12 +74,25 @@ logger = logging.getLogger(__name__)
 # Advanced options
 @click.option("--no-verify", is_flag=True, help="Skip pre-commit and lefthook hooks when committing")
 @click.option("--skip-secret-scan", is_flag=True, help="Skip security scan for secrets in staged changes")
+@click.option(
+    "--no-verify-ssl",
+    is_flag=True,
+    help="Skip SSL certificate verification (useful for corporate proxies)",
+)
+@click.option(
+    "--hook-timeout",
+    type=int,
+    default=0,
+    help="Timeout for pre-commit and lefthook hooks in seconds (0 to use configuration)",
+)
 # 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,
+    group: bool = False,
+    interactive: bool = False,
     log_level: str = str(config["log_level"]),
     one_liner: bool = False,
     push: bool = False,
@@ -75,11 +102,15 @@ def cli(
     yes: bool = False,
     hint: str = "",
     model: str | None = None,
+    language: str | None = None,
     version: bool = False,
     dry_run: bool = False,
+    message_only: bool = False,
     verbose: bool = False,
     no_verify: bool = False,
     skip_secret_scan: bool = False,
+    no_verify_ssl: bool = False,
+    hook_timeout: int = 0,
 ) -> None:
     """Git Auto Commit - Generate commit messages with AI."""
     if ctx.invoked_subcommand is None:
@@ -92,15 +123,32 @@ def cli(
         setup_logging(effective_log_level)
         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):
+            os.environ["GAC_NO_VERIFY_SSL"] = "true"
+            logger.info("SSL certificate verification disabled")
+
+        # Validate incompatible flag combinations
+        if message_only and group:
+            console.print("[red]Error: --message-only and --group options are mutually exclusive[/red]")
+            console.print("[yellow]--message-only is for generating a single commit message for external use[/yellow]")
+            console.print("[yellow]--group is for organizing multiple commits within the current workflow[/yellow]")
+            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))
 
         # Determine if verbose mode should be enabled based on -v flag or verbose config setting
         use_verbose = bool(verbose or config.get("verbose", False))
 
+        # Resolve language code to full name if provided
+        resolved_language = Languages.resolve_code(language) if language else None
+
         try:
             main(
                 stage_all=add_all,
+                group=group,
+                interactive=interactive,
                 model=model,
                 hint=hint,
                 one_liner=one_liner,
@@ -110,9 +158,12 @@ def cli(
                 push=push,
                 quiet=quiet,
                 dry_run=dry_run,
+                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)),
+                language=resolved_language,
+                hook_timeout=hook_timeout if hook_timeout > 0 else int(config.get("hook_timeout", 120) or 120),
             )
         except Exception as e:
             handle_error(e, exit_program=True)
@@ -122,6 +173,8 @@ def cli(
 
         ctx.obj = {
             "add_all": add_all,
+            "group": group,
+            "interactive": interactive,
             "log_level": log_level,
             "one_liner": one_liner,
             "push": push,
@@ -131,17 +184,34 @@ def cli(
             "yes": yes,
             "hint": hint,
             "model": model,
+            "language": language,
             "version": version,
             "dry_run": dry_run,
+            "message_only": message_only,
             "verbose": verbose,
             "no_verify": no_verify,
             "skip_secret_scan": skip_secret_scan,
+            "no_verify_ssl": no_verify_ssl,
+            "hook_timeout": hook_timeout,
         }
 
 
+cli.add_command(auth_cli)
 cli.add_command(config_cli)
-cli.add_command(init_cli)
 cli.add_command(diff_cli)
+cli.add_command(init_cli)
+cli.add_command(language_cli)
+cli.add_command(model_cli)
+
+
+@click.command(context_settings=language_cli.context_settings)
+@click.pass_context
+def lang(ctx):
+    """Set the language for commit messages interactively. (Alias for 'language')"""
+    ctx.forward(language_cli)
+
+
+cli.add_command(lang)  # Add the lang alias
 
 if __name__ == "__main__":
     cli()

gac/config.py

@@ -1,6 +1,6 @@
 """Configuration loading for gac.
 
-Handles environment variable and .env file precedence for application settings.
+Handles environment variable and .gac.env file precedence for application settings.
 """
 
 import os
@@ -9,22 +9,70 @@ from pathlib import Path
 from dotenv import load_dotenv
 
 from gac.constants import EnvDefaults, Logging
+from gac.errors import ConfigError
+
+
+def validate_config(config: dict[str, str | int | float | bool | None]) -> 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() -> dict[str, str | int | float | bool | None]:
-    """Load configuration from $HOME/.gac.env, then ./.gac.env or ./.env, then environment variables."""
+    """Load configuration from $HOME/.gac.env, then ./.gac.env, then environment variables."""
     user_config = Path.home() / ".gac.env"
     if user_config.exists():
         load_dotenv(user_config)
 
-    # Check for both .gac.env and .env in project directory
+    # Check for .gac.env in project directory
     project_gac_env = Path(".gac.env")
-    project_env = Path(".env")
 
     if project_gac_env.exists():
         load_dotenv(project_gac_env, override=True)
-    elif project_env.exists():
-        load_dotenv(project_env, override=True)
 
     config = {
         "model": os.getenv("GAC_MODEL"),
@@ -37,7 +85,16 @@ def load_config() -> dict[str, str | int | float | bool | None]:
         in ("true", "1", "yes", "on"),
         "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"),
+        "translate_prefixes": os.getenv("GAC_TRANSLATE_PREFIXES", "false").lower() in ("true", "1", "yes", "on"),
+        "rtl_confirmed": os.getenv("GAC_RTL_CONFIRMED", "false").lower() in ("true", "1", "yes", "on"),
+        "hook_timeout": int(os.getenv("GAC_HOOK_TIMEOUT", EnvDefaults.HOOK_TIMEOUT)),
     }
 
+    validate_config(config)
     return config

gac/config_cli.py

@@ -18,13 +18,34 @@ def config():
 @config.command()
 def show() -> None:
     """Show all current config values."""
-    if not GAC_ENV_PATH.exists():
+    project_env_path = Path(".gac.env")
+    user_exists = GAC_ENV_PATH.exists()
+    project_exists = project_env_path.exists()
+
+    if not user_exists and not project_exists:
         click.echo("No $HOME/.gac.env found.")
+        click.echo("No project-level .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())
+
+    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())
+    else:
+        click.echo("No $HOME/.gac.env found.")
+
+    if project_exists:
+        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())
+        click.echo("")
+        click.echo("Note: Project-level .gac.env overrides $HOME/.gac.env values for any duplicated variables.")
+    else:
+        click.echo("No project-level .gac.env found.")
 
 
 @config.command()

gac/constants.py

@@ -20,11 +20,20 @@ class EnvDefaults:
 
     MAX_RETRIES: int = 3
     TEMPERATURE: float = 1
-    MAX_OUTPUT_TOKENS: int = 1024  # includes reasoning tokens
-    WARNING_LIMIT_TOKENS: int = 16384
+    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:
@@ -150,3 +159,170 @@ class CodePatternImportance:
         r"\+\s*(test|describe|it|should)\s*\(": 1.1,  # Test definitions
         r"\+\s*(assert|expect)": 1.0,  # Assertions
     }
+
+
+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
+
+
+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",
+    ]