soothe-cli 0.6.16__tar.gz → 0.6.17__tar.gz

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.16
+Version: 0.6.17
 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.17/src/soothe_cli/runtime/__init__.py

@@ -0,0 +1,17 @@
+"""Daemon event processing and display state for the CLI (source of truth for TUI).
+
+Bridges daemon events/messages to in-memory state. ``soothe_cli.tui`` owns widgets
+and layout only.
+"""
+
+from soothe_cli.config.loader import load_config
+from soothe_cli.config.logging_setup import setup_logging
+from soothe_cli.runtime.headless.processor import EventProcessor
+from soothe_cli.runtime.headless.processor_state import ProcessorState
+
+__all__ = [
+    "EventProcessor",
+    "ProcessorState",
+    "load_config",
+    "setup_logging",
+]

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/runtime/parse/message_processing.py

@@ -16,17 +16,14 @@ from soothe_sdk.display.message_processing import (
     _resolve_pending_lookup_tool_name,
     accumulate_tool_call_chunks,
     coerce_tool_call_args_to_dict,
-    coerce_tool_call_entry_to_dict,
     extract_tool_args_dict,
     extract_tool_brief,
     finalize_pending_tool_call,
     ingest_tool_call_stream_state,
     normalize_tool_calls_list,
     richest_pending_args_for_lookup,
-    seed_pending_tool_calls_from_message,
     tool_calls_have_any_arg_dict,
     tool_ids_touched_by_stream_message,
-    tool_lookup_step_id,
     try_parse_pending_tool_call_args,
 )
 
@@ -36,16 +33,13 @@ __all__ = [
     "_resolve_pending_lookup_tool_name",
     "accumulate_tool_call_chunks",
     "coerce_tool_call_args_to_dict",
-    "coerce_tool_call_entry_to_dict",
     "extract_tool_args_dict",
     "extract_tool_brief",
     "finalize_pending_tool_call",
     "ingest_tool_call_stream_state",
     "normalize_tool_calls_list",
     "richest_pending_args_for_lookup",
-    "seed_pending_tool_calls_from_message",
     "tool_calls_have_any_arg_dict",
     "tool_ids_touched_by_stream_message",
-    "tool_lookup_step_id",
     "try_parse_pending_tool_call_args",
 ]

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/runtime/parse/tool_call_resolution.py

@@ -17,7 +17,15 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any
 
-from soothe_sdk.ux.task_namespace import parse_unified_tool_call_id
+from soothe_sdk.ux.execute_namespace import (
+    is_root_execute_namespace_key,
+    is_step_level_execute_namespace_key,
+)
+from soothe_sdk.ux.task_namespace import (
+    TaskScope,
+    parse_unified_tool_call_id,
+    row_key_for_subgraph_tool,
+)
 
 from soothe_cli.runtime.parse.message_processing import (
     extract_tool_args_dict,
@@ -40,15 +48,32 @@ def tool_args_meaningful(raw: Any) -> bool:
 
 
 def is_execute_step_namespace(ns_key: tuple[str, ...]) -> bool:
-    """True for CoreAgent execute root namespace (``execute:{run_id}``), not nested ``tools:`` subgraphs."""
-    if len(ns_key) != 1:
-        return False
-    return str(ns_key[0] or "").startswith("execute:")
+    """True for CoreAgent execute root namespace (``execute:{run_id}``), not nested ``/N`` or ``tools:`` subgraphs."""
+    return is_root_execute_namespace_key(ns_key)
 
 
 def is_step_card_tool_scope(*, ns_key: tuple[str, ...]) -> bool:
     """True when tool activity belongs on the step card as main execute-graph tools."""
-    return ns_key == () or is_execute_step_namespace(ns_key)
+    return ns_key == () or is_step_level_execute_namespace_key(ns_key)
+
+
+def resolve_tool_result_row_key(
+    *,
+    ns_key: tuple[str, ...],
+    tool_call_id: str,
+    task_scope: TaskScope | None = None,
+) -> str:
+    """Row key for completing a tool row from a streamed ``ToolMessage``.
+
+    Execute-graph namespaces (``()`` or ``execute:…``) keep the unified ``s:`` id.
+    Subagent ``tools:…`` namespaces remap via :func:`row_key_for_subgraph_tool`.
+    """
+    sid = str(tool_call_id or "").strip()
+    if not sid:
+        return ""
+    if is_step_card_tool_scope(ns_key=ns_key):
+        return sid
+    return row_key_for_subgraph_tool(ns_key, sid, task_scope=task_scope)
 
 
 def is_main_step_level_tool_call_id(tool_call_id: str) -> bool:
@@ -546,6 +571,7 @@ __all__ = [
     "merge_tool_display_args",
     "resolve_stream_tool_name",
     "resolve_tool_invocations_for_display",
+    "resolve_tool_result_row_key",
     "should_ingest_tool_for_step_stats",
     "tool_args_meaningful",
 ]

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/runtime/parse/tool_result.py

@@ -3,13 +3,11 @@
 from __future__ import annotations
 
 from soothe_sdk.display.tool_result import (
-    ToolResultPayload,
     extract_tool_result_payload,
     infer_tool_output_suggests_error,
 )
 
 __all__ = [
-    "ToolResultPayload",
     "extract_tool_result_payload",
     "infer_tool_output_suggests_error",
 ]

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/runtime/state/step_router.py

@@ -165,6 +165,47 @@ class StepTaskRouter:
         if sid:
             self.active_step_ids.add(sid)
 
+    def maybe_promote_step_to_running(
+        self,
+        step_w: StepWidget,
+        tool_call_id: str,
+        *,
+        step_cards: dict[str, StepWidget],
+    ) -> None:
+        """Promote a pending step card to running only when it is executing (RFC-628).
+
+        Pre-mounted future steps must stay ``pending`` until ``step.started`` even when
+        tools are stamped with their unified step id. The pre-``step.started`` race for
+        the active step is allowed only while no sibling step card is already running.
+        """
+        if getattr(step_w, "_status", "") != "pending":
+            return
+        step_id = str(getattr(step_w, "_step_id", "") or "").strip()
+        if not step_id:
+            return
+
+        tcid = str(tool_call_id or "").strip()
+        parsed_sid, _, _, _ = parse_unified_tool_call_id(tcid)
+        if parsed_sid and parsed_sid != step_id:
+            return
+
+        if step_id in self.active_step_ids:
+            allowed = True
+        elif self.active_step_ids:
+            allowed = False
+        else:
+            allowed = not any(
+                getattr(w, "_status", "") == "running"
+                and str(getattr(w, "_step_id", "") or "").strip() != step_id
+                for w in step_cards.values()
+            )
+
+        if not allowed:
+            return
+        promote = getattr(step_w, "promote_to_running_if_pending", None)
+        if callable(promote):
+            promote()
+
     def on_step_completed(self, step_id: str) -> None:
         """Drop step from the active set and spawn registry."""
         sid = step_id.strip()
@@ -353,6 +394,11 @@ class StepTaskRouter:
                     item.args,
                     raw_args=item.raw_args,
                 )
+                self.maybe_promote_step_to_running(
+                    step_w,
+                    item.tool_call_id,
+                    step_cards=step_cards,
+                )
             tool_to_step[item.tool_call_id] = step_w
             existing = tool_display_by_call_id.get(item.tool_call_id)
             if existing is None:
@@ -394,6 +440,8 @@ class StepTaskRouter:
         parent: ParentWidget,
         scope: TaskScope,
         tool_to_step: dict[str, ParentWidget],
+        *,
+        step_cards: dict[str, StepWidget] | None = None,
     ) -> bool:
         """Register one subgraph tool row on an already-resolved parent step card."""
         if _is_task_metadata_subgraph_tool(item):
@@ -432,7 +480,6 @@ class StepTaskRouter:
                         resolved_args = parsed
                 update(row_id, resolved_args)
         else:
-            parent_task_id = str(scope[0]).strip()
             resolved_args = dict(item.args or {})
             from soothe_cli.runtime.parse.message_processing import extract_tool_args_dict
 
@@ -446,9 +493,10 @@ class StepTaskRouter:
                 item.tool_name,
                 resolved_args,
                 raw_args=item.raw_args,
-                parent_tool_call_id=parent_task_id or None,
             )
         tool_to_step[row_id] = parent
+        if step_cards is not None:
+            self.maybe_promote_step_to_running(parent, row_id, step_cards=step_cards)
         return True
 
     def try_route_subgraph_tool(
@@ -522,7 +570,13 @@ class StepTaskRouter:
             return False
         pending_key = _subgraph_pending_key(ns_key, item.lookup_id)
         self._pending_subgraph_tools.pop(pending_key, None)
-        return self._ingest_subgraph_tool_on_parent(item, parent, scope, tool_to_step)
+        return self._ingest_subgraph_tool_on_parent(
+            item,
+            parent,
+            scope,
+            tool_to_step,
+            step_cards=step_cards,
+        )
 
     def route_pending_subgraph_tools(
         self,
@@ -575,7 +629,13 @@ class StepTaskRouter:
             if parent is None:
                 still[key] = item
                 continue
-            if self._ingest_subgraph_tool_on_parent(item, parent, scope, tool_to_step):
+            if self._ingest_subgraph_tool_on_parent(
+                item,
+                parent,
+                scope,
+                tool_to_step,
+                step_cards=step_cards,
+            ):
                 routed += 1
             else:
                 still[key] = item
@@ -586,15 +646,15 @@ class StepTaskRouter:
         """Snapshot of subgraph tools still awaiting parent resolution."""
         return list(self._pending_subgraph_tools.values())
 
+    def discard_pending_subgraph_tool(self, ns_key: tuple[str, ...], lookup_id: str) -> None:
+        """Drop a buffered subgraph tool after routing it to a SubAgent card."""
+        self._pending_subgraph_tools.pop(_subgraph_pending_key(ns_key, lookup_id), None)
+
     @property
     def pending_main_tool_count(self) -> int:
         """Number of root tools still awaiting step card routing."""
         return len(self._pending_main_tools)
 
-    def clear_step_tool_bindings(self, step_id: str) -> None:
-        """No-op: step routing uses unified tool_call_id encoding only."""
-        _ = step_id
-
 
 __all__ = [
     "ParentWidget",

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -393,25 +393,42 @@ class _MessagesMixin:
         copy_selection_to_clipboard(self, notify_if_empty=True)
 
     def action_quit_or_interrupt(self) -> None:
-        """Handle Ctrl+C - interrupt agent or quit on double press.
+        """Handle Ctrl+C - clear input, interrupt agent, or quit on double press.
 
-        Priority order:
-        1. If shell command is running, kill it
-        2. If agent is running, interrupt it (preserve input)
-        3. If double press (quit_pending), quit
-        4. Otherwise clear draft input and show quit hint
+        Priority order when task is running (agent/shell):
+        1. If input has pending text, clear it (first Ctrl+C)
+        2. If input is empty, interrupt the running task (second Ctrl+C)
+
+        Priority order when idle:
+        1. If double press (quit_pending), quit
+        2. Otherwise clear pending input and show quit hint
 
         Note: Copying selected text is bound to Ctrl+Y (`action_copy_selection`)
         so Ctrl+C is reserved for interrupt/quit only.
         """
-        # If shell command is running, cancel the worker
+        # Check if input has pending content (text, mode, or completion)
+        has_pending_input = self._chat_input and (
+            self._chat_input.value.strip()
+            or self._chat_input.mode != "normal"
+            or self._chat_input._current_suggestions
+        )
+
+        # If shell command is running: clear input first, then kill shell
         if self._shell_running and self._shell_worker:
+            if has_pending_input:
+                self._chat_input.clear_input()
+                self._quit_pending = False
+                return
             self._cancel_worker(self._shell_worker)
             self._quit_pending = False
             return
 
-        # If agent is running, interrupt it and discard queued messages
+        # If agent is running: clear input first, then interrupt
         if self._agent_running and self._agent_worker:
+            if has_pending_input:
+                self._chat_input.clear_input()
+                self._quit_pending = False
+                return
             if self._daemon_session is not None:
                 self.run_worker(
                     self._interrupt_daemon_agent_turn(),
@@ -430,7 +447,7 @@ class _MessagesMixin:
             self._arm_quit_pending("Ctrl+C")
 
     def _arm_quit_pending(self, shortcut: str) -> None:
-        """Set the pending-quit flag, clear draft input, and show a matching hint.
+        """Set the pending-quit flag, clear pending input, and show a matching hint.
 
         Args:
             shortcut: The key chord to show in the quit hint.

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/tui/config.py

@@ -7,7 +7,6 @@ import json
 import logging
 import os
 import re
-import shlex
 import sys
 import threading
 from dataclasses import dataclass
@@ -499,13 +498,6 @@ def get_banner() -> str:
     return banner
 
 
-MAX_ARG_LENGTH = 150
-"""Character limit for tool argument values in the UI.
-
-Longer values are truncated with an ellipsis by `truncate_value`
-in `tool_display`.
-"""
-
 config: RunnableConfig = {
     "recursion_limit": 1000,
 }
@@ -1426,87 +1418,6 @@ def contains_dangerous_patterns(command: str) -> bool:
     return bool(re.search(r"(?<![&])&(?![&])", command))
 
 
-def is_shell_command_allowed(command: str, allow_list: list[str] | None) -> bool:
-    """Check if a shell command is in the allow-list.
-
-    The allow-list matches against the first token of the command (the executable
-    name). This allows read-only commands like ls, cat, grep, etc. to be
-    auto-approved.
-
-    When `allow_list` is the `SHELL_ALLOW_ALL` sentinel, all non-empty commands
-    are approved unconditionally — dangerous pattern checks are skipped.
-
-    SECURITY: For regular allow-lists, this function rejects commands containing
-    dangerous shell patterns (command substitution, redirects, process
-    substitution, etc.) BEFORE parsing, to prevent injection attacks that could
-    bypass the allow-list.
-
-    Args:
-        command: The full shell command to check.
-        allow_list: List of allowed command names (e.g., `["ls", "cat", "grep"]`),
-            the `SHELL_ALLOW_ALL` sentinel to allow any command, or `None`.
-
-    Returns:
-        `True` if the command is allowed, `False` otherwise.
-    """
-    if not allow_list or not command or not command.strip():
-        return False
-
-    # SHELL_ALLOW_ALL sentinel — skip pattern and token checks
-    if isinstance(allow_list, _ShellAllowAll):
-        return True
-
-    # SECURITY: Check for dangerous patterns BEFORE any parsing
-    # This prevents injection attacks like: ls "$(rm -rf /)"
-    if contains_dangerous_patterns(command):
-        return False
-
-    allow_set = set(allow_list)
-
-    # Extract the first command token
-    # Handle pipes and other shell operators by checking each command in the pipeline
-    # Split by compound operators first (&&, ||), then single-char operators (|, ;).
-    # Note: standalone & (background) is blocked by contains_dangerous_patterns above.
-    segments = re.split(r"&&|\|\||[|;]", command)
-
-    # Track if we found at least one valid command
-    found_command = False
-
-    for raw_segment in segments:
-        segment = raw_segment.strip()
-        if not segment:
-            continue
-
-        try:
-            # Try to parse as shell command to extract the executable name
-            tokens = shlex.split(segment)
-            if tokens:
-                found_command = True
-                cmd_name = tokens[0]
-                # Check if this command is in the allow set
-                if cmd_name not in allow_set:
-                    return False
-        except ValueError:
-            # If we can't parse it, be conservative and require approval
-            return False
-
-    # All segments are allowed (and we found at least one command)
-    return found_command
-
-
-def get_default_coding_instructions() -> str:
-    """Get the default coding agent instructions.
-
-    These are the immutable base instructions that cannot be modified by the agent.
-    Long-term memory (AGENTS.md) is handled separately by the middleware.
-
-    Returns:
-        The default agent instructions as a string.
-    """
-    default_prompt_path = Path(__file__).parent / "default_agent_prompt.md"
-    return default_prompt_path.read_text()
-
-
 def detect_provider(model_name: str) -> str | None:
     """Auto-detect provider from model name.
 
@@ -2027,58 +1938,6 @@ def create_model(
     )
 
 
-def validate_model_capabilities(model: BaseChatModel, model_name: str) -> None:
-    """Validate that the model has required capabilities for `Soothe`.
-
-    Checks the model's profile (if available) to ensure it supports tool calling, which
-    is required for agent functionality. Issues warnings for models without profiles or
-    with limited context windows.
-
-    Args:
-        model: The instantiated model to validate.
-        model_name: Model name for error/warning messages.
-
-    Note:
-        This validation is best-effort. Models without profiles will pass with
-        a warning. Calls `sys.exit(1)` if the model's profile explicitly
-        indicates `tool_calling=False`.
-    """
-    console = _get_console()
-    profile = getattr(model, "profile", None)
-
-    if profile is None:
-        # Model doesn't have profile data - warn but allow
-        console.print(
-            f"[dim][yellow]Note:[/yellow] No capability profile for "
-            f"'{model_name}'. Cannot verify tool calling support.[/dim]"
-        )
-        return
-
-    if not isinstance(profile, dict):
-        return
-
-    # Check required capability: tool_calling
-    tool_calling = profile.get("tool_calling")
-    if tool_calling is False:
-        console.print(
-            f"[bold red]Error:[/bold red] Model '{model_name}' does not support tool calling."
-        )
-        console.print(
-            "\nDeep Agents requires tool calling for agent functionality. "
-            "Please choose a model that supports tool calling."
-        )
-        console.print("\nSee MODELS.md for supported models.")
-        sys.exit(1)
-
-    # Warn about potentially limited context (< 8k tokens)
-    max_input_tokens = profile.get("max_input_tokens")
-    if max_input_tokens and max_input_tokens < 8000:  # noqa: PLR2004  # Model context window default
-        console.print(
-            f"[dim][yellow]Warning:[/yellow] Model '{model_name}' has limited context "
-            f"({max_input_tokens:,} tokens). Agent performance may be affected.[/dim]"
-        )
-
-
 def _get_console() -> Console:
     """Return the lazily-initialized global `Console` instance.
 

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/tui/media_utils.py

@@ -9,7 +9,6 @@ import shutil
 
 # S404: subprocess needed for clipboard access via pngpaste/osascript
 import subprocess  # noqa: S404
-import sys
 import tempfile
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
@@ -118,25 +117,6 @@ class VideoData:
         )
 
 
-def get_clipboard_image() -> ImageData | None:
-    """Attempt to read an image from the system clipboard.
-
-    Supports macOS via `pngpaste` or `osascript`.
-
-    Returns:
-        ImageData if an image is found, None otherwise.
-    """
-    if sys.platform == "darwin":
-        return _get_macos_clipboard_image()
-    logger.warning(
-        "Clipboard image paste is not supported on %s. "
-        "Only macOS is currently supported. "
-        "You can still attach images by dragging and dropping file paths.",
-        sys.platform,
-    )
-    return None
-
-
 def get_image_from_path(path: pathlib.Path) -> ImageData | None:
     """Read and encode an image file from disk.
 

{soothe_cli-0.6.16 → soothe_cli-0.6.17}/src/soothe_cli/tui/model_config.py

@@ -381,16 +381,6 @@ def save_default_model(model_spec: ModelSpec) -> None:
     pass
 
 
-def save_recent_model(model_spec: ModelSpec) -> None:
-    """Save model to recent models list.
-
-    Args:
-        model_spec: Model specification to add to recent models.
-    """
-    # Stub - should maintain recent models list in SootheConfig
-    pass
-
-
 def clear_default_model() -> None:
     """Clear saved default model preference."""
     # Stub