newcode 0.1.1__py3-none-any.whl

code_puppy/agents/prompt_reviewer.py

@@ -0,0 +1,145 @@
+"""Prompt Reviewer Agent - Specializes in analyzing and reviewing prompt quality."""
+
+from code_puppy.config import get_agent_name
+
+from .. import callbacks
+from .base_agent import BaseAgent
+
+
+class PromptReviewerAgent(BaseAgent):
+    """Prompt Reviewer Agent - Analyzes prompts for quality, clarity, and effectiveness."""
+
+    @property
+    def name(self) -> str:
+        return "prompt-reviewer"
+
+    @property
+    def display_name(self) -> str:
+        return "Prompt Reviewer 📝"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Specializes in analyzing and reviewing prompt quality. "
+            "Assesses clarity, specificity, context completeness, constraint handling, and ambiguity detection."
+        )
+
+    def get_available_tools(self) -> list[str]:
+        """Get the list of tools available to the Prompt Reviewer Agent."""
+        return [
+            "list_files",
+            "read_file",
+            "grep",
+            "agent_share_your_reasoning",
+            "agent_run_shell_command",
+        ]
+
+    def get_system_prompt(self) -> str:
+        """Get the optimized Prompt Reviewer Agent's system prompt."""
+        agent_name = get_agent_name()
+
+        result = f"""
+You are {agent_name} in Prompt Review Mode, a prompt quality analyst that reviews and improves prompts for clarity, specificity, and effectiveness.
+
+## Core Mission:
+Analyze prompt quality across 5 key dimensions and provide actionable improvements. Focus on practical, immediately applicable feedback.
+
+## Quick Review Framework:
+
+### Quality Dimensions (1-10 scale):
+1. **Clarity & Specificity**: Unambiguous language, concrete requirements
+2. **Context Completeness**: Sufficient background, target audience, environment
+3. **Constraint Handling**: Clear boundaries, technical requirements, limitations
+4. **Ambiguity Detection**: Vague terms, multiple interpretations, missing edge cases
+5. **Actionability**: Clear deliverables, success criteria, next steps
+
+### Review Process:
+1. **Intent Analysis**: Identify core purpose and target users
+2. **Gap Detection**: Find missing context, constraints, or clarity issues
+3. **Improvement Design**: Provide specific, actionable enhancements
+4. **Best Practice Integration**: Share relevant prompt engineering techniques
+
+## Output Template:
+```
+📊 **PROMPT QUALITY ASSESSMENT**:
+**Overall Score**: [X]/10 - [Quality Level]
+
+📋 **QUALITY DIMENSIONS**:
+- **Clarity & Specificity**: [X]/10 - [Brief comment]
+- **Context Completeness**: [X]/10 - [Brief comment]
+- **Constraint Handling**: [X]/10 - [Brief comment]
+- **Ambiguity Level**: [X]/10 - [Lower is better, brief comment]
+- **Actionability**: [X]/10 - [Brief comment]
+
+🎯 **STRENGTHS**:
+[2-3 key strengths with examples]
+
+⚠️ **CRITICAL ISSUES**:
+[2-3 major problems with impact]
+
+✨ **IMPROVEMENTS**:
+**Fixes**:
+- [ ] [Specific, actionable improvement 1]
+- [ ] [Specific, actionable improvement 2]
+**Enhancements**:
+- [ ] [Optional improvement 1]
+- [ ] [Optional improvement 2]
+
+🎨 **IMPROVED PROMPT**:
+[Concise, improved version]
+
+🚀 **NEXT STEPS**:
+[Clear implementation guidance]
+```
+
+## Context Integration:
+
+### When to Use Tools:
+- **list_files**: Prompt references project structure or files
+- **read_file**: Need to analyze existing code or documentation
+- **grep**: Find similar patterns or existing implementations
+- **agent_share_your_reasoning**: Explain complex review decisions
+- **invoke_agent**: Consult domain specialists for context-specific issues
+
+### Project-Aware Analysis:
+- Consider the project's tech stack
+- Account for git workflow and build tooling
+- Adapt to the project's style (clean, concise, DRY)
+- Reference existing patterns in the codebase
+
+## Adaptive Review:
+
+### Prompt Complexity Detection:
+- **Simple (<200 tokens)**: Quick review, focus on core clarity
+- **Medium (200-800 tokens)**: Standard review with context analysis
+- **Complex (>800 tokens)**: Deep analysis, break into components, consider token usage
+
+### Priority Areas by Prompt Type:
+- **Code Generation**: Language specificity, style requirements, testing expectations
+- **Planning**: Timeline realism, resource constraints, risk assessment
+- **Analysis**: Data sources, scope boundaries, output formats
+- **Creative**: Style guidelines, audience constraints, brand requirements
+
+## Common Prompt Patterns:
+- **Vague**: "make it better" → Need for specific success criteria
+- **Missing Context**: "fix this" without specifying what or why
+- **Over-constrained**: Too many conflicting requirements
+- **Under-constrained**: No boundaries leading to scope creep
+- **Assumed Knowledge**: Technical jargon without explanation
+
+## Optimization Principles:
+1. **Token Efficiency**: Review proportionally to prompt complexity
+2. **Actionability First**: Prioritize fixes that have immediate impact
+3. **Context Sensitivity**: Adapt feedback to project environment
+4. **Iterative Improvement**: Provide stages of enhancement
+5. **Practical Constraints**: Consider development reality and resource limits
+
+You excel at making prompts more effective while respecting practical constraints. Your feedback is constructive, specific, and immediately implementable. Balance thoroughness with efficiency based on prompt complexity and user needs.
+
+Remember: Great prompts lead to great results, but perfect is the enemy of good enough.
+"""
+
+        prompt_additions = callbacks.on_load_prompt()
+        if len(prompt_additions):
+            result += "\n" + "\n".join(prompt_additions)
+        return result

code_puppy/agents/subagent_stream_handler.py

@@ -0,0 +1,276 @@
+"""Silenced event stream handler for sub-agents.
+
+This handler suppresses all console output but still:
+- Updates SubAgentConsoleManager with status/metrics
+- Fires stream_event callbacks for the frontend emitter plugin
+- Tracks tool calls, tokens, and status changes
+
+Usage:
+    >>> from code_puppy.agents.subagent_stream_handler import subagent_stream_handler
+    >>> # In agent run:
+    >>> await subagent_stream_handler(ctx, events, session_id="my-session-123")
+"""
+
+import asyncio
+import logging
+from collections.abc import AsyncIterable
+from typing import Any, Optional
+
+from pydantic_ai import PartDeltaEvent, PartEndEvent, PartStartEvent, RunContext
+from pydantic_ai.messages import (
+    TextPart,
+    TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
+    ToolCallPart,
+    ToolCallPartDelta,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Callback Helper
+# =============================================================================
+
+
+def _fire_callback(event_type: str, event_data: Any, session_id: Optional[str]) -> None:
+    """Fire stream_event callback non-blocking.
+
+    Schedules the callback to run asynchronously without waiting for it.
+    Silently ignores errors if no event loop is running or if the callback
+    system is unavailable.
+
+    Args:
+        event_type: Type of the event ('part_start', 'part_delta', 'part_end')
+        event_data: Dictionary containing event-specific data
+        session_id: Optional session ID for the sub-agent
+    """
+    try:
+        from code_puppy import callbacks
+
+        loop = asyncio.get_running_loop()
+        loop.create_task(callbacks.on_stream_event(event_type, event_data, session_id))
+    except RuntimeError:
+        # No event loop running - this can happen during shutdown
+        logger.debug("No event loop available for stream event callback")
+    except ImportError:
+        # Callbacks module not available
+        logger.debug("Callbacks module not available for stream event")
+    except Exception as e:
+        # Don't let callback errors break the stream handler
+        logger.debug(f"Error firing stream event callback: {e}")
+
+
+# =============================================================================
+# Token Estimation
+# =============================================================================
+
+
+def _estimate_tokens(content: str) -> int:
+    """Estimate token count from content string.
+
+    Uses a rough heuristic: ~4 characters per token for English text.
+    This is a ballpark estimate - actual tokenization varies by model.
+
+    Args:
+        content: The text content to estimate tokens for
+
+    Returns:
+        Estimated token count (minimum 1 for non-empty content)
+    """
+    if not content:
+        return 0
+    # Rough estimate: 4 chars = 1 token, minimum 1 for any content
+    return max(1, len(content) // 4)
+
+
+# =============================================================================
+# Main Handler
+# =============================================================================
+
+
+async def subagent_stream_handler(
+    ctx: RunContext,
+    events: AsyncIterable[Any],
+    session_id: Optional[str] = None,
+) -> None:
+    """Silent event stream handler for sub-agents.
+
+    Processes streaming events without producing any console output.
+    Updates the SubAgentConsoleManager with status and metrics, and fires
+    stream_event callbacks for any registered listeners.
+
+    Args:
+        ctx: The pydantic-ai run context
+        events: Async iterable of streaming events (PartStartEvent,
+                PartDeltaEvent, PartEndEvent)
+        session_id: Session ID of the sub-agent for console manager updates.
+                   If None, falls back to get_session_context().
+    """
+    # Late import to avoid circular dependencies
+    from code_puppy.messaging import get_session_context
+    from code_puppy.messaging.subagent_console import SubAgentConsoleManager
+
+    manager = SubAgentConsoleManager.get_instance()
+
+    # Resolve session_id, falling back to context if not provided
+    effective_session_id = session_id or get_session_context()
+
+    # Metrics tracking
+    token_count = 0
+    tool_call_count = 0
+    active_tool_parts: set[int] = set()  # Track active tool call indices
+
+    async for event in events:
+        try:
+            await _handle_event(
+                event=event,
+                manager=manager,
+                session_id=effective_session_id,
+                token_count=token_count,
+                tool_call_count=tool_call_count,
+                active_tool_parts=active_tool_parts,
+            )
+
+            # Update metrics from returned values
+            # (we need to track these at this level since they're modified in _handle_event)
+            if isinstance(event, PartStartEvent):
+                if isinstance(event.part, ToolCallPart):
+                    tool_call_count += 1
+                    active_tool_parts.add(event.index)
+
+            elif isinstance(event, PartDeltaEvent):
+                delta = event.delta
+                if isinstance(delta, (TextPartDelta, ThinkingPartDelta)):
+                    if delta.content_delta:
+                        token_count += _estimate_tokens(delta.content_delta)
+
+            elif isinstance(event, PartEndEvent):
+                active_tool_parts.discard(event.index)
+
+        except Exception as e:
+            # Log but don't crash on event handling errors
+            logger.debug(f"Error handling stream event: {e}")
+            continue
+
+
+async def _handle_event(
+    event: Any,
+    manager: Any,  # SubAgentConsoleManager
+    session_id: Optional[str],
+    token_count: int,
+    tool_call_count: int,
+    active_tool_parts: set[int],
+) -> None:
+    """Handle a single streaming event.
+
+    Updates the console manager and fires callbacks for each event type.
+
+    Args:
+        event: The streaming event to handle
+        manager: SubAgentConsoleManager instance
+        session_id: Session ID for updates
+        token_count: Current token count
+        tool_call_count: Current tool call count
+        active_tool_parts: Set of active tool call indices
+    """
+    if session_id is None:
+        # Can't update manager without session_id
+        logger.debug("No session_id available for stream event")
+        return
+
+    # -------------------------------------------------------------------------
+    # PartStartEvent - Track new parts and update status
+    # -------------------------------------------------------------------------
+    if isinstance(event, PartStartEvent):
+        part = event.part
+        event_data = {
+            "index": event.index,
+            "part_type": type(part).__name__,
+        }
+
+        if isinstance(part, ThinkingPart):
+            manager.update_agent(session_id, status="thinking")
+            event_data["content"] = getattr(part, "content", None)
+
+        elif isinstance(part, TextPart):
+            manager.update_agent(session_id, status="running")
+            event_data["content"] = getattr(part, "content", None)
+
+        elif isinstance(part, ToolCallPart):
+            # tool_call_count is updated in the main handler
+            manager.update_agent(
+                session_id,
+                status="tool_calling",
+                tool_call_count=tool_call_count + 1,  # +1 for this new one
+                current_tool=part.tool_name,
+            )
+            event_data["tool_name"] = part.tool_name
+            event_data["tool_call_id"] = getattr(part, "tool_call_id", None)
+
+        _fire_callback("part_start", event_data, session_id)
+
+    # -------------------------------------------------------------------------
+    # PartDeltaEvent - Track content deltas and update metrics
+    # -------------------------------------------------------------------------
+    elif isinstance(event, PartDeltaEvent):
+        delta = event.delta
+        event_data = {
+            "index": event.index,
+            "delta_type": type(delta).__name__,
+        }
+
+        if isinstance(delta, TextPartDelta):
+            content_delta = delta.content_delta
+            if content_delta:
+                # Token count is updated in main handler
+                new_token_count = token_count + _estimate_tokens(content_delta)
+                manager.update_agent(session_id, token_count=new_token_count)
+                event_data["content_delta"] = content_delta
+
+        elif isinstance(delta, ThinkingPartDelta):
+            content_delta = delta.content_delta
+            if content_delta:
+                new_token_count = token_count + _estimate_tokens(content_delta)
+                manager.update_agent(session_id, token_count=new_token_count)
+                event_data["content_delta"] = content_delta
+
+        elif isinstance(delta, ToolCallPartDelta):
+            # Tool call deltas might have partial args
+            event_data["args_delta"] = getattr(delta, "args_delta", None)
+            event_data["tool_name_delta"] = getattr(delta, "tool_name_delta", None)
+
+        _fire_callback("part_delta", event_data, session_id)
+
+    # -------------------------------------------------------------------------
+    # PartEndEvent - Track part completion and update status
+    # -------------------------------------------------------------------------
+    elif isinstance(event, PartEndEvent):
+        event_data = {
+            "index": event.index,
+            "next_part_kind": getattr(event, "next_part_kind", None),
+        }
+
+        # If this was a tool call part ending, check if we should reset status
+        if event.index in active_tool_parts:
+            # Remove this index from active parts (done in main handler)
+            # If no more active tool parts after removal, reset to running
+            remaining_active = active_tool_parts - {event.index}
+            if not remaining_active:
+                manager.update_agent(
+                    session_id,
+                    current_tool=None,
+                    status="running",
+                )
+
+        _fire_callback("part_end", event_data, session_id)
+
+
+# =============================================================================
+# Exports
+# =============================================================================
+
+__all__ = [
+    "subagent_stream_handler",
+]

code_puppy/api/__init__.py

@@ -0,0 +1,13 @@
+"""REST API module.
+
+This module provides a FastAPI-based REST API for the application configuration,
+sessions, commands, and real-time WebSocket communication.
+
+Exports:
+    create_app: Factory function to create the FastAPI application
+    main: Entry point to run the server
+"""
+
+from code_puppy.api.app import create_app
+
+__all__ = ["create_app"]

code_puppy/api/app.py

@@ -0,0 +1,169 @@
+"""FastAPI application factory."""
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncGenerator
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+
+logger = logging.getLogger(__name__)
+
+# Default request timeout (seconds) - fail fast!
+REQUEST_TIMEOUT = 30.0
+
+
+class TimeoutMiddleware(BaseHTTPMiddleware):
+    """Middleware to enforce request timeouts and prevent hanging requests."""
+
+    def __init__(self, app, timeout: float = REQUEST_TIMEOUT):
+        super().__init__(app)
+        self.timeout = timeout
+
+    async def dispatch(self, request: Request, call_next):
+        # Skip timeout for WebSocket upgrades and streaming endpoints
+        if request.headers.get(
+            "upgrade", ""
+        ).lower() == "websocket" or request.url.path.startswith("/ws/"):
+            return await call_next(request)
+
+        try:
+            return await asyncio.wait_for(
+                call_next(request),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError:
+            return JSONResponse(
+                status_code=504,
+                content={
+                    "detail": f"Request timed out after {self.timeout}s",
+                    "error": "timeout",
+                },
+            )
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Lifespan context manager for startup and shutdown events.
+
+    Handles graceful cleanup of resources when the server shuts down.
+    """
+    # Startup: nothing special needed yet, but this is where you'd do it
+    logger.info("API starting up...")
+    yield
+    # Shutdown: clean up all the things!
+    logger.info("API shutting down, cleaning up...")
+
+    # 1. Close all PTY sessions
+    try:
+        from code_puppy.api.pty_manager import get_pty_manager
+
+        pty_manager = get_pty_manager()
+        await pty_manager.close_all()
+        logger.info("✓ All PTY sessions closed")
+    except Exception as e:
+        logger.error(f"Error closing PTY sessions: {e}")
+
+    # 2. Remove PID file so /api status knows we're gone
+    try:
+        from code_puppy.config import STATE_DIR
+
+        pid_file = Path(STATE_DIR) / "api_server.pid"
+        if pid_file.exists():
+            pid_file.unlink()
+            logger.info("✓ PID file removed")
+    except Exception as e:
+        logger.error(f"Error removing PID file: {e}")
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        lifespan=lifespan,
+        title="Code Agent API",
+        description="REST API and Interactive Terminal",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+    )
+
+    # Timeout middleware - added first so it wraps everything
+    app.add_middleware(TimeoutMiddleware, timeout=REQUEST_TIMEOUT)
+
+    # CORS middleware for frontend access
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Local/trusted
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include routers
+    from code_puppy.api.routers import agents, commands, config, sessions
+
+    app.include_router(config.router, prefix="/api/config", tags=["config"])
+    app.include_router(commands.router, prefix="/api/commands", tags=["commands"])
+    app.include_router(sessions.router, prefix="/api/sessions", tags=["sessions"])
+    app.include_router(agents.router, prefix="/api/agents", tags=["agents"])
+
+    # WebSocket endpoints (events + terminal)
+    from code_puppy.api.websocket import setup_websocket
+
+    setup_websocket(app)
+
+    # Templates directory
+    templates_dir = Path(__file__).parent / "templates"
+
+    @app.get("/")
+    async def root():
+        """Landing page with links to terminal and docs."""
+        return HTMLResponse(
+            content="""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Code Agent</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gray-900 text-white min-h-screen flex items-center justify-center">
+    <div class="text-center">
+        <h1 class="text-6xl mb-4">&#x2699;</h1>
+        <h2 class="text-3xl font-bold mb-8">Code Agent</h2>
+        <div class="space-x-4">
+            <a href="/terminal" class="px-6 py-3 bg-blue-600 hover:bg-blue-700 rounded-lg text-lg font-semibold">
+                Open Terminal
+            </a>
+            <a href="/docs" class="px-6 py-3 bg-gray-700 hover:bg-gray-600 rounded-lg text-lg">
+                API Docs
+            </a>
+        </div>
+        <p class="mt-8 text-gray-400">
+            WebSocket: ws://localhost:8765/ws/terminal
+        </p>
+    </div>
+</body>
+</html>
+        """
+        )
+
+    @app.get("/terminal")
+    async def terminal_page():
+        """Serve the interactive terminal page."""
+        html_file = templates_dir / "terminal.html"
+        if html_file.exists():
+            return FileResponse(html_file, media_type="text/html")
+        return HTMLResponse(
+            content="<h1>Terminal template not found</h1>",
+            status_code=404,
+        )
+
+    @app.get("/health")
+    async def health():
+        return {"status": "healthy"}
+
+    return app

code_puppy/api/main.py

@@ -0,0 +1,21 @@
+"""Entry point for running the FastAPI server."""
+
+import uvicorn
+
+from code_puppy.api.app import create_app
+
+app = create_app()
+
+
+def main(host: str = "127.0.0.1", port: int = 8765) -> None:
+    """Run the FastAPI server.
+
+    Args:
+        host: The host address to bind to. Defaults to localhost.
+        port: The port number to listen on. Defaults to 8765.
+    """
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()