gac 3.10.11__tar.gz → 3.12.0__tar.gz

{gac-3.10.11 → gac-3.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gac
-Version: 3.10.11
+Version: 3.12.0
 Summary: LLM-powered Git commit message generator with multi-provider support
 Project-URL: Homepage, https://github.com/cellwebb/gac
 Project-URL: Documentation, https://github.com/cellwebb/gac#readme
@@ -29,7 +29,6 @@ Requires-Dist: pydantic>=2.12.0
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: questionary
 Requires-Dist: rich>=14.1.0
-Requires-Dist: tiktoken>=0.12.0
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: codecov; extra == 'dev'

{gac-3.10.11 → gac-3.12.0}/pyproject.toml

@@ -29,8 +29,7 @@ dependencies = [
     "httpx>=0.28.0",
     "httpcore>=1.0.9",  # Required for Python 3.14 compatibility
 
-    # Token counting (OpenAI models)
-    "tiktoken>=0.12.0",
+
 
     # Core functionality
     "pydantic>=2.12.0",

{gac-3.10.11 → gac-3.12.0}/src/gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "3.10.11"
+__version__ = "3.12.0"

{gac-3.10.11 → gac-3.12.0}/src/gac/ai_utils.py

@@ -8,14 +8,11 @@ import logging
 import os
 import time
 from collections.abc import Callable
-from functools import lru_cache
 from typing import Any, cast
 
-import tiktoken
 from rich.console import Console
 from rich.status import Status
 
-from gac.constants import EnvDefaults, Utility
 from gac.errors import AIError
 from gac.oauth import QwenOAuthProvider, refresh_token_if_expired
 from gac.oauth.token_store import TokenStore
@@ -25,29 +22,16 @@ logger = logging.getLogger(__name__)
 console = Console()
 
 
-@lru_cache(maxsize=1)
-def _should_skip_tiktoken_counting() -> bool:
-    """Return True when token counting should avoid tiktoken calls entirely."""
-    value = os.getenv("GAC_NO_TIKTOKEN", str(EnvDefaults.NO_TIKTOKEN))
-    return value.lower() in ("true", "1", "yes", "on")
-
-
 def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: str) -> int:
-    """Count tokens in content using the model's tokenizer."""
+    """Count tokens in content using character-based estimation (1 token per 3.4 characters)."""
     text = extract_text_content(content)
     if not text:
         return 0
 
-    if _should_skip_tiktoken_counting():
-        return len(text) // 4
-
-    try:
-        encoding = get_encoding(model)
-        return len(encoding.encode(text))
-    except (KeyError, UnicodeError, ValueError) as e:
-        logger.error(f"Error counting tokens: {e}")
-        # Fallback to rough estimation (4 chars per token on average)
-        return len(text) // 4
+    # Use simple character-based estimation: 1 token per 3.4 characters (rounded)
+    result = round(len(text) / 3.4)
+    # Ensure at least 1 token for non-empty text
+    return result if result > 0 else 1
 
 
 def extract_text_content(content: str | list[dict[str, str]] | dict[str, Any]) -> str:
@@ -61,24 +45,6 @@ def extract_text_content(content: str | list[dict[str, str]] | dict[str, Any]) -
     return ""
 
 
-@lru_cache(maxsize=1)
-def get_encoding(model: str) -> tiktoken.Encoding:
-    """Get the appropriate encoding for a given model."""
-    provider, model_name = model.split(":", 1) if ":" in model else (None, model)
-
-    if provider != "openai":
-        return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
-
-    try:
-        return tiktoken.encoding_for_model(model_name)
-    except KeyError:
-        # Fall back to default encoding if model not found
-        return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
-    except (OSError, ConnectionError):
-        # If there are any network/SSL issues, fall back to default encoding
-        return tiktoken.get_encoding(Utility.DEFAULT_ENCODING)
-
-
 def generate_with_retries(
     provider_funcs: dict[str, Callable[..., str]],
     model: str,

{gac-3.10.11 → gac-3.12.0}/src/gac/cli.py

@@ -24,6 +24,7 @@ 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.prompt_cli import prompt as prompt_cli
 from gac.utils import setup_logging
 from gac.workflow_context import CLIOptions
 
@@ -206,6 +207,7 @@ cli.add_command(diff_cli)
 cli.add_command(init_cli)
 cli.add_command(language_cli)
 cli.add_command(model_cli)
+cli.add_command(prompt_cli)
 
 
 @click.command(context_settings=language_cli.context_settings)

{gac-3.10.11 → gac-3.12.0}/src/gac/config.py

@@ -27,7 +27,6 @@ class GACConfig(TypedDict, total=False):
     warning_limit_tokens: int
     always_include_scope: bool
     skip_secret_scan: bool
-    no_tiktoken: bool
     no_verify_ssl: bool
     verbose: bool
     system_prompt_path: str | None
@@ -110,7 +109,6 @@ def load_config() -> GACConfig:
         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"),
         "no_verify_ssl": os.getenv("GAC_NO_VERIFY_SSL", str(EnvDefaults.NO_VERIFY_SSL)).lower()
         in ("true", "1", "yes", "on"),
         "verbose": os.getenv("GAC_VERBOSE", str(EnvDefaults.VERBOSE)).lower() in ("true", "1", "yes", "on"),

{gac-3.10.11 → gac-3.12.0}/src/gac/constants/defaults.py

@@ -13,7 +13,6 @@ class EnvDefaults:
     ALWAYS_INCLUDE_SCOPE: bool = False
     SKIP_SECRET_SCAN: bool = False
     VERBOSE: bool = False
-    NO_TIKTOKEN: bool = False
     NO_VERIFY_SSL: bool = False  # Skip SSL certificate verification (for corporate proxies)
     HOOK_TIMEOUT: int = 120  # Timeout for pre-commit and lefthook hooks in seconds
 
@@ -34,7 +33,6 @@ class Logging:
 class Utility:
     """General utility constants."""
 
-    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

{gac-3.10.11 → gac-3.12.0}/src/gac/grouped_commit_workflow.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """Grouped commit workflow handling for gac."""
+# mypy: warn-unreachable=false
 
 import json
 import logging
@@ -41,10 +42,23 @@ class GroupedCommitWorkflow:
         self, staged: set[str], grouped_result: dict[str, Any]
     ) -> tuple[bool, str, str]:
         """Validate that grouped commits cover all staged files correctly."""
-        commits = grouped_result.get("commits", []) if isinstance(grouped_result, dict) else []
+        # Handle edge cases that should be caught elsewhere
+        if not isinstance(grouped_result, dict):
+            return True, "", ""
+
+        commits = grouped_result.get("commits", [])
+        # Handle empty commits case (defensive - unreachable in normal flow)
+        if not commits:  # pragma: no cover  # type: ignore[unreachable]
+            return True, "", ""  # Empty commits is valid (will be caught elsewhere)
+
+        # Check if any commit has invalid structure - these should be caught in JSON validation
+        for commit in commits:
+            if not isinstance(commit, dict) or "files" not in commit:
+                return True, "", ""  # Invalid structure - let JSON validation handle it
+
         all_files: list[str] = []
         for commit in commits:
-            files = commit.get("files", []) if isinstance(commit, dict) else []
+            files = commit.get("files", [])
             all_files.extend([str(p) for p in files])
 
         counts = Counter(all_files)
@@ -84,11 +98,13 @@ class GroupedCommitWorkflow:
         conversation_messages.append({"role": "user", "content": feedback_message})
         if attempts >= content_retry_budget:
             logger.error(error_message)
+            logger.error("Raw model output:")
             console.print(f"\n[red]{error_message}[/red]")
             console.print("\n[yellow]Raw model output:[/yellow]")
             console.print(Panel(raw_response, title="Model Output", border_style="yellow"))
             return True
         if not quiet:
+            logger.info(f"Retry {attempts} of {content_retry_budget - 1}: {retry_context}")
             console.print(f"[yellow]Retry {attempts} of {content_retry_budget - 1}: {retry_context}[/yellow]")
         return False
 

{gac-3.10.11 → gac-3.12.0}/src/gac/model_cli.py

@@ -84,18 +84,18 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
         ("Anthropic", "claude-haiku-4-5"),
         ("Azure OpenAI", "gpt-5-mini"),
         ("Cerebras", "zai-glm-4.6"),
-        ("Chutes", "zai-org/GLM-4.6-FP8"),
+        ("Chutes", "zai-org/GLM-4.7-TEE"),
         ("Claude Code (OAuth)", "claude-sonnet-4-5"),
         ("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"),
+        ("Fireworks", "fireworks/glm-4p7"),
+        ("Gemini", "gemini-3-flash-preview"),
+        ("Groq", "openai/gpt-oss-120b"),
         ("Kimi for Coding", "kimi-for-coding"),
         ("LM Studio", "gemma3"),
-        ("MiniMax.io", "MiniMax-M2"),
-        ("Mistral", "mistral-small-latest"),
+        ("MiniMax.io", "MiniMax-M2.1"),
+        ("Mistral", "devstral-2512"),
         ("Moonshot AI", "kimi-k2-thinking-turbo"),
         ("Ollama", "gemma3"),
         ("OpenAI", "gpt-5-mini"),
@@ -103,10 +103,10 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
         ("Qwen.ai (OAuth)", "qwen3-coder-plus"),
         ("Replicate", "openai/gpt-oss-120b"),
         ("Streamlake", ""),
-        ("Synthetic.new", "hf:zai-org/GLM-4.6"),
-        ("Together AI", "openai/gpt-oss-20B"),
-        ("Z.AI", "glm-4.5-air"),
-        ("Z.AI Coding", "glm-4.6"),
+        ("Synthetic.new", "hf:zai-org/GLM-4.7"),
+        ("Together AI", "openai/gpt-oss-120B"),
+        ("Z.AI", "glm-47"),
+        ("Z.AI Coding", "glm-4.7"),
     ]
     provider_names = [p[0] for p in providers]
     provider = questionary.select(

gac-3.12.0/src/gac/prompt_cli.py

@@ -0,0 +1,266 @@
+"""CLI for managing custom system prompts."""
+
+import logging
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+GAC_CONFIG_DIR = Path.home() / ".config" / "gac"
+CUSTOM_PROMPT_FILE = GAC_CONFIG_DIR / "custom_system_prompt.txt"
+
+
+def get_active_custom_prompt() -> tuple[str | None, str | None]:
+    """Return (content, source) for active custom prompt, or (None, None) if none.
+
+    Returns:
+        Tuple of (content, source) where:
+        - content: The custom prompt text, or None if using default
+        - source: Human-readable description of where the prompt came from, or None if using default
+    """
+    # Check GAC_SYSTEM_PROMPT_PATH env var first (highest precedence)
+    env_path = os.getenv("GAC_SYSTEM_PROMPT_PATH")
+    if env_path:
+        env_file = Path(env_path)
+        if env_file.exists():
+            try:
+                content = env_file.read_text(encoding="utf-8")
+                return content, f"GAC_SYSTEM_PROMPT_PATH={env_path}"
+            except OSError:
+                pass
+
+    # Check stored custom prompt file
+    if CUSTOM_PROMPT_FILE.exists():
+        try:
+            content = CUSTOM_PROMPT_FILE.read_text(encoding="utf-8")
+            return content, str(CUSTOM_PROMPT_FILE)
+        except OSError:
+            pass
+
+    # No custom prompt configured
+    return None, None
+
+
+@click.group()
+def prompt() -> None:
+    """Manage custom system prompts."""
+    pass
+
+
+@prompt.command()
+def show() -> None:
+    """Show the active custom system prompt."""
+    from gac.prompt import _load_default_system_template
+
+    content, source = get_active_custom_prompt()
+
+    if content is None:
+        console.print("[dim]No custom prompt configured. Showing default:[/dim]\n")
+        default_template = _load_default_system_template()
+        console.print(Panel(default_template.strip(), title="Default System Prompt", border_style="green"))
+        return
+
+    # Determine title based on source
+    if source and source.startswith("GAC_SYSTEM_PROMPT_PATH="):
+        title = f"Custom System Prompt (from {source})"
+    else:
+        title = f"Custom System Prompt ({source})"
+
+    console.print(Panel(content.strip(), title=title, border_style="green"))
+
+
+def _edit_text_interactive(initial_text: str) -> str | None:
+    """Edit text interactively using prompt_toolkit.
+
+    Returns edited text, or None if cancelled.
+    """
+    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, KeyPressEvent
+    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:
+        import shutil
+
+        console.print("\n[bold]Edit your custom system prompt:[/bold]")
+        console.print("[dim]Esc+Enter or Ctrl+S to save | Ctrl+C to cancel[/dim]\n")
+
+        # Create buffer for text editing
+        text_buffer = Buffer(
+            document=Document(text=initial_text, cursor_position=0),
+            multiline=True,
+            enable_history_search=False,
+        )
+
+        # Track state
+        cancelled = {"value": False}
+        submitted = {"value": False}
+
+        # Get terminal size and calculate appropriate height
+        term_size = shutil.get_terminal_size((80, 24))
+        # Reserve 6 lines for header, hint bar, and margins
+        available_height = max(5, term_size.lines - 6)
+        content_height = initial_text.count("\n") + 3
+        editor_height = min(available_height, max(5, content_height))
+
+        # Create text editor window - adapt to terminal size
+        text_window = Window(
+            content=BufferControl(buffer=text_buffer, focus_on_click=True),
+            height=editor_height,
+            wrap_lines=True,
+            right_margins=[ScrollbarMargin()],
+        )
+
+        # Create hint window
+        hint_window = Window(
+            content=FormattedTextControl(text=[("class:hint", " Esc+Enter or Ctrl+S to save | 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: KeyPressEvent) -> None:
+            submitted["value"] = True
+            event.app.exit()
+
+        @kb.add("c-c")
+        def _(event: KeyPressEvent) -> None:
+            cancelled["value"] = True
+            event.app.exit()
+
+        @kb.add("escape", "enter")
+        def _(event: KeyPressEvent) -> None:
+            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,
+            style=custom_style,
+        )
+
+        app.run()
+
+        if cancelled["value"]:
+            return None
+
+        if submitted["value"]:
+            return text_buffer.text.strip()
+
+        return None
+
+    except (EOFError, KeyboardInterrupt):
+        return None
+    except Exception as e:
+        logger.error(f"Error during interactive editing: {e}")
+        console.print(f"[red]Failed to open editor: {e}[/red]")
+        return None
+
+
+def _get_prompt_file_to_edit() -> tuple[Path, str]:
+    """Get the file path to edit and its current content.
+
+    Returns the env var path if set, otherwise the default stored path.
+    """
+    env_path = os.getenv("GAC_SYSTEM_PROMPT_PATH")
+    if env_path:
+        target_file = Path(env_path)
+        content = ""
+        if target_file.exists():
+            try:
+                content = target_file.read_text(encoding="utf-8")
+            except OSError:
+                pass
+        return target_file, content
+
+    # Default to stored config file
+    content = ""
+    if CUSTOM_PROMPT_FILE.exists():
+        try:
+            content = CUSTOM_PROMPT_FILE.read_text(encoding="utf-8")
+        except OSError:
+            pass
+    return CUSTOM_PROMPT_FILE, content
+
+
+@prompt.command()
+@click.option("--edit", "-e", is_flag=True, help="Edit prompt interactively in terminal")
+@click.option("--file", "file_path", type=click.Path(exists=True), help="Copy prompt from file")
+def set(edit: bool, file_path: str | None) -> None:
+    """Set custom system prompt via interactive editor or file."""
+    # Require exactly one of --edit or --file
+    if edit and file_path:
+        console.print("[red]Error: --edit and --file are mutually exclusive[/red]")
+        raise click.Abort()
+
+    if not edit and not file_path:
+        console.print("[red]Error: either --edit or --file must be specified[/red]")
+        raise click.Abort()
+
+    if edit:
+        # Get the target file and its current content
+        target_file, initial_content = _get_prompt_file_to_edit()
+
+        # Create parent directory if needed
+        target_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Open interactive editor
+        result = _edit_text_interactive(initial_content)
+
+        if result is None:
+            console.print("\n[yellow]Edit cancelled, no changes made.[/yellow]")
+            return
+
+        if not result:
+            console.print("\n[yellow]Empty prompt not saved.[/yellow]")
+            return
+
+        # Save result
+        target_file.write_text(result, encoding="utf-8")
+        console.print(f"\n[green]Custom prompt saved to {target_file}[/green]")
+
+    elif file_path:
+        # Copy file content
+        source_file = Path(file_path)
+        try:
+            content = source_file.read_text(encoding="utf-8")
+            # Create parent directory if needed
+            CUSTOM_PROMPT_FILE.parent.mkdir(parents=True, exist_ok=True)
+            CUSTOM_PROMPT_FILE.write_text(content, encoding="utf-8")
+            console.print(f"Custom prompt copied from {file_path} to {CUSTOM_PROMPT_FILE}")
+        except OSError as e:
+            console.print(f"[red]Error reading file {file_path}: {e}[/red]")
+            raise click.Abort() from e
+
+
+@prompt.command()
+def clear() -> None:
+    """Clear custom system prompt (revert to default)."""
+    if CUSTOM_PROMPT_FILE.exists():
+        CUSTOM_PROMPT_FILE.unlink()
+        console.print(f"Custom prompt deleted: {CUSTOM_PROMPT_FILE}")
+    else:
+        console.print("No custom prompt file to delete.")

{gac-3.10.11 → gac-3.12.0}/src/gac/providers/base.py

@@ -249,6 +249,14 @@ class AnthropicCompatibleProvider(BaseConfiguredProvider):
         headers["anthropic-version"] = "2023-06-01"
         return headers
 
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Anthropic API URL with /messages endpoint."""
+        if self.config.base_url.endswith("messages"):
+            return self.config.base_url
+        if self.config.base_url.endswith("/"):
+            return f"{self.config.base_url}messages"
+        return f"{self.config.base_url}/messages"
+
     def _build_request_body(
         self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
     ) -> dict[str, Any]:

{gac-3.10.11 → gac-3.12.0}/src/gac/providers/claude_code.py

@@ -17,7 +17,7 @@ class ClaudeCodeProvider(AnthropicCompatibleProvider):
     config = ProviderConfig(
         name="Claude Code",
         api_key_env="CLAUDE_CODE_ACCESS_TOKEN",
-        base_url="https://api.anthropic.com/v1/messages",
+        base_url="https://api.anthropic.com/v1",
     )
 
     def _get_api_key(self) -> str: