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

gac/constants.py

@@ -20,11 +20,13 @@ class EnvDefaults:
 
     MAX_RETRIES: int = 3
     TEMPERATURE: float = 1
-    MAX_OUTPUT_TOKENS: int = 1024  # includes reasoning tokens
-    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:
@@ -150,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/git.py

@@ -14,6 +14,63 @@ from gac.utils import run_subprocess
 logger = logging.getLogger(__name__)
 
 
+def run_subprocess_with_encoding_fallback(
+    command: list[str], silent: bool = False, timeout: int = 60
+) -> subprocess.CompletedProcess:
+    """Run subprocess with encoding fallback, returning full CompletedProcess object.
+
+    This is used for cases where we need both stdout and stderr separately,
+    like pre-commit and lefthook hook execution.
+
+    Args:
+        command: List of command arguments
+        silent: If True, suppress debug logging
+        timeout: Command timeout in seconds
+
+    Returns:
+        CompletedProcess object with stdout, stderr, and returncode
+    """
+    from gac.utils import get_safe_encodings
+
+    encodings = get_safe_encodings()
+    last_exception: Exception | None = None
+
+    for encoding in encodings:
+        try:
+            if not silent:
+                logger.debug(f"Running command: {' '.join(command)} (encoding: {encoding})")
+
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=timeout,
+                encoding=encoding,
+                errors="replace",
+            )
+            return result
+        except UnicodeError as e:
+            last_exception = e
+            if not silent:
+                logger.debug(f"Failed to decode with {encoding}: {e}")
+            continue
+        except subprocess.TimeoutExpired:
+            raise
+        except Exception as e:
+            if not silent:
+                logger.debug(f"Command error: {e}")
+            # Try next encoding for non-timeout errors
+            last_exception = e
+            continue
+
+    # If we get here, all encodings failed
+    if last_exception:
+        raise subprocess.CalledProcessError(1, command, "", f"Encoding error: {last_exception}") from last_exception
+    else:
+        raise subprocess.CalledProcessError(1, command, "", "All encoding attempts failed")
+
+
 def run_git_command(args: list[str], silent: bool = False, timeout: int = 30) -> str:
     """Run a git command and return the output."""
     command = ["git"] + args
@@ -50,6 +107,48 @@ def get_staged_files(file_type: str | None = None, existing_only: bool = False)
         return []
 
 
+def get_staged_status() -> str:
+    """Get formatted status of staged files only, excluding unstaged/untracked files.
+
+    Returns:
+        Formatted status string with M/A/D/R indicators
+    """
+    try:
+        output = run_git_command(["diff", "--name-status", "--staged"])
+        if not output:
+            return "No changes staged for commit."
+
+        status_map = {
+            "M": "modified",
+            "A": "new file",
+            "D": "deleted",
+            "R": "renamed",
+            "C": "copied",
+            "T": "typechange",
+        }
+
+        status_lines = ["Changes to be committed:"]
+        for line in output.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+
+            # Parse status line (e.g., "M\tfile.py" or "R100\told.py\tnew.py")
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+
+            change_type = parts[0][0]  # First char is the status (M, A, D, R, etc.)
+            file_path = parts[-1]  # Last part is the new/current file path
+
+            status_label = status_map.get(change_type, "modified")
+            status_lines.append(f"\t{status_label}:   {file_path}")
+
+        return "\n".join(status_lines)
+    except GitError:
+        return "No changes staged for commit."
+
+
 def get_diff(staged: bool = True, color: bool = True, commit1: str | None = None, commit2: str | None = None) -> str:
     """Get the diff between commits or working tree.
 
@@ -90,23 +189,23 @@ def get_diff(staged: bool = True, color: bool = True, commit1: str | None = None
 
 def get_repo_root() -> str:
     """Get absolute path of repository root."""
-    result = subprocess.check_output(["git", "rev-parse", "--show-toplevel"])
-    return result.decode().strip()
+    result = run_git_command(["rev-parse", "--show-toplevel"])
+    return result
 
 
 def get_current_branch() -> str:
     """Get name of current git branch."""
-    result = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-    return result.decode().strip()
+    result = run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
+    return result
 
 
 def get_commit_hash() -> str:
     """Get SHA-1 hash of current commit."""
-    result = subprocess.check_output(["git", "rev-parse", "HEAD"])
-    return result.decode().strip()
+    result = run_git_command(["rev-parse", "HEAD"])
+    return result
 
 
-def run_pre_commit_hooks() -> bool:
+def run_pre_commit_hooks(hook_timeout: int = 120) -> bool:
     """Run pre-commit hooks if they exist.
 
     Returns:
@@ -126,9 +225,9 @@ def run_pre_commit_hooks() -> bool:
             return True
 
         # Run pre-commit hooks on staged files
-        logger.info("Running pre-commit hooks...")
+        logger.info(f"Running pre-commit hooks with {hook_timeout}s timeout...")
         # Run pre-commit and capture both stdout and stderr
-        result = subprocess.run(["pre-commit", "run"], capture_output=True, text=True, check=False)
+        result = run_subprocess_with_encoding_fallback(["pre-commit", "run"], timeout=hook_timeout)
 
         if result.returncode == 0:
             # All hooks passed
@@ -153,7 +252,7 @@ def run_pre_commit_hooks() -> bool:
         return True
 
 
-def run_lefthook_hooks() -> bool:
+def run_lefthook_hooks(hook_timeout: int = 120) -> bool:
     """Run Lefthook hooks if they exist.
 
     Returns:
@@ -176,9 +275,9 @@ def run_lefthook_hooks() -> bool:
             return True
 
         # Run lefthook hooks on staged files
-        logger.info("Running Lefthook hooks...")
+        logger.info(f"Running Lefthook hooks with {hook_timeout}s timeout...")
         # Run lefthook and capture both stdout and stderr
-        result = subprocess.run(["lefthook", "run", "pre-commit"], capture_output=True, text=True, check=False)
+        result = run_subprocess_with_encoding_fallback(["lefthook", "run", "pre-commit"], timeout=hook_timeout)
 
         if result.returncode == 0:
             # All hooks passed
@@ -224,3 +323,50 @@ def push_changes() -> bool:
     except Exception as e:
         logger.error(f"Failed to push changes: {e}")
         return False
+
+
+def detect_rename_mappings(staged_diff: str) -> dict[str, str]:
+    """Detect file rename mappings from a staged diff.
+
+    Args:
+        staged_diff: The output of 'git diff --cached --binary'
+
+    Returns:
+        Dictionary mapping new_file_path -> old_file_path for rename operations
+    """
+    rename_mappings = {}
+    lines = staged_diff.split("\n")
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        if line.startswith("diff --git a/"):
+            # Extract old and new file paths from diff header
+            if " b/" in line:
+                parts = line.split(" a/")
+                if len(parts) >= 2:
+                    old_path_part = parts[1]
+                    old_path = old_path_part.split(" b/")[0] if " b/" in old_path_part else old_path_part
+
+                    new_path = line.split(" b/")[-1] if " b/" in line else None
+
+                    # Check if this diff represents a rename by looking at following lines
+                    j = i + 1
+                    is_rename = False
+
+                    while j < len(lines) and not lines[j].startswith("diff --git"):
+                        if lines[j].startswith("similarity index "):
+                            is_rename = True
+                            break
+                        elif lines[j].startswith("rename from "):
+                            is_rename = True
+                            break
+                        j += 1
+
+                    if is_rename and old_path and new_path and old_path != new_path:
+                        rename_mappings[new_path] = old_path
+
+        i += 1
+
+    return rename_mappings

gac/init_cli.py

@@ -4,7 +4,10 @@ from pathlib import Path
 
 import click
 import questionary
-from dotenv import set_key
+from dotenv import dotenv_values
+
+from gac.language_cli import configure_language_init_workflow
+from gac.model_cli import _configure_model
 
 GAC_ENV_PATH = Path.home() / ".gac.env"
 
@@ -21,134 +24,46 @@ def _prompt_required_text(prompt: str) -> str | None:
         click.echo("A value is required. Please try again.")
 
 
-@click.command()
-def init() -> None:
-    """Interactively set up $HOME/.gac.env for gac."""
-    click.echo("Welcome to gac initialization!\n")
+def _load_existing_env() -> dict[str, str]:
+    """Ensure the env file exists and return its current values."""
+    existing_env: dict[str, str] = {}
     if GAC_ENV_PATH.exists():
         click.echo(f"$HOME/.gac.env already exists at {GAC_ENV_PATH}. Values will be updated.")
+        existing_env = {k: v for k, v in dotenv_values(str(GAC_ENV_PATH)).items() if v is not None}
     else:
         GAC_ENV_PATH.touch()
         click.echo(f"Created $HOME/.gac.env at {GAC_ENV_PATH}.")
+    return existing_env
 
-    providers = [
-        ("Anthropic", "claude-haiku-4-5"),
-        ("Cerebras", "qwen-3-coder-480b"),
-        ("Chutes", "zai-org/GLM-4.6-FP8"),
-        ("Custom (Anthropic)", ""),
-        ("Custom (OpenAI)", ""),
-        ("DeepSeek", "deepseek-chat"),
-        ("Fireworks", "accounts/fireworks/models/gpt-oss-20b"),
-        ("Gemini", "gemini-2.5-flash"),
-        ("Groq", "meta-llama/llama-4-maverick-17b-128e-instruct"),
-        ("LM Studio", "gemma3"),
-        ("MiniMax", "MiniMax-M2"),
-        ("Ollama", "gemma3"),
-        ("OpenAI", "gpt-4.1-mini"),
-        ("OpenRouter", "openrouter/auto"),
-        ("Streamlake", ""),
-        ("Synthetic", "hf:zai-org/GLM-4.6"),
-        ("Together AI", "openai/gpt-oss-20B"),
-        ("Z.AI", "glm-4.5-air"),
-        ("Z.AI Coding", "glm-4.6"),
-    ]
-    provider_names = [p[0] for p in providers]
-    provider = questionary.select("Select your provider:", choices=provider_names).ask()
-    if not provider:
-        click.echo("Provider selection cancelled. Exiting.")
-        return
-    provider_key = provider.lower().replace(".", "").replace(" ", "-").replace("(", "").replace(")", "")
-
-    is_ollama = provider_key == "ollama"
-    is_lmstudio = provider_key == "lm-studio"
-    is_streamlake = provider_key == "streamlake"
-    is_zai = provider_key in ("zai", "zai-coding")
-    is_custom_anthropic = provider_key == "custom-anthropic"
-    is_custom_openai = provider_key == "custom-openai"
-
-    if is_streamlake:
-        endpoint_id = _prompt_required_text("Enter the Streamlake inference endpoint ID (required):")
-        if endpoint_id is None:
-            click.echo("Streamlake configuration cancelled. Exiting.")
-            return
-        model_to_save = endpoint_id
+
+def _configure_language(existing_env: dict[str, str]) -> None:
+    """Run the language configuration flow using consolidated logic."""
+    click.echo("\n")
+
+    # Use the consolidated language configuration from language_cli
+    success = configure_language_init_workflow(GAC_ENV_PATH)
+
+    if not success:
+        click.echo("Language configuration cancelled or failed.")
     else:
-        model_suggestion = dict(providers)[provider]
-        if model_suggestion == "":
-            model_prompt = "Enter the model (required):"
-        else:
-            model_prompt = f"Enter the model (default: {model_suggestion}):"
-        model = questionary.text(model_prompt, default=model_suggestion).ask()
-        if model is None:
-            click.echo("Model entry cancelled. Exiting.")
-            return
-        model_to_save = model.strip() if model.strip() else model_suggestion
-
-    set_key(str(GAC_ENV_PATH), "GAC_MODEL", f"{provider_key}:{model_to_save}")
-    click.echo(f"Set GAC_MODEL={provider_key}:{model_to_save}")
-
-    if is_custom_anthropic:
-        base_url = _prompt_required_text("Enter the custom Anthropic-compatible base URL (required):")
-        if base_url is None:
-            click.echo("Custom Anthropic base URL entry cancelled. Exiting.")
-            return
-        set_key(str(GAC_ENV_PATH), "CUSTOM_ANTHROPIC_BASE_URL", base_url)
-        click.echo(f"Set CUSTOM_ANTHROPIC_BASE_URL={base_url}")
-
-        api_version = questionary.text(
-            "Enter the API version (optional, press Enter for default: 2023-06-01):", default="2023-06-01"
-        ).ask()
-        if api_version and api_version != "2023-06-01":
-            set_key(str(GAC_ENV_PATH), "CUSTOM_ANTHROPIC_VERSION", api_version)
-            click.echo(f"Set CUSTOM_ANTHROPIC_VERSION={api_version}")
-    elif is_custom_openai:
-        base_url = _prompt_required_text("Enter the custom OpenAI-compatible base URL (required):")
-        if base_url is None:
-            click.echo("Custom OpenAI base URL entry cancelled. Exiting.")
-            return
-        set_key(str(GAC_ENV_PATH), "CUSTOM_OPENAI_BASE_URL", base_url)
-        click.echo(f"Set CUSTOM_OPENAI_BASE_URL={base_url}")
-    elif is_ollama:
-        url_default = "http://localhost:11434"
-        url = questionary.text(f"Enter the Ollama API URL (default: {url_default}):", default=url_default).ask()
-        if url is None:
-            click.echo("Ollama URL entry cancelled. Exiting.")
-            return
-        url_to_save = url.strip() if url.strip() else url_default
-        set_key(str(GAC_ENV_PATH), "OLLAMA_API_URL", url_to_save)
-        click.echo(f"Set OLLAMA_API_URL={url_to_save}")
-    elif is_lmstudio:
-        url_default = "http://localhost:1234"
-        url = questionary.text(f"Enter the LM Studio API URL (default: {url_default}):", default=url_default).ask()
-        if url is None:
-            click.echo("LM Studio URL entry cancelled. Exiting.")
-            return
-        url_to_save = url.strip() if url.strip() else url_default
-        set_key(str(GAC_ENV_PATH), "LMSTUDIO_API_URL", url_to_save)
-        click.echo(f"Set LMSTUDIO_API_URL={url_to_save}")
-
-    api_key_prompt = "Enter your API key (input hidden, can be set later):"
-    if is_ollama or is_lmstudio:
-        click.echo(
-            "This provider typically runs locally. API keys are optional unless your instance requires authentication."
-        )
-        api_key_prompt = "Enter your API key (optional, press Enter to skip):"
-
-    api_key = questionary.password(api_key_prompt).ask()
-    if api_key:
-        if is_lmstudio:
-            api_key_name = "LMSTUDIO_API_KEY"
-        elif is_zai:
-            api_key_name = "ZAI_API_KEY"
-        elif is_custom_anthropic:
-            api_key_name = "CUSTOM_ANTHROPIC_API_KEY"
-        elif is_custom_openai:
-            api_key_name = "CUSTOM_OPENAI_API_KEY"
-        else:
-            api_key_name = f"{provider_key.upper()}_API_KEY"
-        set_key(str(GAC_ENV_PATH), api_key_name, api_key)
-        click.echo(f"Set {api_key_name} (hidden)")
-    elif is_ollama or is_lmstudio:
-        click.echo("Skipping API key. You can add one later if needed.")
-
-    click.echo(f"\ngac environment setup complete. You can edit {GAC_ENV_PATH} to update values later.")
+        click.echo("Language configuration completed.")
+
+
+@click.command()
+def init() -> None:
+    """Interactively set up $HOME/.gac.env for gac."""
+    click.echo("Welcome to gac initialization!\n")
+
+    existing_env = _load_existing_env()
+
+    if not _configure_model(existing_env):
+        click.echo("Model configuration cancelled. Exiting.")
+        return
+
+    _configure_language(existing_env)
+
+    click.echo("\ngac environment setup complete 🎉")
+    click.echo("Configuration saved to:")
+    click.echo(f"  {GAC_ENV_PATH}")
+    click.echo("\nYou can now run 'gac' in any Git repository to generate commit messages.")
+    click.echo("Run 'gac --help' to see available options.")