@scemoon/cdh 1.0.0

package/tui/screens/projects_app.py

@@ -0,0 +1,319 @@
+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 onecode.config import CLOUD_DEV_HARNESS_DIR, load_config, save_config
+from onecode.agent.cdh_loader import CdhProjectLoader
+from onecode.config_screen 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 = CLOUD_DEV_HARNESS_DIR / "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
+        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_data = {"name": name, "path": str(ws), "description": ""}
+        (projects_dir / f"{name}.yaml").write_text(yaml.dump(proj_data))
+        cfg = load_config()
+        cfg.current_project = name
+        cfg.current_project_path = str(ws)
+        save_config(cfg)
+        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
+        from cdh.scaffold import init_dlc_project
+        init_dlc_project(target, name)
+        CdhProjectLoader.init_project(target, name)
+        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 = CLOUD_DEV_HARNESS_DIR / "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", ".")
+                cfg = load_config()
+                cfg.current_project = name
+                cfg.current_project_path = project_path
+                save_config(cfg)
+                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 = CLOUD_DEV_HARNESS_DIR / "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,142 @@
+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
+from textual import widgets
+from textual import containers
+from textual import on
+
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+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."
+
+
+class ProjectsScreen(ModalScreen[str]):
+    CSS_PATH = "projects.tcss"
+    BINDINGS = [
+        Binding("escape", "dismiss", "Dismiss"),
+        Binding("d", "delete_project", "Delete"),
+        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")
+        yield ProjectGridSelect()
+        with containers.Center():
+            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]
+
+    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 = CLOUD_DEV_HARNESS_DIR / "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(f"Project file not found", severity="error")
+            return
+        widget.remove()
+        self.notify(f"Deleted project: {project_name}")
+
+    def action_new_project(self) -> None:
+        self.dismiss("__new__")
+
+    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(
+            EditFieldScreen("Directory to initialize .cdh", default_path),
+            self._on_init_path,
+        )
+
+    def _on_init_path(self, path_str: str | None) -> None:
+        from pathlib import Path
+        from onecode.agent.cdh_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
+        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
+        from cdh.scaffold import scaffold_dlc_project
+        scaffold_dlc_project(target, name)
+        CdhProjectLoader.init_project(target, name)
+        self.notify(f"Initialized .cdh in {target}")
+
+    @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.dismiss("__new__")
+
+    @on(widgets.Button.Pressed, "#init-project")
+    def on_init_project(self) -> None:
+        self.action_init_project()

package/tui/screens/session_resume_modal.py

@@ -0,0 +1,172 @@
+from datetime import datetime, timezone
+import json
+
+from textual import on
+from textual.app import ComposeResult
+from textual import getters
+from textual import widgets
+from textual import containers
+from textual.screen import ModalScreen
+
+from tui.db import DB, Session
+
+HELP = """\
+# Session Resume
+
+Pick a session to resume.
+"""
+
+
+class SessionResumeModal(ModalScreen[Session]):
+    """Dialog to select a session to resume."""
+
+    CSS_PATH = "session_resume_modal.tcss"
+
+    BINDINGS = [("escape", "dismiss", "Dismiss")]
+
+    session_table = getters.query_one("#sessions", widgets.DataTable)
+
+    def compose(self) -> ComposeResult:
+        with containers.VerticalGroup(id="container"):
+            yield widgets.Markdown(HELP)
+            yield widgets.Static(
+                "⚠ Not all ACP agents currently support resume",
+                classes="warning",
+            )
+            with containers.Center(id="table-container"):
+                yield widgets.DataTable(id="sessions", cursor_type="row")
+            with containers.HorizontalGroup(id="buttons"):
+                yield widgets.Button(
+                    "Resume", id="resume", variant="primary", disabled=True
+                )
+                yield widgets.Button("Cancel", id="cancel")
+
+    @classmethod
+    def friendly_time_ago(cls, iso_timestamp: str) -> str:
+        """
+        Convert ISO timestamp to friendly time description.
+
+        Args:
+            iso_timestamp: ISO format timestamp string (e.g., '2024-01-30T15:30:00+00:00')
+
+        Returns:
+            - "just now" if < 1 minute ago
+            - "X minute(s) ago" if < 1 hour ago
+            - "X hour(s) ago" if < 24 hours ago
+            - Local datetime string if >= 24 hours ago (format: 'YYYY-MM-DD HH:MM AM/PM')
+
+        Examples:
+            >>> friendly_time_ago('2024-01-30T15:30:00+00:00')  # 30 seconds ago
+            'just now'
+            >>> friendly_time_ago('2024-01-30T15:00:00+00:00')  # 5 minutes ago
+            '5 minutes ago'
+            >>> friendly_time_ago('2024-01-30T13:00:00+00:00')  # 3 hours ago
+            '3 hours ago'
+            >>> friendly_time_ago('2024-01-28T15:30:00+00:00')  # 2 days ago
+            '2024-01-28 10:30 AM'  # (in local time)
+        """
+        # Parse the timestamp
+        past_dt = datetime.fromisoformat(iso_timestamp)
+
+        # Get current time in appropriate timezone
+        if past_dt.tzinfo is not None:
+            # Timezone-aware: use UTC for comparison
+            now = datetime.now(timezone.utc)
+        else:
+            # Naive datetime: use naive now
+            now = datetime.now()
+
+        # Calculate time difference
+        diff = now - past_dt
+        total_seconds = diff.total_seconds()
+
+        # Less than 1 minute
+        if total_seconds < 60:
+            return "just now"
+
+        # Less than 1 hour (3600 seconds)
+        if total_seconds < 3600:
+            minutes = int(total_seconds // 60)
+            return f"{minutes} minute{'s' if minutes != 1 else ''} ago"
+
+        # Less than 24 hours (86400 seconds)
+        if total_seconds < 86400:
+            hours = int(total_seconds // 3600)
+            return f"{hours} hour{'s' if hours != 1 else ''} ago"
+
+        # 24 hours or more - return as local time
+        if past_dt.tzinfo is not None:
+            local_dt = past_dt.astimezone()  # Convert to local timezone
+        else:
+            local_dt = past_dt  # Already naive, assume local
+
+        return local_dt.strftime("%c")
+
+    async def on_mount(self) -> None:
+        table = self.session_table
+        table.add_columns("Agent", "Session", "Created", "Last Used", "Path")
+        db = DB()
+        sessions = await db.session_get_recent()
+        if sessions is None:
+            return
+
+        for session in sessions:
+            cwd = ""
+            if meta_json := session["meta_json"]:
+                try:
+                    cwd = json.loads(meta_json).get("cwd", None)
+                except Exception:
+                    pass
+
+            table.add_row(
+                session["agent"],
+                session["title"],
+                self.friendly_time_ago(session["created_at"]),
+                self.friendly_time_ago(session["last_used"]),
+                cwd,
+                key=str(session["id"]),
+            )
+
+    async def dissmiss_with_session(self, row_key_value: str) -> Session | None:
+        try:
+            session_id = int(row_key_value)
+        except ValueError:
+            return
+        db = DB()
+        session = await db.session_get(session_id)
+        self.dismiss(session)
+
+    @on(widgets.Button.Pressed, "#resume")
+    async def on_resume_button(self) -> None:
+        table = self.session_table
+        row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        if row_key is None or row_key.value is None:
+            return
+        await self.dissmiss_with_session(row_key.value)
+
+    @on(widgets.Button.Pressed, "#cancel")
+    def on_cancel_button(self) -> None:
+        self.dismiss()
+
+    @on(widgets.DataTable.RowHighlighted)
+    def on_data_table_row_highlighted(self) -> None:
+        self.query_one("#resume").disabled = False
+
+    @on(widgets.DataTable.RowSelected)
+    async def on_data_table_row_selected(
+        self, event: widgets.DataTable.RowSelected
+    ) -> None:
+        if event.row_key is None or event.row_key.value is None:
+            return
+        await self.dissmiss_with_session(event.row_key.value)
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    class TApp(App):
+        def on_mount(self):
+            self.push_screen(SessionResumeModal())
+
+    app = TApp()
+    app.run()

package/tui/screens/session_resume_modal.tcss

@@ -0,0 +1,35 @@
+SessionResumeModal {
+    align: center middle;
+    .warning {
+        border: round $warning;
+        padding: 0 1;
+        color: $text-warning;
+        margin: 0 0 1 1;
+    }
+    #container {        
+        margin: 2 4 1 4;
+        padding: 0 1 0 0;
+        max-width: 100;
+        height: auto;
+        border: thick $primary 20%;
+
+        Markdown {
+            MarkdownH1 {
+                margin: 1 0;
+            }            
+        }
+
+        #table-container {
+            height: auto;
+            padding: 0 0 0 1;
+            DataTable {
+                width: 1fr;
+                height: 12;
+            }
+        }
+        #buttons {
+            margin-top: 1;
+            align: right top;
+        }
+    }
+}