soothe-cli 0.7.16__tar.gz → 0.7.17__tar.gz

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.16
+Version: 0.7.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.7.17/src/soothe_cli/runtime/presentation/id_format.py

@@ -0,0 +1,37 @@
+"""Compact id formatting for CLI and TUI status lines."""
+
+from __future__ import annotations
+
+
+def abbreviate_compact_id(
+    value: str,
+    *,
+    head: int = 8,
+    tail: int = 4,
+    max_len: int = 14,
+    empty: str = "",
+) -> str:
+    """Render a UUID-like id as ``prefix...suffix`` for compact UI surfaces.
+
+    Strips surrounding brackets and hyphens before measuring length. Values that
+    already contain ``...`` are returned unchanged (after hyphen stripping).
+
+    Args:
+        value: Raw id (loop id, etc.).
+        head: Prefix length when abbreviating.
+        tail: Suffix length when abbreviating.
+        max_len: Keep the compact form intact when at most this many characters.
+        empty: Returned when ``value`` is blank after stripping.
+
+    Returns:
+        Compact display string such as ``019f17e6...6543``.
+    """
+    raw = str(value or "").strip().strip("[]")
+    if not raw:
+        return empty
+    compact = raw.replace("-", "")
+    if "..." in compact:
+        return compact
+    if len(compact) <= max_len:
+        return compact
+    return f"{compact[:head]}...{compact[-tail:]}"

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/runtime/state/file_tracker.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import difflib
 import logging
+import re
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Literal
@@ -15,6 +16,7 @@ from soothe_cli.tui.preview_limits import APPROVAL_DIFF_MAX_LINES
 logger = logging.getLogger(__name__)
 
 FileOpStatus = Literal["pending", "success", "error"]
+FileChangeLabelPhase = Literal["pending", "success"]
 
 FILE_CHANGE_TOOLS: frozenset[str] = get_file_write_tool_names()
 """Filesystem tools that produce before/after diffs in the TUI chat."""
@@ -266,6 +268,205 @@ def format_display_path(path_str: str | None) -> str:
         return str(path_str)
 
 
+def _is_opaque_provider_call_fragment(tool_info: str) -> bool:
+    """True for provider opaque ids preserved as ``call_<uuid>`` fragments."""
+    info = (tool_info or "").strip()
+    return info.startswith("call_")
+
+
+def _is_stream_predicted_tool_index(tool_info: str, tool_name: str) -> bool:
+    """True when ``tool_info`` looks like a stream-predicted ``{tool}:{idx}`` id."""
+    tname = str(tool_name or "").strip()
+    info = (tool_info or "").strip()
+    if not tname or not info:
+        return False
+    if ":" not in info:
+        return False
+    head, _, suffix = info.partition(":")
+    return head == tname and suffix.isdigit()
+
+
+def file_change_tool_call_ids_match(
+    candidate_id: str,
+    lookup_id: str,
+    *,
+    tool_name: str,
+) -> bool:
+    """True when two tool_call_ids refer to the same logical file-change invocation.
+
+    Handles provider opaque ``call_*`` ids vs stream-predicted ``edit_file:N`` keys
+    on the same execute step (Kimi/OpenAI-style providers).
+    """
+    from soothe_sdk.display.message_processing import _pending_or_overlay_id_matches_lookup
+
+    cid = str(candidate_id).strip()
+    lid = str(lookup_id).strip()
+    if not cid or not lid:
+        return False
+    if cid == lid:
+        return True
+    if _pending_or_overlay_id_matches_lookup(cid, lid, tool_name=tool_name):
+        return True
+
+    from soothe_sdk.ux.task_namespace import parse_unified_tool_call_id
+
+    cand_step, cand_type, cand_tidx, cand_info = parse_unified_tool_call_id(cid)
+    lookup_step, lookup_type, lookup_tidx, lookup_info = parse_unified_tool_call_id(lid)
+    if not cand_step or not lookup_step or cand_step != lookup_step:
+        return False
+    if cand_type != lookup_type:
+        return False
+    if cand_type == "t" and cand_tidx != lookup_tidx:
+        return False
+
+    tname = str(tool_name or "").strip()
+    if not tname or tname == "tool":
+        return False
+
+    cand_opaque = _is_opaque_provider_call_fragment(cand_info)
+    lookup_opaque = _is_opaque_provider_call_fragment(lookup_info)
+    cand_predicted = _is_stream_predicted_tool_index(cand_info, tname)
+    lookup_predicted = _is_stream_predicted_tool_index(lookup_info, tname)
+    return (cand_opaque and lookup_predicted) or (lookup_opaque and cand_predicted)
+
+
+def file_path_from_tool_message_content(content_text: str) -> str | None:
+    """Best-effort file path extraction from a filesystem tool result string."""
+    text = str(content_text or "").strip()
+    if not text:
+        return None
+    quoted = re.search(r"in '([^']+)'", text)
+    if quoted:
+        return quoted.group(1).strip()
+    return None
+
+
+def resolve_active_file_operation(
+    tracker: FileOpTracker,
+    tool_call_id: str,
+    *,
+    tool_name: str,
+    content_text: str = "",
+) -> tuple[str | None, FileOperationRecord | None]:
+    """Resolve a pending :class:`FileOperationRecord` for a tool result id.
+
+    Returns:
+        ``(active_dict_key, record)`` when a unique match exists, else ``(None, None)``.
+    """
+    tcid = str(tool_call_id or "").strip()
+    if not tcid:
+        return None, None
+    direct = tracker.active.get(tcid)
+    if direct is not None:
+        return tcid, direct
+
+    tname = str(tool_name or "").strip()
+    msg_path = file_path_from_tool_message_content(content_text)
+    matches: list[tuple[str, FileOperationRecord]] = []
+    for key, record in tracker.active.items():
+        if not key:
+            continue
+        rname = str(record.tool_name or "").strip()
+        if tname and rname and tname != rname:
+            continue
+        alias_name = tname or rname
+        if not file_change_tool_call_ids_match(str(key), tcid, tool_name=alias_name):
+            continue
+        if msg_path:
+            rec_path = str(record.args.get("file_path") or record.args.get("path") or "").strip()
+            if rec_path and rec_path != msg_path:
+                continue
+        matches.append((str(key), record))
+
+    if len(matches) == 1:
+        return matches[0]
+    if len(matches) > 1:
+        logger.debug(
+            "Ambiguous file-change alias for tool_call_id=%s tool_name=%s candidates=%s",
+            tcid,
+            tname,
+            [key for key, _ in matches],
+        )
+    return None, None
+
+
+def file_change_preview_alias_already_shown(
+    previews_shown: set[str],
+    tool_call_id: str,
+    *,
+    tool_name: str,
+) -> bool:
+    """Return True when a preview for this logical invocation is already mounted."""
+    tcid = str(tool_call_id or "").strip()
+    if not tcid:
+        return False
+    if tcid in previews_shown:
+        return True
+    return any(
+        file_change_tool_call_ids_match(existing, tcid, tool_name=tool_name)
+        for existing in previews_shown
+    )
+
+
+def find_mounted_file_change_widget(
+    widgets: dict[str, Any],
+    tool_call_id: str,
+    *,
+    tool_name: str,
+) -> tuple[str | None, Any]:
+    """Locate a mounted preview widget, including stream/provider id aliases."""
+    tcid = str(tool_call_id or "").strip()
+    if not tcid:
+        return None, None
+    direct = widgets.get(tcid)
+    if direct is not None:
+        return tcid, direct
+    for key, widget in widgets.items():
+        if file_change_tool_call_ids_match(str(key), tcid, tool_name=tool_name):
+            return str(key), widget
+    return None, None
+
+
+def file_change_operation_already_tracked(
+    active: dict[str | None, FileOperationRecord],
+    tool_call_id: str,
+    *,
+    tool_name: str,
+) -> bool:
+    """Return True when ``active`` already holds this logical file-change operation."""
+    tcid = str(tool_call_id or "").strip()
+    if not tcid:
+        return False
+    if tcid in active:
+        return True
+    return any(
+        file_change_tool_call_ids_match(str(key), tcid, tool_name=tool_name)
+        for key in active
+        if key
+    )
+
+
+def _tool_message_content_text(tool_message: Any) -> str:  # noqa: ANN401
+    """Flatten a LangChain tool message content payload to plain text."""
+    content = getattr(tool_message, "content", None)
+    if isinstance(content, list):
+        joined: list[str] = []
+        for item in content:
+            if isinstance(item, str):
+                joined.append(item)
+            else:
+                joined.append(str(item))
+        return "\n".join(joined)
+    return str(content) if content is not None else ""
+
+
+def _tool_message_indicates_error(tool_message: Any, content_text: str) -> bool:  # noqa: ANN401
+    """Match :meth:`FileOpTracker.complete_with_message` error detection."""
+    return getattr(
+        tool_message, "status", "success"
+    ) != "success" or content_text.lower().startswith("error")
+
+
 class FileOpTracker:
     """Collect file operation metrics during a CLI interaction."""
 
@@ -273,7 +474,8 @@ class FileOpTracker:
         """Initialize the tracker."""
         self.assistant_id = assistant_id
         self.active: dict[str | None, FileOperationRecord] = {}
-        self.completed: list[FileOperationRecord] = []
+        self.recently_completed: dict[str, FileOperationRecord] = {}
+        """Completed records keyed by tool_call_id for late preview mounts."""
 
     def start_operation(
         self, tool_name: str, args: dict[str, Any], tool_call_id: str | None
@@ -305,29 +507,22 @@ class FileOpTracker:
             The completed FileOperationRecord, or None if no matching operation.
         """
         tool_call_id = getattr(tool_message, "tool_call_id", None)
-        record = self.active.get(tool_call_id)
+        tool_name = str(getattr(tool_message, "name", "") or "").strip()
+        content_text = _tool_message_content_text(tool_message)
+
+        active_key, record = resolve_active_file_operation(
+            self,
+            str(tool_call_id or ""),
+            tool_name=tool_name,
+            content_text=content_text,
+        )
         if record is None:
             return None
 
-        content = tool_message.content
-        if isinstance(content, list):
-            # Some tool messages may return list segments; join them for analysis.
-            joined = []
-            for item in content:
-                if isinstance(item, str):
-                    joined.append(item)
-                else:
-                    joined.append(str(item))
-            content_text = "\n".join(joined)
-        else:
-            content_text = str(content) if content is not None else ""
-
-        if getattr(
-            tool_message, "status", "success"
-        ) != "success" or content_text.lower().startswith("error"):
+        if _tool_message_indicates_error(tool_message, content_text):
             record.status = "error"
             record.error = content_text
-            self._finalize(record)
+            self._finalize(record, active_key=active_key)
             return record
 
         record.status = "success"
@@ -357,7 +552,7 @@ class FileOpTracker:
             if record.after_content is None:
                 record.status = "error"
                 record.error = "Could not read updated file content."
-                self._finalize(record)
+                self._finalize(record, active_key=active_key)
                 return record
             record.metrics.lines_written = _count_lines(record.after_content)
 
@@ -399,7 +594,7 @@ class FileOpTracker:
             ):
                 record.metrics.lines_added = max(record.metrics.lines_written - before_lines, 0)
 
-        self._finalize(record)
+        self._finalize(record, active_key=active_key)
         return record
 
     def _populate_after_content(self, record: FileOperationRecord) -> None:
@@ -409,9 +604,106 @@ class FileOpTracker:
             return
         record.after_content = _safe_read(record.physical_path)
 
-    def _finalize(self, record: FileOperationRecord) -> None:
-        self.completed.append(record)
-        self.active.pop(record.tool_call_id, None)
+    def _finalize(self, record: FileOperationRecord, *, active_key: str | None = None) -> None:
+        key = str(active_key or record.tool_call_id or "").strip()
+        if key:
+            self.active.pop(key, None)
+            self.recently_completed[key] = record
+        else:
+            self.active.pop(record.tool_call_id, None)
+            completed_id = str(record.tool_call_id or "").strip()
+            if completed_id:
+                self.recently_completed[completed_id] = record
+
+    def stash_untracked_file_change_result(
+        self,
+        tool_message: Any,  # noqa: ANN401
+    ) -> FileOperationRecord | None:
+        """Remember a filesystem tool result that arrived before tracking started.
+
+        Used when the CLI receives ``ToolMessage`` before streamed args mount a
+        preview card. Late mounts consult :attr:`recently_completed`.
+
+        Returns:
+            The stashed record, or None when the message is not a file-change tool.
+        """
+        tool_name = str(getattr(tool_message, "name", "") or "").strip()
+        if tool_name not in FILE_CHANGE_TOOLS:
+            return None
+        tcid = str(getattr(tool_message, "tool_call_id", None) or "").strip()
+        if not tcid:
+            return None
+        existing = self.peek_recently_completed(tcid, tool_name=tool_name)
+        if existing is not None:
+            return existing
+
+        content_text = _tool_message_content_text(tool_message)
+        path_str = file_path_from_tool_message_content(content_text) or ""
+        record = FileOperationRecord(
+            tool_name=tool_name,
+            display_path=format_display_path(path_str),
+            physical_path=resolve_physical_path(path_str, self.assistant_id),
+            tool_call_id=tcid,
+            args={"file_path": path_str} if path_str else {},
+        )
+        if _tool_message_indicates_error(tool_message, content_text):
+            record.status = "error"
+            record.error = content_text
+        else:
+            record.status = "success"
+            if record.physical_path is not None:
+                after = _safe_read(record.physical_path)
+                if after is not None:
+                    record.after_content = after
+                    record.metrics.lines_written = _count_lines(after)
+                    record.metrics.bytes_written = len(after.encode("utf-8"))
+        self.recently_completed[tcid] = record
+        return record
+
+    def _recently_completed_key(
+        self,
+        tool_call_id: str,
+        *,
+        tool_name: str,
+    ) -> str | None:
+        """Resolve the map key for a recently completed file-change id/alias."""
+        tcid = str(tool_call_id or "").strip()
+        if not tcid:
+            return None
+        if tcid in self.recently_completed:
+            return tcid
+        for key, record in self.recently_completed.items():
+            rname = str(record.tool_name or "").strip()
+            alias_name = str(tool_name or rname).strip()
+            if tool_name and rname and tool_name != rname:
+                continue
+            if file_change_tool_call_ids_match(str(key), tcid, tool_name=alias_name):
+                return str(key)
+        return None
+
+    def peek_recently_completed(
+        self,
+        tool_call_id: str,
+        *,
+        tool_name: str,
+    ) -> FileOperationRecord | None:
+        """Return a recently completed record without removing it."""
+        key = self._recently_completed_key(tool_call_id, tool_name=tool_name)
+        if key is None:
+            return None
+        return self.recently_completed.get(key)
+
+    def take_recently_completed(
+        self,
+        tool_call_id: str,
+        *,
+        tool_name: str,
+    ) -> FileOperationRecord | None:
+        """Pop a recently completed record for late preview finalization."""
+        key = self._recently_completed_key(tool_call_id, tool_name=tool_name)
+        if key is None:
+            return None
+        return self.recently_completed.pop(key, None)
 
 
 def track_file_operation(
@@ -424,13 +716,45 @@ def track_file_operation(
     if tool_name not in FILE_CHANGE_TOOLS:
         return
     tcid = str(tool_call_id).strip() if tool_call_id else ""
-    if not tcid or tcid in tracker.active:
+    if not tcid:
+        return
+    # Result already landed (result-before-preview race): do not capture
+    # post-edit on-disk bytes as before_content.
+    if tracker.peek_recently_completed(tcid, tool_name=tool_name) is not None:
+        return
+    if file_change_operation_already_tracked(
+        tracker.active,
+        tcid,
+        tool_name=tool_name,
+    ):
         return
     tracker.start_operation(tool_name, args, tcid)
 
 
-def file_change_label(tool_name: str, *, is_new_file: bool = False) -> str:
-    """Single-word past-tense prefix for a file-change card header."""
+def file_change_label(
+    tool_name: str,
+    *,
+    is_new_file: bool = False,
+    phase: FileChangeLabelPhase = "success",
+) -> str:
+    """Single-word action prefix for a file-change card header.
+
+    ``pending`` is used while the tool is still running (progressive tense),
+    and ``success`` is used once the tool completes (past tense).
+    """
+    if phase == "pending":
+        if tool_name in ("delete_file", "delete_lines"):
+            return "Deleting"
+        if tool_name == "write_file":
+            return "Creating" if is_new_file else "Writing"
+        if tool_name in ("edit_file", "edit_file_lines"):
+            return "Editing"
+        if tool_name == "insert_lines":
+            return "Inserting"
+        if tool_name == "apply_diff":
+            return "Patching"
+        return "Changing"
+
     if tool_name in ("delete_file", "delete_lines"):
         return "Deleted"
     if tool_name == "write_file":
@@ -445,9 +769,9 @@ def file_change_label(tool_name: str, *, is_new_file: bool = False) -> str:
 
 
 def file_change_label_from_preview_data(tool_name: str, data: dict[str, Any]) -> str:
-    """Derive a preview header label from renderer-built widget data."""
+    """Derive an in-progress preview header label from renderer-built data."""
     is_new = bool(data.get("is_new_file")) if tool_name == "write_file" else False
-    return file_change_label(tool_name, is_new_file=is_new)
+    return file_change_label(tool_name, is_new_file=is_new, phase="pending")
 
 
 def file_change_action_label(record: FileOperationRecord) -> str:

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/runtime/transport/session.py

@@ -215,6 +215,7 @@ class TuiDaemonSession:
         preferred_subagent: str | None = None,
         model: str | None = None,
         model_params: dict[str, Any] | None = None,
+        router_profile: str | None = None,
         attachments: list[dict[str, str]] | None = None,
         clarification_mode: str | None = None,
         clarification_answer: bool = False,
@@ -231,6 +232,7 @@ class TuiDaemonSession:
             preferred_subagent=preferred_subagent,
             model=model,
             model_params=model_params,
+            router_profile=router_profile,
             attachments=attachments,
             clarification_mode=clarification_mode,
             clarification_answer=clarification_answer,

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/tui/_cli_context.py

@@ -25,3 +25,6 @@ class CLIContext(TypedDict, total=False):
     model_params: dict[str, Any]
     """Invocation params (e.g. `temperature`, `max_tokens`) to merge
     into `model_settings`."""
+
+    router_profile: str | None
+    """Named ``router_profiles`` entry for chat-role overlay this turn."""

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/tui/app/_app.py

@@ -213,6 +213,8 @@ class SootheApp(
 
         self._model_params_override: dict[str, Any] | None = None
 
+        self._router_profile_override: str | None = None
+
         # RFC-622: clarification relay mode. Seeded from --mode flag (CLIConfig);
         # default to Auto so loops keep moving when the user hasn't opted in.
         self._clarification_mode: str = getattr(daemon_config, "clarification_mode", None) or "auto"

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/tui/app/_execution.py

@@ -542,12 +542,26 @@ class _ExecutionMixin:
                         banner.update_loop_id(new_loop_id)
                     except NoMatches:
                         pass
-                    self._clear_loop_model_override()
+                    self._clear_loop_session_overrides()
                     await self._mount_message(AppMessage(f"Started new loop: {new_loop_id}"))
         elif cmd == "/editor":
             await self.action_open_editor()
         elif cmd == "/resume":
             await self._show_loop_selector()
+        elif cmd == "/model-router" or cmd.startswith("/model-router "):
+            await self._mount_message(UserMessage(command))
+            arg = ""
+            if cmd.startswith("/model-router "):
+                arg = command.strip()[len("/model-router ") :].strip()
+            if not arg:
+                await self._show_router_profile_selector()
+            elif arg == "--clear":
+                self._clear_loop_router_profile_override()
+                await self._mount_message(
+                    AppMessage("Cleared loop model router; using config active profile.")
+                )
+            else:
+                await self._switch_router_profile(arg)
         elif cmd == "/update":
             await self._handle_update_command()
         elif cmd == "/auto-update":
@@ -767,11 +781,8 @@ class _ExecutionMixin:
                     return
             self._agent_running = True
 
-            # Cancel background event consumer so it doesn't compete for
-            # WebSocket reads with the active turn's iter_turn_chunks().
-            if self._bg_event_worker is not None:
-                self._bg_event_worker.cancel()
-                self._bg_event_worker = None
+            # Stop passive reads so active turn streaming has sole websocket access.
+            await self._stop_bg_event_worker(wait_timeout=2.0)
 
             if self._chat_input:
                 self._chat_input.set_cursor_active(active=False)
@@ -840,6 +851,7 @@ class _ExecutionMixin:
                         context=CLIContext(
                             model=self._model_override,
                             model_params=self._model_params_override or {},
+                            router_profile=self._router_profile_override,
                         ),
                         turn_stats=turn_stats,
                         skip_daemon_send_turn=skip_daemon_send_turn,

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/tui/app/_history.py

@@ -40,6 +40,20 @@ logger = logging.getLogger(__name__)
 class _HistoryMixin:
     """History conversion, loading, and daemon WebSocket event consumption."""
 
+    async def _stop_bg_event_worker(self, *, wait_timeout: float = 2.0) -> None:
+        """Cancel and await the passive daemon event worker, if running.
+
+        This keeps loop re-bootstrap and active turns from racing with an old
+        background reader on the same websocket.
+        """
+        worker = getattr(self, "_bg_event_worker", None)
+        if worker is None:
+            return
+        worker.cancel()
+        with suppress(Exception):
+            await asyncio.wait_for(worker.wait(), timeout=wait_timeout)
+        self._bg_event_worker = None
+
     # ------------------------------------------------------------------
     # Binder delegation (RFC-413).
     # Pure logic lives in `soothe_sdk.display.card_binder`; these wrappers

{soothe_cli-0.7.16 → soothe_cli-0.7.17}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -47,14 +47,14 @@ class _MessagesMixin:
         """Show queue interaction tips on the most recently queued goal only."""
         if not self._queued_widgets:
             return
-        tip_index = -1
+        tip_index: int | None = None
         if self._pending_messages and self._pending_messages[-1].mode == "normal":
             pending_tail_index = len(self._pending_messages) - 1
             if pending_tail_index < len(self._queued_widgets):
                 tip_index = pending_tail_index
         for index, widget in enumerate(self._queued_widgets):
             with suppress(Exception):
-                widget.set_show_queue_tips(index == tip_index if tip_index >= 0 else False)
+                widget.set_show_queue_tips(tip_index is not None and index == tip_index)
 
     def _has_pending_chat_input(self) -> bool:
         """Return whether chat input has draft content that should be preserved."""
@@ -493,7 +493,7 @@ class _MessagesMixin:
         """Immediately stop in-flight step/goal UI when the user interrupts a turn.
 
         Daemon cancel and worker teardown can take several seconds; without an
-        eager UI pass the thinking spinner and goal-tree running rows stay live.
+        eager UI pass the thinking spinner and plan running status stay live.
         """
         label = message or self._INTERRUPT_UI_MESSAGE
         adapter = getattr(self, "_ui_adapter", None)
@@ -522,7 +522,7 @@ class _MessagesMixin:
         """Stop in-flight UI and request daemon-side cancel.
 
         UI teardown runs first so Ctrl+C does not leave the thinking spinner or
-        goal-tree running rows active while the daemon winds down (which can take
+        plan running status active while the daemon winds down (which can take
         several seconds on long execute steps).
 
         Args: