@scemoon/cdh 1.0.0

package/tui/widgets/session_tabs.py

@@ -0,0 +1,188 @@
+import asyncio
+from functools import partial
+from rich.style import Style as RichStyle
+
+from textual import work
+from textual.app import ComposeResult, RenderResult
+
+from textual import events
+from textual.content import Content
+from textual.geometry import Offset
+from textual.reactive import reactive
+from textual.renderables.bar import Bar
+from textual.widget import Widget
+from textual import containers
+from textual import widgets
+from textual import getters
+from textual.message import Message
+
+from tui.app import A2TUIApp
+from tui.session_tracker import SessionDetails
+from tui import messages
+
+
+class SessionLabel(widgets.Label):
+    ALLOW_SELECT = False
+
+    def on_click(self) -> None:
+        if self.id is not None:
+            self.post_message(messages.SessionSwitch(self.id))
+
+
+class Underline(Widget):
+    """The animated underline beneath tabs."""
+
+    COMPONENT_CLASSES = {"underline--bar"}
+    """
+    | Class | Description |
+    | :- | :- |
+    | `underline--bar` | Style of the bar (may be used to change the color). |
+    """
+
+    highlight_start = reactive(0)
+    """First cell in highlight."""
+    highlight_end = reactive(0)
+    """Last cell (inclusive) in highlight."""
+    show_highlight: reactive[bool] = reactive(True)
+    """Flag to indicate if a highlight should be shown at all."""
+
+    class Clicked(Message):
+        """Inform ancestors the underline was clicked."""
+
+        offset: Offset
+        """The offset of the click, relative to the origin of the bar."""
+
+        def __init__(self, offset: Offset) -> None:
+            self.offset = offset
+            super().__init__()
+
+    @property
+    def _highlight_range(self) -> tuple[int, int]:
+        """Highlighted range for underline bar."""
+        return (
+            (self.highlight_start, self.highlight_end)
+            if self.show_highlight
+            else (0, 0)
+        )
+
+    def render(self) -> RenderResult:
+        """Render the bar."""
+        bar_style = self.get_component_rich_style("underline--bar")
+        return Bar(
+            highlight_range=self._highlight_range,
+            highlight_style=RichStyle.from_color(bar_style.color),
+            background_style=RichStyle.from_color(bar_style.bgcolor),
+        )
+
+    def _on_click(self, event: events.Click):
+        """Catch clicks, so that the underline can activate the tabs."""
+        event.stop()
+        self.post_message(self.Clicked(event.screen_offset))
+
+
+class SessionsTabs(Widget):
+
+    ALLOW_SELECT = False
+    app: getters.app[A2TUIApp] = getters.app(A2TUIApp)
+
+    title_container = getters.query_one("#title-container", Widget)
+
+    current_session = reactive("", init=False)
+
+    def on_mount(self) -> None:
+        self.current_session = self.app.current_mode
+        self.app.mode_change_signal.subscribe(self, self.handle_mode_change)
+        self.app.session_update_signal.subscribe(
+            self, self.handle_session_update_signal, immediate=True
+        )
+        self.update_underline(self.current_session, animate=False)
+        self.call_after_refresh(self.update_underline, self.current_session)
+
+    def handle_mode_change(self, mode: str) -> None:
+        self.current_session = mode
+
+    def watch_current_session(self, old_session: str, new_session: str) -> None:
+        self.query(".-current").remove_class("-current")
+        self.query(f"#{new_session}").add_class("-current")
+        if old_session:
+            self.update_underline(old_session, animate=False)
+
+        self.update_underline(new_session, animate=True)
+
+    def update_underline(self, session: str | None = None, animate: bool = True):
+        if not self.is_mounted or not self.is_attached:
+            return
+        if session is None:
+            session = self.current_session
+        if not session:
+            return
+        if current_label := self.query_one_optional(f"#{session}", SessionLabel):
+            tab_region = current_label.virtual_region.shrink((0, 1, 0, 1))
+            if not tab_region:
+                return
+            start, end = tab_region.column_span
+            underline = self.query_one(Underline)
+            if animate:
+                underline.animate("highlight_start", start, duration=0.3)
+                underline.animate(
+                    "highlight_end",
+                    end,
+                    duration=0.3,
+                    on_complete=partial(self.scroll_to_center, current_label),
+                )
+            else:
+                underline.highlight_start = start
+                underline.highlight_end = end
+                self.scroll_to_center(current_label, animate=False)
+
+    def render_session_label(self, session: SessionDetails) -> Content:
+        match session.state:
+            case "asking":
+                return Content.assemble(
+                    ("❯ ", "not dim $text-secondary"), session.title
+                )
+            case "busy":
+                return Content(f"⌛ {session.title}")
+        return Content(session.title)
+
+    def compose(self) -> ComposeResult:
+        with containers.HorizontalGroup(id="title-container"):
+            for session in self.app.session_tracker.ordered_sessions:
+                yield SessionLabel(
+                    self.render_session_label(session),
+                    id=session.mode_name,
+                    classes="-current" if session.mode_name == self.screen.id else "",
+                )
+        yield Underline()
+
+    @work(exit_on_error=False)
+    async def handle_session_update_signal(
+        self, update: tuple[str, SessionDetails | None]
+    ) -> None:
+        mode, details = update
+        if details is None:
+            removed_mode = mode
+            await self.query(f"#{mode}").remove()
+            if self.current_session == removed_mode:
+                remaining = list(self.query(SessionLabel))
+                if remaining:
+                    new_current = remaining[0].id or ""
+                else:
+                    new_current = ""
+                self.current_session = new_current
+        else:
+            if tab_label := self.query_one_optional(f"#{mode}", SessionLabel):
+                tab_label.update(self.render_session_label(details))
+            else:
+                self.query(SessionLabel).remove_class("-current")
+                await self.title_container.mount(
+                    SessionLabel(
+                        self.render_session_label(details),
+                        id=details.mode_name,
+                        classes=(
+                            "-current" if details.mode_name == self.screen.id else ""
+                        ),
+                    )
+                )
+        await asyncio.sleep(0.05)
+        self.call_after_refresh(self.update_underline, self.current_session)

package/tui/widgets/shell_result.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import Iterable
+
+from textual.app import ComposeResult
+from textual import containers
+from textual.highlight import highlight
+from textual.widgets import Static
+
+
+from tui.menus import MenuItem
+from tui.widgets.non_selectable_label import NonSelectableLabel
+
+
+class ShellResult(containers.HorizontalGroup):
+    def __init__(
+        self,
+        command: str,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        self._command = command
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+
+    def compose(self) -> ComposeResult:
+        yield NonSelectableLabel("$", id="prompt", markup=False)
+        yield Static(highlight(self._command, language="sh"))
+
+    def get_block_menu(self) -> Iterable[MenuItem]:
+        yield from ()
+
+    def get_block_content(self, destination: str) -> str | None:
+        return self._command

package/tui/widgets/shell_terminal.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Iterable
+
+from textual.content import Content
+from textual.dom import DOMNode
+from textual.message import Message
+
+from tui.menus import MenuItem
+from tui.widgets.terminal import Terminal
+
+
+class ShellTerminal(Terminal):
+    """Subclass of Terminal used in the Shell view."""
+
+    @dataclass
+    class Terminate(Message):
+        teminal: ShellTerminal
+
+        @property
+        def control(self) -> DOMNode:
+            return self.terminal
+
+    @dataclass
+    class Interrupt(Message):
+        teminal: ShellTerminal
+
+        @property
+        def control(self) -> DOMNode:
+            return self.terminal
+
+    def get_block_menu(self) -> Iterable[MenuItem]:
+        if not self.is_finalized:
+            yield MenuItem("Interrupt", "interrupt", "i")
+            yield MenuItem("Focus", f"focus_block({self.id!r})", "f")
+
+    def get_block_content(self, destination: str) -> str | None:
+        return "\n".join(line.content.plain for line in self.state.buffer.lines)
+
+    def on_mount(self) -> None:
+        self.border_title = Content(self.name)

package/tui/widgets/side_bar.py

@@ -0,0 +1,114 @@
+from dataclasses import dataclass
+
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual import containers
+from textual import widgets
+from textual.message import Message
+
+
+class SideBarCollapsible(widgets.Collapsible):
+    BINDING_GROUP_TITLE = "Sidebar collapsible"
+    HELP = """\
+## Sidebar
+
+This is your sidebar.
+
+The Sidebar contains additonal information associated with the conversation.
+
+- **tab / shift+tab** Navigate sections
+- **enter** expand or collapse secions
+"""
+
+
+class SideBar(containers.Vertical):
+    BINDING_GROUP_TITLE = "Sidebar"
+    BINDINGS = [("escape", "dismiss", "Dismiss sidebar")]
+
+    class Dismiss(Message):
+        pass
+
+    @dataclass(frozen=True)
+    class Panel:
+        title: str
+        widget: Widget
+        flex: bool = False
+        collapsed: bool = False
+        id: str | None = None
+
+    def __init__(
+        self,
+        *panels: Panel,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+        hide: bool = False,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+        self.panels: list[SideBar.Panel] = [*panels]
+        self.hide = hide
+
+    def on_mount(self) -> None:
+        self.trap_focus()
+
+    def compose(self) -> ComposeResult:
+        for panel in self.panels:
+            yield SideBarCollapsible(
+                panel.widget,
+                title=panel.title,
+                collapsed=panel.collapsed,
+                classes="-flex" if panel.flex else "-fixed",
+                id=panel.id,
+            )
+
+    def action_dismiss(self) -> None:
+        self.post_message(self.Dismiss())
+
+    def has_panel(self, panel_id: str) -> bool:
+        return self.query_one_optional(f"#{panel_id}") is not None
+
+    async def add_panel(self, panel: Panel) -> SideBarCollapsible:
+        collapsible = SideBarCollapsible(
+            panel.widget,
+            title=panel.title,
+            collapsed=panel.collapsed,
+            classes="-flex" if panel.flex else "-fixed",
+            id=panel.id,
+        )
+        await self.mount(collapsible)
+        self.panels.append(panel)
+        return collapsible
+
+    def remove_panel(self, panel_id: str) -> bool:
+        for i, p in enumerate(self.panels):
+            if p.id == panel_id:
+                widget = self.query_one_optional(f"#{panel_id}")
+                if widget is not None:
+                    widget.remove()
+                self.panels.pop(i)
+                return True
+        return False
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    class SApp(App):
+        def compose(self) -> ComposeResult:
+            yield SideBar(
+                SideBar.Panel("Hello", widgets.Label("Hello, World!")),
+                SideBar.Panel(
+                    "Files",
+                    widgets.DirectoryTree(
+                        "~/",
+                    ),
+                    flex=True,
+                ),
+                SideBar.Panel(
+                    "Hello",
+                    widgets.Static("Where there is a Will! " * 10),
+                ),
+            )
+
+    SApp().run()

package/tui/widgets/slash_complete.py

@@ -0,0 +1,235 @@
+from dataclasses import dataclass
+from operator import itemgetter
+from typing import Iterable, Self, Sequence
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.content import Content, Span
+
+from textual import getters
+from textual.message import Message
+from textual.reactive import var
+from textual import containers
+from textual import widgets
+from textual.widgets.option_list import Option
+
+from tui.fuzzy import FuzzySearch
+from tui.messages import Dismiss
+from tui.slash_command import SlashCommand
+from tui.visuals.columns import Columns
+
+
+class SlashCompleteInput(widgets.Input):
+    BINDING_GROUP_TITLE = "Fuzzy search slash commands"
+    HELP = """\
+## Slash command fuzzy search
+
+Search for slash commands by typing a few characters from the command.
+
+- **cursor keys** Navigate list
+- **enter** Add command to prompt
+- **escape** Dismiss fuzzy search
+"""
+
+
+class SlashComplete(containers.VerticalGroup):
+    """A widget to auto-complete slash commands."""
+
+    CURSOR_BINDING_GROUP = Binding.Group(description="Select")
+    BINDINGS = [
+        Binding(
+            "up",
+            "cursor_up",
+            "Cursor up",
+            group=CURSOR_BINDING_GROUP,
+            priority=True,
+        ),
+        Binding(
+            "down",
+            "cursor_down",
+            "Cursor down",
+            group=CURSOR_BINDING_GROUP,
+            priority=True,
+        ),
+        Binding("enter", "submit", "Insert /command", priority=True),
+        Binding("escape", "dismiss", "Dismiss", priority=True),
+    ]
+
+    DEFAULT_CSS = """
+    SlashComplete {
+        OptionList {
+            height: auto;
+        }
+    }
+    """
+
+    input = getters.query_one(widgets.Input)
+    option_list = getters.query_one(widgets.OptionList)
+
+    slash_commands: var[list[SlashCommand]] = var(list)
+
+    @dataclass
+    class Completed(Message):
+        command: str
+
+    def __init__(
+        self,
+        slash_commands: Iterable[SlashCommand] | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(id=id, classes=classes)
+        self.slash_commands = list(slash_commands) if slash_commands else []
+        self.hints = {
+            slash_command.command: slash_command.hint
+            for slash_command in self.slash_commands
+            if slash_command.hint
+        }
+
+        self.fuzzy_search = FuzzySearch(case_sensitive=False)
+
+    def compose(self) -> ComposeResult:
+        yield SlashCompleteInput(compact=True, placeholder="fuzzy search")
+        yield widgets.OptionList()
+
+    def focus(self, scroll_visible: bool = False) -> Self:
+        self.filter_slash_commands("")
+        self.input.focus(scroll_visible)
+        return self
+
+    def on_mount(self) -> None:
+        self.filter_slash_commands("")
+
+    def on_descendant_blur(self) -> None:
+        self.post_message(Dismiss(self))
+
+    @on(widgets.Input.Changed)
+    def on_input_changed(self, event: widgets.Input.Changed) -> None:
+        event.stop()
+        self.filter_slash_commands(event.value)
+
+    async def watch_slash_commands(self, slash_commands: list[SlashCommand]) -> None:
+        self.hints = {
+            slash_command.command: slash_command.hint
+            for slash_command in slash_commands
+            if slash_command.hint
+        }
+        self.filter_slash_commands(self.input.value)
+
+    def filter_slash_commands(self, prompt: str) -> None:
+        """Filter slash commands by the given prompt.
+
+        Args:
+            prompt: Text prompt.
+        """
+        prompt = prompt.lstrip("/").casefold().rstrip()
+        columns = self.columns = Columns("auto", "flex")
+
+        slash_commands = sorted(
+            self.slash_commands,
+            key=lambda slash_command: slash_command.command.casefold(),
+        )
+        deduplicated_slash_commands = {
+            slash_command.command: slash_command for slash_command in slash_commands
+        }
+        self.fuzzy_search.cache.grow(len(deduplicated_slash_commands))
+
+        if prompt:
+            slash_prompt = f"/{prompt}"
+            scores: list[tuple[float, Sequence[int], SlashCommand]] = [
+                (
+                    *self.fuzzy_search.match(prompt, slash_command.command[1:]),
+                    slash_command,
+                )
+                for slash_command in slash_commands
+            ]
+
+            scores = sorted(
+                [
+                    (
+                        (
+                            score * 2
+                            if slash_command.command.casefold().startswith(slash_prompt)
+                            else score
+                        ),
+                        highlights,
+                        slash_command,
+                    )
+                    for score, highlights, slash_command in scores
+                    if score
+                ],
+                key=itemgetter(0),
+                reverse=True,
+            )
+        else:
+            scores = [(1.0, [], slash_command) for slash_command in slash_commands]
+
+        def make_row(
+            slash_command: SlashCommand, indices: Iterable[int]
+        ) -> tuple[Content, ...]:
+            """Make a row for the Columns display.
+
+            Args:
+                slash_command: The slash command instance.
+                indices: Indices of matching characters.
+
+            Returns:
+                A tuple of `Content` instances for use as a column row.
+            """
+            command = Content.styled(slash_command.command, "$text-success")
+            command = command.add_spans(
+                [Span(index + 1, index + 2, "underline not dim") for index in indices]
+            )
+            return (command, Content.styled(slash_command.help, "dim"))
+
+        rows = [
+            (
+                columns.add_row(
+                    *make_row(slash_command, indices),
+                ),
+                slash_command.command,
+            )
+            for _, indices, slash_command in scores
+        ]
+        self.option_list.set_options(
+            Option(row, id=command_name) for row, command_name in rows
+        )
+        if self.display:
+            self.option_list.highlighted = 0
+        else:
+            with self.option_list.prevent(widgets.OptionList.OptionHighlighted):
+                self.option_list.highlighted = 0
+
+    def action_cursor_down(self) -> None:
+        self.option_list.action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self.option_list.action_cursor_up()
+
+    def action_dismiss(self) -> None:
+        self.post_message(Dismiss(self))
+
+    def action_submit(self) -> None:
+        option_list = self.option_list
+        if (option := option_list.highlighted_option) is not None:
+            with self.input.prevent(widgets.Input.Changed):
+                self.input.clear()
+            self.post_message(self.Completed(option.id or ""))
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    COMMANDS = [
+        SlashCommand("/help", "Help with slash commands"),
+        SlashCommand("/foo", "This is FOO"),
+        SlashCommand("/bar", "This is BAR"),
+        SlashCommand("/baz", "This is BAZ"),
+    ]
+
+    class SlashApp(App):
+        def compose(self) -> ComposeResult:
+            yield SlashComplete(COMMANDS)
+
+    SlashApp().run()

package/tui/widgets/strike_text.py

@@ -0,0 +1,70 @@
+from time import monotonic
+
+from textual.widget import Widget
+
+from textual.content import Content
+from textual.reactive import reactive
+
+
+class StrikeText(Widget):
+    DEFAULT_CSS = """
+    StrikeText {
+        height: auto;
+        &.-complete {
+            text-style: strike;
+            color: $text-primary;
+        }
+    }
+    """
+
+    strike_time: reactive[float | None] = reactive(None)
+
+    def __init__(
+        self,
+        content: Content,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        self.content = content
+        super().__init__(name=name, id=id, classes=classes)
+
+    def strike(self) -> None:
+        self.strike_time = monotonic()
+        self.auto_refresh = 1 / 30
+
+    def render(self) -> Content:
+        content = self.content
+        if self.strike_time is not None:
+            position = int((monotonic() - self.strike_time) * 70)
+            content = content.stylize("strike $text-primary", 0, position)
+            if position > len(content):
+                self.auto_refresh = None
+        return content
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+    from textual.widgets import Static
+
+    class StrikeApp(App):
+        CSS = """
+        Screen {
+            overflow: auto;
+        }
+
+        """
+        BINDINGS = [("space", "strike", "Strike")]
+
+        def compose(self) -> ComposeResult:
+            for n in range(20):
+                yield Static("HELLO")
+            yield StrikeText(Content("Where there is a Will, there is a way"))
+            for n in range(200):
+                yield Static("World")
+
+        def action_strike(self):
+            self.query_one(StrikeText).strike()
+
+    app = StrikeApp()
+    app.run()