soothe-cli 0.5.1__tar.gz → 0.5.3__tar.gz

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.1
+Version: 0.5.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

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/cli/commands/run_cmd.py

@@ -24,25 +24,29 @@ def run_impl(
     streaming_enabled: bool | None = None,
     streaming_mode: str | None = None,
     *,
+    tui_with_prompt: bool = False,
     config_path: str | None = None,
 ) -> None:
     """Core implementation for running Soothe agent.
 
     Args:
-        prompt: Optional prompt for headless mode
+        prompt: Optional user message; non-empty prompt defaults to a headless
+            one-shot run unless ``tui_with_prompt`` is set or a loop is being
+            resumed (``resume_loop_id``).
         resume_loop_id: Existing loop id to attach to (optional)
-        no_tui: Force headless mode
+        no_tui: Require headless mode (must include a non-empty prompt)
         autonomous: Enable autonomous iteration mode
         max_iterations: Max iterations for autonomous mode
         streaming_enabled: Override daemon streaming enabled setting (RFC-614)
         streaming_mode: Override daemon streaming mode ('streaming' or 'batch')
+        tui_with_prompt: When True with a prompt, open the TUI instead of headless.
     """
     startup_start = time.perf_counter()
 
     try:
         cfg = load_config(config_path)
         log_level = resolve_cli_log_level(logging_level=cfg.logging_level)
-        log_file = Path(SOOTHE_HOME) / "logs" / "soothe-cli.log"
+        log_file = Path(SOOTHE_HOME) / "logs" / "cli.log"
         setup_logging(log_level, log_file=log_file)
 
         # PostgreSQL availability check (requires daemon-side config)
@@ -62,17 +66,31 @@ def run_impl(
 
         run_start = time.perf_counter()
 
-        if no_tui:
-            # Headless mode (force no TUI)
+        has_prompt = bool(prompt and str(prompt).strip())
+        attaching_loop = bool(resume_loop_id and str(resume_loop_id).strip())
+
+        if tui_with_prompt and has_prompt:
+            use_headless = False
+        elif no_tui and not has_prompt:
+            typer.echo(
+                "Error: --no-tui requires a non-empty --prompt (-p).",
+                err=True,
+            )
+            sys.exit(1)
+        elif no_tui:
+            use_headless = True
+        else:
+            use_headless = has_prompt and not attaching_loop
+
+        if use_headless:
             run_headless(
                 cfg,
-                prompt or "",
+                str(prompt).strip(),
                 resume_loop_id=resume_loop_id,
                 autonomous=autonomous,
                 max_iterations=max_iterations,
             )
         else:
-            # TUI mode (with optional initial prompt)
             run_tui(cfg, resume_loop_id=resume_loop_id, initial_prompt=prompt)
 
         run_elapsed_s = time.perf_counter() - run_start

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/cli/main.py

@@ -55,12 +55,24 @@ def main(
     prompt: Annotated[
         str | None,
         typer.Option(
-            "--prompt", "-p", help="Prompt to send as user message (headless single-shot mode)."
+            "--prompt",
+            "-p",
+            help="User message; runs a one-shot headless query by default (use --tui for TUI).",
         ),
     ] = None,
     no_tui: Annotated[  # noqa: FBT002
         bool,
-        typer.Option("--no-tui", help="Disable TUI; run single prompt and exit."),
+        typer.Option(
+            "--no-tui",
+            help="Headless mode (requires --prompt). Same as default when -p is set.",
+        ),
+    ] = False,
+    tui_with_prompt: Annotated[  # noqa: FBT002
+        bool,
+        typer.Option(
+            "--tui",
+            help="With --prompt/-p, open the interactive TUI and auto-submit the prompt.",
+        ),
     ] = False,
     streaming: Annotated[
         bool | None,
@@ -81,13 +93,15 @@ def main(
 ) -> None:
     """Soothe CLI - Intelligent AI assistant client.
 
-    Run without arguments for interactive TUI mode, or provide a prompt via --prompt/-p option.
+    Run without arguments for interactive TUI mode, or pass --prompt for a one-shot
+    headless query (stdout, then exit).
 
     Note: This is the CLI client. Use 'soothed' command to manage the daemon server.
 
     Examples:
         soothe                           # Interactive TUI mode
-        soothe -p "Research AI advances" # Headless single-prompt mode
+        soothe -p "Research AI advances" # One-shot headless (non-TUI) query
+        soothe -p "Hello" --tui         # TUI with an auto-submitted prompt
         soothe loop list                 # List AgentLoop instances
     """
     # Handle -h/--help flag
@@ -112,6 +126,7 @@ def main(
             max_iterations=None,
             streaming_enabled=streaming,
             streaming_mode=streaming_mode,
+            tui_with_prompt=tui_with_prompt,
         )
 
 

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/config/cli_config.py

@@ -24,7 +24,7 @@ class CLIConfig:
     daemon_host: str = "127.0.0.1"
     daemon_port: int = 8765
 
-    # logging_level: DEBUG/INFO/… for ~/.soothe/logs/soothe-cli.log; None = default INFO.
+    # logging_level: DEBUG/INFO/… for ~/.soothe/logs/cli.log; None = default INFO.
     logging_level: str | None = None
 
     # Output streaming overrides (RFC-614)

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/tui/_env_vars.py

@@ -29,7 +29,7 @@ from __future__ import annotations
 # ---------------------------------------------------------------------------
 
 AUTO_UPDATE = "SOOTHE_CLI_AUTO_UPDATE"
-"""Enable automatic CLI updates ('1', 'true', or 'yes')."""
+"""Override automatic CLI updates: '1'/'true'/'yes' on, '0'/'false'/'no' off. On by default when unset."""
 
 DEBUG = "SOOTHE_CLI_DEBUG"
 """Enable verbose debug logging to a file."""
@@ -43,6 +43,9 @@ EXTRA_SKILLS_DIRS = "SOOTHE_CLI_EXTRA_SKILLS_DIRS"
 NO_UPDATE_CHECK = "SOOTHE_CLI_NO_UPDATE_CHECK"
 """Disable automatic update checking when set."""
 
+UPDATE_CHECK = "SOOTHE_CLI_UPDATE_CHECK"
+"""Force-enable startup PyPI update checks ('1', 'true', or 'yes'). On by default."""
+
 SERVER_ENV_PREFIX = "SOOTHE_CLI_SERVER_"
 """Environment variable prefix used to pass CLI config to the server subprocess."""
 

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/tui/app/_app.py

@@ -10,7 +10,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
 
 if TYPE_CHECKING:
-    from langgraph.pregel import Pregel
     from textual.app import ComposeResult
     from textual.worker import Worker
 
@@ -133,22 +132,8 @@ class SootheApp(
     """App-level keybindings for interrupt, quit, toggles, and approval menu
     navigation."""
 
-    class ServerReady(Message):
-        """Posted by the background server-startup worker on success."""
-
-        def __init__(  # noqa: D107
-            self,
-            agent: Any,  # noqa: ANN401
-            server_proc: Any,  # noqa: ANN401
-            mcp_server_info: list[Any] | None,
-        ) -> None:
-            super().__init__()
-            self.agent = agent
-            self.server_proc = server_proc
-            self.mcp_server_info = mcp_server_info
-
     class ServerStartFailed(Message):
-        """Posted by the background server-startup worker on failure."""
+        """Posted when daemon bootstrap or background connection fails."""
 
         def __init__(self, error: Exception) -> None:  # noqa: D107
             super().__init__()
@@ -165,63 +150,30 @@ class SootheApp(
     def __init__(
         self,
         *,
-        agent: Pregel | None = None,
+        daemon_config: Any,
         assistant_id: str | None = None,
         auto_approve: bool = False,
         cwd: str | Path | None = None,
         resume_loop_id: str | None = None,
-        resume_loop_intent: str | None = None,
         initial_prompt: str | None = None,
         initial_skill: str | None = None,
         mcp_server_info: list[dict[str, Any]] | None = None,
         profile_override: dict[str, Any] | None = None,
-        server_proc: Any | None = None,
-        server_kwargs: dict[str, Any] | None = None,
-        mcp_preload_kwargs: dict[str, Any] | None = None,
-        model_kwargs: dict[str, Any] | None = None,
-        daemon_config: Any | None = None,
         **kwargs: Any,
     ) -> None:
-        """Initialize the Deep Agents application.
+        """Initialize the Textual application (daemon-backed execution only).
 
         Args:
-            agent: Pre-configured LangGraph agent, or `None` when server
-                startup is deferred via `server_kwargs`.
-            assistant_id: Agent identifier for memory storage
-            auto_approve: Whether to start with auto-approve enabled
-            cwd: Current working directory to display
-            resume_loop_id: Initial AgentLoop id (daemon-backed).
-
-                `None` when `resume_loop_intent` is provided (resolved asynchronously).
-            resume_loop_intent: Raw resume intent from `-r` flag.
-
-                `'__MOST_RECENT__'` for bare `-r`, a loop id for
-                `-r <id>`, or `None` for new sessions.
-
-                Resolved via `_resolve_resume_loop_intent`
-                during `_start_server_background`.
-
-                Requires `server_kwargs` to be set; ignored otherwise.
-            initial_prompt: Optional prompt to auto-submit when session starts
+            daemon_config: Loaded Soothe configuration (WebSocket URL, etc.).
+            assistant_id: Agent identifier for memory storage.
+            auto_approve: Whether to start with auto-approve enabled.
+            cwd: Current working directory to display.
+            resume_loop_id: Initial AgentLoop id when attaching to an existing loop.
+            initial_prompt: Optional prompt to auto-submit when session starts.
             initial_skill: Optional skill name to invoke when session starts.
             mcp_server_info: MCP server metadata for the `/mcp` viewer.
-            profile_override: Extra profile fields from `--profile-override`,
-                retained so later profile-aware behavior stays consistent with
-                the CLI override, including model selection details and
-                on-demand `create_model()` calls.
-            server_proc: LangGraph server process for the interactive session.
-            server_kwargs: When provided, server startup is deferred.
-
-                The app shows a "Connecting..." state and starts the server in
-                the background using these kwargs
-                for `start_server_and_get_agent`.
-            mcp_preload_kwargs: Kwargs for `_preload_session_mcp_server_info`,
-                run concurrently with server startup when `server_kwargs` is set.
-            model_kwargs: Kwargs for deferred `create_model()`.
-
-                When provided, model creation runs in a background worker after
-                first paint instead of blocking startup.
-            **kwargs: Additional arguments passed to parent
+            profile_override: Extra profile fields from ``--profile-override``.
+            **kwargs: Additional arguments passed to the Textual ``App``.
         """
         super().__init__(**kwargs)
 
@@ -230,8 +182,6 @@ class SootheApp(
         # Apply saved theme preference (or default)
         self.theme = _load_theme_preference()
 
-        self._agent = agent
-
         self._assistant_id = assistant_id
 
         self._auto_approve = auto_approve
@@ -242,8 +192,6 @@ class SootheApp(
         # Named `_lc_loop_id` to avoid colliding with Textual's App._thread_id.
         self._lc_loop_id = resume_loop_id
 
-        self._resume_loop_intent = resume_loop_intent
-
         self._initial_prompt = initial_prompt
 
         self._initial_skill = (
@@ -254,14 +202,6 @@ class SootheApp(
 
         self._profile_override = profile_override
 
-        self._server_proc = server_proc
-
-        self._server_kwargs = server_kwargs
-
-        self._mcp_preload_kwargs = mcp_preload_kwargs
-
-        self._model_kwargs = model_kwargs
-
         self._daemon_config = daemon_config
 
         self._daemon_session: Any | None = None
@@ -269,14 +209,9 @@ class SootheApp(
         self._daemon_skills_wire: list[dict[str, Any]] = []
         """Cached ``skills_list_response`` rows when the TUI uses ``TuiDaemonSession``."""
 
-        self._connecting = server_kwargs is not None or daemon_config is not None
-        # Extract sandbox type from server kwargs for trace metadata.
-        # ServerConfig.__post_init__ normalizes "none" → None, but server_kwargs carries
-        # the raw argparse value, so guard against both.
+        self._connecting = True
 
-        raw = (server_kwargs or {}).get("sandbox_type")
-
-        self._sandbox_type: str | None = raw if raw and raw != "none" else None
+        self._sandbox_type: str | None = None
 
         self._model_override: str | None = None
 
@@ -304,11 +239,7 @@ class SootheApp(
         self._agent_running = False
 
         self._server_startup_error: str | None = None
-        """Set when the background server fails to start; persists for the
-        session lifetime (server failure is terminal).
-
-        Shown in place of the generic 'Agent not configured' message.
-        """
+        """Set when daemon bootstrap fails; persists for the session lifetime."""
 
         self._shell_process: asyncio.subprocess.Process | None = None
         """Shell command process tracking for interruption (! commands)."""
@@ -391,18 +322,9 @@ class SootheApp(
 
         self._image_tracker = MediaTracker()
 
-    def _remote_agent(self) -> Any:  # noqa: ANN401
-        """Return the agent if it appears to be a remote agent, or `None`.
-
-        Returns `None` when no agent is configured or the agent is a local graph.
-        """
-        # RemoteAgent module doesn't exist in this package; always return None.
-        # When the SDK provides a RemoteAgent class, this can be re-implemented.
-        return None
-
     def _runtime_backend_ready(self) -> bool:
-        """Return whether the app has a usable execution backend."""
-        return self._daemon_session is not None or self._agent is not None
+        """Return whether the app has a connected daemon session."""
+        return self._daemon_session is not None
 
     def get_theme_variable_defaults(self) -> dict[str, str]:
         """Return custom CSS variable defaults for the current theme.
@@ -434,8 +356,6 @@ class SootheApp(
                     mcp_tool_count=self._mcp_tool_count,
                     workspace_path=self._cwd,
                     connecting=self._connecting,
-                    resuming=self._resume_loop_intent is not None,
-                    local_server=self._server_kwargs is not None,
                     id="welcome-banner",
                 )
                 yield Container(id="messages")

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/tui/app/_commands.py

@@ -9,7 +9,6 @@ from contextlib import suppress
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from langchain_core.runnables import RunnableConfig
     from textual.content import Content
 
 from textual.app import ScreenStackError
@@ -191,24 +190,25 @@ class _CommandsMixin:
             self._update_tokens(0)
             # Clear status message (e.g., "Interrupted" from previous session)
             self._update_status("")
-            # New AgentLoop (daemon) or new local loop id
             if self._session_state:
-                if self._daemon_session is not None:
+                if self._daemon_session is None:
+                    await self._mount_message(
+                        AppMessage("Not connected to the daemon; cannot start a new loop.")
+                    )
+                else:
                     status_event = await self._daemon_session.new_loop()
                     new_loop_id = (
                         str(status_event.get("loop_id", "")) or self._session_state.reset_loop()
                     )
                     self._session_state.loop_id = new_loop_id
                     self._lc_loop_id = new_loop_id
-                else:
-                    new_loop_id = self._session_state.reset_loop()
-                try:
-                    banner = self.query_one("#welcome-banner", WelcomeBanner)
-                    banner.update_loop_id(new_loop_id)
-                except NoMatches:
-                    pass
-                self._clear_loop_model_override()
-                await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
+                    try:
+                        banner = self.query_one("#welcome-banner", WelcomeBanner)
+                        banner.update_loop_id(new_loop_id)
+                    except NoMatches:
+                        pass
+                    self._clear_loop_model_override()
+                    await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
         elif cmd == "/editor":
             await self.action_open_editor()
         elif cmd == "/loops":
@@ -367,13 +367,6 @@ class _CommandsMixin:
                 report += "\nTheme registry reload failed. Check config.yml for errors."
             await self._mount_message(AppMessage(report))
 
-            # Re-discover skills so autocomplete reflects any new/removed skills
-            if self._daemon_config is None:
-                self.run_worker(
-                    self._discover_skills(),
-                    exclusive=True,
-                    group="startup-skill-discovery",
-                )
             if self._daemon_session is not None:
                 self.run_worker(
                     self._refresh_daemon_skills_catalog(),
@@ -424,22 +417,26 @@ class _CommandsMixin:
         Returns:
             Token count as an integer, or `None` if state is unavailable.
         """
-        if not self._agent:
+        if not self._lc_loop_id:
             return None
         try:
-            from langchain_core.messages.utils import (
-                count_tokens_approximately,
-            )
+            from langchain_core.messages import messages_from_dict
+            from langchain_core.messages.utils import count_tokens_approximately
 
-            config: RunnableConfig = {
-                "configurable": {"thread_id": self._lc_loop_id},
-            }
-            state = await self._agent.aget_state(config)
-            if not state or not state.values:
+            if self._daemon_session is None:
                 return None
-            messages = state.values.get("messages", [])
-            if not messages:
+            snap = await self._daemon_session.aget_loop_state(self._lc_loop_id)
+            vals = getattr(snap, "values", None)
+            if not isinstance(vals, dict):
                 return None
+            raw = vals.get("messages")
+            if not isinstance(raw, list) or not raw:
+                return None
+            if isinstance(raw[0], dict):
+                messages = messages_from_dict(raw)
+            else:
+                messages = raw
+
             return count_tokens_approximately(messages)
         except Exception:  # best-effort for /tokens display
             logger.debug("Failed to retrieve conversation token count", exc_info=True)

{soothe_cli-0.5.1 → soothe_cli-0.5.3}/src/soothe_cli/tui/app/_execution.py

@@ -10,10 +10,7 @@ import sys
 import time
 import webbrowser
 from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Literal
-
-if TYPE_CHECKING:
-    from langchain_core.runnables import RunnableConfig
+from typing import Any, Literal
 
 from textual.app import ScreenStackError
 from textual.containers import VerticalScroll
@@ -532,24 +529,25 @@ class _ExecutionMixin:
             self._update_tokens(0)
             # Clear status message (e.g., "Interrupted" from previous session)
             self._update_status("")
-            # New AgentLoop (daemon) or new local loop id
             if self._session_state:
-                if self._daemon_session is not None:
+                if self._daemon_session is None:
+                    await self._mount_message(
+                        AppMessage("Not connected to the daemon; cannot start a new loop.")
+                    )
+                else:
                     status_event = await self._daemon_session.new_loop()
                     new_loop_id = (
                         str(status_event.get("loop_id", "")) or self._session_state.reset_loop()
                     )
                     self._session_state.loop_id = new_loop_id
                     self._lc_loop_id = new_loop_id
-                else:
-                    new_loop_id = self._session_state.reset_loop()
-                try:
-                    banner = self.query_one("#welcome-banner", WelcomeBanner)
-                    banner.update_loop_id(new_loop_id)
-                except NoMatches:
-                    pass
-                self._clear_loop_model_override()
-                await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
+                    try:
+                        banner = self.query_one("#welcome-banner", WelcomeBanner)
+                        banner.update_loop_id(new_loop_id)
+                    except NoMatches:
+                        pass
+                    self._clear_loop_model_override()
+                    await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
         elif cmd == "/editor":
             await self.action_open_editor()
         elif cmd == "/loops":
@@ -708,13 +706,6 @@ class _ExecutionMixin:
                 report += "\nTheme registry reload failed. Check config.yml for errors."
             await self._mount_message(AppMessage(report))
 
-            # Re-discover skills so autocomplete reflects any new/removed skills
-            if self._daemon_config is None:
-                self.run_worker(
-                    self._discover_skills(),
-                    exclusive=True,
-                    group="startup-skill-discovery",
-                )
             if self._daemon_session is not None:
                 self.run_worker(
                     self._refresh_daemon_skills_catalog(),
@@ -759,33 +750,6 @@ class _ExecutionMixin:
             AppMessage("Skills require a daemon connection. Connect to a daemon first.")
         )
 
-    async def _get_conversation_token_count(self) -> int | None:
-        """Return the approximate conversation-only token count.
-
-        Returns:
-            Token count as an integer, or `None` if state is unavailable.
-        """
-        if not self._agent:
-            return None
-        try:
-            from langchain_core.messages.utils import (
-                count_tokens_approximately,
-            )
-
-            config: RunnableConfig = {
-                "configurable": {"thread_id": self._lc_loop_id},
-            }
-            state = await self._agent.aget_state(config)
-            if not state or not state.values:
-                return None
-            messages = state.values.get("messages", [])
-            if not messages:
-                return None
-            return count_tokens_approximately(messages)
-        except Exception:  # best-effort for /tokens display
-            logger.debug("Failed to retrieve conversation token count", exc_info=True)
-            return None
-
     async def _handle_user_message(self, message: str) -> None:
         """Handle a user message to send to the agent.
 
@@ -878,7 +842,6 @@ class _ExecutionMixin:
         try:
             await execute_task_textual(
                 user_input=message,
-                agent=self._agent,
                 daemon_session=self._daemon_session,
                 assistant_id=self._assistant_id,
                 session_state=self._session_state,