@scemoon/cdh 1.0.0 → 1.0.3

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

package/onecode/agent/tools/task_tools.py

@@ -1,249 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from onecode.agent.tools.protocol import ToolResult
-from onecode.agent.tools.registry import ToolSpec
-
-
-class TaskCreateTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TaskCreate",
-            description="Create a fine-grained task (1-3 tool calls each). For large work, split into multiple smaller tasks with dependencies. Returns task id.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "subject": {"type": "string", "description": "Short, action-oriented title (verb + noun, e.g. 'Create User model')"},
-                    "description": {"type": "string", "description": "What needs to be done + acceptance criteria"},
-                    "activeForm": {"type": "string", "description": "Active form description"},
-                    "metadata": {"type": "object", "description": 'Optional metadata. Supports priority (high/medium/low) and effort (small/medium/large)'},
-                },
-                "required": ["subject", "description"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        task = self._tm.create_task(
-            subject=tool_input.get("subject", ""),
-            description=tool_input.get("description", ""),
-            active_form=tool_input.get("activeForm", ""),
-            metadata=tool_input.get("metadata"),
-        )
-        return ToolResult(name="TaskCreate", output={"task": {"id": task["id"], "subject": task["subject"]}})
-
-
-
-class TaskGetTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TaskGet",
-            description="Retrieve a task by ID.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "taskId": {"type": "string", "description": "Task id to retrieve"},
-                },
-                "required": ["taskId"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        task_id = tool_input.get("taskId", "")
-        task = self._tm.get_task(task_id)
-        if task is None:
-            return ToolResult(name="TaskGet", output={"task": None})
-        info = {k: task[k] for k in ("id", "subject", "description", "status", "blocks", "blockedBy")}
-        return ToolResult(name="TaskGet", output={"task": info})
-
-
-
-class TaskListTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TaskList",
-            description="List all tasks with their current status and dependencies.",
-            input_schema={"type": "object", "properties": {}, "required": []},
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        tasks = self._tm.list_tasks()
-        if not tasks:
-            return ToolResult(name="TaskList", output={"tasks": []})
-        summaries = []
-        for t in tasks:
-            s = {"id": t["id"], "subject": t["subject"], "status": t["status"]}
-            if t.get("owner"):
-                s["owner"] = t["owner"]
-            s["blockedBy"] = list(t.get("blockedBy") or [])
-            summaries.append(s)
-        return ToolResult(name="TaskList", output={"tasks": summaries})
-
-
-
-class TaskUpdateTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TaskUpdate",
-            description="Update a task: subject, description, status, owner, dependencies, output.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "taskId": {"type": "string", "description": "Task id to update"},
-                    "subject": {"type": "string"},
-                    "description": {"type": "string"},
-                    "activeForm": {"type": "string"},
-                    "status": {"type": "string", "description": "pending|in_progress|completed|deleted"},
-                    "owner": {"type": "string"},
-                    "addBlocks": {"type": "array", "items": {"type": "string"}, "description": "Task IDs this task blocks"},
-                    "addBlockedBy": {"type": "array", "items": {"type": "string"}, "description": "Task IDs that block this"},
-                    "metadata": {"type": "object"},
-                    "output": {"type": "string", "description": "Key results to pass to downstream tasks"},
-                },
-                "required": ["taskId"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        task_id = tool_input.get("taskId", "")
-        updates = {k: v for k, v in tool_input.items() if k != "taskId" and v is not None}
-        if "subject" not in updates and "title" in updates:
-            updates["subject"] = updates.pop("title")
-        if "addBlocks" not in updates and "blocks" in updates and isinstance(updates.get("blocks"), list):
-            updates["addBlocks"] = updates.pop("blocks")
-        result = self._tm.update_task(task_id, **updates)
-        if result is None:
-            return ToolResult(name="TaskUpdate", output={"success": False, "taskId": task_id, "error": "Task not found"}, is_error=True)
-        if result.get("deleted"):
-            return ToolResult(name="TaskUpdate", output={"success": True, "taskId": task_id, "updatedFields": ["deleted"]})
-        return ToolResult(name="TaskUpdate", output={"success": True, "taskId": task_id, "task": {"id": result["id"], "subject": result["subject"], "status": result["status"]}})
-
-
-
-class TaskOutputTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TaskOutput",
-            description="Get output for a task.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "task_id": {"type": "string", "description": "Task id to get output for"},
-                },
-                "required": ["task_id"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        task_id = tool_input.get("task_id", "")
-        result = self._tm.get_task_output(task_id)
-        return ToolResult(name="TaskOutput", output=result)
-
-
-
-class TaskStopTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TaskStop",
-            description="Stop/cancel a running task.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "task_id": {"type": "string", "description": "Task id to stop"},
-                },
-                "required": ["task_id"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        task_id = tool_input.get("task_id", "")
-        result = self._tm.update_task(task_id, status="completed")
-        if result is None:
-            return ToolResult(name="TaskStop", output={"success": False, "stopped": False, "error": "Task not found"}, is_error=True)
-        if result.get("deleted"):
-            return ToolResult(name="TaskStop", output={"success": True, "stopped": True, "task_id": task_id})
-        return ToolResult(name="TaskStop", output={"success": True, "stopped": True, "task_id": task_id})
-
-
-
-class TodoCreateTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoCreate",
-            description="Create a todo item. Returns todo id.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "text": {"type": "string", "description": "Todo item text"},
-                },
-                "required": ["text"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        text = tool_input.get("text", "")
-        todo_id = self._tm.add_todo(text)
-        return ToolResult(name="TodoCreate", output={"id": todo_id, "text": text})
-
-
-
-class TodoListTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoList",
-            description="List all todo items.",
-            input_schema={"type": "object", "properties": {}, "required": []},
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todos = self._tm.list_todos()
-        return ToolResult(name="TodoList", output=todos)
-
-
-
-class TodoCompleteTool:
-    def __init__(self, task_manager):
-        self._tm = task_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoComplete",
-            description="Mark a todo as completed.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "todo_id": {"type": "string", "description": "Todo id to complete"},
-                },
-                "required": ["todo_id"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_id = tool_input.get("todo_id", tool_input.get("id", ""))
-        ok = self._tm.complete_todo(str(todo_id))
-        return ToolResult(name="TodoComplete", output={"success": ok, "todo_id": todo_id}, is_error=not ok)
-