rockycode 0.1.0__py3-none-any.whl

rockycode/routines.py

@@ -0,0 +1,287 @@
+"""Routines — recurring, pre-approved autonomous work (self-evolve phase 2).
+
+A routine is a directory under the global $ROCKYCODE_HOME/routines/<name>/:
+
+  routine.toml   — the DECLARATION: what it does, when it's due, and the
+                   grant envelope the user approved once on the enable card
+                   (network, tools, isolation, budgets). Declarative and
+                   hand-editable; never mutated by runs.
+  SKILL.md       — the HOW: the playbook the runner follows.
+  state.json     — the RUNTIME state: last run, lease spend, run history.
+                   Machine-owned, separate on purpose so the declaration
+                   stays reviewable.
+
+Scheduling is catch-up-on-launch (no daemon): at launch, due routines show a
+card — click to run. `auto = true` is a LEASE, not a switch (locked design,
+2026-07-17): it expires after at most MAX_LEASE_DAYS or when the lease
+budget is spent, whichever first, then the routine falls back to
+click-to-run until the lease is renewed (one click, spend shown). Trust
+decays; it must be re-earned.
+
+Execution (slice 3) is exec-shaped: headless engine run where the approver
+IS the grant envelope — out-of-grant means a clean stop and a card at next
+launch, never a mid-run hang. Every run writes a trajectory with
+project_id + runner="routine", so the dream grades routines like chats.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+MAX_LEASE_DAYS = 7          # hard ceiling — a lease is never longer than this
+CADENCES = {"daily": 86_400.0, "weekly": 7 * 86_400.0}
+
+
+def routines_dir() -> Path:
+    base = os.environ.get("ROCKYCODE_HOME")
+    root = Path(base).expanduser() if base else Path.home() / ".rockycode"
+    return root / "routines"
+
+
+@dataclass
+class Routine:
+    name: str
+    description: str = ""
+    cadence: str = "daily"            # daily | weekly
+    prompt: str = ""                  # the task line handed to the runner
+    workdir: str = ""                 # where it runs
+    project_id: str = ""              # groups its trajectories with a project
+    output_dir: str = ""              # where results land (relative to workdir)
+    # -- the grant envelope (approved once, on the enable card) --------------
+    network: bool = False
+    tools: list[str] = field(default_factory=list)
+    isolation: bool = False           # worktree + branch delivery (mutating routines)
+    budget_run: float = 0.10          # per-run spend cap (session currency)
+    max_steps: int = 30               # per-run step cap (exec: never unbounded)
+    # -- the auto lease -------------------------------------------------------
+    auto: bool = False
+    lease_deadline: float = 0.0       # unix; 0 = no lease ever granted
+    budget_lease: float = 1.00        # cross-run cap while the lease is active
+    enabled: bool = True
+    path: Optional[Path] = None       # the routine's directory
+
+
+def _emit_toml(r: Routine) -> str:
+    def s(v: str) -> str:
+        return '"' + v.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+    lines = [
+        f"name = {s(r.name)}",
+        f"description = {s(r.description)}",
+        f"cadence = {s(r.cadence)}",
+        f"prompt = {s(r.prompt)}",
+        f"workdir = {s(r.workdir)}",
+        f"project_id = {s(r.project_id)}",
+        f"output_dir = {s(r.output_dir)}",
+        f"network = {'true' if r.network else 'false'}",
+        "tools = [" + ", ".join(s(t) for t in r.tools) + "]",
+        f"isolation = {'true' if r.isolation else 'false'}",
+        f"budget_run = {r.budget_run}",
+        f"max_steps = {r.max_steps}",
+        f"auto = {'true' if r.auto else 'false'}",
+        f"lease_deadline = {r.lease_deadline}",
+        f"budget_lease = {r.budget_lease}",
+        f"enabled = {'true' if r.enabled else 'false'}",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+@dataclass
+class RoutineState:
+    last_run: float = 0.0             # unix; 0 = never ran
+    lease_spent: float = 0.0          # spend since the CURRENT lease started
+    runs: list[dict] = field(default_factory=list)  # {sid, t, cost, status}
+
+
+class RoutineStore:
+    """Directory-per-routine under one global root. The toml is the contract,
+    state.json the odometer — same files-are-the-truth rule as everything."""
+
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self.root = root or routines_dir()
+
+    # -- declarations ---------------------------------------------------------
+
+    def list(self, project_id: Optional[str] = None) -> list[Routine]:
+        if not self.root.is_dir():
+            return []
+        out = []
+        for d in sorted(self.root.iterdir()):
+            r = self.load(d.name)
+            if r is None or not r.enabled:
+                continue
+            if project_id is None or r.project_id in ("", project_id):
+                out.append(r)
+        return out
+
+    def load(self, name: str) -> Optional[Routine]:
+        path = self.root / name / "routine.toml"
+        try:
+            data = tomllib.loads(path.read_text(encoding="utf-8"))
+        except (OSError, tomllib.TOMLDecodeError):
+            return None
+        known = {f for f in Routine.__dataclass_fields__ if f != "path"}
+        clean = {k: v for k, v in data.items() if k in known}
+        r = Routine(**{"name": name, **clean})
+        if r.cadence not in CADENCES:
+            r.cadence = "daily"
+        r.path = self.root / name
+        return r
+
+    def save(self, r: Routine, skill_md: str = "") -> Path:
+        d = self.root / r.name
+        d.mkdir(parents=True, exist_ok=True)
+        (d / "routine.toml").write_text(_emit_toml(r), encoding="utf-8")
+        if skill_md:
+            (d / "SKILL.md").write_text(skill_md, encoding="utf-8")
+        r.path = d
+        return d
+
+    # -- runtime state --------------------------------------------------------
+
+    def state(self, r: Routine) -> RoutineState:
+        try:
+            raw = json.loads((self.root / r.name / "state.json").read_text(encoding="utf-8"))
+            return RoutineState(
+                last_run=float(raw.get("last_run", 0.0)),
+                lease_spent=float(raw.get("lease_spent", 0.0)),
+                runs=list(raw.get("runs", [])),
+            )
+        except (OSError, ValueError, json.JSONDecodeError):
+            return RoutineState()
+
+    def _write_state(self, r: Routine, st: RoutineState) -> None:
+        (self.root / r.name).mkdir(parents=True, exist_ok=True)
+        (self.root / r.name / "state.json").write_text(json.dumps({
+            "last_run": st.last_run, "lease_spent": st.lease_spent,
+            "runs": st.runs[-50:],  # a bounded odometer, not a log store
+        }, indent=1), encoding="utf-8")
+
+    # -- due + lease ----------------------------------------------------------
+
+    def due(self, project_id: Optional[str] = None, now: Optional[float] = None) -> list[Routine]:
+        """Routines whose cadence has elapsed. Missed runs never stack — a
+        routine is due once, no matter how long the machine slept."""
+        now = time.time() if now is None else now
+        out = []
+        for r in self.list(project_id):
+            st = self.state(r)
+            if now - st.last_run >= CADENCES[r.cadence]:
+                out.append(r)
+        return out
+
+    def lease_active(self, r: Routine, now: Optional[float] = None) -> bool:
+        """The auto lease holds only while BOTH the deadline and the lease
+        budget hold — expiry of either falls back to click-to-run."""
+        now = time.time() if now is None else now
+        if not (r.auto and r.enabled):
+            return False
+        if now >= r.lease_deadline:
+            return False
+        return self.state(r).lease_spent < r.budget_lease
+
+    def grant_lease(self, r: Routine, days: float, budget: float) -> Routine:
+        """Start (or renew) the auto lease: at most MAX_LEASE_DAYS, always
+        with a budget. Renewal resets the lease odometer."""
+        days = max(0.0, min(float(days), MAX_LEASE_DAYS))
+        r.auto = True
+        r.lease_deadline = time.time() + days * 86_400.0
+        r.budget_lease = float(budget)
+        st = self.state(r)
+        st.lease_spent = 0.0
+        self.save(r)
+        self._write_state(r, st)
+        return r
+
+    def revoke_lease(self, r: Routine) -> Routine:
+        r.auto = False
+        r.lease_deadline = 0.0
+        self.save(r)
+        return r
+
+    def record_run(self, r: Routine, *, session_id: str, cost: float, status: str,
+                   now: Optional[float] = None) -> RoutineState:
+        """Odometer tick after a run: last_run moves, lease spend accumulates,
+        the run lands in the (bounded) history with its trajectory id — the
+        dream finds the full story there."""
+        now = time.time() if now is None else now
+        st = self.state(r)
+        st.last_run = now
+        st.lease_spent += max(0.0, float(cost))
+        st.runs.append({"sid": session_id, "t": now, "cost": cost, "status": status})
+        self._write_state(r, st)
+        return st
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# the runner — exec's headless machinery, driven by a routine's contract
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def _grant_tokens(tools: list[str]) -> frozenset[str]:
+    """routine.toml lists what the user granted; exec's HeadlessApprover
+    speaks grant tokens — bare tool names become "tool:<name>", anything
+    already token-shaped (a bash safety-pattern name, "tool:x") passes as-is."""
+    return frozenset(t if ":" in t or "-" in t else f"tool:{t}" for t in tools)
+
+
+async def run_routine(store: RoutineStore, r: Routine, *, model: str,
+                      client=None, registry=None, err=None) -> dict:
+    """Run one routine through exec (sandboxed ALWAYS — no host fallback for
+    unattended work; Docker down = the run fails loudly, the card says so).
+    Settles the odometer from the result envelope and writes last-run.md
+    beside the routine for the "ready" line. Returns a summary dict."""
+    from rockycode.engine.headless import run_exec
+    from rockycode.pricing import UsageLedger
+    from rockycode.session import get_project
+
+    workdir = Path(r.workdir).expanduser() if r.workdir else Path.cwd()
+    skill = ""
+    if r.path is not None:
+        try:
+            skill = (r.path / "SKILL.md").read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            skill = ""
+    out_note = (f"\nWrite your results into the directory '{r.output_dir}' "
+                f"(relative to the working directory)." if r.output_dir else "")
+    prompt = f"{r.prompt}{out_note}"
+    if skill.strip():
+        prompt += f"\n\nFollow this playbook:\n\n{skill.strip()}"
+
+    project = get_project(workdir)
+    lines: list[dict] = []
+    code = await run_exec(
+        prompt=prompt, model=model, workdir=workdir,
+        grants=_grant_tokens(r.tools), max_steps=r.max_steps,
+        originator=f"routine:{r.name}",
+        sandbox=True, network=r.network,
+        write=lines.append, client=client, registry=registry, err=err,
+        extra_meta={"runner": "routine", "routine": r.name,
+                    "project_id": r.project_id or project.id,
+                    "project_name": project.name},
+    )
+
+    meta = next((l for l in lines if l.get("type") == "meta"), {})
+    result = next((l for l in lines if l.get("type") == "result"), {})
+    status = {0: "done", 2: "blocked", 3: "budget"}.get(code, "error")
+    ledger = UsageLedger()
+    if result.get("usage"):
+        ledger.add(model, result["usage"])
+    cost = ledger.cost("usd")
+    store.record_run(r, session_id=meta.get("session", ""), cost=cost, status=status)
+
+    summary = str(result.get("summary", "") or result.get("error", ""))
+    if r.path is not None:
+        try:
+            (r.path / "last-run.md").write_text(
+                f"# {r.name} — last run\n\nstatus: {status} · cost: ${cost:.4f} · "
+                f"session: {meta.get('session', '?')}\n\n{summary}\n", encoding="utf-8")
+        except OSError:
+            pass
+    return {"status": status, "cost": cost, "summary": summary,
+            "session": meta.get("session", ""), "blocked_on": result.get("blocked_on")}

rockycode/runners/agent.py

@@ -0,0 +1,273 @@
+"""The rockycode harness runner: the agent loop on SWE-bench tasks.
+
+Per task: pull the official SWE-bench image → start a container → Rocky
+works inside it (bash/read/write/edit via docker exec) → `git diff` is the
+prediction. Same images the scorer uses (namespace "swebench" on Docker
+Hub), so nothing is built locally and the cache is shared.
+
+Tasks run sequentially on purpose: containers run under emulation on
+Apple Silicon, and one task at a time keeps API spend observable.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+
+from rockycode.banner import amaze, confused, fail, info
+from rockycode.engine.container import DockerSession, build_session_registry, extract_patch
+from rockycode.palette import RED
+from rockycode.engine.events import (
+    Compacted,
+    EngineError,
+    TextDelta,
+    ToolFinished,
+    ToolStarted,
+    TurnFinished,
+)
+from rockycode.engine.loop import Engine
+from rockycode.prompts.rocky import BENCH_TASK, ROCKY_SYSTEM
+from rockycode.runners.data import load_verified
+
+PREDICTIONS_DIR = Path("results") / "predictions"
+
+
+def _image_for(instance: dict) -> str:
+    from swebench.harness.test_spec.test_spec import make_test_spec
+
+    return make_test_spec(instance, namespace="swebench").instance_image_key
+
+
+async def _ensure_image(image: str, console: Console) -> bool:
+    proc = await asyncio.create_subprocess_exec(
+        "docker", "image", "inspect", image,
+        stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL,
+    )
+    if await proc.wait() == 0:
+        return True
+    info(console, f"pulling {image} [dim](first time per task, can be ~1GB)[/dim]")
+    proc = await asyncio.create_subprocess_exec(
+        "docker", "pull", "--platform", "linux/amd64", image,
+        stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.PIPE,
+    )
+    _, err = await proc.communicate()
+    if proc.returncode != 0:
+        fail(console, f"pull failed: {err.decode(errors='replace').strip().splitlines()[-1]}")
+        return False
+    return True
+
+
+def _task_prompt(instance: dict) -> str:
+    return BENCH_TASK.format(
+        repo=instance.get("repo", "unknown"),
+        problem_statement=instance.get("problem_statement", ""),
+    )
+
+
+async def _run_instance(
+    instance: dict,
+    *,
+    model: str,
+    thinking: bool,
+    reasoning_effort: str,
+    max_tokens: int,
+    context_window: int,
+    max_steps: int,
+    system_prompt: str,
+    prompt_name: str,
+    prompt_sha: str,
+    console: Console,
+) -> dict:
+    iid = instance["instance_id"]
+    image = _image_for(instance)
+
+    if not await _ensure_image(image, console):
+        return {"instance_id": iid, "patch": "", "steps": 0, "usage": {}, "error": "image pull failed"}
+
+    session = await DockerSession.start(image)
+    try:
+        registry = build_session_registry(session)
+        # Same generated "# Tools this session" section as chat, built from
+        # THIS registry — so bench prompts list exactly the container tools
+        # (no phantom web/artifact advertisements burning budget steps). No
+        # language/env/date appends: bench stays English + byte-reproducible.
+        from rockycode.prompts.rocky import tools_section
+        engine = Engine(
+            model=model,
+            thinking=thinking,
+            reasoning_effort=reasoning_effort,
+            max_tokens=max_tokens,
+            context_window=context_window,
+            max_steps=max_steps,
+            system_prompt=system_prompt + tools_section(registry),
+            registry=registry,
+            trajectory_meta={
+                "runner": "rockycode",
+                "instance_id": iid,
+                "image": image,
+                "prompt_name": prompt_name,
+                "prompt_sha": prompt_sha,
+            },
+        )
+
+        steps, usage, err = 0, {}, None
+        async for ev in engine.run_turn(_task_prompt(instance)):
+            if isinstance(ev, ToolStarted):
+                arg = (ev.args.get("raw") or "")[:70].replace("\n", " ")
+                console.print(f"    [dim]⚒ {ev.tool} {arg}[/dim]")
+            elif isinstance(ev, ToolFinished) and not ev.ok:
+                first = ev.output.strip().splitlines()[0][:90] if ev.output.strip() else ""
+                console.print(f"    [dim]✗ {ev.tool}: {first}[/dim]")
+            elif isinstance(ev, Compacted):
+                console.print(
+                    f"    [dim]♻ compacted ({ev.strategy}): "
+                    f"~{ev.tokens_before:,} → ~{ev.tokens_after:,} tokens[/dim]"
+                )
+            elif isinstance(ev, TextDelta):
+                pass  # final summary text; trajectory has it
+            elif isinstance(ev, EngineError):
+                err = ev.message
+                console.print(f"    [{RED}]✗ {ev.message}[/]")
+            elif isinstance(ev, TurnFinished):
+                steps, usage = ev.steps, ev.usage
+
+        patch = await extract_patch(session)
+        engine.trajectory.outcome(
+            {
+                "instance_id": iid,
+                "steps": steps,
+                "patch_chars": len(patch),
+                "engine_error": err,
+                "usage": usage,
+            }
+        )
+        return {"instance_id": iid, "patch": patch, "steps": steps, "usage": usage, "error": err}
+    finally:
+        await session.stop()
+
+
+async def _run_all(
+    instances: list[dict],
+    *,
+    model: str,
+    thinking: bool,
+    reasoning_effort: str,
+    max_tokens: int,
+    context_window: int,
+    max_steps: int,
+    token_budget: int,
+    system_prompt: str,
+    prompt_name: str,
+    prompt_sha: str,
+    out_path: Path,
+    safe_model: str,
+    console: Console,
+) -> None:
+    totals: dict[str, int] = {"prompt_tokens": 0, "completion_tokens": 0, "prompt_cache_hit_tokens": 0}
+    n_patch = 0
+
+    with out_path.open("w") as f:
+        for i, instance in enumerate(instances, 1):
+            spent = totals["prompt_tokens"] + totals["completion_tokens"]
+            if token_budget and spent >= token_budget:
+                info(console, f"token budget reached ({spent:,} >= {token_budget:,}) — stopping.")
+                break
+
+            iid = instance["instance_id"]
+            console.print(f"\n[bold]task {i}/{len(instances)}[/bold] · {iid}")
+            try:
+                result = await _run_instance(
+                    instance,
+                    model=model,
+                    thinking=thinking,
+                    reasoning_effort=reasoning_effort,
+                    max_tokens=max_tokens,
+                    context_window=context_window,
+                    max_steps=max_steps,
+                    system_prompt=system_prompt,
+                    prompt_name=prompt_name,
+                    prompt_sha=prompt_sha,
+                    console=console,
+                )
+            except Exception as e:  # noqa: BLE001 — one task must not kill the run
+                fail(console, f"{iid}: {type(e).__name__}: {e}")
+                result = {"instance_id": iid, "patch": "", "steps": 0, "usage": {}, "error": str(e)}
+
+            patch = result["patch"]
+            if patch.strip():
+                n_patch += 1
+                amaze(console, f"patch ready · {result['steps']} steps · {len(patch):,} chars")
+            else:
+                confused(console, f"no patch produced ({result.get('error') or 'agent stopped without changes'})")
+
+            for k in totals:
+                totals[k] += result["usage"].get(k, 0) or 0
+
+            f.write(json.dumps({
+                "instance_id": iid,
+                "model_name_or_path": f"rockycode-{safe_model}",
+                "model_patch": patch,
+            }) + "\n")
+            f.flush()
+
+    console.print(
+        f"\n[dim]· {n_patch}/{len(instances)} tasks produced a patch · "
+        f"{totals['prompt_tokens']:,} in / {totals['completion_tokens']:,} out · "
+        f"cache hit {totals['prompt_cache_hit_tokens']:,}[/dim]"
+    )
+
+
+def run(
+    model: str,
+    instance_ids: Optional[list[str]],
+    console: Console,
+    *,
+    thinking: bool = True,
+    reasoning_effort: str = "max",
+    max_tokens: int = 16384,
+    context_window: int = 131_072,
+    max_steps: int = 50,
+    token_budget: int = 0,
+    system_prompt: Optional[str] = None,
+    prompt_name: str = "rocky-builtin",
+    prompt_sha: str = "",
+    task_label: str = "tasks",
+    output_dir: Path = PREDICTIONS_DIR,
+) -> Path:
+    """Run the harness on the requested instances. Returns predictions path."""
+    if system_prompt is None:
+        system_prompt = ROCKY_SYSTEM
+    ds = load_verified(console, instance_ids)
+    instances = list(ds)
+    console.print(f"  → {len(instances)} tasks for the rockycode harness\n")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    safe_model = model.replace("/", "-")
+    # prompt + task-set + timestamp: no run ever overwrites another
+    stamp = datetime.now().strftime("%Y%m%d-%H%M")
+    out_path = output_dir / f"rockycode-{safe_model}-{prompt_name}-{task_label}-{stamp}.jsonl"
+
+    asyncio.run(
+        _run_all(
+            instances,
+            model=model,
+            thinking=thinking,
+            reasoning_effort=reasoning_effort,
+            max_tokens=max_tokens,
+            context_window=context_window,
+            max_steps=max_steps,
+            token_budget=token_budget,
+            system_prompt=system_prompt,
+            prompt_name=prompt_name,
+            prompt_sha=prompt_sha,
+            out_path=out_path,
+            safe_model=safe_model,
+            console=console,
+        )
+    )
+    info(console, f"predictions at {out_path}; trajectories at .rockycode/trajectories/")
+    return out_path

rockycode/runners/data.py

@@ -0,0 +1,61 @@
+"""Shared SWE-bench Verified dataset loading for all runners."""
+from __future__ import annotations
+
+from typing import Optional
+
+from rich.console import Console
+
+from rockycode.banner import confused, fail, info
+from rockycode.palette import BLUE
+
+_NETWORK_HINTS = (
+    "connection", "timeout", "name resolution", "network", "unreachable",
+    "dns", "ssl", "max retries", "getaddrinfo", "proxy", "refused",
+)
+
+DATASET = "princeton-nlp/SWE-bench_Verified"
+
+
+def load_verified(console: Console, instance_ids: Optional[list[str]]):
+    """Load Verified (filtered to instance_ids if given). Exits with a
+    friendly message on network failure."""
+    import datasets
+
+    # HF's tqdm bars (download + filter) collide with our Rich status line —
+    # one renderer must own the terminal.
+    datasets.disable_progress_bars()
+
+    try:
+        with console.status(
+            f"loading [{BLUE}]{DATASET}[/] "
+            "[dim](first run pulls ~hundreds of MB from huggingface)[/dim]",
+            spinner="dots",
+        ):
+            ds = datasets.load_dataset(DATASET, split="test")
+    except Exception as e:
+        fail(console, "could not load SWE-bench Verified from huggingface.")
+        msg = str(e).lower()
+        if any(k in msg for k in _NETWORK_HINTS):
+            confused(
+                console,
+                "looks like a network issue. check internet / vpn / proxy / "
+                "is huggingface.co reachable?",
+            )
+        else:
+            confused(console, f"underlying error: {type(e).__name__}: {e}")
+        info(console, "isolate the load step to debug:")
+        info(
+            console,
+            "  uv run python -c \"from datasets import load_dataset; "
+            "load_dataset('princeton-nlp/SWE-bench_Verified', split='test')\"",
+        )
+        raise SystemExit(1)
+
+    if instance_ids:
+        wanted = set(instance_ids)
+        ds = ds.filter(lambda r: r["instance_id"] in wanted)
+        missing = wanted - set(ds["instance_id"])
+        if missing:
+            confused(console, f"{len(missing)} requested IDs not in Verified: {sorted(missing)[:3]}…")
+
+    return ds