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

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")
@@ -36,17 +46,24 @@ logger = logging.getLogger(__name__)
 @click.option(
     "--scope",
     "-s",
-    is_flag=False,
-    flag_value="",
-    default=None,
-    help="Add a scope to the commit message. If used without a value, the LLM will determine an appropriate scope.",
+    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="Increase output verbosity to INFO")
+@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"],
@@ -54,26 +71,39 @@ logger = logging.getLogger(__name__)
     help=f"Set log level (default: {config['log_level']})",
 )
 # Advanced options
-@click.option("--no-verify", is_flag=True, help="Skip pre-commit hooks when committing")
+@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,
-    log_level: str = config["log_level"],
+    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: str = None,
+    scope: bool = False,
     quiet: bool = False,
     yes: bool = False,
     hint: str = "",
-    model: str = None,
+    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:
@@ -81,56 +111,94 @@ def cli(
             print(f"Git Auto Commit (gac) version: {__version__}")
             sys.exit(0)
         effective_log_level = log_level
-        if verbose and log_level not in ("DEBUG", "INFO"):
-            effective_log_level = "INFO"
         if quiet:
             effective_log_level = "ERROR"
         setup_logging(effective_log_level)
         logger.info("Starting gac")
 
-        # Apply always_include_scope setting if no explicit scope provided
-        effective_scope = scope
-        if scope is None and config.get("always_include_scope", False):
-            effective_scope = ""  # Empty string triggers scope inference
+        # 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,
-                scope=effective_scope,
+                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": scope,
+            "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,
+            "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
@@ -11,20 +11,17 @@ from dotenv import load_dotenv
 from gac.constants import EnvDefaults, Logging
 
 
-def load_config() -> dict[str, str | int | float | bool]:
-    """Load configuration from $HOME/.gac.env, then ./.gac.env or ./.env, then environment variables."""
+def load_config() -> dict[str, str | int | float | bool | None]:
+    """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"),
@@ -35,6 +32,15 @@ def load_config() -> dict[str, str | int | float | bool]:
         "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"),
+        "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()

gac/constants.py

@@ -2,7 +2,6 @@
 
 import os
 from enum import Enum
-from re import Pattern
 
 
 class FileStatus(Enum):
@@ -21,9 +20,13 @@ class EnvDefaults:
 
     MAX_RETRIES: int = 3
     TEMPERATURE: float = 1
-    MAX_OUTPUT_TOKENS: int = 512
-    WARNING_LIMIT_TOKENS: int = 16384
+    MAX_OUTPUT_TOKENS: int = 4096  # includes reasoning tokens
+    WARNING_LIMIT_TOKENS: int = 32768
     ALWAYS_INCLUDE_SCOPE: bool = False
+    SKIP_SECRET_SCAN: bool = False
+    VERBOSE: bool = False
+    NO_TIKTOKEN: bool = False
+    HOOK_TIMEOUT: int = 120  # Timeout for pre-commit and lefthook hooks in seconds
 
 
 class Logging:
@@ -39,13 +42,14 @@ class Utility:
     DEFAULT_ENCODING: str = "cl100k_base"  # llm encoding
     DEFAULT_DIFF_TOKEN_LIMIT: int = 15000  # Maximum tokens for diff processing
     MAX_WORKERS: int = os.cpu_count() or 4  # Maximum number of parallel workers
+    MAX_DISPLAYED_SECRET_LENGTH: int = 50  # Maximum length for displaying secrets
 
 
 class FilePatterns:
     """Patterns for identifying special file types."""
 
     # Regex patterns to detect binary file changes in git diffs (e.g., images or other non-text files)
-    BINARY: list[Pattern[str]] = [
+    BINARY: list[str] = [
         r"Binary files .* differ",
         r"GIT binary patch",
     ]
@@ -126,7 +130,7 @@ class CodePatternImportance:
 
     # Regex patterns to detect code structure changes in git diffs (e.g., class, function, import)
     # Note: The patterns are prefixed with "+" to match only added and modified lines
-    PATTERNS: dict[Pattern[str], float] = {
+    PATTERNS: dict[str, float] = {
         # Structure changes
         r"\+\s*(class|interface|enum)\s+\w+": 1.8,  # Class/interface/enum definitions
         r"\+\s*(def|function|func)\s+\w+\s*\(": 1.5,  # Function definitions
@@ -148,3 +152,170 @@ class CodePatternImportance:
         r"\+\s*(test|describe|it|should)\s*\(": 1.1,  # Test definitions
         r"\+\s*(assert|expect)": 1.0,  # Assertions
     }
+
+
+class Languages:
+    """Language code mappings and utilities."""
+
+    # Language code to full name mapping
+    # Supports ISO 639-1 codes and common variants
+    CODE_MAP: dict[str, str] = {
+        # English
+        "en": "English",
+        # Chinese
+        "zh": "Simplified Chinese",
+        "zh-cn": "Simplified Chinese",
+        "zh-hans": "Simplified Chinese",
+        "zh-tw": "Traditional Chinese",
+        "zh-hant": "Traditional Chinese",
+        # Japanese
+        "ja": "Japanese",
+        # Korean
+        "ko": "Korean",
+        # Spanish
+        "es": "Spanish",
+        # Portuguese
+        "pt": "Portuguese",
+        # French
+        "fr": "French",
+        # German
+        "de": "German",
+        # Russian
+        "ru": "Russian",
+        # Hindi
+        "hi": "Hindi",
+        # Italian
+        "it": "Italian",
+        # Polish
+        "pl": "Polish",
+        # Turkish
+        "tr": "Turkish",
+        # Dutch
+        "nl": "Dutch",
+        # Vietnamese
+        "vi": "Vietnamese",
+        # Thai
+        "th": "Thai",
+        # Indonesian
+        "id": "Indonesian",
+        # Swedish
+        "sv": "Swedish",
+        # Arabic
+        "ar": "Arabic",
+        # Hebrew
+        "he": "Hebrew",
+        # Greek
+        "el": "Greek",
+        # Danish
+        "da": "Danish",
+        # Norwegian
+        "no": "Norwegian",
+        "nb": "Norwegian",
+        "nn": "Norwegian",
+        # Finnish
+        "fi": "Finnish",
+    }
+
+    # List of languages with display names and English names for CLI selection
+    # Format: (display_name, english_name)
+    LANGUAGES: list[tuple[str, str]] = [
+        ("English", "English"),
+        ("简体中文", "Simplified Chinese"),
+        ("繁體中文", "Traditional Chinese"),
+        ("日本語", "Japanese"),
+        ("한국어", "Korean"),
+        ("Español", "Spanish"),
+        ("Português", "Portuguese"),
+        ("Français", "French"),
+        ("Deutsch", "German"),
+        ("Русский", "Russian"),
+        ("हिन्दी", "Hindi"),
+        ("Italiano", "Italian"),
+        ("Polski", "Polish"),
+        ("Türkçe", "Turkish"),
+        ("Nederlands", "Dutch"),
+        ("Tiếng Việt", "Vietnamese"),
+        ("ไทย", "Thai"),
+        ("Bahasa Indonesia", "Indonesian"),
+        ("Svenska", "Swedish"),
+        ("العربية", "Arabic"),
+        ("עברית", "Hebrew"),
+        ("Ελληνικά", "Greek"),
+        ("Dansk", "Danish"),
+        ("Norsk", "Norwegian"),
+        ("Suomi", "Finnish"),
+        ("Custom", "Custom"),
+    ]
+
+    @staticmethod
+    def resolve_code(language: str) -> str:
+        """Resolve a language code to its full name.
+
+        Args:
+            language: Language name or code (e.g., 'Spanish', 'es', 'zh-CN')
+
+        Returns:
+            Full language name (e.g., 'Spanish', 'Simplified Chinese')
+
+        If the input is already a full language name, it's returned as-is.
+        If it's a recognized code, it's converted to the full name.
+        Otherwise, the input is returned unchanged (for custom languages).
+        """
+        # Normalize the code to lowercase for lookup
+        code_lower = language.lower().strip()
+
+        # Check if it's a recognized code
+        if code_lower in Languages.CODE_MAP:
+            return Languages.CODE_MAP[code_lower]
+
+        # Return as-is (could be a full name or custom language)
+        return language
+
+
+class CommitMessageConstants:
+    """Constants for commit message generation and cleaning."""
+
+    # Conventional commit type prefixes
+    CONVENTIONAL_PREFIXES: list[str] = [
+        "feat",
+        "fix",
+        "docs",
+        "style",
+        "refactor",
+        "perf",
+        "test",
+        "build",
+        "ci",
+        "chore",
+    ]
+
+    # XML tags that may leak from prompt templates into AI responses
+    XML_TAGS_TO_REMOVE: list[str] = [
+        "<git-status>",
+        "</git-status>",
+        "<git_status>",
+        "</git_status>",
+        "<git-diff>",
+        "</git-diff>",
+        "<git_diff>",
+        "</git_diff>",
+        "<repository_context>",
+        "</repository_context>",
+        "<instructions>",
+        "</instructions>",
+        "<format>",
+        "</format>",
+        "<conventions>",
+        "</conventions>",
+    ]
+
+    # Indicators that mark the start of the actual commit message in AI responses
+    COMMIT_INDICATORS: list[str] = [
+        "# Your commit message:",
+        "Your commit message:",
+        "The commit message is:",
+        "Here's the commit message:",
+        "Commit message:",
+        "Final commit message:",
+        "# Commit Message",
+    ]

gac/errors.py

@@ -95,6 +95,11 @@ class AIError(GacError):
         """Create a model error."""
         return cls(message, error_type="model")
 
+    @classmethod
+    def unknown_error(cls, message: str) -> "AIError":
+        """Create an unknown error."""
+        return cls(message, error_type="unknown")
+
 
 class FormattingError(GacError):
     """Error related to code formatting."""
@@ -102,6 +107,12 @@ class FormattingError(GacError):
     exit_code = 5
 
 
+class SecurityError(GacError):
+    """Error related to security issues (e.g., detected secrets)."""
+
+    exit_code = 6
+
+
 # Simplified error hierarchy - we use a single AIError class with error codes
 # instead of multiple subclasses for better maintainability
 
@@ -130,6 +141,8 @@ def handle_error(error: Exception, exit_program: bool = False, quiet: bool = Fal
         logger.error("Git operation failed. Please check your repository status.")
     elif isinstance(error, AIError):
         logger.error("AI operation failed. Please check your configuration and API keys.")
+    elif isinstance(error, SecurityError):
+        logger.error("Security scan detected potential secrets in staged changes.")
     else:
         logger.error("An unexpected error occurred.")
 
@@ -170,6 +183,7 @@ def format_error_for_user(error: Exception) -> str:
         ConfigError: "Please check your configuration settings.",
         GitError: "Please ensure Git is installed and you're in a valid Git repository.",
         FormattingError: "Please check that required formatters are installed.",
+        SecurityError: "Please remove or secure any detected secrets before committing.",
     }
 
     # Generic remediation for unexpected errors