soothe-cli 0.4.1__tar.gz → 0.4.3__tar.gz

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/.gitignore

@@ -218,3 +218,4 @@ plot_*
 checkpoint.json
 manifest.json
 _bmad
+__MACOSX

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.4.1
+Version: 0.4.3
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/OpenSoothe/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.15,>=3.11
+Requires-Python: <4.0,>=3.11
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
 Requires-Dist: rich>=13.0.0
@@ -57,9 +57,6 @@ soothe -p "Research AI advances"
 # Loop management
 soothe loop list
 soothe loop continue loop_abc123
-
-# Configuration
-soothe config show
 ```
 
 ## Architecture
@@ -82,13 +79,14 @@ This package is the **client** component that communicates with the Soothe daemo
 CLI uses `cli_config.yml`:
 
 ```yaml
-websocket:
-  host: "localhost"
-  port: 8765
-
-ui:
-  verbosity: "normal"
-  format: "text"
+daemon:
+  transports:
+    websocket:
+      host: "127.0.0.1"
+      port: 8765
+
+# Optional: logging_level for ~/.soothe/logs/soothe-cli.log (DEBUG, INFO, …)
+# logging_level: INFO
 
 tui:
   theme: "default"

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/README.md

@@ -22,9 +22,6 @@ soothe -p "Research AI advances"
 # Loop management
 soothe loop list
 soothe loop continue loop_abc123
-
-# Configuration
-soothe config show
 ```
 
 ## Architecture
@@ -47,13 +44,14 @@ This package is the **client** component that communicates with the Soothe daemo
 CLI uses `cli_config.yml`:
 
 ```yaml
-websocket:
-  host: "localhost"
-  port: 8765
-
-ui:
-  verbosity: "normal"
-  format: "text"
+daemon:
+  transports:
+    websocket:
+      host: "127.0.0.1"
+      port: 8765
+
+# Optional: logging_level for ~/.soothe/logs/soothe-cli.log (DEBUG, INFO, …)
+# logging_level: INFO
 
 tui:
   theme: "default"

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "Soothe CLI client - communicates with daemon via WebSocket"
 readme = "README.md"
 license = { text = "MIT" }
-requires-python = ">=3.11,<3.15"
+requires-python = ">=3.11,<4.0"
 keywords = ["soothe", "cli", "client", "tui", "websocket"]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -76,7 +76,7 @@ path = "../../VERSION"
 pattern = "^(?P<version>[0-9]+\\.[0-9]+\\.[0-9]+)$"
 
 [tool.mypy]
-python_version = "3.11"
+python_version = "3.12"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -21,9 +21,6 @@ def run(
     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.
 
@@ -39,7 +36,6 @@ def run(
         no_tui=True,
         autonomous=True,
         max_iterations=max_iterations,
-        output_format=output_format,
     )
 
 

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/src/soothe_cli/cli/commands/run_cmd.py

@@ -17,30 +17,29 @@ logger = logging.getLogger(__name__)
 
 def run_impl(
     prompt: str | None,
-    config: str | None,
     thread_id: str | None,
     no_tui: bool,  # noqa: FBT001
     autonomous: bool,  # noqa: FBT001
     max_iterations: int | None,
-    output_format: str,
+    streaming_enabled: bool | None = None,
+    streaming_mode: str | None = None,
 ) -> None:
     """Core implementation for running Soothe agent.
 
     Args:
         prompt: Optional prompt for headless mode
-        config: Deprecated; passed through for ``--config`` compatibility (ignored for
-            client settings; see ``load_config``).
         thread_id: Thread ID to resume
         no_tui: Force headless mode
         autonomous: Enable autonomous iteration mode
         max_iterations: Max iterations for autonomous mode
-        output_format: Output format (text or jsonl)
+        streaming_enabled: Override daemon streaming enabled setting (RFC-614)
+        streaming_mode: Override daemon streaming mode ('streaming' or 'batch')
     """
     startup_start = time.perf_counter()
 
     try:
-        cfg = load_config(config)
-        log_level = resolve_cli_log_level(cfg.verbosity, logging_level=cfg.logging_level)
+        cfg = load_config()
+        log_level = resolve_cli_log_level(logging_level=cfg.logging_level)
         log_file = Path(SOOTHE_HOME) / "logs" / "soothe-cli.log"
         setup_logging(log_level, log_file=log_file)
 
@@ -50,6 +49,12 @@ def run_impl(
             if checkpointer == "postgresql":
                 logger.info("PostgreSQL checkpointer configured; ensure server is running.")
 
+        # Apply CLI streaming overrides (RFC-614)
+        if streaming_enabled is not None:
+            cfg.output_streaming_enabled = streaming_enabled
+        if streaming_mode is not None:
+            cfg.output_streaming_mode = streaming_mode
+
         startup_elapsed_ms = (time.perf_counter() - startup_start) * 1000
         logger.info("[Startup] ✓ Ready (%.1fms)", startup_elapsed_ms)
 
@@ -61,7 +66,6 @@ def run_impl(
                 cfg,
                 prompt or "",
                 thread_id=thread_id,
-                output_format=output_format,
                 autonomous=autonomous,
                 max_iterations=max_iterations,
             )

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/src/soothe_cli/cli/commands/thread_cmd.py

@@ -19,6 +19,11 @@ from soothe_sdk.client import WebSocketClient, is_daemon_live, websocket_url_fro
 
 from soothe_cli.shared import load_config
 
+thread_app = typer.Typer(
+    name="thread",
+    help="Inspect conversation threads (read-only diagnostics)",
+)
+
 # Display limits for thread list
 _TOPIC_DISPLAY_LIMIT = 30  # Max chars for last human message
 _TOPIC_TRUNCATE_KEEP = 27  # Leave room for "..."
@@ -116,6 +121,7 @@ def _echo_thread_table(rows: list[dict[str, object]]) -> None:
         typer.echo(f"{tid:<20}  {t_status:<10}  {created:<19}  {last_msg:<19}  {topic:<30}")
 
 
+@thread_app.command("list")
 def thread_list(
     config: Annotated[
         str | None,
@@ -186,6 +192,7 @@ def thread_list(
     asyncio.run(_list())
 
 
+@thread_app.command("show")
 def thread_show(
     thread_id: Annotated[str, typer.Argument(help="Thread ID to show.")],
     config: Annotated[
@@ -239,6 +246,7 @@ def thread_show(
     asyncio.run(_show())
 
 
+@thread_app.command("export")
 def thread_export(
     thread_id: Annotated[str, typer.Argument(help="Thread ID to export.")],
     output: Annotated[
@@ -309,6 +317,7 @@ def thread_export(
     asyncio.run(_export())
 
 
+@thread_app.command("stats")
 def thread_stats(
     thread_id: Annotated[str, typer.Argument(help="Thread ID.")],
     config: Annotated[
@@ -368,6 +377,7 @@ def thread_stats(
     asyncio.run(_stats())
 
 
+@thread_app.command("artifacts")
 def thread_artifacts(
     thread_id: Annotated[str, typer.Argument(help="Thread ID to list artifacts for.")],
     config: Annotated[

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/src/soothe_cli/cli/execution/daemon.py

@@ -1,13 +1,14 @@
 """Daemon-based execution for headless mode.
 
-Refactored to use RFC-0019 EventProcessor with CliRenderer.
+Uses RFC-0019 EventProcessor with HeadlessCliRenderer (stdout: loop-tagged answers only).
 Uses WebSocket transport (RFC-0013).
 """
 
+from __future__ import annotations
+
 import asyncio
-import json
 import logging
-import sys
+import os
 from typing import Any
 
 import typer
@@ -17,7 +18,7 @@ from soothe_sdk.client import (
     websocket_url_from_config,
 )
 
-from soothe_cli.cli.renderer import CliRenderer
+from soothe_cli.cli.execution.headless_renderer import HeadlessCliRenderer
 from soothe_cli.shared import EventProcessor
 from soothe_cli.shared.presentation_engine import PresentationEngine
 from soothe_cli.shared.subagent_routing import parse_subagent_from_input
@@ -34,27 +35,28 @@ async def run_headless_via_daemon(
     prompt: str,
     *,
     thread_id: str | None = None,
-    output_format: str = "text",
     autonomous: bool = False,
     max_iterations: int | None = None,
 ) -> int:
     """Run a single prompt by connecting to a running daemon.
 
     Uses WebSocket transport for all connections (RFC-0013).
-    Refactored to use RFC-0019 EventProcessor with CliRenderer.
+    Headless output is RFC-614 loop-tagged main-graph assistant text only (IG-343).
     """
     from soothe_sdk.client import WebSocketClient
 
     ws_url = websocket_url_from_config(cfg)
     client = WebSocketClient(url=ws_url)
-    verbosity = cfg.logging.verbosity
+    final_output_mode = getattr(cfg, "final_output_mode", "streaming")
 
     try:
         await connect_websocket_with_retries(client)
+        cli_ws = os.environ.get("SOOTHE_CLI_WORKSPACE", "").strip() or os.getcwd()
         status_event = await bootstrap_thread_session(
             client,
             resume_thread_id=thread_id,
-            verbosity=verbosity,
+            verbosity="normal",
+            workspace=cli_ws,
             thread_status_timeout_s=_SESSION_BOOTSTRAP_TIMEOUT_S,
             subscription_timeout_s=_SESSION_BOOTSTRAP_TIMEOUT_S,
         )
@@ -69,25 +71,26 @@ async def run_headless_via_daemon(
 
         subagent_name, cleaned_prompt = parse_subagent_from_input(prompt)
 
-        # Send the input
         await asyncio.wait_for(
             client.send_input(
                 cleaned_prompt if subagent_name else prompt,
                 autonomous=autonomous,
                 max_iterations=max_iterations,
-                subagent=subagent_name,
+                preferred_subagent=subagent_name,
             ),
             timeout=_SESSION_BOOTSTRAP_TIMEOUT_S,
         )
 
-        # Initialize RFC-0019 unified event processor with one PresentationEngine
-        # for pipeline + message gating (RFC-502).
         presentation = PresentationEngine()
-        renderer = CliRenderer(verbosity=verbosity, presentation_engine=presentation)
-        processor = EventProcessor(renderer, verbosity=verbosity, presentation_engine=presentation)
+        renderer = HeadlessCliRenderer()
+        processor = EventProcessor(
+            renderer,
+            final_output_mode=final_output_mode,
+            presentation_engine=presentation,
+            headless_output=True,
+        )
 
-        has_error = False
-        query_started = False  # Track if we've seen the query start running
+        query_started = False
 
         while True:
             try:
@@ -104,13 +107,10 @@ async def run_headless_via_daemon(
 
             event_type = event.get("type", "")
 
-            # IMMEDIATE error check - exit before any other processing
-            # This ensures errors before query starts return immediately (IG-181)
             if event_type == "error":
                 typer.echo(f"Daemon error: {event.get('message', 'unknown')}", err=True)
                 return 1
 
-            # Check for soothe.error.* events before query starts
             ev_data = event.get("data")
             if (
                 not query_started
@@ -120,14 +120,11 @@ async def run_headless_via_daemon(
                 typer.echo(f"Daemon error: {ev_data.get('error', 'unknown')}", err=True)
                 return 1
 
-            # Handle status changes (need to track query_started for timeout)
             if event_type == "status":
                 state = event.get("state", "")
                 if state == "running":
                     query_started = True
                 elif (state == "idle" and query_started) or state == "stopped":
-                    # loop.completed (and stray message chunks) may arrive *after* idle on the
-                    # WebSocket stream; draining avoids dropping completion + final stdout (test-case1).
                     loop_clock = asyncio.get_event_loop()
                     drain_deadline = loop_clock.time() + 2.5
                     while loop_clock.time() < drain_deadline:
@@ -137,45 +134,13 @@ async def run_headless_via_daemon(
                             break
                         if not nxt:
                             break
-                        if output_format == "jsonl":
-                            namespace = nxt.get("namespace", [])
-                            mode = nxt.get("mode", "")
-                            data = nxt.get("data")
-                            sys.stdout.write(
-                                json.dumps(
-                                    {"namespace": list(namespace), "mode": mode, "data": data},
-                                    default=str,
-                                )
-                                + "\n"
-                            )
-                            sys.stdout.flush()
-                            continue
                         processor.process_event(nxt)
 
-                    processor.process_event(event)  # Finalize (on_turn_end after drain)
+                    processor.process_event(event)
                     break
 
-            # JSONL output bypass processor
-            if output_format == "jsonl":
-                namespace = event.get("namespace", [])
-                mode = event.get("mode", "")
-                data = event.get("data")
-                sys.stdout.write(
-                    json.dumps(
-                        {"namespace": list(namespace), "mode": mode, "data": data}, default=str
-                    )
-                    + "\n"
-                )
-                sys.stdout.flush()
-                continue
-
-            # Delegate to unified event processor
             processor.process_event(event)
 
-        # Note: Final newline is handled by renderer.on_turn_end() called
-        # when status changes to idle/stopped in _handle_status().
-        # Daemon lifecycle remains silent in normal headless mode.
-
     except (ConnectionError, OSError, TimeoutError) as e:
         logger.exception("Daemon connection failed")
         from soothe_sdk.utils import format_cli_error
@@ -189,6 +154,6 @@ async def run_headless_via_daemon(
         typer.echo(f"Error: {format_cli_error(e)}", err=True)
         return 1
     else:
-        return 1 if has_error else 0
+        return 0
     finally:
         await client.close()

{soothe_cli-0.4.1 → soothe_cli-0.4.3}/src/soothe_cli/cli/execution/headless.py

@@ -23,13 +23,12 @@ def run_headless(
     prompt: str,
     *,
     thread_id: str | None = None,
-    output_format: str = "text",
     autonomous: bool = False,
     max_iterations: int | None = None,
 ) -> None:
     """Run a single prompt with streaming output and progress events.
 
-    Connects to running daemon via WebSocket if available to avoid RocksDB lock conflicts.
+    Connects to running daemon via WebSocket if available to avoid database lock conflicts.
     Auto-starts daemon if not running (RFC-0013 daemon lifecycle).
 
     Note (RFC-0013): Daemon persists after request completion. Use 'soothed stop'
@@ -41,8 +40,8 @@ def run_headless(
     ws_url = websocket_url_from_config(cfg)
 
     # Auto-start daemon if not running (RFC-0013) - WebSocket RPC checks (IG-174 Phase 1)
-    async def _check_and_ensure_daemon() -> None:
-        """Check daemon status and auto-start if needed."""
+    async def _run_headless_pipeline() -> int:
+        """Ensure daemon is reachable, then run the headless daemon session."""
         daemon_live = await is_daemon_live(ws_url, timeout=5.0)
 
         if not daemon_live:
@@ -75,19 +74,15 @@ def run_headless(
             # Note: We don't fail here - let the connection attempt handle errors
             # This allows tests and edge cases to proceed with mocked daemons
 
-    asyncio.run(_check_and_ensure_daemon())
-
-    # Connect to daemon and execute
-    daemon_exit_code = asyncio.run(
-        run_headless_via_daemon(
+        return await run_headless_via_daemon(
             cfg,
             prompt,
             thread_id=thread_id,
-            output_format=output_format,
             autonomous=autonomous,
             max_iterations=max_iterations,
         )
-    )
+
+    daemon_exit_code = asyncio.run(_run_headless_pipeline())
 
     # Handle daemon fallback (unresponsive daemon)
     if daemon_exit_code == _DAEMON_FALLBACK_EXIT_CODE:

soothe_cli-0.4.3/src/soothe_cli/cli/execution/headless_renderer.py

@@ -0,0 +1,107 @@
+"""Minimal stdout-only renderer for headless CLI (IG-343).
+
+Emits RFC-614 loop-tagged assistant text for the main graph (empty LangGraph namespace)
+and loop-tagged finals (including replayed ``goal_completion`` from IG-355). Subgraph
+namespaced prose is suppressed unless loop-tagged. Stderr is used for errors.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from rich.console import Console
+
+from soothe_cli.shared.renderer_base import RendererBase
+
+
+class HeadlessCliRenderer(RendererBase):
+    """Headless mode: clean assistant output on stdout, errors on stderr."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.console = Console()
+
+    def on_assistant_text(
+        self,
+        text: str,
+        *,
+        is_main: bool,
+        is_streaming: bool,
+        task_scope: tuple[str, str] | None = None,
+    ) -> None:
+        if not is_main or task_scope:
+            return
+        payload = text if is_streaming else self.repair_concatenated_output(text)
+        if not payload:
+            return
+        sys.stdout.write(payload)
+        sys.stdout.flush()
+
+    def on_streaming_output(
+        self,
+        event_type: str,
+        text: str,
+        *,
+        is_chunk: bool,
+        namespace: tuple[str, ...],
+    ) -> None:
+        self.on_assistant_text(text, is_main=True, is_streaming=is_chunk)
+
+    def on_tool_call(
+        self,
+        name: str,
+        args: dict[str, Any],
+        tool_call_id: str,
+        *,
+        is_main: bool,
+        task_scope: tuple[str, str] | None = None,
+    ) -> None:
+        del name, args, tool_call_id, is_main, task_scope
+
+    def on_tool_result(
+        self,
+        name: str,
+        result: str,
+        tool_call_id: str,
+        *,
+        is_error: bool,
+        is_main: bool,
+        task_scope: tuple[str, str] | None = None,
+    ) -> None:
+        del name, result, tool_call_id, is_error, is_main, task_scope
+
+    def on_status_change(self, state: str) -> None:
+        del state
+
+    def on_error(self, error: str, *, context: str | None = None) -> None:
+        prefix = f"[{context}] " if context else ""
+        sys.stderr.write(f"{prefix}ERROR: {error}\n")
+        sys.stderr.flush()
+
+    def on_progress_event(
+        self,
+        event_type: str,
+        data: dict[str, Any],
+        *,
+        namespace: tuple[str, ...],
+        task_scope: tuple[str, str] | None = None,
+    ) -> None:
+        del event_type, data, namespace, task_scope
+
+    def on_plan_created(self, plan: Any) -> None:
+        del plan
+
+    def on_plan_step_started(self, step_id: str, description: str) -> None:
+        del step_id, description
+
+    def on_plan_step_completed(
+        self,
+        step_id: str,
+        success: bool,
+        duration_ms: int,
+    ) -> None:
+        del step_id, success, duration_ms
+
+    def on_turn_end(self) -> None:
+        """End of turn; headless does not append synthetic newlines to stdout."""