gac 0.17.2__py3-none-any.whl → 3.6.0__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:
@@ -120,15 +219,15 @@ def run_pre_commit_hooks() -> bool:
     # Check if pre-commit is installed and configured
     try:
         # First check if pre-commit is installed
-        result = run_subprocess(["pre-commit", "--version"], silent=True, raise_on_error=False)
-        if not result:
+        version_check = run_subprocess(["pre-commit", "--version"], silent=True, raise_on_error=False)
+        if not version_check:
             logger.debug("pre-commit not installed, skipping hooks")
             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,6 +252,56 @@ def run_pre_commit_hooks() -> bool:
         return True
 
 
+def run_lefthook_hooks(hook_timeout: int = 120) -> bool:
+    """Run Lefthook hooks if they exist.
+
+    Returns:
+        True if Lefthook hooks passed or don't exist, False if they failed.
+    """
+    # Check for common Lefthook configuration files
+    lefthook_configs = [".lefthook.yml", "lefthook.yml", ".lefthook.yaml", "lefthook.yaml"]
+    config_exists = any(os.path.exists(config) for config in lefthook_configs)
+
+    if not config_exists:
+        logger.debug("No Lefthook configuration found, skipping Lefthook hooks")
+        return True
+
+    # Check if lefthook is installed and configured
+    try:
+        # First check if lefthook is installed
+        version_check = run_subprocess(["lefthook", "--version"], silent=True, raise_on_error=False)
+        if not version_check:
+            logger.debug("Lefthook not installed, skipping hooks")
+            return True
+
+        # Run lefthook hooks on staged files
+        logger.info(f"Running Lefthook hooks with {hook_timeout}s timeout...")
+        # Run lefthook and capture both stdout and stderr
+        result = run_subprocess_with_encoding_fallback(["lefthook", "run", "pre-commit"], timeout=hook_timeout)
+
+        if result.returncode == 0:
+            # All hooks passed
+            return True
+        else:
+            # Lefthook hooks failed - show the output
+            output = result.stdout if result.stdout else ""
+            error = result.stderr if result.stderr else ""
+
+            # Combine outputs (lefthook usually outputs to stdout)
+            full_output = output + ("\n" + error if error else "")
+
+            if full_output.strip():
+                # Show which hooks failed and why
+                logger.error(f"Lefthook hooks failed:\n{full_output}")
+            else:
+                logger.error(f"Lefthook hooks failed with exit code {result.returncode}")
+            return False
+    except Exception as e:
+        logger.debug(f"Error running Lefthook: {e}")
+        # If lefthook isn't available, don't block the commit
+        return True
+
+
 def push_changes() -> bool:
     """Push committed changes to the remote repository."""
     remote_exists = run_git_command(["remote"])
@@ -174,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,43 +4,66 @@ 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"
 
 
-@click.command()
-def init() -> None:
-    """Interactively set up $HOME/.gac.env for gac."""
-    click.echo("Welcome to gac initialization!\n")
+def _prompt_required_text(prompt: str) -> str | None:
+    """Prompt until a non-empty string is provided or the user cancels."""
+    while True:
+        response = questionary.text(prompt).ask()
+        if response is None:
+            return None
+        value = response.strip()
+        if value:
+            return value  # type: ignore[no-any-return]
+        click.echo("A value is required. Please try again.")
+
+
+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
+
+
+def _configure_language(existing_env: dict[str, str]) -> None:
+    """Run the language configuration flow using consolidated logic."""
+    click.echo("\n")
 
-    providers = [
-        ("Anthropic", "claude-3-5-haiku-latest"),
-        ("Cerebras", "qwen-3-coder-480b"),
-        ("Groq", "meta-llama/llama-4-maverick-17b-128e-instruct"),
-        ("Ollama", "gemma3"),
-        ("OpenAI", "gpt-4.1-mini"),
-    ]
-    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.")
+    # 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:
+        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
-    provider_key = provider.lower()
-    model_suggestion = dict(providers)[provider]
-    model = questionary.text(f"Enter the model (default: {model_suggestion}):", default=model_suggestion).ask()
-    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}")
-
-    api_key = questionary.password("Enter your API key (input hidden, can be set later):").ask()
-    if api_key:
-        set_key(str(GAC_ENV_PATH), f"{provider_key.upper()}_API_KEY", api_key)
-        click.echo(f"Set {provider_key.upper()}_API_KEY (hidden)")
-
-    click.echo(f"\ngac environment setup complete. You can edit {GAC_ENV_PATH} to update values later.")
+
+    _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.")