@scemoon/cdh 1.0.4 → 1.0.6

package/tui/widgets/subagent.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
-from typing import ClassVar
+import logging
+from collections.abc import Callable, Coroutine
+from typing import Any
 
-from textual import containers
+from textual import containers, events
 from textual.app import ComposeResult
-from textual.binding import Binding, BindingType
 from textual.content import Content
 from textual.reactive import var
 from textual.widgets import Static
 
-from tui.protocol import ExpandProtocol
+_sa_logger = logging.getLogger("tui.widgets.subagent")
 
 
 class SubAgentHeader(Static):
@@ -23,11 +24,9 @@ class SubAgentHeader(Static):
 
 
 class SubAgent(containers.VerticalGroup, can_focus=True):
-    """Sub-agent compact view — animated header + latest line with ctrl+x hint.
+    """Sub-agent view — header + dynamically updated latest line.
 
-    During streaming: header shows a spinner + latest line updates live.
-    After completion: header shows static marker.
-    Ctrl+X to open full-screen SubAgentScreen with full structured output.
+    Ctrl+N opens the full-screen SubAgentScreen.
     """
 
     DEFAULT_CLASSES = "block"
@@ -35,60 +34,46 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
     HELP = """
 ## Sub-agent
 
-- **ctrl+x** Open full-screen output
-- **up/down** Scroll (if content overflows)
+- **ctrl+n / click** Open full-screen output
 """
 
-    BINDINGS: ClassVar[list[BindingType]] = [
-        Binding("ctrl+x", "toggle", "Full screen", show=False, priority=True),
-    ]
-
-    ALLOW_MAXIMIZE = True
-
     DEFAULT_CSS = """
     SubAgent {
         height: auto;
         width: 1fr;
         min-height: 2;
-        padding: 0 1;
-        border-left: thick $secondary;
-        background: $surface-darken-1;
+        border-left: tall $secondary;
 
         SubAgentHeader {
             color: $text-secondary;
             text-style: bold;
+            padding: 0 1;
+        }
+
+        #subagent-latest {
+            padding: 0 0 0 2;
         }
 
         &.-status-running {
-            border-left: thick $warning;
-            background: $boost;
+            border-left: tall $warning;
             SubAgentHeader {
                 color: $warning;
                 text-style: bold italic;
             }
-            #subagent-latest {
-                color: $text;
-            }
         }
 
         &.-status-completed {
-            border-left: thick $success;
+            border-left: tall $success;
             SubAgentHeader {
                 color: $success;
             }
-            #subagent-latest {
-                color: $text-muted;
-            }
         }
 
         &.-status-failed {
-            border-left: thick $error;
+            border-left: tall $error;
             SubAgentHeader {
                 color: $error;
             }
-            #subagent-latest {
-                color: $error;
-            }
         }
     }
     """
@@ -115,10 +100,20 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
         self._error = ""
         self._mounted = False
         self._spin_timer = None
+        # Single handler set by SubAgentScreen for real-time event delivery
+        self._screen_handler: Callable[[str, Any], Coroutine[Any, Any, None]] | None = None
+        # Tool calls invoked *inside* this subagent (tracked for SubAgentScreen)
+        self._tool_calls: dict = {}
+        self._tool_order: list[str] = []
+        # Ordered event queue for chronological rendering (used by SubAgentScreen)
+        self._events: list = []
+        # Diagnostics counters (for log correlation)
+        self._chunk_count_log: int = 0
+        self._byte_count_log: int = 0
 
     def compose(self) -> ComposeResult:
         self.set_class(True, f"-status-{self._status}")
-        yield SubAgentHeader(self._header_text(), id="subagent-header")
+        yield SubAgentHeader(self._header_text(), id="subagent-header", markup=False)
         yield Static(self._latest_content, id="subagent-latest")
 
     def on_mount(self) -> None:
@@ -147,6 +142,8 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
         if _new != "running":
             self._stop_spinner()
 
+    # ── Refresh helpers ──
+
     def _refresh(self) -> None:
         if not self._mounted:
             return
@@ -155,7 +152,6 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
             if self._status != "running":
                 self.set_class(False, "-status-running")
             self.query_one("#subagent-header", SubAgentHeader).update(self._header_text())
-            self.query_one("#subagent-latest", Static).update(self._latest_content)
         except Exception:
             pass
 
@@ -167,25 +163,40 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
         except Exception:
             pass
 
-    def _header_text(self) -> str:
-        label = self.agent_type
-        status_tag = self._status_label()
+    # ── Header content (aligned with ToolCall style) ──
+
+    def _header_text(self) -> Content:
+        parts = [
+            Content.from_markup(f"🧠 Subagent ({self.agent_type})"),
+        ]
+        if self.prompt:
+            p = self.prompt.replace("\n", " ").strip()
+            if len(p) > 55:
+                p = p[:55] + "…"
+            parts.append(Content.from_markup(f"  [$text-muted]{p}[/]"))
         if self._status == "running":
             spin = self.SPINNER_FRAMES[self.spinner_frame]
-            return f"{spin} @ {label} [{status_tag}]"
+            parts.append(Content.from_markup(f" [$text-warning]{spin}"))
         elif self._status == "completed":
-            return f"✓ @ {label} [{status_tag}]"
+            parts.append(Content.from_markup(" [$success]✔"))
         elif self._status == "failed":
-            return f"✗ @ {label} [{status_tag}]"
-        return f"@ {label} [{status_tag}]"
+            from tui.pill import pill
+            tag = f": {self._error[:40]}" if self._error else ""
+            parts.append(Content.assemble(" ", pill(f"failed{tag}", "$error-muted", "$error")))
+        return Content.assemble(*parts)
+
+    # ── Preview line (shown when collapsed) ──
 
     @property
     def _latest_content(self) -> Content:
         text = (self.latest_line or "").strip()
-        hint = Content.from_markup("  [$text-muted]ctrl+x 展开查看")
         if text:
-            return Content.assemble(text, hint)
-        return Content.from_markup("[$text-muted]⏳ 等待输出…  ctrl+x 展开查看")
+            return Content.assemble(
+                Content(text),
+                Content("  "),
+                Content.from_markup("[$text-muted]ctrl+n / 点击打开全屏[/]"),
+            )
+        return Content.from_markup("[$text-muted]⏳ 等待输出…  (ctrl+n / 点击打开全屏)[/]")
 
     def _status_label(self) -> str:
         if self._status == "running":
@@ -206,15 +217,45 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
                 return line
         return ""
 
+    # ── Streaming updates ──
+
     def append_chunk(self, text: str) -> None:
         self._chunks.append(text)
+        self._events.append(("text", text))
+        self._chunk_count_log += 1
+        self._byte_count_log += len(text or "")
         self.latest_line = self._update_latest_line()
         self._refresh_latest()
+        if self._screen_handler is not None:
+            self.run_worker(self._screen_handler("text", text), exit_on_error=False)
 
     def append_thinking(self, text: str) -> None:
         self._thinking_chunks.append(text)
+        self._events.append(("thinking", text))
+        if self._screen_handler is not None:
+            self.run_worker(self._screen_handler("thinking", text), exit_on_error=False)
+
+    async def add_or_update_tool_call(self, tool_id: str, tool_call) -> None:
+        """Track a tool call so the full-screen SubAgentScreen can display it."""
+        self._tool_calls[tool_id] = tool_call
+        if tool_id not in self._tool_order:
+            self._tool_order.append(tool_id)
+        self._events.append(("tool", (tool_id, tool_call)))
+        # Show the current tool name as the inline preview line.
+        title = tool_call.get("title", "") if isinstance(tool_call, dict) else ""
+        if title:
+            self.latest_line = title
+            self._refresh_latest()
+        if self._screen_handler is not None:
+            self.run_worker(self._screen_handler("tool", (tool_id, tool_call)), exit_on_error=False)
 
     def complete(self, status: str = "completed", error: str = "") -> None:
+        _sa_logger.debug(
+            "[WIDGET-SUBagent] complete id=%s status=%s err=%r chunks=%d bytes=%d "
+            "was_completed=%s",
+            self.id, status, (error or "")[:80], self._chunk_count_log,
+            self._byte_count_log, self._completed,
+        )
         if self._completed:
             return
         self._completed = True
@@ -226,6 +267,8 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
             self.latest_line = self._update_latest_line()
         self._stop_spinner()
         self._refresh()
+        if self._screen_handler is not None:
+            self.run_worker(self._screen_handler("complete", {"status": status, "error": error}), exit_on_error=False)
 
     def _refresh_latest(self) -> None:
         if not self._mounted:
@@ -235,19 +278,10 @@ class SubAgent(containers.VerticalGroup, can_focus=True):
         except Exception:
             pass
 
-    def can_expand(self) -> bool:
-        return True
-
-    def expand_block(self) -> None:
-        self.action_toggle()
-
-    def collapse_block(self) -> None:
-        pass
-
-    def is_block_expanded(self) -> bool:
-        return False
+    def on_click(self, _event: events.Click) -> None:
+        self.action_fullscreen()
 
-    def action_toggle(self) -> None:
-        """Ctrl+X: open full-screen view (works even while running)."""
+    def action_fullscreen(self) -> None:
+        """Ctrl+N / click: open full-screen view (works even while running)."""
         from tui.widgets.subagent_screen import SubAgentScreen
-        self.app.push_screen(SubAgentScreen(self))
+        self.app.push_screen(SubAgentScreen(self))