@scemoon/cdh 1.0.0 → 1.0.3

package/tui/screens/projects_app.py

@@ -226,13 +226,24 @@ class ProjectsApp(App):
         except Exception:
             ws = Path.cwd().resolve()
         name = ws.name
-        from cdh.scaffold import scaffold_dlc_project
-        scaffold_dlc_project(ws, name)
-        CdhProjectLoader.init_project(ws, name)
         projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
         projects_dir.mkdir(parents=True, exist_ok=True)
+        proj_file = projects_dir / f"{name}.yaml"
+        if proj_file.exists():
+            self.notify(
+                f"Project '{name}' already exists in the project list",
+                severity="error",
+            )
+            return
+        from cdh.scaffold import scaffold_dlc_project
+        try:
+            scaffold_dlc_project(ws, name)
+        except (ValueError, RuntimeError) as e:
+            self.notify(str(e), severity="error")
+            return
+        CdhProjectLoader.init_project(ws, name)
         proj_data = {"name": name, "path": str(ws), "description": ""}
-        (projects_dir / f"{name}.yaml").write_text(yaml.dump(proj_data))
+        proj_file.write_text(yaml.dump(proj_data))
         cfg = load_config()
         cfg.current_project = name
         cfg.current_project_path = str(ws)
@@ -262,9 +273,26 @@ class ProjectsApp(App):
             self.notify(f".cdh already exists at {existing}", severity="warning")
             return
         name = target.name
+        projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+        projects_dir.mkdir(parents=True, exist_ok=True)
+        proj_file = projects_dir / f"{name}.yaml"
+        if proj_file.exists():
+            self.notify(
+                f"Project '{name}' already exists in the project list",
+                severity="error",
+            )
+            return
         from cdh.scaffold import init_dlc_project
-        init_dlc_project(target, name)
+        try:
+            init_dlc_project(target, name)
+        except (ValueError, RuntimeError) as e:
+            self.notify(str(e), severity="error")
+            return
         CdhProjectLoader.init_project(target, name)
+        import yaml
+        proj_data = {"name": name, "path": str(target), "description": ""}
+        proj_file.write_text(yaml.dump(proj_data))
+        self._refresh()
         self.notify(f"Initialized .cdh in {target}")
 
     def _load_project(self) -> None:

package/tui/screens/projects_screen.py

@@ -2,7 +2,6 @@ from time import monotonic
 
 from textual.app import ComposeResult
 from textual.binding import Binding
-from textual.events import ScreenResume
 from textual.screen import ModalScreen
 from textual import getters
 from textual.widget import Widget
@@ -17,12 +16,26 @@ from tui.app import A2TUIApp
 from tui.widgets.grid_select import GridSelect
 from tui.widgets.project_grid_select import ProjectGridSelect
 from tui.widgets.project_summary import ProjectSummary
+from tui.screens.component_picker import ComponentPickerScreen
 
 
 CONFIRM_TIMEOUT = 5.0
 INSTRUCTIONS_NO_PROJECTS = "Your projects will be shown here."
 
 
+def _project_db_path(name: str):
+    """Return the path of the project entry in ``~/.cdh/projects/``
+    for *name* across all supported extensions, or ``None`` if the
+    project is not registered yet.
+    """
+    projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+    for ext in ("yaml", "yml", "json"):
+        pf = projects_dir / f"{name}.{ext}"
+        if pf.exists():
+            return pf
+    return None
+
+
 class ProjectsScreen(ModalScreen[str]):
     CSS_PATH = "projects.tcss"
     BINDINGS = [
@@ -41,7 +54,7 @@ class ProjectsScreen(ModalScreen[str]):
             yield widgets.Label("Projects")
         yield widgets.Static(INSTRUCTIONS_NO_PROJECTS, classes="instructions")
         yield ProjectGridSelect()
-        with containers.Center():
+        with containers.Horizontal(id="actions"):
             yield widgets.Button("+ New Project", id="new-project", variant="primary")
             yield widgets.Button("Init .cdh (i)", id="init-project")
         yield widgets.Footer()
@@ -89,12 +102,95 @@ class ProjectsScreen(ModalScreen[str]):
         self.notify(f"Deleted project: {project_name}")
 
     def action_new_project(self) -> None:
-        self.dismiss("__new__")
+        from pathlib import Path
+        from onecode.config_screen import EditFieldScreen
+
+        default_path = str(Path.cwd().resolve())
+        self.app.push_screen(
+            EditFieldScreen("Project path", default_path),
+            self._on_new_project_path,
+        )
+
+    def _on_new_project_path(self, path_str: str | None) -> None:
+        from pathlib import Path
+
+        if not path_str:
+            return
+        try:
+            target = Path(path_str).expanduser().resolve()
+        except Exception:
+            self.notify("Invalid path", severity="error")
+            return
+        if _project_db_path(target.name) is not None:
+            self.notify(
+                f"Project '{target.name}' is already in the project list",
+                severity="warning",
+            )
+            return
+        self.app.push_screen(
+            ComponentPickerScreen(
+                title="New Project — Select Components",
+                subtitle=(
+                    f"Project path: {target}\n"
+                    "Cross-cutting items (contracts, shared types, etc.) are created automatically."
+                ),
+                allow_empty=False,
+            ),
+            lambda picked: self._on_new_project_components(target, picked),
+        )
+
+    def _on_new_project_components(
+        self,
+        target: "Path",
+        picked: list[str] | None,
+    ) -> None:
+        if picked is None:
+            self.notify("New project cancelled", severity="warning")
+            return
+        if not picked:
+            return
+        self._do_new_project(target, picked)
+
+    def _do_new_project(
+        self,
+        target: "Path",
+        components: list[str],
+    ) -> None:
+        from pathlib import Path
+        from onecode.agent.cdh_loader import CdhProjectLoader
+
+        name = target.name
+        from cdh.scaffold import scaffold_dlc_project
+
+        try:
+            scaffold_dlc_project(target, name, components=components)
+        except (ValueError, RuntimeError) as e:
+            self.notify(str(e), severity="error")
+            return
+        if _project_db_path(name) is not None:
+            self.notify(
+                f"Project '{name}' is already in the project list",
+                severity="error",
+            )
+            return
+        projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+        projects_dir.mkdir(parents=True, exist_ok=True)
+        proj_file = projects_dir / f"{name}.yaml"
+        CdhProjectLoader.init_project(target, name)
+        import yaml
+        proj_data = {"name": name, "path": str(target), "description": ""}
+        proj_file.write_text(yaml.dump(proj_data))
+        widget = ProjectSummary(name, str(target), id=name)
+        self.project_grid_select.mount(widget)
+        self.project_grid_select.highlighted = len(self.project_grid_select.children) - 1
+        self.notify(
+            f"Created project '{name}' at {target} "
+            f"(components: {', '.join(components)})"
+        )
 
     def action_init_project(self) -> None:
         from pathlib import Path
         from onecode.config_screen import EditFieldScreen
-        from onecode.agent.cdh_loader import CdhProjectLoader
 
         default_path = str(Path.cwd().resolve())
         self.app.push_screen(
@@ -117,14 +213,80 @@ class ProjectsScreen(ModalScreen[str]):
             self.notify("Invalid path", severity="error")
             return
         existing = CdhProjectLoader.find_cdh_dir(target)
-        if existing is not None:
+        if existing is not None and existing.parent == target:
             self.notify(f".cdh already exists at {existing}", severity="warning")
             return
+        if _project_db_path(target.name) is not None:
+            self.notify(
+                f"Project '{target.name}' is already in the project list",
+                severity="warning",
+            )
+            return
+        self.app.push_screen(
+            ComponentPickerScreen(
+                title="Init .cdh — Select Components",
+                subtitle=(
+                    f"Directory: {target}\n"
+                    "Pick the components already present in this directory. "
+                    "Empty selection is allowed (no apps/ created)."
+                ),
+                allow_empty=True,
+            ),
+            lambda picked: self._on_init_components(target, picked),
+        )
+
+    def _on_init_components(
+        self,
+        target: "Path",
+        picked: list[str] | None,
+    ) -> None:
+        if picked is None:
+            self.notify("Init cancelled", severity="warning")
+            return
+        self._do_init_project(target, picked)
+
+    def _do_init_project(
+        self,
+        target: "Path",
+        components: list[str],
+    ) -> None:
+        from pathlib import Path
+        from onecode.agent.cdh_loader import CdhProjectLoader
+        from cdh.scaffold import add_component, init_dlc_project
+
         name = target.name
-        from cdh.scaffold import scaffold_dlc_project
-        scaffold_dlc_project(target, name)
+        if _project_db_path(name) is not None:
+            self.notify(
+                f"Project '{name}' is already in the project list",
+                severity="error",
+            )
+            return
+        try:
+            init_dlc_project(target, name)
+        except (ValueError, RuntimeError) as e:
+            self.notify(str(e), severity="error")
+            return
+        for cid in components:
+            try:
+                add_component(target, cid)
+            except (ValueError, FileNotFoundError) as e:
+                self.notify(str(e), severity="error")
         CdhProjectLoader.init_project(target, name)
-        self.notify(f"Initialized .cdh in {target}")
+        import yaml
+        projects_dir = CLOUD_DEV_HARNESS_DIR / "projects"
+        projects_dir.mkdir(parents=True, exist_ok=True)
+        proj_file = projects_dir / f"{name}.yaml"
+        proj_data = {"name": name, "path": str(target), "description": ""}
+        proj_file.write_text(yaml.dump(proj_data))
+        widget = ProjectSummary(name, str(target), id=name)
+        self.project_grid_select.mount(widget)
+        self.project_grid_select.highlighted = len(self.project_grid_select.children) - 1
+        suffix = (
+            f" (components: {', '.join(components)})"
+            if components
+            else " (no components)"
+        )
+        self.notify(f"Initialized .cdh in {target}{suffix}")
 
     @on(GridSelect.Selected)
     def on_selected(self, event: GridSelect.Selected) -> None:
@@ -135,7 +297,7 @@ class ProjectsScreen(ModalScreen[str]):
 
     @on(widgets.Button.Pressed, "#new-project")
     def on_new_project(self) -> None:
-        self.dismiss("__new__")
+        self.action_new_project()
 
     @on(widgets.Button.Pressed, "#init-project")
     def on_init_project(self) -> None:

package/tui/widgets/ask_user.py

@@ -260,5 +260,5 @@ class AskUserWidget(VerticalGroup):
     def _finish(self, value: str) -> None:
         self._answer = value
         self._done = True
-        self.refresh(recompose=True, layout=True)
+        self.refresh(recompose=True)
         self.post_message(AskUserSubmitted(value, self._tool_id))

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: