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

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.")