delos-cli 0.1.0__py3-none-any.whl

delos_cli/ui/chat_picker.py

@@ -0,0 +1,151 @@
+"""Startup picker: resume a recent chat, or start a new one.
+
+Shown once on REPL start if the user has recent chats. Flat list with
+time-bucket separators (Today / Yesterday / This week / Older) so the
+user can scan without paging. Keyboard-only: ↑↓ to move, ⏎ to pick,
+esc to quit.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING
+
+import questionary
+
+if TYPE_CHECKING:
+    from delos_cli.transport.chats import ChatListItem
+
+# Sentinel value questionary returns from the "new chat" choice — no chat to resume.
+NEW_CHAT = "__new__"
+
+# How wide the title column is padded to. Anything longer is truncated with …
+_TITLE_WIDTH = 44
+
+_PICKER_STYLE = questionary.Style(
+    [
+        ("qmark", "fg:ansicyan"),
+        ("question", "bold"),
+        ("pointer", "fg:ansicyan bold"),
+        ("highlighted", "fg:ansicyan bold"),
+        ("selected", "fg:ansicyan"),
+        ("answer", "fg:ansicyan"),
+        ("separator", "fg:#6c6c6c"),
+        ("instruction", "fg:#6c6c6c"),
+    ],
+)
+
+
+async def pick_conversation(chats: list[ChatListItem]) -> str | None:
+    """Ask the user to pick a chat to resume, or start fresh.
+
+    Returns the chosen ``chat_id`` string, or ``None`` for "new chat"
+    (also returned when the user presses esc / ctrl-c — callers should
+    treat ``None`` as cancellation-equivalent).
+
+    Async because the caller already runs inside an :func:`asyncio.run`
+    loop; using ``.ask_async()`` avoids trying to start a nested loop.
+    """
+    if not chats:
+        return None
+
+    now = datetime.now(UTC)
+    choices: list[questionary.Choice | questionary.Separator] = [
+        questionary.Choice(title="✱  Start a new chat", value=NEW_CHAT),
+    ]
+
+    for bucket_label, items in _group_by_bucket(chats, now):
+        if not items:
+            continue
+        choices.append(questionary.Separator(f"  {bucket_label}"))
+        choices.extend(_choice_for(chat, now) for chat in items)
+
+    answer = await questionary.select(
+        "Pick a conversation",
+        choices=choices,
+        use_shortcuts=False,
+        use_arrow_keys=True,
+        qmark="›",
+        instruction="(↑↓ to move · ⏎ to open · esc to quit)",
+        style=_PICKER_STYLE,
+    ).ask_async()
+
+    if answer is None or answer == NEW_CHAT:
+        return None
+    return str(answer)
+
+
+def _choice_for(chat: ChatListItem, now: datetime) -> questionary.Choice:
+    title = chat.name or "(untitled)"
+    display_title = _truncate(title, _TITLE_WIDTH).ljust(_TITLE_WIDTH)
+    age = _relative_age(now - chat.updated_at)
+    count = f"{chat.message_count} msg" + ("s" if chat.message_count != 1 else "")
+    # One visual line: title padded left-aligned, then metadata in the same row.
+    line = f"  {display_title}  {age}  ·  {count}"
+    return questionary.Choice(title=line, value=chat.id)
+
+
+def _group_by_bucket(
+    chats: list[ChatListItem],
+    now: datetime,
+) -> list[tuple[str, list[ChatListItem]]]:
+    today: list[ChatListItem] = []
+    yesterday: list[ChatListItem] = []
+    this_week: list[ChatListItem] = []
+    older: list[ChatListItem] = []
+
+    for c in chats:
+        age_days = (now - c.updated_at).days
+        if age_days <= 0:
+            today.append(c)
+        elif age_days == 1:
+            yesterday.append(c)
+        elif age_days < _DAYS_PER_WEEK:
+            this_week.append(c)
+        else:
+            older.append(c)
+
+    return [
+        ("Today", today),
+        ("Yesterday", yesterday),
+        ("This week", this_week),
+        ("Older", older),
+    ]
+
+
+_MINUTE_S = 60
+_HOUR_S = 60 * _MINUTE_S
+_DAY_S = 24 * _HOUR_S
+_DAYS_PER_WEEK = 7
+_WEEKS_CUTOFF = 5  # beyond ~a month, switch to "mo ago"
+_DAYS_PER_MONTH = 30
+_MONTHS_PER_YEAR = 12
+_DAYS_PER_YEAR = 365
+
+
+def _relative_age(delta: timedelta) -> str:
+    s = max(int(delta.total_seconds()), 0)
+    if s < _MINUTE_S:
+        return "just now"
+    if s < _HOUR_S:
+        return f"{s // _MINUTE_S}m ago"
+    if s < _DAY_S:
+        return f"{s // _HOUR_S}h ago"
+    d = s // _DAY_S
+    if d == 1:
+        return "yesterday"
+    if d < _DAYS_PER_WEEK:
+        return f"{d}d ago"
+    weeks = d // _DAYS_PER_WEEK
+    if weeks < _WEEKS_CUTOFF:
+        return f"{weeks}w ago"
+    months = d // _DAYS_PER_MONTH
+    if months < _MONTHS_PER_YEAR:
+        return f"{months}mo ago"
+    return f"{d // _DAYS_PER_YEAR}y ago"
+
+
+def _truncate(s: str, width: int) -> str:
+    if len(s) <= width:
+        return s
+    return s[: width - 1] + "…"

delos_cli/ui/completer.py

@@ -0,0 +1,68 @@
+"""Slash-command completer.
+
+At the start of a line: complete ``/<command>`` against the merged
+``global + app`` registry. After the command has been typed (space follows):
+delegate to the matched command's own ``complete`` callback, if it defines
+one.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.completion import Completer, Completion
+
+from delos_cli.commands import GLOBAL_COMMANDS
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from prompt_toolkit.completion import CompleteEvent
+    from prompt_toolkit.document import Document
+
+    from delos_cli.commands.base import CommandSpec
+    from delos_cli.ctx import Ctx
+
+
+class CommandCompleter(Completer):
+    """Reads the live command registry from ``ctx.app`` on every keystroke."""
+
+    def __init__(self, ctx: Ctx) -> None:
+        """Hold a reference to ``ctx`` so completions see live app state."""
+        self._ctx = ctx
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent,
+    ) -> Iterable[Completion]:
+        """Yield completions for the current buffer position."""
+        _ = complete_event
+        text = document.text_before_cursor
+        if "\n" in text or not text.startswith("/"):
+            return
+
+        if " " in text:
+            head, _, rest = text.partition(" ")
+            spec = self._all_commands().get(head)
+            if spec is None or spec.complete is None:
+                return
+            needle = rest.lower()
+            for suggestion in spec.complete(self._ctx, rest):
+                if needle in suggestion.lower():
+                    yield Completion(suggestion, start_position=-len(rest))
+            return
+
+        seen: set[str] = set()
+        for spec in self._all_commands().values():
+            if spec.name in seen or not spec.name.startswith(text):
+                continue
+            seen.add(spec.name)
+            yield Completion(
+                spec.name,
+                start_position=-len(text),
+                display_meta=spec.summary,
+            )
+
+    def _all_commands(self) -> dict[str, CommandSpec]:
+        merged: dict[str, CommandSpec] = dict(GLOBAL_COMMANDS)
+        merged.update(self._ctx.app.commands)
+        return merged

delos_cli/ui/lexer.py

@@ -0,0 +1,62 @@
+"""Input lexer: colors slash commands, @mentions, URLs, and code fences."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.lexers import Lexer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+    from prompt_toolkit.document import Document
+    from prompt_toolkit.formatted_text.base import StyleAndTextTuples
+
+_URL_RE = re.compile(r"https?://\S+")
+_MENTION_RE = re.compile(r"@[\w./-]+")
+
+
+class ChatLexer(Lexer):
+    """Tiny line-aware lexer driven by a few regexes."""
+
+    def lex_document(self, document: Document) -> Callable[[int], StyleAndTextTuples]:
+        """Return a per-line lexer function over ``document``'s current lines."""
+        _ = self
+        lines = document.lines
+
+        def get_line(lineno: int) -> StyleAndTextTuples:
+            line = lines[lineno]
+            if lineno == 0 and line.startswith("/"):
+                head, sep, rest = line.partition(" ")
+                out: StyleAndTextTuples = [("class:repl.cmd", head)]
+                if sep:
+                    out.append(("", sep + rest))
+                return out
+            if line.startswith("```"):
+                return [("class:repl.fence", line)]
+            return list(_tokenize_line(line))
+
+        return get_line
+
+
+def _tokenize_line(line: str) -> Iterable[tuple[str, str]]:
+    i = 0
+    for m in _URL_RE.finditer(line):
+        if m.start() > i:
+            yield from _tokenize_mentions(line[i : m.start()])
+        yield ("class:repl.url", m.group())
+        i = m.end()
+    if i < len(line):
+        yield from _tokenize_mentions(line[i:])
+
+
+def _tokenize_mentions(text: str) -> Iterable[tuple[str, str]]:
+    i = 0
+    for m in _MENTION_RE.finditer(text):
+        if m.start() > i:
+            yield ("", text[i : m.start()])
+        yield ("class:repl.mention", m.group())
+        i = m.end()
+    if i < len(text):
+        yield ("", text[i:])

delos_cli/ui/output.py

@@ -0,0 +1,180 @@
+"""Output buffer for the multi-area REPL layout.
+
+Bridges the v6 event renderer (which produces Rich renderables) to the
+prompt_toolkit Application (which renders ANSI text inside a Window).
+Owns:
+
+- ``history`` — a list of finalized blocks (tool calls, completed
+  assistant turns, banner lines, command output, …).  Pre-rendered as
+  ANSI text to keep redraws cheap.
+- ``live`` — an optional in-flight block that re-renders on every
+  ``text-delta`` during streaming.  When :meth:`commit_live` is called
+  (text-end), it joins history and the slot becomes free again.
+
+Each :meth:`update_live` / :meth:`append_block` / :meth:`print` call
+invalidates the attached :class:`Application` so its redraw loop picks
+up the change.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+from prompt_toolkit.formatted_text import ANSI
+from rich.console import Console
+
+if TYPE_CHECKING:
+    from prompt_toolkit.application import Application
+    from rich.console import RenderableType
+
+
+_DEFAULT_WIDTH = 100
+
+
+def _terminal_width() -> int:
+    """Best-effort terminal column count; falls back to 100."""
+    try:
+        return os.get_terminal_size().columns
+    except OSError:
+        return _DEFAULT_WIDTH
+
+
+class OutputBuffer:
+    """Append-only output buffer with a single in-flight live slot.
+
+    Stores rendered ANSI text so the prompt_toolkit redraw can simply
+    concatenate strings — no Rich re-render on every keystroke.
+    """
+
+    def __init__(self, width: int | None = None) -> None:
+        """Build an empty buffer.  ``width`` defaults to the terminal width."""
+        self._width = width or _terminal_width()
+        self._console = self._make_console(self._width)
+        self._history: list[str] = []
+        self._live: str | None = None
+        self._app: Application | None = None
+
+    @staticmethod
+    def _make_console(width: int) -> Console:
+        return Console(
+            width=width,
+            force_terminal=True,
+            color_system="truecolor",
+            soft_wrap=False,
+            highlight=False,
+        )
+
+    def attach(self, app: Application) -> None:
+        """Bind the buffer to a prompt_toolkit application for redraw triggers."""
+        self._app = app
+
+    def set_width(self, width: int) -> None:
+        """Update the rendering width (call on terminal resize)."""
+        if width == self._width:
+            return
+        self._width = width
+        self._console = self._make_console(width)
+
+    @property
+    def width(self) -> int:
+        """Current rendering width."""
+        return self._width
+
+    def append_block(self, renderable: RenderableType) -> None:
+        """Render a block and add it to history.
+
+        Any in-flight live block is committed first so blocks don't
+        interleave with streaming text.
+        """
+        self._commit_live()
+        self._history.append(self._render(renderable))
+        self._invalidate()
+
+    def update_live(self, renderable: RenderableType) -> None:
+        """Replace the live block — called per text-delta during streaming."""
+        self._live = self._render(renderable)
+        self._invalidate()
+
+    def commit_live(self) -> None:
+        """Finalize the current live block into history.  No-op if none."""
+        if self._live is None:
+            return
+        self._commit_live()
+        self._invalidate()
+
+    def discard_live(self) -> None:
+        """Drop the current live block without committing it to history.
+
+        Used for ephemeral indicators (e.g. the "thinking" spinner) that
+        shouldn't appear in scrollback once the agent emits real output.
+        """
+        if self._live is None:
+            return
+        self._live = None
+        self._invalidate()
+
+    def clear(self) -> None:
+        """Wipe history and any in-flight live block — resets the UI."""
+        self._history.clear()
+        self._live = None
+        self._invalidate()
+
+    def print(self, *renderables: Any, **kwargs: Any) -> None:
+        """Append an informational block to history.
+
+        Critically, this does **not** commit the in-flight live block —
+        external callers (slash command output, queue / stop confirmations,
+        echoed user messages, …) shouldn't disrupt streaming.  Their text
+        appears in history above the live slot; ``get_ansi`` still puts the
+        live last, so the user sees ``[old history] → [message] → [streaming]``.
+
+        Block-level transitions inside the conversation flow (tool calls,
+        finished assistant turns, errors) go through :meth:`append_block`,
+        which commits the live first.
+        """
+        if not renderables:
+            return
+        with self._console.capture() as cap:
+            self._console.print(*renderables, **kwargs)
+        self._history.append(cap.get())
+        self._invalidate()
+
+    def get_ansi(self) -> ANSI:
+        """Return the full output as one ANSI string for prompt_toolkit."""
+        parts = list(self._history)
+        if self._live is not None:
+            parts.append(self._live)
+        return ANSI("".join(parts))
+
+    @property
+    def line_count(self) -> int:
+        """Total source-line count across history + live.
+
+        Used by the REPL to position an invisible cursor at the bottom of
+        the output Window so prompt_toolkit auto-scrolls to follow the
+        latest content.  Lines are counted in source-line space; wrapping
+        is handled by the Window at render time.
+        """
+        text = "".join(self._history)
+        if self._live is not None:
+            text += self._live
+        if not text:
+            return 0
+        # Each "\n" terminates a line, plus one if the buffer doesn't end
+        # in a newline (Rich's renders almost always do, but be safe).
+        return text.count("\n") + (0 if text.endswith("\n") else 1)
+
+    def _commit_live(self) -> None:
+        if self._live is not None:
+            self._history.append(self._live)
+            self._live = None
+
+    def _render(self, renderable: RenderableType) -> str:
+        with self._console.capture() as cap:
+            self._console.print(renderable)
+        return cap.get()
+
+    def _invalidate(self) -> None:
+        if self._app is not None:
+            self._app.invalidate()