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

code_puppy/api/routers/commands.py

@@ -0,0 +1,217 @@
+"""Commands API endpoints for slash command execution and autocomplete.
+
+This router provides REST endpoints for:
+- Listing all available slash commands
+- Getting info about specific commands
+- Executing slash commands
+- Autocomplete suggestions for partial commands
+"""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+# Thread pool for blocking command execution
+_executor = ThreadPoolExecutor(max_workers=4)
+
+# Timeout for command execution (seconds)
+COMMAND_TIMEOUT = 30.0
+
+router = APIRouter()
+
+
+# =============================================================================
+# Pydantic Models
+# =============================================================================
+
+
+class CommandInfo(BaseModel):
+    """Information about a registered command."""
+
+    name: str
+    description: str
+    usage: str
+    aliases: List[str] = []
+    category: str = "core"
+    detailed_help: Optional[str] = None
+
+
+class CommandExecuteRequest(BaseModel):
+    """Request to execute a slash command."""
+
+    command: str  # Full command string, e.g., "/set model=gpt-4o"
+
+
+class CommandExecuteResponse(BaseModel):
+    """Response from executing a slash command."""
+
+    success: bool
+    result: Any = None
+    error: Optional[str] = None
+
+
+class AutocompleteRequest(BaseModel):
+    """Request for command autocomplete."""
+
+    partial: str  # Partial command string, e.g., "/se" or "/set mo"
+
+
+class AutocompleteResponse(BaseModel):
+    """Response with autocomplete suggestions."""
+
+    suggestions: List[str]
+
+
+# =============================================================================
+# Endpoints
+# =============================================================================
+
+
+@router.get("/")
+async def list_commands() -> List[CommandInfo]:
+    """List all available slash commands.
+
+    Returns a sorted list of all unique commands (no alias duplicates),
+    with their metadata including name, description, usage, aliases,
+    category, and detailed help.
+
+    Returns:
+        List[CommandInfo]: Sorted list of command information.
+    """
+    from code_puppy.command_line.command_registry import get_unique_commands
+
+    commands = []
+    for cmd in get_unique_commands():
+        commands.append(
+            CommandInfo(
+                name=cmd.name,
+                description=cmd.description,
+                usage=cmd.usage,
+                aliases=cmd.aliases,
+                category=cmd.category,
+                detailed_help=cmd.detailed_help,
+            )
+        )
+    return sorted(commands, key=lambda c: c.name)
+
+
+@router.get("/{name}")
+async def get_command_info(name: str) -> CommandInfo:
+    """Get detailed info about a specific command.
+
+    Looks up a command by name or alias (case-insensitive).
+
+    Args:
+        name: Command name or alias (without leading /).
+
+    Returns:
+        CommandInfo: Full command information.
+
+    Raises:
+        HTTPException: 404 if command not found.
+    """
+    from code_puppy.command_line.command_registry import get_command
+
+    cmd = get_command(name)
+    if not cmd:
+        raise HTTPException(404, f"Command '/{name}' not found")
+
+    return CommandInfo(
+        name=cmd.name,
+        description=cmd.description,
+        usage=cmd.usage,
+        aliases=cmd.aliases,
+        category=cmd.category,
+        detailed_help=cmd.detailed_help,
+    )
+
+
+@router.post("/execute")
+async def execute_command(request: CommandExecuteRequest) -> CommandExecuteResponse:
+    """Execute a slash command.
+
+    Takes a command string (with or without leading /) and executes it
+    using the command handler. Runs in a thread pool to avoid blocking
+    the event loop, with a timeout to prevent hangs.
+
+    Args:
+        request: CommandExecuteRequest with the command to execute.
+
+    Returns:
+        CommandExecuteResponse: Result of command execution.
+    """
+    from code_puppy.command_line.command_handler import handle_command
+
+    command = request.command
+    if not command.startswith("/"):
+        command = "/" + command
+
+    loop = asyncio.get_running_loop()
+
+    try:
+        # Run blocking command in thread pool with timeout
+        result = await asyncio.wait_for(
+            loop.run_in_executor(_executor, handle_command, command),
+            timeout=COMMAND_TIMEOUT,
+        )
+        return CommandExecuteResponse(success=True, result=result)
+    except asyncio.TimeoutError:
+        return CommandExecuteResponse(
+            success=False, error=f"Command timed out after {COMMAND_TIMEOUT}s"
+        )
+    except Exception as e:
+        return CommandExecuteResponse(success=False, error=str(e))
+
+
+@router.post("/autocomplete")
+async def autocomplete_command(request: AutocompleteRequest) -> AutocompleteResponse:
+    """Get autocomplete suggestions for a partial command.
+
+    Provides intelligent autocomplete based on partial input:
+    - Empty input: returns all command names
+    - Partial command name: returns matching commands and aliases
+    - Complete command with args: returns usage hint
+
+    Args:
+        request: AutocompleteRequest with partial command string.
+
+    Returns:
+        AutocompleteResponse: List of autocomplete suggestions.
+    """
+    from code_puppy.command_line.command_registry import (
+        get_command,
+        get_unique_commands,
+    )
+
+    partial = request.partial.lstrip("/")
+
+    # If empty, return all command names
+    if not partial:
+        suggestions = [f"/{cmd.name}" for cmd in get_unique_commands()]
+        return AutocompleteResponse(suggestions=sorted(suggestions))
+
+    # Split into command name and args
+    parts = partial.split(maxsplit=1)
+    cmd_partial = parts[0].lower()
+
+    # If just the command name (no space yet), suggest matching commands
+    if len(parts) == 1:
+        suggestions = []
+        for cmd in get_unique_commands():
+            if cmd.name.startswith(cmd_partial):
+                suggestions.append(f"/{cmd.name}")
+            for alias in cmd.aliases:
+                if alias.startswith(cmd_partial):
+                    suggestions.append(f"/{alias}")
+        return AutocompleteResponse(suggestions=sorted(set(suggestions)))
+
+    # Command name complete, suggest based on command type
+    # (For now, just return the command usage as a hint)
+    cmd = get_command(cmd_partial)
+    if cmd:
+        return AutocompleteResponse(suggestions=[cmd.usage])
+
+    return AutocompleteResponse(suggestions=[])

code_puppy/api/routers/config.py

@@ -0,0 +1,74 @@
+"""Configuration management API endpoints."""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Any, Dict, List
+
+router = APIRouter()
+
+
+class ConfigValue(BaseModel):
+    key: str
+    value: Any
+
+
+class ConfigUpdate(BaseModel):
+    value: Any
+
+
+@router.get("/")
+async def list_config() -> Dict[str, Any]:
+    """List all configuration keys and their current values."""
+    from code_puppy.config import get_config_keys, get_value
+
+    config = {}
+    for key in get_config_keys():
+        config[key] = get_value(key)
+    return {"config": config}
+
+
+@router.get("/keys")
+async def get_config_keys_list() -> List[str]:
+    """Get list of all valid configuration keys."""
+    from code_puppy.config import get_config_keys
+
+    return get_config_keys()
+
+
+@router.get("/{key}")
+async def get_config_value(key: str) -> ConfigValue:
+    """Get a specific configuration value."""
+    from code_puppy.config import get_config_keys, get_value
+
+    valid_keys = get_config_keys()
+    if key not in valid_keys:
+        raise HTTPException(
+            404, f"Config key '{key}' not found. Valid keys: {valid_keys}"
+        )
+
+    value = get_value(key)
+    return ConfigValue(key=key, value=value)
+
+
+@router.put("/{key}")
+async def set_config_value(key: str, update: ConfigUpdate) -> ConfigValue:
+    """Set a configuration value."""
+    from code_puppy.config import get_config_keys, get_value, set_value
+
+    valid_keys = get_config_keys()
+    if key not in valid_keys:
+        raise HTTPException(
+            404, f"Config key '{key}' not found. Valid keys: {valid_keys}"
+        )
+
+    set_value(key, str(update.value))
+    return ConfigValue(key=key, value=get_value(key))
+
+
+@router.delete("/{key}")
+async def reset_config_value(key: str) -> Dict[str, str]:
+    """Reset a configuration value to default (remove from config file)."""
+    from code_puppy.config import reset_value
+
+    reset_value(key)
+    return {"message": f"Config key '{key}' reset to default"}

code_puppy/api/routers/sessions.py

@@ -0,0 +1,232 @@
+"""Sessions API endpoints for retrieving subagent session data."""
+
+import asyncio
+import json
+import pickle
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+# Thread pool for blocking file I/O
+_executor = ThreadPoolExecutor(max_workers=2)
+
+# Timeout for file operations (seconds)
+FILE_IO_TIMEOUT = 10.0
+
+router = APIRouter()
+
+
+class SessionInfo(BaseModel):
+    """Session metadata information."""
+
+    session_id: str
+    agent_name: Optional[str] = None
+    initial_prompt: Optional[str] = None
+    created_at: Optional[str] = None
+    last_updated: Optional[str] = None
+    message_count: int = 0
+
+
+class MessageContent(BaseModel):
+    """Message content with role and optional timestamp."""
+
+    role: str
+    content: Any
+    timestamp: Optional[str] = None
+
+
+class SessionDetail(SessionInfo):
+    """Session info with full message history."""
+
+    messages: List[Dict[str, Any]] = []
+
+
+def _get_sessions_dir() -> Path:
+    """Get the subagent sessions directory.
+
+    Returns:
+        Path to the subagent sessions directory
+    """
+    from code_puppy.config import DATA_DIR
+
+    return Path(DATA_DIR) / "subagent_sessions"
+
+
+def _serialize_message(msg: Any) -> Dict[str, Any]:
+    """Serialize a pydantic-ai message to a JSON-safe dict.
+
+    Handles various pydantic-ai message types that may be stored
+    in the pickle files.
+
+    Args:
+        msg: A pydantic-ai message object
+
+    Returns:
+        JSON-serializable dictionary representation of the message
+    """
+    # Handle pydantic v2 models with model_dump
+    if hasattr(msg, "model_dump"):
+        return msg.model_dump(mode="json")
+    # Handle objects with __dict__ (convert values to strings for safety)
+    elif hasattr(msg, "__dict__"):
+        return {k: str(v) for k, v in msg.__dict__.items()}
+    # Fallback: wrap in a content dict
+    else:
+        return {"content": str(msg)}
+
+
+def _load_json_sync(file_path: Path) -> dict:
+    """Synchronous JSON file load (for use in executor)."""
+    with open(file_path, "r") as f:
+        return json.load(f)
+
+
+def _load_pickle_sync(file_path: Path) -> Any:
+    """Synchronous pickle file load (for use in executor)."""
+    with open(file_path, "rb") as f:
+        return pickle.load(f)
+
+
+@router.get("/")
+async def list_sessions() -> List[SessionInfo]:
+    """List all available sessions.
+
+    Returns:
+        List of SessionInfo objects for each session found
+    """
+    sessions_dir = _get_sessions_dir()
+    if not sessions_dir.exists():
+        return []
+
+    loop = asyncio.get_running_loop()
+    sessions = []
+
+    for txt_file in sessions_dir.glob("*.txt"):
+        session_id = txt_file.stem
+        try:
+            # Run blocking I/O in thread pool with timeout
+            metadata = await asyncio.wait_for(
+                loop.run_in_executor(_executor, _load_json_sync, txt_file),
+                timeout=FILE_IO_TIMEOUT,
+            )
+            sessions.append(
+                SessionInfo(
+                    session_id=session_id,
+                    agent_name=metadata.get("agent_name"),
+                    initial_prompt=metadata.get("initial_prompt"),
+                    created_at=metadata.get("created_at"),
+                    last_updated=metadata.get("last_updated"),
+                    message_count=metadata.get("message_count", 0),
+                )
+            )
+        except asyncio.TimeoutError:
+            # Timed out reading file, include basic info
+            sessions.append(SessionInfo(session_id=session_id))
+        except Exception:
+            # If we can't parse metadata, still include basic session info
+            sessions.append(SessionInfo(session_id=session_id))
+
+    return sessions
+
+
+@router.get("/{session_id}")
+async def get_session(session_id: str) -> SessionInfo:
+    """Get session metadata.
+
+    Args:
+        session_id: The session identifier
+
+    Returns:
+        SessionInfo with metadata for the specified session
+
+    Raises:
+        HTTPException: 404 if session not found, 504 on timeout
+    """
+    sessions_dir = _get_sessions_dir()
+    txt_file = sessions_dir / f"{session_id}.txt"
+
+    if not txt_file.exists():
+        raise HTTPException(404, f"Session '{session_id}' not found")
+
+    loop = asyncio.get_running_loop()
+
+    try:
+        metadata = await asyncio.wait_for(
+            loop.run_in_executor(_executor, _load_json_sync, txt_file),
+            timeout=FILE_IO_TIMEOUT,
+        )
+    except asyncio.TimeoutError:
+        raise HTTPException(504, f"Timeout reading session '{session_id}'")
+
+    return SessionInfo(
+        session_id=session_id,
+        agent_name=metadata.get("agent_name"),
+        initial_prompt=metadata.get("initial_prompt"),
+        created_at=metadata.get("created_at"),
+        last_updated=metadata.get("last_updated"),
+        message_count=metadata.get("message_count", 0),
+    )
+
+
+@router.get("/{session_id}/messages")
+async def get_session_messages(session_id: str) -> List[Dict[str, Any]]:
+    """Get the full message history for a session.
+
+    Args:
+        session_id: The session identifier
+
+    Returns:
+        List of serialized message dictionaries
+
+    Raises:
+        HTTPException: 404 if session messages not found, 500 on load error, 504 on timeout
+    """
+    sessions_dir = _get_sessions_dir()
+    pkl_file = sessions_dir / f"{session_id}.pkl"
+
+    if not pkl_file.exists():
+        raise HTTPException(404, f"Session '{session_id}' messages not found")
+
+    loop = asyncio.get_running_loop()
+
+    try:
+        messages = await asyncio.wait_for(
+            loop.run_in_executor(_executor, _load_pickle_sync, pkl_file),
+            timeout=FILE_IO_TIMEOUT,
+        )
+        return [_serialize_message(msg) for msg in messages]
+    except asyncio.TimeoutError:
+        raise HTTPException(504, f"Timeout loading session '{session_id}' messages")
+    except Exception as e:
+        raise HTTPException(500, f"Error loading session messages: {e}")
+
+
+@router.delete("/{session_id}")
+async def delete_session(session_id: str) -> Dict[str, str]:
+    """Delete a session and its data.
+
+    Args:
+        session_id: The session identifier
+
+    Returns:
+        Success message dict
+
+    Raises:
+        HTTPException: 404 if session not found
+    """
+    sessions_dir = _get_sessions_dir()
+    txt_file = sessions_dir / f"{session_id}.txt"
+    pkl_file = sessions_dir / f"{session_id}.pkl"
+
+    if not txt_file.exists() and not pkl_file.exists():
+        raise HTTPException(404, f"Session '{session_id}' not found")
+
+    if txt_file.exists():
+        txt_file.unlink()
+    if pkl_file.exists():
+        pkl_file.unlink()
+
+    return {"message": f"Session '{session_id}' deleted"}