@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/widgets/plan.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from textual.app import ComposeResult
+from textual.content import Content
+from textual.reactive import reactive
+from textual import containers
+from textual.widgets import Static
+
+from tui.pill import pill
+from tui.widgets.strike_text import StrikeText
+
+
+class NonSelectableStatic(Static):
+    ALLOW_SELECT = False
+
+
+class Plan(containers.Grid):
+    # BORDER_TITLE = "Plan"
+    DEFAULT_CLASSES = "block"
+    DEFAULT_CSS = """
+
+    Plan {
+        border-top: ascii $secondary;
+        border-bottom: ascii $secondary;
+        background: black 10%;
+        margin: 1 0 1 0 !important;
+        padding: 0 1 0 1;
+        height: auto;
+        grid-size: 2;
+        grid-columns: auto 1fr;
+        grid-rows: auto;
+        border-title-align: center;
+
+        .-no-plan {
+            text-style: dim italic;
+        }
+
+        .-plan-header {
+            column-span: 2;
+            padding: 0 0 1 0;
+            color: $text-secondary;
+        }
+
+        .plan {
+            color: $text-secondary;
+            padding: 0 0 0 0;
+        }
+
+        .status {
+            padding: 0 0 0 0;
+            color: $text-secondary;
+        }
+
+        .status-icon {
+            min-width: 3;
+        }
+
+        .priority-high {
+            color: $text-error;
+        }
+
+        .priority-medium {
+            color: $text-warning;
+        }
+
+        .priority-low {
+            color: $text-secondary;
+        }
+
+        .status-in_progress {
+            background: $primary 15%;
+        }
+
+        .status-completed {
+            color: $text-success;
+        }
+
+        .status-pending {
+            opacity: 0.6;
+        }
+    }
+
+    """
+
+    @dataclass(frozen=True)
+    class Entry:
+        """Information about an entry in the Plan."""
+
+        content: Content
+        priority: str
+        status: str
+
+        def update_status(self, status: str) -> Plan.Entry:
+            """Get a new Entry with updated status.
+
+            Args:
+                status: New status
+
+            Returns:
+                New Entry instance.
+            """
+            return Plan.Entry(self.content, self.priority, status)
+
+    entries: reactive[list[Entry] | None] = reactive(None, recompose=True)
+    all_complete: reactive[bool] = reactive(False, toggle_class="-all-complete")
+
+    PRIORITIES = {
+        "high": pill("H", "$error-muted", "$text-error"),
+        "medium": pill("M", "$warning-muted", "$text-warning"),
+        "low": pill("L", "$primary-muted", "$text-primary"),
+    }
+
+    def __init__(
+        self,
+        entries: list[Entry],
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        placeholder: str = "No plan yet",
+    ):
+        self.newly_completed: set[Plan.Entry] = set()
+        self._placeholder = placeholder
+        super().__init__(name=name, id=id, classes=classes)
+        self.set_reactive(Plan.entries, entries)
+
+    def watch_entries(self, old_entries: list[Entry], new_entries: list[Entry]) -> None:
+        entry_map = {entry.content: entry for entry in old_entries}
+        newly_completed: set[Plan.Entry] = set()
+        for entry in new_entries:
+            old_entry = entry_map.get(entry.content, None)
+            if (
+                old_entry is not None
+                and entry.status == "completed"
+                and entry.status != old_entry.status
+            ):
+                newly_completed.add(entry)
+        self.newly_completed = newly_completed
+        if new_entries:
+            self.all_complete = all(
+                entry.status == "completed" for entry in self.entries
+            )
+        else:
+            self.all_complete = False
+
+    def compose(self) -> ComposeResult:
+        if not self.entries:
+            yield Static(self._placeholder, classes="-no-plan")
+            return
+
+        total = len(self.entries)
+        done = sum(1 for e in self.entries if e.status == "completed")
+        yield Static(f"📋 {done}/{total}  全部完成 ✔" if done == total else f"📋 {done}/{total}", classes="-plan-header")
+
+        for entry in self.entries:
+            classes = f"priority-{entry.priority} status-{entry.status}"
+
+            status_parts = [self.render_status(entry.status)]
+            if pill_content := self.PRIORITIES.get(entry.priority):
+                status_parts.append(pill_content)
+            yield NonSelectableStatic(
+                Content.assemble(*status_parts),
+                classes=f"status status-icon {classes}",
+            )
+
+            yield (
+                strike_text := StrikeText(
+                    entry.content,
+                    classes=f"plan {classes}",
+                )
+            )
+            if entry in self.newly_completed:
+                self.call_after_refresh(strike_text.strike)
+            elif entry.status == "completed":
+                strike_text.add_class("-complete")
+        self.all_complete = all(entry.status == "completed" for entry in self.entries)
+
+    def render_status(self, status: str) -> Content:
+        if status == "completed":
+            return Content(" ✔ ")
+        elif status == "pending":
+            return Content(" • ")
+        elif status == "in_progress":
+            return Content(" 👉")
+        return Content()
+
+
+def entries_from_dicts(raw_entries):
+    """Convert raw plan entries (dicts) into ``Plan.Entry`` dataclass instances.
+
+    Shared by ``MainScreen`` (sidebar) and ``Conversation`` (inline) so both
+    Plan widgets render the same data the same way. Filters entries with
+    empty content so the Plan widget never renders a blank row.
+    """
+    result = []
+    for entry in raw_entries:
+        content = (entry.get("content") or "").strip()
+        if not content:
+            continue
+        result.append(
+            Plan.Entry(
+                Content(content),
+                entry.get("priority", "medium"),
+                entry.get("status", "pending"),
+            )
+        )
+    return result
+
+
+if __name__ == "__main__":
+    from textual.app import App
+
+    entries = [
+        Plan.Entry(
+            Content("Build the best damn UI for agentic coding in the terminal"),
+            "hide",
+            "in_progress",
+        ),
+        Plan.Entry(
+            Content(
+                "Embarass big tech by being the only agent CLI that can render Markdown tables"
+            ),
+            "high",
+            "pending",
+        ),
+        Plan.Entry(
+            Content.from_markup("Catch flight to Wuhan"),
+            "low",
+            "pending",
+        ),
+        Plan.Entry(
+            Content.from_markup("Eat 热干面 for breakfast"),
+            "low",
+            "pending",
+        ),
+        Plan.Entry(
+            Content.from_markup("Pack sunscreen, catch flight to Thailand"),
+            "low",
+            "pending",
+        ),
+        Plan.Entry(
+            Content.from_markup(
+                "Work as a digital nomad in Asia, eat well, don't get sun-stroke"
+            ),
+            "low",
+            "pending",
+        ),
+    ]
+
+    class PlanApp(App):
+        BINDINGS = [("space", "strike")]
+
+        CSS = """
+        Screen {
+            align: center middle;
+            Plan {
+                margin: 1;
+            }
+        }
+        """
+
+        def __init__(self) -> None:
+            super().__init__()
+            self.working = 0
+
+        def compose(self) -> ComposeResult:
+            yield Plan(entries)
+
+        def action_strike(self) -> None:
+            new_entries = entries.copy()
+            new_entries[self.working] = entries[self.working].update_status("completed")
+            self.working += 1
+            try:
+                new_entries[self.working] = entries[self.working].update_status(
+                    "in_progress"
+                )
+            except IndexError:
+                pass
+
+            self.query_one(Plan).entries = new_entries
+            entries[:] = new_entries
+
+    app = PlanApp()
+    app.run()

package/tui/widgets/project_directory_tree.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+from typing import Iterable
+
+import asyncio
+
+from textual import work
+from textual.binding import Binding
+from textual.widgets import DirectoryTree
+from textual.widgets.directory_tree import DirEntry
+
+from tui.path_filter import PathFilter
+
+
+class ProjectDirectoryTree(DirectoryTree):
+    BINDING_GROUP_TITLE = "Tree view"
+    HELP = """\
+## Project files
+
+This shows the files in your project directory.
+
+- **cursor keys** navigation
+- **Enter** expand folder
+"""
+    BINDINGS = [
+        Binding(
+            "ctrl+c",
+            "dismiss",
+            "Interrupt",
+            tooltip="Interrupt running command",
+            show=False,
+        ),
+        Binding("ctrl+r", "refresh", "Refresh", tooltip="Refresh file view", show=True),
+    ]
+
+    def __init__(
+        self,
+        path: str | Path,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        self.path_filter: PathFilter | None = None
+        self._reload_lock = asyncio.Lock()
+        path = Path(path).resolve() if isinstance(path, str) else path.resolve()
+        super().__init__(path, name=name, id=id, classes=classes, disabled=disabled)
+
+    async def _update_path_filter(self) -> None:
+        if self.path is None:
+            self.path_filter = None
+            return
+        path = Path(self.path) if isinstance(self.path, str) else self.path
+        path = await asyncio.to_thread(path.resolve)
+        self.path_filter = await asyncio.to_thread(PathFilter.from_git_root, path)
+
+    async def watch_path(self) -> None:
+        """Watch for changes to the `path` of the directory tree.
+
+        If the path is changed the directory tree will be repopulated using
+        the new value as the root.
+        """
+        if self.path is None:
+            return
+        async with self._reload_lock:
+            has_cursor = self.cursor_node is not None
+            self.reset_node(self.root, str(self.path), DirEntry(self.PATH(self.path)))
+            await self._update_path_filter()
+            await self.reload()
+            if has_cursor:
+                self.cursor_line = 0
+            self.scroll_to(0, 0, animate=False)
+
+    async def on_mount(self) -> None:
+        await self._update_path_filter()
+
+    def filter_paths(self, paths: Iterable[Path]) -> Iterable[Path]:
+        """Filter the paths before adding them to the tree.
+
+        Args:
+            paths: The paths to be filtered.
+
+        Returns:
+            The filtered paths.
+
+        By default this method returns all of the paths provided. To create
+        a filtered `DirectoryTree` inherit from it and implement your own
+        version of this method.
+        """
+
+        if (path_filter := self.path_filter) is not None:
+            for path in paths:
+                if not path_filter.match(path):
+                    yield path
+        else:
+            yield from paths
+
+    @work
+    async def action_refresh(self) -> None:
+        async with self._reload_lock:
+            await self.reload()
+        self.notify("Project directory has been refreshed", title="Directory Tree")

package/tui/widgets/project_grid_select.py

@@ -0,0 +1,68 @@
+from pathlib import Path
+
+import yaml
+from textual.app import ComposeResult
+from textual import getters
+
+from tui.app import A2TUIApp
+from tui.widgets.grid_select import GridSelect
+from tui.widgets.project_summary import ProjectSummary
+
+
+def _read_project_path(pf: Path) -> str:
+    """Return the project directory path stored in ``pf``, or the
+    yaml/json file path as a fallback."""
+    try:
+        if pf.suffix == ".json":
+            import json
+
+            data = json.loads(pf.read_text(encoding="utf-8")) or {}
+        else:
+            data = yaml.safe_load(pf.read_text(encoding="utf-8")) or {}
+        path = data.get("path")
+        if isinstance(path, str) and path:
+            return path
+    except Exception:
+        pass
+    return str(pf)
+
+
+class ProjectGridSelect(GridSelect):
+    FOCUS_ON_CLICK = True
+    app: getters.app[A2TUIApp] = getters.app(A2TUIApp)
+
+    def __init__(
+        self,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(
+            id=id,
+            classes=classes,
+            min_column_width=36,
+        )
+
+    def allow_focus(self) -> bool:
+        return True
+
+    def compose(self) -> ComposeResult:
+        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):
+            try:
+                summary = ProjectSummary(pf.stem, _read_project_path(pf), id=pf.stem)
+            except Exception:
+                continue
+            await self.mount(summary)
+
+    def refresh(self, **kwargs) -> None:
+        super().refresh(**kwargs)

package/tui/widgets/project_summary.py

@@ -0,0 +1,33 @@
+from textual.app import ComposeResult
+from textual import containers
+from textual import widgets
+
+
+class ProjectSummary(containers.VerticalGroup):
+    def __init__(
+        self,
+        project_name: str,
+        project_path: str,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(id=id, classes=classes)
+        self._project_name = project_name
+        self._project_path = project_path
+
+    def compose(self) -> ComposeResult:
+        with containers.HorizontalGroup():
+            yield widgets.Label("❯", classes="icon")
+            with containers.VerticalGroup():
+                yield widgets.Label(
+                    self._project_name,
+                    classes="title",
+                    markup=False,
+                )
+                with containers.HorizontalGroup():
+                    yield widgets.Label("📁 ")
+                    yield widgets.Label(
+                        self._project_path,
+                        classes="path",
+                        markup=False,
+                    )