@scemoon/cdh 1.0.0

package/tui/screens/store.py

@@ -0,0 +1,500 @@
+import asyncio
+from contextlib import suppress
+from dataclasses import dataclass
+from itertools import zip_longest
+from pathlib import Path
+from random import shuffle
+
+from textual.binding import Binding
+from textual.screen import Screen
+from textual import events
+from textual import work
+from textual import getters
+from textual import on
+from textual.app import ComposeResult
+from textual.content import Content
+from textual.css.query import NoMatches
+from textual.message import Message
+from textual.reactive import reactive
+from textual import containers
+from textual import widgets
+
+from tui.app import A2TUIApp
+from tui.format_path import format_path
+from tui import messages
+from tui.pill import pill
+from tui.widgets.directory_input import DirectoryInput
+from tui.widgets.mandelbrot import Mandelbrot
+from tui.widgets.condensed_path import CondensedPath
+from tui.widgets.grid_select import GridSelect
+from tui.agent_schema import Agent
+from tui.agents import read_agents
+
+
+@dataclass
+class ChangeDirectory(Message):
+    path: str
+
+
+class DirectoryDisplay(containers.HorizontalGroup):
+
+    BINDINGS = [("escape", "dismiss", "Dismiss")]
+
+    DEFAULT_CSS = """
+    DirectoryDisplay {
+        CondensedPath { display: block; }
+        DirectoryInput { display: none; }
+        &.-edit {
+            CondensedPath { display: none}
+            DirectoryInput { display: block; }
+        }
+    }
+    """
+
+    project_dir: reactive[Path] = reactive(Path)
+    path = reactive("")
+    edit = reactive(False, toggle_class="-edit")
+
+    directory_input = getters.query_one(DirectoryInput)
+    condensed_path = getters.query_one(CondensedPath)
+
+    def __init__(self, project_dir: Path) -> None:
+        super().__init__()
+        self.project_dir = project_dir
+        self.path = format_path(project_dir, directory=True)
+
+    def watch_project_dir(self, path: Path) -> None:
+        self.path = format_path(path, directory=True)
+
+    def focus(self, scroll_visible=True) -> "Self":
+        self.edit = True
+        self.directory_input.focus(scroll_visible=scroll_visible)
+        return self
+
+    @on(events.Click, "CondensedPath")
+    def on_click(self) -> None:
+        self.edit = True
+        self.directory_input.focus()
+
+    @on(events.DescendantBlur)
+    def on_blur(self):
+        self.action_dismiss()
+
+    @on(widgets.Input.Submitted)
+    def on_input_submitted(self, event: widgets.Input.Submitted) -> None:
+        path = Path(event.value).expanduser().resolve()
+        self.edit = False
+        if not path.is_dir():
+            self.notify(
+                f"Unable to change directory to {str(path)!r}",
+                title="Change directory",
+                severity="error",
+            )
+            return
+        self.condensed_path.path = format_path(path, directory=True)
+        self.post_message(ChangeDirectory(str(path)))
+
+    def action_dismiss(self) -> None:
+        self.edit = False
+        self.directory_input.value = self.path
+
+    def watch_edit(self, edit: bool) -> None:
+        if not edit and self.directory_input.has_focus:
+            self.directory_input.blur()
+
+    def compose(self) -> ComposeResult:
+        yield widgets.Label("📁 ")
+        yield CondensedPath(self.path, directory=True).data_bind(
+            path=DirectoryDisplay.path
+        ).with_tooltip("Project directory for new agent sessions (click to edit)")
+        yield DirectoryInput(self.path, select_on_focus=True, compact=True).data_bind(
+            value=DirectoryDisplay.path
+        )
+
+
+class AgentItem(containers.VerticalGroup):
+    """An entry in the Agent grid select."""
+
+    def __init__(self, agent: Agent) -> None:
+        self._agent = agent
+        super().__init__()
+
+    @property
+    def agent(self) -> Agent:
+        return self._agent
+
+    def compose(self) -> ComposeResult:
+        agent = self._agent
+        with containers.Grid():
+            yield widgets.Label(agent["name"], id="name")
+            tag = pill(agent.get("type", "agent"), "$primary-muted 50%", "$text-primary")
+            yield widgets.Label(tag, id="type")
+        yield widgets.Label(agent.get("author_name", ""), id="author")
+        yield widgets.Static(agent.get("description", ""), id="description")
+
+
+class LauncherItem(containers.VerticalGroup):
+    """An entry in the Launcher grid select."""
+
+    def __init__(self, digit: str, agent: Agent) -> None:
+        self._digit = digit
+        self._agent = agent
+        super().__init__()
+
+    @property
+    def agent(self) -> Agent:
+        return self._agent
+
+    def compose(self) -> ComposeResult:
+        agent = self._agent
+        with containers.HorizontalGroup():
+            if self._digit:
+                yield widgets.Label(self._digit, classes="digit")
+            with containers.VerticalGroup():
+                yield widgets.Label(agent["name"], id="name")
+                yield widgets.Label(agent.get("author_name", ""), id="author")
+                yield widgets.Static(agent.get("description", ""), id="description")
+
+
+class Launcher(containers.VerticalGroup):
+    app = getters.app(A2TUIApp)
+    grid_select = getters.query_one("#launcher-grid-select", GridSelect)
+    DIGITS = "123456789ABCDEF"
+
+    def __init__(
+        self,
+        agents: dict[str, Agent],
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        self._agents = agents
+        super().__init__(name=name, id=id, classes=classes)
+
+    @property
+    def highlighted(self) -> int | None:
+        return self.grid_select.highlighted
+
+    @highlighted.setter
+    def highlighted(self, value: int) -> None:
+        self.grid_select.highlighted = value
+
+    def focus(self, scroll_visible: bool = True) -> "Self":
+        try:
+            self.grid_select.focus(scroll_visible=scroll_visible)
+        except NoMatches:
+            pass
+        return self
+
+    def compose(self) -> ComposeResult:
+        launcher_agents = list(
+            dict.fromkeys(
+                identity
+                for identity in self.app.settings.get(
+                    "launcher.agents", str
+                ).splitlines()
+                if identity.strip()
+            )
+        )
+        agents = self._agents
+        self.set_class(not launcher_agents, "-empty")
+        if launcher_agents:
+            with GridSelect(
+                id="launcher-grid-select", min_column_width=32, max_column_width=32
+            ):
+                for digit, identity in zip_longest(self.DIGITS, launcher_agents):
+                    if identity is None:
+                        break
+                    if identity in agents:
+                        yield LauncherItem(digit or "", agents[identity])
+
+        if not launcher_agents:
+            yield widgets.Label("Choose your fighter below!", classes="no-agents")
+
+    def launch_highlighted(self) -> None:
+        self.grid_select.action_select()
+
+
+class Container(containers.VerticalScroll):
+    BINDING_GROUP_TITLE = "View"
+
+    def allow_focus(self) -> bool:
+        """Only allow focus when we can scroll."""
+        return super().allow_focus() and self.show_vertical_scrollbar
+
+
+class StoreScreen(Screen):
+    BINDING_GROUP_TITLE = "Screen"
+    CSS_PATH = "store.tcss"
+    FOCUS_GROUP = Binding.Group("Focus")
+
+    BINDINGS = [
+        Binding(
+            "tab",
+            "app.focus_next",
+            "Focus Next",
+            group=FOCUS_GROUP,
+        ),
+        Binding(
+            "shift+tab",
+            "app.focus_previous",
+            "Focus Previous",
+            group=FOCUS_GROUP,
+        ),
+        Binding(
+            "null",
+            "quick_launch",
+            "Quick launch",
+            key_display="1-9 a-f",
+        ),
+        Binding("ctrl+r", "resume", "Resume", tooltip="Resume a previous session"),
+        Binding(
+            "ctrl+d",
+            "directory",
+            "Directory",
+            tooltip="Change project directory",
+        ),
+        Binding("escape", "dismiss", "Dismiss"),
+    ]
+
+    agents_view = getters.query_one("#agents-view", GridSelect)
+    launcher = getters.query_one("#launcher", Launcher)
+    container = getters.query_one("#container", Container)
+
+    project_dir: reactive[Path] = reactive(Path)
+
+    app = getters.app(A2TUIApp)
+
+    @dataclass
+    class OpenAgentDetails(Message):
+        identity: str
+
+    def __init__(
+        self, name: str | None = None, id: str | None = None, classes: str | None = None
+    ):
+        self._agents: dict[str, Agent] = {}
+        super().__init__(name=name, id=id, classes=classes)
+        self.project_dir = self.app.project_dir
+
+    @property
+    def agents(self) -> dict[str, Agent]:
+        return self._agents
+
+    def compose(self) -> ComposeResult:
+        with containers.VerticalGroup(id="title-container"):
+            with containers.Grid(id="title-grid"):
+                yield Mandelbrot()
+                yield widgets.Label(self.get_info(), id="info")
+        yield DirectoryDisplay(self.project_dir).data_bind(
+            project_dir=StoreScreen.project_dir
+        )
+        yield Container(id="container", can_focus=False)
+        yield widgets.Footer()
+
+    def get_info(self) -> Content:
+        content = Content.assemble(
+            Content.from_markup("[bold]🐸 A2TUI[/]\n"),
+            Content.from_markup("[dim]Agent store - choose your fighter[/]"),
+        )
+        return content
+
+    
+
+    def compose_agents(self) -> ComposeResult:
+        agents = self._agents
+
+        yield Launcher(agents, id="launcher")
+
+        ordered_agents = sorted(
+            agents.values(), key=lambda agent: agent.get("name", "").casefold()
+        )
+
+        recommended_agents = [
+            agent for agent in ordered_agents if agent.get("recommended", False)
+        ]
+        shuffle(recommended_agents)
+        if recommended_agents:
+            with containers.VerticalGroup(id="sponsored-agents", classes="recommended"):
+                yield widgets.Static(
+                    "[$text-warning u]Recommended[/] [$text-secondary 100% i]Best of the bunch",
+                    classes="heading",
+                )
+                with GridSelect(classes="agents-picker", min_column_width=40):
+                    for agent in recommended_agents:
+                        yield AgentItem(agent)
+
+        chat_bots = [
+            agent for agent in ordered_agents if agent.get("type") in {"chat", "assistant"}
+        ]
+        if chat_bots:
+            yield widgets.Static(
+                "[$text-warning u]Chat & Assistants[/]",
+                classes="heading",
+            )
+            with containers.VerticalGroup():
+                with GridSelect(classes="agents-picker", min_column_width=40):
+                    for agent in chat_bots:
+                        yield AgentItem(agent)
+
+        coding_agents = [agent for agent in ordered_agents if agent.get("type") == "coding"]
+        if coding_agents:
+            yield widgets.Static(
+                "[$text-warning u]Coding agents[/]",
+                classes="heading",
+            )
+            with containers.VerticalGroup():
+                with GridSelect(classes="agents-picker", min_column_width=40):
+                    for agent in coding_agents:
+                        yield AgentItem(agent)
+
+    def move_focus(self, direction: int) -> None:
+        if isinstance(self.focused, GridSelect):
+            focus_chain = list(self.query(GridSelect))
+            if self.focused in focus_chain:
+                index = focus_chain.index(self.focused)
+                new_focus = focus_chain[(index + direction) % len(focus_chain)]
+                if direction == -1:
+                    new_focus.highlight_last()
+                else:
+                    new_focus.highlight_first()
+                new_focus.focus(scroll_visible=False)
+
+    @on(GridSelect.LeaveUp)
+    def on_grid_select_leave_up(self, event: GridSelect.LeaveUp):
+        event.stop()
+        self.move_focus(-1)
+
+    @on(GridSelect.LeaveDown)
+    def on_grid_select_leave_down(self, event: GridSelect.LeaveUp):
+        event.stop()
+        self.move_focus(+1)
+
+    @on(GridSelect.Selected, ".agents-picker")
+    @work
+    async def on_grid_select_selected(self, event: GridSelect.Selected):
+        if not isinstance(event.widget, AgentItem):
+            return
+        assert isinstance(event.widget, AgentItem)
+        from tui.screens.agent_modal import AgentModal
+
+        modal_response = await self.app.push_screen_wait(AgentModal(event.widget.agent))
+        await self.app.save_settings()
+        if modal_response == "launch":
+            self.post_message(messages.LaunchAgent(event.widget.agent["identity"]))
+
+    @on(OpenAgentDetails)
+    @work
+    async def open_agent_detail(self, message: OpenAgentDetails) -> None:
+        from tui.screens.agent_modal import AgentModal
+
+        try:
+            agent = self._agents[message.identity]
+        except KeyError:
+            return
+        modal_response = await self.app.push_screen_wait(AgentModal(agent))
+        await self.app.save_settings()
+        if modal_response == "launch":
+            self.post_message(messages.LaunchAgent(agent["identity"]))
+
+    @on(GridSelect.Selected, "#launcher GridSelect")
+    @work
+    async def on_launcher_selected(self, event: GridSelect.Selected):
+        launcher_item = event.widget
+        assert isinstance(launcher_item, LauncherItem)
+
+        from tui.screens.agent_modal import AgentModal
+
+        modal_response = await self.app.push_screen_wait(
+            AgentModal(launcher_item.agent)
+        )
+        await self.app.save_settings()
+        if modal_response == "launch":
+            self.post_message(messages.LaunchAgent(launcher_item.agent["identity"]))
+
+    @on(ChangeDirectory)
+    def on_change_directory(self, event: ChangeDirectory) -> None:
+        self.project_dir = Path(event.path)
+        self.app.project_dir = self.project_dir
+
+    @work
+    async def on_mount(self) -> None:
+        self.app.settings_changed_signal.subscribe(self, self.setting_updated)
+        if not self.app.settings.get("launcher.agents", str).strip():
+            self.app.settings.set("launcher.agents", "cdh.cloud-dev-harness")
+            await self.app.save_settings()
+        try:
+            self._agents = await read_agents()
+        except Exception as error:
+            self.notify(
+                f"Failed to read agents data ({error})",
+                title="Agents data",
+                severity="error",
+            )
+        else:
+            await self.container.mount_compose(self.compose_agents())
+            with suppress(NoMatches):
+                first_grid = self.container.query(GridSelect).first()
+                first_grid.focus(scroll_visible=False)
+
+    def setting_updated(self, setting: tuple[str, object]) -> None:
+        key, value = setting
+        if key == "launcher.agents":
+            try:
+                launcher = self.launcher
+            except NoMatches:
+                return
+
+            async def _recompose():
+                await launcher.recompose()
+                try:
+                    self.query(GridSelect).first().focus()
+                except Exception:
+                    pass
+
+            asyncio.create_task(_recompose())
+
+    def on_key(self, event: events.Key) -> None:
+        if event.character is None:
+            return
+        LAUNCHER_KEYS = "123456789abcdef"
+
+        if event.character in LAUNCHER_KEYS:
+            launch_item_offset = LAUNCHER_KEYS.find(event.character)
+            try:
+                item = self.launcher.grid_select.children[launch_item_offset]
+            except (IndexError, NoMatches):
+                self.notify(
+                    f"No agent on key [b]{LAUNCHER_KEYS[launch_item_offset]}",
+                    title="Quick launch",
+                    severity="error",
+                )
+                self.app.bell()
+                return
+            if not isinstance(item, LauncherItem):
+                return
+            self.post_message(messages.LaunchAgent(item.agent["identity"]))
+
+    def action_quick_launch(self) -> None:
+        try:
+            self.launcher.focus()
+        except NoMatches:
+            self.notify("Launcher not ready yet", severity="warning")
+
+    @work
+    async def action_resume(self) -> None:
+        from tui.screens.session_resume_modal import SessionResumeModal
+
+        session = await self.app.push_screen_wait(SessionResumeModal())
+        if session is not None:
+            self.post_message(
+                messages.LaunchAgent(
+                    session["agent_identity"],
+                    session["agent_session_id"],
+                    pk=session["id"],
+                )
+            )
+
+    async def action_directory(self) -> None:
+        if (directory_display := self.query_one_optional(DirectoryDisplay)) is not None:
+            directory_display.focus()