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

gac/__version__.py

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

gac/ai.py

@@ -5,73 +5,31 @@ It consolidates all AI-related functionality including token counting and commit
 """
 
 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.ai_utils import generate_with_retries
+from gac.constants import EnvDefaults
 from gac.errors import AIError
+from gac.providers import PROVIDER_REGISTRY
 
 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().count_tokens(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,
+    prompt: str | tuple[str, str] | list[dict[str, str]],
     temperature: float = EnvDefaults.TEMPERATURE,
     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 aisuite.
+    """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')
-        prompt: The formatted prompt containing diff and context
+        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
         max_retries: Number of retry attempts if generation fails
@@ -84,80 +42,68 @@ def generate_commit_message(
         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)
+        >>> 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'
     """
-    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
+    # Handle both old (string) and new (tuple) prompt formats
+    if isinstance(prompt, list):
+        messages = [{**msg} for msg in prompt]
+    elif isinstance(prompt, tuple):
+        system_prompt, user_prompt = prompt
+        messages = [
+            {"role": "system", "content": system_prompt or ""},
+            {"role": "user", "content": user_prompt},
+        ]
     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()
+        # Backward compatibility: treat string as user prompt with empty system prompt
+        user_prompt = str(prompt)
+        messages = [
+            {"role": "system", "content": ""},
+            {"role": "user", "content": user_prompt},
+        ]
+
+    # Generate the commit message using centralized retry logic
+    try:
+        return generate_with_retries(
+            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
+        raise
+    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
 
-    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
+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

@@ -0,0 +1,227 @@
+"""Utilities for AI provider integration for gac.
+
+This module provides utility functions that support the AI provider implementations.
+"""
+
+import logging
+import os
+import time
+from functools import lru_cache
+from typing import Any
+
+import tiktoken
+from rich.console import Console
+from rich.status import Status
+
+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:
+    """Count tokens in content using the model's tokenizer."""
+    text = extract_text_content(content)
+    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
+
+
+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"]  # type: ignore[no-any-return]
+    return ""
+
+
+@lru_cache(maxsize=1)
+def get_encoding(model: str) -> tiktoken.Encoding:
+    """Get the appropriate encoding for a given 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)
+
+
+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,
+    model: str,
+    messages: list[dict[str, str]],
+    temperature: float,
+    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
+    if ":" not in model:
+        raise AIError.model_error(f"Invalid model format. Expected 'provider:model', got '{model}'")
+
+    provider, model_name = model.split(":", 1)
+
+    # Validate provider
+    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 = Status(f"Generating {message_type} with {provider} {model_name}...")
+        spinner.start()
+
+    last_exception = None
+    last_error_type = "unknown"
+
+    for attempt in range(max_retries):
+        try:
+            if not quiet and not skip_success_message and attempt > 0:
+                if spinner:
+                    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
+            provider_func = provider_funcs.get(provider)
+            if not provider_func:
+                raise AIError.model_error(f"Provider function not found for: {provider}")
+
+            content = provider_func(model=model_name, messages=messages, temperature=temperature, max_tokens=max_tokens)
+
+            if spinner:
+                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]
+            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:
+            last_exception = e
+            error_type = _classify_error(str(e))
+            last_error_type = error_type
+
+            # For authentication and model errors, don't retry
+            if error_type in ["authentication", "model"]:
+                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
+
+            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)}")
+                    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.update(f"Retry {attempt + 1}/{max_retries} in {i}s...")
+                        time.sleep(1)
+                else:
+                    time.sleep(wait_time)
+            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)}")
+
+    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
+    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":
+        raise AIError.rate_limit_error(error_message) from last_exception
+    elif last_error_type == "timeout":
+        raise AIError.timeout_error(error_message) from last_exception
+    elif last_error_type == "connection":
+        raise AIError.connection_error(error_message) from last_exception
+    elif last_error_type == "model":
+        raise AIError.model_error(error_message) from last_exception
+    else:
+        raise AIError.unknown_error(error_message) from last_exception

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")