@scemoon/cdh 1.0.0 → 1.0.3

package/tui/widgets/modified_files.py

@@ -3,12 +3,37 @@ from __future__ import annotations
 from pathlib import Path
 import subprocess
 
+from textual import work
 from textual.app import ComposeResult
 from textual.reactive import reactive
+from textual.timer import Timer
 from textual.widgets import Static
 from textual import containers
 
 
+GIT_STATUS_TIMEOUT = 5.0
+GIT_STATUS_DEBOUNCE = 0.2
+
+NOT_A_REPO_TEXT = "Not a git repository"
+NO_CHANGES_TEXT = "No modified files"
+LOADING_TEXT = "Checking…"
+
+IGNORED_DIRS = frozenset(
+    {
+        ".venv",
+        ".git",
+        ".pytest_cache",
+        "__pycache__",
+        ".mypy_cache",
+        "node_modules",
+        ".uv-cache",
+        "dist",
+        "build",
+        ".idea",
+    }
+)
+
+
 class ModifiedFiles(containers.Vertical):
     DEFAULT_CSS = """
     ModifiedFiles {
@@ -40,11 +65,21 @@ class ModifiedFiles(containers.Vertical):
             color: $text-secondary;
             text-style: italic;
         }
+
+        .not-a-repo {
+            color: $text-secondary;
+            text-style: italic;
+        }
+
+        .-loading {
+            color: $text-secondary;
+            text-style: italic;
+        }
     }
     """
 
     path: reactive[Path | None] = reactive(None)
-    files: reactive[list[str]] = reactive([], recompose=True)
+    files: reactive[list[str]] = reactive(list, recompose=False)
 
     def __init__(
         self,
@@ -54,42 +89,139 @@ class ModifiedFiles(containers.Vertical):
         classes: str | None = None,
     ) -> None:
         super().__init__(name=name, id=id, classes=classes)
-        # Initial value is set via data_bind in main.py on_mount.
-        # Don't use set_reactive here — let _initialize_reactive trigger
-        # watch_path properly on first reactive access.
+        self._debounce_timer: Timer | None = None
+        self._status_kind: str = "no-changes"
+        self._status_text: str = NO_CHANGES_TEXT
+        self._file_widgets: list[Static] = []
+        self._initial_path: Path | None = path
+
+    def on_mount(self) -> None:
+        initial = self._initial_path
+        self._initial_path = None
+        if initial is not None:
+            self.path = initial
 
     def watch_path(self, path: Path | None) -> None:
-        """Run git status when path changes."""
+        """Schedule a (debounced, async) git status when path changes."""
+        self._cancel_debounce()
         if path is None:
-            self.files = []
+            self._show_status("no-changes", NO_CHANGES_TEXT)
+            self._clear_file_widgets()
             return
+        self._show_status("-loading", LOADING_TEXT)
+        self._schedule_run(path)
+
+    def refresh_files(self) -> None:
+        """Re-run git status manually (e.g. after file system changes)."""
+        if self.path is not None:
+            self._cancel_debounce()
+            self._show_status("-loading", LOADING_TEXT)
+            self._run_git_status(self.path)
+
+    def _schedule_run(self, path: Path) -> None:
+        timer = self.set_timer(
+            GIT_STATUS_DEBOUNCE,
+            lambda p=path: self._run_git_status(p),
+        )
+        self._debounce_timer = timer
+
+    def _cancel_debounce(self) -> None:
+        timer = self._debounce_timer
+        if timer is not None:
+            try:
+                timer.stop()
+            except Exception:
+                pass
+            self._debounce_timer = None
+
+    @work(exclusive=True, group="modified-files-git-status", thread=True)
+    def _run_git_status(self, path: Path) -> None:
+        """Worker entry: do the slow ``git status`` off the UI thread,
+        then marshal results back via ``app.call_from_thread``."""
+        app = self.app
+        outcome = self._do_git_status(path)
+        if outcome is None:
+            return
+        kind, text, lines = outcome
+        if lines is None:
+            app.call_from_thread(self._show_status, kind, text)
+            app.call_from_thread(self._clear_file_widgets)
+        else:
+            app.call_from_thread(self._render_lines, lines)
+
+    def _do_git_status(
+        self, path: Path
+    ) -> tuple[str, str, list[str] | None] | None:
+        """Pure helper for ``git status``. Returns
+        ``(kind, text, lines_or_None)`` for the UI to render, or ``None``
+        if the call should silently no-op (e.g. ignored path).
+        """
+        if any(part in IGNORED_DIRS for part in path.parts):
+            return ("not-a-repo", NOT_A_REPO_TEXT, None)
         try:
             result = subprocess.run(
                 ["git", "-C", str(path), "status", "--porcelain"],
                 capture_output=True,
                 text=True,
-                timeout=5,
+                timeout=GIT_STATUS_TIMEOUT,
             )
-            if result.returncode == 0:
-                self.files = [l for l in result.stdout.strip().split("\n") if l.strip()]
-            else:
-                self.files = []
-        except (subprocess.TimeoutExpired, FileNotFoundError):
-            self.files = []
-
-    def refresh_files(self) -> None:
-        """Re-run git status manually (e.g. after file system changes)."""
-        self.watch_path(self.path)
-
-    def compose(self) -> ComposeResult:
-        if not self.files:
-            yield Static("No modified files", classes="no-changes")
+        except subprocess.TimeoutExpired:
+            return ("no-changes", NO_CHANGES_TEXT, None)
+        except FileNotFoundError:
+            return ("not-a-repo", NOT_A_REPO_TEXT, None)
+        except Exception:
+            return ("no-changes", NO_CHANGES_TEXT, None)
+        if result.returncode != 0:
+            return ("not-a-repo", NOT_A_REPO_TEXT, None)
+        lines = [
+            line for line in result.stdout.splitlines() if line.strip()
+        ]
+        if not lines:
+            return ("no-changes", NO_CHANGES_TEXT, [])
+        return ("file-modified", "", lines)
+
+    def _render_lines(self, lines: list[str]) -> None:
+        self.files = list(lines)
+        if not lines:
+            self._show_status("no-changes", NO_CHANGES_TEXT)
+            self._clear_file_widgets()
             return
-        for line in self.files:
+        self._show_status("file-modified", "")
+        self._clear_file_widgets()
+        try:
+            header = self.query_one("#mf-status", Static)
+        except Exception:
+            return
+        for line in lines:
             status = line[:2]
             filepath = line[3:]
             cls = self._class_for_status(status)
-            yield Static(f" {filepath}", classes=cls)
+            widget = Static(f" {filepath}", classes=cls)
+            self._file_widgets.append(widget)
+            self.mount(widget, after=header)
+
+    def _show_status(self, kind: str, text: str) -> None:
+        self._status_kind = kind
+        self._status_text = text
+        try:
+            header = self.query_one("#mf-status", Static)
+        except Exception:
+            return
+        header.set_classes(kind)
+        header.update(text)
+        if kind != "file-modified":
+            self._clear_file_widgets()
+
+    def _clear_file_widgets(self) -> None:
+        for w in self._file_widgets:
+            try:
+                w.remove()
+            except Exception:
+                pass
+        self._file_widgets = []
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._status_text, classes=self._status_kind, id="mf-status")
 
     @staticmethod
     def _class_for_status(status: str) -> str:

package/tui/widgets/plan.py

@@ -186,6 +186,28 @@ class Plan(containers.Grid):
         return Content()
 
 
+def entries_from_dicts(raw_entries):
+    """Convert raw plan entries (dicts) into ``Plan.Entry`` dataclass instances.
+
+    Shared by ``MainScreen`` (sidebar) and ``Conversation`` (inline) so both
+    Plan widgets render the same data the same way. Filters entries with
+    empty content so the Plan widget never renders a blank row.
+    """
+    result = []
+    for entry in raw_entries:
+        content = (entry.get("content") or "").strip()
+        if not content:
+            continue
+        result.append(
+            Plan.Entry(
+                Content(content),
+                entry.get("priority", "medium"),
+                entry.get("status", "pending"),
+            )
+        )
+    return result
+
+
 if __name__ == "__main__":
     from textual.app import App
 

package/tui/widgets/project_directory_tree.py

@@ -42,26 +42,37 @@ This shows the files in your project directory.
         disabled: bool = False,
     ) -> None:
         self.path_filter: PathFilter | None = None
+        self._reload_lock = asyncio.Lock()
         path = Path(path).resolve() if isinstance(path, str) else path.resolve()
         super().__init__(path, name=name, id=id, classes=classes, disabled=disabled)
 
+    async def _update_path_filter(self) -> None:
+        if self.path is None:
+            self.path_filter = None
+            return
+        path = Path(self.path) if isinstance(self.path, str) else self.path
+        path = await asyncio.to_thread(path.resolve)
+        self.path_filter = await asyncio.to_thread(PathFilter.from_git_root, path)
+
     async def watch_path(self) -> None:
         """Watch for changes to the `path` of the directory tree.
 
         If the path is changed the directory tree will be repopulated using
         the new value as the root.
         """
-        has_cursor = self.cursor_node is not None
-        self.reset_node(self.root, str(self.path), DirEntry(self.PATH(self.path)))
-        await self.reload()
-        if has_cursor:
-            self.cursor_line = 0
-        self.scroll_to(0, 0, animate=False)
+        if self.path is None:
+            return
+        async with self._reload_lock:
+            has_cursor = self.cursor_node is not None
+            self.reset_node(self.root, str(self.path), DirEntry(self.PATH(self.path)))
+            await self._update_path_filter()
+            await self.reload()
+            if has_cursor:
+                self.cursor_line = 0
+            self.scroll_to(0, 0, animate=False)
 
     async def on_mount(self) -> None:
-        path = Path(self.path) if isinstance(self.path, str) else self.path
-        path = await asyncio.to_thread(path.resolve)
-        self.path_filter = await asyncio.to_thread(PathFilter.from_git_root, path)
+        await self._update_path_filter()
 
     def filter_paths(self, paths: Iterable[Path]) -> Iterable[Path]:
         """Filter the paths before adding them to the tree.
@@ -86,5 +97,6 @@ This shows the files in your project directory.
 
     @work
     async def action_refresh(self) -> None:
-        await self.reload()
+        async with self._reload_lock:
+            await self.reload()
         self.notify("Project directory has been refreshed", title="Directory Tree")

package/tui/widgets/project_grid_select.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 
+import yaml
 from textual.app import ComposeResult
 from textual import getters
 
@@ -9,6 +10,24 @@ from tui.widgets.project_summary import ProjectSummary
 from onecode.config import CLOUD_DEV_HARNESS_DIR
 
 
+def _read_project_path(pf: Path) -> str:
+    """Return the project directory path stored in ``pf``, or the
+    yaml/json file path as a fallback."""
+    try:
+        if pf.suffix == ".json":
+            import json
+
+            data = json.loads(pf.read_text(encoding="utf-8")) or {}
+        else:
+            data = yaml.safe_load(pf.read_text(encoding="utf-8")) or {}
+        path = data.get("path")
+        if isinstance(path, str) and path:
+            return path
+    except Exception:
+        pass
+    return str(pf)
+
+
 class ProjectGridSelect(GridSelect):
     FOCUS_ON_CLICK = True
     app: getters.app[A2TUIApp] = getters.app(A2TUIApp)
@@ -32,4 +51,7 @@ class ProjectGridSelect(GridSelect):
         projects_dir.mkdir(parents=True, exist_ok=True)
         project_files = list(projects_dir.glob("*.yaml")) + list(projects_dir.glob("*.json"))
         for pf in sorted(project_files):
-            yield ProjectSummary(pf.stem, str(pf), id=pf.stem)
+            yield ProjectSummary(pf.stem, _read_project_path(pf), id=pf.stem)
+
+    def refresh(self, **kwargs) -> None:
+        super().refresh(**kwargs)

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))