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

vtx/ui/tree.py

@@ -0,0 +1,437 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+from rich.text import Text
+from textual.binding import Binding, BindingType
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widget import Widget
+
+from vtx import config
+from vtx.core.types import AssistantMessage, TextContent, ToolCall, ToolResultMessage, UserMessage
+from vtx.session import MessageEntry, SessionEntry, TreeNode
+from vtx.tools import get_tool
+from vtx.tools._tool_utils import shorten_path
+
+
+@dataclass
+class GutterInfo:
+    position: int
+    show: bool
+
+
+@dataclass
+class FlatNode:
+    node: TreeNode
+    indent: int
+    show_connector: bool
+    is_last: bool
+    gutters: list[GutterInfo]
+    is_virtual_root_child: bool
+
+
+class TreeSelector(Widget):
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "move_up", "Move", priority=True),
+        Binding("down", "move_down", "Move", priority=True),
+        Binding("left,pageup", "page_up", "Page", priority=True),
+        Binding("right,pagedown", "page_down", "Page", priority=True),
+        Binding("enter", "select", "Select", priority=True),
+        Binding("escape", "cancel", "Cancel", priority=True),
+    ]
+
+    DEFAULT_CSS = """
+    TreeSelector {
+        height: auto;
+        display: none;
+    }
+
+    TreeSelector.-visible {
+        display: block;
+    }
+    """
+
+    class Selected(Message):
+        def __init__(self, entry_id: str) -> None:
+            super().__init__()
+            self.entry_id = entry_id
+
+    class Cancelled(Message):
+        pass
+
+    _visible: reactive[bool] = reactive(False, repaint=False)
+    _render_key: reactive[int] = reactive(0)
+
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._flat_nodes: list[FlatNode] = []
+        self._filtered_nodes: list[FlatNode] = []
+        self._selected_index = 0
+        self._current_leaf_id: str | None = None
+        self._multiple_roots = False
+        self._active_path_ids: set[str] = set()
+        self._last_selected_id: str | None = None
+        self._max_visible_lines = 10
+        self._tool_calls_by_id: dict[str, ToolCall] = {}
+
+    @property
+    def is_visible(self) -> bool:
+        return self._visible
+
+    def show(self, tree: list[TreeNode], current_leaf_id: str | None, height: int = 24) -> None:
+        self._current_leaf_id = current_leaf_id
+        self._max_visible_lines = max(5, height // 3)
+        self._tool_calls_by_id = self._collect_tool_calls(tree)
+        self._multiple_roots = len(tree) > 1
+        self._flat_nodes = self._flatten_tree(tree)
+        self._filtered_nodes = [
+            node for node in self._flat_nodes if self._should_show_entry(node.node.entry)
+        ]
+        self._build_active_path()
+        self._selected_index = self._find_nearest_visible_index(current_leaf_id)
+        self._last_selected_id = (
+            self._filtered_nodes[self._selected_index].node.entry.id
+            if self._filtered_nodes
+            else None
+        )
+        self._visible = True
+        self._render_key += 1
+        self.focus()
+
+    def hide(self) -> None:
+        self._visible = False
+        self._flat_nodes = []
+        self._filtered_nodes = []
+        self._selected_index = 0
+        self._last_selected_id = None
+        self._render_key += 1
+
+    def watch__visible(self, visible: bool) -> None:
+        if visible:
+            self.add_class("-visible")
+        else:
+            self.remove_class("-visible")
+
+    def _collect_tool_calls(self, roots: list[TreeNode]) -> dict[str, ToolCall]:
+        calls: dict[str, ToolCall] = {}
+        stack = list(roots)
+        while stack:
+            node = stack.pop()
+            entry = node.entry
+            if isinstance(entry, MessageEntry) and isinstance(entry.message, AssistantMessage):
+                for part in entry.message.content:
+                    if isinstance(part, ToolCall):
+                        calls[part.id] = part
+            stack.extend(node.children)
+        return calls
+
+    def _flatten_tree(self, roots: list[TreeNode]) -> list[FlatNode]:
+        result: list[FlatNode] = []
+        contains_active: dict[str, bool] = {}
+
+        def mark(node: TreeNode) -> bool:
+            has = self._current_leaf_id is not None and node.entry.id == self._current_leaf_id
+            for child in node.children:
+                has = mark(child) or has
+            contains_active[node.entry.id] = has
+            return has
+
+        for root in roots:
+            mark(root)
+
+        ordered_roots = sorted(
+            roots, key=lambda n: contains_active.get(n.entry.id, False), reverse=True
+        )
+        multiple_roots = len(roots) > 1
+        stack: list[tuple[TreeNode, int, bool, bool, bool, list[GutterInfo], bool]] = []
+        for index in range(len(ordered_roots) - 1, -1, -1):
+            stack.append(
+                (
+                    ordered_roots[index],
+                    1 if multiple_roots else 0,
+                    multiple_roots,
+                    multiple_roots,
+                    index == len(ordered_roots) - 1,
+                    [],
+                    multiple_roots,
+                )
+            )
+
+        while stack:
+            (
+                node,
+                indent,
+                just_branched,
+                show_connector,
+                is_last,
+                gutters,
+                is_virtual_root_child,
+            ) = stack.pop()
+            result.append(
+                FlatNode(node, indent, show_connector, is_last, gutters, is_virtual_root_child)
+            )
+
+            children = node.children
+            multiple_children = len(children) > 1
+            active_children = [c for c in children if contains_active.get(c.entry.id, False)]
+            other_children = [c for c in children if not contains_active.get(c.entry.id, False)]
+            ordered_children = active_children + other_children
+
+            if multiple_children or (just_branched and indent > 0):
+                child_indent = indent + 1
+            else:
+                child_indent = indent
+
+            connector_displayed = show_connector and not is_virtual_root_child
+            display_indent = max(0, indent - 1) if self._multiple_roots else indent
+            connector_position = max(0, display_indent - 1)
+            child_gutters = (
+                [*gutters, GutterInfo(connector_position, not is_last)]
+                if connector_displayed
+                else gutters
+            )
+
+            for index in range(len(ordered_children) - 1, -1, -1):
+                stack.append(
+                    (
+                        ordered_children[index],
+                        child_indent,
+                        multiple_children,
+                        multiple_children,
+                        index == len(ordered_children) - 1,
+                        child_gutters,
+                        False,
+                    )
+                )
+
+        return result
+
+    def _build_active_path(self) -> None:
+        self._active_path_ids.clear()
+        by_id = {flat.node.entry.id: flat.node.entry for flat in self._flat_nodes}
+        current_id = self._current_leaf_id
+        while current_id:
+            self._active_path_ids.add(current_id)
+            entry = by_id.get(current_id)
+            current_id = entry.parent_id if entry else None
+
+    def _find_nearest_visible_index(self, entry_id: str | None) -> int:
+        if not self._filtered_nodes:
+            return 0
+        entry_map = {flat.node.entry.id: flat.node.entry for flat in self._flat_nodes}
+        visible = {flat.node.entry.id: i for i, flat in enumerate(self._filtered_nodes)}
+        current_id = entry_id
+        while current_id is not None:
+            if current_id in visible:
+                return visible[current_id]
+            entry = entry_map.get(current_id)
+            current_id = entry.parent_id if entry else None
+        return len(self._filtered_nodes) - 1
+
+    def _should_show_entry(self, entry: SessionEntry) -> bool:
+        if not isinstance(entry, MessageEntry):
+            return False
+        message = entry.message
+        if isinstance(message, UserMessage | ToolResultMessage):
+            return True
+        if isinstance(message, AssistantMessage):
+            return any(
+                isinstance(part, TextContent) and part.text.strip() for part in message.content
+            )
+        return False
+
+    def _entry_plain_text(self, entry: SessionEntry) -> str:
+        if isinstance(entry, MessageEntry):
+            message = entry.message
+            if isinstance(message, UserMessage):
+                if isinstance(message.content, str):
+                    return message.content
+                return "".join(
+                    part.text if isinstance(part, TextContent) else "[image]"
+                    for part in message.content
+                )
+            if isinstance(message, AssistantMessage):
+                return "".join(
+                    part.text for part in message.content if isinstance(part, TextContent)
+                )
+            if isinstance(message, ToolResultMessage):
+                return message.tool_name
+        return ""
+
+    def _entry_display_text(self, entry: SessionEntry, selected: bool) -> Text:
+        colors = config.ui.colors
+        text = Text()
+        if isinstance(entry, MessageEntry):
+            message = entry.message
+            if isinstance(message, UserMessage):
+                text.append("user: ", style=colors.accent)
+                text.append(self._normalize(self._entry_plain_text(entry)))
+            elif isinstance(message, AssistantMessage):
+                text.append("assistant: ", style=colors.success)
+                content = self._normalize(self._entry_plain_text(entry))
+                text.append(content or "(no content)", style=None if content else colors.dim)
+            elif isinstance(message, ToolResultMessage):
+                text.append(self._format_tool_result(message), style=colors.dim)
+        if selected:
+            text.stylize("bold")
+        return text
+
+    def _format_tool_result(self, message: ToolResultMessage) -> str:
+        call = self._tool_calls_by_id.get(message.tool_call_id)
+        name = call.name if call else message.tool_name
+        tool = get_tool(name)
+        if tool and call:
+            try:
+                params = tool.params(**call.arguments)
+                return self._normalize(f"[{name}: {tool.format_call(params)}]", max_len=120)
+            except Exception:
+                pass
+        if call and call.arguments:
+            return self._normalize(
+                f"[{name}: {self._format_tool_args(call.arguments)}]", max_len=120
+            )
+        return f"[{name}]"
+
+    def _format_tool_args(self, args: dict[str, object]) -> str:
+        for key in ("path", "file_path", "command", "pattern", "url"):
+            value = args.get(key)
+            if isinstance(value, str) and value.strip():
+                return shorten_path(value.strip())[:80]
+        if not args:
+            return ""
+        return str(args)[:80]
+
+    def _normalize(self, value: str, max_len: int = 200) -> str:
+        text = " ".join(value.replace("\t", " ").split())
+        if len(text) <= max_len:
+            return text
+        return f"{text[: max_len - 1]}…"
+
+    def render(self) -> Text:
+        _ = self._render_key
+        out = Text()
+        if not self._visible:
+            return out
+
+        colors = config.ui.colors
+        width = max(10, self.size.width or 80)
+        out.append("─" * width, style=colors.border)
+        out.append("\n Session Tree\n", style=f"bold {colors.title}")
+        out.append(" ↑/↓ move • ←/→ jump\n", style=colors.dim)
+        out.append("─" * width, style=colors.border)
+        out.append("\n")
+
+        if not self._filtered_nodes:
+            out.append(" No entries found\n", style=colors.dim)
+            out.append(" (0/0)", style=colors.dim)
+            return out
+
+        start = max(
+            0,
+            min(
+                self._selected_index - self._max_visible_lines // 2,
+                len(self._filtered_nodes) - self._max_visible_lines,
+            ),
+        )
+        end = min(start + self._max_visible_lines, len(self._filtered_nodes))
+        for index in range(start, end):
+            flat = self._filtered_nodes[index]
+            entry = flat.node.entry
+            selected = index == self._selected_index
+            line = Text(" ")
+            if selected:
+                line.append("❯", style=colors.accent)  # noqa: RUF001
+            else:
+                line.append(" ")
+            display_indent = max(0, flat.indent - 1) if self._multiple_roots else flat.indent
+            connector = (
+                "└─ "
+                if flat.show_connector and not flat.is_virtual_root_child and flat.is_last
+                else "├─ "
+                if flat.show_connector and not flat.is_virtual_root_child
+                else ""
+            )
+            connector_position = display_indent - 1 if connector else -1
+            prefix_chars: list[str] = []
+            for char_index in range(display_indent * 3):
+                level = char_index // 3
+                pos = char_index % 3
+                gutter = next((g for g in flat.gutters if g.position == level), None)
+                if gutter:
+                    prefix_chars.append("│" if pos == 0 and gutter.show else " ")
+                elif connector and level == connector_position:
+                    if pos == 0:
+                        prefix_chars.append("└" if flat.is_last else "├")
+                    elif pos == 1:
+                        prefix_chars.append("─")
+                    else:
+                        prefix_chars.append(" ")
+                else:
+                    prefix_chars.append(" ")
+            line.append("".join(prefix_chars), style=colors.dim)
+            if entry.id in self._active_path_ids:
+                line.append("• ", style=colors.accent)
+            line.append_text(self._entry_display_text(entry, selected))
+            if selected:
+                line.stylize(f"on {colors.panel_alt}")
+            line.truncate(width, overflow="ellipsis")
+            out.append_text(line)
+            out.append("\n")
+
+        out.append(f" ({self._selected_index + 1}/{len(self._filtered_nodes)})", style=colors.dim)
+        out.append("\n")
+        out.append("─" * width, style=colors.border)
+        return out
+
+    def action_move_up(self) -> None:
+        if self._filtered_nodes:
+            self._selected_index = (
+                len(self._filtered_nodes) - 1
+                if self._selected_index == 0
+                else self._selected_index - 1
+            )
+            self._last_selected_id = self._filtered_nodes[self._selected_index].node.entry.id
+            self._render_key += 1
+
+    def action_move_down(self) -> None:
+        if self._filtered_nodes:
+            self._selected_index = (
+                0
+                if self._selected_index == len(self._filtered_nodes) - 1
+                else self._selected_index + 1
+            )
+            self._last_selected_id = self._filtered_nodes[self._selected_index].node.entry.id
+            self._render_key += 1
+
+    def action_page_up(self) -> None:
+        self._jump_to_message("up")
+
+    def action_page_down(self) -> None:
+        self._jump_to_message("down")
+
+    def _jump_to_message(self, direction: str) -> None:
+        if not self._filtered_nodes:
+            return
+        step = -1 if direction == "up" else 1
+        index = self._selected_index + step
+        while 0 <= index < len(self._filtered_nodes):
+            entry = self._filtered_nodes[index].node.entry
+            if isinstance(entry, MessageEntry) and isinstance(
+                entry.message, UserMessage | AssistantMessage
+            ):
+                self._selected_index = index
+                self._last_selected_id = entry.id
+                self._render_key += 1
+                return
+            index += step
+
+    def action_select(self) -> None:
+        if self._filtered_nodes:
+            self.post_message(
+                self.Selected(self._filtered_nodes[self._selected_index].node.entry.id)
+            )
+
+    def action_cancel(self) -> None:
+        self.post_message(self.Cancelled())

vtx/ui/welcome.py

@@ -0,0 +1,51 @@
+from rich import box
+from rich.panel import Panel
+from rich.text import Text
+
+from vtx import config
+
+_LOGO = ("░█░█░███░█░█", "░█░█░░█░░░█░", "░░█░░░█░░█░█")
+
+_SHORTCUT_ROWS = (
+    (("/", "slash commands"), ("@", "files/dirs"), ("tab", "complete paths"), ("↑/↓", "history")),
+    (("shift+tab", "permissions"), ("esc", "to interrupt"), ("shift+enter", "add newline")),
+    (("ctrl+c", "clear input"), ("ctrl+c x2", "exit"), ("enter", "queue"), ("alt+enter", "steer")),
+    (("↑/↓", "select queue"), ("ctrl+t", "cycle thinking"), ("ctrl+shift+t", "toggle thinking")),
+)
+
+
+def build_welcome(version: str) -> tuple[Text, Panel]:
+    accent = config.ui.colors.accent
+    dim = config.ui.colors.dim
+    muted = config.ui.colors.muted
+    border_color = config.ui.colors.border
+
+    logo = Text()
+    for i, line in enumerate(_LOGO):
+        logo.append(line, style=accent)
+        if i == len(_LOGO) - 1:
+            logo.append(f" v{version}", style=dim)
+        logo.append("\n")
+    logo.append("\n")
+
+    shortcuts = Text()
+    for row_idx, row in enumerate(_SHORTCUT_ROWS):
+        for item_idx, (key, desc) in enumerate(row):
+            if item_idx > 0:
+                shortcuts.append(" • ", style=dim)
+            shortcuts.append(key, style=muted)
+            shortcuts.append(f" {desc}", style=dim)
+        if row_idx < len(_SHORTCUT_ROWS) - 1:
+            shortcuts.append("\n")
+
+    panel = Panel(
+        shortcuts,
+        title=None,
+        title_align="left",
+        box=box.SQUARE,
+        border_style=border_color,
+        padding=(0, 1),
+        expand=False,
+    )
+
+    return logo, panel