scripts/record_reference_runs.py

#!/usr/bin/env python3
"""Record scripted, LLM-free reference episodes through the OpenEnv episode layer, for the replay Space.

Each episode drives `alertforge.episode.Episode` (the class the OpenEnv server wraps) in parity reward mode,
so the per-step rewards sum to the Harbor reward. After every step the workspace is graded with the same
grader, and the trimmed grader details (per-check pass/fail) are stored with the step.

Policies (all read the conventions and the files they will change first):
  oracle    writes the oracle solution file by file, runs `run_checks` in between, then submits
  partial   writes the partial reference solution (half the requests, one plausible mistake)
  careless  oracle, with two slips that are caught and fixed: a hand edit that mis-indents one key of a
            rule file (caught by `run_checks`), and a page route sent to Slack (caught by `route_test`)

    export AF_PROMTOOL=/path/to/promtool AF_AMTOOL=/path/to/amtool
    python scripts/record_reference_runs.py --out dist/replay/traces [--tasks af-001,af-009] [-j 4]
    python scripts/export_runs.py --traces dist/replay/traces --out space/data/runs.json
"""

from __future__ import annotations

import argparse
import json
import os
import sys
from concurrent.futures import ProcessPoolExecutor

ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(ROOT, "src"))

from alertforge.episode import Episode  # noqa: E402
from alertforge.solutions import break_indent  # noqa: E402

# one task per workflow, all three tiers
DEFAULT_TASKS = ["af-001", "af-009", "af-013", "af-017", "af-021", "af-029"]
POLICIES = ["oracle", "partial", "careless"]
TIERS = ("easy", "medium", "hard")


def heredoc_writes(script: str) -> list[tuple[str, str]]:
    """Parse `cat > 'path' <<'AF_EOF'` blocks of a reference solve.sh into (path, content) writes."""
    out, cur, buf = [], None, []
    for line in open(script).read().splitlines():
        if cur is None and line.startswith("cat > '") and line.endswith("<<'AF_EOF'"):
            cur, buf = line.split("'")[1], []
        elif cur is not None and line == "AF_EOF":
            out.append((cur, "\n".join(buf) + "\n"))
            cur = None
        elif cur is not None:
            buf.append(line)
    return out


def trim_details(details: dict) -> dict:
    """Keep what the checks panel needs from a grader details dict."""
    reqs = {}
    for rid, rd in (details.get("requirements") or {}).items():
        fams = rd.get("families") or {}
        reqs[rid] = {"s": rd.get("s"), "families": {"pos": fams["pos"]} if "pos" in fams else {}}
    return {"checks": details.get("checks") or {}, "requirements": reqs,
            "preservation_items": details.get("preservation_items") or [], "tamper": details.get("tamper") or [],
            "syntax_errors": details.get("syntax_errors") or {}}


def indent_slip(rules: list[tuple[str, str]], ws0: str) -> list[dict]:
    """A hand edit of an already-fixed, pre-existing rule file that breaks its YAML, then the fix."""
    pre = [(p, c) for p, c in rules if os.path.exists(os.path.join(ws0, p))] or rules
    if not pre:
        return []
    p, c = pre[0]
    bad = break_indent(c)
    bad_line = next((b for b, g in zip(bad.splitlines(), c.splitlines()) if b != g), None)
    acts = [{"think": f"Tidy up {p} by hand before moving on."},
            {"tool": "write_file", "path": p, "content": bad}, {"tool": "run_checks"},
            {"think": f"`run_checks` says {p} no longer loads: an `expr:` key is indented one space too far, "
                      "so every rule in the file is gone. Fix the indentation."}]
    if bad_line is not None and bad.count("\n" + bad_line + "\n") == 1:
        acts.append({"tool": "replace_in_file", "path": p, "old": "\n" + bad_line + "\n",
                     "new": "\n" + bad_line[1:] + "\n"})
    else:
        acts.append({"tool": "write_file", "path": p, "content": c})
    acts.append({"tool": "run_checks"})
    return acts


def bad_route(am_text: str, route_req: dict | None) -> str | None:
    """A plausible routing slip: the new team's page route sends to its Slack receiver instead of the pager."""
    if not route_req or not route_req["route"]["pos"]:
        return None
    expect = route_req["route"]["pos"][0]["expect"]
    pager = next((e for e in expect if e.startswith("pagerduty-")), None)
    chat = next((e for e in expect if e.startswith("slack-")), None)
    if not pager or not chat or f"receiver: {pager}" not in am_text:
        return None
    return am_text.replace(f"receiver: {pager}", f"receiver: {chat}", 1)


def plan(task_dir: str, policy: str) -> list[dict]:
    """The scripted action list (with `think` notes interleaved) for one policy."""
    tid = os.path.basename(task_dir)
    oracle = heredoc_writes(os.path.join(task_dir, "solution", "solve.sh"))
    writes = heredoc_writes(os.path.join(ROOT, "partial", tid, "solve.sh")) if policy == "partial" else oracle
    with open(os.path.join(task_dir, "tests", "spec.json")) as fh:
        spec = json.load(fh)
    route_req = next((r for r in spec["requirements"] if r["kind"] == "route"), None)
    probe_labels = route_req["route"]["pos"][0]["labels"] if route_req else None
    ws0 = os.path.join(task_dir, "environment", "workspace", "monitoring")

    acts: list[dict] = [{"think": "Start by listing the repo and reading the conventions in README.md."},
                        {"tool": "list_files"}, {"tool": "read_file", "path": "README.md"}]
    targets = [p for p, _ in writes if os.path.exists(os.path.join(ws0, p))]
    if targets:
        acts.append({"think": "Read every file the change requests touch before editing: " + ", ".join(targets) + "."})
        acts += [{"tool": "read_file", "path": p} for p in targets]

    rules = [(p, c) for p, c in writes if p.startswith("rules/")]
    am = [(p, c) for p, c in writes if p.startswith("alertmanager/")]
    for n, (p, c) in enumerate(rules):
        acts.append({"think": f"Update {p}."})
        acts.append({"tool": "write_file", "path": p, "content": c})
        if n % 2 == 1 or n == len(rules) - 1:
            acts.append({"tool": "run_checks"})
    if policy == "careless":
        acts += indent_slip(rules, ws0)
    for p, c in am:
        slip = bad_route(c, route_req) if policy == "careless" else None
        if slip:
            acts.append({"think": "Route the new team and add the inhibition in the Alertmanager config."})
            acts.append({"tool": "write_file", "path": p, "content": slip})
            acts.append({"tool": "route_test", "labels": probe_labels})
            acts.append({"think": "`route_test` shows the page alert only reaching Slack: the page route points at "
                                  "the wrong receiver. Rewrite the config."})
        else:
            acts.append({"think": "Route the new team and add the inhibition in the Alertmanager config."})
        acts.append({"tool": "write_file", "path": p, "content": c})
        if probe_labels:
            acts.append({"tool": "route_test", "labels": probe_labels})
    acts.append({"tool": "run_checks"})
    acts.append({"think": "Checks pass locally; submit."})
    acts.append({"tool": "submit"})
    return acts


def record(task_dir: str, policy: str) -> dict:
    tid = os.path.basename(task_dir)
    tier = next(t for t in TIERS if f"-{t}-" in tid)
    ep = Episode(task_dir, split="train", mode="parity", tier=tier)
    steps = []
    try:
        for a in plan(task_dir, policy):
            if "think" in a:
                steps.append({"think": a["think"]})
                continue
            res = ep.step(a)
            keys, details = ep.grader.grade(ep.ws)  # cached by workspace fingerprint: no second promtool run
            steps.append({"action": a, "output": res["output"], "ok": res["ok"], "reward": res["reward"],
                          "done": res["done"], "metadata": res["metadata"], "keys": keys,
                          "details": trim_details(details)})
            if res["done"]:
                break
    finally:
        ep.close()
    total = sum(s.get("reward", 0.0) for s in steps)
    last = steps[-1]
    return {"format": "3ambench-trace/1", "source": "openenv", "task_id": tid, "tier": tier,
            "agent": f"reference: {policy}", "model": "scripted (no LLM)", "reward_mode": "parity",
            "total_reward": round(total, 6), "harbor_reward": last["metadata"].get("harbor_reward"),
            "final_keys": last["keys"], "steps": steps}


def _job(args: tuple[str, str, str]) -> str:
    task_dir, policy, out = args
    tr = record(task_dir, policy)
    path = os.path.join(out, f"{tr['task_id']}__{policy}.json")
    with open(path, "w") as fh:
        json.dump(tr, fh)
    n = sum(1 for s in tr["steps"] if "action" in s)
    return f"{tr['task_id']:44s} {policy:9s} steps={n:3d} sum_r={tr['total_reward']:.4f} harbor={tr['harbor_reward']}"


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--out", default=os.path.join(ROOT, "dist", "replay", "traces"))
    ap.add_argument("--tasks", default=",".join(DEFAULT_TASKS), help="comma-separated task ids or prefixes")
    ap.add_argument("--policies", default=",".join(POLICIES))
    ap.add_argument("-j", "--jobs", type=int, default=4)
    a = ap.parse_args()
    os.makedirs(a.out, exist_ok=True)
    all_tasks = sorted(os.listdir(os.path.join(ROOT, "tasks")))
    chosen = [t for pre in a.tasks.split(",") for t in all_tasks if t.startswith(pre.strip())]
    jobs = [(os.path.join(ROOT, "tasks", t), p, a.out) for t in chosen for p in a.policies.split(",")]
    with ProcessPoolExecutor(max_workers=a.jobs) as pool:
        for line in pool.map(_job, jobs):
            print(line, flush=True)
    return 0


if __name__ == "__main__":
    sys.exit(main())