@scemoon/cdh 1.0.3 → 1.0.5

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