@scemoon/cdh 1.0.0

package/tui/prompt/resource.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+import mimetypes
+from pathlib import Path
+
+
+@dataclass
+class Resource:
+    root: Path
+    path: Path
+    mime_type: str
+    text: str | None
+    data: bytes | None
+
+
+class ResourceError(Exception):
+    """An error occurred reading a resource."""
+
+
+class ResourceNotRelative(ResourceError):
+    """Attempted to read a resource, not in the project directory."""
+
+
+class ResourceReadError(ResourceError):
+    """Failed to read the resource."""
+
+
+def load_resource(root: Path, path: Path) -> Resource:
+    """Load a resource from the project directory.
+
+    Args:
+        root: The project root.
+        path: Relative path within project.
+
+    Returns:
+        A resource.
+    """
+    resource_path = root / path
+
+    if not resource_path.is_relative_to(root):
+        raise ResourceNotRelative("Resource path is not relative to project root.")
+
+    mime_type, encoding = mimetypes.guess_file_type(resource_path)
+    if mime_type is None:
+        mime_type = "application/octet-stream"
+
+    data: bytes | None
+    text: str | None
+
+    try:
+        if encoding is not None:
+            data = resource_path.read_bytes()
+            text = None
+        else:
+            data = None
+            text = resource_path.read_text(encoding, errors="replace")
+    except FileNotFoundError:
+        raise ResourceReadError(f"File not found {str(path)!r}")
+    except Exception as error:
+        raise ResourceReadError(f"Failed to read {str(path)!r}; {error}")
+
+    resource = Resource(
+        root,
+        resource_path,
+        mime_type=mime_type,
+        text=text,
+        data=data,
+    )
+    return resource

package/tui/protocol.py

@@ -0,0 +1,28 @@
+from typing import Protocol, runtime_checkable, Iterable
+
+from textual.widget import Widget
+
+from tui.menus import MenuItem
+
+
+@runtime_checkable
+class BlockProtocol(Protocol):
+    def block_cursor_up(self) -> Widget | None: ...
+    def block_cursor_down(self) -> Widget | None: ...
+    def get_cursor_block(self) -> Widget | None: ...
+    def block_cursor_clear(self) -> None: ...
+    def block_select(self, widget: Widget) -> None: ...
+
+
+@runtime_checkable
+class MenuProtocol(Protocol):
+    def get_block_menu(self) -> Iterable[MenuItem]: ...
+    def get_block_content(self, destination: str) -> str | None: ...
+
+
+@runtime_checkable
+class ExpandProtocol(Protocol):
+    def can_expand(self) -> bool: ...
+    def expand_block(self) -> None: ...
+    def collapse_block(self) -> None: ...
+    def is_block_expanded(self) -> bool: ...

package/tui/screens/action_modal.py

@@ -0,0 +1,94 @@
+import shutil
+
+from textual.app import ComposeResult
+from textual import on, work
+from textual import containers
+from textual import getters
+from textual.content import Content
+from textual.screen import ModalScreen
+from textual import widgets
+from textual.widget import Widget
+
+from tui.app import A2TUIApp
+from tui.widgets.command_pane import CommandPane
+
+
+UV_INSTALL = "curl -LsSf https://astral.sh/uv/install.sh | sh"
+
+
+class ActionModal(ModalScreen):
+    """Executes an action command."""
+
+    command_pane = getters.query_one(CommandPane)
+    ok_button = getters.query_one("#ok", widgets.Button)
+
+    app = getters.app(A2TUIApp)
+
+    BINDINGS = [("escape", "dismiss_modal", "Dismiss")]
+
+    def __init__(
+        self,
+        action: str,
+        agent: str,
+        title: str,
+        command: str,
+        *,
+        bootstrap_uv: bool = False,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        self._action = action
+        self._agent = agent
+        self._title = title
+        self._command = command
+        self._bootstrap_uv = bootstrap_uv
+        super().__init__(name=name, id=id, classes=classes)
+
+    def get_loading_widget(self) -> Widget:
+        return widgets.LoadingIndicator()
+
+    def compose(self) -> ComposeResult:
+        with containers.VerticalGroup(id="container"):
+            yield CommandPane()
+            yield widgets.Button("OK", id="ok", disabled=True)
+
+    def enable_button(self) -> None:
+        self.ok_button.loading = False
+        self.ok_button.disabled = False
+        self.ok_button.focus()
+
+    @on(CommandPane.CommandComplete)
+    def on_command_complete(self, event: CommandPane.CommandComplete) -> None:
+        self.enable_button()
+
+    def on_mount(self) -> None:
+        self.ok_button.loading = True
+        self.command_pane.border_title = Content(self._title)
+        self.run_command()
+
+    @work()
+    async def run_command(self) -> None:
+        """Write and execute the command."""
+        self.command_pane.anchor()
+        if self._bootstrap_uv and shutil.which("uv") is None:
+            # Bootstrap UV if required
+            await self.command_pane.write(f"$ {UV_INSTALL}\n")
+            await self.command_pane.execute(UV_INSTALL, final=False)
+
+        await self.command_pane.write(f"$ {self._command}\n")
+        action_task = self.command_pane.execute(self._command)
+        await action_task
+        self.app.capture_event(
+            "agent-action",
+            action=self._action,
+            agent=self._agent,
+            fail=self.command_pane.return_code != 0,
+        )
+
+    @on(widgets.Button.Pressed)
+    def on_button_pressed(self) -> None:
+        self.action_dismiss_modal()
+
+    def action_dismiss_modal(self) -> None:
+        self.dismiss(self.command_pane.return_code)

package/tui/screens/agent_modal.py

@@ -0,0 +1,175 @@
+from typing import cast
+
+from textual import on
+from textual import getters
+from textual.app import ComposeResult
+
+from textual import work
+from textual.content import Content
+from textual.screen import ModalScreen
+from textual import containers
+from textual import widgets
+from textual.reactive import var
+
+import tui
+from textual.binding import Binding
+from tui.agent_schema import Action, Agent, OS, Command
+from tui.app import A2TUIApp
+
+
+class DescriptionContainer(containers.VerticalScroll):
+    def allow_focus(self) -> bool:
+        """Focus only if it can be scrolled."""
+        return self.show_vertical_scrollbar
+
+
+class AgentModal(ModalScreen):
+    AUTO_FOCUS = "Select#action-select"
+
+    BINDINGS = [
+        Binding("escape", "dismiss(None)", "Dismiss", show=False),
+        Binding("space", "dismiss('launch')", "Launch agent", priority=True),
+    ]
+
+    action = var("")
+
+    app = getters.app(A2TUIApp)
+    action_select = getters.query_one("#action-select", widgets.Select)
+    launcher_checkbox = getters.query_one("#launcher-checkbox", widgets.Checkbox)
+
+    def __init__(self, agent: Agent) -> None:
+        self._agent = agent
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        launcher_set = frozenset(
+            self.app.settings.get("launcher.agents", str).splitlines()
+        )
+
+        agent = self._agent
+
+        app = self.app
+        launcher_set = frozenset(app.settings.get("launcher.agents", str).splitlines())
+        agent = self._agent
+        actions = agent.get("actions", {})
+
+        script_os = cast(OS, tui.os)
+        if script_os not in actions:
+            script_os = "*"
+
+        commands: dict[Action, Command] = actions.get(cast(OS, script_os), {})
+        script_choices = [
+            (action["description"], name) for name, action in commands.items()
+        ]
+        script_choices.append((f"Launch {agent['name']}", "__launch__"))
+
+        with containers.Vertical(id="container"):
+            with DescriptionContainer(id="description-container"):
+                yield widgets.Markdown(agent["help"], id="description")
+            with containers.VerticalGroup():
+                if "install_acp" in commands:
+                    yield widgets.Static(
+                        Content(
+                            f"{agent['name']} requires an ACP adapter to work with A2TUI. Install from the actions list."
+                        ),
+                        classes="acp-warning",
+                    )
+                with containers.HorizontalGroup():
+                    yield widgets.Checkbox(
+                        "Show in launcher",
+                        value=agent["identity"] in launcher_set,
+                        id="launcher-checkbox",
+                    )
+                    yield widgets.Select(
+                        script_choices,
+                        prompt="Actions",
+                        allow_blank=True,
+                        id="action-select",
+                    )
+                    yield widgets.Button(
+                        "Go", variant="primary", id="run-action", disabled=True
+                    )
+        yield widgets.Footer()
+
+    def on_mount(self) -> None:
+        self.query_one("Footer").styles.animate("opacity", 1.0, duration=500 / 1000)
+
+    @on(widgets.Checkbox.Changed)
+    def on_checkbox_changed(self, event: widgets.Select.Changed) -> None:
+        launcher_agents = self.app.settings.get("launcher.agents", str).splitlines()
+        agent_identity = self._agent["identity"]
+        if agent_identity in launcher_agents:
+            launcher_agents.remove(agent_identity)
+        if event.value:
+            launcher_agents.insert(0, agent_identity)
+        self.app.settings.set("launcher.agents", "\n".join(launcher_agents))
+
+    @on(widgets.Select.Changed)
+    def on_select_changed(self, event: widgets.Select.Changed) -> None:
+        self.action = event.value if isinstance(event.value, str) else ""
+
+    @work
+    @on(widgets.Button.Pressed)
+    async def on_button_pressed(self) -> None:
+        agent = self._agent
+        action = self.action_select.value
+
+        assert isinstance(action, str)
+        if action == "__launch__":
+            self.dismiss("launch")
+            return
+
+        agent_actions = self._agent.get("actions", {})
+
+        if (commands := agent_actions.get(tui.os, None)) is None:
+            commands = agent_actions.get("*", None)
+        if commands is None:
+            self.notify(
+                "Action is not available on this platform",
+                title="Agent action",
+                severity="error",
+            )
+            return
+        command = commands[action]
+
+        from tui.screens.action_modal import ActionModal
+        from tui.screens.command_edit_modal import CommandEditModal
+
+        title = command["description"]
+        agent_id = self._agent["identity"]
+        action_command = command["command"]
+        bootstrap_uv = command.get("bootstrap_uv", False)
+
+        agent = self._agent
+        # Focus the select
+        # It's unlikely the user wants to re-run the action
+        self.action_select.focus()
+
+        action_command = await self.app.push_screen_wait(
+            CommandEditModal(action_command)
+        )
+        if action_command is None:
+            return
+
+        return_code = await self.app.push_screen_wait(
+            ActionModal(
+                action,
+                agent_id,
+                title,
+                action_command,
+                bootstrap_uv=bootstrap_uv,
+            )
+        )
+        if return_code == 0 and action in {"install", "install-acp"}:
+            # Add to launcher if we installed something
+            if not self.launcher_checkbox.value:
+                self.notify(
+                    f"{agent['name']} has been added to your launcher",
+                    title="Add agent",
+                    severity="information",
+                )
+                self.launcher_checkbox.value = True
+
+    def watch_action(self, action: str) -> None:
+        go_button = self.query_one("#run-action", widgets.Button)
+        go_button.disabled = not action

package/tui/screens/command_edit_modal.py

@@ -0,0 +1,74 @@
+from textual import on, work
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual import widgets
+from textual import containers
+from textual import getters
+
+
+class CommandEditModal(ModalScreen[str | None]):
+    BINDINGS = [
+        ("ctrl+c", "copy", "Copy to clipboard"),
+        ("escape", "dismiss", "Dismiss"),
+    ]
+    AUTO_FOCUS = "Button"
+
+    text_area = getters.query_one(widgets.TextArea)
+
+    def __init__(
+        self,
+        command: str,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        self.command = command
+        super().__init__(name=name, id=id, classes=classes)
+
+    def compose(self) -> ComposeResult:
+        with containers.VerticalGroup(id="container"):
+            with containers.Center():
+                yield widgets.Label(
+                    "[b]Run command",
+                    classes="instructions",
+                )
+            yield widgets.Static(
+                "A2TUI will run the following command (edit if you need to).",
+                classes="instructions",
+            )
+            yield widgets.TextArea(
+                self.command,
+                language="bash",
+                highlight_cursor_line=False,
+                soft_wrap=False,
+            )
+            with containers.HorizontalGroup(id="button-container"):
+                yield widgets.Button("OK", variant="primary", id="ok")
+                yield widgets.Button(
+                    "Cancel", id="cancel", action="screen.dismiss(None)"
+                )
+        yield widgets.Footer()
+
+    @on(widgets.Button.Pressed, "#ok")
+    def on_ok_pressed(self, event: widgets.Button.Pressed) -> None:
+        self.dismiss(self.text_area.text)
+
+    @on(widgets.Button.Pressed, "#cancel")
+    def on_cancel_pressed(self, event: widgets.Button.Pressed) -> None:
+        self.dismiss(None)
+
+    def action_copy(self) -> None:
+        self.app.copy_to_clipboard(self.text_area.text)
+        self.notify("Command copied to clipboard", title="Copy")
+
+
+if __name__ == "__main__":
+    from textual.app import App
+
+    class ModalApp(App):
+        @work
+        async def on_mount(self) -> None:
+            result = await self.push_screen_wait(CommandEditModal("ls -al"))
+            self.notify(str(result))
+
+    ModalApp().run()