code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/tools/subagent_context.py

@@ -0,0 +1,158 @@
+"""Sub-agent context management with async-safe state tracking.
+
+This module provides context-aware tracking of sub-agent execution state using
+Python's contextvars for async-safe isolation. This ensures that sub-agent state
+is properly isolated across different async tasks and execution contexts.
+
+## Why ContextVars?
+
+ContextVars provide automatic context isolation in async environments:
+- Each async task gets its own copy of the context
+- State changes in one task don't affect others
+- Perfect for tracking execution depth in nested agent calls
+- Token-based reset ensures proper cleanup even with exceptions
+
+## Usage Example:
+
+```python
+from code_puppy.tools.subagent_context import subagent_context, is_subagent
+
+# Main agent
+print(is_subagent())  # False
+
+async def run_subagent():
+    with subagent_context("retriever"):
+        print(is_subagent())  # True
+        print(get_subagent_name())  # "retriever"
+        print(get_subagent_depth())  # 1
+
+        # Nested sub-agent
+        with subagent_context("terrier"):
+            print(get_subagent_depth())  # 2
+            print(get_subagent_name())  # "terrier"
+
+        # Back to parent sub-agent
+        print(get_subagent_name())  # "retriever"
+        print(get_subagent_depth())  # 1
+
+# After context exits
+print(is_subagent())  # False
+```
+
+## Benefits:
+
+1. **Async Safety**: Multiple sub-agents can run concurrently without interference
+2. **Nested Support**: Properly handles sub-agents calling other sub-agents
+3. **Clean Restoration**: Token-based reset ensures state is restored even on errors
+4. **Zero Overhead**: When not in a sub-agent context, minimal performance impact
+"""
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Generator
+
+__all__ = [
+    "subagent_context",
+    "is_subagent",
+    "get_subagent_name",
+    "get_subagent_depth",
+]
+
+# Track sub-agent depth (0 = main agent, 1+ = sub-agent)
+_subagent_depth: ContextVar[int] = ContextVar("subagent_depth", default=0)
+
+# Track current sub-agent name (None = main agent)
+_subagent_name: ContextVar[str | None] = ContextVar("subagent_name", default=None)
+
+
+@contextmanager
+def subagent_context(agent_name: str) -> Generator[None, None, None]:
+    """Context manager for tracking sub-agent execution.
+
+    Increments the sub-agent depth and sets the current agent name on entry,
+    then restores the previous state on exit. Uses token-based reset for
+    proper async isolation and exception safety.
+
+    Args:
+        agent_name: Name of the sub-agent being executed (e.g., "retriever", "husky")
+
+    Yields:
+        None
+
+    Example:
+        >>> with subagent_context("retriever"):
+        ...     assert is_subagent() is True
+        ...     assert get_subagent_name() == "retriever"
+        >>> assert is_subagent() is False
+
+    Note:
+        Token-based reset ensures that even if an exception occurs, the context
+        is properly restored. This is especially important in async environments
+        where multiple tasks may be running concurrently.
+    """
+    # Get current depth for incrementing
+    current_depth = _subagent_depth.get()
+
+    # Set new values and save tokens for restoration
+    depth_token = _subagent_depth.set(current_depth + 1)
+    name_token = _subagent_name.set(agent_name)
+
+    try:
+        yield
+    finally:
+        # Use token-based reset for proper async isolation
+        # This ensures the context is restored even if an exception occurs
+        _subagent_depth.reset(depth_token)
+        _subagent_name.reset(name_token)
+
+
+def is_subagent() -> bool:
+    """Check if currently executing within a sub-agent context.
+
+    Returns:
+        True if depth > 0 (inside a sub-agent), False otherwise (main agent)
+
+    Example:
+        >>> is_subagent()
+        False
+        >>> with subagent_context("retriever"):
+        ...     is_subagent()
+        True
+    """
+    return _subagent_depth.get() > 0
+
+
+def get_subagent_name() -> str | None:
+    """Get the name of the current sub-agent.
+
+    Returns:
+        Current sub-agent name, or None if in main agent context
+
+    Example:
+        >>> get_subagent_name()
+        None
+        >>> with subagent_context("husky"):
+        ...     get_subagent_name()
+        'husky'
+    """
+    return _subagent_name.get()
+
+
+def get_subagent_depth() -> int:
+    """Get the current sub-agent nesting depth.
+
+    Returns:
+        Current depth level (0 = main agent, 1 = first-level sub-agent,
+        2 = nested sub-agent, etc.)
+
+    Example:
+        >>> get_subagent_depth()
+        0
+        >>> with subagent_context("retriever"):
+        ...     get_subagent_depth()
+        1
+        ...     with subagent_context("terrier"):
+        ...         get_subagent_depth()
+        2
+    """
+    return _subagent_depth.get()

code_puppy/uvx_detection.py

@@ -0,0 +1,242 @@
+"""Detect if code-puppy was launched via uvx on Windows.
+
+This module provides utilities to detect the launch method of code-puppy,
+specifically to handle signal differences when running via uvx on Windows.
+
+On Windows, when launched via `uvx code-puppy`, Ctrl+C (SIGINT) gets captured
+by uvx's process handling before reaching our Python process. To work around
+this, we detect the uvx launch scenario and switch to Ctrl+K for cancellation.
+
+Note: This issue is specific to uvx.exe, NOT uv.exe. Running via `uv run`
+handles SIGINT correctly on Windows.
+
+On non-Windows platforms, this is not an issue - Ctrl+C works fine with uvx.
+"""
+
+import os
+import platform
+import sys
+from functools import lru_cache
+from typing import Optional
+
+# Cache the detection result - it won't change during runtime
+_uvx_detection_cache: Optional[bool] = None
+
+
+def _get_parent_process_name_psutil(pid: int) -> Optional[str]:
+    """Get parent process name using psutil (if available).
+
+    Args:
+        pid: Process ID to get parent name for
+
+    Returns:
+        Parent process name (lowercase) or None if not found
+    """
+    try:
+        import psutil
+
+        proc = psutil.Process(pid)
+        parent = proc.parent()
+        if parent:
+            return parent.name().lower()
+    except Exception:
+        pass
+    return None
+
+
+def _get_parent_process_chain_psutil() -> list[str]:
+    """Get the entire parent process chain using psutil.
+
+    Returns:
+        List of process names from current process up to init/System
+    """
+    chain = []
+    try:
+        import psutil
+
+        proc = psutil.Process(os.getpid())
+        while proc:
+            chain.append(proc.name().lower())
+            parent = proc.parent()
+            if parent is None or parent.pid in (0, proc.pid):
+                break
+            proc = parent
+    except Exception:
+        pass
+    return chain
+
+
+def _get_parent_process_chain_windows_ctypes() -> list[str]:
+    """Get parent process chain on Windows using ctypes (no external deps).
+
+    This is a fallback when psutil is not available.
+
+    Returns:
+        List of process names from current process up to System
+    """
+    if platform.system() != "Windows":
+        return []
+
+    chain = []
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        # Windows API constants
+        TH32CS_SNAPPROCESS = 0x00000002
+        INVALID_HANDLE_VALUE = -1
+
+        class PROCESSENTRY32(ctypes.Structure):
+            _fields_ = [
+                ("dwSize", wintypes.DWORD),
+                ("cntUsage", wintypes.DWORD),
+                ("th32ProcessID", wintypes.DWORD),
+                ("th32DefaultHeapID", ctypes.POINTER(wintypes.ULONG)),
+                ("th32ModuleID", wintypes.DWORD),
+                ("cntThreads", wintypes.DWORD),
+                ("th32ParentProcessID", wintypes.DWORD),
+                ("pcPriClassBase", wintypes.LONG),
+                ("dwFlags", wintypes.DWORD),
+                ("szExeFile", ctypes.c_char * 260),
+            ]
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Take a snapshot of all processes
+        snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
+        if snapshot == INVALID_HANDLE_VALUE:
+            return chain
+
+        try:
+            # Build a map of PID -> (parent_pid, exe_name)
+            process_map: dict[int, tuple[int, str]] = {}
+            pe = PROCESSENTRY32()
+            pe.dwSize = ctypes.sizeof(PROCESSENTRY32)
+
+            if kernel32.Process32First(snapshot, ctypes.byref(pe)):
+                while True:
+                    pid = pe.th32ProcessID
+                    parent_pid = pe.th32ParentProcessID
+                    exe_name = pe.szExeFile.decode("utf-8", errors="ignore").lower()
+                    process_map[pid] = (parent_pid, exe_name)
+
+                    if not kernel32.Process32Next(snapshot, ctypes.byref(pe)):
+                        break
+
+            # Traverse from current PID up the parent chain
+            current_pid = os.getpid()
+            visited = set()  # Prevent infinite loops
+
+            while current_pid in process_map and current_pid not in visited:
+                visited.add(current_pid)
+                parent_pid, exe_name = process_map[current_pid]
+                chain.append(exe_name)
+
+                if parent_pid == 0 or parent_pid == current_pid:
+                    break
+                current_pid = parent_pid
+
+        finally:
+            kernel32.CloseHandle(snapshot)
+
+    except Exception:
+        pass
+
+    return chain
+
+
+def _get_parent_process_chain() -> list[str]:
+    """Get the parent process chain using best available method.
+
+    Returns:
+        List of process names from current process up to init/System
+    """
+    # Try psutil first (more reliable, cross-platform)
+    try:
+        import psutil  # noqa: F401
+
+        return _get_parent_process_chain_psutil()
+    except ImportError:
+        pass
+
+    # Fall back to ctypes on Windows
+    if platform.system() == "Windows":
+        return _get_parent_process_chain_windows_ctypes()
+
+    return []
+
+
+def _is_uvx_in_chain(chain: list[str]) -> bool:
+    """Check if uvx is in the process chain.
+
+    Note: We only check for uvx.exe, NOT uv.exe. The uv.exe binary
+    (used by `uv run`) handles SIGINT correctly on Windows, but
+    uvx.exe captures it before it reaches Python.
+
+    Args:
+        chain: List of process names (lowercase)
+
+    Returns:
+        True if uvx.exe is found in the chain
+    """
+    # Only uvx.exe has the SIGINT issue, not uv.exe
+    uvx_names = {"uvx.exe", "uvx"}
+    return any(name in uvx_names for name in chain)
+
+
+@lru_cache(maxsize=1)
+def is_launched_via_uvx() -> bool:
+    """Detect if code-puppy was launched via uvx.
+
+    Traverses the parent process chain to find uvx.exe or uv.exe.
+    Result is cached for the lifetime of the process.
+
+    Returns:
+        True if launched via uvx, False otherwise
+    """
+    chain = _get_parent_process_chain()
+    return _is_uvx_in_chain(chain)
+
+
+def is_windows() -> bool:
+    """Check if we're running on Windows.
+
+    Returns:
+        True if running on Windows, False otherwise
+    """
+    return platform.system() == "Windows"
+
+
+def should_use_alternate_cancel_key() -> bool:
+    """Determine if we should use an alternate cancel key (Ctrl+K) instead of Ctrl+C.
+
+    This returns True when:
+    - Running on Windows AND
+    - Launched via uvx
+
+    In this scenario, Ctrl+C is captured by uvx before reaching Python,
+    so we need to use a different key (Ctrl+K) for agent cancellation.
+
+    Returns:
+        True if alternate cancel key should be used, False otherwise
+    """
+    return is_windows() and is_launched_via_uvx()
+
+
+def get_uvx_detection_info() -> dict:
+    """Get diagnostic information about uvx detection.
+
+    Useful for debugging and testing.
+
+    Returns:
+        Dictionary with detection details
+    """
+    chain = _get_parent_process_chain()
+    return {
+        "is_windows": is_windows(),
+        "is_launched_via_uvx": is_launched_via_uvx(),
+        "should_use_alternate_cancel_key": should_use_alternate_cancel_key(),
+        "parent_process_chain": chain,
+        "current_pid": os.getpid(),
+        "python_executable": sys.executable,
+    }

code_puppy/version_checker.py

@@ -1,6 +1,9 @@
+"""Version checking utilities for Code Puppy."""
+
 import httpx
 
-from code_puppy.tools.common import console
+from code_puppy.messaging import emit_info, emit_success, emit_warning, get_message_bus
+from code_puppy.messaging.messages import VersionCheckMessage
 
 
 def normalize_version(version_str):
@@ -15,21 +18,37 @@ def versions_are_equal(current, latest):
 
 def fetch_latest_version(package_name):
     try:
-        response = httpx.get(f"https://pypi.org/pypi/{package_name}/json")
-        response.raise_for_status()  # Raise an error for bad responses
+        response = httpx.get(f"https://pypi.org/pypi/{package_name}/json", timeout=5.0)
+        response.raise_for_status()
         data = response.json()
         return data["info"]["version"]
     except Exception as e:
-        print(f"Error fetching version: {e}")
+        emit_warning(f"Error fetching version: {e}")
         return None
 
 
 def default_version_mismatch_behavior(current_version):
+    # Defensive: ensure current_version is never None
+    if current_version is None:
+        current_version = "0.0.0-unknown"
+        emit_warning("Could not detect current version, using fallback")
+
     latest_version = fetch_latest_version("code-puppy")
-    console.print(f"Current version: {current_version}")
-    console.print(f"Latest version: {latest_version}")
-    if latest_version and latest_version != current_version:
-        console.print(
-            f"[bold yellow]A new version of code puppy is available: {latest_version}[/bold yellow]"
-        )
-        console.print("[bold green]Please consider updating![/bold green]")
+
+    update_available = bool(latest_version and latest_version != current_version)
+
+    # Emit structured version check message
+    version_msg = VersionCheckMessage(
+        current_version=current_version,
+        latest_version=latest_version or current_version,
+        update_available=update_available,
+    )
+    get_message_bus().emit(version_msg)
+
+    # Also emit plain text for legacy renderer
+    emit_info(f"Current version: {current_version}")
+
+    if update_available:
+        emit_info(f"Latest version: {latest_version}")
+        emit_warning(f"A new version of code puppy is available: {latest_version}")
+        emit_success("Please consider updating!")

code_puppy-0.0.366.data/data/code_puppy/models.json

@@ -0,0 +1,110 @@
+{
+  "synthetic-GLM-4.7": {
+    "type": "custom_openai",
+    "name": "hf:zai-org/GLM-4.7",
+    "custom_endpoint": {
+      "url": "https://api.synthetic.new/openai/v1/",
+      "api_key": "$SYN_API_KEY"
+    },
+    "context_length": 200000,
+    "supported_settings": ["temperature", "seed"]
+  },
+  "synthetic-MiniMax-M2.1": {
+    "type": "custom_openai",
+    "name": "hf:MiniMaxAI/MiniMax-M2.1",
+    "custom_endpoint": {
+      "url": "https://api.synthetic.new/openai/v1/",
+      "api_key": "$SYN_API_KEY"
+    },
+    "context_length": 195000,
+    "supported_settings": ["temperature", "seed"]
+  },
+  "synthetic-Kimi-K2-Thinking": {
+    "type": "custom_openai",
+    "name": "hf:moonshotai/Kimi-K2-Thinking",
+    "custom_endpoint": {
+      "url": "https://api.synthetic.new/openai/v1/",
+      "api_key": "$SYN_API_KEY"
+    },
+    "context_length": 262144,
+    "supported_settings": ["temperature", "seed"]
+  },
+  "Gemini-3": {
+    "type": "gemini",
+    "name": "gemini-3-pro-preview",
+    "context_length": 200000,
+    "supported_settings": ["temperature"]
+  },
+  "Gemini-3-Long-Context": {
+    "type": "gemini",
+    "name": "gemini-3-pro-preview",
+    "context_length": 1000000,
+    "supported_settings": ["temperature"]
+  },
+  "gpt-5.1": {
+    "type": "openai",
+    "name": "gpt-5.1",
+    "context_length": 272000,
+    "supported_settings": ["reasoning_effort", "verbosity"],
+    "supports_xhigh_reasoning": false
+  },
+  "gpt-5.1-codex-api": {
+    "type": "openai",
+    "name": "gpt-5.1-codex",
+    "context_length": 272000,
+    "supported_settings": ["reasoning_effort", "verbosity"],
+    "supports_xhigh_reasoning": true
+  },
+  "Cerebras-GLM-4.7": {
+    "type": "cerebras",
+    "name": "zai-glm-4.7",
+    "custom_endpoint": {
+      "url": "https://api.cerebras.ai/v1",
+      "api_key": "$CEREBRAS_API_KEY"
+    },
+    "context_length": 131072,
+    "supported_settings": ["temperature", "seed"]
+  },
+  "claude-4-5-haiku": {
+    "type": "anthropic",
+    "name": "claude-haiku-4-5",
+    "context_length": 200000,
+    "supported_settings": ["temperature", "extended_thinking", "budget_tokens"]
+  },
+  "claude-4-5-sonnet": {
+    "type": "anthropic",
+    "name": "claude-sonnet-4-5",
+    "context_length": 200000,
+    "supported_settings": ["temperature", "extended_thinking", "budget_tokens"]
+  },
+  "claude-4-5-opus": {
+    "type": "anthropic",
+    "name": "claude-opus-4-5",
+    "context_length": 200000,
+    "supported_settings": ["temperature", "extended_thinking", "budget_tokens", "interleaved_thinking"]
+  },
+  "zai-glm-4.6-coding": {
+    "type": "zai_coding",
+    "name": "glm-4.6",
+    "context_length": 200000,
+    "supported_settings": ["temperature"]
+  },
+  "zai-glm-4.6-api": {
+    "type": "zai_api",
+    "name": "glm-4.6",
+    "context_length": 200000,
+    "supported_settings": ["temperature"]
+  },
+  "zai-glm-4.7-coding": {
+    "type": "zai_coding",
+    "name": "glm-4.7",
+    "context_length": 200000,
+    "supported_settings": ["temperature"]
+  },
+  "zai-glm-4.7-api": {
+    "type": "zai_api",
+    "name": "glm-4.7",
+    "context_length": 200000,
+    "supported_settings": ["temperature"]
+  }
+}