soothe-cli 0.5.29__tar.gz → 0.5.30__tar.gz

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/.gitignore

@@ -218,3 +218,4 @@ __MACOSX
 .qoder
 .soothe
 deploy/config.yml
+.backups/

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.29
+Version: 0.5.30
 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.5.29 → soothe_cli-0.5.30}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -133,27 +133,121 @@ def status() -> None:
 
 
 @app.command("list")
-def list_goals(
+def list_jobs(
     status_filter: str = typer.Option("", "--status", "-s", help="Filter by status."),
 ) -> None:
-    """List goals from the live daemon autopilot DAG."""
+    """List jobs (root goals) from the daemon autopilot.
+
+    Jobs are user-submitted tasks. Subgoals created during autonomous
+    execution are not shown here; use 'goal <id>' to inspect subgoals.
+    """
     client = _require_daemon_http()
-    payload = client.list_goals()
-    goals = payload.get("goals") or []
-    if not goals:
-        typer.echo("No goals found.")
+    payload = client.list_jobs()
+    jobs = payload.get("jobs") or []
+    if not jobs:
+        typer.echo("No jobs found.")
         return
 
-    for g in goals:
-        if status_filter and g.get("status", "") != status_filter:
+    for j in jobs:
+        if status_filter and j.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)
+        sid = j.get("id", "?")[:8]
+        sdesc = preview_first(j.get("description", ""), 60)
+        sstat = j.get("status", "pending")
+        spri = j.get("priority", 50)
         typer.echo(f"  [{sid}] {sstat:10s} pri={spri:3d}  {sdesc}")
 
 
+def _render_dag_tree(dag: dict, root_id: str) -> None:
+    """Render DAG as ASCII tree for job visualization."""
+    nodes = {n["id"]: n for n in dag.get("nodes", [])}
+    edges = dag.get("edges", [])
+
+    # Build children map from edges
+    children: dict[str, list[str]] = {}
+    for edge in edges:
+        src = edge.get("source")
+        tgt = edge.get("target")
+        if src and tgt:
+            if src not in children:
+                children[src] = []
+            children[src].append(tgt)
+
+    def render_node(goal_id: str, indent: str = "", is_last: bool = True) -> None:
+        node = nodes.get(goal_id)
+        if not node:
+            return
+
+        # Prefix for this level
+        if indent:
+            prefix = indent + ("└─ " if is_last else "├─ ")
+        else:
+            prefix = ""
+
+        status = node.get("status", "pending")
+        desc = preview_first(node.get("description", ""), 50)
+        typer.echo(f'{prefix}{goal_id[:8]} ({status}) "{desc}"')
+
+        # Render children
+        child_ids = children.get(goal_id, [])
+        for i, child_id in enumerate(child_ids):
+            child_indent = indent + ("    " if is_last else "│   ")
+            render_node(child_id, child_indent, i == len(child_ids) - 1)
+
+    render_node(root_id)
+
+
+@app.command("job")
+def show_job(
+    job_id: str = typer.Argument(..., help="Job ID to show details and DAG."),
+) -> None:
+    """Show job status and DAG tree visualization.
+
+    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()
+    try:
+        payload = client.get_job(job_id)
+    except RuntimeError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1)
+
+    job = payload.get("job")
+    dag = payload.get("dag")
+
+    if not job:
+        typer.echo(f"Job '{job_id}' not found.", err=True)
+        raise typer.Exit(1)
+
+    # Job header
+    typer.echo(f"Job ID:          {job.get('id')}")
+    typer.echo(f"Status:          {job.get('status', 'pending')}")
+    typer.echo(f"Priority:        {job.get('priority', 50)}")
+    if job.get("workspace"):
+        typer.echo(f"Workspace:       {job['workspace']}")
+    created = job.get("created_at", "")
+    if created:
+        # Truncate timestamp for readability
+        created_short = created[:19] if len(created) > 19 else created
+        typer.echo(f"Created:         {created_short}")
+
+    # DAG stats from response
+    active = payload.get("active_goals", 0)
+    completed = payload.get("completed_goals", 0)
+    total = payload.get("total_goals", 0)
+    typer.echo(f"Active goals:    {active}")
+    typer.echo(f"Completed goals: {completed}")
+    typer.echo(f"Total goals:     {total}")
+
+    # DAG tree
+    typer.echo("\nDAG:")
+    if dag:
+        _render_dag_tree(dag, job_id)
+    else:
+        typer.echo("  (no subgoals)")
+
+
 @app.command("goal")
 def show_goal(
     goal_id: str = typer.Argument(..., help="Goal ID to show details for."),
@@ -216,6 +310,26 @@ def reject_goal(
     typer.echo(f"Confirmation rejected: {result.get('goal_id', goal_id)}")
 
 
+@app.command("resume")
+def resume_goal(
+    goal_id: str = typer.Argument(..., help="Goal ID to resume."),
+) -> None:
+    """Resume a suspended or blocked 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()
+    try:
+        result = client.resume(goal_id)
+    except RuntimeError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(
+        f"Goal resumed: {result.get('goal_id', goal_id)} → {result.get('new_status', 'pending')}"
+    )
+
+
 @app.command("wake")
 def wake() -> None:
     """Exit dreaming mode — resume active execution."""

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/runtime/transport/session.py

@@ -32,7 +32,13 @@ _POST_IDLE_DRAIN_DEADLINE_S = 2.5
 class TuiDaemonSession:
     """Own the daemon websocket session used by the TUI."""
 
-    def __init__(self, cfg: Any, *, workspace: str | None = None) -> None:
+    def __init__(
+        self,
+        cfg: Any,
+        *,
+        workspace: str | None = None,
+        post_idle_drain_deadline: float = _POST_IDLE_DRAIN_DEADLINE_S,
+    ) -> None:
         self._cfg = cfg
         self._workspace = workspace
         ws_url = websocket_url_from_config(cfg)
@@ -43,6 +49,7 @@ class TuiDaemonSession:
         self._rpc_lock = asyncio.Lock()
         self._rpc_connected = False
         self._streaming = False
+        self._post_idle_drain_deadline = post_idle_drain_deadline
         self.turn_event_stats = TurnEventStats()
 
     @property
@@ -178,7 +185,9 @@ class TuiDaemonSession:
     ) -> Any:
         """Yield stream chunks that arrive just after ``idle`` (headless client parity)."""
         loop = asyncio.get_running_loop()
-        deadline = loop.time() + _POST_IDLE_DRAIN_DEADLINE_S
+        deadline = loop.time() + getattr(
+            self, "_post_idle_drain_deadline", _POST_IDLE_DRAIN_DEADLINE_S
+        )
         exp = expected_loop_id
         while loop.time() < deadline:
             try:

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/tui/app/_execution.py

@@ -340,10 +340,13 @@ class _ExecutionMixin:
         self._shell_process = None
         self._shell_running = False
         self._shell_worker = None
-        if was_interrupted:
-            await self._mount_message(AppMessage("Command interrupted"))
+
+        # Restore input focus first so the user can type immediately.
         if self._chat_input:
             self._chat_input.set_cursor_active(active=True)
+
+        if was_interrupted:
+            await self._mount_message(AppMessage("Command interrupted"))
         try:
             await self._maybe_drain_deferred()
         except Exception:
@@ -490,7 +493,7 @@ class _ExecutionMixin:
         elif cmd == "/help":
             await self._mount_message(UserMessage(command))
             help_body = (
-                "Commands: /quit, /clear, /editor, /autopilot, /mcp, "
+                "Commands: /quit, /clear, /editor, /autopilot <task>, /autopilot-dashboard, /mcp, "
                 "/model [--model-params JSON] [--default], /notifications, "
                 "/reload, /skill:<name>, /theme, "
                 "/tokens, /resume, "
@@ -633,7 +636,19 @@ class _ExecutionMixin:
             args = command.strip()[len("/skill-creator") :].strip()
             rewritten = f"/skill:skill-creator {args}" if args else "/skill:skill-creator"
             await self._handle_skill_command(rewritten)
-        elif cmd == "/autopilot":
+        elif cmd == "/autopilot" or cmd.startswith("/autopilot "):
+            # Submit autopilot job via HTTP REST (like CLI `soothe autopilot run`)
+            args = command.strip()[len("/autopilot") :].strip()
+            if not args:
+                await self._mount_message(UserMessage(command))
+                await self._mount_message(
+                    AppMessage(
+                        "Usage: /autopilot <task description>\nExample: /autopilot refactor the auth module"
+                    )
+                )
+                return
+            await self._submit_autopilot_job(args)
+        elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
         elif cmd == "/mcp":
             await self._show_mcp_viewer()
@@ -961,12 +976,14 @@ class _ExecutionMixin:
         self._agent_running = False
         self._agent_worker = None
 
-        # Remove spinner if present
-        await self._set_spinner(None)
-
+        # Restore input focus FIRST so the user can start typing immediately
+        # while remaining cleanup (spinner, tokens, deferred) runs.
         if self._chat_input:
             self._chat_input.set_cursor_active(active=True)
 
+        # Remove spinner if present
+        await self._set_spinner(None)
+
         # Ensure token display is restored (in case of early cancellation).
         # Pass the cached approximate flag so an interrupted "+" isn't clobbered.
         self._show_tokens(approximate=self._tokens_approximate)

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/tui/app/_model.py

@@ -278,6 +278,57 @@ class _ModelMixin:
 
         self.push_screen(screen, handle_result)
 
+    async def _submit_autopilot_job(self, task: str) -> None:
+        """Submit an autopilot job via HTTP REST (like CLI `soothe autopilot run`).
+
+        Args:
+            task: Task description for autonomous execution.
+        """
+        import os
+
+        from soothe_sdk.client import (
+            AutopilotHttpClient,
+            http_rest_url_from_config,
+            is_daemon_live,
+            websocket_url_from_config,
+        )
+
+        from soothe_cli.runtime import load_config
+        from soothe_cli.tui.widgets.messages import ErrorMessage, UserMessage
+
+        await self._mount_message(UserMessage(f"/autopilot {task}"))
+
+        cfg = load_config()
+        ws_url = websocket_url_from_config(cfg)
+
+        # Check daemon is running
+        if not await is_daemon_live(ws_url, timeout=5.0):
+            await self._mount_message(
+                ErrorMessage("Daemon not running. Start with 'soothed start'.")
+            )
+            return
+
+        base_url = http_rest_url_from_config(cfg)
+        workspace = self._cwd if hasattr(self, "_cwd") else os.getcwd()
+
+        try:
+            client = AutopilotHttpClient(base_url)
+            result = client.submit(task, workspace=workspace)
+        except RuntimeError as exc:
+            await self._mount_message(ErrorMessage(str(exc)))
+            return
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("Autopilot submit failed")
+            await self._mount_message(ErrorMessage(f"Failed to submit autopilot job: {exc}"))
+            return
+
+        goal_id = result.get("goal_id", "")
+        if goal_id:
+            self.notify(f"Autopilot job submitted: {goal_id[:8]}", timeout=5)
+            logger.info("Submitted autopilot job %s: %s", goal_id, task[:50])
+        else:
+            await self._mount_message(ErrorMessage("No goal_id returned from daemon"))
+
     async def _show_loop_selector(self) -> None:
         """Show interactive loop selector as a modal screen."""
         from functools import partial

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/tui/app/_startup.py

@@ -452,7 +452,11 @@ class _StartupMixin:
                     f"Please start the daemon with: soothed start"
                 )
 
-            session = TuiDaemonSession(self._daemon_config, workspace=self._cwd)
+            session = TuiDaemonSession(
+                self._daemon_config,
+                workspace=self._cwd,
+                post_idle_drain_deadline=0.3,
+            )
             status_event = await session.connect(resume_loop_id=self._lc_loop_id)
         except Exception as exc:
             self.post_message(self.ServerStartFailed(error=exc))

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/tui/command_registry.py

@@ -57,9 +57,15 @@ class SlashCommand:
 COMMANDS: tuple[SlashCommand, ...] = (
     SlashCommand(
         name="/autopilot",
+        description="Submit autopilot job (usage: /autopilot <task>)",
+        bypass_tier=BypassTier.QUEUED,
+        hidden_keywords="goals autonomous job submit",
+    ),
+    SlashCommand(
+        name="/autopilot-dashboard",
         description="Open autopilot dashboard",
         bypass_tier=BypassTier.IMMEDIATE_UI,
-        hidden_keywords="goals autonomous",
+        hidden_keywords="goals status workers",
     ),
     SlashCommand(
         name="/clear",

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/tui/commands/slash_commands.py

@@ -259,6 +259,12 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "params_schema": {"loop_id": {"type": "string", "required": True}},
     },
     "/autopilot": {
+        "location": "daemon",
+        "type": "routing",
+        "description": "Submit autopilot job (usage: /autopilot <task>)",
+        "requires_query": True,
+    },
+    "/autopilot-dashboard": {
         "location": "daemon",
         "type": "rpc",
         "daemon_command": "autopilot_dashboard",

{soothe_cli-0.5.29 → soothe_cli-0.5.30}/src/soothe_cli/tui/widgets/chat_input.py

@@ -841,6 +841,13 @@ class ChatInput(Vertical):
     - Autocomplete for @ (files) and / (commands)
     """
 
+    _PATH_INDICATOR_CHARS: ClassVar[frozenset[str]] = frozenset("/\\~")
+    """Characters that indicate text might be a file path.
+
+    Used by `_is_dropped_path_payload` as a fast-path guard to skip
+    filesystem I/O when text cannot possibly be a path.
+    """
+
     DEFAULT_CSS = """
     ChatInput {
         height: auto;
@@ -1038,7 +1045,7 @@ class ChatInput(Vertical):
                 "Cannot update slash commands: controller not initialized (widget not yet mounted)"
             )
 
-    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+    async def on_text_area_changed(self, event: TextArea.Changed) -> None:
         """Detect input mode and update completions."""
         text = event.text_area.text
         self._sync_media_tracker_to_text(text)
@@ -1076,6 +1083,11 @@ class ChatInput(Vertical):
         # or prefix stripping, which never need path detection.
         is_path_payload = self._is_dropped_path_payload(text)
 
+        # Yield to the event loop so pending key events are not starved
+        # when the path check above did filesystem I/O.
+        if is_path_payload:
+            await asyncio.sleep(0)
+
         # Guard: skip mode re-detection after we programmatically stripped
         # a prefix character.
         if self._stripping_prefix:
@@ -1193,13 +1205,28 @@ class ChatInput(Vertical):
         """Return whether text is a dropped-path payload for existing files."""
         if len(text) < 2:  # noqa: PLR2004  # Need at least '/' + one char
             return False
+        # Short texts without path-like prefixes are never valid payloads.
+        # Avoids stat(2) calls for slash-command fragments like "/h" or "/he".
+        if len(text) < 3 and not text.startswith(("'", '"', "~/")):  # noqa: PLR2004
+            return False
         from soothe_cli.tui.input import parse_pasted_path_payload
 
         return parse_pasted_path_payload(text, allow_leading_path=True) is not None
 
     def _is_dropped_path_payload(self, text: str) -> bool:
         """Return whether current text looks like a dropped file-path payload."""
-        if not text:
+        if not text or len(text) < 2:
+            return False
+        # Fast path: skip filesystem I/O when text has no path indicators.
+        # Dropped paths always contain at least one of: / (POSIX), \ (Windows),
+        # ~ (home), or a quote prefix ('/path' or "/path").  Plain prose and
+        # slash-command text (e.g. "/help") without path separators never
+        # triggers dropped-path parsing.
+        if (
+            not text.startswith(("'", '"'))
+            and not text.startswith("file://")
+            and not any(c in self._PATH_INDICATOR_CHARS for c in text)
+        ):
             return False
         if self._is_existing_path_payload(text):
             return True