delos-cli 0.1.0__py3-none-any.whl

delos_cli/ui/repl.py

@@ -0,0 +1,679 @@
+"""Custom prompt_toolkit Application: streaming output above, persistent input below.
+
+Replaces the per-turn ``prompt_async`` loop so the user can:
+
+- See live Markdown rendering as the agent streams text.
+- Type new messages or slash commands while the agent is mid-turn.
+- Hit ``/stop`` (or Ctrl+C) to send the backend stop signal without
+  losing the prompt.
+
+Layout::
+
+    ┌── output area (Rich-rendered ANSI, scrollable) ───────────┐
+    │ history blocks: tool calls, completed turns               │
+    │ live block: streaming Markdown (re-rendered each delta)   │
+    ├──────────────────── separator ────────────────────────────┤
+    │ » multiline input                                          │
+    ├──────────────────── separator ────────────────────────────┤
+    │ region · conv · turn · model · streaming/idle              │
+    └────────────────────────────────────────────────────────────┘
+
+A single asyncio task tracks the in-flight turn (if any).  Plain text
+sent while a turn is running is queued via the backend FIFO queue (same
+mechanism the web frontend uses).  Slash commands are dispatched
+immediately regardless of streaming state.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import inspect
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from prompt_toolkit.application import Application, get_app
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters import Condition, has_completions
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.layout.containers import (
+    ConditionalContainer,
+    Float,
+    FloatContainer,
+    HSplit,
+    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 BeforeInput
+from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
+from prompt_toolkit.styles import Style
+from rich.text import Text
+
+from delos_cli.commands import GLOBAL_COMMANDS, Quit
+from delos_cli.ctx import ConfirmOutcome
+from delos_cli.transport.client import TransportError
+from delos_cli.ui.completer import CommandCompleter
+from delos_cli.ui.output import OutputBuffer
+
+if TYPE_CHECKING:
+    from collections.abc import Coroutine
+
+    from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+
+    from delos_cli.ctx import Ctx
+
+
+# Keep handles to background tasks so the GC doesn't collect them mid-flight
+# (asyncio holds only weak refs).  Pruned on completion via add_done_callback.
+_BG_TASKS: set[asyncio.Task[None]] = set()
+
+
+def _spawn(coro: Coroutine[Any, Any, None]) -> None:
+    """Schedule ``coro`` and retain a strong ref until it finishes."""
+    task = asyncio.create_task(coro)
+    _BG_TASKS.add(task)
+    task.add_done_callback(_BG_TASKS.discard)
+
+
+class _OutputControl(FormattedTextControl):
+    """:class:`FormattedTextControl` that owns scroll handling.
+
+    We can't lean on the Window's built-in ``_mouse_handler`` because it
+    adjusts ``vertical_scroll`` directly, and prompt_toolkit then
+    overrides it on the next render based on the cursor position pin we
+    use for auto-follow.  Instead we intercept scroll events ourselves,
+    update ``state`` (cursor line + follow flag), and let the Window
+    re-render with the new cursor — which is the exact behavior we want.
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        on_scroll: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Wrap the parent control with an ``on_scroll(direction)`` side effect."""
+        super().__init__(*args, **kwargs)
+        self._on_scroll = on_scroll
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> Any:
+        """Handle scroll events ourselves; defer everything else to the parent."""
+        etype = mouse_event.event_type
+        if etype == MouseEventType.SCROLL_UP:
+            self._on_scroll("up")
+            return None
+        if etype == MouseEventType.SCROLL_DOWN:
+            self._on_scroll("down")
+            return None
+        return super().mouse_handler(mouse_event)
+
+
+_STYLE = Style.from_dict({
+    "prompt": "fg:ansicyan bold",
+    "separator": "fg:#444444",
+    "toolbar": "fg:#888888 bg:#1a1a1a",
+    "toolbar.streaming": "fg:#fbbf24 bg:#1a1a1a",
+    "toolbar.idle": "fg:#888888 bg:#1a1a1a",
+    "confirm.body": "fg:#fbbf24",
+    "confirm.button": "fg:#888888",
+    "confirm.button.selected": "fg:#1a1a1a bg:#fbbf24 bold",
+})
+
+
+_SCROLL_STEP = 3
+_PAGE_STEP = 10
+
+
+@dataclass
+class _ConfirmRequest:
+    """Live state for an in-app Accept/Deny dialog.
+
+    Created by :func:`_repl_confirm` (installed on ``ctx.confirm``) when
+    a tool handler asks the user to approve a destructive action.  The
+    REPL replaces the input area with the command preview, an
+    Accept / Deny pair of buttons (Tab to toggle), and a freeform
+    reason buffer; the keybindings resolve ``future`` and clear the
+    request so the layout snaps back to the regular input.
+    """
+
+    body: str
+    selected: int  # 0 = Accept, 1 = Deny
+    future: asyncio.Future[ConfirmOutcome]
+
+
+class _ReplState:
+    """Shared mutable state between the layout and the keybinding handlers."""
+
+    def __init__(self, ctx: Ctx, output: OutputBuffer) -> None:
+        self.ctx = ctx
+        self.output = output
+        self.input_buffer = Buffer(
+            multiline=True,
+            completer=CommandCompleter(ctx),
+            complete_while_typing=True,
+        )
+        self.turn_task: asyncio.Task[None] | None = None
+        # ``follow`` = True → output Window snaps to bottom on every change.
+        # Toggled off when the user scrolls up (mouse wheel, PageUp, Home);
+        # toggled back on automatically when scrolling reaches the bottom
+        # again, or explicitly via End.
+        self.follow: bool = True
+        # When ``follow`` is False, the source-line index the output Window
+        # focuses on.  The Window keeps this line visible (via the cursor
+        # position pin), so new streaming content piling up below doesn't
+        # yank the user away from where they're reading.
+        self.cursor_line: int = 0
+        # Active in-app confirmation dialog, if any.  Layout swaps the
+        # input window for the confirm widget when this is set.
+        self.confirm: _ConfirmRequest | None = None
+        # Single-line buffer for the optional "reason" field shown
+        # underneath the Accept/Deny buttons during confirmation.
+        # Reset at the start of each new dialog (cf. ``_repl_confirm``).
+        self.reason_buffer = Buffer(multiline=False)
+
+    def is_streaming(self) -> bool:
+        """True iff a turn task is still running."""
+        return self.turn_task is not None and not self.turn_task.done()
+
+    def last_line(self) -> int:
+        """Index of the last source line in the output buffer (clamped to 0)."""
+        return max(0, self.output.line_count - 1)
+
+    def scroll_up(self, step: int) -> None:
+        """Move the focus line up by ``step``; drops out of follow mode."""
+        if self.follow:
+            self.follow = False
+            self.cursor_line = self.last_line()
+        self.cursor_line = max(0, self.cursor_line - step)
+
+    def scroll_down(self, step: int) -> None:
+        """Move the focus line down; re-enters follow mode at the bottom."""
+        if self.follow:
+            return
+        target = self.cursor_line + step
+        last = self.last_line()
+        if target >= last:
+            self.follow = True
+            self.cursor_line = last
+        else:
+            self.cursor_line = target
+
+
+async def run(ctx: Ctx) -> None:
+    """Entry point — build the app, wire it to ``ctx``, run until exit."""
+    output = OutputBuffer()
+    ctx.output = output
+
+    state = _ReplState(ctx, output)
+    app, input_window, reason_window = _build_application(state)
+    output.attach(app)
+
+    # Install an in-app confirmation prompt so tools can request user
+    # approval (``ctx.confirm("preview")``) without spawning a nested
+    # PromptSession that fights the live one for the terminal.
+    async def _repl_confirm(body: str) -> ConfirmOutcome:
+        # Cancel any prior pending request — only one dialog at a time.
+        prior = state.confirm
+        if prior is not None and not prior.future.done():
+            prior.future.set_result(ConfirmOutcome(accepted=False))
+        # Reset the reason buffer so old text from a previous denial
+        # doesn't leak into the next dialog.
+        state.reason_buffer.reset()
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[ConfirmOutcome] = loop.create_future()
+        state.confirm = _ConfirmRequest(body=body, selected=0, future=future)
+        # Move focus onto the reason buffer so the user can type a
+        # comment freely; arrow-key bindings in confirm mode bypass
+        # buffer cursor movement (we override Tab for button toggle).
+        with contextlib.suppress(Exception):
+            app.layout.focus(reason_window)
+        app.invalidate()
+        try:
+            return await future
+        finally:
+            if state.confirm is not None and state.confirm.future is future:
+                state.confirm = None
+                with contextlib.suppress(Exception):
+                    app.layout.focus(input_window)
+                app.invalidate()
+
+    ctx.confirm = _repl_confirm
+
+    _print_banner(state)
+    await ctx.app.on_enter(ctx)
+
+    try:
+        await app.run_async()
+    finally:
+        # Cancel any in-flight turn so the asyncio loop can exit cleanly.
+        turn_task = state.turn_task
+        if turn_task is not None and not turn_task.done():
+            turn_task.cancel()
+            with contextlib.suppress(BaseException):
+                await turn_task
+        ctx.output = None
+        ctx.confirm = None
+
+
+# ---------------------------------------------------------------------------
+# Layout + keybindings
+# ---------------------------------------------------------------------------
+
+
+def _build_application(
+    state: _ReplState,
+) -> tuple[Application[None], Window, Window]:
+    """Wire the layout, keybindings, and root Application object.
+
+    Returns ``(app, input_window, reason_window)`` so the caller can
+    swap focus between the regular input and the confirm-dialog reason
+    field without reaching into private layout state.
+    """
+    def _output_cursor() -> Point:
+        # Pin an invisible cursor on the line we want to keep in view —
+        # the Window's auto-scroll logic adjusts ``vertical_scroll`` to
+        # keep this line visible, which gives us auto-follow for free
+        # (and stable user-scroll: returning a real line — never None —
+        # avoids prompt_toolkit's default Point(0, 0) snap-to-top).
+        if state.follow:
+            return Point(x=0, y=state.last_line())
+        return Point(x=0, y=state.cursor_line)
+
+    def _on_scroll(direction: str) -> None:
+        if direction == "up":
+            state.scroll_up(_SCROLL_STEP)
+        else:  # "down"
+            state.scroll_down(_SCROLL_STEP)
+
+    output_window = Window(
+        content=_OutputControl(
+            text=state.output.get_ansi,
+            get_cursor_position=_output_cursor,
+            focusable=False,
+            show_cursor=False,
+            on_scroll=_on_scroll,
+        ),
+        wrap_lines=True,
+        always_hide_cursor=True,
+    )
+
+    input_window = Window(
+        content=BufferControl(
+            buffer=state.input_buffer,
+            input_processors=[BeforeInput("» ", style="class:prompt")],
+        ),
+        wrap_lines=True,
+        height=Dimension(min=1, max=10),
+    )
+
+    confirm_header = Window(
+        content=FormattedTextControl(
+            text=lambda: _confirm_text(state),
+            focusable=False,
+            show_cursor=False,
+        ),
+        wrap_lines=True,
+        height=Dimension(min=3, max=10),
+    )
+
+    # Reason text input — only shown during confirmation.  Focused via
+    # ``app.layout.focus(reason_window)`` so the user can type freely;
+    # custom keybindings (Tab / Enter) handle button toggling and submit.
+    reason_window = Window(
+        content=BufferControl(
+            buffer=state.reason_buffer,
+            input_processors=[BeforeInput("reason: ", style="class:confirm.body")],
+        ),
+        wrap_lines=True,
+        height=Dimension(min=1, max=3),
+    )
+
+    is_confirming = Condition(lambda: state.confirm is not None)
+    is_idle = Condition(lambda: state.confirm is None)
+
+    confirm_layout = HSplit(
+        [confirm_header, reason_window],
+    )
+
+    toolbar_window = Window(
+        content=FormattedTextControl(text=lambda: _toolbar_text(state)),
+        height=1,
+        style="class:toolbar",
+    )
+
+    body = HSplit([
+        output_window,
+        Window(height=1, char="─", style="class:separator"),
+        ConditionalContainer(input_window, filter=is_idle),
+        ConditionalContainer(confirm_layout, filter=is_confirming),
+        Window(height=1, char="─", style="class:separator"),
+        toolbar_window,
+    ])
+    # Floating completions menu pinned to the input area.  Wrapped in a
+    # ConditionalContainer so the float disappears when there's nothing
+    # to complete (avoids a stray empty box when you're not typing ``/``).
+    root = FloatContainer(
+        content=body,
+        floats=[
+            Float(
+                xcursor=True,
+                ycursor=True,
+                content=ConditionalContainer(
+                    content=CompletionsMenu(max_height=8, scroll_offset=1),
+                    filter=has_completions,
+                ),
+            ),
+        ],
+    )
+
+    kb = _build_keybindings(state, output_window)
+
+    app = Application(
+        layout=Layout(root, focused_element=input_window),
+        key_bindings=kb,
+        style=_STYLE,
+        full_screen=True,
+        # Capture mouse so scroll wheel works on the output area.  Trade-off:
+        # plain click-drag selection in the terminal is intercepted; users
+        # who want to copy text can hold Shift while selecting on most
+        # modern terminals (iTerm2, GNOME Terminal, kitty, …).
+        mouse_support=True,
+    )
+    return app, input_window, reason_window
+
+
+def _build_keybindings(state: _ReplState, output_window: Window) -> KeyBindings:
+    """Bindings for submit, newline, scroll, stop, quit."""
+    kb = KeyBindings()
+
+    is_confirming = Condition(lambda: state.confirm is not None)
+    is_idle = Condition(lambda: state.confirm is None)
+
+    # ── Confirmation dialog (replaces the input area when active) ──
+    # Tab toggles between Accept and Deny; left/right stay free for the
+    # reason buffer's cursor.  ``eager=True`` means these bindings win
+    # over the buffer's defaults the moment they match.
+    @kb.add("tab", filter=is_confirming, eager=True)
+    @kb.add("s-tab", filter=is_confirming, eager=True)
+    def _confirm_toggle(event: KeyPressEvent) -> None:
+        _ = event
+        if state.confirm is not None:
+            state.confirm.selected = 1 - state.confirm.selected
+
+    @kb.add("enter", filter=is_confirming, eager=True)
+    def _confirm_submit(event: KeyPressEvent) -> None:
+        _ = event
+        req = state.confirm
+        if req is None or req.future.done():
+            return
+        if req.selected == 0:
+            outcome = ConfirmOutcome(accepted=True)
+        else:
+            outcome = ConfirmOutcome(
+                accepted=False,
+                reason=state.reason_buffer.text.strip(),
+            )
+        req.future.set_result(outcome)
+
+    @kb.add("escape", filter=is_confirming, eager=True)
+    def _confirm_cancel(event: KeyPressEvent) -> None:
+        _ = event
+        req = state.confirm
+        if req is None or req.future.done():
+            return
+        # Esc = quick deny without reason, regardless of what's typed.
+        req.future.set_result(ConfirmOutcome(accepted=False))
+
+    # ── Normal input mode (only when no confirm dialog is up) ──
+    @kb.add("enter", filter=is_idle)
+    def _submit(event: KeyPressEvent) -> None:
+        _ = event
+        text = state.input_buffer.text
+        if not text.strip():
+            return
+        state.input_buffer.reset()
+        _spawn(_dispatch_input(state, text))
+
+    @kb.add("escape", "enter", filter=is_idle)
+    def _newline(event: KeyPressEvent) -> None:
+        _ = event
+        state.input_buffer.insert_text("\n")
+
+    @kb.add("escape", filter=is_idle)
+    def _escape(event: KeyPressEvent) -> None:
+        # Plain Esc waits ~100ms (default escape timeout) for sequences like
+        # `escape, enter`, then fires here.  Streaming → stop the turn.
+        # Idle with text in the input → clear the input.  Idle empty → no-op.
+        _ = event
+        if state.is_streaming():
+            _spawn(_handle_stop(state))
+        elif state.input_buffer.text:
+            state.input_buffer.reset()
+
+    @kb.add("c-c")
+    def _ctrl_c(event: KeyPressEvent) -> None:
+        # Don't let Ctrl+C kill the CLI by accident — it's the muscle
+        # memory for "stop the LLM" but exiting the whole REPL is a much
+        # bigger blast radius.  Stop the run if streaming; otherwise hint.
+        _ = event
+        if state.is_streaming():
+            _spawn(_handle_stop(state))
+        else:
+            state.output.print(
+                Text(
+                    "(Esc to stop a turn · Ctrl+D to quit)",
+                    style="dim yellow",
+                ),
+            )
+
+    @kb.add("c-d")
+    def _ctrl_d(event: KeyPressEvent) -> None:
+        event.app.exit()
+
+    @kb.add("pageup")
+    def _page_up(event: KeyPressEvent) -> None:
+        _ = event
+        state.scroll_up(_PAGE_STEP)
+
+    @kb.add("pagedown")
+    def _page_down(event: KeyPressEvent) -> None:
+        _ = event
+        state.scroll_down(_PAGE_STEP)
+
+    @kb.add("end")
+    def _end(event: KeyPressEvent) -> None:
+        _ = event
+        # Re-engage auto-follow — cursor pin snaps to latest line.
+        state.follow = True
+
+    @kb.add("home")
+    def _home(event: KeyPressEvent) -> None:
+        _ = event
+        state.follow = False
+        state.cursor_line = 0
+
+    _ = output_window  # kept in scope for the layout; no manual scroll needed
+    return kb
+
+
+# ---------------------------------------------------------------------------
+# Toolbar
+# ---------------------------------------------------------------------------
+
+
+_NAME_DISPLAY_MAX = 50
+
+
+def _confirm_text(state: _ReplState) -> HTML:
+    """Render the confirmation widget header — preview + Accept/Deny buttons.
+
+    The reason input lives in its own ``Window`` (a Buffer) below this
+    block so the user can type and edit a comment freely.
+    """
+    req = state.confirm
+    if req is None:
+        return HTML("")
+    safe = req.body.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    accept_class = "confirm.button.selected" if req.selected == 0 else "confirm.button"
+    deny_class = "confirm.button.selected" if req.selected == 1 else "confirm.button"
+    return HTML(
+        f"<confirm.body>$ {safe}</confirm.body>\n"
+        f"\n"
+        f"  <{accept_class}> Accept </{accept_class}>"
+        f"   "
+        f"<{deny_class}> Deny </{deny_class}>"
+        f"   <i>tab to switch · enter to confirm · esc to cancel · "
+        f"type a reason below to send it with deny</i>",
+    )
+
+
+def _toolbar_text(state: _ReplState) -> HTML:
+    """Compose the bottom-toolbar HTML (re-evaluated on every redraw)."""
+    ctx = state.ctx
+    name = ctx.state.name
+    if name:
+        label = name if len(name) <= _NAME_DISPLAY_MAX else name[: _NAME_DISPLAY_MAX - 1] + "…"
+    else:
+        label = "conv " + ctx.state.conv_id.split("-", 1)[0]
+    streaming_class = "toolbar.streaming" if state.is_streaming() else "toolbar.idle"
+    streaming_label = "● streaming" if state.is_streaming() else "○ idle"
+    scroll_part = "" if state.follow else "  ·  <b>↑ scrolled (End to follow)</b>"
+    return HTML(
+        f" <b>{ctx.cfg.region}</b>  ·  "
+        f"<b>{label}</b>  ·  "
+        f"<{streaming_class}>{streaming_label}</{streaming_class}>"
+        f"{scroll_part}",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Input dispatch
+# ---------------------------------------------------------------------------
+
+
+async def _dispatch_input(state: _ReplState, text: str) -> None:
+    """Route a submitted line: slash command, queue, or new turn."""
+    line = text.strip()
+    if not line:
+        return
+
+    if line.startswith("/") or line == ":q":
+        try:
+            await _dispatch_command(state, line)
+        except Quit:
+            _exit_app(state)
+        return
+
+    if state.is_streaming():
+        await _queue_during_stream(state, line)
+        return
+
+    # Drain any prior task so its `finally` cleanup ran before we start a new one.
+    if state.turn_task is not None:
+        with contextlib.suppress(BaseException):
+            await state.turn_task
+
+    state.turn_task = asyncio.create_task(_run_turn(state, line))
+    # Force a final redraw once the task is fully done — the last
+    # ``output.invalidate()`` from inside the stream fires BEFORE the
+    # task is marked done, so without this nudge the toolbar would keep
+    # showing "● streaming" until the user typed something.
+    state.turn_task.add_done_callback(lambda _t: _safe_invalidate())
+
+
+def _safe_invalidate() -> None:
+    """Trigger an Application redraw, swallowing any "no app running" error."""
+    with contextlib.suppress(Exception):
+        get_app().invalidate()
+
+
+async def _dispatch_command(state: _ReplState, line: str) -> None:
+    """Look up the command spec and call its handler."""
+    head, _, args = line.partition(" ")
+    spec = state.ctx.app.commands.get(head) or GLOBAL_COMMANDS.get(head)
+    if spec is None:
+        state.output.print(Text(f"unknown command {head} — try /help", style="yellow"))
+        return
+    result = spec.handler(state.ctx, args.strip())
+    if inspect.isawaitable(result):
+        await result
+
+
+async def _queue_during_stream(state: _ReplState, content: str) -> None:
+    """Append a plain message to the backend FIFO queue."""
+    try:
+        queued = await state.ctx.app.queue_message(state.ctx, content)
+    except Exception as e:
+        state.output.print(Text(f"queue failed: {e}", style="red"))
+        return
+    if queued:
+        state.output.print(Text(f"[queued] {content}", style="dim cyan"))
+    else:
+        state.output.print(
+            Text(
+                "(no active turn to queue against — wait for the prompt or send /stop)",
+                style="yellow",
+            ),
+        )
+
+
+async def _handle_stop(state: _ReplState) -> None:
+    """``/stop`` invoked or Ctrl+C while streaming."""
+    try:
+        await state.ctx.app.cancel(state.ctx)
+    except Exception as e:
+        state.output.print(Text(f"stop failed: {e}", style="yellow"))
+        return
+    state.output.print(Text("stop signal sent", style="dim"))
+
+
+async def _run_turn(state: _ReplState, line: str) -> None:
+    """Run one user turn end-to-end, pushing every event through the renderer."""
+    ctx = state.ctx
+    ctx.state.turn += 1
+    new_message = [{"role": "user", "content": line}]
+    # Echo the user message into the buffer so the conversation reads cleanly.
+    state.output.print(Text(f"» {line}", style="bold cyan"))
+
+    renderer = ctx.app.make_renderer(state.output)
+    try:
+        async for event in ctx.app.send(ctx, new_message):
+            renderer.apply(event)
+    except TransportError as e:
+        state.output.print(Text(str(e), style="red"))
+        ctx.state.turn -= 1
+    except asyncio.CancelledError:
+        with contextlib.suppress(Exception):
+            await ctx.app.cancel(ctx)
+        state.output.print(Text("[cancelled]", style="dim"))
+        ctx.state.turn -= 1
+        raise
+    finally:
+        renderer.close()
+
+
+# ---------------------------------------------------------------------------
+# Banner / exit
+# ---------------------------------------------------------------------------
+
+
+def _print_banner(state: _ReplState) -> None:
+    """Print the startup banner into the output buffer."""
+    cfg = state.ctx.cfg
+    state.output.print(Text(f"delos  {cfg.region} · {cfg.api_url}", style="dim"))
+    state.output.print(Text(f"conversation {state.ctx.state.conv_id}", style="dim"))
+    state.output.print(
+        Text("/help for commands — ctrl-c stop · ctrl-d quit", style="dim"),
+    )
+
+
+def _exit_app(state: _ReplState) -> None:
+    """Trigger the Application to exit on the next event-loop tick."""
+    _ = state
+    with contextlib.suppress(Exception):
+        get_app().exit()

delos_cli/ui/style.py

@@ -0,0 +1,24 @@
+"""Central prompt_toolkit style dict.
+
+Keep all terminal colors here so the REPL has one surface to tune when
+themes drift. CSS-class-style dotted names match the tokens emitted by
+``ui/lexer.py``.
+"""
+
+from __future__ import annotations
+
+from prompt_toolkit.styles import Style
+
+# Muted grays for secondary UI (placeholder, toolbar hints).
+# Explicit hex works across dark + light terminal themes.
+PLACEHOLDER_FG = "#5c5c5c"
+HINT_FG = "#6c6c6c"
+
+STYLE = Style.from_dict(
+    {
+        "repl.cmd": "ansicyan bold",
+        "repl.mention": "ansimagenta",
+        "repl.url": "ansiblue underline",
+        "repl.fence": "ansiyellow",
+    },
+)