mindcode 0.2.0__py3-none-any.whl

mindcode/cli/shell/tui.py

@@ -0,0 +1,897 @@
+"""Mindcode shell 的全屏展示层。
+
+这里仅负责布局与渲染：既有的命令分发、队列和 runtime 事件语义仍由
+``repl.Shell`` 保持。消息区使用 Rich 将 Markdown 预渲染成 ANSI，再交给
+Prompt Toolkit 管理固定头尾和滚动视图。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import contextlib
+import io
+import re
+import time
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Condition, has_completions, is_done
+from prompt_toolkit.formatted_text import (
+    ANSI,
+    StyleAndTextTuples,
+    to_formatted_text,
+)
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import (
+    Float,
+    FloatContainer,
+    HSplit,
+    Layout,
+)
+from prompt_toolkit.layout.containers import ConditionalContainer, Window
+from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.menus import CompletionsMenu
+from prompt_toolkit.layout.processors import (
+    AfterInput,
+    BeforeInput,
+    ConditionalProcessor,
+)
+from prompt_toolkit.mouse_events import MouseButton, MouseEventType
+from prompt_toolkit.styles import Style
+from prompt_toolkit.utils import get_cwidth
+from prompt_toolkit.widgets import Box, Frame, RadioList
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+_ANSI_ESCAPE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+COMPOSER_PREFIX = "› "
+COMPOSER_HINT = "Let me help you with that"
+
+
+@dataclass
+class TranscriptEntry:
+    """A single display item in the scrollable transcript."""
+
+    role: str
+    content: str
+    streaming: bool = False
+    label: str = ""
+    status: str = ""
+
+
+class Transcript:
+    """Small in-memory transcript with one replaceable streaming assistant row."""
+
+    def __init__(self) -> None:
+        self.entries: list[TranscriptEntry] = []
+        self.on_change: Callable[[], None] | None = None
+        self.version = 0
+
+    def add_user(self, content: str) -> None:
+        self.entries.append(TranscriptEntry("user", content))
+        self._changed()
+
+    def add_assistant(self, content: str) -> None:
+        self.entries.append(TranscriptEntry("assistant", content))
+        self._changed()
+
+    def add_system(self, content: str) -> None:
+        content = content.strip("\n")
+        if content:
+            self.entries.append(TranscriptEntry("system", content))
+            self._changed()
+
+    def add_tool(self, label: str, detail: str) -> None:
+        self.entries.append(
+            TranscriptEntry("tool", detail, label=label, status="running")
+        )
+        self._changed()
+
+    def finish_tool(self, ok: bool, detail: str) -> None:
+        for entry in reversed(self.entries):
+            if entry.role == "tool" and entry.status == "running":
+                entry.status = "ok" if ok else "error"
+                entry.content = detail
+                self._changed()
+                return
+        self.entries.append(
+            TranscriptEntry(
+                "tool",
+                detail,
+                label="Tool",
+                status="ok" if ok else "error",
+            )
+        )
+        self._changed()
+
+    def add_tool_detail(self, markdown: str) -> None:
+        self.entries.append(TranscriptEntry("tool_detail", markdown))
+        self._changed()
+
+    def add_thinking(self, summary: str) -> None:
+        if self.entries and self.entries[-1].role == "thinking":
+            self.entries[-1].content = summary
+        else:
+            self.entries.append(TranscriptEntry("thinking", summary))
+        self._changed()
+
+    def append_delta(self, delta: str) -> None:
+        if not delta:
+            return
+        if (
+            self.entries
+            and self.entries[-1].role == "assistant"
+            and self.entries[-1].streaming
+        ):
+            self.entries[-1].content += delta
+        else:
+            self.entries.append(TranscriptEntry("assistant", delta, streaming=True))
+        self._changed()
+
+    def finish_stream(self) -> None:
+        if self.entries and self.entries[-1].role == "assistant":
+            self.entries[-1].streaming = False
+            self._changed()
+
+    def _changed(self) -> None:
+        self.version += 1
+        if self.on_change is not None:
+            self.on_change()
+
+
+def user_card_lines(content: str, width: int) -> list[str]:
+    """Return a bordered, fixed-width user card.
+
+    A one-line message has exactly one content row between the top and bottom
+    rules, so its first line is vertically centered in the box. Additional
+    lines expand the card downward without adding a leading blank row.
+    """
+
+    inner_width = max(12, width - 4)
+    wrapped = _wrap_display_text(content, inner_width - 2)
+    top = "┌" + "─" * (inner_width + 2) + "┐"
+    body = [
+        "│ "
+        + ("> " if index == 0 else "  ")
+        + line
+        + " " * (inner_width - 2 - get_cwidth(line))
+        + " │"
+        for index, line in enumerate(wrapped)
+    ]
+    bottom = "└" + "─" * (inner_width + 2) + "┘"
+    return [top, *body, bottom]
+
+
+def _wrap_display_text(text: str, width: int) -> list[str]:
+    """Wrap text by terminal cell width while retaining explicit blank lines."""
+
+    lines: list[str] = []
+    for source_line in text.splitlines() or [""]:
+        current = ""
+        for char in source_line:
+            if get_cwidth(current + char) > width and current:
+                lines.append(current)
+                current = char
+            else:
+                current += char
+        lines.append(current)
+    return lines or [""]
+
+
+def markdown_to_formatted_text(content: str, width: int) -> StyleAndTextTuples:
+    """Render Markdown through Rich and preserve its ANSI styling in the TUI."""
+
+    stream = io.StringIO()
+    Console(
+        file=stream,
+        force_terminal=True,
+        no_color=True,
+        width=max(20, width),
+        highlight=False,
+    ).print(Markdown(content, code_theme="ansi_dark"))
+    return list(to_formatted_text(ANSI(stream.getvalue().rstrip("\n"))))
+
+
+class TuiOutput(io.TextIOBase):
+    """Redirect console output such as slash-command results into the transcript."""
+
+    def __init__(self, transcript: Transcript) -> None:
+        self.transcript = transcript
+        self._buffer = ""
+
+    def write(self, data: str) -> int:
+        if not data:
+            return 0
+        self._buffer += _ANSI_ESCAPE.sub("", data).replace("\r", "")
+        while "\n" in self._buffer:
+            line, self._buffer = self._buffer.split("\n", 1)
+            self.transcript.add_system(line)
+        return len(data)
+
+    def flush(self) -> None:
+        if self._buffer:
+            self.transcript.add_system(self._buffer)
+            self._buffer = ""
+
+    def isatty(self) -> bool:
+        return True
+
+
+class _TranscriptControl(FormattedTextControl):
+    """A viewport control with explicit scroll offsets, independent of cursor."""
+
+    def __init__(self, tui: "MindcodeTui") -> None:
+        self._tui = tui
+        super().__init__(text=tui._render_transcript_view, focusable=False)
+
+    def mouse_handler(self, mouse_event: Any) -> Any:
+        if mouse_event.event_type == MouseEventType.SCROLL_UP:
+            self._tui._scroll_transcript(-3)
+            return None
+        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+            self._tui._scroll_transcript(3)
+            return None
+        if mouse_event.button == MouseButton.LEFT:
+            if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
+                self._tui._start_selection(
+                    mouse_event.position.y, mouse_event.position.x
+                )
+                return None
+            if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+                self._tui._update_selection(
+                    mouse_event.position.y, mouse_event.position.x
+                )
+                return None
+            if mouse_event.event_type == MouseEventType.MOUSE_UP:
+                self._tui._finish_selection(
+                    mouse_event.position.y, mouse_event.position.x
+                )
+                return None
+        return super().mouse_handler(mouse_event)
+
+
+class MindcodeTui:
+    """Fullscreen frame: header, transcript, bordered composer and status bar."""
+
+    def __init__(
+        self,
+        state: Any,
+        transcript: Transcript,
+        *,
+        on_submit: Callable[[str], Awaitable[None]],
+        on_exit: Callable[[], Awaitable[None]],
+        status_provider: Callable[[], str],
+    ) -> None:
+        self.state = state
+        self.transcript = transcript
+        self.on_submit = on_submit
+        self.on_exit = on_exit
+        self.status_provider = status_provider
+        self._follow_transcript = True
+        self._scroll_offset = 0
+        self._active_dialog: Float | None = None
+        self._working = False
+        self._selection_start: tuple[int, int] | None = None
+        self._copy_notice: tuple[str, float] | None = None
+        self._layout_cache: tuple[int, int, int, list[StyleAndTextTuples]] | None = (
+            None
+        )
+        self._layout_dirty = False
+
+        self.buffer = Buffer(
+            multiline=True,
+            completer=getattr(state, "completer", None),
+            complete_while_typing=True,
+        )
+        self._transcript_window = Window(
+            _TranscriptControl(self),
+            wrap_lines=False,
+            always_hide_cursor=True,
+            style="class:transcript",
+        )
+        self._composer_body = Window(
+            BufferControl(
+                buffer=self.buffer,
+                focusable=True,
+                focus_on_click=True,
+                input_processors=[
+                    BeforeInput(
+                        COMPOSER_PREFIX,
+                        style="class:composer.hint",
+                    ),
+                    ConditionalProcessor(
+                        AfterInput(
+                            COMPOSER_HINT,
+                            style="class:composer.hint",
+                        ),
+                        filter=Condition(lambda: not self.buffer.text),
+                    )
+                ],
+            ),
+            height=Dimension(min=1, max=1, preferred=1),
+            wrap_lines=True,
+            style="class:composer.body",
+        )
+        self._composer = Frame(
+            self._composer_body,
+            height=Dimension(min=3, max=3, preferred=3),
+            style="class:composer",
+        )
+        header = Frame(
+            Window(
+                FormattedTextControl(self._render_header),
+                height=2,
+                style="class:header.body",
+            ),
+            height=4,
+            style="class:header",
+        )
+        status = Window(
+            FormattedTextControl(self._render_status),
+            height=1,
+            style="class:status",
+        )
+        self._root = FloatContainer(
+            HSplit([header, self._transcript_window, self._composer, status]),
+            floats=[
+                Float(
+                    xcursor=True,
+                    ycursor=True,
+                    content=self._build_completion_popup(),
+                )
+            ],
+        )
+        self.app = Application(
+            layout=Layout(self._root, focused_element=self._composer_body),
+            key_bindings=self._build_key_bindings(),
+            full_screen=True,
+            mouse_support=True,
+            style=_STYLE,
+            refresh_interval=0.25,
+            terminal_size_polling_interval=0.25,
+        )
+        self.transcript.on_change = self._on_transcript_changed
+        self.buffer.on_text_changed += lambda _: self._sync_composer_height()
+
+    async def run(self) -> None:
+        await self.app.run_async()
+
+    def exit(self) -> None:
+        if self.app.is_running:
+            self.app.exit()
+
+    def add_user_message(self, content: str) -> None:
+        self.transcript.add_user(content)
+
+    def set_working(self, working: bool) -> None:
+        """Show a transient activity row while an agent turn is running."""
+        if self._working == working:
+            return
+        self._working = working
+        if self._follow_transcript:
+            self._scroll_offset = self._bottom_scroll_offset()
+        self.app.invalidate()
+
+    async def choose(
+        self,
+        title: str,
+        options: list[tuple[str, str]],
+        default: str | None,
+    ) -> str | None:
+        """Show the existing slash-command picker inside the current TUI."""
+
+        if not self.app.is_running:
+            return None
+        loop = asyncio.get_running_loop()
+        result: asyncio.Future[str | None] = loop.create_future()
+        choices = RadioList(
+            options,
+            default=default,
+            open_character="",
+            select_character="•",
+            close_character="",
+            container_style="class:popup.list",
+            default_style="class:popup.option",
+            selected_style="class:popup.option.current",
+            checked_style="class:popup.option.checked",
+            select_on_focus=True,
+        )
+
+        def close(value: str | None) -> None:
+            if not result.done():
+                result.set_result(value)
+
+        popup_bindings = KeyBindings()
+
+        @popup_bindings.add("enter", eager=True)
+        def select_option(event) -> None:
+            close(choices.current_value)
+
+        @popup_bindings.add("escape", eager=True)
+        def cancel_option(event) -> None:
+            close(None)
+
+        dialog = Frame(
+            HSplit(
+                [
+                    Window(
+                        FormattedTextControl(
+                            [("class:popup.title", f"  {title}")]
+                        ),
+                        height=1,
+                        style="class:popup.title",
+                    ),
+                    Box(choices, padding=1),
+                    Window(
+                        FormattedTextControl(
+                            [("class:popup.hint", "  ↑↓ Select · Enter Apply · Esc Cancel")]
+                        ),
+                        height=1,
+                        style="class:popup.hint",
+                    ),
+                ],
+                style="class:popup.body",
+            ),
+            width=Dimension(preferred=58, max=72),
+            style="class:popup",
+            key_bindings=popup_bindings,
+            modal=True,
+        )
+        floating = Float(content=dialog)
+        self._active_dialog = floating
+        self._root.floats.append(floating)
+        self.app.layout.focus(choices)
+        self.app.invalidate()
+        try:
+            return await result
+        finally:
+            if floating in self._root.floats:
+                self._root.floats.remove(floating)
+            self._active_dialog = None
+            self.app.layout.focus(self._composer_body)
+            self.app.invalidate()
+
+    def _build_completion_popup(self) -> ConditionalContainer:
+        """The shared, compact popup used for slash commands and arguments."""
+        return ConditionalContainer(
+            Frame(
+                HSplit(
+                    [
+                        Window(
+                            FormattedTextControl(
+                                [("class:popup.title", "  Suggestions")]
+                            ),
+                            height=1,
+                            style="class:popup.title",
+                        ),
+                        CompletionsMenu(max_height=8, scroll_offset=1),
+                        Window(
+                            FormattedTextControl(
+                                [("class:popup.hint", "  ↑↓ Select · Enter Insert")]
+                            ),
+                            height=1,
+                            style="class:popup.hint",
+                        ),
+                    ],
+                    style="class:popup.body",
+                ),
+                width=Dimension(preferred=48, max=72),
+                style="class:popup",
+            ),
+            filter=has_completions & ~is_done,
+        )
+
+    def _build_key_bindings(self) -> KeyBindings:
+        bindings = KeyBindings()
+
+        @bindings.add(
+            "enter", filter=Condition(lambda: self._active_dialog is None)
+        )
+        def submit(event) -> None:
+            if self._accept_completion():
+                event.app.invalidate()
+                return
+            text = self.buffer.text.strip()
+            if not text:
+                return
+            self.buffer.reset()
+            self.app.create_background_task(self.on_submit(text))
+
+        @bindings.add(
+            "up", filter=Condition(self._completion_is_visible), eager=True
+        )
+        def completion_previous(event) -> None:
+            self.buffer.complete_previous(disable_wrap_around=True)
+
+        @bindings.add(
+            "down", filter=Condition(self._completion_is_visible), eager=True
+        )
+        def completion_next(event) -> None:
+            self.buffer.complete_next(disable_wrap_around=True)
+
+        @bindings.add(
+            "escape", "enter",
+            filter=Condition(lambda: self._active_dialog is None),
+        )
+        def insert_newline(event) -> None:
+            event.current_buffer.insert_text("\n")
+
+        @bindings.add(
+            "c-d", filter=Condition(lambda: self._active_dialog is None)
+        )
+        def exit_shell(event) -> None:
+            self.app.create_background_task(self.on_exit())
+
+        @bindings.add(
+            "c-c", filter=Condition(lambda: self._active_dialog is None)
+        )
+        def interrupt_shell(event) -> None:
+            self.app.create_background_task(self.on_exit())
+
+        @bindings.add(
+            "c-y", filter=Condition(lambda: self._active_dialog is None)
+        )
+        def copy_last_assistant(event) -> None:
+            latest = next(
+                (
+                    entry.content
+                    for entry in reversed(self.transcript.entries)
+                    if entry.role == "assistant"
+                ),
+                "",
+            )
+            if latest:
+                self._copy_to_clipboard(latest, "已复制最新回复")
+            else:
+                self._set_copy_notice("暂无可复制的助手回复")
+
+        @bindings.add("pageup", eager=True)
+        def page_up(event) -> None:
+            self._scroll_transcript(-max(1, event.app.output.get_size().rows - 6))
+
+        @bindings.add("pagedown", eager=True)
+        def page_down(event) -> None:
+            self._scroll_transcript(max(1, event.app.output.get_size().rows - 6))
+
+        @bindings.add("end", eager=True)
+        def follow(event) -> None:
+            self._follow_transcript = True
+            self._scroll_offset = self._bottom_scroll_offset()
+            self.app.invalidate()
+
+        return bindings
+
+    def _scroll_transcript(self, amount: int) -> None:
+        bottom = self._bottom_scroll_offset()
+        self._scroll_offset = min(
+            bottom, max(0, self._scroll_offset + amount)
+        )
+        self._follow_transcript = self._scroll_offset >= bottom
+        self.app.invalidate()
+
+    def _completion_is_visible(self) -> bool:
+        state = self.buffer.complete_state
+        return state is not None and bool(state.completions)
+
+    def _accept_completion(self) -> bool:
+        state = self.buffer.complete_state
+        if state is None or not state.completions:
+            return False
+        if state.current_completion is None:
+            self.buffer.go_to_completion(0)
+            state = self.buffer.complete_state
+        assert state is not None and state.current_completion is not None
+        self.buffer.apply_completion(state.current_completion)
+        return True
+
+    def _on_transcript_changed(self) -> None:
+        if self._follow_transcript:
+            self._scroll_offset = self._bottom_scroll_offset()
+        self.app.invalidate()
+
+    def _render_header(self) -> StyleAndTextTuples:
+        workspace = str(getattr(self.state, "workspace", ""))
+        model = getattr(self.state, "active_model", "") or "未选择模型"
+        provider = getattr(self.state, "active_provider", "") or "未选择 provider"
+        session_id = getattr(self.state, "session_id", "")
+        renderer = getattr(self.state, "renderer", None)
+        token_display = _format_token_count(
+            getattr(renderer, "total_tokens", None)
+        )
+        return [
+            ("class:header.logo", "  MINDCODE  "),
+            ("class:header.detail", f"{provider}/{model}  ·  {token_display}\n"),
+            (
+                "class:header.detail",
+                f"  {workspace}  ·  session {session_id}",
+            ),
+        ]
+
+    def _render_status(self) -> StyleAndTextTuples:
+        status = self.status_provider()
+        if self._copy_notice is not None:
+            message, expires_at = self._copy_notice
+            if time.monotonic() < expires_at:
+                status += f"  ·  {message}"
+            else:
+                self._copy_notice = None
+        return [("class:status", " " + status)]
+
+    def _render_transcript_view(self) -> StyleAndTextTuples:
+        lines = self._transcript_visual_lines()
+        height = self._transcript_height()
+        bottom = max(0, len(lines) - height)
+        if self._follow_transcript:
+            self._scroll_offset = bottom
+        else:
+            self._scroll_offset = min(self._scroll_offset, bottom)
+        visible = lines[self._scroll_offset : self._scroll_offset + height]
+        rendered: StyleAndTextTuples = []
+        for line in visible:
+            rendered.extend(line)
+            rendered.append(("", "\n"))
+        return rendered
+
+    def _transcript_visual_lines(self) -> list[StyleAndTextTuples]:
+        width = max(24, self.app.output.get_size().columns - 2)
+        cache_key = (self.transcript.version, width, self._working)
+        if (
+            not self._layout_dirty
+            and self._layout_cache is not None
+            and self._layout_cache[:3] == cache_key
+        ):
+            return self._layout_cache[3]
+        self._layout_dirty = False
+        lines = _wrap_formatted_text(self._render_transcript_content(width), width)
+        self._layout_cache = (*cache_key, lines)
+        return lines
+
+    def _render_transcript_content(self, width: int) -> StyleAndTextTuples:
+        rendered: StyleAndTextTuples = []
+        for entry in self.transcript.entries:
+            if rendered:
+                rendered.append(("", "\n\n"))
+            if entry.role == "user":
+                for line in user_card_lines(entry.content, width):
+                    rendered.append(("class:user.border", line[0]))
+                    rendered.append(("class:user.message", line[1:-1]))
+                    rendered.append(("class:user.border", line[-1:]))
+                    rendered.append(("", "\n"))
+                rendered.pop()
+            elif entry.role == "assistant":
+                rendered.extend(
+                    _assistant_reply_formatted_text(
+                        markdown_to_formatted_text(entry.content, width - 4),
+                    )
+                )
+                if entry.streaming:
+                    rendered.append(("class:streaming", " ▍"))
+            elif entry.role == "tool":
+                symbol, style = {
+                    "running": ("●", "class:tool.running"),
+                    "ok": ("✓", "class:tool.ok"),
+                    "error": ("✗", "class:tool.error"),
+                }.get(entry.status, ("•", "class:tool.running"))
+                rendered.append((style, f"  {symbol} {entry.label}"))
+                if entry.content:
+                    rendered.append(("class:tool.detail", f"  {entry.content}"))
+            elif entry.role == "tool_detail":
+                rendered.extend(markdown_to_formatted_text(entry.content, width))
+            elif entry.role == "thinking":
+                rendered.append(("class:thinking.label", "  Thinking"))
+                rendered.append(("class:thinking.detail", f"  {entry.content}"))
+            else:
+                rendered.append(("class:system", entry.content))
+        if self._working:
+            if rendered:
+                rendered.append(("", "\n\n"))
+            rendered.append(("class:working", "  ● Working…"))
+        return rendered or [("class:empty", "\n  发送消息开始对话。")]
+
+    def _transcript_height(self) -> int:
+        terminal_rows = self.app.output.get_size().rows
+        return max(1, terminal_rows - self._composer_height() - 7)
+
+    def _bottom_scroll_offset(self) -> int:
+        total_lines = len(self._transcript_visual_lines())
+        return max(0, total_lines - self._transcript_height())
+
+    def _start_selection(self, row: int, column: int) -> None:
+        self._selection_start = (self._scroll_offset + max(0, row), max(0, column))
+
+    def _update_selection(self, row: int, column: int) -> None:
+        if self._selection_start is not None:
+            self.app.invalidate()
+
+    def _finish_selection(self, row: int, column: int) -> None:
+        start = self._selection_start
+        self._selection_start = None
+        if start is None:
+            return
+        end = (self._scroll_offset + max(0, row), max(0, column))
+        if start == end:
+            return
+        selected = _selection_text(self._transcript_visual_lines(), start, end)
+        if selected:
+            self._copy_to_clipboard(selected, "已复制所选文本")
+
+    def _copy_to_clipboard(self, text: str, notice: str) -> None:
+        self.app.clipboard.set_text(text)
+        if self.app.is_running:
+            encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+            self.app.output.write_raw(f"\x1b]52;c;{encoded}\a")
+            self.app.output.flush()
+        self._set_copy_notice(notice)
+
+    def _set_copy_notice(self, message: str) -> None:
+        self._copy_notice = (message, time.monotonic() + 2)
+        self.app.invalidate()
+
+    def _composer_height(self) -> int:
+        width = max(20, self.app.output.get_size().columns - 6)
+        rows = len(_wrap_display_text(self.buffer.text or "", width))
+        return min(6, max(1, rows))
+
+    def _sync_composer_height(self) -> None:
+        height = self._composer_height()
+        self._composer_body.height = Dimension(
+            min=height, max=height, preferred=height
+        )
+        outer_height = height + 2
+        self._composer.height = Dimension(
+            min=outer_height, max=outer_height, preferred=outer_height
+        )
+        self._layout_dirty = True
+        self.app.invalidate()
+
+
+_STYLE = Style.from_dict(
+    {
+        "header": "bg:#1b1b1b",
+        "header.body": "bg:#1b1b1b #d0d0d0",
+        "header.logo": "bold #e2e2e2",
+        "header.detail": "#b8b8b8",
+        "transcript": "bg:#121212 #d6d6d6",
+        "composer": "bg:#1b1b1b",
+        "composer.body": "bg:#1b1b1b #e6e6e6",
+        "composer.hint": "#858585",
+        "frame.border": "#727272",
+        "frame.label": "bold #d0d0d0",
+        "status": "bg:#244766 #e5f0f8",
+        "popup": "bg:#202020 #d7d7d7",
+        "popup.body": "bg:#202020 #d7d7d7",
+        "popup.title": "bold bg:#202020 #e3e3e3",
+        "popup.hint": "bg:#202020 #969696",
+        "popup.list": "bg:#202020 #d7d7d7",
+        "popup.option": "bg:#202020 #d7d7d7",
+        "popup.option.current": "bg:#5a5a5a #ffffff",
+        "popup.option.checked": "#cfcfcf",
+        "completion-menu": "bg:#202020 #d7d7d7",
+        "completion-menu.completion": "bg:#202020 #d7d7d7",
+        "completion-menu.completion.current": "bg:#5a5a5a #ffffff",
+        "completion-menu.meta.completion": "bg:#202020 #9d9d9d",
+        "completion-menu.meta.completion.current": "bg:#5a5a5a #f0f0f0",
+        "shadow": "bg:#0b0b0b",
+        "user.border": "#858585",
+        "user.message": "#e6e6e6",
+        "assistant.marker": "#bdbdbd",
+        "system": "#9c9c9c",
+        "tool.running": "bold #bcbcbc",
+        "tool.ok": "bold #d0d0d0",
+        "tool.error": "bold #b3b3b3",
+        "tool.detail": "#ababab",
+        "thinking.label": "bold #c9c9c9",
+        "thinking.detail": "italic #acacac",
+        "working": "bold #d0d0d0",
+        "streaming": "#c8c8c8",
+        "empty": "#888888",
+    }
+)
+
+
+@contextlib.contextmanager
+def redirect_console_output(transcript: Transcript):
+    """Route the shared Rich console's stdout proxy into the TUI transcript."""
+
+    output = TuiOutput(transcript)
+    with contextlib.redirect_stdout(output):
+        yield
+    output.flush()
+
+
+def _wrap_formatted_text(
+    fragments: StyleAndTextTuples,
+    width: int,
+) -> list[StyleAndTextTuples]:
+    """Split rendered Rich fragments into terminal-width visual lines."""
+
+    lines: list[StyleAndTextTuples] = [[]]
+    line_width = 0
+    for style, text, *_ in fragments:
+        for char in text:
+            if char == "\n":
+                lines.append([])
+                line_width = 0
+                continue
+            char_width = get_cwidth(char)
+            if line_width + char_width > width and lines[-1]:
+                lines.append([])
+                line_width = 0
+            _append_fragment(lines[-1], style, char)
+            line_width += char_width
+    return lines
+
+
+def _append_fragment(
+    line: StyleAndTextTuples,
+    style: str,
+    text: str,
+) -> None:
+    if line and line[-1][0] == style:
+        previous_style, previous_text, *rest = line[-1]
+        line[-1] = (previous_style, previous_text + text, *rest)
+    else:
+        line.append((style, text))
+
+
+def _assistant_reply_formatted_text(
+    fragments: StyleAndTextTuples,
+) -> StyleAndTextTuples:
+    """Prefix assistant replies with a bullet and align continuation lines."""
+
+    indented: StyleAndTextTuples = [("class:assistant.marker", "  • ")]
+    for style, text, *_ in fragments:
+        parts = text.splitlines(keepends=True)
+        for part in parts:
+            indented.append((style, part))
+            if part.endswith("\n"):
+                indented.append(("", "    "))
+    return indented
+
+
+def _selection_text(
+    lines: list[StyleAndTextTuples],
+    start: tuple[int, int],
+    end: tuple[int, int],
+) -> str:
+    """Extract an inclusive terminal-cell selection from rendered lines."""
+
+    if end < start:
+        start, end = end, start
+    start_row, start_column = start
+    end_row, end_column = end
+    selected: list[str] = []
+    for row in range(start_row, min(end_row + 1, len(lines))):
+        text = "".join(fragment[1] for fragment in lines[row])
+        left = start_column if row == start_row else 0
+        right = end_column + 1 if row == end_row else get_cwidth(text)
+        selected.append(_slice_terminal_cells(text, left, right).rstrip())
+    return "\n".join(selected).strip("\n")
+
+
+def _slice_terminal_cells(text: str, left: int, right: int) -> str:
+    result: list[str] = []
+    offset = 0
+    for char in text:
+        char_width = get_cwidth(char)
+        if offset + char_width > left and offset < right:
+            result.append(char)
+        offset += char_width
+        if offset >= right:
+            break
+    return "".join(result)
+
+
+def _format_token_count(value: int | None) -> str:
+    if value is None:
+        return "tokens —"
+    if value < 1_000:
+        return f"tokens {value}"
+    if value < 1_000_000:
+        return f"tokens {value / 1_000:.1f}k"
+    return f"tokens {value / 1_000_000:.1f}M"