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

gac/providers/zai.py

@@ -1,10 +1,15 @@
 """Z.AI API provider for gac."""
 
+import logging
 import os
 
 import httpx
 
+from gac.constants import ProviderDefaults
 from gac.errors import AIError
+from gac.utils import get_ssl_verify
+
+logger = logging.getLogger(__name__)
 
 
 def _call_zai_api_impl(
@@ -18,8 +23,12 @@ def _call_zai_api_impl(
     headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
     data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
 
+    logger.debug(f"Calling {api_name} API with model={model}")
+
     try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response = httpx.post(
+            url, headers=headers, json=data, timeout=ProviderDefaults.HTTP_TIMEOUT, verify=get_ssl_verify()
+        )
         response.raise_for_status()
         response_data = response.json()
 
@@ -32,6 +41,7 @@ def _call_zai_api_impl(
                     raise AIError.model_error(f"{api_name} API returned null content")
                 if content == "":
                     raise AIError.model_error(f"{api_name} API returned empty content")
+                logger.debug(f"{api_name} API response received successfully")
                 return content
             else:
                 raise AIError.model_error(f"{api_name} API response missing content: {response_data}")

gac/security.py

@@ -54,7 +54,7 @@ class SecretPatterns:
     PRIVATE_KEY = re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----")
 
     # Bearer Tokens (require actual token with specific characteristics)
-    BEARER_TOKEN = re.compile(r"Bearer\s+[A-Za-z0-9]{20,}[/=]*\s", re.IGNORECASE)
+    BEARER_TOKEN = re.compile(r"Bearer\s+[A-Za-z0-9]{20,}[/=]*(?:\s|$)", re.IGNORECASE)
 
     # JWT Tokens
     JWT_TOKEN = re.compile(r"eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+")

gac/utils.py

@@ -1,15 +1,46 @@
 """Utility functions for gac."""
 
+import locale
 import logging
+import os
 import subprocess
+import sys
+from functools import lru_cache
 
 from rich.console import Console
 from rich.theme import Theme
 
-from gac.constants import Logging
+from gac.constants import EnvDefaults, Logging
 from gac.errors import GacError
 
 
+@lru_cache(maxsize=1)
+def should_skip_ssl_verification() -> bool:
+    """Return True when SSL certificate verification should be skipped.
+
+    This is useful for corporate environments with proxy servers that
+    intercept SSL traffic and cause certificate verification failures.
+
+    Can be enabled via:
+    - GAC_NO_VERIFY_SSL=true environment variable
+    - --no-verify-ssl CLI flag (which sets the env var)
+
+    Returns:
+        True if SSL verification should be skipped, False otherwise.
+    """
+    value = os.getenv("GAC_NO_VERIFY_SSL", str(EnvDefaults.NO_VERIFY_SSL))
+    return value.lower() in ("true", "1", "yes", "on")
+
+
+def get_ssl_verify() -> bool:
+    """Get the SSL verification setting for httpx requests.
+
+    Returns:
+        True to verify SSL certificates (default), False to skip verification.
+    """
+    return not should_skip_ssl_verification()
+
+
 def setup_logging(
     log_level: int | str = Logging.DEFAULT_LEVEL,
     quiet: bool = False,
@@ -65,18 +96,47 @@ def print_message(message: str, level: str = "info") -> None:
     console.print(message, style=level)
 
 
-def run_subprocess(
+def get_safe_encodings() -> list[str]:
+    """Get a list of safe encodings to try for subprocess calls, in order of preference.
+
+    Returns:
+        List of encoding strings to try, with UTF-8 first
+    """
+    encodings = ["utf-8"]
+
+    # Add locale encoding as fallback
+    locale_encoding = locale.getpreferredencoding(False)
+    if locale_encoding and locale_encoding not in encodings:
+        encodings.append(locale_encoding)
+
+    # Windows-specific fallbacks
+    if sys.platform == "win32":
+        windows_encodings = ["cp65001", "cp936", "cp1252"]  # UTF-8, GBK, Windows-1252
+        for enc in windows_encodings:
+            if enc not in encodings:
+                encodings.append(enc)
+
+    # Final fallback to system default
+    if "utf-8" not in encodings:
+        encodings.append("utf-8")
+
+    return encodings
+
+
+def run_subprocess_with_encoding(
     command: list[str],
+    encoding: str,
     silent: bool = False,
     timeout: int = 60,
     check: bool = True,
     strip_output: bool = True,
     raise_on_error: bool = True,
 ) -> str:
-    """Run a subprocess command safely and return the output.
+    """Run subprocess with a specific encoding, handling encoding errors gracefully.
 
     Args:
         command: List of command arguments
+        encoding: Specific encoding to use
         silent: If True, suppress debug logging
         timeout: Command timeout in seconds
         check: Whether to check return code (for compatibility)
@@ -91,7 +151,7 @@ def run_subprocess(
         subprocess.CalledProcessError: If the command fails and raise_on_error is True
     """
     if not silent:
-        logger.debug(f"Running command: {' '.join(command)}")
+        logger.debug(f"Running command: {' '.join(command)} (encoding: {encoding})")
 
     try:
         result = subprocess.run(
@@ -100,6 +160,8 @@ def run_subprocess(
             text=True,
             check=False,
             timeout=timeout,
+            encoding=encoding,
+            errors="replace",  # Replace problematic characters instead of crashing
         )
 
         should_raise = result.returncode != 0 and (check or raise_on_error)
@@ -123,6 +185,11 @@ def run_subprocess(
         if raise_on_error:
             raise
         return ""
+    except UnicodeError as e:
+        # This should be rare with errors="replace", but handle it just in case
+        if not silent:
+            logger.debug(f"Encoding error with {encoding}: {e}")
+        raise
     except Exception as e:
         if not silent:
             logger.debug(f"Command error: {e}")
@@ -130,3 +197,204 @@ def run_subprocess(
             # Convert generic exceptions to CalledProcessError for consistency
             raise subprocess.CalledProcessError(1, command, "", str(e)) from e
         return ""
+
+
+def run_subprocess(
+    command: list[str],
+    silent: bool = False,
+    timeout: int = 60,
+    check: bool = True,
+    strip_output: bool = True,
+    raise_on_error: bool = True,
+) -> str:
+    """Run a subprocess command safely and return the output, trying multiple encodings.
+
+    Args:
+        command: List of command arguments
+        silent: If True, suppress debug logging
+        timeout: Command timeout in seconds
+        check: Whether to check return code (for compatibility)
+        strip_output: Whether to strip whitespace from output
+        raise_on_error: Whether to raise an exception on error
+
+    Returns:
+        Command output as string
+
+    Raises:
+        GacError: If the command times out
+        subprocess.CalledProcessError: If the command fails and raise_on_error is True
+
+    Note:
+        Tries multiple encodings in order: utf-8, locale encoding, platform-specific fallbacks
+        This prevents UnicodeDecodeError on systems with non-UTF-8 locales (e.g., Chinese Windows)
+    """
+    encodings = get_safe_encodings()
+    last_exception = None
+
+    for encoding in encodings:
+        try:
+            return run_subprocess_with_encoding(
+                command=command,
+                encoding=encoding,
+                silent=silent,
+                timeout=timeout,
+                check=check,
+                strip_output=strip_output,
+                raise_on_error=raise_on_error,
+            )
+        except UnicodeError as e:
+            last_exception = e
+            if not silent:
+                logger.debug(f"Failed to decode with {encoding}: {e}")
+            continue
+        except (subprocess.CalledProcessError, GacError, subprocess.TimeoutExpired):
+            # These are not encoding-related errors, so don't retry with other encodings
+            raise
+
+    # If we get here, all encodings failed with UnicodeError
+    if not silent:
+        logger.error(f"Failed to decode command output with any encoding: {encodings}")
+
+    # Raise the last UnicodeError we encountered
+    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 edit_commit_message_inplace(message: str) -> str | None:
+    """Edit commit message in-place using rich terminal editing.
+
+    Uses prompt_toolkit to provide a rich editing experience with:
+    - Multi-line editing
+    - Vi/Emacs key bindings
+    - Line editing capabilities
+    - Esc+Enter or Ctrl+S to submit
+    - Ctrl+C to cancel
+
+    Args:
+        message: The initial commit message
+
+    Returns:
+        The edited commit message, or None if editing was cancelled
+
+    Example:
+        >>> edited = edit_commit_message_inplace("feat: add feature")
+        >>> # User can edit the message using vi/emacs key bindings
+        >>> # Press Esc+Enter or Ctrl+S to submit
+    """
+    from prompt_toolkit import Application
+    from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.document import Document
+    from prompt_toolkit.enums import EditingMode
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout import HSplit, Layout, Window
+    from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+    from prompt_toolkit.layout.margins import ScrollbarMargin
+    from prompt_toolkit.styles import Style
+
+    try:
+        console.print("\n[info]Edit commit message:[/info]")
+        console.print()
+
+        # Create buffer for text editing
+        text_buffer = Buffer(
+            document=Document(text=message, cursor_position=0),
+            multiline=True,
+            enable_history_search=False,
+        )
+
+        # Track submission state
+        cancelled = {"value": False}
+        submitted = {"value": False}
+
+        # Create text editor window
+        text_window = Window(
+            content=BufferControl(
+                buffer=text_buffer,
+                focus_on_click=True,
+            ),
+            height=lambda: max(5, message.count("\n") + 3),
+            wrap_lines=True,
+            right_margins=[ScrollbarMargin()],
+        )
+
+        # Create hint window
+        hint_window = Window(
+            content=FormattedTextControl(
+                text=[("class:hint", " Esc+Enter or Ctrl+S to submit | Ctrl+C to cancel ")],
+            ),
+            height=1,
+            dont_extend_height=True,
+        )
+
+        # Create layout
+        root_container = HSplit(
+            [
+                text_window,
+                hint_window,
+            ]
+        )
+
+        layout = Layout(root_container, focused_element=text_window)
+
+        # Create key bindings
+        kb = KeyBindings()
+
+        @kb.add("c-s")
+        def _(event):
+            """Submit with Ctrl+S."""
+            submitted["value"] = True
+            event.app.exit()
+
+        @kb.add("c-c")
+        def _(event):
+            """Cancel editing."""
+            cancelled["value"] = True
+            event.app.exit()
+
+        @kb.add("escape", "enter")
+        def _(event):
+            """Submit with Esc+Enter."""
+            submitted["value"] = True
+            event.app.exit()
+
+        # Create and run application
+        custom_style = Style.from_dict(
+            {
+                "hint": "#888888",
+            }
+        )
+
+        app: Application[None] = Application(
+            layout=layout,
+            key_bindings=kb,
+            full_screen=False,
+            mouse_support=False,
+            editing_mode=EditingMode.VI,  # Enable vi key bindings
+            style=custom_style,
+        )
+
+        app.run()
+
+        # Handle result
+        if cancelled["value"]:
+            console.print("\n[yellow]Edit cancelled.[/yellow]")
+            return None
+
+        if submitted["value"]:
+            edited_message = text_buffer.text.strip()
+            if not edited_message:
+                console.print("[yellow]Commit message cannot be empty. Edit cancelled.[/yellow]")
+                return None
+            return edited_message
+
+        return None
+
+    except (EOFError, KeyboardInterrupt):
+        console.print("\n[yellow]Edit cancelled.[/yellow]")
+        return None
+    except Exception as e:
+        logger.error(f"Error during in-place editing: {e}")
+        console.print(f"[error]Failed to edit commit message: {e}[/error]")
+        return None

gac/workflow_utils.py

@@ -0,0 +1,217 @@
+import logging
+import tempfile
+from pathlib import Path
+
+import click
+from prompt_toolkit import prompt
+from rich.console import Console
+from rich.panel import Panel
+
+from gac.constants import EnvDefaults
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+def handle_confirmation_loop(
+    commit_message: str,
+    conversation_messages: list[dict[str, str]],
+    quiet: bool,
+    model: str,
+) -> tuple[str, str, list[dict[str, str]]]:
+    from gac.utils import edit_commit_message_inplace
+
+    while True:
+        response = click.prompt(
+            "Proceed with commit above? [y/n/r/e/<feedback>]",
+            type=str,
+            show_default=False,
+        ).strip()
+        response_lower = response.lower()
+
+        if response_lower in ["y", "yes"]:
+            return ("yes", commit_message, conversation_messages)
+        if response_lower in ["n", "no"]:
+            return ("no", commit_message, conversation_messages)
+        if response == "":
+            continue
+        if response_lower in ["e", "edit"]:
+            edited_message = edit_commit_message_inplace(commit_message)
+            if edited_message:
+                commit_message = edited_message
+                conversation_messages[-1] = {"role": "assistant", "content": commit_message}
+                logger.info("Commit message edited by user")
+                console.print("\n[bold green]Edited commit message:[/bold green]")
+                console.print(Panel(commit_message, title="Commit Message", border_style="cyan"))
+            else:
+                console.print("[yellow]Using previous message.[/yellow]")
+                console.print(Panel(commit_message, title="Commit Message", border_style="cyan"))
+            continue
+        if response_lower in ["r", "reroll"]:
+            msg = "Please provide an alternative commit message using the same repository context."
+            conversation_messages.append({"role": "user", "content": msg})
+            console.print("[cyan]Regenerating commit message...[/cyan]")
+            return ("regenerate", commit_message, conversation_messages)
+
+        msg = f"Please revise the commit message based on this feedback: {response}"
+        conversation_messages.append({"role": "user", "content": msg})
+        console.print(f"[cyan]Regenerating commit message with feedback: {response}[/cyan]")
+        return ("regenerate", commit_message, conversation_messages)
+
+
+def execute_commit(commit_message: str, no_verify: bool, hook_timeout: int | None = None) -> None:
+    from gac.git import run_git_command
+
+    commit_args = ["commit", "-m", commit_message]
+    if no_verify:
+        commit_args.append("--no-verify")
+    effective_timeout = hook_timeout if hook_timeout and hook_timeout > 0 else EnvDefaults.HOOK_TIMEOUT
+    run_git_command(commit_args, timeout=effective_timeout)
+    logger.info("Commit created successfully")
+    console.print("[green]Commit created successfully[/green]")
+
+
+def check_token_warning(
+    prompt_tokens: int,
+    warning_limit: int,
+    require_confirmation: bool,
+) -> bool:
+    if warning_limit and prompt_tokens > warning_limit:
+        console.print(
+            f"[yellow]⚠️  WARNING: Prompt has {prompt_tokens} tokens (warning threshold: {warning_limit})[/yellow]"
+        )
+        if require_confirmation:
+            proceed = click.confirm("Do you want to continue anyway?", default=True)
+            if not proceed:
+                console.print("[yellow]Aborted due to large token count.[/yellow]")
+                return False
+    return True
+
+
+def display_commit_message(commit_message: str, prompt_tokens: int, model: str, quiet: bool) -> None:
+    from gac.ai_utils import count_tokens
+
+    console.print("[bold green]Generated commit message:[/bold green]")
+    console.print(Panel(commit_message, title="Commit Message", border_style="cyan"))
+
+    if not quiet:
+        completion_tokens = count_tokens(commit_message, model)
+        total_tokens = prompt_tokens + completion_tokens
+        console.print(
+            f"[dim]Token usage: {prompt_tokens} prompt + {completion_tokens} completion = {total_tokens} total[/dim]"
+        )
+
+
+def restore_staging(staged_files: list[str], staged_diff: str | None = None) -> None:
+    """Restore the git staging area to a previous state.
+
+    Args:
+        staged_files: List of file paths that should be staged
+        staged_diff: Optional staged diff to reapply for partial staging
+    """
+    from gac.git import run_git_command
+
+    run_git_command(["reset", "HEAD"])
+
+    if staged_diff:
+        temp_path: Path | None = None
+        try:
+            with tempfile.NamedTemporaryFile("w", delete=False) as tmp:
+                tmp.write(staged_diff)
+                temp_path = Path(tmp.name)
+            run_git_command(["apply", "--cached", str(temp_path)])
+            return
+        except Exception as e:
+            logger.warning(f"Failed to reapply staged diff, falling back to file list: {e}")
+        finally:
+            if temp_path:
+                temp_path.unlink(missing_ok=True)
+
+    for file_path in staged_files:
+        try:
+            run_git_command(["add", file_path])
+        except Exception as e:
+            logger.warning(f"Failed to restore staging for {file_path}: {e}")
+
+
+def collect_interactive_answers(questions: list[str]) -> dict[str, str] | None:
+    """Collect user answers to generated questions interactively.
+
+    Args:
+        questions: List of generated questions
+
+    Returns:
+        Dictionary mapping questions to answers, or None if user aborted
+    """
+    if not questions:
+        return {}
+
+    console.print("\n[bold cyan]🤝 Let's clarify your commit intent:[/bold cyan]")
+    console.print("[dim]Answer each question, press Enter to skip, or type:[/dim]")
+    console.print("[dim]  • 'skip' - skip remaining questions[/dim]")
+    console.print("[dim]  • 'quit' - abort interactive mode[/dim]\n")
+
+    answers = {}
+
+    for i, question in enumerate(questions, 1):
+        # Display the question with nice formatting
+        console.print(f"[bold blue]Question {i}:[/bold blue] {question}")
+
+        try:
+            answer = prompt("Your answer: ").strip()
+
+            # Handle special commands
+            answer_lower = answer.lower()
+
+            if answer_lower == "quit":
+                console.print("\n[yellow]⚠️  Interactive mode aborted by user[/yellow]")
+                return None
+            elif answer_lower == "skip":
+                console.print("[dim]Skipping remaining questions...[/dim]")
+                break
+            elif answer_lower == "" or answer_lower == "none":
+                # User explicitly skipped this question
+                console.print("[dim]↳ Skipped[/dim]")
+                continue
+            else:
+                # Valid answer provided
+                answers[question] = answer
+                console.print("[dim]↳ Got it![/dim]")
+
+        except KeyboardInterrupt:
+            # User pressed Ctrl+C
+            console.print("\n[yellow]⚠️  Interactive mode aborted by user[/yellow]")
+            return None
+
+        console.print()  # Add spacing between questions
+
+    return answers
+
+
+def format_answers_for_prompt(answers: dict[str, str]) -> str:
+    """Format collected answers for inclusion in the commit message prompt.
+
+    Args:
+        answers: Dictionary mapping questions to answers
+
+    Returns:
+        Formatted string for inclusion in the prompt
+    """
+    if not answers:
+        return ""
+
+    formatted_lines = []
+    for question, answer in answers.items():
+        formatted_lines.append(f"Q: {question}")
+        formatted_lines.append(f"A: {answer}")
+        formatted_lines.append("")
+
+    answers_text = "\n".join(formatted_lines).rstrip()
+
+    return (
+        f"\n\n<user_answers>\n"
+        f"The user provided the following clarifying information:\n\n"
+        f"{answers_text}\n\n"
+        f"</user_answers>\n\n"
+        f"<context_request>Use the user's answers above to craft a more accurate and informative commit message that captures their specific intent and context.</context_request>"
+    )