soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Soothe CLI client - communicates with daemon via WebSocket."""
+
+__version__ = "0.1.0"
+
+__all__ = []

soothe_cli/cli/__init__.py

@@ -0,0 +1 @@
+"""Module initialization for UX components."""

soothe_cli/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Module initialization for UX components."""

soothe_cli/cli/commands/autopilot_cmd.py

@@ -0,0 +1,410 @@
+"""Autopilot CLI subcommands for RFC-204.
+
+CLI is a control surface — no streaming output. Users submit tasks
+and check status; real-time monitoring is via TUI/daemon.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from soothe_sdk.protocol import preview_first
+
+app = typer.Typer(help="Autopilot mode — long-running autonomous agent control.")
+
+
+@app.command("run")
+def run(
+    prompt: str = typer.Argument(..., help="Task for autonomous execution."),
+    config: str | None = typer.Option(None, "--config", "-c", help="Path to configuration file."),
+    max_iterations: int | None = typer.Option(
+        None, "--max-iterations", help="Maximum autonomous iterations."
+    ),
+    output_format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or jsonl."
+    ),
+) -> None:
+    """Run autonomous agent loop for complex tasks.
+
+    Autopilot mode executes tasks autonomously without requiring user interaction.
+    The agent operates in headless mode (no TUI) and outputs progress to stdout.
+    """
+    from soothe_cli.cli.commands.run_cmd import run_impl
+
+    run_impl(
+        prompt=prompt,
+        config=config,
+        thread_id=None,
+        no_tui=True,
+        autonomous=True,
+        max_iterations=max_iterations,
+        output_format=output_format,
+        verbosity=None,
+    )
+
+
+@app.command("submit")
+def submit(
+    task: str = typer.Argument(..., help="Task description."),
+    priority: int = typer.Option(50, "--priority", "-p", help="Goal priority (0-100)."),
+) -> None:
+    """Submit a new task to autopilot.
+
+    Writes a markdown task file to the autopilot inbox.
+    """
+    from datetime import UTC, datetime
+
+    from soothe_sdk import SOOTHE_HOME
+
+    inbox_dir = SOOTHE_HOME / "autopilot" / "inbox"
+    inbox_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now(tz=UTC).strftime("%Y%m%dT%H%M%S")
+    filename = f"TASK-{timestamp}.md"
+    fpath = inbox_dir / filename
+
+    fpath.write_text(f"---\ntype: task_submit\npriority: {priority}\n---\n\n{task}\n")
+    typer.echo(f"Task submitted: {fpath}")
+    typer.echo(f"  Priority: {priority}")
+
+
+@app.command("status")
+def status() -> None:
+    """Show overall autopilot state."""
+    from soothe_sdk import SOOTHE_HOME
+
+    autopilot_dir = SOOTHE_HOME / "autopilot"
+    state_file = autopilot_dir / "status.json"
+
+    if not autopilot_dir.exists():
+        typer.echo("Autopilot not configured. Run 'soothe autopilot submit' to start.")
+        return
+
+    if state_file.exists():
+        import json
+
+        data = json.loads(state_file.read_text())
+        state = data.get("state", "unknown")
+        typer.echo(f"Autopilot state: {state}")
+
+        if "active_goals" in data:
+            typer.echo(f"Active goals: {len(data['active_goals'])}")
+    else:
+        typer.echo("Autopilot: idle (no status file)")
+
+    # Check inbox for pending tasks
+    inbox_dir = autopilot_dir / "inbox"
+    if inbox_dir.exists():
+        pending = list(inbox_dir.glob("*.md"))
+        if pending:
+            typer.echo(f"Pending inbox tasks: {len(pending)}")
+
+
+@app.command("list")
+def list_goals(
+    status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
+) -> None:
+    """List all goals."""
+    from soothe_sdk import SOOTHE_HOME
+
+    autopilot_dir = SOOTHE_HOME / "autopilot"
+    goals = _discover_goals(autopilot_dir)
+
+    if not goals:
+        typer.echo("No goals found.")
+        return
+
+    for g in goals:
+        if status_filter and g.get("status", "") != status_filter:
+            continue
+        sid = g.get("id", "?")[:8]
+        sdesc = preview_first(g.get("description", ""), 60)
+        sstat = g.get("status", "pending")
+        spri = g.get("priority", 50)
+        typer.echo(f"  [{sid}] {sstat:10s} pri={spri:3d}  {sdesc}")
+
+
+@app.command("goal")
+def show_goal(
+    goal_id: str = typer.Argument(..., help="Goal ID to show details for."),
+) -> None:
+    """Show details for a specific goal."""
+    from soothe_sdk import SOOTHE_HOME
+
+    autopilot_dir = SOOTHE_HOME / "autopilot"
+    goals = _discover_goals(autopilot_dir)
+
+    found = None
+    for g in goals:
+        if g.get("id", "").startswith(goal_id) or goal_id in g.get("id", ""):
+            found = g
+            break
+
+    if not found:
+        typer.echo(f"Goal '{goal_id}' not found.")
+        raise typer.Exit(1)
+
+    typer.echo(f"ID:          {found.get('id')}")
+    typer.echo(f"Description: {found.get('description')}")
+    typer.echo(f"Status:      {found.get('status', 'pending')}")
+    typer.echo(f"Priority:    {found.get('priority', 50)}")
+    if found.get("depends_on"):
+        typer.echo(f"Depends On:  {', '.join(found['depends_on'])}")
+    if found.get("source_file"):
+        typer.echo(f"Source File: {found['source_file']}")
+
+
+@app.command("cancel")
+def cancel_goal(
+    goal_id: str = typer.Argument(..., help="Goal ID to cancel."),
+) -> None:
+    """Cancel a goal (remove from inbox if pending)."""
+    from soothe_sdk import SOOTHE_HOME
+
+    inbox_dir = SOOTHE_HOME / "autopilot" / "inbox"
+    if not inbox_dir.exists():
+        typer.echo("No inbox to cancel from.")
+        return
+
+    # Remove matching inbox file
+    removed = 0
+    for f in inbox_dir.glob("*.md"):
+        if goal_id in f.stem:
+            f.unlink()
+            removed += 1
+            typer.echo(f"Removed: {f.name}")
+
+    if removed == 0:
+        typer.echo(f"No matching inbox tasks for '{goal_id}'.")
+    else:
+        typer.echo(f"Cancelled {removed} task(s).")
+
+
+@app.command("approve")
+def approve_goal(
+    goal_id: str = typer.Argument(
+        ..., help="Confirmation ID to approve (use 'inbox' to list pending)."
+    ),
+) -> None:
+    """Approve a MUST-confirmation goal."""
+    import json
+
+    from soothe_sdk import SOOTHE_HOME
+
+    confirmations_file = SOOTHE_HOME / "autopilot" / "pending_confirmations.json"
+    if not confirmations_file.exists():
+        typer.echo("No pending goal confirmations.")
+        return
+
+    try:
+        confirmations = json.loads(confirmations_file.read_text())
+    except (json.JSONDecodeError, OSError):
+        typer.echo("Failed to read pending confirmations.")
+        return
+
+    for i, c in enumerate(confirmations):
+        if c.get("id") == goal_id:
+            c["status"] = "approved"
+            confirmations[i] = c
+            confirmations_file.write_text(json.dumps(confirmations, indent=2))
+            typer.echo(
+                f"Confirmation {goal_id} approved. Goal will be created on next runner poll."
+            )
+            return
+
+    typer.echo(f"Confirmation {goal_id} not found. Run 'soothe autopilot inbox' to list pending.")
+
+
+@app.command("reject")
+def reject_goal(
+    goal_id: str = typer.Argument(..., help="Confirmation ID to reject."),
+) -> None:
+    """Reject a proposed goal."""
+    import json
+
+    from soothe_sdk import SOOTHE_HOME
+
+    confirmations_file = SOOTHE_HOME / "autopilot" / "pending_confirmations.json"
+    if not confirmations_file.exists():
+        typer.echo("No pending goal confirmations.")
+        return
+
+    try:
+        confirmations = json.loads(confirmations_file.read_text())
+    except (json.JSONDecodeError, OSError):
+        typer.echo("Failed to read pending confirmations.")
+        return
+
+    remaining = [c for c in confirmations if c.get("id") != goal_id]
+    if len(remaining) == len(confirmations):
+        typer.echo(f"Confirmation {goal_id} not found.")
+        return
+
+    confirmations_file.write_text(json.dumps(remaining, indent=2))
+    typer.echo(f"Confirmation {goal_id} rejected.")
+
+
+@app.command("wake")
+def wake() -> None:
+    """Exit dreaming mode — resume active execution."""
+    from soothe_sdk import SOOTHE_HOME
+
+    inbox_dir = SOOTHE_HOME / "autopilot" / "inbox"
+    inbox_dir.mkdir(parents=True, exist_ok=True)
+
+    signal = inbox_dir / "WAKE.md"
+    signal.write_text("---\ntype: signal_resume\n---\n\nWake signal.\n")
+    typer.echo("Wake signal sent. Autopilot will exit dreaming mode.")
+
+
+@app.command("dream")
+def dream() -> None:
+    """Force enter dreaming mode."""
+    from soothe_sdk import SOOTHE_HOME
+
+    inbox_dir = SOOTHE_HOME / "autopilot" / "inbox"
+    inbox_dir.mkdir(parents=True, exist_ok=True)
+
+    signal = inbox_dir / "DREAM.md"
+    signal.write_text("---\ntype: signal_interrupt\n---\n\nDream signal.\n")
+    typer.echo("Dream signal sent. Autopilot will enter dreaming mode.")
+
+
+@app.command("inbox")
+def view_inbox(
+    limit: int = typer.Option(10, "--limit", "-n", help="Max tasks to show."),
+) -> None:
+    """View pending inbox tasks."""
+    from soothe_sdk import SOOTHE_HOME
+
+    inbox_dir = SOOTHE_HOME / "autopilot" / "inbox"
+    if not inbox_dir.exists():
+        typer.echo("Inbox is empty.")
+        return
+
+    tasks = sorted(inbox_dir.glob("*.md"), key=lambda f: f.stat().st_mtime, reverse=True)
+    if not tasks:
+        typer.echo("Inbox is empty.")
+        return
+
+    typer.echo(f"Pending tasks ({len(tasks)}):")
+    for f in tasks[:limit]:
+        content = f.read_text()
+        # Extract description from body
+        desc = ""
+        for line in content.splitlines():
+            stripped = line.strip()
+            if stripped.startswith("# "):
+                desc = stripped[2:]
+                break
+            if stripped.startswith(("--", "type:", "priority:")):
+                continue
+            if stripped:
+                desc = preview_first(stripped, 80)
+                break
+        if not desc:
+            desc = "(no description)"
+        typer.echo(f"  {f.name:30s}  {desc}")
+
+    if len(tasks) > limit:
+        typer.echo(f"  ... and {len(tasks) - limit} more")
+
+
+def _discover_goals(autopilot_dir: Path) -> list[dict]:
+    """Parse goals from GOAL.md/GOALS.md files for CLI display.
+
+    This is a simple parser for CLI use — not the full engine.
+    """
+    import re
+
+    goals = []
+
+    # Check GOAL.md
+    goal_file = autopilot_dir / "GOAL.md"
+    if goal_file.exists():
+        g = _parse_single_goal(goal_file.read_text(), str(goal_file))
+        if g:
+            return [g]
+
+    # Check GOALS.md
+    goals_file = autopilot_dir / "GOALS.md"
+    if goals_file.exists():
+        text = goals_file.read_text()
+        for section in re.split(r"## Goal:", text)[1:]:
+            g = _parse_goals_section(section.strip(), str(goals_file))
+            if g:
+                goals.append(g)
+
+    # Check goals/ subdirectories
+    goals_dir = autopilot_dir / "goals"
+    if goals_dir.exists():
+        for subdir in sorted(goals_dir.iterdir()):
+            gfile = subdir / "GOAL.md"
+            if gfile.exists():
+                g = _parse_single_goal(gfile.read_text(), str(gfile))
+                if g:
+                    goals.append(g)
+
+    return goals
+
+
+def _parse_single_goal(text: str, source: str) -> dict | None:
+    """Parse a single GOAL.md file."""
+    if not text.startswith("---"):
+        return None
+
+    parts = text.split("---", 2)
+    if len(parts) < 3:  # noqa: PLR2004
+        return None
+
+    import yaml
+
+    fm = yaml.safe_load(parts[1]) or {}
+    body = parts[2].strip()
+
+    desc = ""
+    for line in body.splitlines():
+        s = line.strip()
+        if s.startswith("# "):
+            desc = s[2:]
+            break
+
+    return {
+        "id": fm.get("id", source.split("/")[-2]),
+        "description": desc or preview_first(body, 100),
+        "priority": int(fm.get("priority", 50)),
+        "status": fm.get("status", "pending"),
+        "depends_on": fm.get("depends_on", []),
+        "source_file": source,
+    }
+
+
+def _parse_goals_section(text: str, source: str) -> dict | None:
+    """Parse a single goal section from GOALS.md."""
+    lines = text.splitlines()
+    name = lines[0].strip() if lines else ""
+    metadata: dict = {}
+
+    for line in lines[1:]:
+        s = line.strip()
+        if s.startswith("- id:"):
+            metadata["id"] = s.split(":", 1)[1].strip()
+        elif s.startswith("- priority:"):
+            metadata["priority"] = int(s.split(":", 1)[1].strip())
+        elif s.startswith("- depends_on:"):
+            raw = s.split(":", 1)[1].strip()
+            if raw.startswith("[") and raw.endswith("]"):
+                inner = raw[1:-1].strip()
+                metadata["depends_on"] = (
+                    [x.strip() for x in inner.split(",") if x.strip()] if inner else []
+                )
+
+    return {
+        "id": metadata.get("id", name.lower().replace(" ", "-")),
+        "description": name,
+        "priority": metadata.get("priority", 50),
+        "status": "pending",
+        "depends_on": metadata.get("depends_on", []),
+        "source_file": source,
+    }

soothe_cli/cli/commands/config_cmd.py

@@ -0,0 +1,277 @@
+"""Config command for Soothe CLI."""
+
+import json
+import logging
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+from soothe_cli.shared import load_config
+
+logger = logging.getLogger(__name__)
+
+
+def config_show(
+    config: Annotated[
+        str | None,
+        typer.Option("--config", "-c", help="Path to configuration file."),
+    ] = None,
+    format_output: Annotated[
+        str,
+        typer.Option("--format", "-f", help="Output format: json or summary."),
+    ] = "summary",
+    show_sensitive: Annotated[  # noqa: ARG001, FBT002
+        bool,
+        typer.Option("--show-sensitive", "-s", help="Show sensitive values like API keys."),
+    ] = False,
+) -> None:
+    """Display current configuration.
+
+    Examples:
+        soothe config show
+        soothe config show --show-sensitive
+        soothe config show --format json
+    """
+    try:
+        cfg = load_config(config)
+
+        if format_output == "json":
+            # Output full config as JSON
+            config_dict = cfg.model_dump(mode="python", exclude_unset=True)
+            # Note: show_sensitive parameter reserved for future use
+            typer.echo(json.dumps(config_dict, indent=2, default=str))
+        else:
+            # Summary output
+            from rich.console import Console
+            from rich.panel import Panel
+            from rich.table import Table
+
+            # Providers summary
+            providers_table = Table(title="Model Providers")
+            providers_table.add_column("Name", style="cyan")
+            providers_table.add_column("Models", style="yellow")
+            providers_table.add_column("Default", justify="center")
+
+            for provider in cfg.providers:
+                model_count = len(provider.models)
+                providers_table.add_row(
+                    provider.name,
+                    f"{model_count} models",
+                    "✓" if cfg.router.default.startswith(f"{provider.name}:") else "",
+                )
+
+            if not cfg.providers:
+                providers_table.add_row("None configured", "", "")
+
+            # Subagents summary
+            from soothe_cli.cli.commands.subagent_names import (
+                BUILTIN_SUBAGENT_NAMES,
+                SUBAGENT_DISPLAY_NAMES,
+            )
+
+            subagents_table = Table(title="Agents")
+            subagents_table.add_column("Name", style="cyan")
+            subagents_table.add_column("Status", justify="center")
+
+            for subagent_id in BUILTIN_SUBAGENT_NAMES:
+                display_name = SUBAGENT_DISPLAY_NAMES.get(
+                    subagent_id, subagent_id.replace("_", " ").title()
+                )
+                enabled = True
+                if subagent_id in cfg.subagents:
+                    enabled = cfg.subagents[subagent_id].enabled
+                status = "[green]Enabled[/green]" if enabled else "[red]Disabled[/red]"
+                subagents_table.add_row(display_name, status)
+
+            # General info
+            general_table = Table(title="General Configuration")
+            general_table.add_column("Setting", style="cyan")
+            general_table.add_column("Value", style="yellow")
+            general_table.add_row(
+                "Debug Mode", "[green]Yes[/green]" if cfg.debug else "[red]No[/red]"
+            )
+            general_table.add_row("Context Backend", cfg.protocols.context.backend.title())
+            # MemU is the memory backend type (no separate backend attribute)
+            general_table.add_row(
+                "Memory Backend", "MemU" if cfg.protocols.memory.enabled else "Disabled"
+            )
+            general_table.add_row("Policy Profile", cfg.protocols.policy.profile)
+            general_table.add_row("Progress Verbosity", cfg.logging.verbosity)
+            # Show vector store providers count
+            vs_count = len(cfg.vector_stores)
+            general_table.add_row("Vector Store Providers", f"{vs_count} configured")
+
+            console = Console()
+            console.print(Panel(providers_table, border_style="blue"))
+            console.print(Panel(subagents_table, border_style="blue"))
+            console.print(Panel(general_table, border_style="blue"))
+
+    except KeyboardInterrupt:
+        typer.echo("\nInterrupted.")
+        sys.exit(0)
+    except Exception as e:
+        logger.exception("Config command error")
+        from soothe_sdk import format_cli_error
+
+        typer.echo(f"Error: {format_cli_error(e)}", err=True)
+        sys.exit(1)
+
+
+def config_init(
+    force: Annotated[  # noqa: FBT002
+        bool,
+        typer.Option(
+            "--force", "-f", help="Overwrite existing configuration without confirmation."
+        ),
+    ] = False,
+) -> None:
+    """Initialize ~/.soothe with a default configuration.
+
+    Examples:
+        soothe config init
+        soothe config init --force  # Overwrite existing without confirmation
+    """
+    import shutil
+    from importlib.resources import as_file, files
+    from pathlib import Path
+
+    from soothe_sdk import SOOTHE_HOME
+
+    home = Path(SOOTHE_HOME).expanduser()
+    target = home / "config" / "config.yml"
+
+    # Check if config file exists and ask for confirmation
+    if target.exists() and not force:
+        typer.echo(f"Config file already exists at: {target}")
+        overwrite = typer.confirm("Do you want to overwrite it?", default=False)
+        if not overwrite:
+            typer.echo("Cancelled.")
+            return
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    # Try loading from installed package resources first
+    template_found = False
+    try:
+        config_resource = files("soothe_sdk").joinpath("templates/config.yml")
+        with as_file(config_resource) as template_path:
+            if template_path.exists():
+                shutil.copy2(template_path, target)
+                typer.echo(f"Created {target}")
+                template_found = True
+    except (FileNotFoundError, TypeError, AttributeError, ModuleNotFoundError):
+        pass
+
+    # Fallback: try daemon package (co-installed on server)
+    if not template_found:
+        try:
+            config_resource = files("soothe.config").joinpath("config.yml")
+            with as_file(config_resource) as template_path:
+                if template_path.exists():
+                    shutil.copy2(template_path, target)
+                    typer.echo(f"Created {target}")
+                    template_found = True
+        except (FileNotFoundError, TypeError, AttributeError, ModuleNotFoundError):
+            pass
+
+    # Fallback for development/editable installs
+    if not template_found:
+        template = Path(__file__).resolve().parent.parent.parent.parent / "config" / "config.yml"
+        if template.exists():
+            shutil.copy2(template, target)
+            typer.echo(f"Created {target}")
+            template_found = True
+
+    # Create minimal config if template not found
+    if not template_found:
+        target.write_text("# Soothe configuration\n# See docs/user_guide.md for options\n")
+        typer.echo(f"Created minimal {target}")
+
+    for subdir in ("runs", "generated_agents", "logs"):
+        (home / subdir).mkdir(parents=True, exist_ok=True)
+
+    typer.echo(f"Soothe home initialized at {home}")
+
+
+def config_validate(
+    config: Annotated[
+        str | None,
+        typer.Option("--config", "-c", help="Path to configuration file."),
+    ] = None,
+) -> None:
+    """Validate configuration file and show basic info.
+
+    Examples:
+        soothe config validate
+        soothe config validate --config custom.yml
+    """
+    from pathlib import Path
+
+    from soothe_sdk import SOOTHE_HOME
+
+    try:
+        cfg = load_config(config)
+
+        # Determine config file path
+        if config:
+            config_path = Path(config).expanduser().resolve()
+        else:
+            config_path = Path(SOOTHE_HOME).expanduser() / "config" / "config.yml"
+
+        # Show basic information
+        typer.echo(f"\nConfig file: {config_path}")
+        typer.echo("Status: ✓ Valid\n")
+
+        # Show default model provider info
+        typer.echo("Default Model Configuration:")
+        default_model = cfg.router.default
+        provider_name, model_name = (
+            default_model.split(":", 1) if ":" in default_model else (default_model, "default")
+        )
+        typer.echo(f"  Provider: {provider_name}")
+        typer.echo(f"  Model: {model_name}")
+
+        # Show available providers
+        if cfg.providers:
+            typer.echo(f"\nConfigured Providers: {len(cfg.providers)}")
+            for provider in cfg.providers:
+                model_count = len(provider.models)
+                is_default = default_model.startswith(f"{provider.name}:")
+                default_marker = " (default)" if is_default else ""
+                typer.echo(f"  • {provider.name}: {model_count} models{default_marker}")
+        else:
+            typer.echo("\nNo custom providers configured (using defaults)")
+
+        # Show enabled subagents count
+        enabled_subagents = sum(1 for s in cfg.subagents.values() if s.enabled)
+        typer.echo(f"\nSubagents: {enabled_subagents} enabled")
+
+        # Show LangSmith tracing status
+        typer.echo("\nObservability:")
+        langsmith_tracing = os.getenv("LANGSMITH_TRACING", "").lower()
+        langchain_tracing = os.getenv("LANGCHAIN_TRACING_V2", "").lower()
+        langsmith_api_key = os.getenv("LANGSMITH_API_KEY")
+        langchain_api_key = os.getenv("LANGCHAIN_API_KEY")
+        langsmith_project = os.getenv("LANGSMITH_PROJECT")
+        langchain_project = os.getenv("LANGCHAIN_PROJECT")
+
+        tracing_enabled = langsmith_tracing == "true" or langchain_tracing == "true"
+        has_api_key = bool(langsmith_api_key or langchain_api_key)
+
+        if tracing_enabled and has_api_key:
+            project_name = langsmith_project or langchain_project or "default"
+            typer.echo(f"  LangSmith: ✓ Enabled (project: {project_name})")
+        elif tracing_enabled and not has_api_key:
+            typer.echo("  LangSmith: ⚠ Tracing enabled but API key missing", err=True)
+        elif has_api_key and not tracing_enabled:
+            typer.echo("  LangSmith: ○ API key found but tracing disabled")
+        else:
+            typer.echo("  LangSmith: ○ Not configured")
+
+        typer.echo()  # Blank line at end
+
+    except Exception as e:
+        typer.echo(f"\n✗ Configuration error: {e}", err=True)
+        sys.exit(1)