@scemoon/cdh 1.0.4 → 1.0.6

package/tui/widgets/conversation.py

@@ -65,9 +65,10 @@ from tui.protocol import BlockProtocol, MenuProtocol, ExpandProtocol
 from tui.menus import MenuItem
 from tui.widgets.shell_terminal import ShellTerminal
 from tui.widgets.ask_user import AskUserWidget, AskUserSubmitted
+from tui.widgets.load_more import LoadMoreIndicator
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
+    from collections.abc import Callable
     from tui.acp.agent import Mode
     from tui.widgets.terminal import Terminal
     from tui.widgets.agent_response import AgentResponse
@@ -183,7 +184,12 @@ class Cursor(Static):
         self.blink_timer = self.set_interval(0.5, self._update_blink, pause=True)
 
     def _update_blink(self) -> None:
-        if self.query_ancestor(Window).has_focus and self.screen.is_active:
+        try:
+            window = self.query_ancestor(Window)
+        except NoMatches:
+            self.blink = True
+            return
+        if window.has_focus and self.screen.is_active:
             self.blink = not self.blink
         else:
             self.blink = False
@@ -263,9 +269,19 @@ This is a view of your conversation with the agent.
     BINDING_GROUP_TITLE = "View"
     BINDINGS = [Binding("end", "screen.focus_prompt", "Prompt")]
 
+    auto_follow: var[bool] = var(True)
+
     def update_node_styles(self, animate: bool = True) -> None:
         pass
 
+    def watch_scroll_y(self, old_value: float, new_value: float) -> None:
+        self.auto_follow = new_value >= self.max_scroll_y
+        super().watch_scroll_y(old_value, new_value)
+
+    def scroll_end_if_following(self, animate: bool = True) -> None:
+        if self.auto_follow:
+            self.scroll_end(animate=animate)
+
 
 def _plan_entries_from_dicts(raw_entries):
     """Deprecated thin wrapper around the shared ``entries_from_dicts`` helper.
@@ -316,6 +332,7 @@ class Conversation(containers.Vertical):
             "cancel",
             "Cancel",
             tooltip="Cancel agent's turn",
+            priority=True,
         ),
         Binding(
             "ctrl+f",
@@ -330,6 +347,12 @@ class Conversation(containers.Vertical):
             "Modes",
             tooltip="Open the mode switcher",
         ),
+        Binding(
+            "ctrl+n",
+            "fullscreen_block",
+            "Full screen",
+            tooltip="Open full-screen view of the cursor block",
+        ),
         Binding(
             "ctrl+c",
             "interrupt",
@@ -424,6 +447,12 @@ class Conversation(containers.Vertical):
         self._post_lock = asyncio.Lock()
         self._auto_named_session = False
 
+        self._total_messages: int = 0
+        self._visible_count: int = 0
+        self._loaded_up_to: int = 0
+        self._load_more_widget: LoadMoreIndicator | None = None
+        self._flush_append_at: int | None = None
+
     def update_title(self) -> None:
         """Update the screen title."""
         screen = self.screen
@@ -474,6 +503,7 @@ class Conversation(containers.Vertical):
         self.prompt.prompt_text_area.insert(" ")
 
     def watch_project_path(self, path: Path) -> None:
+        self.working_directory = str(path)
         self.post_message(messages.SessionUpdate(path=str(path)))
 
     async def watch_shell_history_index(self, previous_index: int, index: int) -> None:
@@ -721,6 +751,13 @@ class Conversation(containers.Vertical):
                 self.refresh_bindings()
                 self.call_after_refresh(self.cursor.follow, cursor_block)
 
+    async def action_fullscreen_block(self) -> None:
+        if (cursor_block := self.cursor_block) is not None:
+            fullscreen = getattr(cursor_block, "action_fullscreen", None)
+            if fullscreen:
+                fullscreen()
+                self.call_after_refresh(self.cursor.follow, cursor_block)
+
     async def post_agent_response(self, fragment: str = "") -> AgentResponse | None:
         """Get or create an agent response widget."""
         from tui.widgets.agent_response import AgentResponse
@@ -926,6 +963,9 @@ class Conversation(containers.Vertical):
             self._auto_named_session = True
             return
 
+        if self.agent.session_pk is None:
+            return
+
         self._auto_named_session = True
         name = prompt.strip().split("\n")[0][:60].strip()
         if name:
@@ -957,6 +997,7 @@ class Conversation(containers.Vertical):
                 )
             finally:
                 self.busy_count -= 1
+            await self._auto_name_session(prompt)
             self.call_later(self.agent_turn_over, stop_reason)
 
     async def agent_turn_over(self, stop_reason: str | None) -> None:
@@ -971,6 +1012,14 @@ class Conversation(containers.Vertical):
         self._agent_response = None
         self._complete_thought()
 
+        # Safety net: mark any still-active subagents as cancelled.
+        # Normal flow emits subagent_end before getting here, but
+        # cancellation or errors can leave widgets stuck in "running".
+        if self._active_subagents:
+            for sa in self._active_subagents.values():
+                sa.complete(status="cancelled", error="Turn ended")
+            self._active_subagents.clear()
+
         if self._directory_changed or not self.is_watching_directory:
             self._directory_changed = False
             self.post_message(messages.ProjectDirectoryUpdated(project_dir=self.app.project_dir))
@@ -1094,6 +1143,10 @@ class Conversation(containers.Vertical):
         self._replay = message.active
         # When the replay just ended, flush buffer and complete any pending thought.
         if was_replay and not message.active:
+            if message.total_messages > 0:
+                self._total_messages = message.total_messages
+                self._visible_count = message.visible_count
+                self._loaded_up_to = message.total_messages - message.visible_count
             self.call_after_refresh(self._flush_replay_buffer)
             self._complete_thought()
 
@@ -1168,6 +1221,13 @@ class Conversation(containers.Vertical):
                             entry.get("error", ""),
                         )
 
+                case "subagent_tool_call":
+                    sa = created_subagents.get(entry["id"])
+                    if sa is not None:
+                        await sa.add_or_update_tool_call(
+                            entry["tool_id"], entry["tool_call"]
+                        )
+
                 case "ask_user":
                     current_thought = None
                     self.new_block()
@@ -1178,11 +1238,50 @@ class Conversation(containers.Vertical):
                         questions=entry.get("questions", []),
                     ))
 
+        if self._loaded_up_to > 0 and self._flush_append_at is None:
+            load_more = LoadMoreIndicator(count=self._loaded_up_to)
+            widgets.insert(0, load_more)
+            self._load_more_widget = load_more
+
         if widgets:
-            await self.contents.mount(*widgets)
+            insert_before = self._flush_append_at
+            if insert_before is not None:
+                await self.contents.mount(*widgets, before=insert_before)
+                self._loaded_up_to = max(0, self._loaded_up_to - len(widgets))
+                if self._loaded_up_to > 0:
+                    lm = LoadMoreIndicator(count=self._loaded_up_to)
+                    self._load_more_widget = lm
+                    await self.contents.mount(lm, before=len(widgets))
+                self._flush_append_at = None
+            else:
+                await self.contents.mount(*widgets)
         self._replay_buffer.clear()
         self._complete_thought()
-        self.window.scroll_end(animate=False)
+        self.window.scroll_end_if_following(animate=False)
+
+    @on(LoadMoreIndicator.LoadMorePressed)
+    async def on_load_more_pressed(self, message: LoadMoreIndicator.LoadMorePressed) -> None:
+        message.stop()
+        if self._loaded_up_to <= 0:
+            return
+        batch_size = 50
+        start = max(0, self._loaded_up_to - batch_size)
+        limit = self._loaded_up_to - start
+        if limit <= 0:
+            return
+
+        if self._load_more_widget is not None:
+            await self._load_more_widget.remove()
+            self._load_more_widget = None
+
+        loading = Static("  Loading earlier messages...  ")
+        await self.contents.mount(loading, before=0)
+
+        self._flush_append_at = 0
+        self.post_message(acp_messages.SessionReplay(active=True))
+        await self.agent.acp_load_earlier_messages(offset=start, limit=limit)
+        self.post_message(acp_messages.SessionReplay(active=False))
+        await loading.remove()
 
     @on(acp_messages.RequestPermission)
     async def on_acp_request_permission(self, message: acp_messages.RequestPermission):
@@ -1275,6 +1374,25 @@ class Conversation(containers.Vertical):
             return
         tool_id = message.tool_id
 
+        # Tools invoked *inside* a subagent carry a ``subagentId`` (the parent
+        # Spawn toolCallId). Render them as ToolCall cards INSIDE the owning
+        # SubAgent widget (same style as main-conversation tools) instead of
+        # the main conversation.
+        subagent_id = tool_call.get("subagentId")
+        if subagent_id:
+            if self._replay:
+                self._replay_buffer.append({
+                    "kind": "subagent_tool_call",
+                    "id": subagent_id,
+                    "tool_id": tool_id,
+                    "tool_call": tool_call,
+                })
+                return
+            sa = self._get_subagent(subagent_id)
+            if sa is not None:
+                await sa.add_or_update_tool_call(tool_id, tool_call)
+            return
+
         if self._replay:
             if isinstance(message, acp_messages.ToolCall):
                 self._replay_buffer.append({"kind": "tool_call", "tool_call": tool_call, "tool_id": tool_id})
@@ -1349,12 +1467,18 @@ class Conversation(containers.Vertical):
         from tui.widgets.subagent import SubAgent
 
         message.stop()
+        logger.debug(
+            "[TUI-SUBagent] on_start id=%s type=%s prompt_len=%d replay=%s",
+            message.subagent_id, message.agent_type,
+            len(message.prompt or ""), self._replay,
+        )
         if self._replay:
             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, prompt=message.prompt)
         self._active_subagents[message.subagent_id] = sa
         await self.post(sa, new_block=True)
+        logger.debug("[TUI-SUBagent] on_start posted SubAgent id=%s", message.subagent_id)
 
     def _get_subagent(self, subagent_id: str):
         from tui.widgets.subagent import SubAgent
@@ -1370,10 +1494,19 @@ class Conversation(containers.Vertical):
     @on(acp_messages.SubAgentChunk)
     async def on_acp_subagent_chunk(self, message: acp_messages.SubAgentChunk):
         message.stop()
+        sa = self._get_subagent(message.subagent_id)
+        _cnt = (sa._chunk_count_log + 1) if sa else 0
+        if sa:
+            sa._chunk_count_log = _cnt
+        if _cnt <= 5 or _cnt % 50 == 0:
+            logger.debug(
+                "[TUI-SUBagent] on_chunk id=%s chunk#%d bytes=%d sa=%s",
+                message.subagent_id, _cnt, len(message.text or ""),
+                "yes" if sa else "MISSING",
+            )
         if self._replay:
             self._replay_buffer.append({"kind": "subagent_chunk", "id": message.subagent_id, "text": message.text})
             return
-        sa = self._get_subagent(message.subagent_id)
         if sa is not None:
             sa.append_chunk(message.text)
 
@@ -1394,6 +1527,16 @@ class Conversation(containers.Vertical):
     @on(acp_messages.SubAgentEnd)
     async def on_acp_subagent_end(self, message: acp_messages.SubAgentEnd):
         message.stop()
+        logger.debug(
+            "[TUI-SUBagent] on_end id=%s status=%s err=%r active=%s "
+            "chunks=%d bytes=%d",
+            message.subagent_id, message.status, (message.error or "")[:80],
+            message.subagent_id in self._active_subagents,
+            (self._get_subagent(message.subagent_id)._chunk_count_log
+             if self._get_subagent(message.subagent_id) else 0),
+            (self._get_subagent(message.subagent_id)._byte_count_log
+             if self._get_subagent(message.subagent_id) else 0),
+        )
         if self._replay:
             self._replay_buffer.append({
                 "kind": "subagent_end",
@@ -2132,17 +2275,18 @@ class Conversation(containers.Vertical):
                 cursor_block.block_cursor_down()
         self.refresh_block_cursor()
 
-    @work
     async def action_cancel(self) -> None:
-        if monotonic() - self._last_escape_time < 3:
+        now = monotonic()
+        if now - self._last_escape_time < 3:
             if (agent := self.agent) is not None:
+                self._last_escape_time = 0.0
                 if await agent.cancel():
                     self.flash("Turn cancelled", style="success")
                 else:
                     self.flash("Agent declined to cancel. Please wait.", style="error")
         else:
             self.flash("Press [b]esc[/] again to cancel agent's turn")
-            self._last_escape_time = monotonic()
+            self._last_escape_time = now
 
     def focus_prompt(self, reset_cursor: bool = True, scroll_end: bool = True) -> None:
         """Focus the prompt input.
@@ -2419,8 +2563,7 @@ class Conversation(containers.Vertical):
 
         if sub_cmd == "list":
             from pathlib import Path
-            from onecode.config import CLOUD_DEV_HARNESS_DIR
-            projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+            projects_dir = Path.home() / ".cdh" / "projects"
             if not projects_dir.exists():
                 self.notify("No projects found", title="/project list")
                 return True
@@ -2438,8 +2581,8 @@ class Conversation(containers.Vertical):
                 self.notify("Project name required", title="/project load", severity="error")
                 return True
             from pathlib import Path
-            from onecode.config import load_config, save_config, CLOUD_DEV_HARNESS_DIR
-            projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+            from onecode.config import load_config, save_config
+            projects_dir = Path.home() / ".cdh" / "projects"
             project_file = None
             for ext in ["yaml", "yml", "json"]:
                 pf = projects_dir / f"{name}.{ext}"
@@ -2466,11 +2609,11 @@ class Conversation(containers.Vertical):
                 self.notify("Usage: /project new <name> [path]", title="/project new", severity="error")
                 return True
             from pathlib import Path
-            from onecode.config import load_config, save_config, CLOUD_DEV_HARNESS_DIR
+            from onecode.config import load_config, save_config
             from onecode.agent.cdh_loader import CdhProjectLoader
             from cdh.scaffold import scaffold_dlc_project
             import yaml
-            projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+            projects_dir = Path.home() / ".cdh" / "projects"
             projects_dir.mkdir(parents=True, exist_ok=True)
             project_path = path or str(Path.cwd())
             ws = Path(project_path).expanduser().resolve()

package/tui/widgets/diff_view.py

@@ -1,5 +1,15 @@
 from textual_diff_view import DiffView
 
+# Workaround for textual_diff_view crash: DiffCode has ALLOW_SELECT = True
+# but its parent chain is not a proper Widget, causing Textual's
+# _forward_event to assert-fail on mouse move.
+try:
+    from textual_diff_view._diff_view import DiffCode
+
+    DiffCode.ALLOW_SELECT = False
+except ImportError:
+    pass
+
 from tui.app import A2TUIApp
 
 

package/tui/widgets/load_more.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import Static
+
+
+class LoadMoreIndicator(Static, can_focus=True):
+    """Clickable 'load earlier messages' indicator at top of conversation."""
+
+    class LoadMorePressed(Message):
+        pass
+
+    BINDINGS = [
+        Binding("enter", "press", "Load"),
+    ]
+
+    def __init__(self, count: int, batch: int = 50) -> None:
+        self.count = count
+        label = f"  ▲  Load {min(count, batch)} earlier messages ({count} remaining)  ▲  "
+        super().__init__(label)
+
+    def action_press(self) -> None:
+        self.post_message(self.LoadMorePressed())

package/tui/widgets/modified_files.py

@@ -5,11 +5,16 @@ import subprocess
 
 from textual import work
 from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.message import Message
 from textual.reactive import reactive
 from textual.timer import Timer
+from textual.widget import Widget
 from textual.widgets import Static
 from textual import containers
 
+from dataclasses import dataclass
+
 
 CONTENT_WIDTH = 35
 
@@ -55,13 +60,17 @@ def _tag_color(added: int, deleted: int) -> str:
     return DIFF_COLORS["dim"]
 
 
-class ModifiedFiles(containers.Vertical):
+class ModifiedFiles(containers.Vertical, can_focus=True):
     DEFAULT_CSS = """
     ModifiedFiles {
         height: auto;
         overflow-y: auto;
         padding: 0 0 0 0;
 
+        &:focus {
+            background-tint: $surface 10%;
+        }
+
         #mf-files {
             height: auto;
             padding: 0 0 0 1;
@@ -69,8 +78,24 @@ class ModifiedFiles(containers.Vertical):
     }
     """
 
+    BINDINGS = [
+        Binding("up", "cursor_up", "Up", group="Files"),
+        Binding("down", "cursor_down", "Down", group="Files"),
+        Binding("enter", "select", "Select"),
+    ]
+
+    @dataclass
+    class FileSelected(Message):
+        filepath: str
+        modified_files: "ModifiedFiles"
+
+        @property
+        def control(self) -> Widget:
+            return self.modified_files
+
     path: reactive[Path | None] = reactive(None)
     files: reactive[list[str]] = reactive(list, recompose=False)
+    highlighted: reactive[int | None] = reactive(None)
 
     def __init__(
         self,
@@ -84,6 +109,8 @@ class ModifiedFiles(containers.Vertical):
         self._status_kind: str = "no-changes"
         self._status_text: str = NO_CHANGES_TEXT
         self._initial_path: Path | None = path
+        self._filepaths: list[str] = []
+        self._lines_data: tuple[list[str], dict[str, tuple[int, int]]] | None = None
 
     def on_mount(self) -> None:
         initial = self._initial_path
@@ -93,17 +120,12 @@ class ModifiedFiles(containers.Vertical):
 
     def watch_path(self, path: Path | None) -> None:
         self._cancel_debounce()
-        if path is None:
-            self._show_status("no-changes", NO_CHANGES_TEXT)
-            return
-        self._show_status("-loading", LOADING_TEXT)
-        self._schedule_run(path)
+        self._schedule_run(path or Path.cwd())
 
     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)
+        target = self.path or Path.cwd()
+        self._cancel_debounce()
+        self._run_git_status(target)
 
     def _schedule_run(self, path: Path) -> None:
         timer = self.set_timer(
@@ -184,13 +206,33 @@ class ModifiedFiles(containers.Vertical):
     def _render_lines(self, data: tuple[list[str], dict[str, tuple[int, int]]]) -> None:
         lines, diffmap = data
         self.files = list(lines)
+        self._filepaths = [l[3:] for l in lines]
         if not lines:
             self._show_status("no-changes", NO_CHANGES_TEXT)
+            self._lines_data = None
+            self.highlighted = None
             return
         self._show_status("file-modified", "")
+        self._lines_data = data
+        if self.highlighted is None or self.highlighted >= len(self._filepaths):
+            self.highlighted = 0
+        self._apply_rendering()
 
+    def on_focus(self) -> None:
+        if self.highlighted is None and self._filepaths:
+            self.highlighted = 0
+
+    def watch_highlighted(
+        self, old: int | None, highlighted: int | None
+    ) -> None:
+        if self._lines_data is not None:
+            self._apply_rendering()
+
+    def _apply_rendering(self) -> None:
+        assert self._lines_data is not None
+        lines, diffmap = self._lines_data
         out: list[str] = []
-        for raw_line in lines:
+        for idx, raw_line in enumerate(lines):
             filepath = raw_line[3:]
             icon, sc = _status_info(raw_line[:2])
 
@@ -216,10 +258,42 @@ class ModifiedFiles(containers.Vertical):
             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}")
+            line = f"[{sc}]{icon} {disp}[/]{pad_s}{tag_s}"
+
+            if idx == self.highlighted:
+                line = f"[reverse]{line}[/]"
+            out.append(line)
 
         files_widget = self.query_one("#mf-files", Static)
         files_widget.update("\n".join(out))
+        self.call_after_refresh(self._scroll_to_highlighted)
+
+    def _scroll_to_highlighted(self) -> None:
+        if self.highlighted is not None:
+            self.scroll_to(y=self.highlighted, animate=False)
+
+    def action_cursor_up(self) -> None:
+        if not self._filepaths:
+            return
+        if self.highlighted is None or self.highlighted <= 0:
+            self.highlighted = 0
+        else:
+            self.highlighted -= 1
+
+    def action_cursor_down(self) -> None:
+        if not self._filepaths:
+            return
+        if self.highlighted is None:
+            self.highlighted = 0
+        elif self.highlighted >= len(self._filepaths) - 1:
+            self.highlighted = len(self._filepaths) - 1
+        else:
+            self.highlighted += 1
+
+    def action_select(self) -> None:
+        if self.highlighted is not None and self._filepaths:
+            filepath = self._filepaths[self.highlighted]
+            self.post_message(self.FileSelected(filepath, self))
 
     def _show_status(self, kind: str, text: str) -> None:
         self._status_kind = kind

package/tui/widgets/plan.py

@@ -182,7 +182,7 @@ class Plan(containers.Grid):
         elif status == "pending":
             return Content(" • ")
         elif status == "in_progress":
-            return Content("👉 ")
+            return Content(" 👉")
         return Content()
 
 

package/tui/widgets/project_grid_select.py

@@ -7,7 +7,6 @@ from textual import getters
 from tui.app import A2TUIApp
 from tui.widgets.grid_select import GridSelect
 from tui.widgets.project_summary import ProjectSummary
-from onecode.config import CLOUD_DEV_HARNESS_DIR
 
 
 def _read_project_path(pf: Path) -> str:
@@ -47,11 +46,19 @@ class ProjectGridSelect(GridSelect):
         return True
 
     def compose(self) -> ComposeResult:
-        projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+        projects_dir = Path.home() / ".cdh" / "projects"
         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, _read_project_path(pf), id=pf.stem)
 
+    async def reload(self) -> None:
+        await self.remove_children()
+        projects_dir = Path.home() / ".cdh" / "projects"
+        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):
+            await self.mount(ProjectSummary(pf.stem, _read_project_path(pf), id=pf.stem))
+
     def refresh(self, **kwargs) -> None:
         super().refresh(**kwargs)

package/tui/widgets/session_grid_select.py

@@ -111,6 +111,12 @@ class SessionGridSelect(GridSelect):
                     break
             return
 
+        for i, existing in enumerate(self._all_sessions):
+            if existing.mode_name == mode_name:
+                self._all_sessions[i] = details
+                self._render_page()
+                return
+
         if details.session_pk is not None:
             for i, existing in enumerate(self._all_sessions):
                 if existing.session_pk == details.session_pk:

package/tui/widgets/side_bar.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 from textual.app import ComposeResult
+from textual.binding import Binding
 from textual.widget import Widget
 from textual import containers
 from textual import widgets
@@ -9,6 +10,9 @@ from textual.message import Message
 
 class SideBarCollapsible(widgets.Collapsible):
     BINDING_GROUP_TITLE = "Sidebar collapsible"
+    BINDINGS = [
+        Binding("down", "focus_content", "Focus content", show=False),
+    ]
     HELP = """\
 ## Sidebar
 
@@ -20,6 +24,12 @@ The Sidebar contains additonal information associated with the conversation.
 - **enter** expand or collapse secions
 """
 
+    def action_focus_content(self) -> None:
+        """Move focus into the content area when expanded."""
+        if self.collapsed:
+            return
+        self.screen.focus_next()
+
 
 class SideBar(containers.Vertical):
     BINDING_GROUP_TITLE = "Sidebar"