@scemoon/cdh 1.0.0 → 1.0.4

package/tui/widgets/question.py

@@ -247,7 +247,7 @@ class Question(containers.VerticalGroup, can_focus=True):
         self.options = ask.options
         self.selection = 0
         self.selected = False
-        self.refresh(recompose=True, layout=True)
+        self.refresh(recompose=True)
 
     def compose(self) -> ComposeResult:
 

package/tui/widgets/subagent.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+from typing import ClassVar
+
+from textual import containers
 from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.content import Content
 from textual.reactive import var
-from textual import containers
-from textual.widgets import Static, Markdown
+from textual.widgets import Static
 
-from tui.pill import pill
+from tui.protocol import ExpandProtocol
 
 
 class SubAgentHeader(Static):
@@ -18,70 +22,232 @@ class SubAgentHeader(Static):
     """
 
 
-class SubAgentContent(Markdown):
-    DEFAULT_CSS = """
-    SubAgentContent {
-        margin: 0 1 0 2;
-    }
-    """
+class SubAgent(containers.VerticalGroup, can_focus=True):
+    """Sub-agent compact view — animated header + latest line with ctrl+x hint.
 
+    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.
+    """
 
-class SubAgent(containers.VerticalGroup):
     DEFAULT_CLASSES = "block"
+
+    HELP = """
+## Sub-agent
+
+- **ctrl+x** Open full-screen output
+- **up/down** Scroll (if content overflows)
+"""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+x", "toggle", "Full screen", show=False, priority=True),
+    ]
+
+    ALLOW_MAXIMIZE = True
+
     DEFAULT_CSS = """
     SubAgent {
-        margin: 0 0 0 1;
         height: auto;
+        width: 1fr;
+        min-height: 2;
+        padding: 0 1;
+        border-left: thick $secondary;
+        background: $surface-darken-1;
+
         SubAgentHeader {
             color: $text-secondary;
+            text-style: bold;
+        }
+
+        &.-status-running {
+            border-left: thick $warning;
+            background: $boost;
+            SubAgentHeader {
+                color: $warning;
+                text-style: bold italic;
+            }
+            #subagent-latest {
+                color: $text;
+            }
         }
-        &.-status-running SubAgentHeader {
-            color: $text-warning;
-            text-style: italic;
+
+        &.-status-completed {
+            border-left: thick $success;
+            SubAgentHeader {
+                color: $success;
+            }
+            #subagent-latest {
+                color: $text-muted;
+            }
         }
-        &.-status-completed SubAgentHeader {
-            color: $text-success;
+
+        &.-status-failed {
+            border-left: thick $error;
+            SubAgentHeader {
+                color: $error;
+            }
+            #subagent-latest {
+                color: $error;
+            }
         }
     }
     """
 
-    agent_type: var[str] = var("")
     status: var[str] = var("running")
+    latest_line: var[str] = var("")
+    spinner_frame: var[int] = var(0)
+
+    SPINNER_FRAMES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
 
     def __init__(
         self,
         agent_type: str,
         tool_id: str | None = None,
+        prompt: str = "",
     ) -> None:
         super().__init__(id=tool_id)
         self.agent_type = agent_type
-        self.status = "running"
+        self.prompt = prompt
         self._chunks: list[str] = []
+        self._thinking_chunks: list[str] = []
+        self._completed = False
+        self._status = "running"
+        self._error = ""
+        self._mounted = False
+        self._spin_timer = None
 
     def compose(self) -> ComposeResult:
-        self.set_class(True, f"-status-{self.status}")
-        label = pill(self.agent_type, "$warning-muted", "$text-warning")
-        yield SubAgentHeader(
-            f"🧠 Sub‑agent: {self.agent_type} {label}",
-            markup=False,
-        )
-        yield SubAgentContent("")
+        self.set_class(True, f"-status-{self._status}")
+        yield SubAgentHeader(self._header_text(), id="subagent-header")
+        yield Static(self._latest_content, id="subagent-latest")
 
-    def append_chunk(self, text: str) -> None:
-        self._chunks.append(text)
+    def on_mount(self) -> None:
+        self._mounted = True
+        self.styles.height = "auto"
+        self.styles.min_height = 2
+        self._start_spinner()
+        self._refresh()
+
+    def _start_spinner(self) -> None:
+        if self._spin_timer is not None:
+            return
+        self._spin_timer = self.set_interval(0.1, self._tick_spinner)
+
+    def _stop_spinner(self) -> None:
+        if self._spin_timer is not None:
+            self._spin_timer.stop()
+            self._spin_timer = None
+
+    def _tick_spinner(self) -> None:
+        if self._status == "running":
+            self.spinner_frame = (self.spinner_frame + 1) % len(self.SPINNER_FRAMES)
+            self._refresh_header()
+
+    def watch_status(self, _old: str, _new: str) -> None:
+        if _new != "running":
+            self._stop_spinner()
+
+    def _refresh(self) -> None:
+        if not self._mounted:
+            return
         try:
-            content = self.query_one(SubAgentContent)
-            content.load("".join(self._chunks))
+            self.set_class(True, f"-status-{self._status}")
+            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
 
-    def complete(self) -> None:
-        self.status = "completed"
-        self.set_class(True, "-status-completed")
-        self.set_class(False, "-status-running")
+    def _refresh_header(self) -> None:
+        if not self._mounted:
+            return
         try:
-            self.query_one(SubAgentHeader).update(
-                f"🧠 Sub‑agent: {self.agent_type} — completed ✅"
-            )
+            self.query_one("#subagent-header", SubAgentHeader).update(self._header_text())
         except Exception:
             pass
+
+    def _header_text(self) -> str:
+        label = self.agent_type
+        status_tag = self._status_label()
+        if self._status == "running":
+            spin = self.SPINNER_FRAMES[self.spinner_frame]
+            return f"{spin} @ {label} [{status_tag}]"
+        elif self._status == "completed":
+            return f"✓ @ {label} [{status_tag}]"
+        elif self._status == "failed":
+            return f"✗ @ {label} [{status_tag}]"
+        return f"@ {label} [{status_tag}]"
+
+    @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 展开查看")
+
+    def _status_label(self) -> str:
+        if self._status == "running":
+            return "running"
+        elif self._status == "failed":
+            return f"failed{': ' + self._error[:40] if self._error else ''}"
+        return "completed"
+
+    def _update_latest_line(self) -> str:
+        MAX_LEN = 50
+        full = "".join(self._chunks)
+        lines = full.split("\n")
+        for line in reversed(lines):
+            line = line.strip()
+            if line:
+                if len(line) > MAX_LEN:
+                    return line[:MAX_LEN] + "..."
+                return line
+        return ""
+
+    def append_chunk(self, text: str) -> None:
+        self._chunks.append(text)
+        self.latest_line = self._update_latest_line()
+        self._refresh_latest()
+
+    def append_thinking(self, text: str) -> None:
+        self._thinking_chunks.append(text)
+
+    def complete(self, status: str = "completed", error: str = "") -> None:
+        if self._completed:
+            return
+        self._completed = True
+        self._status = status
+        self._error = error
+        if status == "failed":
+            self.latest_line = f"Failed: {error[:60]}" if error else "Failed"
+        else:
+            self.latest_line = self._update_latest_line()
+        self._stop_spinner()
+        self._refresh()
+
+    def _refresh_latest(self) -> None:
+        if not self._mounted:
+            return
+        try:
+            self.query_one("#subagent-latest", Static).update(self._latest_content)
+        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 action_toggle(self) -> None:
+        """Ctrl+X: open full-screen view (works even while running)."""
+        from tui.widgets.subagent_screen import SubAgentScreen
+        self.app.push_screen(SubAgentScreen(self))

package/tui/widgets/subagent_screen.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Header, Markdown, Static
+
+from tui.widgets.subagent import SubAgent
+
+
+class SubAgentScreen(Screen):
+    """Full-screen view of a SubAgent output.
+
+    Displays the complete structured output (SUMMARY/CHANGES/EVIDENCE/RISKS/BLOCKERS)
+    as Markdown.  Esc to close, Up/Down/PageUp/PageDown to scroll.
+    Streams live while the SubAgent is running via a refresh timer.
+    """
+
+    BINDINGS: list[BindingType] = [
+        Binding("escape", "app.pop_screen", "Back", priority=True),
+        Binding("up", "scroll_up", "Up", priority=True),
+        Binding("down", "scroll_down", "Down", priority=True),
+        Binding("pageup", "scroll_page_up", "Page Up", priority=True),
+        Binding("pagedown", "scroll_page_down", "Page Down", priority=True),
+        Binding("home", "scroll_home", "Home", priority=True),
+        Binding("end", "scroll_end", "End", priority=True),
+    ]
+
+    DEFAULT_CSS = """
+    SubAgentScreen {
+        align: center middle;
+
+        #subagent-screen-frame {
+            width: 95%;
+            max-width: 160;
+            height: 95%;
+            border: thick $primary;
+            background: $surface;
+        }
+
+        SubAgentScreenFooter {
+            dock: bottom;
+            height: 1;
+            padding: 0 1;
+            color: $text-muted;
+            background: $boost;
+        }
+
+        #subagent-full-content {
+            padding: 0 1;
+            height: 1fr;
+            overflow-y: auto;
+            scrollbar-gutter: stable;
+        }
+    }
+    """
+
+    def __init__(self, subagent: SubAgent) -> None:
+        super().__init__()
+        self.subagent = subagent
+        self._auto_follow = True
+        self._refresh_timer = None
+        self._last_content_hash: str = ""
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        with Vertical(id="subagent-screen-frame"):
+            yield Markdown(self._build_content(), id="subagent-full-content")
+        yield Static(
+            "[$text-muted]esc[/] 返回  "
+            "[$text-muted]↑↓[/] 滚动  "
+            "[$text-muted]pageup/pagedown[/] 翻页  "
+            "[$text-muted]end[/] 跟随最新",
+            id="subagent-screen-footer",
+        )
+
+    def on_mount(self) -> None:
+        self.title = "subagent"
+        self.sub_title = f"@{self.subagent.agent_type} [{self.subagent._status}]"
+        self._last_content_hash = self._content_signature()
+        self._refresh_content(scroll_to_end=True)
+        self._refresh_timer = self.set_interval(0.2, self._poll_subagent)
+
+    def on_unmount(self) -> None:
+        if self._refresh_timer is not None:
+            self._refresh_timer.stop()
+            self._refresh_timer = None
+
+    def _content_signature(self) -> str:
+        sa = self.subagent
+        return f"{sa._status}|{sa.spinner_frame}|{len(sa._chunks)}|{len(sa._thinking_chunks)}|{sa._error}"
+
+    def _poll_subagent(self) -> None:
+        sig = self._content_signature()
+        if sig != self._last_content_hash:
+            self._last_content_hash = sig
+            self._refresh_content(scroll_to_end=self._auto_follow)
+            self.sub_title = f"@{self.subagent.agent_type} [{self.subagent._status}]"
+            if self.subagent._status != "running" and self._refresh_timer is not None:
+                self._refresh_timer.stop()
+                self._refresh_timer = None
+
+    def _refresh_content(self, scroll_to_end: bool = False) -> None:
+        try:
+            md = self.query_one("#subagent-full-content", Markdown)
+            md.update(self._build_content())
+            if scroll_to_end:
+                self.call_after_refresh(md.scroll_end)
+        except Exception:
+            pass
+
+    def action_scroll_up(self) -> None:
+        self._auto_follow = False
+        try:
+            self.query_one("#subagent-full-content", Markdown).scroll_up()
+        except Exception:
+            pass
+
+    def action_scroll_down(self) -> None:
+        try:
+            md = self.query_one("#subagent-full-content", Markdown)
+            md.scroll_down()
+        except Exception:
+            pass
+
+    def action_scroll_page_up(self) -> None:
+        self._auto_follow = False
+        try:
+            self.query_one("#subagent-full-content", Markdown).scroll_page_up()
+        except Exception:
+            pass
+
+    def action_scroll_page_down(self) -> None:
+        try:
+            md = self.query_one("#subagent-full-content", Markdown)
+            md.scroll_page_down()
+        except Exception:
+            pass
+
+    def action_scroll_home(self) -> None:
+        self._auto_follow = False
+        try:
+            self.query_one("#subagent-full-content", Markdown).scroll_home()
+        except Exception:
+            pass
+
+    def action_scroll_end(self) -> None:
+        self._auto_follow = True
+        try:
+            self.query_one("#subagent-full-content", Markdown).scroll_end()
+        except Exception:
+            pass
+
+    def _build_content(self) -> str:
+        sa = self.subagent
+        parts: list[str] = []
+        parts.append(f"# @ {sa.agent_type}  [{sa._status}]\n")
+        if sa.prompt:
+            prompt_preview = sa.prompt if len(sa.prompt) <= 200 else sa.prompt[:200] + "..."
+            parts.append(
+                "\n## 任务\n\n"
+                f"> {prompt_preview}\n\n"
+                "---\n"
+            )
+        if sa._thinking_chunks:
+            parts.append("## 思考\n")
+            parts.append("".join(sa._thinking_chunks))
+            parts.append("\n\n---\n\n")
+        raw = "".join(sa._chunks)
+        if sa._status == "failed":
+            parts.append(
+                f"## ❌ Failed\n\n"
+                f"**Error:** {sa._error}\n\n"
+                "---\n\n"
+                "### Partial output\n\n"
+                f"```\n{(raw or '(none)')[:4000]}\n```"
+            )
+        elif raw:
+            parts.append("## 输出\n\n")
+            parts.append(raw)
+            if sa._status == "running":
+                parts.append("\n\n*…streaming*")
+        else:
+            parts.append("## 输出\n\n_(streaming…)_")
+        return "".join(parts)

package/tui/widgets/tool_call.py

@@ -207,17 +207,14 @@ class ToolCall(containers.VerticalGroup):
                 self.expanded = status in ("completed", "failed")
 
     _TOOL_ICONS: dict[str, str] = {
-        "Task": "🧠",
+        "Spawn": "🧠",
         "Agent": "🧠",
-        "TaskCreate": "📋",
-        "TaskGet": "📋",
-        "TaskList": "📋",
-        "TaskUpdate": "📋",
-        "TaskOutput": "📋",
-        "TaskStop": "📋",
         "TodoCreate": "📋",
+        "TodoGet": "📋",
         "TodoList": "📋",
-        "TodoComplete": "📋",
+        "TodoUpdate": "📋",
+        "TodoOutput": "📋",
+        "TodoStop": "📋",
     }
 
     @property