soothe-cli 0.6.12__tar.gz → 0.6.14__tar.gz

{soothe_cli-0.6.12 → soothe_cli-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.12
+Version: 0.6.14
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.6.12 → soothe_cli-0.6.14}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -1,6 +1,6 @@
 """Autopilot CLI subcommands for RFC-204.
 
-Daemon-backed control surface: submit tasks and manage goals via HTTP REST.
+Daemon-backed control surface: submit tasks and manage goals via WebSocket.
 Requires ``soothed start``. Real-time monitoring is via TUI ``/autopilot``.
 """
 
@@ -15,11 +15,9 @@ from pathlib import Path
 
 import typer
 from soothe_sdk.client import (
-    AutopilotHttpClient,
-    ensure_http_rest_available,
-    http_rest_url_from_config,
     is_daemon_live,
     websocket_url_from_config,
+    ws_command_client_from_config,
 )
 from soothe_sdk.client.protocol import preview_first
 
@@ -36,8 +34,8 @@ def _resolve_submit_workspace(explicit: str | None) -> str:
     return str(Path(raw).expanduser().resolve())
 
 
-def _require_daemon_http() -> AutopilotHttpClient:
-    """Return a live HTTP client or exit."""
+def _require_daemon_ws():
+    """Return a live WebSocket command client or exit."""
     from soothe_cli.runtime import load_config
 
     cfg = load_config()
@@ -48,13 +46,7 @@ def _require_daemon_http() -> AutopilotHttpClient:
             err=True,
         )
         sys.exit(1)
-    base_url = http_rest_url_from_config(cfg)
-    try:
-        ensure_http_rest_available(base_url)
-    except RuntimeError as exc:
-        typer.echo(f"Error: {exc}", err=True)
-        sys.exit(1)
-    return AutopilotHttpClient(base_url)
+    return ws_command_client_from_config(cfg)
 
 
 @app.command("run")
@@ -79,9 +71,9 @@ def run(
     path — distinct from a one-shot agentic query via ``soothe -p``.
     """
     del max_iterations  # daemon owns config for autopilot dispatch
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     submit_workspace = _resolve_submit_workspace(workspace)
-    result = client.submit(prompt, workspace=submit_workspace)
+    result = client.autopilot_submit(prompt, workspace=submit_workspace)
     goal_id = result.get("goal_id", "")
     typer.echo(f"Submitted goal: {goal_id}")
     if not wait or not goal_id:
@@ -89,7 +81,7 @@ def run(
 
     deadline = time.time() + 600
     while time.time() < deadline:
-        detail = client.get_goal(goal_id)
+        detail = client.autopilot_get_goal(goal_id)
         goal = detail.get("goal") or {}
         status = goal.get("status", "unknown")
         if status in ("completed", "failed", "cancelled", "suspended"):
@@ -114,9 +106,9 @@ def submit(
     ),
 ) -> None:
     """Submit a new task to the daemon autopilot."""
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     submit_workspace = _resolve_submit_workspace(workspace)
-    result = client.submit(task, priority=priority, workspace=submit_workspace)
+    result = client.autopilot_submit(task, priority=priority, workspace=submit_workspace)
     goal_id = result.get("goal_id", "?")
     typer.echo(f"Task submitted (goal_id={goal_id})")
     typer.echo(f"  Priority: {priority}")
@@ -126,8 +118,8 @@ def submit(
 @app.command("status")
 def status() -> None:
     """Show overall autopilot state and goal DAG summary."""
-    client = _require_daemon_http()
-    data = client.status()
+    client = _require_daemon_ws()
+    data = client.autopilot_status()
     state = data.get("state", data.get("status", "unknown"))
     running = data.get("running", False)
     dreaming = data.get("dreaming", False)
@@ -139,8 +131,8 @@ def status() -> None:
     if isinstance(loop_pool, dict) and loop_pool:
         typer.echo(f"Worker pool: {loop_pool}")
 
-    jobs = client.list_jobs().get("jobs") or []
-    goals = client.list_goals().get("goals") or []
+    jobs = client.autopilot_list_jobs().get("jobs") or []
+    goals = client.autopilot_list_goals().get("goals") or []
     typer.echo(f"\nJobs (root goals): {len(jobs)}")
     if goals:
         counts = Counter(str(g.get("status", "pending")) for g in goals)
@@ -182,8 +174,8 @@ def list_jobs_alias(
 
 
 def _list_jobs_impl(status_filter: str) -> None:
-    client = _require_daemon_http()
-    payload = client.list_jobs()
+    client = _require_daemon_ws()
+    payload = client.autopilot_list_jobs()
     jobs = payload.get("jobs") or []
     if not jobs:
         typer.echo("No jobs found.")
@@ -204,8 +196,8 @@ def list_goals(
     status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
 ) -> None:
     """List all goals in the daemon autopilot DAG (including subgoals)."""
-    client = _require_daemon_http()
-    payload = client.list_goals()
+    client = _require_daemon_ws()
+    payload = client.autopilot_list_goals()
     goals = payload.get("goals") or []
     if not goals:
         typer.echo("No goals found.")
@@ -270,9 +262,9 @@ def show_job(
     A job is a root goal submitted by the user. This command shows
     the job's details and the complete goal DAG under it.
     """
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        payload = client.get_job(job_id)
+        payload = client.autopilot_get_job(job_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -314,8 +306,8 @@ def show_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to show details for."),
 ) -> None:
     """Show details for a specific goal."""
-    client = _require_daemon_http()
-    payload = client.get_goal(goal_id)
+    client = _require_daemon_ws()
+    payload = client.autopilot_get_goal(goal_id)
     found = payload.get("goal")
     if not found:
         typer.echo(f"Goal '{goal_id}' not found.")
@@ -336,8 +328,8 @@ def cancel_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to cancel."),
 ) -> None:
     """Cancel a goal via the daemon."""
-    client = _require_daemon_http()
-    result = client.cancel_goal(goal_id)
+    client = _require_daemon_ws()
+    result = client.autopilot_cancel_goal(goal_id)
     typer.echo(f"Cancel result: {result.get('status', result)}")
 
 
@@ -348,9 +340,9 @@ def approve_goal(
     ),
 ) -> None:
     """Approve a MUST-confirmation goal."""
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        result = client.approve(goal_id)
+        result = client.autopilot_approve(goal_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -362,9 +354,9 @@ def reject_goal(
     goal_id: str = typer.Argument(..., help="Confirmation ID to reject."),
 ) -> None:
     """Reject a proposed goal."""
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        result = client.reject(goal_id)
+        result = client.autopilot_reject(goal_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -380,9 +372,9 @@ def resume_goal(
     Reactivates a paused goal back to pending status so the scheduler
     can pick it up for execution. Use 'jobs' to list goals and their status.
     """
-    client = _require_daemon_http()
+    client = _require_daemon_ws()
     try:
-        result = client.resume(goal_id)
+        result = client.autopilot_resume(goal_id)
     except RuntimeError as exc:
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
@@ -394,16 +386,16 @@ def resume_goal(
 @app.command("wake")
 def wake() -> None:
     """Exit dreaming mode — resume active execution."""
-    client = _require_daemon_http()
-    client.wake()
+    client = _require_daemon_ws()
+    client.autopilot_wake()
     typer.echo("Wake signal sent.")
 
 
 @app.command("dream")
 def dream() -> None:
     """Force enter dreaming mode."""
-    client = _require_daemon_http()
-    client.dream()
+    client = _require_daemon_ws()
+    client.autopilot_dream()
     typer.echo("Dream signal sent.")
 
 

{soothe_cli-0.6.12 → soothe_cli-0.6.14}/src/soothe_cli/cli/commands/cron_cmd.py

@@ -1,9 +1,10 @@
 """Cron CLI subcommands for RFC-229.
 
-Daemon-backed control surface: manage scheduled jobs via HTTP REST.
+Daemon-backed control surface: manage scheduled jobs via WebSocket.
 Requires ``soothed start``.
 
 Commands:
+    soothe cron add <text>        # Add scheduled job (natural language)
     soothe cron list              # List scheduled jobs
     soothe cron show <job_id>     # Show job details
     soothe cron cancel <job_id>   # Cancel a job
@@ -23,6 +24,7 @@ from rich.table import Table
 from soothe_sdk.client import (
     is_daemon_live,
     websocket_url_from_config,
+    ws_command_client_from_config,
 )
 
 from soothe_cli.runtime import load_config
@@ -32,8 +34,8 @@ console = Console()
 app = typer.Typer(help="Manage scheduled cron jobs — natural language scheduled tasks.")
 
 
-def _require_daemon_http() -> tuple[str, str]:
-    """Return WebSocket URL and HTTP base URL, or exit if daemon not running."""
+def _require_cron_client():
+    """Return a live WebSocket command client or exit."""
     cfg = load_config()
     ws_url = websocket_url_from_config(cfg)
     if not asyncio.run(is_daemon_live(ws_url, timeout=5.0)):
@@ -42,50 +44,68 @@ def _require_daemon_http() -> tuple[str, str]:
             err=True,
         )
         sys.exit(1)
+    return ws_command_client_from_config(cfg)
 
-    # Derive HTTP URL from WebSocket URL
-    if ws_url.startswith("wss://"):
-        http_url = "https://" + ws_url[len("wss://") :]
-    elif ws_url.startswith("ws://"):
-        http_url = "http://" + ws_url[len("ws://") :]
-    else:
-        http_url = ws_url
-
-    return ws_url, http_url
-
-
-def _http_request(
-    base_url: str,
-    method: str,
-    path: str,
-    body: dict | None = None,
-    timeout: float = 30.0,
-) -> dict:
-    """Make HTTP request to daemon REST API."""
-    import json
-    import urllib.error
-    import urllib.request
-
-    url = f"{base_url.rstrip('/')}{path}"
-    data = None
-    headers = {"Accept": "application/json"}
-    if body is not None:
-        data = json.dumps(body).encode("utf-8")
-        headers["Content-Type"] = "application/json"
-
-    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+
+def _format_next_run(next_run: str) -> str:
+    if not next_run:
+        return "-"
     try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8")
-            return json.loads(raw) if raw else {}
-    except urllib.error.HTTPError as exc:
-        detail = exc.read().decode("utf-8", errors="replace")
-        typer.echo(f"Error: HTTP {exc.code} - {detail}", err=True)
-        sys.exit(1)
-    except urllib.error.URLError as exc:
-        typer.echo(f"Error: Cannot reach daemon - {exc.reason}", err=True)
+        dt = datetime.fromisoformat(next_run.replace("Z", "+00:00"))
+        now = datetime.now(dt.tzinfo)
+        delta = dt - now
+        if delta.total_seconds() < 0:
+            return "due now"
+        if delta.total_seconds() < 3600:
+            return f"in {int(delta.total_seconds() / 60)}m"
+        if delta.total_seconds() < 86400:
+            return f"in {int(delta.total_seconds() / 3600)}h"
+        return f"in {int(delta.total_seconds() / 86400)}d"
+    except ValueError:
+        return next_run[:19]
+
+
+@app.command("add")
+def add_job(
+    text: Annotated[str, typer.Argument(help="Natural language schedule and task.")],
+    priority: Annotated[
+        int | None,
+        typer.Option("--priority", "-p", help="Job priority (0-100)."),
+    ] = None,
+) -> None:
+    """Add a scheduled cron job via natural language.
+
+    The daemon extracts schedule semantics via LLM and persists the job.
+
+    Example:
+        soothe cron add "in 1 hour remind me to check the deploy"
+        soothe cron add "every weekday at 9am send status report" --priority 70
+    """
+    client = _require_cron_client()
+    try:
+        result = client.cron_add(text, priority=priority)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
         sys.exit(1)
 
+    job = result.get("job") or {}
+    job_id = job.get("id", "?")
+    console.print(
+        Panel(
+            "\n".join(
+                [
+                    f"[bold]ID:[/bold] {job_id}",
+                    f"[bold]Description:[/bold] {job.get('description', '-')}",
+                    f"[bold]Schedule:[/bold] {job.get('schedule_kind', '?')} = {job.get('schedule_value', '?')}",
+                    f"[bold]Next Run:[/bold] [yellow]{str(job.get('next_run', ''))[:19]}[/yellow]",
+                    f"[bold]Status:[/bold] [green]{job.get('status', 'pending')}[/green]",
+                ]
+            ),
+            title="Scheduled Job Created",
+            border_style="green",
+        )
+    )
+
 
 @app.command("list")
 def list_jobs(
@@ -106,18 +126,14 @@ def list_jobs(
         soothe cron list
         soothe cron list --status pending
     """
-    ws_url, http_url = _require_daemon_http()
-
-    params = {}
-    if status:
-        params["status"] = status
-
-    query = "&".join(f"{k}={v}" for k, v in params.items())
-    path = f"/api/v1/cron/jobs?{query}" if query else "/api/v1/cron/jobs"
+    client = _require_cron_client()
+    try:
+        result = client.cron_list_jobs(status=status)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
 
-    result = _http_request(http_url, "GET", path)
     jobs = result.get("jobs", [])
-
     if not jobs:
         console.print("[info]No scheduled jobs found.[/info]")
         return
@@ -133,35 +149,11 @@ def list_jobs(
         desc = job.get("description", "")
         if len(desc) > 40:
             desc = desc[:37] + "..."
-
-        next_run = job.get("next_run", "")
-        if next_run:
-            # Parse ISO datetime and format relative
-            try:
-                dt = datetime.fromisoformat(next_run.replace("Z", "+00:00"))
-                now = datetime.now(dt.tzinfo)
-                delta = dt - now
-                if delta.total_seconds() < 0:
-                    next_run_str = "due now"
-                elif delta.total_seconds() < 3600:
-                    mins = int(delta.total_seconds() / 60)
-                    next_run_str = f"in {mins}m"
-                elif delta.total_seconds() < 86400:
-                    hrs = int(delta.total_seconds() / 3600)
-                    next_run_str = f"in {hrs}h"
-                else:
-                    days = int(delta.total_seconds() / 86400)
-                    next_run_str = f"in {days}d"
-            except ValueError:
-                next_run_str = next_run[:19]
-        else:
-            next_run_str = "-"
-
         table.add_row(
             job.get("id", "?")[:12],
             desc,
             job.get("status", "pending"),
-            next_run_str,
+            _format_next_run(job.get("next_run", "")),
             str(job.get("run_count", 0)),
         )
 
@@ -180,42 +172,34 @@ def show_job(
     Example:
         soothe cron show abc123def456
     """
-    ws_url, http_url = _require_daemon_http()
+    client = _require_cron_client()
+    try:
+        result = client.cron_show(job_id)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
 
-    result = _http_request(http_url, "GET", f"/api/v1/cron/jobs/{job_id}")
     job = result.get("job")
-
     if not job:
         typer.echo(f"Error: Job '{job_id}' not found.", err=True)
         sys.exit(1)
 
-    # Build details panel
-    details = []
-    details.append(f"[bold]ID:[/bold] {job.get('id', '?')}")
-    details.append(f"[bold]Description:[/bold] {job.get('description', '-')}")
-    details.append(f"[bold]Status:[/bold] [green]{job.get('status', 'pending')}[/green]")
-    details.append(f"[bold]Priority:[/bold] {job.get('priority', 50)}")
-
-    # Schedule info
-    schedule_kind = job.get("schedule_kind", "once")
-    schedule_value = job.get("schedule_value", "")
-    details.append(f"[bold]Schedule:[/bold] {schedule_kind} = {schedule_value}")
-
+    details = [
+        f"[bold]ID:[/bold] {job.get('id', '?')}",
+        f"[bold]Description:[/bold] {job.get('description', '-')}",
+        f"[bold]Status:[/bold] [green]{job.get('status', 'pending')}[/green]",
+        f"[bold]Priority:[/bold] {job.get('priority', 50)}",
+        f"[bold]Schedule:[/bold] {job.get('schedule_kind', 'once')} = {job.get('schedule_value', '')}",
+    ]
     if job.get("end_condition"):
         details.append(f"[bold]End Condition:[/bold] {job['end_condition']}")
-
-    # Timestamps
     next_run = job.get("next_run", "")
     if next_run:
         details.append(f"[bold]Next Run:[/bold] [yellow]{next_run[:19]}[/yellow]")
-
     last_run = job.get("last_run")
     if last_run:
         details.append(f"[bold]Last Run:[/bold] {last_run[:19]}")
-
     details.append(f"[bold]Run Count:[/bold] {job.get('run_count', 0)}")
-
-    # Created/Updated
     created = job.get("created_at", "")
     if created:
         details.append(f"[bold]Created:[/bold] [dim]{created[:19]}[/dim]")
@@ -234,9 +218,12 @@ def cancel_job(
     Example:
         soothe cron cancel abc123def456
     """
-    ws_url, http_url = _require_daemon_http()
-
-    result = _http_request(http_url, "DELETE", f"/api/v1/cron/jobs/{job_id}")
+    client = _require_cron_client()
+    try:
+        result = client.cron_cancel(job_id)
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
 
     if result.get("cancelled"):
         console.print(f"[success]Cancelled job: {job_id[:12]}[/success]")
@@ -247,6 +234,7 @@ def cancel_job(
 
 __all__ = [
     "app",
+    "add_job",
     "list_jobs",
     "show_job",
     "cancel_job",

{soothe_cli-0.6.12 → soothe_cli-0.6.14}/src/soothe_cli/cli/execution/daemon.py

@@ -15,6 +15,7 @@ from typing import Any
 import typer
 from soothe_sdk.client import (
     WebSocketClient,
+    async_ws_command_client_from_config,
     bootstrap_loop_session,
     connect_websocket_with_retries,
     websocket_url_from_config,
@@ -59,6 +60,22 @@ async def _send_cancel_to_daemon(client: WebSocketClient) -> None:
         logger.warning("Failed to send /cancel to daemon", exc_info=True)
 
 
+def _parse_cron_slash_prompt(prompt: str) -> str | None:
+    """Return natural-language cron text if ``prompt`` is a ``/cron`` slash command.
+
+    Args:
+        prompt: User input (e.g. ``/cron in 1 hour remind me to deploy``).
+
+    Returns:
+        Text after ``/cron``, or ``None`` if not a cron slash command.
+    """
+    stripped = prompt.strip()
+    if not stripped.lower().startswith("/cron"):
+        return None
+    rest = stripped[len("/cron") :].strip()
+    return rest
+
+
 async def _run_headless_session_once(
     cfg: Any,
     prompt: str,
@@ -79,6 +96,24 @@ async def _run_headless_session_once(
     sigint_count = 0
     original_sigint: Any = None
 
+    cron_text = _parse_cron_slash_prompt(prompt)
+    if cron_text is not None:
+        if not cron_text.strip():
+            _emit_headless_error("Usage: /cron <natural language schedule>")
+            return 1, False
+        try:
+            ws_client = async_ws_command_client_from_config(cfg)
+            result = await ws_client.cron_add(cron_text)
+        except RuntimeError as exc:
+            _emit_headless_error(str(exc))
+            return 1, False
+        job = result.get("job") or {}
+        job_id = job.get("id", "?")
+        typer.echo(f"Scheduled cron job: {job_id}")
+        typer.echo(f"  Description: {job.get('description', cron_text)}")
+        typer.echo(f"  Next run: {str(job.get('next_run', ''))[:19]}")
+        return 0, False
+
     try:
         await connect_websocket_with_retries(client)
         cli_ws = os.environ.get("SOOTHE_CLI_WORKSPACE", "").strip() or os.getcwd()

{soothe_cli-0.6.12 → soothe_cli-0.6.14}/src/soothe_cli/tui/app/_execution.py

@@ -493,7 +493,8 @@ class _ExecutionMixin:
         elif cmd == "/help":
             await self._mount_message(UserMessage(command))
             help_body = (
-                "Commands: /quit, /clear, /editor, /autopilot <task>, /autopilot-dashboard, /mcp, "
+                "Commands: /quit, /clear, /editor, /autopilot <task>, /cron <schedule>, "
+                "/autopilot-dashboard, /mcp, "
                 "/model [--model-params JSON] [--default], /notifications, "
                 "/reload, /skill:<name>, /theme, "
                 "/tokens, /resume, "
@@ -649,6 +650,18 @@ class _ExecutionMixin:
                 )
                 return
             await self._submit_autopilot_job(args)
+        elif cmd == "/cron" or cmd.startswith("/cron "):
+            args = command.strip()[len("/cron") :].strip()
+            if not args:
+                await self._mount_message(UserMessage(command))
+                await self._mount_message(
+                    AppMessage(
+                        "Usage: /cron <natural language schedule>\n"
+                        "Example: /cron in 1 hour remind me to check the deploy"
+                    )
+                )
+                return
+            await self._submit_cron_job(args, slash_input=command)
         elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
         elif cmd == "/autopilot-toggle":