batrachian-toad 0.5.22__py3-none-any.whl

toad/screens/agent_modal.py

@@ -0,0 +1,172 @@
+from typing import cast
+
+from textual import on
+from textual import getters
+from textual.app import ComposeResult
+
+from textual import work
+from textual.screen import ModalScreen
+from textual import containers
+from textual import widgets
+from textual.reactive import var
+
+import toad
+from textual.binding import Binding
+from toad.agent_schema import Action, Agent, OS, Command
+from toad.app import ToadApp
+
+
+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(ToadApp)
+    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["actions"]
+
+        script_os = cast(OS, toad.os)
+        if script_os not in actions:
+            script_os = "*"
+
+        commands: dict[Action, Command] = actions[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(
+                        f"{agent['name']} requires an ACP adapter to work with Toad. 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["actions"]
+
+        if (commands := agent_actions.get(toad.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 toad.screens.action_modal import ActionModal
+        from toad.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

toad/screens/command_edit_modal.py

@@ -0,0 +1,58 @@
+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 = [("escape", "dismiss", "Dismiss")]
+
+    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"):
+            yield widgets.Static(
+                "Toad will run the following command(s).\n\nEdit if you want to.",
+                classes="instructions",
+            )
+            yield widgets.TextArea(
+                self.command, language="bash", highlight_cursor_line=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)
+
+
+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()

toad/screens/main.py

@@ -0,0 +1,192 @@
+from functools import partial
+from pathlib import Path
+import random
+
+from textual import on
+from textual.app import ComposeResult
+from textual import getters
+from textual.binding import Binding
+from textual.command import Hit, Hits, Provider, DiscoveryHit
+from textual.content import Content
+from textual.screen import Screen
+from textual.reactive import var, reactive
+from textual.widgets import Footer, OptionList, DirectoryTree, Tree
+from textual import containers
+from textual.widget import Widget
+
+
+from toad.app import ToadApp
+from toad import messages
+from toad.agent_schema import Agent
+from toad.acp import messages as acp_messages
+from toad.widgets.plan import Plan
+from toad.widgets.throbber import Throbber
+from toad.widgets.conversation import Conversation
+from toad.widgets.project_directory_tree import ProjectDirectoryTree
+from toad.widgets.side_bar import SideBar
+
+
+class ModeProvider(Provider):
+    async def search(self, query: str) -> Hits:
+        """Search for Python files."""
+        matcher = self.matcher(query)
+
+        screen = self.screen
+        assert isinstance(screen, MainScreen)
+
+        for mode in sorted(
+            screen.conversation.modes.values(), key=lambda mode: mode.name
+        ):
+            command = mode.name
+            score = matcher.match(command)
+            if score > 0:
+                yield Hit(
+                    score,
+                    matcher.highlight(command),
+                    partial(screen.conversation.set_mode, mode.id),
+                    help=mode.description,
+                )
+
+    async def discover(self) -> Hits:
+        screen = self.screen
+        assert isinstance(screen, MainScreen)
+
+        for mode in sorted(
+            screen.conversation.modes.values(), key=lambda mode: mode.name
+        ):
+            yield DiscoveryHit(
+                mode.name,
+                partial(screen.conversation.set_mode, mode.id),
+                help=mode.description,
+            )
+
+
+class MainScreen(Screen, can_focus=False):
+    AUTO_FOCUS = "Conversation Prompt TextArea"
+
+    COMMANDS = {ModeProvider}
+    BINDINGS = [
+        Binding("f3", "show_sidebar", "Sidebar"),
+    ]
+
+    BINDING_GROUP_TITLE = "Screen"
+    busy_count = var(0)
+    throbber: getters.query_one[Throbber] = getters.query_one("#throbber")
+    conversation = getters.query_one(Conversation)
+    side_bar = getters.query_one(SideBar)
+    project_directory_tree = getters.query_one("#project_directory_tree")
+
+    column = reactive(False)
+    column_width = reactive(100)
+    scrollbar = reactive("")
+    project_path: var[Path] = var(Path("./").expanduser().absolute())
+
+    app = getters.app(ToadApp)
+
+    def __init__(self, project_path: Path, agent: Agent | None = None) -> None:
+        super().__init__()
+        self.set_reactive(MainScreen.project_path, project_path)
+        self._agent = agent
+
+    def get_loading_widget(self) -> Widget:
+        throbber = self.app.settings.get("ui.throbber", str)
+        if throbber == "quotes":
+            from toad.app import QUOTES
+            from toad.widgets.future_text import FutureText
+
+            quotes = QUOTES.copy()
+            random.shuffle(quotes)
+            return FutureText([Content(quote) for quote in quotes])
+        return super().get_loading_widget()
+
+    def compose(self) -> ComposeResult:
+        with containers.Center():
+            yield SideBar(
+                SideBar.Panel("Plan", Plan([])),
+                SideBar.Panel(
+                    "Project",
+                    ProjectDirectoryTree(
+                        self.project_path,
+                        id="project_directory_tree",
+                    ),
+                    flex=True,
+                ),
+            )
+            yield Conversation(self.project_path, self._agent).data_bind(
+                project_path=MainScreen.project_path,
+                column=MainScreen.column,
+            )
+        yield Footer()
+
+    def update_node_styles(self, animate: bool = True) -> None:
+        self.conversation.update_node_styles(animate=animate)
+        self.query_one(Footer).update_node_styles(animate=animate)
+        self.query_one(SideBar).update_node_styles(animate=animate)
+
+    @on(messages.ProjectDirectoryUpdated)
+    async def on_project_directory_update(self) -> None:
+        await self.query_one(ProjectDirectoryTree).reload()
+
+    @on(DirectoryTree.FileSelected, "ProjectDirectoryTree")
+    def on_project_directory_tree_selected(self, event: Tree.NodeSelected):
+        if (data := event.node.data) is not None:
+            self.conversation.insert_path_into_prompt(data.path)
+
+    @on(acp_messages.Plan)
+    async def on_acp_plan(self, message: acp_messages.Plan):
+        message.stop()
+        entries = [
+            Plan.Entry(
+                Content(entry["content"]),
+                entry.get("priority", "medium"),
+                entry.get("status", "pending"),
+            )
+            for entry in message.entries
+        ]
+        self.query_one("SideBar Plan", Plan).entries = entries
+
+    def on_mount(self) -> None:
+        for tree in self.query("#project_directory_tree").results(DirectoryTree):
+            tree.data_bind(path=MainScreen.project_path)
+        for tree in self.query(DirectoryTree):
+            #     tree.show_guides = False
+            tree.guide_depth = 3
+
+    @on(OptionList.OptionHighlighted)
+    def on_option_list_option_highlighted(
+        self, event: OptionList.OptionHighlighted
+    ) -> None:
+        if event.option.id is not None:
+            self.conversation.prompt.suggest(event.option.id)
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action == "show_sidebar" and self.side_bar.has_focus_within:
+            return False
+        return True
+
+    def action_show_sidebar(self) -> None:
+        self.side_bar.query_one("Collapsible CollapsibleTitle").focus()
+
+    def action_focus_prompt(self) -> None:
+        self.conversation.focus_prompt()
+
+    @on(SideBar.Dismiss)
+    def on_side_bar_dismiss(self, message: SideBar.Dismiss):
+        message.stop()
+        self.conversation.focus_prompt()
+
+    def watch_column(self, column: bool) -> None:
+        self.conversation.styles.max_width = (
+            max(10, self.column_width) if column else None
+        )
+
+    def watch_column_width(self, column_width: int) -> None:
+        self.conversation.styles.max_width = (
+            max(10, column_width) if self.column else None
+        )
+
+    def watch_scrollbar(self, old_scrollbar: str, scrollbar: str) -> None:
+        if old_scrollbar:
+            self.conversation.remove_class(f"-scrollbar-{old_scrollbar}")
+        if scrollbar:
+            self.conversation.add_class(f"-scrollbar-{scrollbar}")