code-puppy 0.0.325__py3-none-any.whl → 0.0.341__py3-none-any.whl

code_puppy/keymap.py

@@ -55,11 +55,19 @@ class KeymapError(Exception):
 def get_cancel_agent_key() -> str:
     """Get the configured cancel agent key from config.
 
+    On Windows when launched via uvx, this automatically returns "ctrl+k"
+    to work around uvx capturing Ctrl+C before it reaches Python.
+
     Returns:
         The key name (e.g., "ctrl+c", "ctrl+k") from config,
         or the default if not configured.
     """
     from code_puppy.config import get_value
+    from code_puppy.uvx_detection import should_use_alternate_cancel_key
+
+    # On Windows + uvx, force ctrl+k to bypass uvx's SIGINT capture
+    if should_use_alternate_cancel_key():
+        return "ctrl+k"
 
     key = get_value("cancel_agent_key")
     if key is None or key.strip() == "":
@@ -86,15 +94,9 @@ def cancel_agent_uses_signal() -> bool:
     """Check if the cancel agent key uses SIGINT (Ctrl+C).
 
     Returns:
-        True if the cancel key is ctrl+c AND we're not on Windows
-        (uses SIGINT handler), False if it uses keyboard listener approach.
+        True if the cancel key is ctrl+c (uses SIGINT handler),
+        False if it uses keyboard listener approach.
     """
-    import sys
-
-    # On Windows, always use keyboard listener - SIGINT is unreliable
-    if sys.platform == "win32":
-        return False
-
     return get_cancel_agent_key() == "ctrl+c"
 
 

code_puppy/mcp_/managed_server.py

@@ -222,18 +222,14 @@ class ManagedMCPServer:
                     http_kwargs["timeout"] = config["timeout"]
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
-                if "headers" in config:
-                    # Expand environment variables in headers
-                    headers = config.get("headers")
-                    resolved_headers = {}
-                    if isinstance(headers, dict):
-                        for k, v in headers.items():
-                            if isinstance(v, str):
-                                resolved_headers[k] = os.path.expandvars(v)
-                            else:
-                                resolved_headers[k] = v
-                    http_kwargs["headers"] = resolved_headers
+
+                # Handle http_client vs headers (mutually exclusive)
+                if "http_client" in config:
+                    # Use provided http_client
+                    http_kwargs["http_client"] = config["http_client"]
+                elif config.get("headers"):
                     # Create HTTP client if headers are provided but no client specified
+                    http_kwargs["http_client"] = self._get_http_client()
 
                 self._pydantic_server = MCPServerStreamableHTTP(
                     **http_kwargs, process_tool_call=process_tool_call

code_puppy/messaging/messages.py

@@ -209,6 +209,9 @@ class ShellStartMessage(BaseMessage):
         default=None, description="Working directory for the command"
     )
     timeout: int = Field(default=60, description="Timeout in seconds")
+    background: bool = Field(
+        default=False, description="Whether command runs in background mode"
+    )
 
 
 class ShellLineMessage(BaseMessage):

code_puppy/messaging/rich_renderer.py

@@ -348,7 +348,17 @@ class RichConsoleRenderer:
     # =========================================================================
 
     def _render_file_listing(self, msg: FileListingMessage) -> None:
-        """Render a directory listing matching the old Rich-formatted output."""
+        """Render a compact directory listing with directory summaries.
+
+        Instead of listing every file, we group by directory and show:
+        - Directory name
+        - Number of files
+        - Total size
+        - Number of subdirectories
+        """
+        import os
+        from collections import defaultdict
+
         # Header on single line
         rec_flag = f"(recursive={msg.recursive})"
         banner = self._format_banner("directory_listing", "DIRECTORY LISTING")
@@ -357,32 +367,104 @@ class RichConsoleRenderer:
             f"📂 [bold cyan]{msg.directory}[/bold cyan] [dim]{rec_flag}[/dim]\n"
         )
 
-        # Directory header
-        dir_name = msg.directory.rstrip("/").split("/")[-1] or msg.directory
-        self._console.print(f"📁 [bold blue]{dir_name}[/bold blue]")
+        # Build a tree structure: {parent_path: {files: [], dirs: set(), size: int}}
+        # Each key is a directory path, value contains direct children stats
+        dir_stats: dict = defaultdict(
+            lambda: {"files": [], "subdirs": set(), "total_size": 0}
+        )
+
+        # Root directory is represented as ""
+        root_key = ""
 
-        # Build tree structure from flat list
         for entry in msg.files:
-            # Calculate indentation based on depth
-            prefix = ""
-            for d in range(entry.depth + 1):
-                if d == entry.depth:
-                    prefix += "└── "
-                else:
-                    prefix += "    "
+            path = entry.path
+            parent = os.path.dirname(path) if os.path.dirname(path) else root_key
 
             if entry.type == "dir":
-                self._console.print(f"{prefix}📁 [bold blue]{entry.path}/[/bold blue]")
+                # Register this dir as a subdir of its parent
+                dir_stats[parent]["subdirs"].add(path)
+                # Ensure the dir itself exists in stats (even if empty)
+                _ = dir_stats[path]
             else:
-                icon = self._get_file_icon(entry.path)
-                if entry.size > 0:
-                    size_str = f" [dim]({self._format_size(entry.size)})[/dim]"
-                else:
-                    size_str = ""
+                # It's a file - add to parent's stats
+                dir_stats[parent]["files"].append(entry)
+                dir_stats[parent]["total_size"] += entry.size
+
+        def render_dir_tree(dir_path: str, depth: int = 0) -> None:
+            """Recursively render directory with compact summary."""
+            stats = dir_stats.get(
+                dir_path, {"files": [], "subdirs": set(), "total_size": 0}
+            )
+            files = stats["files"]
+            subdirs = sorted(stats["subdirs"])
+
+            # Calculate total size including subdirectories (recursive)
+            def get_recursive_size(d: str) -> int:
+                s = dir_stats.get(d, {"files": [], "subdirs": set(), "total_size": 0})
+                size = s["total_size"]
+                for sub in s["subdirs"]:
+                    size += get_recursive_size(sub)
+                return size
+
+            def get_recursive_file_count(d: str) -> int:
+                s = dir_stats.get(d, {"files": [], "subdirs": set(), "total_size": 0})
+                count = len(s["files"])
+                for sub in s["subdirs"]:
+                    count += get_recursive_file_count(sub)
+                return count
+
+            indent = "    " * depth
+
+            # For root level, just show contents
+            if dir_path == root_key:
+                # Show files at root level (depth 0)
+                for f in sorted(files, key=lambda x: x.path):
+                    icon = self._get_file_icon(f.path)
+                    name = os.path.basename(f.path)
+                    size_str = (
+                        f" [dim]({self._format_size(f.size)})[/dim]"
+                        if f.size > 0
+                        else ""
+                    )
+                    self._console.print(
+                        f"{indent}{icon} [green]{name}[/green]{size_str}"
+                    )
+
+                # Show subdirs at root level
+                for subdir in subdirs:
+                    render_dir_tree(subdir, depth)
+            else:
+                # Show directory with summary
+                dir_name = os.path.basename(dir_path)
+                rec_size = get_recursive_size(dir_path)
+                rec_file_count = get_recursive_file_count(dir_path)
+                subdir_count = len(subdirs)
+
+                # Build summary parts
+                parts = []
+                if rec_file_count > 0:
+                    parts.append(
+                        f"{rec_file_count} file{'s' if rec_file_count != 1 else ''}"
+                    )
+                if subdir_count > 0:
+                    parts.append(
+                        f"{subdir_count} subdir{'s' if subdir_count != 1 else ''}"
+                    )
+                if rec_size > 0:
+                    parts.append(self._format_size(rec_size))
+
+                summary = f" [dim]({', '.join(parts)})[/dim]" if parts else ""
                 self._console.print(
-                    f"{prefix}{icon} [green]{entry.path}[/green]{size_str}"
+                    f"{indent}📁 [bold blue]{dir_name}/[/bold blue]{summary}"
                 )
 
+                # Recursively show subdirectories
+                for subdir in subdirs:
+                    render_dir_tree(subdir, depth + 1)
+
+        # Render the tree starting from root
+        render_dir_tree(root_key, 0)
+
         # Summary
         self._console.print("\n[bold cyan]Summary:[/bold cyan]")
         self._console.print(
@@ -538,15 +620,25 @@ class RichConsoleRenderer:
         safe_command = escape_rich_markup(msg.command)
         # Header showing command is starting
         banner = self._format_banner("shell_command", "SHELL COMMAND")
-        self._console.print(f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]")
+
+        # Add background indicator if running in background mode
+        if msg.background:
+            self._console.print(
+                f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]  [bold magenta][BACKGROUND 🌙][/bold magenta]"
+            )
+        else:
+            self._console.print(f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]")
 
         # Show working directory if specified
         if msg.cwd:
             safe_cwd = escape_rich_markup(msg.cwd)
             self._console.print(f"[dim]📂 Working directory: {safe_cwd}[/dim]")
 
-        # Show timeout
-        self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
+        # Show timeout or background status
+        if msg.background:
+            self._console.print("[dim]⏱ Runs detached (no timeout)[/dim]")
+        else:
+            self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
 
     def _render_shell_line(self, msg: ShellLineMessage) -> None:
         """Render shell output line preserving ANSI codes."""

code_puppy/model_factory.py

@@ -4,7 +4,6 @@ import os
 import pathlib
 from typing import Any, Dict
 
-import httpx
 from anthropic import AsyncAnthropic
 from openai import AsyncAzureOpenAI
 from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
@@ -212,6 +211,7 @@ class ModelFactory:
 
         # Import OAuth model file paths from main config
         from code_puppy.config import (
+            ANTIGRAVITY_MODELS_FILE,
             CHATGPT_MODELS_FILE,
             CLAUDE_MODELS_FILE,
             GEMINI_MODELS_FILE,
@@ -223,6 +223,7 @@ class ModelFactory:
             (pathlib.Path(CHATGPT_MODELS_FILE), "ChatGPT OAuth models", False),
             (pathlib.Path(CLAUDE_MODELS_FILE), "Claude Code OAuth models", True),
             (pathlib.Path(GEMINI_MODELS_FILE), "Gemini OAuth models", False),
+            (pathlib.Path(ANTIGRAVITY_MODELS_FILE), "Antigravity OAuth models", False),
         ]
 
         for source_path, label, use_filtered in extra_sources:
@@ -387,6 +388,20 @@ class ModelFactory:
             return AnthropicModel(model_name=model_config["name"], provider=provider)
         elif model_type == "claude_code":
             url, headers, verify, api_key = get_custom_config(model_config)
+            if model_config.get("oauth_source") == "claude-code-plugin":
+                try:
+                    from code_puppy.plugins.claude_code_oauth.utils import (
+                        get_valid_access_token,
+                    )
+
+                    refreshed_token = get_valid_access_token()
+                    if refreshed_token:
+                        api_key = refreshed_token
+                        custom_endpoint = model_config.get("custom_endpoint")
+                        if isinstance(custom_endpoint, dict):
+                            custom_endpoint["api_key"] = refreshed_token
+                except ImportError:
+                    pass
             if not api_key:
                 emit_warning(
                     f"API key is not set for Claude Code endpoint; skipping model '{model_config.get('name')}'."
@@ -556,24 +571,94 @@ class ModelFactory:
                     f"API key is not set for custom Gemini endpoint; skipping model '{model_config.get('name')}'."
                 )
                 return None
-            os.environ["GEMINI_API_KEY"] = api_key
 
-            class CustomGoogleGLAProvider(GoogleProvider):
-                def __init__(self, *args, **kwargs):
-                    super().__init__(*args, **kwargs)
+            # Check if this is an Antigravity model
+            if model_config.get("antigravity"):
+                try:
+                    from code_puppy.plugins.antigravity_oauth.token import (
+                        is_token_expired,
+                        refresh_access_token,
+                    )
+                    from code_puppy.plugins.antigravity_oauth.transport import (
+                        create_antigravity_client,
+                    )
+                    from code_puppy.plugins.antigravity_oauth.utils import (
+                        load_stored_tokens,
+                        save_tokens,
+                    )
 
-                @property
-                def base_url(self):
-                    return url
+                    # Try to import custom model for thinking signatures
+                    try:
+                        from code_puppy.plugins.antigravity_oauth.antigravity_model import (
+                            AntigravityModel,
+                        )
+                    except ImportError:
+                        AntigravityModel = None
 
-                @property
-                def client(self) -> httpx.AsyncClient:
-                    _client = create_async_client(headers=headers, verify=verify)
-                    _client.base_url = self.base_url
-                    return _client
+                    # Get fresh access token (refresh if needed)
+                    tokens = load_stored_tokens()
+                    if not tokens:
+                        emit_warning(
+                            "Antigravity tokens not found; run /antigravity-auth first."
+                        )
+                        return None
 
-            google_gla = CustomGoogleGLAProvider(api_key=api_key)
-            model = GoogleModel(model_name=model_config["name"], provider=google_gla)
+                    access_token = tokens.get("access_token", "")
+                    refresh_token = tokens.get("refresh_token", "")
+                    expires_at = tokens.get("expires_at")
+
+                    # Refresh if expired or about to expire
+                    if is_token_expired(expires_at):
+                        new_tokens = refresh_access_token(refresh_token)
+                        if new_tokens:
+                            access_token = new_tokens.access_token
+                            tokens["access_token"] = new_tokens.access_token
+                            tokens["refresh_token"] = new_tokens.refresh_token
+                            tokens["expires_at"] = new_tokens.expires_at
+                            save_tokens(tokens)
+                        else:
+                            emit_warning(
+                                "Failed to refresh Antigravity token; run /antigravity-auth again."
+                            )
+                            return None
+
+                    project_id = tokens.get(
+                        "project_id", model_config.get("project_id", "")
+                    )
+                    client = create_antigravity_client(
+                        access_token=access_token,
+                        project_id=project_id,
+                        model_name=model_config["name"],
+                        base_url=url,
+                        headers=headers,
+                    )
+
+                    provider = GoogleProvider(
+                        api_key=api_key, base_url=url, http_client=client
+                    )
+
+                    # Use custom model if available to preserve thinking signatures
+                    if AntigravityModel:
+                        model = AntigravityModel(
+                            model_name=model_config["name"], provider=provider
+                        )
+                    else:
+                        model = GoogleModel(
+                            model_name=model_config["name"], provider=provider
+                        )
+
+                    return model
+
+                except ImportError:
+                    emit_warning(
+                        f"Antigravity transport not available; skipping model '{model_config.get('name')}'."
+                    )
+                    return None
+            else:
+                client = create_async_client(headers=headers, verify=verify)
+
+            provider = GoogleProvider(api_key=api_key, base_url=url, http_client=client)
+            model = GoogleModel(model_name=model_config["name"], provider=provider)
             return model
         elif model_type == "cerebras":
 
@@ -592,6 +677,8 @@ class ModelFactory:
                     f"API key is not set for Cerebras endpoint; skipping model '{model_config.get('name')}'."
                 )
                 return None
+            # Add Cerebras 3rd party integration header
+            headers["X-Cerebras-3rd-Party-Integration"] = "code-puppy"
             client = create_async_client(headers=headers, verify=verify)
             provider_args = dict(
                 api_key=api_key,

code_puppy/models.json

@@ -55,9 +55,9 @@
     "supported_settings": ["reasoning_effort", "verbosity"],
     "supports_xhigh_reasoning": true
   },
-  "Cerebras-GLM-4.6": {
+  "Cerebras-GLM-4.7": {
     "type": "cerebras",
-    "name": "zai-glm-4.6",
+    "name": "zai-glm-4.7",
     "custom_endpoint": {
       "url": "https://api.cerebras.ai/v1",
       "api_key": "$CEREBRAS_API_KEY"

code_puppy/plugins/antigravity_oauth/__init__.py

@@ -0,0 +1,10 @@
+"""Antigravity OAuth Plugin for Code Puppy.
+
+Enables authentication with Google/Antigravity APIs to access Gemini and Claude models
+via Google credentials. Supports multi-account load balancing and automatic failover.
+"""
+
+from .config import ANTIGRAVITY_OAUTH_CONFIG
+from .register_callbacks import *  # noqa: F401, F403
+
+__all__ = ["ANTIGRAVITY_OAUTH_CONFIG"]