rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/tui/transcript.py

@@ -0,0 +1,172 @@
+"""Main transcript area — scrollable conversation view."""
+
+from __future__ import annotations
+
+from textual.containers import VerticalScroll
+
+from rlmagent.tui.adapter import summarize_call
+from rlmagent.tui.messages import (
+    AssistantBlock,
+    CommandEcho,
+    ErrorBlock,
+    KindNotice,
+    NoticeBlock,
+    ShellBlock,
+    SideAnswer,
+    ToolCode,
+    ToolLine,
+    ToolOutput,
+    UserBlock,
+    should_collapse,
+)
+from rlmagent.tui.steps import StepCard
+
+
+class TranscriptView(VerticalScroll):
+    """Scrollable region holding the conversation."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._live: AssistantBlock | None = None
+        self._tools: dict[str, ToolLine] = {}
+        self._cards: dict[tuple[str, int], StepCard] = {}
+
+    # -- appending ----------------------------------------------------------
+
+    def add_user(self, text: str) -> None:
+        """Append a user turn."""
+        self.mount(UserBlock(text))
+        self._scroll()
+
+    def add_notice(self, text: str, *, error: bool = False) -> None:
+        """Append a notice (command output, error, cancellation).
+
+        A multi-line error shows its first line and folds the rest.
+        """
+        if error and "\n" in text.strip():
+            self.mount(ErrorBlock(text))
+        else:
+            self.mount(NoticeBlock(text, error=error))
+        self._scroll()
+
+    def add_command(self, text: str) -> None:
+        """Echo a slash command the user ran."""
+        self.mount(CommandEcho(text))
+        self._scroll()
+
+    def add_shell(self, command: str, output: str, exit_code: int | None = None) -> None:
+        """A shell result in its box, last lines only."""
+        self.mount(ShellBlock(command, output, exit_code))
+        self._scroll()
+
+    def add_side_answer(self, question: str, answer: str) -> None:
+        self.mount(SideAnswer(question, answer))
+        self._scroll()
+
+    def add_kind(self, kind: str, text: str) -> None:
+        """A labelled notice: compaction, refinement, skill, injected prompt."""
+        self.mount(KindNotice(kind, text))
+        self._scroll()
+
+    def start_tool(self, call_id: str, summary: str, code: str = "") -> None:
+        """Append a pending tool line, and the code it runs if any."""
+        line = ToolLine(call_id, summary)
+        self._tools[call_id] = line
+        self.mount(line)
+        if code:
+            self.mount(ToolCode(code))
+        self._scroll()
+
+    def finish_tool(self, call_id: str, output: str, *, is_error: bool) -> None:
+        """Resolve a pending tool line and attach large output."""
+        line = self._tools.pop(call_id, None)
+        if line is not None:
+            line.mark_done(is_error=is_error)
+        if output and should_collapse(output):
+            self.mount(ToolOutput(output))
+        self._scroll()
+
+    def show_step(self, step) -> StepCard:
+        """Add a card for a new step, or redraw the card it already has."""
+        card = self._cards.get(step.key)
+        if card is None:
+            card = StepCard(step)
+            self._cards[step.key] = card
+            if self._live is not None and not self._live.text.strip():
+                self.mount(card, before=self._live)
+            else:
+                self.mount(card)
+        else:
+            card.refresh_step(step)
+        self._scroll()
+        return card
+
+    def new_run(self) -> None:
+        """Later steps get new cards; the last run's cards stay as they are."""
+        self._cards.clear()
+
+    @property
+    def cards(self) -> list[StepCard]:
+        return list(self._cards.values())
+
+    # -- streaming ----------------------------------------------------------
+
+    def stream_delta(self, delta: str) -> None:
+        """Append streamed assistant text, opening a block on first delta."""
+        if self._live is None:
+            self._live = AssistantBlock()
+            self.mount(self._live)
+        self._live.append(delta)
+        self._scroll()
+
+    @property
+    def live_text(self) -> str:
+        """Text streamed into the open assistant block so far."""
+        return self._live.text if self._live is not None else ""
+
+    def finish_assistant(self, text: str) -> None:
+        """Close the live assistant block."""
+        if self._live is None:
+            if text:
+                self.mount(AssistantBlock(text))
+        else:
+            self._live.finalize(text)
+        self._live = None
+        self._scroll()
+
+    def reset(self) -> None:
+        """Clear the transcript (used when switching sessions)."""
+        self._live = None
+        self._tools.clear()
+        self._cards.clear()
+        self.remove_children()
+
+    def replay(self, entries) -> None:
+        """Repaint the view from a session's stored transcript."""
+        self.reset()
+        for entry in entries:
+            role = getattr(entry, "role", None)
+            if role == "user":
+                self.mount(UserBlock(entry.text))
+            elif role == "assistant":
+                for call in entry.tool_calls:
+                    line = ToolLine(call.id, summarize_call(call.name, call.arguments))
+                    line.mark_done(is_error=False)
+                    self.mount(line)
+                    code = call.arguments.get("code") if call.name == "python" else None
+                    if isinstance(code, str) and code:
+                        self.mount(ToolCode(code))
+                if entry.text:
+                    self.mount(AssistantBlock(entry.text))
+            elif role == "compactionSummary":
+                self.mount(KindNotice("compacted", entry.summary))
+        self._scroll()
+
+    # -- internal -----------------------------------------------------------
+
+    def _scroll(self) -> None:
+        """Keep the newest content in view."""
+        self.scroll_end(animate=False)
+
+
+__all__ = ["TranscriptView"]

rlmagent/tui/trust_dialog.py

@@ -0,0 +1,58 @@
+"""Startup question: may this folder's project inputs load?"""
+
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Label, ListItem, ListView
+
+from rlmagent.runtime import trust_choices, trust_question
+from rlmagent.trust import Choice, TrustRequest
+
+
+class _Option(ListItem):
+    def __init__(self, label: str, choice: Choice) -> None:
+        super().__init__(Label(label))
+        self.choice = choice
+
+
+class TrustDialog(App[Choice | None]):
+    """A single list of trust choices under a short explanation."""
+
+    BINDINGS = [("escape", "dismiss_question", "Exit")]
+    CSS = """
+    #trust-box { padding: 1 2; height: auto; }
+    #trust-text { margin-bottom: 1; }
+    #trust-options { height: auto; }
+    """
+
+    def __init__(self, request: TrustRequest) -> None:
+        super().__init__()
+        self._request = request
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="trust-box"):
+            yield Label(trust_question(self._request), id="trust-text")
+            yield ListView(
+                *(_Option(label, choice) for choice, label in trust_choices(self._request)),
+                id="trust-options",
+            )
+
+    def on_mount(self) -> None:
+        self.query_one(ListView).focus()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        item = event.item
+        if isinstance(item, _Option):
+            self.exit(item.choice)
+
+    def action_dismiss_question(self) -> None:
+        self.exit(None)
+
+
+async def ask_in_dialog(request: TrustRequest) -> Choice | None:
+    """Show the dialog and return the chosen answer, or ``None`` if dismissed."""
+    return await TrustDialog(request).run_async()
+
+
+__all__ = ["TrustDialog", "ask_in_dialog"]

rlmagent/tui/worker_attach.py

@@ -0,0 +1,141 @@
+"""Textual client for a worker that owns its conversation and execution."""
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.css.query import NoMatches
+from textual.widgets import Footer, Static
+from pydantic import TypeAdapter, ValidationError
+
+from rlmagent import worker
+from rlmagent.harness.contracts.transcript import TranscriptEntry
+from rlmagent.tui.adapter import summarize_call
+from rlmagent.tui.prompt import PromptInput
+from rlmagent.tui.transcript import TranscriptView
+
+_TRANSCRIPT = TypeAdapter(list[TranscriptEntry])
+
+
+class WorkerAttachApp(App[None]):
+    BINDINGS = [("ctrl+d", "quit", "Detach"), Binding("ctrl+c", "interrupt", "Interrupt", priority=True)]
+    CSS = """
+    TranscriptView { height: 1fr; }
+    PromptInput { height: 4; }
+    #worker-status { height: 1; }
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__()
+        self.worker_name = name
+        self.cursor = worker.WorkerLog(name, recent_only=True)
+        self.history_path = worker.folder(name) / "history.json"
+        self.history_modified = None
+        self.history_session = None
+        self.last_model_reply = None
+        #: Whether the worker was alive at the last poll, to report drops and returns.
+        self.was_alive: bool | None = None
+        #: The worker version already warned about, so the warning shows once.
+        self.warned_version: str | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="worker-status", markup=False)
+        yield TranscriptView()
+        yield PromptInput()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.poll_worker()
+        self.set_interval(0.3, self.poll_worker)
+
+    def poll_worker(self) -> None:
+        try:
+            transcript = self.query_one(TranscriptView)
+            status = self.query_one("#worker-status", Static)
+        except NoMatches:
+            return  # A queued poll can run during teardown.
+        try:
+            modified = self.history_path.stat().st_mtime_ns
+        except OSError:
+            modified = None
+        history = worker._read(self.history_path) if modified != self.history_modified else None
+        if history is not None:
+            self.history_modified = modified
+        if history and history.get("session") != self.history_session:
+            try:
+                entries = _TRANSCRIPT.validate_python(history["entries"])
+                offset = int(history["log_offset"])
+            except (ValidationError, KeyError, TypeError, ValueError):
+                self.history_session = history.get("session")
+                transcript.add_notice("Could not read the saved session history.", error=True)
+            else:
+                self.history_session = history["session"]
+                self.last_model_reply = None
+                self.cursor = worker.WorkerLog(self.worker_name, start_at=max(0, offset))
+                transcript.replay(entries)
+        for row in self.cursor.read():
+            kind, text = row["kind"], str(row["text"])
+            if kind == "prompt":
+                if transcript.live_text:
+                    transcript.finish_assistant(transcript.live_text)
+                self.last_model_reply = None
+                transcript.add_user(text)
+            elif kind == "model_delta":
+                transcript.stream_delta(text)
+            elif kind == "model_end":
+                partial = transcript.live_text
+                if partial and text.startswith(partial) and len(text) > len(partial):
+                    transcript.stream_delta(text[len(partial):])
+                transcript.finish_assistant(text)
+                self.last_model_reply = text
+            elif kind == "reply" and self.last_model_reply != text:
+                transcript.finish_assistant(text)
+            elif kind == "tool_start":
+                args = row.get("args", {})
+                code = str(args.get("code") or "") if text == "python" else ""
+                transcript.start_tool(row["call_id"], summarize_call(text, args), code)
+            elif kind == "tool_end":
+                transcript.finish_tool(row["call_id"], text, is_error=bool(row["is_error"]))
+            elif kind != "reply":
+                transcript.add_notice(text, error=kind == "error")
+        state = worker.state_of(self.worker_name)
+        self.note_connection(transcript, state)
+        label = state.get("state", "starting") if state["alive"] else "offline · prompts queue"
+        if state.get("state") == "passive" and not (worker.folder(self.worker_name) / "stop").exists():
+            label = "passive · prompts queue"
+        status.update(f"{self.worker_name} · {label}")
+
+    def note_connection(self, transcript, state: dict) -> None:
+        """Say when the worker drops or comes back, and when its version differs."""
+        alive = bool(state.get("alive"))
+        if self.was_alive is not None and alive != self.was_alive:
+            transcript.add_notice("worker is back; reattached" if alive
+                                  else "worker stopped; prompts will queue until it restarts")
+        self.was_alive = alive
+        theirs = state.get("version")
+        if alive and theirs and theirs != self.warned_version:
+            from rlmagent.cli.main import get_version
+
+            ours = get_version()
+            if theirs != ours:
+                transcript.add_notice(
+                    f"This worker runs rlm-agent {theirs}; this window is {ours}. "
+                    "Restart the worker to use the same version.", error=True)
+            self.warned_version = theirs
+
+    def on_prompt_input_submitted(self, event: PromptInput.Submitted) -> None:
+        if event.text in ("/detach", "/quit", "/exit", "/q"):
+            self.exit()
+            return
+        try:
+            result = worker.answer_input(self.worker_name, event.text)
+            if result is None:
+                worker.send(self.worker_name, event.text)
+            else:
+                self.query_one(TranscriptView).add_notice(result)
+        except OSError as error:
+            self.query_one(TranscriptView).add_notice(str(error), error=True)
+            return
+        self.query_one(PromptInput).clear_prompt()
+
+    def action_interrupt(self) -> None:
+        if not worker.interrupt(self.worker_name):
+            self.exit()

rlmagent/ui/__init__.py

@@ -0,0 +1 @@
+"""rlm-agent ui: terminal rendering (an event-stream consumer)."""

rlmagent/ui/render.py

@@ -0,0 +1,211 @@
+"""Event rendering layer — pure consumers of the harness event stream."""
+
+from __future__ import annotations
+
+import json
+import sys
+from enum import Enum
+from typing import Protocol, TextIO
+
+from rlmagent.harness.contracts.stream import (
+    AgentEvent,
+    MessageEndEvent,
+    MessageUpdateEvent,
+    RetryEvent,
+    ToolRunEndEvent,
+    ToolRunStartEvent,
+)
+from rlmagent.harness.contracts.transcript import ModelEntry, TextSegment
+
+# ---------------------------------------------------------------------------
+# Output mode enum
+# ---------------------------------------------------------------------------
+
+
+class OutputMode(Enum):
+    """Supported rendering modes."""
+
+    TEXT = "text"
+    JSON = "json"
+    TRANSCRIPT = "transcript"
+
+
+# ---------------------------------------------------------------------------
+# Renderer protocol
+# ---------------------------------------------------------------------------
+
+
+class EventRenderer(Protocol):
+    """Minimal contract every renderer implements."""
+
+    def render(self, event: AgentEvent) -> None: ...
+    def finish(self) -> bool: ...
+
+
+# ---------------------------------------------------------------------------
+# JSON renderer
+# ---------------------------------------------------------------------------
+
+
+class JsonRenderer:
+    """Serialises every event as a single JSON line."""
+
+    __slots__ = ("_out", "_ok")
+
+    def __init__(self, out: TextIO | None = None) -> None:
+        self._out = out if out is not None else sys.stdout
+        self._ok = True
+
+    def render(self, event: AgentEvent) -> None:
+        line = json.dumps(event.model_dump(by_alias=True), default=str)
+        self._out.write(line + "\n")
+        self._out.flush()
+        if isinstance(event, MessageEndEvent):
+            msg = event.message
+            if isinstance(msg, ModelEntry) and msg.stop_reason == "error":
+                self._ok = False
+
+    def finish(self) -> bool:
+        return self._ok
+
+
+# ---------------------------------------------------------------------------
+# Final-text renderer
+# ---------------------------------------------------------------------------
+
+
+class FinalTextRenderer:
+    """Prints only the final assistant response after the run completes."""
+
+    __slots__ = ("_out", "_last_text", "_errors")
+
+    def __init__(self, out: TextIO | None = None) -> None:
+        self._out = out if out is not None else sys.stdout
+        self._last_text: str | None = None
+        self._errors: list[str] = []
+
+    def render(self, event: AgentEvent) -> None:
+        if not isinstance(event, MessageEndEvent):
+            return
+        msg = event.message
+        if not isinstance(msg, ModelEntry):
+            return
+        text = msg.text.strip()
+        if text:
+            self._last_text = text
+        if msg.error_message:
+            self._errors.append(msg.error_message)
+
+    def finish(self) -> bool:
+        if self._errors:
+            for err in self._errors:
+                self._out.write(f"Error: {err}\n")
+            return False
+        if self._last_text:
+            self._out.write(self._last_text + "\n")
+        return True
+
+
+# ---------------------------------------------------------------------------
+# Transcript renderer
+# ---------------------------------------------------------------------------
+
+
+class TranscriptRenderer:
+    """Streams assistant text and tool activity as it happens."""
+
+    __slots__ = ("_out", "_ok", "_prev_len", "_needs_nl")
+
+    def __init__(self, out: TextIO | None = None) -> None:
+        self._out = out if out is not None else sys.stdout
+        self._ok = True
+        self._prev_len = 0
+        self._needs_nl = False
+
+    def render(self, event: AgentEvent) -> None:
+        if isinstance(event, MessageUpdateEvent):
+            self._on_update(event)
+        elif isinstance(event, MessageEndEvent):
+            self._on_end(event)
+        elif isinstance(event, RetryEvent):
+            self._ensure_newline()
+            self._out.write(f"[retry] {event.message}\n")
+            self._out.flush()
+        elif isinstance(event, ToolRunStartEvent):
+            self._ensure_newline()
+            self._out.write(f"[tool:{event.tool_name}] running...\n")
+        elif isinstance(event, ToolRunEndEvent):
+            status = "error" if event.is_error else "done"
+            result_preview = event.result.text[:120].replace("\n", " ")
+            self._out.write(f"[tool:{event.tool_name}] {status}")
+            if result_preview:
+                self._out.write(f" — {result_preview}")
+            self._out.write("\n")
+            self._out.flush()
+
+    def finish(self) -> bool:
+        self._ensure_newline()
+        return self._ok
+
+    # -- private ------------------------------------------------------------
+
+    def _on_update(self, event: MessageUpdateEvent) -> None:
+        msg = event.message
+        if not isinstance(msg, ModelEntry):
+            return
+        full = "".join(
+            block.text for block in msg.content if isinstance(block, TextSegment)
+        )
+        delta = full[self._prev_len:]
+        if delta:
+            self._out.write(delta)
+            self._out.flush()
+            self._prev_len = len(full)
+            self._needs_nl = not delta.endswith("\n")
+
+    def _on_end(self, event: MessageEndEvent) -> None:
+        msg = event.message
+        if not isinstance(msg, ModelEntry):
+            return
+        # Flush any remaining text not yet streamed
+        full = msg.text
+        delta = full[self._prev_len:]
+        if delta:
+            self._out.write(delta)
+            self._needs_nl = not delta.endswith("\n")
+        self._prev_len = 0
+        self._ensure_newline()
+        if msg.stop_reason == "error":
+            self._ok = False
+            if msg.error_message:
+                self._out.write(f"Error: {msg.error_message}\n")
+        self._out.flush()
+
+    def _ensure_newline(self) -> None:
+        if self._needs_nl:
+            self._out.write("\n")
+            self._needs_nl = False
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def make_renderer(mode: OutputMode, out: TextIO | None = None) -> EventRenderer:
+    """Create a renderer for the given output mode."""
+    if mode is OutputMode.JSON:
+        return JsonRenderer(out)
+    if mode is OutputMode.TRANSCRIPT:
+        return TranscriptRenderer(out)
+    return FinalTextRenderer(out)
+
+
+__all__ = [
+    "EventRenderer",
+    "FinalTextRenderer",
+    "JsonRenderer",
+    "OutputMode",
+    "TranscriptRenderer",
+    "make_renderer",
+]

rlmagent/undo.py

@@ -0,0 +1,109 @@
+"""/undo: a hidden git repository that snapshots the workspace before every turn.
+
+The repository lives under ~/.rlm-agent/shadow/, never inside the project, so the
+project's own git history is untouched. It honours the project's .gitignore and
+also skips dependency folders, files named like secrets (see EXCLUDES) and files
+over 5 MB, none of which come back on undo. Other files are copied there as they
+are, including any secret under an ordinary name. The last 50 turns can be undone
+after a restart, the last 5 with their variables. The session rolls back saved
+variables itself, on the backend engine, unless they are too large to copy.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import shutil
+import subprocess
+from pathlib import Path
+
+EXCLUDES = """.git/
+node_modules/
+.venv/
+venv/
+__pycache__/
+.rlm-agent/
+.logs/
+.env
+.env.*
+*.pem
+*.key
+id_rsa*
+*.p12
+"""
+MAX_FILE_BYTES = 5_000_000
+
+
+class Shadow:
+    def __init__(self, workspace: str | Path, home: Path) -> None:
+        self.workspace = Path(workspace).resolve()
+        key = hashlib.sha1(str(self.workspace).encode()).hexdigest()[:16]
+        self.git_dir = home / "shadow" / f"{key}.git"
+        self.reason = ""
+        self.available = shutil.which("git") is not None
+        if not self.available:
+            self.reason = "Undo needs git on PATH."
+        elif self.workspace.parent == self.workspace or self.workspace == Path.home().resolve():
+            # Snapshotting a whole drive or home folder would copy everything in it.
+            self.available = False
+            self.reason = (f"Undo is off in {self.workspace}: it is too broad to snapshot. "
+                           "Start rlm-agent inside a project folder.")
+        self.skipped: set[str] = set()
+
+    def _git(self, *args: str) -> str:
+        out = subprocess.run(
+            ["git", f"--git-dir={self.git_dir}", f"--work-tree={self.workspace}", *args],
+            stdin=subprocess.DEVNULL, capture_output=True, text=True,
+            # File names are UTF-8 whatever the console's codepage says.
+            encoding="utf-8", errors="replace",
+            cwd=self.workspace, timeout=120,
+        )
+        if out.returncode != 0:
+            raise RuntimeError((out.stderr or "").strip() or f"git {args[0]} failed")
+        return (out.stdout or "").strip()
+
+    def _init(self) -> None:
+        if (self.git_dir / "HEAD").exists():
+            return
+        self.git_dir.parent.mkdir(parents=True, exist_ok=True)
+        self._git("init", "-q")
+        self._git("config", "user.name", "rlm-agent")
+        self._git("config", "user.email", "rlm-agent@localhost")
+        self._git("config", "core.autocrlf", "false")
+        (self.git_dir / "info").mkdir(exist_ok=True)
+        (self.git_dir / "info" / "exclude").write_text(EXCLUDES, encoding="utf-8")
+
+    def _skip_large(self) -> None:
+        listed = self._git("ls-files", "--others", "--modified", "--exclude-standard", "-z")
+        for rel in filter(None, listed.split("\0")):
+            path = self.workspace / rel
+            if path.is_file() and path.stat().st_size > MAX_FILE_BYTES:
+                self.skipped.add(rel)
+                with open(self.git_dir / "info" / "exclude", "a", encoding="utf-8") as f:
+                    f.write(f"/{rel}\n")
+
+    def snapshot(self, label: str) -> str:
+        """Commit the workspace as it is now; returns the commit id."""
+        self._init()
+        self._skip_large()
+        self._git("add", "-A")
+        self._git("commit", "-q", "--allow-empty", "--no-verify", "-m", label[:200])
+        return self._git("rev-parse", "HEAD")
+
+    def diff(self, commit: str, stat: bool = False) -> str:
+        """What changed in the workspace since `commit`, as a unified diff or a summary."""
+        self.snapshot("before diff")
+        return self._git("diff", "--stat" if stat else "--no-color", commit, "HEAD")
+
+    def label(self, commit: str) -> str:
+        return self._git("log", "-1", "--format=%s", commit).removeprefix("before: ")
+
+    def restore(self, commit: str) -> list[str]:
+        """Put the workspace back to `commit` and check it; returns the paths that changed."""
+        self.snapshot("before undo")
+        changed = self._git("diff", "--name-only", commit, "HEAD").splitlines()
+        self._git("read-tree", "-u", "--reset", commit)
+        wrong = self._git("diff", "--name-only", commit)
+        if wrong:
+            raise RuntimeError("these files did not come back: " + ", ".join(wrong.splitlines()[:10]))
+        self._git("commit", "-q", "--allow-empty", "--no-verify", "-m", f"undo to {commit[:12]}")
+        return changed