@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/screens/projects_app.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+from pathlib import Path
+from time import monotonic
+
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import var
+from textual.widget import Widget
+from textual.widgets import Button, Label, Static
+
+from cdh.config import write_active_project
+from cdh.project_loader import CdhProjectLoader
+from tui.widgets.edit_field import EditFieldScreen
+
+import yaml
+
+CONFIRM_TIMEOUT = 5.0
+
+
+class ProjectItem(Static, can_focus=True):
+    """A single project row in the list."""
+
+    def __init__(self, name: str, path: str) -> None:
+        super().__init__()
+        self._name = name
+        self._path = path
+
+    def render(self) -> str:
+        return f"  {self._name:<20} {self._path}"
+
+
+class ProjectsApp(App):
+    """Standalone project management TUI."""
+
+    CSS = """
+    Screen {
+        align: center middle;
+    }
+    ProjectsApp {
+        background: #000;
+    }
+    #dialog {
+        width: 64;
+        height: 20;
+        background: #000;
+        border: solid #555;
+    }
+    #header {
+        height: 2;
+        background: #333;
+        content-align: center middle;
+        color: #fff;
+        text-style: bold;
+    }
+    #content {
+        width: 100%;
+        height: 1fr;
+        background: #000;
+    }
+    ProjectItem {
+        width: 100%;
+        height: 1;
+        padding: 0 1;
+        color: #fff;
+        background: #000;
+    }
+    ProjectItem:hover, ProjectItem.-focus {
+        background: #444;
+    }
+    #shortcuts {
+        height: 1;
+        background: #222;
+        color: #888;
+        padding: 0 1;
+        content-align: left middle;
+    }
+    #button-row {
+        height: 3;
+        background: #333;
+        align: center middle;
+    }
+    Button {
+        margin: 0 1;
+        background: #444;
+        color: #fff;
+    }
+    Button:hover {
+        background: #666;
+    }
+    Button:focus {
+        background: #555;
+    }
+    #empty-label {
+        width: 100%;
+        height: 100%;
+        content-align: center middle;
+        color: #666;
+    }
+    """
+
+    BINDINGS = [
+        ("up", "cursor_up", "Up"),
+        ("down", "cursor_down", "Down"),
+        ("enter", "confirm", "Select"),
+        ("n", "new_project", "New"),
+        ("i", "init_project", "Init"),
+        ("d", "delete_project", "Delete"),
+        ("ctrl+q", "quit", "Quit"),
+        ("escape", "dismiss_modal", "Cancel"),
+    ]
+
+    cursor: var[int] = var(0)
+    _delete_confirm_time: float = 0.0
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.projects: list[tuple[str, str]] = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Static("Project Management", id="header")
+            with Widget(id="content"):
+                pass
+            yield Label("↑↓ Select  ↵ Load  n New  i Init  d Delete  Ctrl+Q Quit", id="shortcuts")
+            with Horizontal(id="button-row"):
+                yield Button("Load (↵)", id="load")
+                yield Button("New (n)", id="new", variant="primary")
+                yield Button("Init .cdh (i)", id="init")
+                yield Button("Delete (d)", id="delete")
+
+    def _rebuild_items(self) -> None:
+        content = self.query_one("#content")
+        content.remove_children()
+        if not self.projects:
+            content.mount(Static("No projects found", id="empty-label"))
+            return
+        for name, path in self.projects:
+            content.mount(ProjectItem(name, path))
+        self.cursor = 0
+
+    def _clamp_cursor(self) -> None:
+        if not self.projects:
+            return
+        self.cursor = max(0, min(self.cursor, len(self.projects) - 1))
+
+    def watch_cursor(self, old: int, new: int) -> None:
+        if not self.projects:
+            return
+        items = list(self.query(ProjectItem))
+        for i, item in enumerate(items):
+            item.set_class(i == new, "-focus")
+
+    @property
+    def _current_item(self) -> ProjectItem | None:
+        items = list(self.query(ProjectItem))
+        if 0 <= self.cursor < len(items):
+            return items[self.cursor]
+        return None
+
+    def on_mount(self) -> None:
+        self._refresh()
+
+    def _refresh(self) -> None:
+        projects_dir = Path.home() / ".cdh" / "projects"
+        projects_dir.mkdir(parents=True, exist_ok=True)
+        pf_list = sorted(
+            list(projects_dir.glob("*.yaml")) + list(projects_dir.glob("*.json"))
+        )
+        self.projects = []
+        for pf in pf_list:
+            try:
+                data = yaml.safe_load(pf.read_text()) or {}
+                p = data.get("path", ".")
+            except Exception:
+                p = "."
+            self.projects.append((pf.stem, p))
+        self._rebuild_items()
+
+    def action_cursor_up(self) -> None:
+        self.cursor -= 1
+        self._clamp_cursor()
+
+    def action_cursor_down(self) -> None:
+        self.cursor += 1
+        self._clamp_cursor()
+
+    def action_confirm(self) -> None:
+        self._load_project()
+
+    def action_new_project(self) -> None:
+        self._new_project()
+
+    def action_init_project(self) -> None:
+        self._init_project()
+
+    def action_delete_project(self) -> None:
+        self._delete_project()
+
+    def action_quit(self) -> None:
+        self.exit()
+
+    def action_dismiss_modal(self) -> None:
+        pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+        if btn_id == "new":
+            self._new_project()
+        elif btn_id == "load":
+            self._load_project()
+        elif btn_id == "init":
+            self._init_project()
+        elif btn_id == "delete":
+            self._delete_project()
+
+    def _new_project(self) -> None:
+        self.push_screen(
+            EditFieldScreen("Project path", str(Path.cwd().resolve())),
+            self._on_new_project_path,
+        )
+
+    def _on_new_project_path(self, path_str: str | None) -> None:
+        try:
+            ws = Path(path_str).expanduser().resolve() if path_str else Path.cwd().resolve()
+        except Exception:
+            ws = Path.cwd().resolve()
+        name = ws.name
+        projects_dir = Path.home() / ".cdh" / "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": ""}
+        proj_file.write_text(yaml.dump(proj_data))
+        write_active_project(name, str(ws))
+        self.notify(f"Created project '{name}' at {ws}")
+        self._refresh()
+
+    def _init_project(self) -> None:
+        self.push_screen(
+            EditFieldScreen("Directory to initialize .cdh", str(Path.cwd().resolve())),
+            self._on_init_project_path,
+        )
+
+    def _on_init_project_path(self, path_str: str | None) -> None:
+        if not path_str:
+            return
+        try:
+            target = Path(path_str).expanduser().resolve()
+            if not target.is_dir():
+                self.notify(f"Not a directory: {target}", severity="error")
+                return
+        except Exception:
+            self.notify("Invalid path", severity="error")
+            return
+        existing = CdhProjectLoader.find_cdh_dir(target)
+        if existing is not None:
+            self.notify(f".cdh already exists at {existing}", severity="warning")
+            return
+        name = target.name
+        projects_dir = Path.home() / ".cdh" / "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
+        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:
+        item = self._current_item
+        if item is None:
+            self.notify("No project selected", severity="warning")
+            return
+        name = item._name
+        projects_dir = Path.home() / ".cdh" / "projects"
+        for ext in ["yaml", "yml", "json"]:
+            pf = projects_dir / f"{name}.{ext}"
+            if pf.exists():
+                proj_data = yaml.safe_load(pf.read_text()) if ext in ["yaml", "yml"] else __import__("json").loads(pf.read_text())
+                project_path = proj_data.get("path", ".")
+                write_active_project(name, project_path)
+                self.notify(f"Loaded project '{name}' ({project_path})")
+                self.exit("loaded")
+                return
+        self.notify(f"Project '{name}' not found", severity="error")
+
+    def _delete_project(self) -> None:
+        now = monotonic()
+        if now - self._delete_confirm_time > CONFIRM_TIMEOUT:
+            self._delete_confirm_time = now
+            self.notify(
+                "Press [b]d[/b] again to confirm deletion",
+                title="Delete project",
+                timeout=CONFIRM_TIMEOUT,
+            )
+            return
+        self._delete_confirm_time = 0.0
+        item = self._current_item
+        if item is None:
+            self.notify("No project selected", severity="warning")
+            return
+        name = item._name
+        projects_dir = Path.home() / ".cdh" / "projects"
+        for ext in ["yaml", "yml", "json"]:
+            pf = projects_dir / f"{name}.{ext}"
+            if pf.exists():
+                pf.unlink()
+                self.notify(f"Deleted project '{name}'")
+                self._refresh()
+                return
+        self.notify(f"Project '{name}' not found", severity="error")
+
+
+def main():
+    return ProjectsApp().run()

package/tui/screens/projects_screen.py

@@ -0,0 +1,277 @@
+from pathlib import Path
+from time import monotonic
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.screen import ModalScreen
+from textual import getters
+from textual.widget import Widget
+from textual import widgets
+from textual import containers
+from textual import on
+
+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
+
+
+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 = Path.home() / ".cdh" / "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 = [
+        Binding("escape", "dismiss", "Dismiss", show=False),
+        Binding("d", "delete_project", "Del"),
+        Binding("n", "new_project", "New"),
+        Binding("i", "init_project", "Init"),
+    ]
+
+    app: getters.app[A2TUIApp] = getters.app(A2TUIApp)
+    project_grid_select = getters.query_one(ProjectGridSelect)
+    _delete_confirm_time: float = 0.0
+
+    def compose(self) -> ComposeResult:
+        with containers.Center(id="title-container"):
+            yield widgets.Label("Projects")
+        yield widgets.Static(
+            INSTRUCTIONS_NO_PROJECTS,
+            classes="instructions",
+            id="instructions-label",
+        )
+        yield ProjectGridSelect()
+        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()
+
+    @property
+    def focus_chain(self) -> list[Widget]:
+        return [
+            self.project_grid_select,
+            self.query_one("#new-project", widgets.Button),
+            self.query_one("#init-project", widgets.Button),
+        ]
+
+    def action_delete_project(self) -> None:
+        now = monotonic()
+        if now - self._delete_confirm_time > CONFIRM_TIMEOUT:
+            self._delete_confirm_time = now
+            self.notify(
+                "Press [b]d[/b] again to confirm deletion",
+                title="Delete project",
+                timeout=CONFIRM_TIMEOUT,
+            )
+            return
+
+        self._delete_confirm_time = 0.0
+        highlighted = self.project_grid_select.highlighted
+        if highlighted is None:
+            return
+        try:
+            widget = self.project_grid_select.children[highlighted]
+        except IndexError:
+            return
+        if not isinstance(widget, ProjectSummary):
+            return
+        project_name = widget.id
+        if project_name is None:
+            return
+        projects_dir = Path.home() / ".cdh" / "projects"
+        deleted = False
+        for ext in ["yaml", "yml", "json"]:
+            pf = projects_dir / f"{project_name}.{ext}"
+            if pf.exists():
+                pf.unlink()
+                deleted = True
+                break
+        if not deleted:
+            self.notify("Project file not found", severity="error")
+            return
+        widget.remove()
+        if not self.project_grid_select.children:
+            self._show_instructions()
+        self.notify(f"Deleted project: {project_name}")
+
+    def _hide_instructions(self) -> None:
+        try:
+            self.query_one("#instructions-label", widgets.Static).add_class("-hidden")
+        except Exception:
+            pass
+
+    def _show_instructions(self) -> None:
+        try:
+            self.query_one("#instructions-label", widgets.Static).remove_class("-hidden")
+        except Exception:
+            pass
+
+    def action_new_project(self) -> None:
+        from pathlib import Path
+        from tui.widgets.edit_field import EditFieldScreen
+
+        default_path = str(Path.cwd().resolve())
+        self.app.push_screen(
+            EditFieldScreen("Project path", default_path),
+            self._on_new_project_path,
+        )
+
+    async 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
+        await self._do_new_project(target, [])
+
+    async def _do_new_project(
+        self,
+        target: "Path",
+        components: list[str],
+    ) -> None:
+        from pathlib import Path
+        from cdh.project_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 = Path.home() / ".cdh" / "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))
+        await self.project_grid_select.reload()
+        self.project_grid_select.highlighted = len(self.project_grid_select.children) - 1
+        self._hide_instructions()
+        self.notify(
+            f"Created project '{name}' at {target} "
+            f"(components: {', '.join(components)})"
+        )
+
+    def action_init_project(self) -> None:
+        from pathlib import Path
+        from tui.widgets.edit_field import EditFieldScreen
+
+        default_path = str(Path.cwd().resolve())
+        self.app.push_screen(
+            EditFieldScreen("Directory to initialize .cdh", default_path),
+            self._on_init_path,
+        )
+
+    async def _on_init_path(self, path_str: str | None) -> None:
+        from pathlib import Path
+        from cdh.project_loader import CdhProjectLoader
+
+        if not path_str:
+            return
+        try:
+            target = Path(path_str).expanduser().resolve()
+            if not target.is_dir():
+                self.notify(f"Not a directory: {target}", severity="error")
+                return
+        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
+        await self._do_init_project(target, [])
+
+    async def _do_init_project(
+        self,
+        target: "Path",
+        components: list[str],
+    ) -> None:
+        from pathlib import Path
+        from cdh.project_loader import CdhProjectLoader
+        from cdh.scaffold import add_component, init_dlc_project
+
+        name = target.name
+        if _project_db_path(name) is not None:
+            self.notify(
+                f"Project '{name}' is already in the project list",
+                severity="error",
+            )
+            return
+        if not (target / "aidlc" / "project.yaml").exists():
+            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)
+        import yaml
+        projects_dir = Path.home() / ".cdh" / "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))
+        await self.project_grid_select.reload()
+        self.project_grid_select.highlighted = len(self.project_grid_select.children) - 1
+        self._hide_instructions()
+        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:
+        if (
+            isinstance(event.widget, ProjectSummary)
+        ):
+            self.dismiss(event.widget.id)
+
+    @on(widgets.Button.Pressed, "#new-project")
+    def on_new_project(self) -> None:
+        self.action_new_project()
+
+    @on(widgets.Button.Pressed, "#init-project")
+    def on_init_project(self) -> None:
+        self.action_init_project()