soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/shared/renderer_protocol.py

@@ -0,0 +1,158 @@
+"""Abstract callback interface for CLI/TUI event rendering.
+
+This module defines the RendererProtocol that CLI and TUI renderers implement.
+The EventProcessor calls these callbacks; implementations handle mode-specific display.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Protocol
+
+if TYPE_CHECKING:
+    from soothe_sdk import Plan
+
+
+class RendererProtocol(Protocol):
+    """Abstract callback interface for CLI/TUI event rendering.
+
+    Implementations handle mode-specific display while EventProcessor
+    handles unified event routing and state management.
+
+    Core callbacks are required for basic functionality.
+    Optional fine-grained hooks can be implemented for specific event handling.
+    """
+
+    # === Core Callbacks (Required) ===
+
+    def on_assistant_text(
+        self,
+        text: str,
+        *,
+        is_main: bool,
+        is_streaming: bool,
+    ) -> None:
+        """Assistant text chunk or complete message.
+
+        Args:
+            text: Text content to display.
+            is_main: True if from main agent, False if from subagent.
+            is_streaming: True if partial chunk, False if complete.
+        """
+        ...
+
+    def on_tool_call(
+        self,
+        name: str,
+        args: dict[str, Any],
+        tool_call_id: str,
+        *,
+        is_main: bool,
+    ) -> None:
+        """Tool invocation started.
+
+        Args:
+            name: Tool name (snake_case internal name).
+            args: Parsed argument dictionary.
+            tool_call_id: Unique identifier for correlation with result.
+            is_main: True if from main agent.
+        """
+        ...
+
+    def on_tool_result(
+        self,
+        name: str,
+        result: str,
+        tool_call_id: str,
+        *,
+        is_error: bool,
+        is_main: bool,
+    ) -> None:
+        """Tool returned a result.
+
+        Args:
+            name: Tool name.
+            result: Result content (may be truncated).
+            tool_call_id: Correlates with on_tool_call.
+            is_error: True if result indicates failure.
+            is_main: True if from main agent.
+        """
+        ...
+
+    def on_status_change(self, state: str) -> None:
+        """Daemon state changed.
+
+        Args:
+            state: One of "idle", "running", "stopped".
+        """
+        ...
+
+    def on_error(self, error: str, *, context: str | None = None) -> None:
+        """Error occurred.
+
+        Args:
+            error: Error message.
+            context: Optional context (e.g., "tool_execution", "daemon").
+        """
+        ...
+
+    def on_progress_event(
+        self,
+        event_type: str,
+        data: dict[str, Any],
+        *,
+        namespace: tuple[str, ...],
+    ) -> None:
+        """Protocol/subagent progress event.
+
+        Catch-all for events not covered by specific callbacks.
+
+        Args:
+            event_type: Full event type string (e.g., "soothe.capability.browser.step.running").
+            data: Event payload.
+            namespace: Subagent namespace tuple (empty for main agent).
+        """
+        ...
+
+    # === Optional Fine-Grained Hooks ===
+    # These have default no-op implementations in base renderers
+
+    def on_plan_created(self, plan: Plan) -> None:
+        """Plan was created.
+
+        Default implementation may delegate to on_progress_event.
+
+        Args:
+            plan: The created plan object.
+        """
+        ...
+
+    def on_plan_step_started(self, step_id: str, description: str) -> None:
+        """Plan step began execution.
+
+        Args:
+            step_id: Unique step identifier.
+            description: Step description.
+        """
+        ...
+
+    def on_plan_step_completed(
+        self,
+        step_id: str,
+        success: bool,  # noqa: FBT001
+        duration_ms: int,
+    ) -> None:
+        """Plan step finished.
+
+        Args:
+            step_id: Unique step identifier.
+            success: True if step succeeded.
+            duration_ms: Execution duration in milliseconds.
+        """
+        ...
+
+    def on_turn_end(self) -> None:
+        """Current turn completed.
+
+        Use for finalizing streaming buffers and cleanup.
+        """
+        ...

soothe_cli/shared/rendering.py

@@ -0,0 +1,43 @@
+"""Shared TUI utilities for state management and rendering.
+
+This module contains reusable display helpers used by both TUI and headless modes.
+"""
+
+from __future__ import annotations
+
+from soothe_sdk import _TASK_NAME_RE
+
+__all__ = [
+    "update_name_map_from_tool_calls",
+]
+
+
+def _display_subagent_name(name: str) -> str:
+    """Return friendly display name for a subagent id."""
+    from soothe_cli.shared.subagent_routing import SUBAGENT_DISPLAY_NAMES
+
+    return SUBAGENT_DISPLAY_NAMES.get(name.lower(), name.replace("_", " ").title())
+
+
+def update_name_map_from_tool_calls(message_obj: object, name_map: dict[str, str]) -> None:
+    """Update tool-call-id -> display name mapping from AIMessage/tool calls.
+
+    This is the shared implementation used by both TUI and headless modes.
+    """
+    tool_calls = getattr(message_obj, "tool_calls", None) or []
+    for tc in tool_calls:
+        if not isinstance(tc, dict):
+            continue
+        if tc.get("name") != "task":
+            continue
+        call_id = str(tc.get("id", ""))
+        args = tc.get("args", {})
+        raw_name = ""
+        if isinstance(args, dict):
+            raw_name = str(args.get("agent", "") or args.get("name", ""))
+        elif args:
+            match = _TASK_NAME_RE.search(str(args))
+            if match:
+                raw_name = match.group(1)
+        if call_id and raw_name:
+            name_map[call_id] = _display_subagent_name(raw_name)

soothe_cli/shared/slash_commands.py

@@ -0,0 +1,354 @@
+"""Slash command handlers for CLI and TUI (RFC-404).
+
+Unified command registry with metadata-based routing:
+- CLI-only commands: handled locally
+- Daemon RPC commands: structured data rendering
+- Daemon routing commands: behavior indicators
+
+This module provides the COMMANDS registry and rendering functions.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from rich.panel import Panel
+from rich.table import Table
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+# ---------------------------------------------------------------------------
+# Rendering Functions (must be defined before COMMANDS registry)
+# ---------------------------------------------------------------------------
+
+
+def show_commands(console: Console) -> None:
+    """Show available slash commands (CLI-only)."""
+    table = Table(title="Available Commands", show_lines=False)
+    table.add_column("Command", style="bold cyan")
+    table.add_column("Description")
+
+    # Import COMMANDS here to avoid circular reference at module load
+    from soothe_cli.shared.slash_commands import COMMANDS
+
+    for cmd, entry in COMMANDS.items():
+        table.add_row(cmd, entry.get("description", ""))
+
+    console.print(table)
+
+
+def show_keymaps(console: Console) -> None:
+    """Show keyboard shortcuts (CLI-only)."""
+    table = Table(title="Keyboard Shortcuts", show_lines=False)
+    table.add_column("Shortcut", style="bold cyan")
+    table.add_column("Action")
+
+    for k, v in KEYBOARD_SHORTCUTS.items():
+        table.add_row(k, v)
+
+    console.print(table)
+
+
+def show_memory(console: Console, data: dict[str, Any]) -> None:
+    """Render memory stats from daemon RPC response."""
+    stats = data.get("memory_stats", {})
+    console.print(
+        Panel(
+            json.dumps(stats, indent=2, default=str),
+            title="Memory Stats",
+            border_style="cyan",
+        )
+    )
+
+
+def show_policy(console: Console, data: dict[str, Any]) -> None:
+    """Render policy profile from daemon RPC response."""
+    policy = data.get("policy", {})
+    console.print(f"[dim]Policy profile: {policy.get('profile', 'unknown')}[/dim]")
+    console.print(f"[dim]Planner routing: {policy.get('planner_routing', 'unknown')}[/dim]")
+    console.print(f"[dim]Memory backend: {policy.get('memory_backend', 'unknown')}[/dim]")
+
+
+def show_history(console: Console, data: dict[str, Any]) -> None:
+    """Render input history from daemon RPC response."""
+    history = data.get("history", [])
+    if not history:
+        console.print("[dim]No recent history.[/dim]")
+        return
+
+    table = Table(title="Recent Input History", show_lines=False)
+    table.add_column("Time", style="dim")
+    table.add_column("Input", style="cyan")
+
+    for item in history[:10]:  # Show last 10
+        timestamp = item.get("timestamp", "")
+        text = item.get("text", "")
+        if len(text) > 50:
+            text = text[:47] + "..."
+        table.add_row(timestamp, text)
+
+    console.print(table)
+
+
+def show_config(console: Console, data: dict[str, Any]) -> None:
+    """Render configuration summary from daemon RPC response."""
+    config = data.get("config", {})
+    console.print(
+        Panel(
+            json.dumps(config, indent=2, default=str),
+            title="Configuration Summary",
+            border_style="cyan",
+        )
+    )
+
+
+def show_review(console: Console, data: dict[str, Any]) -> None:
+    """Render conversation/action history from daemon RPC response."""
+    history = data.get("review", [])
+    if not history:
+        console.print("[dim]No conversation history.[/dim]")
+        return
+
+    table = Table(title="Conversation Review", show_lines=False)
+    table.add_column("Time", style="dim")
+    table.add_column("Type", style="cyan")
+    table.add_column("Content", style="white")
+
+    for item in history[:20]:
+        timestamp = item.get("timestamp", "")
+        item_type = item.get("type", "unknown")
+        content = item.get("content", "")
+        if len(content) > 60:
+            content = content[:57] + "..."
+        table.add_row(timestamp, item_type, content)
+
+    console.print(table)
+
+
+def show_autopilot_dashboard(console: Console, data: dict[str, Any]) -> None:
+    """Render autopilot dashboard from daemon RPC response."""
+    dashboard = data.get("autopilot_dashboard", {})
+
+    table = Table(title="Autopilot Dashboard", show_lines=False)
+    table.add_column("Metric", style="bold cyan")
+    table.add_column("Value", style="white")
+
+    # Display key metrics
+    table.add_row("Status", dashboard.get("status", "idle"))
+    table.add_row("Iterations", str(dashboard.get("iterations", 0)))
+    table.add_row("Goals Completed", str(dashboard.get("goals_completed", 0)))
+    table.add_row("Goals Active", str(dashboard.get("goals_active", 0)))
+
+    console.print(table)
+
+    # Display active goals if present
+    active_goals = dashboard.get("active_goals", [])
+    if active_goals:
+        console.print("\n[bold cyan]Active Goals:[/bold cyan]")
+        for goal in active_goals:
+            console.print(f"  • {goal.get('description', 'unknown')}")
+
+
+# ---------------------------------------------------------------------------
+# Keyboard Shortcuts
+# ---------------------------------------------------------------------------
+
+KEYBOARD_SHORTCUTS: dict[str, str] = {
+    "Ctrl+Q": "Quit TUI: Stop thread (confirm) and exit client",
+    "Ctrl+D": "Detach TUI: Leave thread running (confirm) and exit client",
+    "Ctrl+C": "Cancel running job, press twice within 1s to quit",
+    "Ctrl+E": "Focus chat input",
+    "Ctrl+Y": "Copy last message to clipboard",
+}
+
+
+# ---------------------------------------------------------------------------
+# Unified Command Registry (RFC-404)
+# ---------------------------------------------------------------------------
+
+COMMANDS: dict[str, dict[str, Any]] = {
+    # CLI-only commands (2)
+    "/help": {
+        "location": "cli",
+        "handler": show_commands,
+        "description": "Show available commands",
+    },
+    "/keymaps": {
+        "location": "cli",
+        "handler": show_keymaps,
+        "description": "Show keyboard shortcuts",
+    },
+    # Daemon RPC commands (12)
+    "/clear": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "clear",
+        "description": "Clear thread history",
+        "requires_thread": True,
+    },
+    "/exit": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "exit",
+        "description": "Stop thread and exit client",
+    },
+    "/quit": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "quit",
+        "description": "Stop thread and exit client",
+    },
+    "/detach": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "detach",
+        "description": "Leave thread running and exit client",
+    },
+    "/cancel": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "cancel",
+        "description": "Cancel the current running job",
+        "requires_thread": True,
+    },
+    "/memory": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "memory",
+        "description": "Show memory stats",
+        "requires_thread": True,
+        "handler": show_memory,
+    },
+    "/policy": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "policy",
+        "description": "Show active policy profile",
+        "handler": show_policy,
+    },
+    "/history": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "history",
+        "description": "Show recent prompt history",
+        "requires_thread": True,
+        "handler": show_history,
+    },
+    "/config": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "config",
+        "description": "Show active configuration summary",
+        "handler": show_config,
+    },
+    "/review": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "review",
+        "description": "Review recent conversation and action history",
+        "requires_thread": True,
+        "handler": show_review,
+    },
+    "/thread": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "thread",
+        "description": "Thread operations (archive <id>)",
+        "params_schema": {
+            "action": {"type": "string", "required": True},
+            "id": {"type": "string", "required": False},
+        },
+    },
+    "/resume": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "resume",
+        "description": "Resume a recent thread",
+        "params_schema": {"thread_id": {"type": "string", "required": True}},
+    },
+    "/autopilot": {
+        "location": "daemon",
+        "type": "rpc",
+        "daemon_command": "autopilot_dashboard",
+        "description": "Show autopilot dashboard",
+        "requires_thread": True,
+        "handler": show_autopilot_dashboard,
+    },
+    # Daemon routing commands (5)
+    "/plan": {"location": "daemon", "type": "routing", "description": "Trigger plan mode"},
+    "/browser": {
+        "location": "daemon",
+        "type": "routing",
+        "description": "Route query to Browser subagent",
+        "requires_query": True,
+    },
+    "/claude": {
+        "location": "daemon",
+        "type": "routing",
+        "description": "Route query to Claude subagent",
+        "requires_query": True,
+    },
+    "/research": {
+        "location": "daemon",
+        "type": "routing",
+        "description": "Route query to Research subagent",
+        "requires_query": True,
+    },
+}
+
+
+# Legacy compatibility (used by tests/old code)
+SLASH_COMMANDS: dict[str, str] = {
+    cmd: entry.get("description", "") for cmd, entry in COMMANDS.items()
+}
+
+
+# ---------------------------------------------------------------------------
+# Legacy helper (used by tests/old code)
+# ---------------------------------------------------------------------------
+
+
+def parse_autonomous_command(cmd: str) -> tuple[int | None, str] | None:
+    """Parse `/autopilot` command payload (legacy helper)."""
+    stripped = cmd.strip()
+    if not stripped.startswith("/autopilot"):
+        return None
+
+    parts = stripped.split(maxsplit=2)
+    if len(parts) == 1:
+        return None
+
+    if len(parts) == 2:
+        single = parts[1].strip()
+        if not single or single.isdigit():
+            return None
+        return (None, single)
+
+    maybe_num = parts[1].strip()
+    if maybe_num.isdigit():
+        prompt = parts[2].strip()
+        if not prompt:
+            return None
+        max_iterations = int(maybe_num)
+        return (max_iterations if max_iterations > 0 else None, prompt)
+
+    prompt = f"{parts[1]} {parts[2]}".strip()
+    return (None, prompt) if prompt else None
+
+
+__all__ = [
+    "COMMANDS",
+    "SLASH_COMMANDS",
+    "KEYBOARD_SHORTCUTS",
+    "parse_autonomous_command",
+    "show_commands",
+    "show_keymaps",
+    "show_memory",
+    "show_policy",
+    "show_history",
+    "show_config",
+    "show_review",
+    "show_autopilot_dashboard",
+]

soothe_cli/shared/subagent_routing.py

@@ -0,0 +1,63 @@
+"""Subagent display names and input routing (shared by CLI and TUI)."""
+
+from __future__ import annotations
+
+SUBAGENT_DISPLAY_NAMES: dict[str, str] = {
+    "browser": "Browser",
+    "claude": "Claude",
+    "research": "Research",
+}
+
+BUILTIN_SUBAGENT_NAMES: list[str] = list(SUBAGENT_DISPLAY_NAMES.keys())
+
+
+def get_subagent_display_name(technical_name: str) -> str:
+    """Get display name for a subagent.
+
+    Args:
+        technical_name: Internal subagent name.
+
+    Returns:
+        PascalCase display name.
+    """
+    return SUBAGENT_DISPLAY_NAMES.get(
+        technical_name,
+        technical_name.replace("_", " ").title().replace(" ", ""),
+    )
+
+
+def parse_subagent_from_input(user_input: str) -> tuple[str | None, str]:
+    """Parse subagent subcommand from user input.
+
+    Detects subagent subcommands (e.g., /browser, /claude) anywhere in the text
+    and extracts the subagent name along with the cleaned input text.
+
+    Args:
+        user_input: Raw user input string.
+
+    Returns:
+        Tuple of ``(subagent_name, cleaned_text)``.
+        ``subagent_name`` is ``None`` if no valid subcommand found.
+        The subcommand is removed from ``cleaned_text``.
+
+    Examples:
+        ``"/browser check this"`` -> ``("browser", "check this")``
+        ``"Can you /claude analyze this"`` -> ``("claude", "Can you analyze this")``
+        ``"hello world"`` -> ``(None, "hello world")``
+    """
+    first_match: tuple[int, str] | None = None
+
+    for subagent_name in BUILTIN_SUBAGENT_NAMES:
+        subcommand = f"/{subagent_name}"
+        idx = user_input.lower().find(subcommand)
+        if idx != -1 and (first_match is None or idx < first_match[0]):
+            first_match = (idx, subagent_name)
+
+    if first_match:
+        idx, subagent_name = first_match
+        subcommand = f"/{subagent_name}"
+        cleaned = user_input[:idx] + user_input[idx + len(subcommand) :]
+        cleaned = " ".join(cleaned.split())
+        return (subagent_name, cleaned)
+
+    return (None, user_input)