@scemoon/cdh 1.0.0 → 1.0.4

package/tui/widgets/conversation.py

@@ -267,6 +267,16 @@ This is a view of your conversation with the agent.
         pass
 
 
+def _plan_entries_from_dicts(raw_entries):
+    """Deprecated thin wrapper around the shared ``entries_from_dicts`` helper.
+
+    Kept for backwards compatibility with any external callers; new code
+    should import ``entries_from_dicts`` directly from ``tui.widgets.plan``.
+    """
+    from tui.widgets.plan import entries_from_dicts
+    return entries_from_dicts(raw_entries)
+
+
 class Conversation(containers.Vertical):
     """Holds the agent conversation (input, output, and various controls / information)."""
 
@@ -378,6 +388,7 @@ class Conversation(containers.Vertical):
         self._agent_thought: AgentThought | None = None
         self._replay: bool = False
         self._replay_buffer: list[dict] = []
+        self._active_subagents: dict = {}
         self._last_escape_time: float = monotonic()
         self._agent_data = agent
         self._agent_session_id = agent_session_id
@@ -404,6 +415,7 @@ class Conversation(containers.Vertical):
 
         self._directory_changed = False
         self._directory_watcher: DirectoryWatcher | None = None
+        self._suppress_directory_changed = False
 
         self._initial_prompt = initial_prompt
 
@@ -559,7 +571,34 @@ class Conversation(containers.Vertical):
     @on(DirectoryChanged)
     def on_directory_changed(self, event: DirectoryChanged) -> None:
         event.stop()
-        self.post_message(messages.ProjectDirectoryUpdated())
+        self._directory_changed = True
+        if self._suppress_directory_changed:
+            return
+        self._suppress_directory_changed = True
+        self.post_message(messages.ProjectDirectoryUpdated(project_dir=self.app.project_dir))
+        self.set_timer(0.5, self._release_directory_changed_suppress)
+
+    def _release_directory_changed_suppress(self) -> None:
+        self._suppress_directory_changed = False
+
+    def directory_watcher_swap(self, project_path: Path) -> None:
+        """Stop the current DirectoryWatcher (if any) and start a new one
+        rooted at *project_path*.
+
+        Used by ``MainScreen`` when the user switches projects so we don't
+        keep receiving events for the old tree.
+        """
+        if self._directory_watcher is not None:
+            self._directory_watcher.stop()
+            self._directory_watcher = None
+        if project_path is None:
+            return
+        try:
+            watcher = DirectoryWatcher(project_path, self)
+        except Exception:
+            return
+        watcher.start()
+        self._directory_watcher = watcher
 
     @on(Terminal.Finalized)
     def on_terminal_finalized(self, event: Terminal.Finalized) -> None:
@@ -572,7 +611,7 @@ class Conversation(containers.Vertical):
         if self._directory_changed or not self.is_watching_directory:
             self.prompt.project_directory_updated()
             self._directory_changed = False
-            self.post_message(messages.ProjectDirectoryUpdated())
+            self.post_message(messages.ProjectDirectoryUpdated(project_dir=self.app.project_dir))
 
     @on(Terminal.LongRunning)
     def on_terminal_long_running(self, event: Terminal.LongRunning) -> None:
@@ -934,7 +973,7 @@ class Conversation(containers.Vertical):
 
         if self._directory_changed or not self.is_watching_directory:
             self._directory_changed = False
-            self.post_message(messages.ProjectDirectoryUpdated())
+            self.post_message(messages.ProjectDirectoryUpdated(project_dir=self.app.project_dir))
             self.prompt.project_directory_updated()
 
         self._turn_count += 1
@@ -1102,12 +1141,12 @@ class Conversation(containers.Vertical):
                 case "plan":
                     current_thought = None
                     self.new_block()
-                    widgets.append(Plan(entry["entries"]))
+                    widgets.append(Plan(_plan_entries_from_dicts(entry["entries"])))
 
                 case "subagent_start":
                     current_thought = None
                     self.new_block()
-                    sa = SubAgent(entry["agent_type"], tool_id=entry["id"])
+                    sa = SubAgent(entry["agent_type"], tool_id=entry["id"], prompt=entry.get("prompt", ""))
                     created_subagents[entry["id"]] = sa
                     widgets.append(sa)
 
@@ -1116,10 +1155,18 @@ class Conversation(containers.Vertical):
                     if sa is not None:
                         sa.append_chunk(entry["text"])
 
+                case "subagent_thinking":
+                    sa = created_subagents.get(entry["id"])
+                    if sa is not None:
+                        sa.append_thinking(entry["text"])
+
                 case "subagent_end":
                     sa = created_subagents.get(entry["id"])
                     if sa is not None:
-                        sa.complete()
+                        sa.complete(
+                            entry.get("status", "completed"),
+                            entry.get("error", ""),
+                        )
 
                 case "ask_user":
                     current_thought = None
@@ -1192,14 +1239,7 @@ class Conversation(containers.Vertical):
             return
         from tui.widgets.plan import Plan
 
-        entries = [
-            Plan.Entry(
-                Content(entry["content"]),
-                entry.get("priority", "medium"),
-                entry.get("status", "pending"),
-            )
-            for entry in message.entries
-        ]
+        entries = _plan_entries_from_dicts(message.entries)
 
         # Look up any existing Plan widget anywhere in the conversation
         # tree — checking only ``children[-1]`` would create duplicates if
@@ -1310,46 +1350,62 @@ class Conversation(containers.Vertical):
 
         message.stop()
         if self._replay:
-            self._replay_buffer.append({"kind": "subagent_start", "agent_type": message.agent_type, "id": message.subagent_id})
+            self._replay_buffer.append({"kind": "subagent_start", "agent_type": message.agent_type, "id": message.subagent_id, "prompt": message.prompt})
             return
-        sa = SubAgent(message.agent_type, tool_id=message.subagent_id)
+        sa = SubAgent(message.agent_type, tool_id=message.subagent_id, prompt=message.prompt)
+        self._active_subagents[message.subagent_id] = sa
         await self.post(sa, new_block=True)
 
-    @on(acp_messages.SubAgentChunk)
-    async def on_acp_subagent_chunk(self, message: acp_messages.SubAgentChunk):
+    def _get_subagent(self, subagent_id: str):
         from tui.widgets.subagent import SubAgent
 
+        sa = self._active_subagents.get(subagent_id)
+        if sa is not None:
+            return sa
+        try:
+            return self.contents.get_child_by_id(subagent_id, SubAgent)
+        except NoMatches:
+            return None
+
+    @on(acp_messages.SubAgentChunk)
+    async def on_acp_subagent_chunk(self, message: acp_messages.SubAgentChunk):
         message.stop()
         if self._replay:
             self._replay_buffer.append({"kind": "subagent_chunk", "id": message.subagent_id, "text": message.text})
             return
-        try:
-            sa: SubAgent | None = self.contents.get_child_by_id(
-                message.subagent_id, SubAgent
-            )
-        except NoMatches:
+        sa = self._get_subagent(message.subagent_id)
+        if sa is not None:
+            sa.append_chunk(message.text)
+
+    @on(acp_messages.SubAgentThinking)
+    async def on_acp_subagent_thinking(self, message: acp_messages.SubAgentThinking):
+        message.stop()
+        if self._replay:
+            self._replay_buffer.append({
+                "kind": "subagent_thinking",
+                "id": message.subagent_id,
+                "text": message.text,
+            })
             return
-        else:
-            if sa is not None:
-                sa.append_chunk(message.text)
+        sa = self._get_subagent(message.subagent_id)
+        if sa is not None:
+            sa.append_thinking(message.text)
 
     @on(acp_messages.SubAgentEnd)
     async def on_acp_subagent_end(self, message: acp_messages.SubAgentEnd):
-        from tui.widgets.subagent import SubAgent
-
         message.stop()
         if self._replay:
-            self._replay_buffer.append({"kind": "subagent_end", "id": message.subagent_id})
-            return
-        try:
-            sa: SubAgent | None = self.contents.get_child_by_id(
-                message.subagent_id, SubAgent
-            )
-        except NoMatches:
+            self._replay_buffer.append({
+                "kind": "subagent_end",
+                "id": message.subagent_id,
+                "status": message.status,
+                "error": message.error,
+            })
             return
-        else:
-            if sa is not None:
-                sa.complete()
+        sa = self._get_subagent(message.subagent_id)
+        if sa is not None:
+            sa.complete(message.status, message.error)
+            self._active_subagents.pop(message.subagent_id, None)
 
     @on(acp_messages.AvailableCommandsUpdate)
     async def on_acp_available_commands_update(
@@ -1929,12 +1985,13 @@ class Conversation(containers.Vertical):
         self.cursor_offset = -1
         self.cursor.visible = False
         self.cursor.follow(None)
-        contents.refresh(layout=True)
+        contents.refresh()
 
         if prune_children:
             await contents.remove_children(prune_children)
 
-        self.call_later(self.window.anchor)
+        if self.window.scroll_y >= self.window.max_scroll_y:
+            self.call_later(self.window.anchor)
 
     async def new_terminal(self) -> Terminal:
         """Create a new interactive Terminal.
@@ -2401,7 +2458,7 @@ class Conversation(containers.Vertical):
             save_config(cfg)
             new_project_dir = Path(project_path) if project_path else Path.cwd()
             self.app.project_dir = new_project_dir
-            self.post_message(messages.ProjectDirectoryUpdated())
+            self.post_message(messages.ProjectDirectoryUpdated(project_dir=new_project_dir))
             self.flash(f"Switched to project: {name}", style="success")
             return True
         elif sub_cmd == "new":
@@ -2427,7 +2484,7 @@ class Conversation(containers.Vertical):
             cfg.current_project_path = str(ws)
             save_config(cfg)
             self.app.project_dir = ws
-            self.post_message(messages.ProjectDirectoryUpdated())
+            self.post_message(messages.ProjectDirectoryUpdated(project_dir=ws))
             self.flash(f"Created and switched to project: {name}", style="success")
             return True
         else:

package/tui/widgets/modified_files.py

@@ -3,48 +3,74 @@ 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
 
 
-class ModifiedFiles(containers.Vertical):
-    DEFAULT_CSS = """
-    ModifiedFiles {
-        height: auto;
-        max-height: 15;
-        overflow-y: auto;
+CONTENT_WIDTH = 35
 
-        Static {
-            padding: 0 1;
-        }
+GIT_STATUS_TIMEOUT = 5.0
+GIT_STATUS_DEBOUNCE = 0.2
 
-        .file-added {
-            color: $text-success;
-        }
+NOT_A_REPO_TEXT = "Not a git repository"
+NO_CHANGES_TEXT = "No modified files"
+LOADING_TEXT = "Checking…"
 
-        .file-modified {
-            color: $text-warning;
-        }
+IGNORED_DIRS = frozenset(
+    {
+        ".venv",
+        ".git",
+        ".pytest_cache",
+        "__pycache__",
+        ".mypy_cache",
+        "node_modules",
+        ".uv-cache",
+        "dist",
+        "build",
+        ".idea",
+    }
+)
 
-        .file-deleted {
-            color: $text-error;
-        }
+STATUS_ICONS = {"?": "?", "M": "M", "A": "A", "D": "D", "R": "R", "C": "C"}
+STATUS_COLORS = {"?": "green", "M": "yellow", "A": "green", "D": "red", "R": "#888888", "C": "green"}
+DIFF_COLORS: dict[str, str] = {"add": "green", "del": "red", "mix": "yellow", "dim": "#555555"}
+
+
+def _status_info(raw: str) -> tuple[str, str]:
+    ch = raw.strip()[:1] or "M"
+    return STATUS_ICONS.get(ch, "M"), STATUS_COLORS.get(ch, "yellow")
+
+
+def _tag_color(added: int, deleted: int) -> str:
+    if added and deleted:
+        return DIFF_COLORS["mix"]
+    if added:
+        return DIFF_COLORS["add"]
+    if deleted:
+        return DIFF_COLORS["del"]
+    return DIFF_COLORS["dim"]
 
-        .file-renamed {
-            color: $text-secondary;
-        }
 
-        .no-changes {
-            color: $text-secondary;
-            text-style: italic;
+class ModifiedFiles(containers.Vertical):
+    DEFAULT_CSS = """
+    ModifiedFiles {
+        height: auto;
+        overflow-y: auto;
+        padding: 0 0 0 0;
+
+        #mf-files {
+            height: auto;
+            padding: 0 0 0 1;
         }
     }
     """
 
     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,53 +80,153 @@ 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._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."""
+        self._cancel_debounce()
         if path is None:
-            self.files = []
+            self._show_status("no-changes", NO_CHANGES_TEXT)
             return
+        self._show_status("-loading", LOADING_TEXT)
+        self._schedule_run(path)
+
+    def refresh_files(self) -> None:
+        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:
+        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)
+        else:
+            app.call_from_thread(self._render_lines, lines)
+
+    def _do_git_status(
+        self, path: Path
+    ) -> tuple[str, str, list[str] | None] | None:
+        if any(part in IGNORED_DIRS for part in path.parts):
+            return ("not-a-repo", NOT_A_REPO_TEXT, None)
         try:
-            result = subprocess.run(
+            status = subprocess.run(
                 ["git", "-C", str(path), "status", "--porcelain"],
-                capture_output=True,
-                text=True,
-                timeout=5,
+                capture_output=True, text=True,
+                timeout=GIT_STATUS_TIMEOUT,
             )
-            if result.returncode == 0:
-                self.files = [l for l in result.stdout.strip().split("\n") if l.strip()]
+        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 status.returncode != 0:
+            return ("not-a-repo", NOT_A_REPO_TEXT, None)
+
+        lines = [l for l in status.stdout.splitlines() if l.strip()]
+        if not lines:
+            return ("no-changes", NO_CHANGES_TEXT, ([], {}))
+
+        diffmap: dict[str, tuple[int, int]] = {}
+        for diff_cmd in (
+            ["git", "-C", str(path), "diff", "--numstat"],
+            ["git", "-C", str(path), "diff", "--cached", "--numstat"],
+        ):
+            try:
+                r = subprocess.run(
+                    diff_cmd, capture_output=True, text=True,
+                    timeout=GIT_STATUS_TIMEOUT,
+                )
+            except Exception:
+                continue
+            for dl in r.stdout.splitlines():
+                parts = dl.split("\t", 2)
+                if len(parts) == 3:
+                    added, deleted = parts[0], parts[1]
+                    if added != "-":
+                        a, d = int(added), int(deleted)
+                        fp = parts[2]
+                        prev_a, prev_d = diffmap.get(fp, (0, 0))
+                        diffmap[fp] = (prev_a + a, prev_d + d)
+
+        return ("file-modified", "", (lines, diffmap))
+
+    def _render_lines(self, data: tuple[list[str], dict[str, tuple[int, int]]]) -> None:
+        lines, diffmap = data
+        self.files = list(lines)
+        if not lines:
+            self._show_status("no-changes", NO_CHANGES_TEXT)
+            return
+        self._show_status("file-modified", "")
+
+        out: list[str] = []
+        for raw_line in lines:
+            filepath = raw_line[3:]
+            icon, sc = _status_info(raw_line[:2])
+
+            added, deleted = diffmap.get(filepath, (0, 0))
+            if "?" in raw_line[:2]:
+                tag = "new"
+                tc = DIFF_COLORS["dim"]
+            elif "D" in raw_line[:2]:
+                tag = "del"
+                tc = DIFF_COLORS["del"]
+            elif added or deleted:
+                tag = f"+{added}/-{deleted}"
+                tc = _tag_color(added, deleted)
             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)
+                tag = ""
+                tc = ""
+
+            tag_s = f" [{tc}]{tag}[/]" if tag else ""
+            tag_len = len(tag) + 1 if tag else 0
+            max_fn = CONTENT_WIDTH - 2 - tag_len
+            if max_fn < 3:
+                max_fn = 3
+            disp = filepath[:max_fn - 1] + "…" if len(filepath) > max_fn else filepath
+            pad = CONTENT_WIDTH - 2 - len(disp) - tag_len
+            pad_s = " " * pad if pad > 0 else ""
+            out.append(f"[{sc}]{icon} {disp}[/]{pad_s}{tag_s}")
+
+        files_widget = self.query_one("#mf-files", Static)
+        files_widget.update("\n".join(out))
+
+    def _show_status(self, kind: str, text: str) -> None:
+        self._status_kind = kind
+        self._status_text = text
+        status = self.query_one("#mf-status", Static)
+        status.update(text)
 
     def compose(self) -> ComposeResult:
-        if not self.files:
-            yield Static("No modified files", classes="no-changes")
-            return
-        for line in self.files:
-            status = line[:2]
-            filepath = line[3:]
-            cls = self._class_for_status(status)
-            yield Static(f" {filepath}", classes=cls)
-
-    @staticmethod
-    def _class_for_status(status: str) -> str:
-        if "?" in status:
-            return "file-added"
-        if "D" in status:
-            return "file-deleted"
-        if "A" in status or "C" in status:
-            return "file-added"
-        if "R" in status:
-            return "file-renamed"
-        if "M" in status:
-            return "file-modified"
-        return "file-modified"
+        yield Static(self._status_text, id="mf-status")
+        yield Static("", id="mf-files")

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)