code-puppy 0.0.348__py3-none-any.whl → 0.0.361__py3-none-any.whl

code_puppy/tools/common.py

@@ -1,10 +1,13 @@
+import asyncio
 import fnmatch
+import functools
 import hashlib
+import logging
 import os
 import sys
 import time
 from pathlib import Path
-from typing import Callable, Optional, Tuple
+from typing import Any, Callable, Optional, Tuple
 
 from prompt_toolkit import Application
 from prompt_toolkit.formatted_text import HTML
@@ -1406,3 +1409,175 @@ def generate_group_id(tool_name: str, extra_context: str = "") -> str:
     short_hash = hash_obj.hexdigest()[:8]
 
     return f"{tool_name}_{short_hash}"
+
+
+# =============================================================================
+# TOOL CALLBACK WRAPPER
+# =============================================================================
+
+logger = logging.getLogger(__name__)
+
+
+def with_tool_callbacks(tool_name: str) -> Callable:
+    """Decorator that wraps tool functions with pre/post callback hooks.
+
+    This decorator enables plugins to hook into tool execution for:
+    - Logging and analytics
+    - Pre-execution validation or modification
+    - Post-execution result processing
+    - Performance monitoring
+
+    Args:
+        tool_name: The name of the tool being wrapped (e.g., 'edit_file', 'list_files')
+
+    Returns:
+        A decorator function that wraps the tool with callbacks.
+
+    Example:
+        @with_tool_callbacks('my_tool')
+        async def my_tool_impl(ctx, **kwargs):
+            return result
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs) -> Any:
+            # Extract context from args if available (usually first arg is RunContext)
+            context = None
+            tool_args = kwargs.copy()
+
+            # Try to get session context
+            try:
+                from code_puppy.messaging import get_session_context
+
+                context = get_session_context()
+            except ImportError:
+                pass
+
+            # Fire pre-tool callback (non-blocking)
+            try:
+                from code_puppy import callbacks
+
+                asyncio.create_task(
+                    callbacks.on_pre_tool_call(tool_name, tool_args, context)
+                )
+            except ImportError:
+                logger.debug("callbacks module not available for pre_tool_call")
+            except Exception as e:
+                logger.debug(f"Error in pre_tool_call callback: {e}")
+
+            # Execute the tool and measure duration
+            start_time = time.perf_counter()
+            result = None
+            error = None
+
+            try:
+                result = await func(*args, **kwargs)
+                return result
+            except Exception as e:
+                error = e
+                raise
+            finally:
+                end_time = time.perf_counter()
+                duration_ms = (end_time - start_time) * 1000
+
+                # Fire post-tool callback (non-blocking)
+                final_result = result if error is None else {"error": str(error)}
+                try:
+                    from code_puppy import callbacks
+
+                    asyncio.create_task(
+                        callbacks.on_post_tool_call(
+                            tool_name, tool_args, final_result, duration_ms, context
+                        )
+                    )
+                except ImportError:
+                    logger.debug("callbacks module not available for post_tool_call")
+                except Exception as e:
+                    logger.debug(f"Error in post_tool_call callback: {e}")
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs) -> Any:
+            """Sync wrapper for non-async tool functions."""
+            # Extract context
+            context = None
+            tool_args = kwargs.copy()
+
+            try:
+                from code_puppy.messaging import get_session_context
+
+                context = get_session_context()
+            except ImportError:
+                pass
+
+            # For sync functions, we can't use asyncio.create_task directly
+            # Instead, we'll try to schedule it if there's a running loop
+            def fire_pre_callback():
+                try:
+                    from code_puppy import callbacks
+
+                    loop = asyncio.get_running_loop()
+                    asyncio.run_coroutine_threadsafe(
+                        callbacks.on_pre_tool_call(tool_name, tool_args, context),
+                        loop,
+                    )
+                except RuntimeError:
+                    # No running loop - skip async callback
+                    pass
+                except ImportError:
+                    pass
+                except Exception as e:
+                    logger.debug(f"Error in sync pre_tool_call: {e}")
+
+            fire_pre_callback()
+
+            # Execute the tool
+            start_time = time.perf_counter()
+            result = None
+            error = None
+
+            try:
+                result = func(*args, **kwargs)
+                return result
+            except Exception as e:
+                error = e
+                raise
+            finally:
+                end_time = time.perf_counter()
+                duration_ms = (end_time - start_time) * 1000
+
+                # Fire post-tool callback
+                final_result = result if error is None else {"error": str(error)}
+
+                def fire_post_callback():
+                    try:
+                        from code_puppy import callbacks
+
+                        loop = asyncio.get_running_loop()
+                        asyncio.run_coroutine_threadsafe(
+                            callbacks.on_post_tool_call(
+                                tool_name,
+                                tool_args,
+                                final_result,
+                                duration_ms,
+                                context,
+                            ),
+                            loop,
+                        )
+                    except RuntimeError:
+                        # No running loop - skip async callback
+                        pass
+                    except ImportError:
+                        pass
+                    except Exception as e:
+                        logger.debug(f"Error in sync post_tool_call: {e}")
+
+                fire_post_callback()
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator

code_puppy/tools/display.py

@@ -0,0 +1,84 @@
+"""Common display utilities for rendering agent outputs.
+
+This module provides non-streaming display functions for rendering
+agent results and other structured content using termflow for markdown.
+"""
+
+from typing import Optional
+
+from rich.console import Console
+
+from code_puppy.config import get_banner_color, get_subagent_verbose
+from code_puppy.tools.subagent_context import is_subagent
+
+
+def display_non_streamed_result(
+    content: str,
+    console: Optional[Console] = None,
+    banner_text: str = "AGENT RESPONSE",
+    banner_name: str = "agent_response",
+) -> None:
+    """Display a non-streamed result with markdown rendering via termflow.
+
+    This function renders markdown content using termflow for beautiful
+    terminal output. Use this instead of streaming for sub-agent responses
+    or any other content that arrives all at once.
+
+    Args:
+        content: The content to display (can include markdown).
+        console: Rich Console to use for output. If None, creates a new one.
+        banner_text: Text to display in the banner (default: "AGENT RESPONSE").
+        banner_name: Banner config key for color lookup (default: "agent_response").
+
+    Example:
+        >>> display_non_streamed_result("# Hello\n\nThis is **bold** text.")
+        # Renders with AGENT RESPONSE banner and formatted markdown
+    """
+    # Skip display for sub-agents unless verbose mode
+    if is_subagent() and not get_subagent_verbose():
+        return
+
+    import time
+
+    from rich.text import Text
+    from termflow import Parser as TermflowParser
+    from termflow import Renderer as TermflowRenderer
+
+    from code_puppy.messaging.spinner import pause_all_spinners, resume_all_spinners
+
+    if console is None:
+        console = Console()
+
+    # Pause spinners and give time to clear
+    pause_all_spinners()
+    time.sleep(0.1)
+
+    # Clear line and print banner
+    console.print(" " * 50, end="\r")
+    console.print()  # Newline before banner
+
+    banner_color = get_banner_color(banner_name)
+    console.print(
+        Text.from_markup(
+            f"[bold white on {banner_color}] {banner_text} [/bold white on {banner_color}]"
+        )
+    )
+
+    # Use termflow for markdown rendering
+    parser = TermflowParser()
+    renderer = TermflowRenderer(output=console.file, width=console.width)
+
+    # Process content line by line
+    for line in content.split("\n"):
+        events = parser.parse_line(line)
+        renderer.render_all(events)
+
+    # Finalize to close any open markdown blocks
+    final_events = parser.finalize()
+    renderer.render_all(final_events)
+
+    # Resume spinners
+    resume_all_spinners()
+
+
+__all__ = ["display_non_streamed_result"]

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-0.0.348.dist-info → code_puppy-0.0.361.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.348
+Version: 0.0.361
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.11
 Requires-Dist: camoufox>=0.4.11
 Requires-Dist: dbos>=2.5.0
-Requires-Dist: fastapi>=0.111.0
+Requires-Dist: fastapi>=0.109.0
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
 Requires-Dist: logfire>=0.7.1
@@ -35,8 +35,9 @@ Requires-Dist: rich>=13.4.2
 Requires-Dist: ripgrep==14.1.0
 Requires-Dist: ruff>=0.11.11
 Requires-Dist: tenacity>=8.2.0
-Requires-Dist: termflow-md>=0.1.6
-Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: termflow-md>=0.1.8
+Requires-Dist: uvicorn[standard]>=0.27.0
+Requires-Dist: websockets>=12.0
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -46,20 +47,18 @@ Description-Content-Type: text/markdown
 **🐶✨The sassy AI code agent that makes IDEs look outdated** ✨🐶
 
 [![Version](https://img.shields.io/pypi/v/code-puppy?style=for-the-badge&logo=python&label=Version&color=purple)](https://pypi.org/project/code-puppy/)
-[![Downloads](https://img.shields.io/badge/Downloads-100k%2B-brightgreen?style=for-the-badge&logo=download)](https://pypi.org/project/code-puppy/)
+[![Downloads](https://img.shields.io/badge/Downloads-170k%2B-brightgreen?style=for-the-badge&logo=download)](https://pypi.org/project/code-puppy/)
 [![Python](https://img.shields.io/badge/Python-3.11%2B-blue?style=for-the-badge&logo=python&logoColor=white)](https://python.org)
 [![License](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)](LICENSE)
 [![Build Status](https://img.shields.io/badge/Build-Passing-brightgreen?style=for-the-badge&logo=github)](https://github.com/mpfaffenberger/code_puppy/actions)
-[![Coverage](https://img.shields.io/badge/Coverage-95%25-brightgreen?style=for-the-badge)](https://github.com/mpfaffenberger/code_puppy)
-[![Code Style](https://img.shields.io/badge/Code%20Style-Black-black?style=for-the-badge)](https://github.com/psf/black)
 [![Tests](https://img.shields.io/badge/Tests-Passing-success?style=for-the-badge&logo=pytest)](https://github.com/mpfaffenberger/code_puppy/tests)
 
-[![OpenAI](https://img.shields.io/badge/OpenAI-GPT--5-orange?style=flat-square&logo=openai)](https://openai.com)
+[![OpenAI](https://img.shields.io/badge/OpenAI-GPT--5.2--Codex-orange?style=flat-square&logo=openai)](https://openai.com)
 [![Gemini](https://img.shields.io/badge/Google-Gemini-blue?style=flat-square&logo=google)](https://ai.google.dev/)
 [![Anthropic](https://img.shields.io/badge/Anthropic-Claude-orange?style=flat-square&logo=anthropic)](https://anthropic.com)
-[![Cerebras](https://img.shields.io/badge/Cerebras-GLM%204.6-red?style=flat-square)](https://cerebras.ai)
-[![Z.AI](https://img.shields.io/badge/Z.AI-GLM%204.6-purple?style=flat-square)](https://z.ai/)
-[![Synthetic](https://img.shields.io/badge/Synthetic-MINIMAX_M2-green?style=flat-square)](https://synthetic.new)
+[![Cerebras](https://img.shields.io/badge/Cerebras-GLM%204.7-red?style=flat-square)](https://cerebras.ai)
+[![Z.AI](https://img.shields.io/badge/Z.AI-GLM%204.7-purple?style=flat-square)](https://z.ai/)
+[![Synthetic](https://img.shields.io/badge/Synthetic-MINIMAX_M2.1-green?style=flat-square)](https://synthetic.new)
 
 [![100% Open Source](https://img.shields.io/badge/100%25-Open%20Source-blue?style=for-the-badge)](https://github.com/mpfaffenberger/code_puppy)
 [![Pydantic AI](https://img.shields.io/badge/Pydantic-AI-success?style=for-the-badge)](https://github.com/pydantic/pydantic-ai)
@@ -69,6 +68,9 @@ Description-Content-Type: text/markdown
 [![GitHub stars](https://img.shields.io/github/stars/mpfaffenberger/code_puppy?style=for-the-badge&logo=github)](https://github.com/mpfaffenberger/code_puppy/stargazers)
 [![GitHub forks](https://img.shields.io/github/forks/mpfaffenberger/code_puppy?style=for-the-badge&logo=github)](https://github.com/mpfaffenberger/code_puppy/network)
 
+[![Discord](https://img.shields.io/badge/Discord-Community-purple?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/SqYAaXVy)
+[![Docs](https://img.shields.io/badge/Read-The%20Docs-blue?style=for-the-badge&logo=readthedocs)](https://code-puppy.dev)
+
 **[⭐ Star this repo if you hate expensive IDEs! ⭐](#quick-start)**
 
 *"Who needs an IDE when you have 1024 angry puppies?"* - Someone, probably.