rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/tui/sidebar.py

@@ -0,0 +1,182 @@
+"""Left sidebar — the session switcher, grouped by what each session is doing."""
+
+from __future__ import annotations
+
+from rich.markup import escape
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import Input, Label, ListItem, ListView, Static
+
+from rlmagent.tui.adapter import SessionEntry
+from rlmagent.tui.search_box import SearchBox
+
+#: Section order and headings. Each session sits under exactly one.
+SECTIONS: tuple[tuple[str, str], ...] = (
+    ("running", "Running"),
+    ("idle", "Idle"),
+    ("inactive", "Inactive"),
+)
+
+
+class SessionItem(ListItem):
+    """A session row. Identity is carried as an attribute, not a widget id."""
+
+    def __init__(self, label: str, session_id: str | None) -> None:
+        super().__init__(Label(label, markup=False))
+        self.session_id = session_id
+
+    @property
+    def is_new_action(self) -> bool:
+        """Whether this row creates a new session."""
+        return self.session_id is None
+
+
+class SectionHeading(ListItem):
+    """A section title inside the list; it cannot be chosen."""
+
+    def __init__(self, title: str, count: int) -> None:
+        super().__init__(Label(f"{title} ({count})", markup=False), classes="session-heading")
+        self.disabled = True
+
+
+class SessionList(ListView):
+    """Selectable list of sessions, grouped by status, newest first in each group."""
+
+    def __init__(self) -> None:
+        super().__init__(id="session-list")
+
+
+def matches(entry: SessionEntry, query: str) -> bool:
+    """Whether *entry* fits a search by title or id, case-insensitively."""
+    query = query.strip().lower()
+    return not query or query in entry.label.lower() or query in entry.session_id.lower()
+
+
+class Sidebar(Vertical):
+    """Fixed-width column holding the session switcher."""
+
+    class SwitchRequested(Message):
+        """User picked an existing session."""
+
+        def __init__(self, session_id: str) -> None:
+            super().__init__()
+            self.session_id = session_id
+
+    class NewRequested(Message):
+        """User asked for a fresh session."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        #: What the list was last built from, so an unchanged refresh only restyles.
+        self._shape: tuple = ()
+        self._entries: list[SessionEntry] = []
+        #: Active session id at the last repaint, so the cursor only moves
+        #: when the active session actually changes.
+        self._active: str | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Label("Sessions", id="sidebar-title")
+        yield SearchBox(placeholder="search sessions", id="session-search")
+        yield SessionList()
+        yield Static("", id="task-panel")
+
+    def show_tasks(self, items: list[dict]) -> None:
+        """The agent's task list under the sessions; hidden while it is empty."""
+        panel = self.query_one("#task-panel", Static)
+        lines = [("✓ " if item["done"] else "· ") + escape(item["text"]) for item in items]
+        panel.update("Tasks\n" + "\n".join(lines) if lines else "")
+        panel.display = bool(lines)
+
+    @property
+    def query_text(self) -> str:
+        return self.query_one("#session-search", Input).value
+
+    async def show(self, entries: list[SessionEntry]) -> None:
+        """Repaint the list, highlighting the active session."""
+        self._entries = list(entries)
+        await self._rebuild()
+
+    async def _rebuild(self) -> None:
+        listing = self.query_one(SessionList)
+        query = self.query_text
+        shown = [e for e in self._entries if matches(e, query)]
+        active = next((e.session_id for e in self._entries if e.is_active), None)
+        shape = (query, tuple((e.session_id, e.status) for e in shown))
+
+        if shape == self._shape:
+            self._restyle(listing, shown)
+            if active != self._active:
+                self._active = active
+                listing.index = self._active_index(listing)
+            return
+
+        # clear() removes children lazily, so await it or the appends race
+        # still-mounted widgets.
+        await listing.clear()
+        if not query:
+            await listing.append(SessionItem("+ New session", None))
+        for status, title in SECTIONS:
+            group = [e for e in shown if e.status == status]
+            if not group:
+                continue
+            await listing.append(SectionHeading(title, len(group)))
+            for entry in group:
+                await listing.append(SessionItem(self._label_for(entry), entry.session_id))
+        if query and not shown:
+            await listing.append(SectionHeading("No match", 0))
+        self._shape = shape
+        self._active = active
+        self._restyle(listing, shown)
+        listing.index = self._active_index(listing)
+
+    @staticmethod
+    def _label_for(entry: SessionEntry) -> str:
+        marker = "●" if entry.is_active else " "
+        return f"{marker} {entry.label}"
+
+    def _active_index(self, listing: SessionList) -> int:
+        for i, child in enumerate(listing.children):
+            if isinstance(child, SessionItem) and child.has_class("active-session"):
+                return i
+        return 0
+
+    def _restyle(self, listing: SessionList, entries: list[SessionEntry]) -> None:
+        """Refresh labels and the active marker without touching the cursor."""
+        by_id = {e.session_id: e for e in entries}
+        for child in listing.children:
+            if not isinstance(child, SessionItem) or child.is_new_action:
+                continue
+            entry = by_id.get(child.session_id or "")
+            if entry is None:
+                continue
+            child.set_class(entry.is_active, "active-session")
+            child.query(Label).first().update(self._label_for(entry))
+
+    async def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "session-search":
+            event.stop()
+            await self._rebuild()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Enter in the search box opens the first match."""
+        if event.input.id != "session-search":
+            return
+        event.stop()
+        first = next((e for e in self._entries if matches(e, event.value)), None)
+        if first is not None and not first.is_active:
+            self.post_message(self.SwitchRequested(first.session_id))
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Translate a row activation into an intent message."""
+        event.stop()
+        item = event.item
+        if not isinstance(item, SessionItem):
+            return
+        if item.is_new_action:
+            self.post_message(self.NewRequested())
+        else:
+            self.post_message(self.SwitchRequested(item.session_id or ""))
+
+
+__all__ = ["SECTIONS", "SectionHeading", "SessionItem", "SessionList", "Sidebar", "matches"]

rlmagent/tui/status.py

@@ -0,0 +1,49 @@
+"""Footer status bar: provider, model, session, context usage, git branch."""
+
+from __future__ import annotations
+
+from textual.widgets import Static
+
+from rlmagent.tui.adapter import StatusSnapshot
+
+
+class StatusBar(Static):
+    """One-line status readout pinned above the keybinding footer."""
+
+    def __init__(self) -> None:
+        super().__init__("", id="status-bar")
+        self._line = ""
+
+    @property
+    def line(self) -> str:
+        """The markup currently displayed."""
+        return self._line
+
+    def show(self, snapshot: StatusSnapshot, *, busy: bool = False, goal: str = "") -> None:
+        """Render *snapshot*."""
+        parts = [
+            snapshot.provider,
+            snapshot.model,
+            f"ctx {snapshot.context_percent}%",
+        ]
+        if snapshot.input_tokens or snapshot.output_tokens or snapshot.cost:
+            parts.append(f"{snapshot.input_tokens:,} in, {snapshot.cached_tokens:,} cached, "
+                         f"{snapshot.output_tokens:,} out, ${snapshot.cost:.4f}")
+        if snapshot.budget:
+            parts.append(snapshot.budget)
+        if snapshot.branch:
+            parts.append(f"⎇ {snapshot.branch}")
+        if snapshot.plan_mode:
+            parts.append("PLAN")
+        if goal:
+            short = goal if len(goal) <= 40 else goal[:39] + "…"
+            parts.append(f"◎ {short}")
+        if busy:
+            parts.append("■ generating — press Esc to stop")
+        self._line = "  ·  ".join(parts)
+        # Highlight the whole bar while a generation can be stopped.
+        self.set_class(busy, "busy")
+        self.update(self._line)
+
+
+__all__ = ["StatusBar"]

rlmagent/tui/steps.py

@@ -0,0 +1,283 @@
+"""Step cards: one block per agent step, built from the engine's run events."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from rich.markup import escape
+from rich.text import Text
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widgets import Collapsible, Static
+
+from rlmagent.tui.messages import highlighted_code
+
+SHOWN_OUTPUT_LINES = 6
+MAX_OUTPUT_CHARS = 20_000
+
+GENERATING, RUNNING, DONE, FAILED = "generating", "running", "done", "failed"
+
+
+@dataclass
+class Step:
+    """What a card shows for one step of one agent."""
+
+    agent: str
+    number: int
+    depth: int = 0
+    model: str = ""
+    state: str = GENERATING
+    code: str = ""
+    output: str = ""
+    tokens: int = 0
+    cost: float | None = None
+    started: float | None = None
+    ended: float | None = None
+
+    @property
+    def key(self) -> tuple[str, int]:
+        return (self.agent, self.number)
+
+    @property
+    def short(self) -> str:
+        return short_id(self.agent)
+
+    @property
+    def seconds(self) -> float | None:
+        if self.started is None or self.ended is None:
+            return None
+        return max(0.0, self.ended - self.started)
+
+
+def short_id(run_id: str) -> str:
+    """Six characters that tell agents apart; the root keeps its name."""
+    if run_id == "root" or len(run_id) <= 6:
+        return run_id
+    return run_id[-6:]
+
+
+@dataclass
+class Agent:
+    run_id: str
+    parent: str | None = None
+    depth: int = 0
+    model: str = ""
+    status: str = RUNNING
+    steps: list[int] = field(default_factory=list)
+    child_id: str | None = None
+
+
+def _moment(value) -> float | None:
+    """Seconds since the epoch, from a number or the ISO text the engine records."""
+    if value is None or isinstance(value, (int, float)):
+        return value
+    from datetime import datetime
+
+    try:
+        return datetime.fromisoformat(str(value)).timestamp()
+    except ValueError:
+        return None
+
+
+def _usage(value) -> tuple[int, float | None]:
+    if value is None:
+        return 0, None
+    if isinstance(value, dict):
+        tokens = value.get("total_tokens") or (
+            (value.get("prompt_tokens") or 0) + (value.get("completion_tokens") or 0))
+        return int(tokens or 0), value.get("cost")
+    tokens = getattr(value, "total_tokens", 0) or (
+        (getattr(value, "prompt_tokens", 0) or 0) + (getattr(value, "completion_tokens", 0) or 0))
+    return int(tokens or 0), getattr(value, "cost", None)
+
+
+class StepBook:
+    """Folds engine events into steps and agents. Holds no widgets."""
+
+    def __init__(self) -> None:
+        self.steps: dict[tuple[str, int], Step] = {}
+        self.agents: dict[str, Agent] = {}
+        self.order: list[tuple[str, int]] = []
+        self.child_names: dict[str, str] = {}
+        self.child_notes: dict[str, str] = {}
+
+    def clear(self) -> None:
+        self.steps.clear()
+        self.agents.clear()
+        self.order.clear()
+        self.child_names.clear()
+        self.child_notes.clear()
+
+    def feed(self, event: dict) -> Step | None:
+        """Apply one event; return the step it changed, if it changed one worth showing."""
+        kind = event.get("kind")
+        run_id = event.get("run_id") or "root"
+        child_id = event.get("child_id")
+        if kind == "run_started":
+            agent = self.agents.setdefault(run_id, Agent(run_id))
+            agent.parent = event.get("parent_run_id")
+            agent.depth = int(event.get("depth") or 0)
+            agent.model = str(event.get("model") or "")
+            agent.status = RUNNING
+            if child_id:
+                agent.child_id = child_id
+            return None
+        if kind == "child_bound" and child_id:
+            self.agents.setdefault(run_id, Agent(run_id)).child_id = child_id
+        if kind in ("child_bound", "child_named") and child_id and event.get("name"):
+            self.child_names[child_id] = event["name"]
+        if kind == "child_progress" and child_id:
+            self.child_notes[child_id] = " ".join(str(event.get("text", ""))[:500].splitlines())
+            return None
+        if kind == "child_status":
+            if run_id in self.agents:
+                self.agents[run_id].status = event["status"]
+            return None
+        if kind in ("run_completed", "run_failed"):
+            agent = self.agents.get(run_id)
+            if agent is not None:
+                agent.status = DONE if kind == "run_completed" else FAILED
+            return None
+        number = event.get("step")
+        if not isinstance(number, int) or number <= 0:
+            return None  # step 0 only loads the context
+        step = self._step(run_id, number)
+        if kind == "step_started":
+            step.state = GENERATING
+            step.started = _moment(event.get("started") or event.get("timestamp"))
+        elif kind == "code_generated":
+            step.code = str(event.get("code") or "")
+            step.state = RUNNING if step.code else FAILED
+        elif kind == "output_received":
+            step.output = str(event.get("output") or "")[-MAX_OUTPUT_CHARS:]
+            if event.get("error"):
+                step.state = FAILED
+        elif kind == "step_completed":
+            step.tokens, step.cost = _usage(event.get("usage"))
+            step.state = FAILED if event.get("error") else DONE
+            step.ended = _moment(event.get("ended") or event.get("timestamp"))
+        else:
+            return None
+        return step
+
+    def _step(self, run_id: str, number: int) -> Step:
+        key = (run_id, number)
+        step = self.steps.get(key)
+        if step is None:
+            agent = self.agents.get(run_id) or Agent(run_id)
+            self.agents.setdefault(run_id, agent)
+            step = Step(run_id, number, agent.depth, agent.model)
+            self.steps[key] = step
+            self.order.append(key)
+            agent.steps.append(number)
+        return step
+
+    def totals(self) -> dict:
+        steps = self.steps.values()
+        costs = [s.cost for s in steps if s.cost is not None]
+        return {
+            "steps": len(self.steps),
+            "tokens": sum(s.tokens for s in steps),
+            "cost": sum(costs) if costs else None,
+            "agents": len(self.agents),
+            "running": sum(1 for a in self.agents.values() if a.status == RUNNING),
+            "depth": max((a.depth for a in self.agents.values()), default=0),
+        }
+
+
+def header_text(step: Step) -> str:
+    """The card's title line, e.g. ``RLM d0 · root · step 1 · running``."""
+    return f"RLM d{step.depth} · {step.short} · step {step.number} · {step.state}"
+
+
+def footer_text(step: Step) -> str:
+    """Tokens, cost and time under a finished step."""
+    parts = [f"{step.tokens / 1000:.1f}k tokens" if step.tokens >= 1000 else f"{step.tokens} tokens"]
+    parts.append("cost unknown" if step.cost is None else f"${step.cost:.4f}")
+    if step.seconds is not None:
+        parts.append(f"{step.seconds:.1f}s")
+    return " · ".join(parts)
+
+
+def output_preview(output: str) -> tuple[str, int]:
+    """The first lines of output and how many were left out."""
+    lines = output.rstrip("\n").splitlines()
+    hidden = max(0, len(lines) - SHOWN_OUTPUT_LINES)
+    return "\n".join(lines[:SHOWN_OUTPUT_LINES]), hidden
+
+
+class StepCard(Vertical, can_focus=True):
+    """One step on screen: title, code, output preview, usage. Enter or a click opens it."""
+
+    BINDINGS = [("enter", "inspect", "Open step"), ("space", "toggle_details", "Toggle details")]
+
+    class Inspect(Message):
+        def __init__(self, step: Step) -> None:
+            super().__init__()
+            self.step = step
+
+    def action_inspect(self) -> None:
+        self.post_message(self.Inspect(self.step))
+
+    def action_toggle_details(self) -> None:
+        if self.step.state in (DONE, FAILED):
+            self._collapsed = not self._collapsed
+            self.refresh_step(self.step)
+
+    def on_click(self) -> None:
+        self.action_inspect()
+
+    def __init__(self, step: Step) -> None:
+        super().__init__(classes="step-card")
+        self.step = step
+        self._collapsed = False
+        self.styles.margin = (0, 0, 0, 2 * step.depth)
+        self._head = Static(classes="step-head")
+        self._code = Static(classes="step-code")
+        self._out = Static(classes="step-output")
+        self._more: Collapsible | None = None
+        self._foot = Static(classes="step-foot")
+
+    def compose(self):
+        yield self._head
+        yield self._code
+        yield self._out
+        yield self._foot
+
+    def on_mount(self) -> None:
+        self.refresh_step(self.step)
+
+    def refresh_step(self, step: Step) -> None:
+        self.step = step
+        self._head.update(Text(header_text(step)))
+        self.set_class(step.state == FAILED, "step-failed")
+        self.set_class(step.state in (GENERATING, RUNNING), "step-live")
+        self._code.update(highlighted_code(step.code) if step.code else "")
+        self._code.display = bool(step.code) and not self._collapsed
+        shown, hidden = output_preview(step.output)
+        self._out.update(escape(shown) if shown else "")
+        self._out.display = bool(shown) and not self._collapsed
+        if hidden and self._more is None:
+            self._more = Collapsible(Static(escape(step.output)), collapsed=True,
+                                     title=f"{hidden} more lines")
+            self.mount(self._more, before=self._foot)
+        elif self._more is not None:
+            self._more.title = f"{hidden} more lines"
+            self._more.query_one(Static).update(escape(step.output))
+        if self._more is not None:
+            self._more.display = bool(hidden) and not self._collapsed
+        done = step.state in (DONE, FAILED)
+        self._foot.update(footer_text(step) if done else "")
+        self._foot.display = done
+
+
+
+__all__ = [
+    "Step",
+    "StepBook",
+    "StepCard",
+    "footer_text",
+    "header_text",
+    "output_preview",
+    "short_id",
+]