rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/tui/messages.py

@@ -0,0 +1,215 @@
+"""Transcript block widgets: user turns, assistant turns, and tool lines."""
+
+from __future__ import annotations
+
+from rich.markdown import Markdown
+from rich.markup import escape
+from rich.syntax import Syntax
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Collapsible, Static
+
+_MAX_INLINE_OUTPUT = 400
+
+RLM_AGENT_MARK = "›"  # prompt marker for user turns
+ACCENT = "#c9a4ff"  # violet accent, shared by markup and rlm_agent.tcss
+
+
+def highlighted_code(code: str) -> Syntax:
+    """Python as the terminal shows it: coloured, wrapped, on the app's background."""
+    return Syntax(code, "python", theme="monokai", word_wrap=True, background_color="default")
+
+
+def render_message(text: str) -> Markdown:
+    """Message text as formatted Markdown; never read as console markup."""
+    return Markdown(text, code_theme="monokai")
+
+
+class UserBlock(Static):
+    """One user message."""
+
+    def __init__(self, text: str) -> None:
+        super().__init__(f"{RLM_AGENT_MARK} {escape(text)}", classes="user-block")
+        self._text = text
+
+    @property
+    def text(self) -> str:
+        """The message this block displays."""
+        return self._text
+
+
+class AssistantBlock(Static):
+    """One assistant message, appended to incrementally while streaming."""
+
+    def __init__(self, text: str = "") -> None:
+        super().__init__(render_message(text), classes="assistant-block")
+        self._buffer = text
+
+    @property
+    def text(self) -> str:
+        """Accumulated text so far."""
+        return self._buffer
+
+    def append(self, delta: str) -> None:
+        """Append streamed text and re-render."""
+        self._buffer += delta
+        self.update(render_message(self._buffer))
+
+    def finalize(self, text: str) -> None:
+        """Replace the buffer with the completed message."""
+        # Progress streamed before the answer (code, output) stays on screen above it.
+        if self._buffer.strip() and text not in self._buffer:
+            text = f"{self._buffer.rstrip()}\n\n{text}" if text else self._buffer
+        elif text in self._buffer:
+            text = self._buffer
+        self._buffer = text
+        self.update(render_message(text))
+
+
+class ToolLine(Static):
+    """A compact one-line record of a tool invocation."""
+
+    def __init__(self, call_id: str, summary: str) -> None:
+        super().__init__(f"· {escape(summary)}", classes="tool-line")
+        self.call_id = call_id
+        self._summary = summary
+
+    def mark_done(self, *, is_error: bool) -> None:
+        """Flip the pending marker to success or failure."""
+        if is_error:
+            self.update(f"✗ {escape(self._summary)}")
+            self.add_class("tool-error")
+        else:
+            self.update(f"✓ {escape(self._summary)}")
+
+
+class ToolCode(Static):
+    """The Python a tool call runs."""
+
+    def __init__(self, code: str) -> None:
+        super().__init__(highlighted_code(code), classes="tool-code")
+
+
+class ToolOutput(Vertical):
+    """Collapsible container for a tool's stdout when it is large."""
+
+    def __init__(self, output: str) -> None:
+        super().__init__(classes="tool-output")
+        self._output = output
+
+    def compose(self) -> ComposeResult:
+        lines = self._output.splitlines()
+        title = f"{len(lines)} lines of output"
+        with Collapsible(title=title, collapsed=True):
+            yield Static(escape(self._output))
+
+
+def should_collapse(output: str) -> bool:
+    """Whether *output* is large enough to warrant a collapsible block."""
+    return len(output) > _MAX_INLINE_OUTPUT or output.count("\n") > 6
+
+
+class NoticeBlock(Static):
+    """A non-conversational notice: command output, errors, cancellations."""
+
+    def __init__(self, text: str, *, error: bool = False) -> None:
+        super().__init__(escape(text), classes="notice-block")
+        if error:
+            self.add_class("tool-error")
+
+
+#: Lines a shell result keeps on screen; earlier ones are counted, not shown.
+SHELL_TAIL = 20
+
+
+class ErrorBlock(Vertical):
+    """An error: its first line always shown, the rest folded underneath."""
+
+    def __init__(self, text: str) -> None:
+        super().__init__(classes="error-block")
+        self._text = text.strip() or "error"
+
+    @property
+    def headline(self) -> str:
+        return self._text.splitlines()[0]
+
+    def compose(self) -> ComposeResult:
+        first, _, rest = self._text.partition("\n")
+        yield Static(f"✗ {escape(first)}", classes="tool-error")
+        if rest.strip():
+            with Collapsible(title=f"details ({len(rest.splitlines())} lines)", collapsed=True):
+                yield Static(escape(rest.strip()))
+
+
+class ShellBlock(Static):
+    """A shell command's result in a box, showing only its last lines."""
+
+    def __init__(self, command: str, output: str, exit_code: int | None = None) -> None:
+        lines = output.rstrip("\n").splitlines()
+        hidden = max(0, len(lines) - SHELL_TAIL)
+        body = "\n".join(lines[-SHELL_TAIL:]) or "(no output)"
+        if hidden:
+            body = f"… {hidden} earlier line{'s' if hidden != 1 else ''}\n{body}"
+        super().__init__(escape(body), classes="shell-block")
+        self.border_title = f"$ {command}"
+        self.border_subtitle = "" if exit_code is None else f"exit {exit_code}"
+        if exit_code not in (None, 0):
+            self.add_class("shell-failed")
+        self.hidden_lines = hidden
+
+
+class CommandEcho(Static):
+    """The slash command the user ran, with its name picked out."""
+
+    def __init__(self, text: str) -> None:
+        name, _, rest = text.strip().partition(" ")
+        markup = f"[{ACCENT}]{escape(name)}[/]" + (f" {escape(rest)}" if rest else "")
+        super().__init__(f"{RLM_AGENT_MARK} {markup}", classes="command-echo")
+
+
+class SideAnswer(Static):
+    """An answer to a /btw side question, set apart from the main thread."""
+
+    def __init__(self, question: str, answer: str) -> None:
+        super().__init__(classes="side-answer")
+        self.update(render_message(f"**btw** {question}\n\n{answer}"))
+
+
+class KindNotice(Static):
+    """A notice with a kind label: compaction, refinement, skill, injected."""
+
+    def __init__(self, kind: str, text: str) -> None:
+        super().__init__(f"[{ACCENT}]{escape(kind)}[/] {escape(text)}",
+                         classes=f"kind-notice kind-{kind.replace(' ', '-')}")
+
+
+class QueuedStrip(Static):
+    """Messages waiting for the current run to end, shown above the prompt."""
+
+    def __init__(self) -> None:
+        super().__init__("", id="queued-strip")
+        self.display = False
+
+    def show(self, queued: list[str]) -> None:
+        self.display = bool(queued)
+        if queued:
+            rows = [f"{i}. {escape(text.splitlines()[0][:120])}" for i, text in enumerate(queued, 1)]
+            self.update(f"queued ({len(queued)}) — sent when this run ends\n" + "\n".join(rows))
+
+
+__all__ = [
+    "AssistantBlock",
+    "CommandEcho",
+    "ErrorBlock",
+    "KindNotice",
+    "QueuedStrip",
+    "SHELL_TAIL",
+    "ShellBlock",
+    "SideAnswer",
+    "NoticeBlock",
+    "ToolCode",
+    "ToolLine",
+    "ToolOutput",
+    "UserBlock",
+    "should_collapse",
+]

rlmagent/tui/model_screen.py

@@ -0,0 +1,307 @@
+"""Modal picker for switching provider and model."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from rlmagent.tui.search_box import SearchBox
+from textual.widgets import Input, Label, ListItem, ListView
+
+from rlmagent.config.store import PROVIDERS, ProviderInfo, load_config, recent_models
+
+
+@dataclass(frozen=True, slots=True)
+class ModelChoice:
+    """The result of a completed picker run."""
+
+    provider: str
+    label: str
+    model: str
+    api_key: str | None
+    base_url: str | None = None
+
+
+class _Row(ListItem):
+    """A list row carrying an opaque value."""
+
+    def __init__(self, text: str, value: str) -> None:
+        super().__init__(Label(text))
+        self.value = value
+
+
+def _explain(error: Exception) -> str:
+    """A failed provider check, in words that say what to change."""
+    status = getattr(getattr(error, "response", None), "status_code", None)
+    if status in (401, 403):
+        return f"The provider rejected this key ({status}). Check it and try again."
+    if status == 404:
+        return "Nothing at that endpoint (404). Check the base URL with Ctrl+E."
+    if status:
+        return f"The provider answered {status}. Try again, or check the endpoint."
+    return f"Could not reach the provider ({type(error).__name__}). Check the endpoint."
+
+
+class ModelScreen(ModalScreen[ModelChoice | None]):
+    """Small centred dialog: pick a provider, a model, and a key if needed."""
+
+    BINDINGS = [
+        ("escape", "cancel", "Cancel"),
+        ("ctrl+f", "discover", "Fetch models"),
+        ("ctrl+t", "test", "Test credentials"),
+        ("ctrl+e", "endpoint", "Endpoint"),
+        ("ctrl+r", "reveal", "Show key"),
+        ("ctrl+d", "forget", "Remove recent"),
+    ]
+
+    def __init__(self, current_provider: str = "", current_model: str = "",
+                 start_provider: str = "", title: str = "Select provider") -> None:
+        super().__init__()
+        #: Open straight on this provider's page (``/login openai``).
+        self._start_provider = start_provider
+        self._title = title
+        self._current_provider = current_provider
+        self._fetched: list[str] = []
+        self._current_model = current_model
+        self._info: ProviderInfo | None = None
+        self._model: str = ""
+        self._input_mode = "key"
+        self._endpoint = None
+
+    # -- composition --------------------------------------------------------
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="model-dialog"):
+            yield Label("Select provider", id="model-title")
+            yield ListView(id="model-list")
+            yield SearchBox(placeholder="Type to filter models", id="model-filter")
+            yield Input(placeholder="API key", password=True, id="model-key")
+            yield Label("", id="model-hint")
+
+    def on_mount(self) -> None:
+        self.query_one("#model-key", Input).display = False
+        self.query_one("#model-filter", Input).display = False
+        self._show_providers()
+        if self._start_provider:
+            self._on_provider_chosen(self._start_provider)
+
+    # -- steps --------------------------------------------------------------
+
+    def _show_providers(self) -> None:
+        """Step 1 — list the supported providers."""
+        self.query_one("#model-title", Label).update(self._title)
+        listing = self.query_one("#model-list", ListView)
+        listing.clear()
+        for recent in recent_models():
+            listing.append(_Row(f"↺ {recent['model']} · {recent['provider']}",
+                                f"recent:{recent['provider']}|{recent['model']}"))
+        for info in PROVIDERS:
+            marker = "●" if info.key == self._current_provider else " "
+            listing.append(_Row(f"{marker} {info.label}", info.key))
+        listing.index = 0
+        listing.focus()
+
+    def _show_models(self, info: ProviderInfo) -> None:
+        """Step 2 — list that provider's models."""
+        self._info = info
+        self.query_one("#model-title", Label).update(f"{info.label} — select model")
+        listing = self.query_one("#model-list", ListView)
+        listing.clear()
+        from rlmagent.model.discovery import price_label
+
+        for name in info.models:
+            marker = "●" if name == self._current_model else " "
+            price = price_label(info.key, name)
+            listing.append(_Row(f"{marker} {name}" + (f"   {price}" if price else ""), name))
+        listing.append(_Row("Enter a model identifier…", "__custom__"))
+        listing.index = 0
+        listing.focus()
+        self.query_one("#model-hint", Label).update(
+            "Ctrl+F fetch models · Ctrl+T test credentials · Ctrl+E endpoint"
+        )
+
+    def _input(self, mode, title, placeholder, password=False):
+        self._input_mode = mode
+        self.query_one("#model-list", ListView).display = False
+        field = self.query_one("#model-key", Input)
+        field.password, field.placeholder, field.value = password, placeholder, ""
+        field.display = True
+        self.query_one("#model-title", Label).update(title)
+        field.focus()
+
+    async def _remote(self, show_models):
+        if self._info is None:
+            return
+        from rlmagent.model.discovery import discover_models, check_provider
+
+        hint = self.query_one("#model-hint", Label)
+        hint.update("Checking provider…")
+        try:
+            if not show_models:
+                hint.update(await check_provider(self._info.key, base_url=self._endpoint))
+                return
+            models = await discover_models(self._info.key, base_url=self._endpoint)
+        except Exception as error:
+            hint.update(_explain(error))
+            return
+        hint.update(f"Model endpoint accepted credentials; {len(models)} models returned.")
+        if show_models:
+            self._fetched = models
+            self._list_fetched("")
+            box = self.query_one("#model-filter", Input)
+            box.value, box.display = "", True
+            box.focus()
+
+    def _list_fetched(self, text: str) -> None:
+        listing = self.query_one("#model-list", ListView)
+        listing.clear()
+        from rlmagent.model.discovery import price_label
+
+        rows = [model for model in self._fetched if text.lower() in model.lower()]
+        provider = self._info.key if self._info is not None else ""
+        for model in rows:
+            price = price_label(provider, model)
+            listing.append(_Row(f"{model}   {price}" if price else model, model))
+        listing.append(_Row("Enter a model identifier…", "__custom__"))
+        listing.index = rows.index(self._current_model) if self._current_model in rows else 0
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "model-filter":
+            event.stop()
+            self._list_fetched(event.value)
+
+    def action_forget(self):
+        from rlmagent.config.store import forget_model
+
+        row = self.query_one("#model-list", ListView).highlighted_child
+        value = getattr(row, "value", "")
+        if self._info is None and value.startswith("recent:"):
+            forget_model(*value.removeprefix("recent:").split("|", 1))
+            self._show_providers()
+
+    def action_reveal(self):
+        field = self.query_one("#model-key", Input)
+        field.password = not field.password
+
+    def action_discover(self):
+        self.run_worker(self._remote(True), exclusive=True, group="provider-check")
+
+    def action_test(self):
+        self.run_worker(self._remote(False), exclusive=True, group="provider-check")
+
+    def action_endpoint(self):
+        if self._info is not None and self._info.key not in ("vertex", "codex", "copilot", "claude-subscription", "xai-subscription"):
+            self._input("endpoint", "Compatible API base URL", "https://host/v1")
+
+    def _show_key_prompt(self) -> None:
+        """Step 3 — ask for an API key, only when none is stored."""
+        assert self._info is not None
+        self._input_mode = "key"
+        self.query_one("#model-key", Input).password = True
+        self.query_one("#model-list", ListView).display = False
+        field = self.query_one("#model-key", Input)
+        field.display = True
+        field.focus()
+        self.query_one("#model-title", Label).update(f"{self._info.label} — API key")
+        self.query_one("#model-hint", Label).update("Enter to save · Esc to cancel")
+
+    def _stored_key(self, info: ProviderInfo) -> str | None:
+        """Key already saved in config or the environment, if any."""
+        import os
+
+        return os.environ.get(info.key_env) or load_config().api_keys.get(info.key)
+
+    # -- events -------------------------------------------------------------
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        event.stop()
+        row = event.item
+        if not isinstance(row, _Row):
+            return
+        if row.value.startswith("recent:"):
+            provider, _, model = row.value.removeprefix("recent:").partition("|")
+            self._info = next((p for p in PROVIDERS if p.key == provider), None)
+            if self._info is None:
+                self._show_providers()
+                return
+            self._on_model_chosen(model)
+        elif self._info is None:
+            self._on_provider_chosen(row.value)
+        else:
+            self._on_model_chosen(row.value)
+
+    def _on_provider_chosen(self, key: str) -> None:
+        info = next((p for p in PROVIDERS if p.key == key), None)
+        if info is None:
+            return
+        self._show_models(info)
+
+    def _on_model_chosen(self, model: str) -> None:
+        assert self._info is not None
+        if model == "__custom__":
+            self._input("model", "Model identifier", "provider/model")
+            return
+        self._model = model
+        if not self._info.needs_key or self._stored_key(self._info):
+            self._finish(None)
+            return
+        self._show_key_prompt()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        if event.input.id == "model-filter":
+            listing = self.query_one("#model-list", ListView)
+            event.input.display = False
+            listing.focus()
+            if listing.highlighted_child is not None:
+                self._on_model_chosen(listing.highlighted_child.value)
+            return
+        key = event.value.strip()
+        if self._input_mode in ("model", "endpoint"):
+            if not key:
+                return
+            if self._input_mode == "endpoint":
+                from urllib.parse import urlsplit
+
+                parsed = urlsplit(key)
+                if (
+                    parsed.scheme not in ("http", "https")
+                    or not parsed.netloc
+                    or parsed.username
+                    or parsed.password
+                ):
+                    self.query_one("#model-hint", Label).update(
+                        "Enter an HTTP(S) base URL without credentials."
+                    )
+                    return
+                self._endpoint = key.rstrip("/")
+            self.query_one("#model-key", Input).display = False
+            self.query_one("#model-list", ListView).display = True
+            self._show_models(self._info)
+            if self._input_mode == "model":
+                self._on_model_chosen(key)
+            return
+        if not key:
+            self.query_one("#model-hint", Label).update("API key must not be empty.")
+            return
+        self._finish(key)
+
+    def _finish(self, api_key: str | None) -> None:
+        assert self._info is not None
+        self.dismiss(
+            ModelChoice(
+                provider=self._info.key,
+                label=self._info.label,
+                model=self._model,
+                api_key=api_key,
+                base_url=self._endpoint,
+            )
+        )
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+__all__ = ["ModelChoice", "ModelScreen"]

rlmagent/tui/prompt.py

@@ -0,0 +1,98 @@
+"""Bottom multiline prompt input."""
+
+from __future__ import annotations
+
+from textual.message import Message
+from textual.widgets import TextArea
+
+
+class PromptInput(TextArea):
+    """Multiline input pinned below the transcript."""
+
+    class Submitted(Message):
+        """Posted when the user presses Enter on a non-empty prompt."""
+
+        def __init__(self, text: str) -> None:
+            super().__init__()
+            self.text = text
+
+    class TextChanged(Message):
+        """Posted whenever the composer contents change."""
+
+        def __init__(self, text: str) -> None:
+            super().__init__()
+            self.text = text
+
+    class Navigate(Message):
+        """Posted on up/down while a completion list is open."""
+
+        def __init__(self, delta: int) -> None:
+            super().__init__()
+            self.delta = delta
+
+    class Complete(Message):
+        """Posted on Tab to accept a completion."""
+
+    def __init__(self, **kwargs: object) -> None:
+        super().__init__(id="prompt-input", **kwargs)  # type: ignore[arg-type]
+
+    def on_mount(self) -> None:
+        """Take focus so the user can type immediately."""
+        self.focus()
+
+    BINDINGS = [
+        ("alt+b", "cursor_word_left", "Word left"),
+        ("alt+f", "cursor_word_right", "Word right"),
+        ("alt+d", "delete_word_right", "Delete word"),
+    ]
+
+    #: Keys that insert a literal newline instead of submitting.
+    #: ``shift+enter`` only reaches the app under the kitty keyboard
+    #: protocol; ``ctrl+j`` is the universal fallback.
+    NEWLINE_KEYS = frozenset({"shift+enter", "alt+enter", "ctrl+j"})
+
+    async def _on_key(self, event) -> None:
+        """Enter submits; newline keys break the line; Tab/arrows complete."""
+        key = event.key
+        if key in self.NEWLINE_KEYS:
+            event.prevent_default()
+            event.stop()
+            self.insert("\n")
+            self.post_message(self.TextChanged(self.text))
+            return
+        if key == "enter":
+            event.prevent_default()
+            event.stop()
+            self.submit()
+            return
+        if key == "tab" and self._completing:
+            event.prevent_default()
+            event.stop()
+            self.post_message(self.Complete())
+            return
+        if key in ("up", "down") and self._completing:
+            event.prevent_default()
+            event.stop()
+            self.post_message(self.Navigate(1 if key == "down" else -1))
+            return
+        await super()._on_key(event)
+        self.post_message(self.TextChanged(self.text))
+
+    @property
+    def _completing(self) -> bool:
+        """Whether the current text is a bare slash command."""
+        text = self.text
+        return text.startswith("/") and " " not in text
+
+    def submit(self) -> None:
+        """Emit the composer's contents if non-empty."""
+        text = self.text.strip()
+        if text:
+            self.post_message(self.Submitted(text))
+
+    def clear_prompt(self) -> None:
+        """Empty the composer after a submission."""
+        self.text = ""
+
+
+__all__ = ["PromptInput"]

rlmagent/tui/question_screen.py

@@ -0,0 +1,52 @@
+"""Modal for a question the agent asks the user."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, ListItem, ListView, SelectionList, Static
+
+
+class _Choice(ListItem):
+    def __init__(self, text: str) -> None:
+        super().__init__(Label(text, markup=False))
+        self.value = text
+
+
+class QuestionScreen(ModalScreen[str | list[str] | None]):
+    BINDINGS = [("escape", "skip", "Don't answer")]
+
+    def __init__(self, question: str, choices: list[str] | None, multiple: bool = False) -> None:
+        super().__init__()
+        self.question = question
+        self.choices = choices or []
+        self.multiple = multiple and bool(self.choices)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="approval-dialog"):
+            yield Label("The agent asks:", id="approval-title")
+            yield Static(self.question, id="approval-body", markup=False)
+            if self.multiple:
+                yield SelectionList(*[(c, c) for c in self.choices], id="approval-list")
+                yield Label("Space picks; Enter in the box below sends the picks or your text.")
+            elif self.choices:
+                yield ListView(*[_Choice(c) for c in self.choices], id="approval-list")
+            yield Input(placeholder="Type an answer, Esc to skip", id="question-answer")
+
+    def on_mount(self) -> None:
+        target = "#approval-list" if self.choices else "#question-answer"
+        self.query_one(target).focus()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        self.dismiss(event.item.value)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        typed = event.value.strip()
+        if self.multiple and not typed:
+            self.dismiss(list(self.query_one(SelectionList).selected) or None)
+        else:
+            self.dismiss(typed or None)
+
+    def action_skip(self) -> None:
+        self.dismiss(None)