@scemoon/cdh 1.0.6 → 1.0.8

package/tui/widgets/session_tabs.py

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

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

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

@@ -1,124 +0,0 @@
-from dataclasses import dataclass
-
-from textual.app import ComposeResult
-from textual.binding import Binding
-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"
-    BINDINGS = [
-        Binding("down", "focus_content", "Focus content", show=False),
-    ]
-    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
-"""
-
-    def action_focus_content(self) -> None:
-        """Move focus into the content area when expanded."""
-        if self.collapsed:
-            return
-        self.screen.focus_next()
-
-
-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

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

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