tau-coding-agent 0.1.0__py3-none-any.whl

tau/tui/component.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tau.tui.input import InputEvent
+
+
+class Component(ABC):
+    """
+    Base class for all TUI components.
+
+    A component produces a list of pre-rendered lines for a given terminal
+    width. The renderer calls render() on each frame and only writes lines
+    that changed since the last frame.
+    """
+
+    @abstractmethod
+    def render(self, width: int) -> list[str]:
+        """
+        Return the component's visual representation as a list of strings.
+
+        Each string is one terminal line. Lines must not contain newline
+        characters — the renderer handles line breaks. ANSI escape codes
+        are allowed; the renderer uses ansi.visible_width() for comparisons.
+
+        Args:
+            width: Available terminal columns.
+
+        Returns:
+            List of strings, one per line.
+        """
+        ...
+
+    def handle_input(self, event: InputEvent) -> bool:  # noqa: ARG002
+        """
+        Handle a keyboard / mouse / paste event.
+
+        Returns True if the event was consumed (stops propagation).
+        Default: not handled.
+        """
+        return False
+
+    def invalidate(self) -> None:
+        """
+        Clear any cached render state.
+
+        Called by the renderer after a terminal resize or when the component
+        needs to be fully re-rendered on the next frame.
+        """
+
+
+class Focusable(ABC):
+    """
+    Mixin for components that want explicit keyboard focus.
+
+    When TUI.set_focus(component) is called, TUI sets ``focused = True``
+    on the component and routes handle_input() calls to it exclusively
+    until focus changes.  Components that display a text cursor or need
+    IME positioning should implement this interface.
+
+    Example::
+
+        class MyInput(Component, Focusable):
+            def render(self, width):
+                cursor = "█" if self.focused else ""
+                return [f"> {self._text}{cursor}"]
+    """
+
+    focused: bool = False
+
+
+class Container(Component):
+    """
+    An ordered list of child components rendered top-to-bottom.
+
+    An ordered list of child components rendered top-to-bottom.
+    Children are rendered in insertion order; each child gets the full
+    available width.
+
+    Usage::
+
+        header = Container()
+        header.add_child(Banner())
+        header.add_child(Spacer(1))
+
+        tui.add_child(header)
+        tui.add_child(chat)
+        tui.add_child(editor)
+    """
+
+    def __init__(self) -> None:
+        self.children: list[Component] = []
+
+    def add_child(self, component: Component) -> None:
+        """Append a component to the bottom of this container."""
+        self.children.append(component)
+
+    def remove_child(self, component: Component) -> None:
+        """Remove a component; no-op if not present."""
+        try:
+            self.children.remove(component)
+        except ValueError:
+            pass
+
+    def clear(self) -> None:
+        """Remove all children."""
+        self.children.clear()
+
+    # -------------------------------------------------------------------------
+    # Component
+    # -------------------------------------------------------------------------
+
+    def render(self, width: int) -> list[str]:
+        lines: list[str] = []
+        for child in self.children:
+            lines.extend(child.render(width))
+        return lines
+
+    def handle_input(self, event: InputEvent) -> bool:
+        for child in self.children:
+            if child.handle_input(event):
+                return True
+        return False
+
+    def invalidate(self) -> None:
+        for child in self.children:
+            child.invalidate()
+
+
+class StaticComponent(Component):
+    """
+    A component backed by a fixed list of pre-rendered lines.
+    Useful for testing and simple static content.
+    """
+
+    def __init__(self, lines: list[str]) -> None:
+        self._lines = lines
+
+    def render(self, width: int) -> list[str]:  # noqa: ARG002
+        return self._lines
+
+
+class Column(Component):
+    """
+    Renders children top-to-bottom, each getting the full width.
+
+    Fixed counterpart to ``Container`` — children are supplied at construction
+    time.  Use ``Container`` when you need to add/remove children at runtime.
+
+    Usage::
+
+        col = Column([Banner(), Divider(), ChatArea()])
+    """
+
+    def __init__(self, children: list[Component]) -> None:
+        self.children = list(children)
+
+    def render(self, width: int) -> list[str]:
+        lines: list[str] = []
+        for child in self.children:
+            lines.extend(child.render(width))
+        return lines
+
+    def handle_input(self, event: InputEvent) -> bool:
+        for child in reversed(self.children):
+            if child.handle_input(event):
+                return True
+        return False
+
+    def invalidate(self) -> None:
+        for child in self.children:
+            child.invalidate()
+
+
+# Backwards-compatible alias
+VerticalStack = Column
+
+
+class Row(Component):
+    """
+    Renders children side-by-side in a single terminal line.
+
+    Each child is assigned a slot — ``"left"``, ``"center"``, or ``"right"``
+    — and the Row distributes the available width so that:
+
+    - left content is flush-left
+    - right content is flush-right
+    - center content sits in the middle (best-effort)
+
+    Each child's ``render()`` is called with its measured slot width and only
+    the **first line** of the result is used.  This keeps Row a single-line
+    primitive; stack multiple Rows inside a Column/Container for multi-line
+    horizontal layouts.
+
+    Usage::
+
+        row = Row([
+            (GitBadge(),   "left"),
+            (StatusBadge(),"center"),
+            (ModelBadge(), "right"),
+        ])
+    """
+
+    def __init__(self, slots: list[tuple[Component, str]] | None = None) -> None:
+        self._slots: list[tuple[Component, str]] = list(slots) if slots else []
+
+    def add_slot(self, component: Component, align: str = "left") -> None:
+        """Append a component with the given alignment (``"left"``, ``"center"``, ``"right"``)."""
+        self._slots.append((component, align))
+
+    def render(self, width: int) -> list[str]:
+        from tau.tui.ansi import visible_width, truncate
+
+        left_parts:   list[str] = []
+        center_parts: list[str] = []
+        right_parts:  list[str] = []
+
+        for component, align in self._slots:
+            lines = component.render(width)
+            text = lines[0] if lines else ""
+            if align == "right":
+                right_parts.append(text)
+            elif align == "center":
+                center_parts.append(text)
+            else:
+                left_parts.append(text)
+
+        left   = "  ".join(left_parts)
+        center = "  ".join(center_parts)
+        right  = "  ".join(right_parts)
+
+        lw = visible_width(left)
+        cw = visible_width(center)
+        rw = visible_width(right)
+
+        if center:
+            # left | center (centered) | right
+            center_start = max(lw + 1, (width - cw) // 2)
+            right_start  = width - rw
+            if center_start + cw > right_start:
+                center_start = max(lw + 1, right_start - cw - 1)
+            line = left
+            line += " " * max(0, center_start - lw)
+            line += center
+            cur = center_start + cw
+            line += " " * max(0, right_start - cur)
+            line += right
+        else:
+            # left | right
+            gap = width - lw - rw
+            if gap >= 0:
+                line = left + " " * gap + right
+            else:
+                line = truncate(left, max(0, width - rw)) + right
+
+        return [line]
+
+    def handle_input(self, event: InputEvent) -> bool:
+        for component, _ in self._slots:
+            if component.handle_input(event):
+                return True
+        return False
+
+    def invalidate(self) -> None:
+        for component, _ in self._slots:
+            component.invalidate()

tau/tui/components/autocomplete_manager.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+from typing import Callable, TYPE_CHECKING
+
+from tau.tui.components.autocomplete_picker import AutocompletePicker
+from tau.tui.input import InputEvent, KeyEvent
+
+if TYPE_CHECKING:
+    from tau.commands.types import CommandInfo
+    from tau.tui.autocomplete import AutocompleteRegistration
+
+
+class AutocompleteManager:
+    """
+    Owns both inline autocomplete pickers and all their async fetch state.
+
+    Previously this logic was spread across ~130 lines inside Layout.
+    Layout now creates one instance and delegates via three calls:
+
+        sync(text, cursor, commands)   — called after every keystroke
+        handle_input(event, text, cursor) -> (consumed, new_text | None)
+        render(width) -> list[str]
+
+    Two pickers are managed internally:
+    - Extension autocomplete  (_ac_picker)     — trigger chars registered by providers
+    - Command arg completions (_cmd_arg_picker) — activated by '/cmd <space>'
+    """
+
+    def __init__(self, max_visible: int, request_render: Callable[[], None]) -> None:
+        self._ac_picker = AutocompletePicker(max_visible=max_visible)
+        self._ac_providers: list[AutocompleteRegistration] = []
+        self._ac_trigger_pos: int = -1
+        self._ac_active_trigger: str = ""
+        self._ac_pending_task: asyncio.Task | None = None  # type: ignore[type-arg]
+
+        self._cmd_arg_picker = AutocompletePicker(max_visible=max_visible)
+        self._cmd_arg_active: str = ""
+        self._cmd_arg_pending_task: asyncio.Task | None = None  # type: ignore[type-arg]
+
+        self._request_render = request_render
+
+    # -------------------------------------------------------------------------
+    # Public API
+    # -------------------------------------------------------------------------
+
+    @property
+    def active(self) -> bool:
+        return self._ac_picker.active or self._cmd_arg_picker.active
+
+    def register_provider(self, reg: AutocompleteRegistration) -> None:
+        self._ac_providers.append(reg)
+
+    def clear(self) -> None:
+        """Dismiss both pickers — called when another picker takes over."""
+        self._ac_picker.clear()
+        self._cmd_arg_picker.clear()
+        self._ac_active_trigger = ""
+        self._ac_trigger_pos = -1
+        self._cmd_arg_active = ""
+
+    def sync(self, text: str, cursor: int, all_commands: list[CommandInfo]) -> None:
+        """
+        Called after every keystroke when neither the file picker nor the
+        command palette is active.  Updates whichever picker applies.
+        """
+        # Command argument completions: '/cmd <args>'
+        if text.startswith("/"):
+            space_idx = text.find(" ")
+            if space_idx != -1:
+                cmd_name = text[1:space_idx]
+                arg_prefix = text[space_idx + 1:]
+                cmd = next(
+                    (c for c in all_commands
+                     if c.name == cmd_name or cmd_name in (c.aliases or [])),
+                    None,
+                )
+                if cmd is not None and cmd.get_argument_completions is not None:
+                    if cmd_name != self._cmd_arg_active:
+                        self._cmd_arg_active = cmd_name
+                        self._cmd_arg_picker.clear()
+                    self._start_cmd_arg(cmd, arg_prefix)
+                    self._ac_picker.clear()
+                    return
+        self._cmd_arg_picker.clear()
+        self._cmd_arg_active = ""
+
+        # Extension autocomplete: trigger character registered by a provider
+        ac_info = self._find_trigger(text, cursor)
+        if ac_info is not None:
+            trigger, query, trigger_pos = ac_info
+            if trigger != self._ac_active_trigger or trigger_pos != self._ac_trigger_pos:
+                self._ac_active_trigger = trigger
+                self._ac_trigger_pos = trigger_pos
+                self._ac_picker.clear()
+                self._start_ac(trigger, query, text, cursor)
+            else:
+                self._ac_picker.set_query(query)
+        else:
+            self._ac_active_trigger = ""
+            self._ac_trigger_pos = -1
+            self._ac_picker.clear()
+
+    def handle_input(
+        self,
+        event: InputEvent,
+        text: str,
+        cursor: int,
+    ) -> tuple[bool, str | None]:
+        """
+        Handle a key event when a picker is active.
+
+        Returns (consumed, new_text):
+          consumed  — True if the event was handled (prevents further dispatch)
+          new_text  — the full replacement text when an item was accepted, else None
+        """
+        if not isinstance(event, KeyEvent):
+            return False, None
+
+        if self._ac_picker.active:
+            match event.key:
+                case "up":
+                    self._ac_picker.move_up()
+                    return True, None
+                case "down":
+                    self._ac_picker.move_down()
+                    return True, None
+                case "tab" | "enter":
+                    return True, self._accept_ac(text, cursor)
+                case "escape":
+                    self._ac_picker.clear()
+                    return True, None
+
+        if self._cmd_arg_picker.active:
+            match event.key:
+                case "up":
+                    self._cmd_arg_picker.move_up()
+                    return True, None
+                case "down":
+                    self._cmd_arg_picker.move_down()
+                    return True, None
+                case "tab" | "enter":
+                    return True, self._accept_cmd_arg(text)
+                case "escape":
+                    self._cmd_arg_picker.clear()
+                    return True, None
+
+        return False, None
+
+    def render(self, width: int) -> list[str]:
+        lines: list[str] = []
+        lines.extend(self._ac_picker.render(width))
+        lines.extend(self._cmd_arg_picker.render(width))
+        return lines
+
+    # -------------------------------------------------------------------------
+    # Trigger detection
+    # -------------------------------------------------------------------------
+
+    def _find_trigger(self, text: str, cursor: int) -> tuple[str, str, int] | None:
+        """Scan rightward from cursor for the nearest registered trigger char."""
+        if not self._ac_providers:
+            return None
+        before = text[:cursor]
+        triggers = {p.trigger for p in self._ac_providers}
+        for i in range(len(before) - 1, -1, -1):
+            ch = before[i]
+            if ch == " ":
+                break
+            if ch in triggers:
+                return ch, before[i + 1:], i
+        return None
+
+    # -------------------------------------------------------------------------
+    # Async fetch helpers
+    # -------------------------------------------------------------------------
+
+    def _start_ac(self, trigger: str, query: str, text: str, cursor: int) -> None:
+        provider = next((p for p in self._ac_providers if p.trigger == trigger), None)
+        if provider is None:
+            return
+
+        from tau.tui.autocomplete import AutocompleteContext
+        ctx = AutocompleteContext(text=text, cursor_pos=cursor, trigger=trigger, query=query)
+
+        if self._ac_pending_task is not None:
+            self._ac_pending_task.cancel()
+            self._ac_pending_task = None
+
+        result = provider.get_items(ctx)
+        if inspect.isawaitable(result):
+            async def _fetch() -> None:
+                try:
+                    items = await result  # type: ignore[misc]
+                    if self._ac_active_trigger == trigger:
+                        self._ac_picker.set_items(items)
+                        self._ac_picker.set_query(query)
+                        self._request_render()
+                except asyncio.CancelledError:
+                    pass
+                except Exception:
+                    pass
+            self._ac_pending_task = asyncio.ensure_future(_fetch())
+        else:
+            self._ac_picker.set_items(result)  # type: ignore[arg-type]
+            self._ac_picker.set_query(query)
+
+    def _start_cmd_arg(self, cmd: CommandInfo, prefix: str) -> None:
+        if cmd.get_argument_completions is None:
+            return
+        if self._cmd_arg_pending_task is not None:
+            self._cmd_arg_pending_task.cancel()
+            self._cmd_arg_pending_task = None
+
+        result = cmd.get_argument_completions(prefix)
+        if inspect.isawaitable(result):
+            active = self._cmd_arg_active
+
+            async def _fetch() -> None:
+                try:
+                    items = await result  # type: ignore[misc]
+                    if self._cmd_arg_active == active:
+                        self._cmd_arg_picker.set_items(items)
+                        self._cmd_arg_picker.set_query(prefix)
+                        self._request_render()
+                except asyncio.CancelledError:
+                    pass
+                except Exception:
+                    pass
+            self._cmd_arg_pending_task = asyncio.ensure_future(_fetch())
+        else:
+            self._cmd_arg_picker.set_items(result)  # type: ignore[arg-type]
+            self._cmd_arg_picker.set_query(prefix)
+
+    # -------------------------------------------------------------------------
+    # Accept helpers
+    # -------------------------------------------------------------------------
+
+    def _accept_ac(self, text: str, cursor: int) -> str | None:
+        item = self._ac_picker.selected
+        if item is None:
+            return None
+        insert = item.insert_text if item.insert_text is not None else item.label
+        new_text = (
+            text[: self._ac_trigger_pos]
+            + self._ac_active_trigger
+            + insert
+            + " "
+            + text[cursor:]
+        )
+        self._ac_picker.clear()
+        self._ac_active_trigger = ""
+        self._ac_trigger_pos = -1
+        return new_text
+
+    def _accept_cmd_arg(self, text: str) -> str | None:
+        item = self._cmd_arg_picker.selected
+        if item is None:
+            return None
+        space_idx = text.find(" ")
+        if space_idx == -1:
+            return None
+        insert = item.insert_text if item.insert_text is not None else item.label
+        new_text = text[: space_idx + 1] + insert + " "
+        self._cmd_arg_picker.clear()
+        return new_text

tau/tui/components/autocomplete_picker.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from tau.tui.ansi import RESET, BOLD, BRIGHT_BLACK, BRIGHT_WHITE
+from tau.tui.component import Component
+from tau.tui.fuzzy import fuzzy_filter
+from tau.tui.input import InputEvent, KeyEvent
+
+if TYPE_CHECKING:
+    from tau.tui.autocomplete import AutocompleteItem
+
+_DEFAULT_VISIBLE_ROWS = 5
+
+
+class AutocompletePicker(Component):
+    """
+    Fuzzy-filtered inline dropdown for extension autocomplete providers.
+
+    Shown above the input (like the command palette) when an extension trigger
+    character is detected in the editor text.  Navigation is handled here;
+    commit (Tab/Enter) and dismiss (Escape) are handled by Layout.
+    """
+
+    def __init__(self, max_visible: int = _DEFAULT_VISIBLE_ROWS) -> None:
+        self._all_items: list[AutocompleteItem] = []
+        self._items: list[AutocompleteItem] = []
+        self._selected: int = 0
+        self._query: str = ""
+        self._active: bool = False
+        self._max_visible = max_visible
+
+    # -------------------------------------------------------------------------
+    # Public API
+    # -------------------------------------------------------------------------
+
+    @property
+    def active(self) -> bool:
+        return self._active and bool(self._items)
+
+    @property
+    def selected(self) -> AutocompleteItem | None:
+        return self._items[self._selected] if self._items else None
+
+    @property
+    def line_count(self) -> int:
+        return min(self._max_visible, len(self._items))
+
+    def set_items(self, items: list[AutocompleteItem]) -> None:
+        self._all_items = list(items)
+        self._active = True
+        self._apply_filter(self._query)
+
+    def set_query(self, query: str) -> None:
+        if query == self._query:
+            return
+        self._query = query
+        self._apply_filter(query)
+
+    def clear(self) -> None:
+        self._all_items = []
+        self._items = []
+        self._selected = 0
+        self._query = ""
+        self._active = False
+
+    def move_up(self) -> None:
+        if self._items:
+            self._selected = (self._selected - 1) % len(self._items)
+
+    def move_down(self) -> None:
+        if self._items:
+            self._selected = (self._selected + 1) % len(self._items)
+
+    # -------------------------------------------------------------------------
+    # Component
+    # -------------------------------------------------------------------------
+
+    def render(self, width: int) -> list[str]:
+        if not self.active:
+            return []
+
+        count   = len(self._items)
+        visible = min(self._max_visible, count)
+        start   = max(0, min(self._selected - visible + 1, count - visible))
+
+        label_w = max(8, min(
+            max(len(item.label) for item in self._items[start : start + visible]),
+            24,
+        ))
+        desc_w = max(0, width - label_w - 4)
+
+        lines: list[str] = []
+
+        if start > 0:
+            lines.append(BRIGHT_BLACK + f"  ↑ {start} more" + RESET)
+
+        for i in range(start, start + visible):
+            item   = self._items[i]
+            is_sel = i == self._selected
+            label  = item.label[:label_w].ljust(label_w)
+            desc   = item.description[:desc_w] if desc_w > 0 else ""
+
+            if is_sel:
+                row = "  " + BOLD + BRIGHT_WHITE + label + RESET + "  " + BRIGHT_BLACK + desc + RESET
+            else:
+                row = "  " + BRIGHT_BLACK + label + "  " + desc + RESET
+
+            lines.append(row)
+
+        remaining = count - (start + visible)
+        if remaining > 0:
+            lines.append(BRIGHT_BLACK + f"  ↓ {remaining} more" + RESET)
+
+        return lines
+
+    def handle_input(self, event: InputEvent) -> bool:
+        if not isinstance(event, KeyEvent):
+            return False
+        key = str(event)
+        if key in ("up", "ctrl+p"):
+            self.move_up()
+            return True
+        if key in ("down", "ctrl+n"):
+            self.move_down()
+            return True
+        return False
+
+    # -------------------------------------------------------------------------
+    # Internal
+    # -------------------------------------------------------------------------
+
+    def _apply_filter(self, query: str) -> None:
+        q = query.strip()
+        if not q:
+            self._items = list(self._all_items)
+        else:
+            self._items = fuzzy_filter(
+                self._all_items,
+                q,
+                lambda item: item.label + " " + item.description,
+            )
+        self._selected = min(self._selected, len(self._items) - 1) if self._items else 0