rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/tui/approval_screen.py

@@ -0,0 +1,57 @@
+"""Modal that asks before the sandbox writes a file or runs a command."""
+
+from __future__ import annotations
+
+from rich.syntax import Syntax
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Label, ListItem, ListView, Static
+
+from rlmagent.agents.approval import ALWAYS, AUTO, DENY, ONCE, Request
+
+
+class _Choice(ListItem):
+    def __init__(self, text: str, value: str) -> None:
+        super().__init__(Label(text))
+        self.value = value
+
+
+class ApprovalScreen(ModalScreen[str]):
+    BINDINGS = [("escape", "deny", "Deny"), ("n", "deny", "Deny"), ("y", "once", "Allow once"),
+                ("shift+tab", "auto", "Auto-accept")]
+
+    def __init__(self, request: Request) -> None:
+        super().__init__()
+        self.request = request
+
+    def compose(self) -> ComposeResult:
+        always = "this command" if self.request.kind == "run" else "this file"
+        with Vertical(id="approval-dialog"):
+            yield Label("The agent wants to:", id="approval-title")
+            text = self.request.describe()
+            body = Syntax(text, "diff", theme="monokai", word_wrap=True,
+                          background_color="default") if self.request.preview else text
+            yield Static(body, id="approval-body", markup=False)
+            yield ListView(
+                _Choice("Allow once", ONCE),
+                _Choice(f"Always allow {always} this session", ALWAYS),
+                _Choice("Allow, and auto-accept the rest of this session", AUTO),
+                _Choice("Deny", DENY),
+                id="approval-list",
+            )
+
+    def on_mount(self) -> None:
+        self.query_one("#approval-list", ListView).focus()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        self.dismiss(event.item.value)
+
+    def action_once(self) -> None:
+        self.dismiss(ONCE)
+
+    def action_auto(self) -> None:
+        self.dismiss(AUTO)
+
+    def action_deny(self) -> None:
+        self.dismiss(DENY)

rlmagent/tui/choice_screen.py

@@ -0,0 +1,47 @@
+"""A small modal list: pick one value with the arrows and Enter, Esc to leave."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Label, ListItem, ListView
+
+
+class _Option(ListItem):
+    def __init__(self, value: str, current: bool) -> None:
+        super().__init__(Label(("● " if current else "  ") + value, markup=False))
+        self.value = value
+
+
+class ChoiceScreen(ModalScreen[str | None]):
+    """Returns the chosen value, or ``None`` when dismissed."""
+
+    BINDINGS = [("escape", "leave", "Cancel")]
+
+    def __init__(self, title: str, options: list[str], current: str | None = None) -> None:
+        super().__init__()
+        self.title_text = title
+        self.options = list(options)
+        self.current = current
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="approval-dialog"):
+            yield Label(self.title_text, id="approval-title")
+            yield ListView(*[_Option(o, o == self.current) for o in self.options],
+                           id="choice-list")
+
+    def on_mount(self) -> None:
+        view = self.query_one("#choice-list", ListView)
+        if self.current in self.options:
+            view.index = self.options.index(self.current)
+        view.focus()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        self.dismiss(event.item.value)
+
+    def action_leave(self) -> None:
+        self.dismiss(None)
+
+
+__all__ = ["ChoiceScreen"]

rlmagent/tui/completions.py

@@ -0,0 +1,116 @@
+"""Slash-command autocomplete bar shown above the composer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from rlmagent.tui.messages import ACCENT
+
+_MAX_VISIBLE = 6
+
+
+@dataclass(frozen=True, slots=True)
+class Completion:
+    """One selectable slash command."""
+
+    name: str
+    description: str
+
+    @property
+    def insertion(self) -> str:
+        """Text that replaces the composer contents when chosen."""
+        return f"/{self.name} "
+
+
+def match_commands(
+    text: str, commands: tuple[tuple[str, str], ...],
+) -> list[Completion]:
+    """Return commands matching *text*, or ``[]`` when not completing."""
+    if not text.startswith("/") or " " in text:
+        return []
+    fragment = text[1:].lower()
+    matches = [
+        Completion(name, description)
+        for name, description in commands
+        if name.startswith(fragment)
+    ]
+    return matches[:_MAX_VISIBLE]
+
+
+class CompletionBar(Vertical):
+    """Dropdown of slash-command candidates."""
+
+    def __init__(self) -> None:
+        super().__init__(id="completion-bar")
+        self._items: list[Completion] = []
+        self._index = 0
+        self.display = False
+
+    # -- state --------------------------------------------------------------
+
+    @property
+    def items(self) -> list[Completion]:
+        """Currently offered completions."""
+        return self._items
+
+    @property
+    def active(self) -> bool:
+        """Whether the bar is showing anything."""
+        return bool(self._items)
+
+    @property
+    def selected(self) -> Completion | None:
+        """The highlighted completion, if any."""
+        if not self._items:
+            return None
+        return self._items[self._index % len(self._items)]
+
+    # -- updates ------------------------------------------------------------
+
+    def offer(self, items: list[Completion]) -> None:
+        """Replace the candidate list and repaint."""
+        self._items = items
+        self._index = 0
+        self.display = bool(items)
+        self._repaint()
+
+    def dismiss(self) -> None:
+        """Hide the bar."""
+        self.offer([])
+
+    def move(self, delta: int) -> None:
+        """Move the highlight, wrapping at both ends."""
+        if not self._items:
+            return
+        self._index = (self._index + delta) % len(self._items)
+        self._repaint()
+
+    # -- rendering ----------------------------------------------------------
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="completion-body")
+
+    def _repaint(self) -> None:
+        try:
+            body = self.query_one("#completion-body", Static)
+        except Exception:  # noqa: BLE001 - not mounted yet
+            return
+        if not self._items:
+            body.update("")
+            return
+        lines = []
+        for i, item in enumerate(self._items):
+            if i == self._index:
+                lines.append(
+                    f"[{ACCENT}]› /{item.name:<10} {item.description}[/{ACCENT}]"
+                )
+            else:
+                lines.append(f"  /{item.name:<10} {item.description}")
+        body.update("\n".join(lines))
+
+
+__all__ = ["Completion", "CompletionBar", "match_commands"]

rlmagent/tui/components.py

@@ -0,0 +1,25 @@
+"""Public widget surface for rlm-agent's TUI."""
+
+from rlmagent.tui.messages import (
+    AssistantBlock,
+    NoticeBlock,
+    ToolLine,
+    ToolOutput,
+    UserBlock,
+)
+from rlmagent.tui.prompt import PromptInput
+from rlmagent.tui.sidebar import Sidebar
+from rlmagent.tui.status import StatusBar
+from rlmagent.tui.transcript import TranscriptView
+
+__all__ = [
+    "AssistantBlock",
+    "NoticeBlock",
+    "PromptInput",
+    "Sidebar",
+    "StatusBar",
+    "ToolLine",
+    "ToolOutput",
+    "TranscriptView",
+    "UserBlock",
+]

rlmagent/tui/composer.py

@@ -0,0 +1,40 @@
+"""The composer row: prompt marker, input, and a model/effort readout."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Static
+
+from rlmagent.tui.messages import RLM_AGENT_MARK
+from rlmagent.tui.prompt import PromptInput
+
+
+class ModelBadge(Static):
+    """Right-hand readout showing the active model and effort level."""
+
+    def __init__(self) -> None:
+        super().__init__("", id="model-badge")
+        self._line = ""
+
+    @property
+    def line(self) -> str:
+        """The text currently displayed."""
+        return self._line
+
+    def show(self, model: str, effort: str, auto_accept: bool = False) -> None:
+        """Render *model* and *effort*, and say so when nothing asks before changing."""
+        self._line = ("auto-accept · " if auto_accept else "") + f"{model} · {effort}"
+        self.update(self._line)
+
+
+class Composer(Horizontal):
+    """Prompt marker + input + model badge on one row."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(RLM_AGENT_MARK, id="prompt-mark")
+        yield PromptInput()
+        yield ModelBadge()
+
+
+__all__ = ["Composer", "ModelBadge", "RLM_AGENT_MARK"]

rlmagent/tui/factory_view.py

@@ -0,0 +1,86 @@
+"""Read-only native view of a detached factory run."""
+
+from pathlib import Path
+
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.widgets import DataTable, Footer, Static
+
+from rlmagent.factory_graph import run_status
+
+
+class FactoryGraphApp(App[None]):
+    CSS = """
+    #run-state { height: auto; }
+    DataTable { height: 1fr; }
+    #stage-result { height: 8; overflow-y: auto; }
+    """
+    BINDINGS = [("q", "quit", "Close")]
+
+    def __init__(self, directory: Path) -> None:
+        super().__init__()
+        self.directory = directory
+        self.snapshot = None
+        self.details: list[str] = []
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="run-state", markup=False)
+        yield DataTable(cursor_type="row")
+        yield Static("", id="stage-result", markup=False)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.query_one(DataTable).add_columns("Stage", "Dependencies", "Guard", "Status")
+        self.refresh_run()
+        self.set_interval(0.5, self.refresh_run)
+
+    def refresh_run(self) -> None:
+        heading = self.query_one("#run-state", Static)
+        try:
+            state = run_status(self.directory)
+        except (OSError, ValueError, KeyError) as exc:
+            self.snapshot = None
+            heading.update(f"Could not read the run: {exc}")
+            return
+        if state == self.snapshot:
+            return
+        self.snapshot = state
+        reason = state.get("error") or state.get("stop_reason")
+        heading.update(f"Factory {state['id']} · {state['status']}"
+                       + (f" · {reason}" if reason else ""))
+        graph, records = state.get("graph", {}), state.get("stages", {})
+        table = self.query_one(DataTable)
+        selected = table.cursor_row
+        table.clear()
+        self.details.clear()
+        for name in dict.fromkeys([*graph, *records]):
+            node = graph.get(name, {})
+            record = records.get(name, {})
+            dependencies = ", ".join(node.get("after", ()))
+            guard = node.get("when", "")
+            if source := node.get("foreach"):
+                guard += f" · foreach {source}"
+            table.add_row(Text(name), Text(dependencies), Text(guard),
+                          Text(record.get("status", "waiting")))
+            self.details.append(self._output(record))
+            for index, item in enumerate(record.get("items", ()), 1):
+                table.add_row(Text(f"  ↳ item {index}"), "", "", Text(item["status"]))
+                self.details.append(self._output(item))
+        if self.details:
+            selected = min(selected, len(self.details) - 1)
+            table.move_cursor(row=selected)
+        self._show_result(selected)
+
+    @staticmethod
+    def _output(record: dict) -> str:
+        output = record.get("output")
+        if isinstance(output, list):
+            return "\n".join(f"{index}. {item}" for index, item in enumerate(output, 1))
+        return str(output or "")
+
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        self._show_result(event.cursor_row)
+
+    def _show_result(self, row: int) -> None:
+        self.query_one("#stage-result", Static).update(
+            self.details[row] if 0 <= row < len(self.details) else "")

rlmagent/tui/inspect.py

@@ -0,0 +1,193 @@
+"""Full views opened from the transcript: one step in full, and the agent tree."""
+
+from __future__ import annotations
+
+from rich.markup import escape
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Static, Tree
+
+from rlmagent.tui.messages import highlighted_code
+from rlmagent.tui.steps import Step, StepBook, footer_text, header_text, short_id
+
+
+class HelpScreen(ModalScreen[None]):
+    BINDINGS = [("escape", "dismiss", "Close"), ("f1", "dismiss", "Close")]
+
+    def __init__(self) -> None:
+        super().__init__(classes="inspect-screen")
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(classes="inspect-body"):
+            yield Static("Keyboard shortcuts", classes="step-head")
+            for binding in self.app.BINDINGS:
+                keys = self.app._keymap.get(binding.id, binding.key)
+                if keys:
+                    yield Static(f"{keys}  {binding.description}", markup=False)
+            for line in (
+                "Esc  Close this panel",
+                "Enter on a step  Inspect its code and output",
+                "Space on a finished step  Show or hide its details",
+                "Type / at the prompt to browse commands.",
+            ):
+                yield Static(line, markup=False)
+
+
+class StepScreen(ModalScreen[None]):
+    """Everything one step has: code, the whole output, usage and time."""
+
+    BINDINGS = [("escape", "dismiss", "Close"), ("q", "dismiss", "Close")]
+
+    def __init__(self, step: Step) -> None:
+        super().__init__(classes="inspect-screen")
+        self.step = step
+
+    def compose(self) -> ComposeResult:
+        step = self.step
+        with VerticalScroll(classes="inspect-body"):
+            yield Static(Text(header_text(step)), classes="step-head")
+            yield Static(Text(f"agent {step.agent} · model {step.model or 'unknown'}"),
+                         classes="step-foot")
+            yield Static(highlighted_code(step.code) if step.code else "(no code)",
+                         classes="step-code")
+            yield Static(escape(step.output) if step.output else "(no output)",
+                         classes="step-output")
+            yield Static(Text(footer_text(step)), classes="step-foot")
+            yield Static("Esc to close", classes="step-foot")
+
+
+def agent_label(book: StepBook, run_id: str) -> str:
+    agent = book.agents[run_id]
+    steps = [book.steps[(run_id, n)] for n in agent.steps]
+    tokens = sum(s.tokens for s in steps)
+    costs = [s.cost for s in steps if s.cost is not None]
+    spent = f" · ${sum(costs):.4f}" if costs else ""
+    name = book.child_names.get(agent.child_id) or short_id(agent.child_id or run_id)
+    note = book.child_notes.get(agent.child_id)
+    progress = f" · {note}" if note else ""
+    return (f"{name} · d{agent.depth} · {agent.status} · "
+            f"{len(steps)} steps · {tokens} tokens{spent}{progress}")
+
+
+class AgentTreeScreen(ModalScreen[None]):
+    """Who started whom, with each agent's state and spend."""
+
+    BINDINGS = [("escape", "dismiss", "Close"), ("q", "dismiss", "Close")]
+
+    def __init__(self, book: StepBook) -> None:
+        super().__init__(classes="inspect-screen")
+        self.book = book
+        self._agent_tree: Tree[str] = Tree("agents", classes="inspect-body")
+        self._agent_tree.show_root = False
+        self._agent_nodes = {}
+        self._empty_leaf = None
+
+    def compose(self) -> ComposeResult:
+        yield self._agent_tree
+        yield Static("Esc to close", classes="step-foot")
+
+    def on_mount(self) -> None:
+        self._agent_tree.root.expand()
+        self._refresh_tree()
+        self.set_interval(0.25, self._refresh_tree)
+
+    def _refresh_tree(self) -> None:
+        agents = self.book.agents
+        root = self._agent_tree.root
+        if self._agent_nodes.keys() - agents.keys():
+            root.remove_children()
+            self._agent_nodes.clear()
+        if not agents and self._empty_leaf is None:
+            self._empty_leaf = root.add_leaf("no agents have run yet")
+        elif agents and self._empty_leaf is not None:
+            self._empty_leaf.remove()
+            self._empty_leaf = None
+        for agent in sorted(agents.values(), key=lambda item: item.depth):
+            label = agent_label(self.book, agent.run_id)
+            node = self._agent_nodes.get(agent.run_id)
+            if node is None:
+                parent = self._agent_nodes.get(agent.parent, root)
+                self._agent_nodes[agent.run_id] = parent.add(Text(label), data=agent.run_id, expand=True)
+            elif node.label.plain != label:
+                node.set_label(Text(label))
+
+
+BAR_WIDTH = 30
+
+
+def timeline_rows(book: StepBook) -> list[str]:
+    """One line per step in start order: offset, duration, a bar to scale, and who ran it."""
+    steps = [s for s in book.steps.values() if s.started is not None]
+    if not steps:
+        return ["No timed steps yet."]
+    steps.sort(key=lambda s: s.started)
+    first = steps[0].started
+    last = max((s.ended or s.started) for s in steps)
+    span = max(last - first, 1e-6)
+    rows = []
+    for step in steps:
+        start = int((step.started - first) / span * BAR_WIDTH)
+        length = 1 if step.ended is None else max(1, round((step.ended - step.started) / span * BAR_WIDTH))
+        bar = " " * start + ("█" if step.ended is not None else "▒") * length
+        took = "running" if step.seconds is None else f"{step.seconds:6.1f}s"
+        rows.append(f"+{step.started - first:7.1f}s {took:>8} |{bar:<{BAR_WIDTH + 1}}| "
+                    f"d{step.depth} {step.short} step {step.number} {step.state}")
+    return rows
+
+
+class TimelineScreen(ModalScreen[None]):
+    """When each step ran and for how long, across every agent."""
+
+    BINDINGS = [("escape", "dismiss", "Close"), ("q", "dismiss", "Close")]
+
+    def __init__(self, book: StepBook) -> None:
+        super().__init__(classes="inspect-screen")
+        self.book = book
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(classes="inspect-body"):
+            yield Static(Text("\n".join(timeline_rows(self.book))))
+            yield Static("Esc to close", classes="step-foot")
+
+
+def worker_rows() -> list[str]:
+    """Every worker: whether it runs, its last heartbeat, and its waiting and scheduled jobs."""
+    import time
+
+    from rlmagent import worker
+
+    base = worker.root()
+    names = sorted(p.name for p in base.iterdir() if p.is_dir()) if base.is_dir() else []
+    if not names:
+        return ["No workers. Start one with: rlm-agent worker start NAME"]
+    rows = []
+    for name in names:
+        meta = worker.state_of(name)
+        state = meta.get("state", "?") if meta["alive"] else "not running"
+        beat = meta.get("beat")
+        ago = f"beat {time.time() - beat:.0f}s ago" if beat else "no heartbeat"
+        jobs = worker.jobs_of(name)
+        waiting = [j for j in jobs if j.get("status") == "waiting"]
+        rows.append(f"{name}: {state}, {ago}, {len(waiting)} waiting")
+        for job in waiting[:5]:
+            when = time.strftime("%m-%d %H:%M", time.localtime(job["due"]))
+            again = f", every {job['every']:.0f}s" if job.get("every") else ""
+            rows.append(f"    {job['id']} at {when}{again}: {job['text'][:80]}")
+    return rows
+
+
+class WorkersScreen(ModalScreen[None]):
+    """Background workers and their jobs."""
+
+    BINDINGS = [("escape", "dismiss", "Close"), ("q", "dismiss", "Close")]
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(classes="inspect-body"):
+            yield Static(Text("\n".join(worker_rows())))
+            yield Static("Esc to close", classes="step-foot")
+
+
+__all__ = ["AgentTreeScreen", "StepScreen", "TimelineScreen", "WorkersScreen", "agent_label",
+           "timeline_rows", "worker_rows"]