gac 3.10.3__py3-none-any.whl

gac/cli.py

@@ -0,0 +1,218 @@
+# flake8: noqa: E304
+
+"""CLI entry point for gac.
+
+Defines the Click-based command-line interface and delegates execution to the main workflow.
+"""
+
+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 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
+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: GACConfig = 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")
+@click.option("--show-prompt", is_flag=True, help="Show the prompt sent to the LLM")
+@click.option(
+    "--scope",
+    "-s",
+    is_flag=True,
+    default=False,
+    help="Infer an appropriate scope for the commit message",
+)
+@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(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Generate detailed commit messages with motivation, architecture, and impact sections",
+)
+@click.option(
+    "--log-level",
+    default=config["log_level"],
+    type=click.Choice(Logging.LEVELS, case_sensitive=False),
+    help=f"Set log level (default: {config['log_level']})",
+)
+# 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,
+    show_prompt: bool = False,
+    scope: bool = False,
+    quiet: bool = False,
+    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:
+        if version:
+            print(f"Git Auto Commit (gac) version: {__version__}")
+            sys.exit(0)
+        effective_log_level = log_level
+        if quiet:
+            effective_log_level = "ERROR"
+        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,
+                show_prompt=show_prompt,
+                infer_scope=bool(infer_scope),
+                require_confirmation=not yes,
+                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)
+    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))
+
+        ctx.obj = {
+            "add_all": add_all,
+            "group": group,
+            "interactive": interactive,
+            "log_level": log_level,
+            "one_liner": one_liner,
+            "push": push,
+            "show_prompt": show_prompt,
+            "scope": infer_scope,
+            "quiet": quiet,
+            "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(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: Any) -> None:
+    """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/commit_executor.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Commit execution logic for gac."""
+
+import logging
+import sys
+
+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."""
+        try:
+            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")
+                sys.exit(0)
+
+            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]"
+                )
+                sys.exit(1)
+        except (GitError, OSError) as e:
+            console.print(f"[red]Error pushing changes: {e}[/red]")
+            sys.exit(1)

gac/config.py

@@ -0,0 +1,125 @@
+"""Configuration loading for gac.
+
+Handles environment variable and .gac.env file precedence for application settings.
+"""
+
+import os
+from pathlib import Path
+from typing import TypedDict
+
+from dotenv import load_dotenv
+
+from gac.constants import EnvDefaults, Logging
+from gac.errors import ConfigError
+
+
+class GACConfig(TypedDict, total=False):
+    """TypedDict for GAC configuration values.
+
+    Fields that can be None or omitted are marked with total=False.
+    """
+
+    model: str | None
+    temperature: float
+    max_output_tokens: int
+    max_retries: int
+    log_level: str
+    warning_limit_tokens: int
+    always_include_scope: bool
+    skip_secret_scan: bool
+    no_tiktoken: bool
+    no_verify_ssl: bool
+    verbose: bool
+    system_prompt_path: str | None
+    language: str | None
+    translate_prefixes: bool
+    rtl_confirmed: bool
+    hook_timeout: int
+
+
+def validate_config(config: GACConfig) -> 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() -> GACConfig:
+    """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 .gac.env in project directory
+    project_gac_env = Path(".gac.env")
+
+    if project_gac_env.exists():
+        load_dotenv(project_gac_env, override=True)
+
+    config: GACConfig = {
+        "model": os.getenv("GAC_MODEL"),
+        "temperature": float(os.getenv("GAC_TEMPERATURE", EnvDefaults.TEMPERATURE)),
+        "max_output_tokens": int(os.getenv("GAC_MAX_OUTPUT_TOKENS", EnvDefaults.MAX_OUTPUT_TOKENS)),
+        "max_retries": int(os.getenv("GAC_RETRIES", EnvDefaults.MAX_RETRIES)),
+        "log_level": os.getenv("GAC_LOG_LEVEL", Logging.DEFAULT_LEVEL),
+        "warning_limit_tokens": int(os.getenv("GAC_WARNING_LIMIT_TOKENS", EnvDefaults.WARNING_LIMIT_TOKENS)),
+        "always_include_scope": os.getenv("GAC_ALWAYS_INCLUDE_SCOPE", str(EnvDefaults.ALWAYS_INCLUDE_SCOPE)).lower()
+        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

@@ -0,0 +1,95 @@
+"""CLI for managing gac configuration in $HOME/.gac.env."""
+
+import os
+from pathlib import Path
+
+import click
+from dotenv import load_dotenv, set_key
+
+GAC_ENV_PATH = Path.home() / ".gac.env"
+
+
+@click.group()
+def config() -> None:
+    """Manage gac configuration."""
+    pass
+
+
+@config.command()
+def show() -> None:
+    """Show all current config values."""
+    from dotenv import dotenv_values
+
+    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
+
+    if user_exists:
+        click.echo(f"User config ({GAC_ENV_PATH}):")
+        user_config = dotenv_values(str(GAC_ENV_PATH))
+        for key, value in sorted(user_config.items()):
+            if value is not None:
+                if any(sensitive in key.lower() for sensitive in ["key", "token", "secret"]):
+                    display_value = "***hidden***"
+                else:
+                    display_value = value
+                click.echo(f"  {key}={display_value}")
+    else:
+        click.echo("No $HOME/.gac.env found.")
+
+    if project_exists:
+        if user_exists:
+            click.echo("")
+        click.echo("Project config (./.gac.env):")
+        project_config = dotenv_values(str(project_env_path))
+        for key, value in sorted(project_config.items()):
+            if value is not None:
+                if any(sensitive in key.lower() for sensitive in ["key", "token", "secret"]):
+                    display_value = "***hidden***"
+                else:
+                    display_value = value
+                click.echo(f"  {key}={display_value}")
+        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()
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str) -> None:
+    """Set a config KEY to VALUE in $HOME/.gac.env."""
+    GAC_ENV_PATH.touch(exist_ok=True)
+    set_key(str(GAC_ENV_PATH), key, value)
+    click.echo(f"Set {key} in $HOME/.gac.env")
+
+
+@config.command()
+@click.argument("key")
+def get(key: str) -> None:
+    """Get a config value by KEY."""
+    load_dotenv(GAC_ENV_PATH, override=True)
+    value = os.getenv(key)
+    if value is None:
+        click.echo(f"{key} not set.")
+    else:
+        click.echo(value)
+
+
+@config.command()
+@click.argument("key")
+def unset(key: str) -> None:
+    """Remove a config KEY from $HOME/.gac.env."""
+    if not GAC_ENV_PATH.exists():
+        click.echo("No $HOME/.gac.env found.")
+        return
+    lines = GAC_ENV_PATH.read_text().splitlines()
+    new_lines = [line for line in lines if not line.strip().startswith(f"{key}=")]
+    GAC_ENV_PATH.write_text("\n".join(new_lines) + "\n")
+    click.echo(f"Unset {key} in $HOME/.gac.env")