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

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "1.13.0"
+__version__ = "3.6.0"

gac/ai.py

@@ -9,27 +9,7 @@ import logging
 from gac.ai_utils import generate_with_retries
 from gac.constants import EnvDefaults
 from gac.errors import AIError
-from gac.providers import (
-    call_anthropic_api,
-    call_cerebras_api,
-    call_chutes_api,
-    call_custom_anthropic_api,
-    call_custom_openai_api,
-    call_deepseek_api,
-    call_fireworks_api,
-    call_gemini_api,
-    call_groq_api,
-    call_lmstudio_api,
-    call_minimax_api,
-    call_ollama_api,
-    call_openai_api,
-    call_openrouter_api,
-    call_streamlake_api,
-    call_synthetic_api,
-    call_together_api,
-    call_zai_api,
-    call_zai_coding_api,
-)
+from gac.providers import PROVIDER_REGISTRY
 
 logger = logging.getLogger(__name__)
 
@@ -41,11 +21,14 @@ def generate_commit_message(
     max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
     max_retries: int = EnvDefaults.MAX_RETRIES,
     quiet: bool = False,
+    is_group: bool = False,
+    skip_success_message: bool = False,
+    task_description: str = "commit message",
 ) -> str:
     """Generate a commit message using direct API calls to AI providers.
 
     Args:
-        model: The model to use in provider:model_name format (e.g., 'anthropic:claude-3-5-haiku-latest')
+        model: The model to use in provider:model_name format (e.g., 'anthropic:claude-haiku-4-5')
         prompt: Either a string prompt (for backward compatibility) or tuple of (system_prompt, user_prompt)
         temperature: Controls randomness (0.0-1.0), lower values are more deterministic
         max_tokens: Maximum tokens in the response
@@ -59,7 +42,7 @@ def generate_commit_message(
         AIError: If generation fails after max_retries attempts
 
     Example:
-        >>> model = "anthropic:claude-3-5-haiku-latest"
+        >>> model = "anthropic:claude-haiku-4-5"
         >>> system_prompt, user_prompt = build_prompt("On branch main", "diff --git a/README.md b/README.md")
         >>> generate_commit_message(model, (system_prompt, user_prompt))
         'docs: Update README with installation instructions'
@@ -81,39 +64,19 @@ def generate_commit_message(
             {"role": "user", "content": user_prompt},
         ]
 
-    # Provider functions mapping
-    provider_funcs = {
-        "anthropic": call_anthropic_api,
-        "cerebras": call_cerebras_api,
-        "chutes": call_chutes_api,
-        "custom-anthropic": call_custom_anthropic_api,
-        "custom-openai": call_custom_openai_api,
-        "deepseek": call_deepseek_api,
-        "fireworks": call_fireworks_api,
-        "gemini": call_gemini_api,
-        "groq": call_groq_api,
-        "lm-studio": call_lmstudio_api,
-        "minimax": call_minimax_api,
-        "ollama": call_ollama_api,
-        "openai": call_openai_api,
-        "openrouter": call_openrouter_api,
-        "streamlake": call_streamlake_api,
-        "synthetic": call_synthetic_api,
-        "together": call_together_api,
-        "zai": call_zai_api,
-        "zai-coding": call_zai_coding_api,
-    }
-
     # Generate the commit message using centralized retry logic
     try:
         return generate_with_retries(
-            provider_funcs=provider_funcs,
+            provider_funcs=PROVIDER_REGISTRY,
             model=model,
             messages=messages,
             temperature=temperature,
             max_tokens=max_tokens,
             max_retries=max_retries,
             quiet=quiet,
+            is_group=is_group,
+            skip_success_message=skip_success_message,
+            task_description=task_description,
         )
     except AIError:
         # Re-raise AIError exceptions as-is to preserve error classification
@@ -121,3 +84,26 @@ def generate_commit_message(
     except Exception as e:
         logger.error(f"Failed to generate commit message: {e}")
         raise AIError.model_error(f"Failed to generate commit message: {e}") from e
+
+
+def generate_grouped_commits(
+    model: str,
+    prompt: list[dict[str, str]],
+    temperature: float,
+    max_tokens: int,
+    max_retries: int,
+    quiet: bool = False,
+    skip_success_message: bool = False,
+) -> str:
+    """Generate grouped commits JSON response."""
+    return generate_commit_message(
+        model=model,
+        prompt=prompt,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_retries=max_retries,
+        quiet=quiet,
+        is_group=True,
+        skip_success_message=skip_success_message,
+        task_description="commit message",
+    )

gac/ai_utils.py

@@ -4,17 +4,28 @@ This module provides utility functions that support the AI provider implementati
 """
 
 import logging
+import os
 import time
 from functools import lru_cache
 from typing import Any
 
 import tiktoken
-from halo import Halo
+from rich.console import Console
+from rich.status import Status
 
-from gac.constants import Utility
+from gac.constants import EnvDefaults, Utility
 from gac.errors import AIError
+from gac.providers import SUPPORTED_PROVIDERS
 
 logger = logging.getLogger(__name__)
+console = Console()
+
+
+@lru_cache(maxsize=1)
+def _should_skip_tiktoken_counting() -> bool:
+    """Return True when token counting should avoid tiktoken calls entirely."""
+    value = os.getenv("GAC_NO_TIKTOKEN", str(EnvDefaults.NO_TIKTOKEN))
+    return value.lower() in ("true", "1", "yes", "on")
 
 
 def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: str) -> int:
@@ -23,11 +34,15 @@ def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: st
     if not text:
         return 0
 
+    if _should_skip_tiktoken_counting():
+        return len(text) // 4
+
     try:
         encoding = get_encoding(model)
         return len(encoding.encode(text))
     except Exception as e:
         logger.error(f"Error counting tokens: {e}")
+        # Fallback to rough estimation (4 chars per token on average)
         return len(text) // 4
 
 
@@ -45,10 +60,18 @@ def extract_text_content(content: str | list[dict[str, str]] | dict[str, Any]) -
 @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
+    provider, model_name = model.split(":", 1) if ":" in model else (None, model)
+
+    if provider != "openai":
+        return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
+
     try:
         return tiktoken.encoding_for_model(model_name)
     except KeyError:
+        # Fall back to default encoding if model not found
+        return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
+    except Exception:
+        # If there are any network/SSL issues, fall back to default encoding
         return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
 
 
@@ -83,6 +106,9 @@ def generate_with_retries(
     max_tokens: int,
     max_retries: int,
     quiet: bool = False,
+    is_group: bool = False,
+    skip_success_message: bool = False,
+    task_description: str = "commit message",
 ) -> str:
     """Generate content with retry logic using direct API calls."""
     # Parse model string to determine provider and actual model
@@ -92,38 +118,22 @@ def generate_with_retries(
     provider, model_name = model.split(":", 1)
 
     # Validate provider
-    supported_providers = [
-        "anthropic",
-        "cerebras",
-        "chutes",
-        "deepseek",
-        "fireworks",
-        "gemini",
-        "groq",
-        "lm-studio",
-        "minimax",
-        "ollama",
-        "openai",
-        "openrouter",
-        "streamlake",
-        "synthetic",
-        "together",
-        "zai",
-        "zai-coding",
-        "custom-anthropic",
-        "custom-openai",
-    ]
-    if provider not in supported_providers:
-        raise AIError.model_error(f"Unsupported provider: {provider}. Supported providers: {supported_providers}")
+    if provider not in SUPPORTED_PROVIDERS:
+        raise AIError.model_error(f"Unsupported provider: {provider}. Supported providers: {SUPPORTED_PROVIDERS}")
 
     if not messages:
         raise AIError.model_error("No messages provided for AI generation")
 
     # Set up spinner
+    if is_group:
+        message_type = f"grouped {task_description}s"
+    else:
+        message_type = task_description
+
     if quiet:
         spinner = None
     else:
-        spinner = Halo(text=f"Generating commit message with {provider} {model_name}...", spinner="dots")
+        spinner = Status(f"Generating {message_type} with {provider} {model_name}...")
         spinner.start()
 
     last_exception = None
@@ -131,9 +141,9 @@ def generate_with_retries(
 
     for attempt in range(max_retries):
         try:
-            if not quiet and attempt > 0:
+            if not quiet and not skip_success_message and attempt > 0:
                 if spinner:
-                    spinner.text = f"Retry {attempt + 1}/{max_retries} with {provider} {model_name}..."
+                    spinner.update(f"Retry {attempt + 1}/{max_retries} with {provider} {model_name}...")
                 logger.info(f"Retry attempt {attempt + 1}/{max_retries}")
 
             # Call the appropriate provider function
@@ -144,7 +154,11 @@ def generate_with_retries(
             content = provider_func(model=model_name, messages=messages, temperature=temperature, max_tokens=max_tokens)
 
             if spinner:
-                spinner.succeed(f"Generated commit message with {provider} {model_name}")
+                if skip_success_message:
+                    spinner.stop()  # Stop spinner without showing success/failure
+                else:
+                    spinner.stop()
+                    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]
@@ -159,8 +173,9 @@ def generate_with_retries(
 
             # For authentication and model errors, don't retry
             if error_type in ["authentication", "model"]:
-                if spinner:
-                    spinner.fail(f"Failed to generate commit message with {provider} {model_name}")
+                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":
@@ -171,23 +186,33 @@ def generate_with_retries(
             if attempt < max_retries - 1:
                 # Exponential backoff
                 wait_time = 2**attempt
-                if not quiet:
-                    logger.warning(f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {str(e)}")
-
-                if spinner:
+                if not quiet and not skip_success_message:
+                    if attempt == 0:
+                        logger.warning(f"AI generation failed, retrying in {wait_time}s: {str(e)}")
+                    else:
+                        logger.warning(
+                            f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {str(e)}"
+                        )
+
+                if spinner and not skip_success_message:
                     for i in range(wait_time, 0, -1):
-                        spinner.text = f"Retry {attempt + 1}/{max_retries} in {i}s..."
+                        spinner.update(f"Retry {attempt + 1}/{max_retries} in {i}s...")
                         time.sleep(1)
                 else:
                     time.sleep(wait_time)
             else:
-                logger.error(f"AI generation failed after {max_retries} attempts: {str(e)}")
+                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)}")
 
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider} {model_name}")
+    if spinner and not skip_success_message:
+        spinner.stop()
+        console.print(f"✗ Failed to generate {message_type} with {provider} {model_name}")
 
     # If we get here, all retries failed - use the last classified error type
-    error_message = f"Failed to generate commit message after {max_retries} attempts"
+    num_retries = max_retries
+    retry_word = "retry" if num_retries == 1 else "retries"
+    error_message = f"Failed to generate {message_type} after {num_retries} {retry_word}"
     if last_error_type == "authentication":
         raise AIError.authentication_error(error_message) from last_exception
     elif last_error_type == "rate_limit":

gac/auth_cli.py

@@ -0,0 +1,69 @@
+"""CLI for authenticating Claude Code OAuth tokens.
+
+Provides a command to authenticate and re-authenticate Claude Code subscriptions.
+"""
+
+import logging
+
+import click
+
+from gac.oauth.claude_code import authenticate_and_save, load_stored_token
+from gac.utils import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option(
+    "--quiet",
+    "-q",
+    is_flag=True,
+    help="Suppress non-error output",
+)
+@click.option(
+    "--log-level",
+    default="INFO",
+    type=click.Choice(["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"], case_sensitive=False),
+    help="Set log level (default: INFO)",
+)
+def auth(quiet: bool = False, log_level: str = "INFO") -> None:
+    """Authenticate Claude Code OAuth token.
+
+    This command allows you to authenticate or re-authenticate your
+    Claude Code OAuth token when it expires or you want to refresh it.
+    It opens a browser window for the OAuth flow and saves the token
+    to ~/.gac.env.
+
+    The token is used by the Claude Code provider to access your
+    Claude Code subscription instead of requiring an Anthropic API key.
+    """
+    # Setup logging
+    if quiet:
+        effective_log_level = "ERROR"
+    else:
+        effective_log_level = log_level
+    setup_logging(effective_log_level)
+
+    # Check if there's an existing token
+    existing_token = load_stored_token()
+    if existing_token and not quiet:
+        click.echo("✓ Found existing Claude Code access token.")
+        click.echo()
+
+    if not quiet:
+        click.echo("🔐 Starting Claude Code OAuth authentication...")
+        click.echo("   Your browser will open automatically")
+        click.echo("   (Waiting up to 3 minutes for callback)")
+        click.echo()
+
+    # Perform OAuth authentication
+    success = authenticate_and_save(quiet=quiet)
+
+    if success:
+        if not quiet:
+            click.echo("✅ Claude Code authentication completed successfully!")
+            click.echo("   Your new token has been saved and is ready to use.")
+    else:
+        click.echo("❌ Claude Code authentication failed.")
+        click.echo("   Please try again or check your network connection.")
+        raise click.ClickException("Claude Code authentication failed")

gac/cli.py

@@ -9,26 +9,36 @@ import logging
 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 +53,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 +73,20 @@ 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(
+    "--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 +96,14 @@ 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,
+    hook_timeout: int = 0,
 ) -> None:
     """Git Auto Commit - Generate commit messages with AI."""
     if ctx.invoked_subcommand is None:
@@ -92,15 +116,27 @@ def cli(
         setup_logging(effective_log_level)
         logger.info("Starting gac")
 
+        # 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 +146,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 +161,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 +172,33 @@ 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,
+            "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
@@ -12,19 +12,16 @@ from gac.constants import EnvDefaults, Logging
 
 
 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 +34,13 @@ 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"),
         "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)),
     }
 
     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()