@scemoon/cdh 1.0.6 → 1.0.7

package/tui/widgets/plan.py

@@ -1,285 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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):
-            await self.mount(ProjectSummary(pf.stem, _read_project_path(pf), id=pf.stem))
-
-    def refresh(self, **kwargs) -> None:
-        super().refresh(**kwargs)

package/tui/widgets/project_summary.py

@@ -1,33 +0,0 @@
-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,
-                    )