soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/config/cli_config.py

@@ -0,0 +1,155 @@
+"""CLI-specific configuration class (IG-174 Phase 3)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class CLIConfig:
+    """Minimal CLI config for daemon connection.
+
+    Full config available via daemon RPC when needed.
+    CLI package can be installed independently without full SootheConfig.
+    """
+
+    # WebSocket connection
+    daemon_host: str = "127.0.0.1"
+    daemon_port: int = 8765
+
+    # CLI behavior
+    verbosity: str = "normal"
+    output_format: str = "text"
+
+    # Paths
+    soothe_home: Path = field(default_factory=lambda: Path.home() / ".soothe")
+
+    # Daemon config cache (fetched via RPC)
+    _daemon_config_cache: dict[str, Any] = field(default_factory=dict)
+
+    def websocket_url(self) -> str:
+        """Construct WebSocket URL for daemon connection."""
+        return f"ws://{self.daemon_host}:{self.daemon_port}"
+
+    async def fetch_daemon_config(self, section: str = "all") -> dict[str, Any]:
+        """Fetch daemon config section via WebSocket RPC.
+
+        Args:
+            section: Config section name (e.g., "providers", "defaults", "all").
+
+        Returns:
+            Wire-safe config section dict.
+        """
+        from soothe_sdk.client import WebSocketClient, fetch_config_section
+
+        client = WebSocketClient(url=self.websocket_url())
+        await client.connect()
+
+        try:
+            config_section = await fetch_config_section(client, section, timeout=5.0)
+            self._daemon_config_cache[section] = config_section
+            return config_section
+        finally:
+            await client.close()
+
+    def get_cached_config(self, section: str) -> dict[str, Any]:
+        """Get cached daemon config section.
+
+        Args:
+            section: Config section name.
+
+        Returns:
+            Cached config section dict, or empty dict if not cached.
+        """
+        return self._daemon_config_cache.get(section, {})
+
+    @classmethod
+    def from_config_file(cls, config_path: Path | None = None) -> CLIConfig:
+        """Load CLI config from YAML file (minimal subset).
+
+        Reads minimal CLI-relevant settings from config file.
+        Full config available via daemon RPC.
+
+        Args:
+            config_path: Path to config file. Defaults to ~/.soothe/config.yml.
+
+        Returns:
+            CLIConfig instance with minimal settings.
+        """
+        import yaml
+
+        if config_path is None:
+            config_path = Path.home() / ".soothe" / "config.yml"
+
+        if not config_path.exists():
+            return cls()  # Use defaults
+
+        with open(config_path) as f:
+            data = yaml.safe_load(f) or {}
+
+        # Extract minimal CLI-relevant config
+        daemon_section = data.get("daemon", {})
+        transports = daemon_section.get("transports", {})
+        websocket = transports.get("websocket", {})
+
+        return cls(
+            daemon_host=websocket.get("host", "127.0.0.1"),
+            daemon_port=websocket.get("port", 8765),
+            verbosity=data.get("logging", {}).get("verbosity", "normal"),
+            soothe_home=Path(data.get("home", str(Path.home() / ".soothe"))),
+        )
+
+    @classmethod
+    def from_soothe_config(cls, soothe_config: Any) -> CLIConfig:
+        """Create CLIConfig from full SootheConfig (compatibility helper).
+
+        Used during transition period where some code still has SootheConfig.
+
+        Args:
+            soothe_config: Full SootheConfig instance.
+
+        Returns:
+            CLIConfig with WebSocket settings extracted.
+        """
+        return cls(
+            daemon_host=soothe_config.daemon.transports.websocket.host,
+            daemon_port=soothe_config.daemon.transports.websocket.port,
+            verbosity=soothe_config.logging.verbosity,
+            soothe_home=Path(soothe_config.home),
+        )
+
+    # Compatibility properties for transition period
+    # These allow gradual migration without breaking existing code
+
+    @property
+    def daemon(self) -> Any:
+        """Compatibility property: return daemon config structure."""
+        return type(
+            "DaemonConfig",
+            (),
+            {
+                "transports": type(
+                    "TransportsConfig",
+                    (),
+                    {
+                        "websocket": type(
+                            "WebSocketConfig",
+                            (),
+                            {"host": self.daemon_host, "port": self.daemon_port},
+                        )
+                    },
+                )()
+            },
+        )()
+
+    @property
+    def logging(self) -> Any:
+        """Compatibility property: return logging config structure."""
+        return type("LoggingConfig", (), {"verbosity": self.verbosity})()
+
+    @property
+    def home(self) -> str:
+        """Compatibility property: return home path string."""
+        return str(self.soothe_home)

soothe_cli/plan/__init__.py

@@ -0,0 +1,5 @@
+"""Plan rendering utilities for CLI/TUI."""
+
+from soothe_cli.plan.rich_tree import render_plan_tree
+
+__all__ = ["render_plan_tree"]

soothe_cli/plan/rich_tree.py

@@ -0,0 +1,54 @@
+"""Render planner ``Plan`` models as Rich trees."""
+
+from __future__ import annotations
+
+import re
+
+from rich.text import Text
+from rich.tree import Tree
+from soothe_sdk.protocol_schemas import Plan
+
+_TASK_NAME_RE = re.compile(r'"?name"?\s*:\s*"?(\w+)"?')
+_STATUS_MARKERS: dict[str, tuple[str, str]] = {
+    "pending": ("[ ]", "dim"),
+    "in_progress": ("[>]", "bold yellow"),
+    "completed": ("[+]", "bold green"),
+    "failed": ("[x]", "bold red"),
+}
+
+
+def render_plan_tree(plan: Plan, title: str | None = None) -> Tree:
+    """Render a plan as a Rich Tree with status markers, dependencies, and activities."""
+    label = title or f"Plan: {plan.goal}"
+    tree = Tree(Text(label, style="bold cyan"))
+
+    if plan.reasoning:
+        reasoning_node = tree.add(Text("Reasoning", style="dim italic"))
+        reasoning_node.add(Text(plan.reasoning, style="dim"))
+
+    if plan.general_activity:
+        activity_node = tree.add(Text("General", style="dim italic"))
+        activity_node.add(Text(plan.general_activity, style="dim"))
+
+    for step in plan.steps:
+        marker, style = _STATUS_MARKERS.get(step.status, ("[ ]", "dim"))
+        step_style = {"in_progress": "yellow", "completed": "green"}.get(step.status, "dim")
+        parts: list[Text | str] = [
+            Text(marker, style=style),
+            " ",
+            Text(step.description, style=step_style),
+        ]
+        if step.depends_on:
+            dep_str = ", ".join(step.depends_on)
+            parts.append(Text(f"  (< {dep_str})", style="dim italic"))
+
+        step_node = tree.add(Text.assemble(*parts))
+
+        if step.status == "in_progress" and step.current_activity:
+            activity_text = Text(step.current_activity, style="dim")
+            step_node.add(activity_text)
+
+    return tree
+
+
+__all__ = ["_STATUS_MARKERS", "_TASK_NAME_RE", "render_plan_tree"]

soothe_cli/shared/__init__.py

@@ -0,0 +1,107 @@
+"""Shared UX presentation layer for CLI and TUI (not Typer/Textual).
+
+This package provides:
+- Configuration loading and logging setup
+- Unified event processing (RFC-0019)
+- Unified display policy for event/content filtering
+- Abstract renderer protocol for CLI/TUI
+- Shared message processing and utilities
+- Slash command handlers and plan rendering (IG-176)
+"""
+
+from soothe_sdk import setup_logging
+
+from soothe_cli.shared.config_loader import load_config
+from soothe_cli.shared.display_policy import (
+    INTERNAL_EVENT_TYPES,
+    INTERNAL_JSON_KEYS,
+    SKIP_EVENT_TYPES,
+    DisplayPolicy,
+    VerbosityLevel,
+    create_display_policy,
+)
+from soothe_cli.shared.essential_events import (
+    ESSENTIAL_PROGRESS_EVENT_TYPES,
+    GOAL_START_EVENT_TYPES,
+    LOOP_REASON_EVENT_TYPE,
+    STEP_COMPLETE_EVENT_TYPES,
+    STEP_START_EVENT_TYPES,
+    is_essential_progress_event_type,
+    is_goal_start_event_type,
+    is_step_complete_event_type,
+    is_step_start_event_type,
+)
+from soothe_cli.shared.event_processor import EventProcessor
+from soothe_cli.shared.message_processing import (
+    accumulate_tool_call_chunks,
+    coerce_tool_call_args_to_dict,
+    extract_tool_brief,
+    finalize_pending_tool_call,
+    format_tool_call_args,
+    normalize_tool_calls_list,
+    strip_internal_tags,
+    tool_calls_have_any_arg_dict,
+    try_parse_pending_tool_call_args,
+)
+from soothe_cli.shared.processor_state import ProcessorState
+from soothe_cli.shared.renderer_protocol import RendererProtocol
+from soothe_cli.shared.rendering import update_name_map_from_tool_calls
+from soothe_cli.shared.slash_commands import (
+    KEYBOARD_SHORTCUTS,
+    SLASH_COMMANDS,
+    parse_autonomous_command,
+    show_commands,
+    show_config,
+    show_history,
+    show_keymaps,
+    show_memory,
+    show_policy,
+)
+
+__all__ = [
+    "INTERNAL_EVENT_TYPES",
+    "INTERNAL_JSON_KEYS",
+    "SKIP_EVENT_TYPES",
+    "DisplayPolicy",
+    "ESSENTIAL_PROGRESS_EVENT_TYPES",
+    "GOAL_START_EVENT_TYPES",
+    "LOOP_REASON_EVENT_TYPE",
+    # Event processing
+    "EventProcessor",
+    "ProcessorState",
+    # Rendering
+    "RendererProtocol",
+    # Message processing
+    "VerbosityLevel",
+    "accumulate_tool_call_chunks",
+    "coerce_tool_call_args_to_dict",
+    # Display Policy (unified filtering module)
+    "create_display_policy",
+    "extract_tool_brief",
+    "finalize_pending_tool_call",
+    "format_tool_call_args",
+    "is_essential_progress_event_type",
+    "is_goal_start_event_type",
+    "is_step_complete_event_type",
+    "is_step_start_event_type",
+    # Config and logging
+    "load_config",
+    "normalize_tool_calls_list",
+    "setup_logging",
+    "STEP_COMPLETE_EVENT_TYPES",
+    "STEP_START_EVENT_TYPES",
+    "strip_internal_tags",
+    "tool_calls_have_any_arg_dict",
+    "try_parse_pending_tool_call_args",
+    "update_name_map_from_tool_calls",
+    # Slash commands (IG-176)
+    "KEYBOARD_SHORTCUTS",
+    "SLASH_COMMANDS",
+    "parse_autonomous_command",
+    "show_commands",
+    "show_config",
+    "show_history",
+    "show_keymaps",
+    "show_memory",
+    "show_policy",
+]

soothe_cli/shared/command_router.py

@@ -0,0 +1,246 @@
+"""Command routing logic for CLI/TUI (RFC-404).
+
+Routes slash commands based on registry metadata:
+- CLI-only commands: handled locally
+- Daemon RPC commands: send command_request, handle command_response
+- Daemon routing commands: send plain text input
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from rich.console import Console
+    from soothe_sdk.client import WebSocketClient
+
+logger = logging.getLogger(__name__)
+
+
+def parse_slash_command(input_text: str) -> tuple[str, str | None]:
+    """Parse slash command and extract command + query.
+
+    Args:
+        input_text: Full user input (e.g., "/browser AI trends")
+
+    Returns:
+        Tuple of (command, query) where query may be None
+    """
+    stripped = input_text.strip()
+    if not stripped.startswith("/"):
+        return ("", None)
+
+    parts = stripped.split(maxsplit=1)
+    command = parts[0].lower()
+    query = parts[1] if len(parts) > 1 else None
+
+    return (command, query)
+
+
+def validate_command(
+    entry: dict[str, Any], command: str, query: str | None, thread_id: str | None
+) -> tuple[bool, str | None]:
+    """Validate command before routing.
+
+    Args:
+        entry: Command registry entry
+        command: Command name
+        query: Query parameter (if present)
+        thread_id: Current thread ID
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    # Check thread requirement
+    if entry.get("requires_thread") and not thread_id:
+        return (False, "No active thread")
+
+    # Check query requirement for routing commands
+    if entry.get("requires_query") and not query:
+        return (False, f"Command requires query: {command} <query>")
+
+    return (True, None)
+
+
+def find_command_by_daemon_command(daemon_command: str) -> dict[str, Any] | None:
+    """Find command entry by daemon command name.
+
+    Args:
+        daemon_command: Daemon command name (e.g., "memory")
+
+    Returns:
+        Command entry dict or None if not found
+    """
+    from soothe_cli.shared.slash_commands import COMMANDS
+
+    for cmd_name, entry in COMMANDS.items():
+        if entry.get("daemon_command") == daemon_command:
+            return entry
+    return None
+
+
+def parse_command_params(entry: dict[str, Any], query: str) -> dict[str, Any]:
+    """Parse query into params based on schema.
+
+    Args:
+        entry: Command registry entry with params_schema
+        query: Query string to parse
+
+    Returns:
+        Dict of params
+    """
+    schema = entry.get("params_schema", {})
+    if not schema:
+        return {}
+
+    parts = query.strip().split()
+    params = {}
+
+    # Map parts to schema keys
+    schema_keys = list(schema.keys())
+    for i, part in enumerate(parts):
+        if i < len(schema_keys):
+            key = schema_keys[i]
+            params[key] = part
+
+    return params
+
+
+async def route_slash_command(cmd_input: str, console: Console, client: WebSocketClient) -> bool:
+    """Route slash command based on registry metadata (RFC-404).
+
+    Args:
+        cmd_input: Full command input (e.g., "/memory", "/browser AI trends")
+        console: Rich console for rendering
+        client: WebSocket client for daemon communication
+
+    Returns:
+        True if command was handled, False if unknown command
+    """
+    from soothe_cli.shared.slash_commands import COMMANDS
+
+    command, query = parse_slash_command(cmd_input)
+
+    # Not a slash command
+    if not command:
+        return False
+
+    # Lookup command in registry
+    entry = COMMANDS.get(command)
+    if not entry:
+        console.print(f"[red]Unknown command: {command}[/red]")
+        console.print("[dim]Type /help for available commands[/dim]")
+        return True  # Handled (as error)
+
+    # Validate command
+    is_valid, error = validate_command(entry, command, query, client.thread_id)
+    if not is_valid:
+        console.print(f"[red]Error: {error}[/red]")
+        return True  # Handled (as error)
+
+    # Route based on location and type
+    if entry["location"] == "cli":
+        # CLI-only: call handler directly
+        handler = entry.get("handler")
+        if handler:
+            handler(console)
+        return True
+
+    elif entry["location"] == "daemon" and entry.get("type") == "rpc":
+        # Daemon RPC: send command_request
+        await handle_rpc_command(entry, command, query, console, client)
+        return True
+
+    elif entry["location"] == "daemon" and entry.get("type") == "routing":
+        # Daemon routing: send as plain text input
+        await handle_routing_command(cmd_input, console, client)
+        return True
+
+    return False
+
+
+async def handle_rpc_command(
+    entry: dict[str, Any],
+    command: str,
+    query: str | None,
+    console: Console,
+    client: WebSocketClient,
+) -> None:
+    """Handle daemon RPC command with structured request/response (RFC-404).
+
+    Args:
+        entry: Command registry entry
+        command: Command name
+        query: Query/params (if present)
+        console: Rich console
+        client: WebSocket client
+    """
+    daemon_command = entry["daemon_command"]
+
+    # Build request
+    request = {
+        "type": "command_request",
+        "command": daemon_command,
+        "thread_id": client.thread_id,
+    }
+
+    # Parse params if schema exists
+    if entry.get("params_schema") and query:
+        params = parse_command_params(entry, query)
+        request["params"] = params
+
+    # Send request and wait for response
+    try:
+        response = await client.request_response(
+            request, response_type="command_response", timeout=5.0
+        )
+
+        # Handle response
+        if response.get("error"):
+            console.print(f"[red]Error: {response['error']}[/red]")
+        elif response.get("data"):
+            handler = entry.get("handler")
+            if handler:
+                handler(console, response["data"])
+            else:
+                # Default: pretty print JSON
+                from rich.panel import Panel
+
+                console.print(
+                    Panel(
+                        json.dumps(response["data"], indent=2, default=str),
+                        title=daemon_command,
+                        border_style="cyan",
+                    )
+                )
+
+    except TimeoutError:
+        console.print("[red]Error: Command request timed out[/red]")
+    except Exception as exc:
+        logger.exception("RPC command failed")
+        console.print(f"[red]Error: {exc}[/red]")
+
+
+async def handle_routing_command(cmd_input: str, console: Console, client: WebSocketClient) -> None:
+    """Handle daemon routing command by sending plain text input (RFC-404).
+
+    Args:
+        cmd_input: Full command input (e.g., "/browser AI trends")
+        console: Rich console
+        client: WebSocket client
+    """
+    # Send as plain text - daemon input parser will route
+    await client.send_input(cmd_input)
+
+
+__all__ = [
+    "parse_slash_command",
+    "route_slash_command",
+    "validate_command",
+    "find_command_by_daemon_command",
+    "parse_command_params",
+    "handle_rpc_command",
+    "handle_routing_command",
+]

soothe_cli/shared/config_loader.py

@@ -0,0 +1,68 @@
+"""Configuration loading utilities (IG-174 Phase 3)."""
+
+import logging
+import time
+from pathlib import Path
+
+from dotenv import load_dotenv
+from soothe_sdk import SOOTHE_HOME
+
+from soothe_cli.config.cli_config import CLIConfig
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_CONFIG_PATH = Path(SOOTHE_HOME) / "config.yml"
+
+# Config cache for performance
+_config_cache: dict[str, CLIConfig] = {}
+
+
+def load_config(config_path: str | None = None) -> CLIConfig:
+    """Load CLIConfig from a file path or defaults with caching.
+
+    CLIConfig is minimal and designed for independent CLI package installation.
+    Full daemon config available via WebSocket RPC when needed.
+
+    When no ``config_path`` is provided, automatically checks
+    ``~/.soothe/config.yml`` and loads it if present.
+
+    Uses an in-memory cache to avoid re-parsing config files.
+
+    Args:
+        config_path: Path to a YAML config file, or ``None`` for defaults.
+
+    Returns:
+        A ``CLIConfig`` instance.
+    """
+    # Load environment variables from .env file
+    # This ensures LangSmith and other env vars are available
+    load_dotenv()
+
+    # Determine the actual path to use
+    path_to_load: Path | None = None
+    if config_path:
+        path_to_load = Path(config_path)
+    elif _DEFAULT_CONFIG_PATH.is_file():
+        path_to_load = _DEFAULT_CONFIG_PATH
+
+    # Use "default" as cache key when no path is provided
+    cache_key = str(path_to_load) if path_to_load else "default"
+
+    # Check cache first
+    if cache_key in _config_cache:
+        logger.debug("Config loaded from cache: %s", cache_key)
+        return _config_cache[cache_key]
+
+    load_start = time.perf_counter()
+
+    # Load minimal CLI config
+    config = CLIConfig.from_config_file(path_to_load)
+    _config_cache[cache_key] = config
+
+    elapsed_ms = (time.perf_counter() - load_start) * 1000
+    if path_to_load:
+        logger.info("Loaded CLI config from '%s' in %.1fms", path_to_load, elapsed_ms)
+    else:
+        logger.debug("Created default CLI config in %.1fms", elapsed_ms)
+
+    return config