gac 3.6.0__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.6.0"
+__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,
@@ -124,6 +105,48 @@ def generate_with_retries(
     if not messages:
         raise AIError.model_error("No messages provided for AI generation")
 
+    # Load Claude Code token from TokenStore if needed
+    if provider == "claude-code":
+        # Check token expiry and refresh if needed
+        if not refresh_token_if_expired(quiet=True):
+            raise AIError.authentication_error(
+                "Claude Code token not found or expired. Please authenticate with 'gac auth claude-code login'."
+            )
+
+        # Load the (possibly refreshed) token
+        token_store = TokenStore()
+        token_data = token_store.get_token("claude-code")
+        if token_data and "access_token" in token_data:
+            os.environ["CLAUDE_CODE_ACCESS_TOKEN"] = token_data["access_token"]
+        else:
+            raise AIError.authentication_error(
+                "Claude Code token not found. Please authenticate with 'gac auth claude-code login'."
+            )
+
+    # Check Qwen OAuth token expiry and refresh if needed
+    if provider == "qwen":
+        oauth_provider = QwenOAuthProvider(TokenStore())
+        token = oauth_provider.get_token()
+        if not token:
+            if not quiet:
+                console.print("[yellow]⚠ Qwen authentication not found or expired[/yellow]")
+                console.print("[cyan]🔐 Starting automatic authentication...[/cyan]")
+            try:
+                oauth_provider.initiate_auth(open_browser=True)
+                token = oauth_provider.get_token()
+                if not token:
+                    raise AIError.authentication_error(
+                        "Qwen authentication failed. Run 'gac auth qwen login' to authenticate manually."
+                    )
+                if not quiet:
+                    console.print("[green]✓ Authentication successful![/green]\n")
+            except AIError:
+                raise
+            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
+
     # Set up spinner
     if is_group:
         message_type = f"grouped {task_description}s"
@@ -136,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):
@@ -161,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
@@ -176,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):
@@ -203,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/auth_cli.py

@@ -1,54 +1,95 @@
-"""CLI for authenticating Claude Code OAuth tokens.
+"""CLI for OAuth authentication with various providers.
 
-Provides a command to authenticate and re-authenticate Claude Code subscriptions.
+Provides commands to authenticate and manage OAuth tokens for supported providers.
 """
 
 import logging
 
 import click
 
-from gac.oauth.claude_code import authenticate_and_save, load_stored_token
+from gac.oauth import (
+    QwenOAuthProvider,
+    TokenStore,
+    authenticate_and_save,
+    remove_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.
+@click.group(invoke_without_command=True)
+@click.pass_context
+def auth(ctx: click.Context) -> None:
+    """Manage OAuth authentication for AI providers.
 
-    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.
+    Supports authentication for:
+    - claude-code: Claude Code subscription OAuth
+    - qwen: Qwen AI OAuth (device flow)
 
-    The token is used by the Claude Code provider to access your
-    Claude Code subscription instead of requiring an Anthropic API key.
+    Examples:
+        gac auth                        # Show authentication status
+        gac auth claude-code login      # Login to Claude Code
+        gac auth claude-code logout     # Logout from Claude Code
+        gac auth claude-code status     # Check Claude Code auth status
+        gac auth qwen login             # Login to Qwen
+        gac auth qwen logout            # Logout from Qwen
+        gac auth qwen status            # Check Qwen auth status
     """
-    # Setup logging
-    if quiet:
-        effective_log_level = "ERROR"
+    if ctx.invoked_subcommand is None:
+        _show_auth_status()
+
+
+def _show_auth_status() -> None:
+    """Show authentication status for all providers."""
+    click.echo("OAuth Authentication Status")
+    click.echo("-" * 40)
+
+    token_store = TokenStore()
+
+    claude_token = token_store.get_token("claude-code")
+    if claude_token:
+        click.echo("Claude Code: ✓ Authenticated")
     else:
-        effective_log_level = log_level
-    setup_logging(effective_log_level)
+        click.echo("Claude Code: ✗ Not authenticated")
+        click.echo("             Run 'gac auth claude-code login' to login")
+
+    qwen_token = token_store.get_token("qwen")
+    if qwen_token:
+        click.echo("Qwen:        ✓ Authenticated")
+    else:
+        click.echo("Qwen:        ✗ Not authenticated")
+        click.echo("             Run 'gac auth qwen login' to login")
+
+
+# Claude Code commands
+@auth.group("claude-code")
+def claude_code() -> None:
+    """Manage Claude Code OAuth authentication.
+
+    Use browser-based authentication to log in to Claude Code.
+    """
+    pass
 
-    # 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()
+
+@claude_code.command("login")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
+def claude_code_login(quiet: bool = False) -> None:
+    """Login to Claude Code using OAuth.
+
+    Opens a browser to authenticate with Claude Code. The token is stored
+    securely in ~/.gac/oauth/claude-code.json.
+    """
+    if not quiet:
+        setup_logging("INFO")
+
+    token_store = TokenStore()
+    existing_token = token_store.get_token("claude-code")
+    if existing_token:
+        if not quiet:
+            click.echo("✓ Already authenticated with Claude Code.")
+            if not click.confirm("Re-authenticate?"):
+                return
 
     if not quiet:
         click.echo("🔐 Starting Claude Code OAuth authentication...")
@@ -56,14 +97,118 @@ def auth(quiet: bool = False, log_level: str = "INFO") -> None:
         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()
             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")
+
+
+@claude_code.command("logout")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
+def claude_code_logout(quiet: bool = False) -> None:
+    """Logout from Claude Code and remove stored tokens."""
+    token_store = TokenStore()
+    existing_token = token_store.get_token("claude-code")
+
+    if not existing_token:
+        if not quiet:
+            click.echo("Not currently authenticated with Claude Code.")
+        return
+
+    try:
+        remove_token()
+        if not quiet:
+            click.echo("✅ Successfully logged out from Claude Code.")
+    except Exception as e:
+        click.echo("❌ Failed to remove Claude Code token.")
+        raise click.ClickException("Claude Code logout failed") from e
+
+
+@claude_code.command("status")
+def claude_code_status() -> None:
+    """Check Claude Code authentication status."""
+    token_store = TokenStore()
+    token = token_store.get_token("claude-code")
+
+    if token:
+        click.echo("Claude Code Authentication Status: ✓ Authenticated")
+    else:
+        click.echo("Claude Code Authentication Status: ✗ Not authenticated")
+        click.echo("Run 'gac auth claude-code login' to authenticate.")
+
+
+# Qwen commands
+@auth.group()
+def qwen() -> None:
+    """Manage Qwen OAuth authentication.
+
+    Use device flow authentication to log in to Qwen AI.
+    """
+    pass
+
+
+@qwen.command("login")
+@click.option("--no-browser", is_flag=True, help="Don't automatically open browser")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
+def qwen_login(no_browser: bool = False, quiet: bool = False) -> None:
+    """Login to Qwen using OAuth device flow.
+
+    Opens a browser to authenticate with Qwen. The token is stored
+    securely in ~/.gac/oauth/qwen.json.
+    """
+    if not quiet:
+        setup_logging("INFO")
+
+    provider = QwenOAuthProvider()
+
+    if provider.is_authenticated():
+        if not quiet:
+            click.echo("✓ Already authenticated with Qwen.")
+            if not click.confirm("Re-authenticate?"):
+                return
+
+    try:
+        provider.initiate_auth(open_browser=not no_browser)
+        if not quiet:
+            click.echo()
+            click.echo("✅ Qwen authentication completed successfully!")
+    except Exception as e:
+        click.echo(f"❌ Qwen authentication failed: {e}")
+        raise click.ClickException("Qwen authentication failed") from None
+
+
+@qwen.command("logout")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
+def qwen_logout(quiet: bool = False) -> None:
+    """Logout from Qwen and remove stored tokens."""
+    provider = QwenOAuthProvider()
+
+    if not provider.is_authenticated():
+        if not quiet:
+            click.echo("Not currently authenticated with Qwen.")
+        return
+
+    provider.logout()
+    if not quiet:
+        click.echo("✅ Successfully logged out from Qwen.")
+
+
+@qwen.command("status")
+def qwen_status() -> None:
+    """Check Qwen authentication status."""
+    provider = QwenOAuthProvider()
+    token = provider.get_token()
+
+    if token:
+        click.echo("Qwen Authentication Status: ✓ Authenticated")
+        if token.get("resource_url"):
+            click.echo(f"API Endpoint: {token['resource_url']}")
+    else:
+        click.echo("Qwen Authentication Status: ✗ Not authenticated")
+        click.echo("Run 'gac auth qwen login' to authenticate.")

gac/cli.py

@@ -6,14 +6,16 @@ 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
@@ -23,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()
 
@@ -73,6 +76,11 @@ console = Console()
 # 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,
@@ -103,6 +111,7 @@ def cli(
     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."""
@@ -116,6 +125,11 @@ 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["no_verify_ssl"]:
+            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]")
@@ -124,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,
@@ -149,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,
@@ -179,6 +195,7 @@ def cli(
             "verbose": verbose,
             "no_verify": no_verify,
             "skip_secret_scan": skip_secret_scan,
+            "no_verify_ssl": no_verify_ssl,
             "hook_timeout": hook_timeout,
         }
 
@@ -193,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")