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

gac/model_cli.py

@@ -2,6 +2,7 @@
 
 import os
 from pathlib import Path
+from typing import cast
 
 import click
 import questionary
@@ -61,7 +62,7 @@ def _prompt_required_text(prompt: str) -> str | None:
             return None
         value = response.strip()
         if value:
-            return value  # type: ignore[no-any-return]
+            return cast(str, value)
         click.echo("A value is required. Please try again.")
 
 

gac/model_identifier.py

@@ -0,0 +1,70 @@
+"""Model identifier value object for parsing and validating model strings."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from gac.errors import ConfigError
+
+
+@dataclass(frozen=True)
+class ModelIdentifier:
+    """Represents a parsed model identifier in the format 'provider:model_name'.
+
+    This is an immutable value object that ensures model identifiers are
+    properly validated and provides convenient access to the components.
+
+    Attributes:
+        provider: The provider name (e.g., 'openai', 'anthropic', 'claude-code')
+        model_name: The model name (e.g., 'gpt-4o-mini', 'claude-haiku-4-5')
+    """
+
+    provider: str
+    model_name: str
+
+    @classmethod
+    def parse(cls, model_string: str) -> ModelIdentifier:
+        """Parse a model string into a ModelIdentifier.
+
+        Args:
+            model_string: A string in the format 'provider:model_name'
+
+        Returns:
+            A ModelIdentifier instance
+
+        Raises:
+            ConfigError: If the format is invalid or components are empty
+        """
+        normalized = model_string.strip()
+
+        if ":" not in normalized:
+            raise ConfigError(
+                f"Invalid model format: '{model_string}'. Expected 'provider:model', "
+                "e.g. 'openai:gpt-4o-mini'. Use 'gac config set model <provider:model>' "
+                "to update your configuration."
+            )
+
+        provider, model_name = normalized.split(":", 1)
+
+        if not provider or not model_name:
+            raise ConfigError(
+                f"Invalid model format: '{model_string}'. Both provider and model name "
+                "are required (example: 'anthropic:claude-haiku-4-5')."
+            )
+
+        return cls(provider=provider, model_name=model_name)
+
+    def __str__(self) -> str:
+        """Return the canonical string representation."""
+        return f"{self.provider}:{self.model_name}"
+
+    def starts_with_provider(self, prefix: str) -> bool:
+        """Check if the provider starts with the given prefix.
+
+        Args:
+            prefix: The prefix to check (e.g., 'claude-code', 'qwen')
+
+        Returns:
+            True if the provider matches or the full identifier starts with prefix
+        """
+        return self.provider == prefix or str(self).startswith(f"{prefix}:")

gac/oauth/claude_code.py

@@ -12,7 +12,7 @@ import time
 import webbrowser
 from dataclasses import dataclass
 from http.server import BaseHTTPRequestHandler, HTTPServer
-from typing import Any, TypedDict
+from typing import Any, TypedDict, cast
 from urllib.parse import parse_qs, urlencode, urlparse
 
 import httpx
@@ -331,7 +331,7 @@ def perform_oauth_flow(quiet: bool = False) -> dict[str, Any] | None:
         print("✓ Authorization code received")
         print("  Exchanging for access token...\n")
 
-    tokens = exchange_code_for_tokens(result.code, context)  # type: ignore[arg-type]
+    tokens = exchange_code_for_tokens(cast(str, result.code), context)
     if not tokens:
         if not quiet:
             print("❌ Token exchange failed. Please try again.")

gac/oauth/qwen_oauth.py

@@ -17,6 +17,7 @@ import httpx
 from gac import __version__
 from gac.errors import AIError
 from gac.oauth.token_store import OAuthToken, TokenStore
+from gac.utils import get_ssl_verify
 
 logger = logging.getLogger(__name__)
 
@@ -86,6 +87,7 @@ class QwenDeviceFlow:
                 "User-Agent": USER_AGENT,
             },
             timeout=30,
+            verify=get_ssl_verify(),
         )
 
         if not response.is_success:
@@ -132,6 +134,7 @@ class QwenDeviceFlow:
                         "User-Agent": USER_AGENT,
                     },
                     timeout=30,
+                    verify=get_ssl_verify(),
                 )
 
                 if response.is_success:
@@ -197,6 +200,7 @@ class QwenDeviceFlow:
                 "User-Agent": USER_AGENT,
             },
             timeout=30,
+            verify=get_ssl_verify(),
         )
 
         if not response.is_success:

gac/oauth/token_store.py

@@ -5,7 +5,7 @@ import os
 import stat
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TypedDict
+from typing import TypedDict, cast
 
 
 class OAuthToken(TypedDict, total=False):
@@ -65,7 +65,7 @@ class TokenStore:
         with open(token_path) as f:
             token_data = json.load(f)
             if isinstance(token_data, dict) and isinstance(token_data.get("access_token"), str):
-                return token_data  # type: ignore[return-value]
+                return cast(OAuthToken, token_data)
             return None
 
     def remove_token(self, provider: str) -> None:

gac/oauth_retry.py

@@ -0,0 +1,161 @@
+"""OAuth retry handling for expired tokens.
+
+This module provides a unified mechanism for handling OAuth token expiration
+across different providers (Claude Code, Qwen, etc.).
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+
+from gac.errors import AIError, ConfigError
+
+if TYPE_CHECKING:
+    from gac.workflow_context import WorkflowContext
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+@dataclass
+class OAuthProviderConfig:
+    """Configuration for OAuth retry handling for a specific provider."""
+
+    provider_prefix: str
+    display_name: str
+    manual_auth_hint: str
+    authenticate: Callable[[bool], bool]
+    extra_error_check: Callable[[AIError], bool] | None = None
+
+
+def _create_claude_code_authenticator() -> Callable[[bool], bool]:
+    """Create authenticator function for Claude Code."""
+
+    def authenticate(quiet: bool) -> bool:
+        from gac.oauth.claude_code import authenticate_and_save
+
+        return authenticate_and_save(quiet=quiet)
+
+    return authenticate
+
+
+def _create_qwen_authenticator() -> Callable[[bool], bool]:
+    """Create authenticator function for Qwen."""
+
+    def authenticate(quiet: bool) -> bool:
+        from gac.oauth import QwenOAuthProvider, TokenStore
+
+        try:
+            oauth_provider = QwenOAuthProvider(TokenStore())
+            oauth_provider.initiate_auth(open_browser=True)
+            return True
+        except (AIError, ConfigError, OSError):
+            return False
+
+    return authenticate
+
+
+def _claude_code_extra_check(e: AIError) -> bool:
+    """Extra check for Claude Code - verify error message contains expired/oauth."""
+    error_str = str(e).lower()
+    return "expired" in error_str or "oauth" in error_str
+
+
+OAUTH_PROVIDERS: list[OAuthProviderConfig] = [
+    OAuthProviderConfig(
+        provider_prefix="claude-code:",
+        display_name="Claude Code",
+        manual_auth_hint="Run 'gac model' to re-authenticate manually.",
+        authenticate=_create_claude_code_authenticator(),
+        extra_error_check=_claude_code_extra_check,
+    ),
+    OAuthProviderConfig(
+        provider_prefix="qwen:",
+        display_name="Qwen",
+        manual_auth_hint="Run 'gac auth qwen login' to re-authenticate manually.",
+        authenticate=_create_qwen_authenticator(),
+        extra_error_check=None,
+    ),
+]
+
+
+def _find_oauth_provider(model: str, error: AIError) -> OAuthProviderConfig | None:
+    """Find the OAuth provider config that matches the model and error."""
+    if error.error_type != "authentication":
+        return None
+
+    for provider in OAUTH_PROVIDERS:
+        if not model.startswith(provider.provider_prefix):
+            continue
+        if provider.extra_error_check and not provider.extra_error_check(error):
+            continue
+        return provider
+
+    return None
+
+
+def _attempt_reauth_and_retry(
+    provider: OAuthProviderConfig,
+    quiet: bool,
+    retry_workflow: Callable[[], int],
+) -> int:
+    """Attempt re-authentication and retry the workflow.
+
+    Args:
+        provider: The OAuth provider configuration
+        quiet: Whether to suppress output
+        retry_workflow: Callable that retries the workflow on success
+
+    Returns:
+        Exit code: 0 for success, 1 for failure
+    """
+    console.print(f"[yellow]⚠ {provider.display_name} OAuth token has expired[/yellow]")
+    console.print("[cyan]🔐 Starting automatic re-authentication...[/cyan]")
+
+    try:
+        if provider.authenticate(quiet):
+            console.print("[green]✓ Re-authentication successful![/green]")
+            console.print("[cyan]Retrying commit...[/cyan]\n")
+            return retry_workflow()
+        else:
+            console.print("[red]Re-authentication failed.[/red]")
+            console.print(f"[yellow]{provider.manual_auth_hint}[/yellow]")
+            return 1
+    except (AIError, ConfigError, OSError) as auth_error:
+        console.print(f"[red]Re-authentication error: {auth_error}[/red]")
+        console.print(f"[yellow]{provider.manual_auth_hint}[/yellow]")
+        return 1
+
+
+def handle_oauth_retry(e: AIError, ctx: WorkflowContext) -> int:
+    """Handle OAuth retry logic for expired tokens.
+
+    Checks if the error is an OAuth-related authentication error for a known
+    provider, attempts re-authentication, and retries the workflow on success.
+
+    Args:
+        e: The AIError that triggered this handler
+        ctx: WorkflowContext containing all workflow configuration and state
+
+    Returns:
+        Exit code: 0 for success, 1 for failure
+    """
+    logger.error(str(e))
+
+    provider = _find_oauth_provider(ctx.model, e)
+
+    if provider is None:
+        console.print(f"[red]Failed to generate commit message: {e!s}[/red]")
+        return 1
+
+    def retry_workflow() -> int:
+        from gac.main import _execute_single_commit_workflow
+
+        return _execute_single_commit_workflow(ctx)
+
+    return _attempt_reauth_and_retry(provider, ctx.quiet, retry_workflow)

gac/postprocess.py

@@ -0,0 +1,155 @@
+"""Post-processing for AI-generated commit messages.
+
+This module handles cleaning and normalization of commit messages generated
+by AI models, removing artifacts like think tags, code blocks, and XML tags.
+"""
+
+import re
+
+from gac.constants import CommitMessageConstants
+
+
+def _remove_think_tags(message: str) -> str:
+    """Remove AI reasoning <think> tags and their content from the message.
+
+    Args:
+        message: The message to clean
+
+    Returns:
+        Message with <think> tags removed
+    """
+    while re.search(r"<think>(?:(?!</think>)[^\n])*\n.*?</think>", message, flags=re.DOTALL | re.IGNORECASE):
+        message = re.sub(
+            r"<think>(?:(?!</think>)[^\n])*\n.*?</think>\s*", "", message, flags=re.DOTALL | re.IGNORECASE, count=1
+        )
+
+    message = re.sub(r"\n\n+\s*<think>.*?</think>\s*", "", message, flags=re.DOTALL | re.IGNORECASE)
+    message = re.sub(r"<think>.*?</think>\s*\n\n+", "", message, flags=re.DOTALL | re.IGNORECASE)
+
+    message = re.sub(r"<think>\s*\n.*$", "", message, flags=re.DOTALL | re.IGNORECASE)
+
+    conventional_prefixes_pattern = r"(" + "|".join(CommitMessageConstants.CONVENTIONAL_PREFIXES) + r")[\(:)]"
+    if re.search(r"^.*?</think>", message, flags=re.DOTALL | re.IGNORECASE):
+        prefix_match = re.search(conventional_prefixes_pattern, message, flags=re.IGNORECASE)
+        think_match = re.search(r"</think>", message, flags=re.IGNORECASE)
+
+        if not prefix_match or (think_match and think_match.start() < prefix_match.start()):
+            message = re.sub(r"^.*?</think>\s*", "", message, flags=re.DOTALL | re.IGNORECASE)
+
+    message = re.sub(r"</think>\s*$", "", message, flags=re.IGNORECASE)
+
+    return message
+
+
+def _remove_code_blocks(message: str) -> str:
+    """Remove markdown code blocks from the message.
+
+    Args:
+        message: The message to clean
+
+    Returns:
+        Message with code blocks removed
+    """
+    return re.sub(r"```[\w]*\n|```", "", message)
+
+
+def _extract_commit_from_reasoning(message: str) -> str:
+    """Extract the actual commit message from reasoning/preamble text.
+
+    Args:
+        message: The message potentially containing reasoning
+
+    Returns:
+        Extracted commit message
+    """
+    for indicator in CommitMessageConstants.COMMIT_INDICATORS:
+        if indicator.lower() in message.lower():
+            message = message.split(indicator, 1)[1].strip()
+            break
+
+    lines = message.split("\n")
+    for i, line in enumerate(lines):
+        if any(line.strip().startswith(f"{prefix}:") for prefix in CommitMessageConstants.CONVENTIONAL_PREFIXES):
+            message = "\n".join(lines[i:])
+            break
+
+    return message
+
+
+def _remove_xml_tags(message: str) -> str:
+    """Remove XML tags that might have leaked into the message.
+
+    Args:
+        message: The message to clean
+
+    Returns:
+        Message with XML tags removed
+    """
+    for tag in CommitMessageConstants.XML_TAGS_TO_REMOVE:
+        message = message.replace(tag, "")
+    return message
+
+
+def _fix_double_prefix(message: str) -> str:
+    """Fix double type prefix issues like 'chore: feat(scope):' to 'feat(scope):'.
+
+    Args:
+        message: The message to fix
+
+    Returns:
+        Message with double prefix corrected
+    """
+    double_prefix_pattern = re.compile(
+        r"^("
+        + r"|\s*".join(CommitMessageConstants.CONVENTIONAL_PREFIXES)
+        + r"):\s*("
+        + r"|\s*".join(CommitMessageConstants.CONVENTIONAL_PREFIXES)
+        + r")\(([^)]+)\):"
+    )
+    match = double_prefix_pattern.match(message)
+
+    if match:
+        second_type = match.group(2)
+        scope = match.group(3)
+        description = message[match.end() :].strip()
+        message = f"{second_type}({scope}): {description}"
+
+    return message
+
+
+def _normalize_whitespace(message: str) -> str:
+    """Normalize whitespace, ensuring no more than one blank line between paragraphs.
+
+    Args:
+        message: The message to normalize
+
+    Returns:
+        Message with normalized whitespace
+    """
+    return re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", message).strip()
+
+
+def clean_commit_message(message: str) -> str:
+    """Clean up a commit message generated by an AI model.
+
+    This function:
+    1. Removes any preamble or reasoning text
+    2. Removes code block markers and formatting
+    3. Removes XML tags that might have leaked into the response
+    4. Fixes double type prefix issues (e.g., "chore: feat(scope):")
+    5. Normalizes whitespace
+
+    Args:
+        message: Raw commit message from AI
+
+    Returns:
+        Cleaned commit message ready for use
+    """
+    message = message.strip()
+    message = _remove_think_tags(message)
+    message = _remove_code_blocks(message)
+    message = _extract_commit_from_reasoning(message)
+    message = _remove_xml_tags(message)
+    message = _fix_double_prefix(message)
+    message = _normalize_whitespace(message)
+    return message