soothe-cli 0.5.4__tar.gz → 0.5.6__tar.gz

{soothe_cli-0.5.4 → soothe_cli-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.5.4
+Version: 0.5.6
 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.4 → soothe_cli-0.5.6}/src/soothe_cli/cli/execution/headless.py

@@ -59,7 +59,7 @@ def run_headless(
             import subprocess
 
             subprocess.Popen(
-                [sys.executable, "-m", "soothe.daemon", "--detached"],
+                [sys.executable, "-m", "soothe_daemon", "--detached"],
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
             )

{soothe_cli-0.5.4 → soothe_cli-0.5.6}/src/soothe_cli/tui/widgets/loading.py

@@ -137,7 +137,8 @@ class LoadingWidget(Static):
         now = monotonic()
         if self._turn_start_mono is None:
             self._turn_start_mono = now
-        self._animation_timer = self.set_interval(0.1, self._update_animation)
+        # Reduced from 0.1s (10fps) to 0.2s (5fps) to reduce UI thread contention
+        self._animation_timer = self.set_interval(0.2, self._update_animation)
 
     def on_unmount(self) -> None:
         """Stop the animation timer when the widget leaves the DOM."""
@@ -159,13 +160,20 @@ class LoadingWidget(Static):
             self._animation_timer = None
 
     def _update_animation(self) -> None:
-        """Update spinner and elapsed time."""
+        """Update spinner and elapsed time (optimized to reduce render overhead)."""
         if self._paused:
             return
 
+        # Skip update if widget is not visible on screen
+        if not self.is_on_screen:
+            return
+
         if self._spinner_widget:
             frame = self._spinner.next_frame()
-            self._spinner_widget.update(frame)
+            # Use refresh with layout=False to avoid expensive layout recalculation
+            self._spinner_widget._content = frame
+            self._spinner_widget._render_cache = None
+            self._spinner_widget.refresh(repaint=True, layout=False)
 
         if self._hint_widget and self._turn_start_mono is not None:
             now = monotonic()

{soothe_cli-0.5.4 → soothe_cli-0.5.6}/src/soothe_cli/tui/widgets/messages.py

@@ -59,7 +59,7 @@ _STEP_TOOL_PREVIEW_ROWS = STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD
 """Collapsed step/task activity preview shows this many rows (IG-402)."""
 
 _MAX_STEP_STAT_TOOL_KINDS = 4
-"""Max distinct tool display names in the step header before ``+N more``."""
+"""Max distinct tool display names in the running-line stats suffix before ``+N more``."""
 
 _RUNNING_SPINNER_INTERVAL_SECONDS = 0.2
 """Spinner/status animation cadence for running cards."""
@@ -711,6 +711,10 @@ class AssistantMessage(Vertical):
     }
     """
 
+    # Performance optimization: batch streaming updates to reduce render frequency
+    _STREAM_FLUSH_INTERVAL: float = 0.05  # 50ms batching for streaming
+    _VISIBILITY_REFRESH_INTERVAL: float = 0.1  # 100ms throttle for visibility refresh
+
     def __init__(self, content: str = "", **kwargs: Any) -> None:
         """Initialize an assistant message.
 
@@ -726,6 +730,11 @@ class AssistantMessage(Vertical):
         self._preview_widget: Static | None = None
         self._hint_widget: Static | None = None
 
+        # Batching buffer for streaming content
+        self._pending_buffer: str = ""
+        self._flush_timer: Timer | None = None
+        self._last_visibility_refresh: float = 0.0
+
     def compose(self) -> ComposeResult:  # noqa: PLR6301  # Textual widget method convention
         """Compose markdown body, plain preview, and expand hint."""
         from textual.widgets import Markdown
@@ -851,14 +860,50 @@ class AssistantMessage(Vertical):
         else:
             _show_timestamp_toast(self)
 
+    def _should_refresh_visibility(self) -> bool:
+        """Check if visibility refresh should run (throttled)."""
+        from time import monotonic
+
+        now = monotonic()
+        if now - self._last_visibility_refresh > self._VISIBILITY_REFRESH_INTERVAL:
+            self._last_visibility_refresh = now
+            return True
+        return False
+
+    async def _flush_pending_content(self) -> None:
+        """Flush buffered content to stream (batched update)."""
+        self._flush_timer = None
+        if not self._pending_buffer:
+            return
+
+        text = self._pending_buffer
+        self._pending_buffer = ""
+
+        stream = self._ensure_stream()
+        await stream.write(text)
+
+        # Throttle visibility refresh
+        if self._should_refresh_visibility():
+            self._refresh_body_visibility()
+
     async def append_content(self, text: str) -> None:
-        """Append content to the message (for streaming)."""
+        """Append content to the message (for streaming with batching).
+
+        Uses internal buffering to batch writes and reduce render frequency.
+        """
         if not text:
             return
+
+        # Accumulate content
         self._content += text
-        stream = self._ensure_stream()
-        self._refresh_body_visibility()
-        await stream.write(text)
+        self._pending_buffer += text
+
+        # Schedule batched flush if not already scheduled
+        if self._flush_timer is None:
+            self._flush_timer = self.set_timer(
+                self._STREAM_FLUSH_INTERVAL,
+                self._flush_pending_content,
+            )
 
     async def write_initial_content(self) -> None:
         """Write initial content from constructor and finalize the stream."""
@@ -869,6 +914,15 @@ class AssistantMessage(Vertical):
 
     async def stop_stream(self) -> None:
         """Stop the streaming and apply collapsed layout when appropriate."""
+        # Cancel any pending flush timer
+        if self._flush_timer is not None:
+            self._flush_timer.stop()
+            self._flush_timer = None
+
+        # Flush any remaining buffered content
+        if self._pending_buffer:
+            await self._flush_pending_content()
+
         if self._stream is not None:
             await self._stream.stop()
             self._stream = None
@@ -878,6 +932,7 @@ class AssistantMessage(Vertical):
         """Set the full message content (stops any active stream)."""
         await self.stop_stream()
         self._content = content
+        self._pending_buffer = ""  # Clear any pending buffer
         if self._markdown:
             await self._markdown.update(content)
         self._refresh_body_visibility()
@@ -2461,8 +2516,9 @@ class _StepToolRow:
 class CognitionStepMessage(Vertical):
     """Agent-loop act step card: aggregates main-agent tool calls (IG-402).
 
-    Header shows per-tool counts; body lists one CLI-style row per call. When
-    there are more than ``_STEP_TOOL_PREVIEW_ROWS`` rows, click first folds or
+    Header is the step description only; per-tool counts appear on the running
+    status line (and match the prior header format). Body lists one CLI-style row
+    per call. When there are more than ``_STEP_TOOL_PREVIEW_ROWS`` rows, click first folds or
     unfolds the tool list; otherwise click toggles whole-card collapse. When tool
     rows, subagent notes, and execute prose together exceed that same threshold,
     the card body auto-collapses until the user expands it (a new ``set_running``
@@ -2630,7 +2686,7 @@ class CognitionStepMessage(Vertical):
         return _assemble_card_header(
             self,
             "🚀 ",
-            f"{self._description}{self._stats_title_suffix()}",
+            self._description,
         )
 
     def compose(self) -> ComposeResult:
@@ -3169,7 +3225,8 @@ class CognitionStepMessage(Vertical):
         toggle_icon = ""
         if has_collapsible:
             toggle_icon = f" {g.expand if self._card_collapsed else g.collapse}"
-        line = f"{gutter}{frame} Running...{elapsed}{toggle_icon}"
+        stats_suffix = self._stats_title_suffix()
+        line = f"{gutter}{frame} Running...{elapsed}{stats_suffix}{toggle_icon}"
         self._status_widget.update(Content.styled(line, colors.cognition))
         now = monotonic()
         if any(r.phase == "running" for r in self._rows) and (