vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/ui/floating_list.py

@@ -0,0 +1,370 @@
+"""
+Floating list overlay for inline completion.
+
+A reusable overlay component that renders below the input, showing
+a paginated list with arrow indicator and counter. Used for:
+- Slash commands (/)
+- File path search (@)
+- Session selection
+- Any other searchable list
+"""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TypeVar
+
+from rich.text import Text
+from textual import events
+from textual.reactive import reactive
+from textual.widget import Widget
+
+from vtx import config
+
+T = TypeVar("T")
+
+
+@dataclass
+class ListItem[T]:
+    value: T
+    label: str
+    description: str = ""
+    prefix: str = ""
+    prefix_style: str = ""
+
+    def __hash__(self) -> int:
+        return hash((self.label, self.description))
+
+
+class FloatingList[T](Widget):
+    """
+    A floating overlay list with pagination and selection.
+
+    Features:
+    - Arrow indicator (→) for selected item
+    - Position counter (x/total)
+    - Window-based pagination (shows subset of items)
+    - Keyboard navigation (up/down)
+    - Optional search bar for filtering (two-layer commands)
+    - Hidden by default, show/hide controlled by parent
+
+    The parent widget is responsible for:
+    - Calling show(items) with filtered items
+    - Calling hide() to dismiss
+    - Calling move_up()/move_down() on key events
+    - Reading selected_item when user confirms
+    """
+
+    DEFAULT_CSS = """
+    FloatingList {
+        height: auto;
+        display: none;
+        padding: 0 1;
+    }
+
+    FloatingList.-visible {
+        display: block;
+    }
+    """
+
+    # Reactive to trigger re-render
+    _selected_index: reactive[int] = reactive(0, repaint=False)
+    _visible: reactive[bool] = reactive(False, repaint=False)
+    _render_key: reactive[int] = reactive(0)  # Force re-render
+
+    def __init__(
+        self,
+        window_size: int = 5,
+        label_width: int = 6,
+        max_label_width: int = 30,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(id=id, classes=classes)
+        self._window_size = window_size
+        self._min_label_width = label_width
+        self._default_max_label_width = max_label_width
+        self._max_label_width = max_label_width
+        self._label_width = label_width
+        self._items: list[ListItem[T]] = []
+
+        # Search state
+        self._search_enabled = False
+        self._search_query = ""
+        self._all_items: list[ListItem[T]] = []
+        self._description_width = 0
+
+    @property
+    def items(self) -> list[ListItem[T]]:
+        return self._items
+
+    @property
+    def selected_index(self) -> int:
+        return self._selected_index
+
+    @property
+    def selected_item(self) -> ListItem[T] | None:
+        if self._items and 0 <= self._selected_index < len(self._items):
+            return self._items[self._selected_index]
+        return None
+
+    @property
+    def is_visible(self) -> bool:
+        return self._visible
+
+    @property
+    def search_enabled(self) -> bool:
+        return self._search_enabled
+
+    def _get_source_items(self) -> list[ListItem[T]]:
+        if self._search_enabled and self._all_items:
+            return self._all_items
+        return self._items
+
+    def _compute_label_width(self) -> int:
+        source = self._get_source_items()
+        if not source:
+            return self._min_label_width
+
+        max_len = max(len(item.label) for item in source)
+        return max(self._min_label_width, min(max_len, self._max_label_width))
+
+    def _compute_description_width(self) -> int:
+        source = self._get_source_items()
+        if not source:
+            return 0
+        max_desc_len = max((len(item.description) for item in source), default=0)
+        if max_desc_len == 0:
+            return 0
+
+        available_width = max(0, self.size.width - 4) if self.size.width else 0
+        if available_width == 0:
+            return min(max_desc_len, 20)
+
+        # Reserve space for arrow (2), gap between cols (3), label width, and margin (1)
+        reserved = 2 + 3 + self._label_width + 1
+        max_desc_width = max(0, available_width - reserved)
+        return min(max_desc_len, max_desc_width)
+
+    def show(
+        self,
+        items: list[ListItem[T]],
+        searchable: bool = False,
+        max_label_width: int | None = None,
+    ) -> None:
+        self._search_enabled = searchable
+        self._search_query = ""
+        self._all_items = items if searchable else []
+        self._items = items
+        self._selected_index = 0
+        self._max_label_width = (
+            max_label_width if max_label_width is not None else self._default_max_label_width
+        )
+        self._label_width = self._compute_label_width()
+        self._description_width = self._compute_description_width()
+        self._visible = True
+        self._render_key += 1
+
+    def hide(self) -> None:
+        self._visible = False
+        self._items = []
+        self._all_items = []
+        self._selected_index = 0
+        self._search_enabled = False
+        self._search_query = ""
+
+    def set_search_query(self, query: str) -> None:
+        if not self._search_enabled:
+            return
+        self._search_query = query
+        if not query:
+            self._items = self._all_items
+        else:
+            self._items = self._fuzzy_filter(query, self._all_items)
+        self._label_width = self._compute_label_width()
+        self._description_width = self._compute_description_width()
+        self._selected_index = 0
+        self._render_key += 1
+
+    def update_items(self, items: list[ListItem[T]]) -> None:
+        self._items = items
+        if self._search_enabled:
+            self._all_items = items
+        self._label_width = self._compute_label_width()
+        self._description_width = self._compute_description_width()
+        # Clamp selected index
+        if self._selected_index >= len(items):
+            self._selected_index = max(0, len(items) - 1)
+        self._render_key += 1
+
+    def select_value(self, value: T) -> None:
+        for index, item in enumerate(self._items):
+            if item.value == value:
+                self._selected_index = index
+                self._render_key += 1
+                return
+
+    def move_up(self) -> None:
+        if not self._items:
+            return
+
+        if self._selected_index > 0:
+            self._selected_index -= 1
+        else:
+            self._selected_index = len(self._items) - 1
+        self._render_key += 1
+
+    def move_down(self) -> None:
+        if not self._items:
+            return
+
+        if self._selected_index < len(self._items) - 1:
+            self._selected_index += 1
+        else:
+            self._selected_index = 0
+        self._render_key += 1
+
+    def render(self) -> Text:
+        _ = self._render_key  # Subscribe to changes
+
+        if not self._visible:
+            return Text("")
+
+        lines = []
+
+        if not self._items:
+            if self._search_enabled:
+                dim_color = config.ui.colors.dim
+                lines.append(Text("  No matches", style=dim_color))
+            result = Text()
+            for i, line in enumerate(lines):
+                if i > 0:
+                    result.append("\n")
+                result.append_text(line)
+            return result
+
+        total = len(self._items)
+        selected = self._selected_index
+
+        # Calculate window
+        half_window = self._window_size // 2
+        start = max(0, selected - half_window)
+        end = min(total, start + self._window_size)
+
+        # Adjust start if we're near the end
+        if end - start < self._window_size and start > 0:
+            start = max(0, end - self._window_size)
+
+        # Render visible items
+        for i in range(start, end):
+            item = self._items[i]
+            is_selected = i == selected
+            lines.append(self._render_row(item, is_selected))
+
+        # Add counter row
+        dim_color = config.ui.colors.dim
+        counter = Text(f"  ({selected + 1}/{total})", style=dim_color)
+        lines.append(counter)
+
+        # Join with newlines
+        result = Text()
+        for i, line in enumerate(lines):
+            if i > 0:
+                result.append("\n")
+            result.append_text(line)
+
+        return result
+
+    def on_resize(self, event: events.Resize) -> None:
+        del event
+        if not self._visible:
+            return
+        self._label_width = self._compute_label_width()
+        self._description_width = self._compute_description_width()
+        self._render_key += 1
+
+    def _render_row(self, item: ListItem[T], is_selected: bool) -> Text:
+        colors = config.ui.colors
+        selected_color = colors.selected
+        dim_color = colors.dim
+        text = Text()
+
+        # Arrow indicator
+        if is_selected:
+            text.append("→ ", style=f"bold {selected_color}")
+        else:
+            text.append("  ")
+
+        # Prefix (e.g. tree indent) rendered with its own style
+        prefix = item.prefix
+        if prefix:
+            text.append(prefix, style=item.prefix_style or "")
+
+        # Label (truncated if too long, padded to computed width + gap)
+        prefix_len = len(prefix)
+        effective_label_width = max(1, self._label_width - prefix_len)
+        raw_label = item.label
+        if len(raw_label) > effective_label_width:
+            label = raw_label[: effective_label_width - 1] + "…"
+        else:
+            label = raw_label
+        label = label.ljust(effective_label_width + 3)
+        if is_selected:
+            text.append(label, style=f"bold {selected_color}")
+        else:
+            text.append(label)
+
+        # Description (if any)
+        if item.description and self._description_width > 0:
+            description = item.description
+            if len(description) > self._description_width:
+                if self._description_width == 1:
+                    description = "…"
+                else:
+                    description = description[: self._description_width - 1] + "…"
+            text.append(description, style=f"bold {selected_color}" if is_selected else dim_color)
+
+        return text
+
+    @staticmethod
+    def _fuzzy_match(query: str, candidate: str) -> tuple[float, Sequence[int]]:
+        q = query.lower()
+        c = candidate.lower()
+        positions: list[int] = []
+        idx = 0
+        for char in q:
+            idx = c.find(char, idx)
+            if idx == -1:
+                return (0.0, [])
+            positions.append(idx)
+            idx += 1
+
+        # Simple scoring: consecutive matches and early matches score higher
+        score = float(len(positions))
+        if positions and positions[0] == 0:
+            score *= 1.2
+        groups = 1
+        for i in range(1, len(positions)):
+            if positions[i] != positions[i - 1] + 1:
+                groups += 1
+        if len(positions) > 1:
+            score *= 1 + (len(positions) - groups + 1) / len(positions)
+        return (score, positions)
+
+    @classmethod
+    def _fuzzy_filter(cls, query: str, items: list[ListItem[T]]) -> list[ListItem[T]]:
+        scored = []
+        for item in items:
+            # Match against both label and description
+            label_score, _ = cls._fuzzy_match(query, item.label)
+            desc_score, _ = cls._fuzzy_match(query, item.description)
+            best = max(label_score, desc_score * 0.8)
+            if best > 0:
+                scored.append((best, item))
+        scored.sort(key=lambda x: -x[0])
+        return [item for _, item in scored]
+
+    def watch__visible(self, visible: bool) -> None:
+        if visible:
+            self.add_class("-visible")
+        else:
+            self.remove_class("-visible")

vtx/ui/formatting.py

@@ -0,0 +1,287 @@
+import re
+import shutil
+from typing import ClassVar
+
+from rich._loop import loop_first
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.markdown import CodeBlock, Heading, ListElement, ListItem, Markdown
+from rich.segment import Segment
+from rich.style import Style
+from rich.syntax import Syntax
+from rich.text import Text
+from rich.theme import Theme
+
+from vtx import config
+
+from .latex import preprocess_latex
+
+_MARKDOWN_THEME: Theme | None = None
+
+
+def get_markdown_theme() -> Theme:
+    global _MARKDOWN_THEME
+    if _MARKDOWN_THEME is None:
+        code_color = config.ui.colors.markdown_code
+        heading_style = Style(bold=True)
+        _MARKDOWN_THEME = Theme(
+            {
+                "markdown.h1": heading_style,
+                "markdown.h2": heading_style,
+                "markdown.h3": heading_style,
+                "markdown.h4": heading_style,
+                "markdown.h5": heading_style,
+                "markdown.h6": heading_style,
+                "markdown.code": Style(color=code_color),
+                "markdown.table.header": Style(bold=True),
+                "markdown.table.border": Style(),
+            }
+        )
+    return _MARKDOWN_THEME
+
+
+MARKDOWN_THEME = get_markdown_theme()
+
+
+class LeftJustifiedHeading(Heading):
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        yield from console.render(self.text, options=options.update(justify="left"))
+
+
+class PlainListItem(ListItem):
+    def render_bullet(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        render_options = options.update(width=options.max_width - 2)
+        lines = console.render_lines(self.elements, render_options, style=self.style)
+        bullet = Segment("- ")
+        padding = Segment("  ")
+        new_line = Segment("\n")
+        for first, line in loop_first(lines):
+            yield bullet if first else padding
+            yield from line
+            yield new_line
+
+    def render_number(
+        self, console: Console, options: ConsoleOptions, number: int, last_number: int
+    ) -> RenderResult:
+        number_width = len(str(last_number)) + 2
+        render_options = options.update(width=options.max_width - number_width)
+        lines = console.render_lines(self.elements, render_options, style=self.style)
+        new_line = Segment("\n")
+        padding = Segment(" " * number_width)
+        numeral = Segment(f"{number}".rjust(number_width - 1) + " ")
+        for first, line in loop_first(lines):
+            yield numeral if first else padding
+            yield from line
+            yield new_line
+
+
+class PlainListElement(ListElement):
+    def on_child_close(self, context, child) -> bool:
+        assert isinstance(child, ListItem)
+        self.items.append(child)
+        return False
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        if self.list_type == "bullet_list_open":
+            for item in self.items:
+                if isinstance(item, PlainListItem):
+                    yield from item.render_bullet(console, options)
+        else:
+            number = 1 if self.list_start is None else self.list_start
+            last_number = number + len(self.items)
+            for index, item in enumerate(self.items):
+                if isinstance(item, PlainListItem):
+                    yield from item.render_number(console, options, number + index, last_number)
+
+
+class PlainCodeBlock(CodeBlock):
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        code = str(self.text).rstrip()
+        syntax = Syntax(code, self.lexer_name, theme="ansi_dark", word_wrap=True, padding=0)
+        yield syntax
+
+
+class CustomMarkdown(Markdown):
+    elements: ClassVar[dict] = {
+        **Markdown.elements,
+        "heading_open": LeftJustifiedHeading,
+        "bullet_list_open": PlainListElement,
+        "ordered_list_open": PlainListElement,
+        "list_item_open": PlainListItem,
+        "fence": PlainCodeBlock,
+        "code_block": PlainCodeBlock,
+    }
+
+
+def _strip_inline_code_ticks_in_headings(text: str) -> str:
+    lines = text.splitlines(keepends=True)
+    in_fence = False
+    processed: list[str] = []
+
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith("```"):
+            in_fence = not in_fence
+            processed.append(line)
+            continue
+
+        if in_fence:
+            processed.append(line)
+            continue
+
+        if re.match(r"^\s{0,3}#{1,6}\s+", line):
+            line = re.sub(r"`([^`]+)`", r"\1", line)
+
+        processed.append(line)
+
+    return "".join(processed)
+
+
+def strip_markdown_for_collapsed_text(text: str) -> str:
+    text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)
+    text = re.sub(r"__([^_]+)__", r"\1", text)
+    text = re.sub(r"(?<!\*)\*([^*]+)\*(?!\*)", r"\1", text)
+    text = re.sub(r"(?<!_)_([^_]+)_(?!_)", r"\1", text)
+    text = re.sub(r"`([^`]+)`", r"\1", text)
+    return text
+
+
+def markdown_render_width() -> int:
+    term_width = shutil.get_terminal_size().columns
+    return max(40, term_width - 4)
+
+
+def format_markdown(text: str, width: int | None = None) -> Text:
+    text = preprocess_latex(text)
+    sanitized = _strip_inline_code_ticks_in_headings(text)
+    md = CustomMarkdown(sanitized)
+    if width is None:
+        width = markdown_render_width()
+    console = Console(force_terminal=True, no_color=False, theme=MARKDOWN_THEME, width=width)
+    with console.capture() as capture:
+        console.print(md)
+    rendered = capture.get()
+    return Text.from_ansi(rendered.rstrip("\n"))
+
+
+def find_stable_block_boundary(text: str) -> int:
+    """Offset just after the last blank line outside a code fence, 0 if none.
+
+    Everything before the boundary is a closed run of top-level markdown blocks.
+    Content streamed after it can no longer change how that text renders.
+    """
+    boundary = 0
+    offset = 0
+    in_fence = False
+    for line in text.splitlines(keepends=True):
+        stripped = line.strip()
+        if stripped.startswith(("```", "~~~")):
+            in_fence = not in_fence
+        elif not stripped and not in_fence:
+            boundary = offset + len(line)
+        offset += len(line)
+    return boundary
+
+
+def format_markdown_block(text: str, width: int) -> Text:
+    """Render a markdown fragment with blank edge lines stripped.
+
+    A fragment can render with stray blank edge lines (a lone list starts with one).
+    Stripping them lets cached blocks be joined with a single blank line, the same
+    spacing Rich puts between top-level elements in a full render.
+    """
+    lines = list(format_markdown(text, width).split("\n"))
+    while lines and not lines[0].plain.strip():
+        lines.pop(0)
+    while lines and not lines[-1].plain.strip():
+        lines.pop()
+    return Text("\n").join(lines)
+
+
+_BASH_TOKEN_RE = re.compile(
+    r"(?P<space>\s+)"
+    r"|(?P<op>\|\||&&|;;|[|;&()<>])"
+    r"|(?P<sq>'[^']*')"
+    r'|(?P<dq>"(?:\\.|[^"\\])*")'
+    r"|(?P<word>[^\s|;&()<>]+)"
+)
+
+
+def _format_bash_command_tokens(command: str) -> Text:
+    """Small shell highlighter for common command headers.
+
+    Pygments mostly highlights shell syntax, not ordinary argv words, so a
+    command like `git status --short && git log` can otherwise appear plain.
+    Use a compact Catppuccin-ish palette similar to Codex's default command
+    highlighting instead of dimming argv text.
+    """
+    syntax = config.ui.colors.syntax_colors
+    command_style = syntax.command
+    arg_style = syntax.arg
+    option_style = syntax.option
+    operator_style = syntax.operator
+    string_style = syntax.string
+    variable_style = syntax.variable
+
+    text = Text()
+    expect_command = True
+
+    for match in _BASH_TOKEN_RE.finditer(command):
+        token = match.group(0)
+        kind = match.lastgroup
+
+        if kind == "space":
+            text.append(token)
+            continue
+
+        if kind == "op":
+            text.append(token, style=operator_style)
+            expect_command = token in {"|", "||", "&&", ";", ";;", "("}
+            continue
+
+        if kind in {"sq", "dq"}:
+            text.append(token, style=string_style)
+            expect_command = False
+            continue
+
+        if token.startswith("$"):
+            text.append(token, style=variable_style)
+            expect_command = False
+        elif expect_command:
+            text.append(token, style=command_style)
+            expect_command = False
+        elif token.startswith("-"):
+            text.append(token, style=option_style)
+        else:
+            text.append(token, style=arg_style)
+
+    return text
+
+
+def format_bash_command(text: str, width: int | None = None) -> Text:
+    """Syntax-highlight a bash command for compact tool headers."""
+    if width is None:
+        term_width = shutil.get_terminal_size().columns
+        width = max(40, term_width - 4)
+
+    prompt = ""
+    command = text
+    if text.startswith("$ "):
+        prompt = "$ "
+        command = text[2:]
+
+    highlighted = _format_bash_command_tokens(command)
+
+    if not prompt:
+        return highlighted
+
+    result = Text(prompt, style=config.ui.colors.dim)
+    result.append_text(highlighted)
+    return result
+
+
+def format_tokens(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{int(n / 1_000_000)}m"
+    elif n >= 1_000:
+        return f"{int(n / 1_000)}k"
+    return str(n)