sbxloop 0.2.0__py3-none-any.whl

sbxloop/cli/tui.py

@@ -0,0 +1,206 @@
+"""Rich rendering for runs: a chat-style live transcript and plain logging.
+
+Agent output is conversational (markdown, fenced code blocks), so the live
+view renders it as a chat thread — markdown panels with syntax-highlighted
+code — rather than truncated log lines. Host lifecycle events stay compact
+one-liners. ``format_event`` remains the dense single-line form used by
+``sbxloop logs``.
+"""
+
+from __future__ import annotations
+
+import datetime
+from collections import deque
+from typing import Any
+
+from rich.console import Console, Group, RenderableType
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from sbxloop.events import Event, HostEventTypes
+from sbxloop_worker.protocol import EventTypes
+
+TASK_STATE_STYLES = {
+    "pending": "dim",
+    "planning": "yellow",
+    "executing": "cyan",
+    "scrutinizing": "magenta",
+    "verifying": "blue",
+    "validating": "magenta",
+    "done": "green",
+    "failed": "red",
+    "skipped": "dim red",
+}
+
+# Compact one-liner lifecycle events (chat "system" messages).
+_LIFECYCLE_PREFIXES = ("run.", "task.", "phase.", "sandbox.", "gh.")
+
+# High-volume noise excluded from the transcript (still queryable via
+# `sbxloop logs`): streaming deltas, raw stdout passthrough, heartbeats.
+_TRANSCRIPT_SKIP = {
+    EventTypes.AGENT_MESSAGE_DELTA,
+    EventTypes.WORKER_STDOUT,
+    EventTypes.WORKER_HEARTBEAT,
+    EventTypes.WORKER_START,
+    EventTypes.WORKER_RESULT,
+    EventTypes.WORKER_END,
+    EventTypes.AGENT_USAGE,
+}
+
+AGENT_MESSAGE_CLIP = 4000
+
+
+def _stamp(event: Event) -> str:
+    return datetime.datetime.fromtimestamp(event.ts).strftime("%H:%M:%S")
+
+
+def render_event(event: Event) -> RenderableType | None:
+    """One transcript entry for an event, or None when it should be skipped."""
+    if event.type in _TRANSCRIPT_SKIP:
+        return None
+    data = event.data
+
+    if event.type == EventTypes.AGENT_MESSAGE:
+        content = str(data.get("content", "")).strip()
+        if not content:
+            return None
+        if len(content) > AGENT_MESSAGE_CLIP:
+            content = content[:AGENT_MESSAGE_CLIP] + "\n\n*…truncated — see `sbxloop logs`*"
+        return Panel(
+            Markdown(content),
+            title=f"[bold cyan]agent[/] [dim]{_stamp(event)}[/]",
+            title_align="left",
+            border_style="cyan",
+            padding=(0, 1),
+        )
+
+    if event.type == EventTypes.WORKER_ERROR:
+        message = str(data.get("message", "")) or str(data.get("error_type", "error"))
+        return Panel(
+            Text(message, style="red", overflow="fold"),
+            title=f"[bold red]error[/] [dim]{_stamp(event)}[/]",
+            title_align="left",
+            border_style="red",
+            padding=(0, 1),
+        )
+
+    if event.type == EventTypes.AGENT_TOOL_START:
+        tool = data.get("tool") or "tool"
+        return Text(f"{_stamp(event)}  ⚙ {tool}", style="yellow", overflow="fold")
+
+    if event.type == EventTypes.AGENT_TOOL_END:
+        return None  # start lines carry enough signal for the transcript
+
+    if event.type.startswith(_LIFECYCLE_PREFIXES):
+        line = format_event(event)
+        style = "dim"
+        if event.type == HostEventTypes.TASK_STATE:
+            style = TASK_STATE_STYLES.get(str(data.get("state", "")), "dim")
+        elif "fallback" in event.type or "missing" in event.type:
+            style = "yellow"
+        return Text(line, style=style, overflow="fold")
+
+    return None
+
+
+class Dashboard:
+    """Accumulates run state from the event stream and renders it."""
+
+    def __init__(self, max_entries: int = 6) -> None:
+        self.run_id: str | None = None
+        self.run_state: str = "starting"
+        self.outcome: str = ""
+        self.tasks: dict[str, dict[str, Any]] = {}
+        self.transcript: deque[RenderableType] = deque(maxlen=max_entries)
+
+    # -- event intake ------------------------------------------------------
+
+    def on_event(self, event: Event) -> None:
+        self.run_id = self.run_id or event.run_id
+        data = event.data
+        if event.type == HostEventTypes.RUN_START:
+            self.outcome = str(data.get("outcome", ""))
+        elif event.type in (HostEventTypes.RUN_STATE, HostEventTypes.RUN_END):
+            self.run_state = str(data.get("state", self.run_state))
+        elif event.type in (HostEventTypes.TASK_START, HostEventTypes.TASK_STATE):
+            task_id = str(data.get("task_id"))
+            entry = self.tasks.setdefault(task_id, {"title": "", "state": "pending"})
+            if data.get("title"):
+                entry["title"] = str(data["title"])
+            if data.get("state"):
+                entry["state"] = str(data["state"])
+            entry["revisions"] = data.get("revisions", entry.get("revisions", 0))
+            entry["replans"] = data.get("replans", entry.get("replans", 0))
+        elif event.type == HostEventTypes.TASK_END:
+            task_id = str(data.get("task_id"))
+            entry = self.tasks.setdefault(task_id, {"title": "", "state": "pending"})
+            if data.get("title"):
+                entry["title"] = str(data["title"])
+            entry["state"] = str(data.get("state", entry["state"]))
+        rendered = render_event(event)
+        if rendered is not None:
+            self.transcript.append(rendered)
+
+    # -- rendering ---------------------------------------------------------
+
+    def renderable(self) -> RenderableType:
+        header = Text.assemble(
+            ("run ", "bold"),
+            (self.run_id or "…", "bold cyan"),
+            ("  state: ", ""),
+            (self.run_state, "bold yellow"),
+        )
+        outcome = Text(self.outcome[:200], style="italic dim")
+
+        table = Table(expand=True, box=None, pad_edge=False)
+        table.add_column("task", style="bold", no_wrap=True)
+        table.add_column("title", ratio=2)
+        table.add_column("state", no_wrap=True)
+        table.add_column("rev/replan", no_wrap=True, justify="right")
+        for task_id, entry in self.tasks.items():
+            state = str(entry.get("state", "?"))
+            table.add_row(
+                task_id,
+                str(entry.get("title", "")),
+                Text(state, style=TASK_STATE_STYLES.get(state, "")),
+                f"{entry.get('revisions', 0)}/{entry.get('replans', 0)}",
+            )
+        if not self.tasks:
+            table.add_row("…", "decomposing outcome", Text("pending", style="dim"), "")
+
+        transcript: RenderableType
+        if self.transcript:
+            transcript = Group(*self.transcript)
+        else:
+            transcript = Text("waiting for events…", style="dim")
+        return Group(
+            Panel(Group(header, outcome), border_style="cyan"),
+            table,
+            transcript,
+        )
+
+
+def format_event(event: Event) -> str:
+    """Dense single-line form (used by `sbxloop logs` and lifecycle lines)."""
+    parts = [_stamp(event), event.type]
+    if event.data.get("task_id"):
+        parts.append(f"[{event.data['task_id']}]")
+    for key in ("state", "content", "tool", "op", "line", "message", "outcome"):
+        if event.data.get(key):
+            value = str(event.data[key]).replace("\n", " ")
+            parts.append(value[:160])
+            break
+    return " ".join(parts)
+
+
+def plain_printer(console: Console) -> Any:
+    """--no-tui mode: print the same chat-style entries sequentially."""
+
+    def print_event(event: Event) -> None:
+        rendered = render_event(event)
+        if rendered is not None:
+            console.print(rendered)
+
+    return print_event

sbxloop/config.py

@@ -0,0 +1,205 @@
+"""Configuration loading with layered precedence.
+
+Precedence (highest wins): ``SBXLOOP_*`` environment variables >
+``./sbxloop.toml`` > ``pyproject.toml [tool.sbxloop]`` > built-in defaults.
+
+Nested keys use ``__`` in environment variables, e.g.
+``SBXLOOP_BUDGETS__MAX_TASKS=5``. Values are parsed as TOML scalars where
+possible (so ``true``, ``42``, ``1.5`` get real types) and fall back to
+strings.
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+from sbxloop.errors import ConfigError
+
+ENV_PREFIX = "SBXLOOP_"
+
+# SBXLOOP_-prefixed variables consumed by the *worker process* rather than
+# host configuration; the env config layer must not treat them as settings.
+RESERVED_ENV_KEYS = frozenset({"worker_backend", "echo_script"})
+
+WorkerTransport = Literal["stream", "poll"]
+SecretStrategy = Literal["proxy", "plain-env"]
+
+
+class _ConfigModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class SandboxConfig(_ConfigModel):
+    template: str | None = None
+    workspace: Path | None = None
+    extra_allow_domains: list[str] = Field(default_factory=list)
+
+
+class GithubConfig(_ConfigModel):
+    report_repo: str | None = None
+
+
+class Budgets(_ConfigModel):
+    max_revisions_per_task: int = 2
+    max_replans_per_task: int = 1
+    max_tasks: int = 20
+    max_wall_clock_s: float = 7200.0
+    per_job_timeout_s: float = 900.0
+
+
+class Config(_ConfigModel):
+    model: str = "auto"
+    # sbx --app-name. Empty (the default) shares the user's normal sbx
+    # application state, so their `sbx login` and `sbx policy init balanced`
+    # apply directly. Setting a name isolates sbxloop state, but the isolated
+    # app-state needs its own `sbx --app-name <name> login` and policy init.
+    app_name: str = ""
+    state_dir: Path = Path(".sbxloop")
+    keep_sandboxes: bool = False
+    worker_transport: WorkerTransport = "stream"
+    secret_strategy: SecretStrategy = "proxy"
+    # Advanced: in-sandbox interpreter for the worker, and whether to run the
+    # install flow. Overridden in tests/e2e via SBXLOOP_WORKER_PYTHON /
+    # SBXLOOP_INSTALL_WORKERS.
+    worker_python: str = "/home/agent/.sbxloop/venv/bin/python"
+    install_workers: bool = True
+    sandbox: SandboxConfig = Field(default_factory=SandboxConfig)
+    github: GithubConfig = Field(default_factory=GithubConfig)
+    budgets: Budgets = Field(default_factory=Budgets)
+
+
+def _read_toml(path: Path) -> dict[str, Any]:
+    try:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except tomllib.TOMLDecodeError as exc:
+        raise ConfigError(f"invalid TOML in {path}: {exc}") from exc
+
+
+def _pyproject_layer(cwd: Path) -> dict[str, Any]:
+    path = cwd / "pyproject.toml"
+    if not path.is_file():
+        return {}
+    data = _read_toml(path)
+    tool = data.get("tool", {})
+    if not isinstance(tool, dict):
+        return {}
+    section = tool.get("sbxloop", {})
+    return section if isinstance(section, dict) else {}
+
+
+def _sbxloop_toml_layer(cwd: Path) -> dict[str, Any]:
+    path = cwd / "sbxloop.toml"
+    if not path.is_file():
+        return {}
+    return _read_toml(path)
+
+
+def _parse_env_value(raw: str) -> Any:
+    """Parse an env var as a TOML scalar; fall back to the raw string."""
+    try:
+        return tomllib.loads(f"v = {raw}")["v"]
+    except tomllib.TOMLDecodeError:
+        return raw
+
+
+def _env_layer(env: Mapping[str, str]) -> dict[str, Any]:
+    layer: dict[str, Any] = {}
+    for key, raw in env.items():
+        if not key.startswith(ENV_PREFIX):
+            continue
+        path = key[len(ENV_PREFIX) :].lower().split("__")
+        if not all(path) or path[0] in RESERVED_ENV_KEYS:
+            continue
+        node = layer
+        for part in path[:-1]:
+            node = node.setdefault(part, {})
+            if not isinstance(node, dict):
+                raise ConfigError(f"conflicting env overrides at {key}")
+        node[path[-1]] = _parse_env_value(raw)
+    return layer
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    merged = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _deep_merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def _flatten(data: dict[str, Any], prefix: str = "") -> dict[str, Any]:
+    flat: dict[str, Any] = {}
+    for key, value in data.items():
+        dotted = f"{prefix}{key}"
+        if isinstance(value, dict):
+            flat.update(_flatten(value, f"{dotted}."))
+        else:
+            flat[dotted] = value
+    return flat
+
+
+def load_dotenv_file(cwd: Path | None = None) -> Path | None:
+    """Load ``<cwd>/.env`` into the process environment, if present.
+
+    Real environment variables always win (``override=False``), so a ``.env``
+    file is a convenience layer for the two PATs and ``SBXLOOP_*`` settings —
+    never a way to silently shadow explicit exports. Returns the loaded path,
+    or None when there is no file.
+    """
+    from dotenv import load_dotenv
+
+    path = (cwd or Path.cwd()) / ".env"
+    if not path.is_file():
+        return None
+    load_dotenv(path, override=False)
+    return path
+
+
+def load_config_with_sources(
+    cwd: Path | None = None,
+    env: Mapping[str, str] | None = None,
+) -> tuple[Config, dict[str, str]]:
+    """Load config and report, per dotted key, which layer supplied it."""
+    cwd = cwd or Path.cwd()
+    if env is None:
+        # Only consult .env when reading the real environment; explicit env
+        # mappings (tests, embedders) stay hermetic.
+        load_dotenv_file(cwd)
+    env = os.environ if env is None else env
+
+    layers: list[tuple[str, dict[str, Any]]] = [
+        ("pyproject.toml", _pyproject_layer(cwd)),
+        ("sbxloop.toml", _sbxloop_toml_layer(cwd)),
+        ("env", _env_layer(env)),
+    ]
+
+    merged: dict[str, Any] = {}
+    sources: dict[str, str] = {}
+    for name, layer in layers:
+        merged = _deep_merge(merged, layer)
+        for dotted in _flatten(layer):
+            sources[dotted] = name
+
+    try:
+        config = Config.model_validate(merged)
+    except ValidationError as exc:
+        raise ConfigError(f"invalid sbxloop configuration: {exc}") from exc
+
+    for dotted in _flatten(config.model_dump()):
+        sources.setdefault(dotted, "default")
+    return config, sources
+
+
+def load_config(cwd: Path | None = None, env: Mapping[str, str] | None = None) -> Config:
+    """Load the effective sbxloop configuration for ``cwd``."""
+    config, _ = load_config_with_sources(cwd=cwd, env=env)
+    return config

sbxloop/engine/__init__.py

@@ -0,0 +1,26 @@
+"""The sbxloop loop engine."""
+
+from sbxloop.engine.engine import LoopEngine, run_outcome
+from sbxloop.engine.model import (
+    PlanModel,
+    RunRecord,
+    RunResult,
+    TaskGraph,
+    TaskRecord,
+    TaskSpec,
+    Verdict,
+)
+from sbxloop.engine.store import StateStore
+
+__all__ = [
+    "LoopEngine",
+    "PlanModel",
+    "RunRecord",
+    "RunResult",
+    "StateStore",
+    "TaskGraph",
+    "TaskRecord",
+    "TaskSpec",
+    "Verdict",
+    "run_outcome",
+]