| """Shared helpers for the replay exporters: text clipping, tool-call summaries, and a scratch copy of a task's |
| workspace that recovered edits are applied to (scripts/export_runs.py for the core tier, scripts/export_expert.py |
| for the expert tier). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import difflib |
| import json |
| import os |
| import shutil |
| import tempfile |
|
|
| from replay_atif import apply_v4a |
|
|
| MAX_OUT, MAX_DIFF, MAX_THINK, MAX_ARGS = 1200, 2400, 1200, 300 |
|
|
|
|
| def clip(s: str | None, n: int) -> str: |
| s = s or "" |
| return s if len(s) <= n else s[:n] + f"\n… [{len(s) - n} more chars]" |
|
|
|
|
| def args_summary(tool: str, a: dict) -> str: |
| if tool in ("write_file", "Write", "create_file"): |
| return f"{a.get('path') or a.get('file_path')} ({len(str(a.get('content', '')))} bytes)" |
| for k in ("path", "file_path", "command", "cmd", "keystrokes", "labels", "input"): |
| if k in a and a[k] not in (None, ""): |
| v = a[k] |
| head = f"{a.get('path') or a.get('file_path')} " if k not in ("path", "file_path") and ( |
| a.get("path") or a.get("file_path")) else "" |
| return clip(head + (json.dumps(v) if isinstance(v, (dict, list)) else str(v)), MAX_ARGS) |
| return clip(json.dumps(a), MAX_ARGS) if a else "" |
|
|
|
|
| class Workspace: |
| """A scratch copy of a task's initial workspace: applies edits, returns diffs, grades on demand.""" |
|
|
| def __init__(self, task_dir: str, grader=None): |
| self.root = tempfile.mkdtemp(prefix="af-replay-") |
| self.ws = os.path.join(self.root, "monitoring") |
| shutil.copytree(os.path.join(task_dir, "environment", "workspace", "monitoring"), self.ws, symlinks=True) |
| self.grader = grader |
|
|
| def read(self, rel: str) -> str | None: |
| p = os.path.join(self.ws, rel) |
| return open(p).read() if os.path.isfile(p) else None |
|
|
| def files(self) -> dict: |
| out = {} |
| for dp, _, fns in os.walk(self.ws): |
| for fn in fns: |
| rel = os.path.relpath(os.path.join(dp, fn), self.ws) |
| out[rel] = self.read(rel) |
| return out |
|
|
| def apply(self, op: tuple) -> tuple[str, bool]: |
| """Apply one op; returns (unified diff, ok).""" |
| if op[0] == "patch": |
| ops, ok = apply_v4a(self.files(), op[1]) |
| diffs = [self.apply(o) for o in ops] |
| return "".join(d for d, _ in diffs), ok and all(k for _, k in diffs) |
| rel = op[1] |
| old = self.read(rel) |
| if op[0] == "write": |
| new = op[2] |
| elif op[0] == "replace": |
| _, _, a, b, every = op |
| if old is None or (a not in old): |
| return "", False |
| new = old.replace(a, b) if every else old.replace(a, b, 1) |
| elif op[0] == "delete": |
| if old is not None: |
| os.remove(os.path.join(self.ws, rel)) |
| return self._diff(rel, old, ""), True |
| else: |
| return "", False |
| p = os.path.join(self.ws, rel) |
| os.makedirs(os.path.dirname(p), exist_ok=True) |
| with open(p, "w") as fh: |
| fh.write(new) |
| return self._diff(rel, old, new), True |
|
|
| @staticmethod |
| def _diff(rel: str, old: str | None, new: str) -> str: |
| return "".join(difflib.unified_diff((old or "").splitlines(True), new.splitlines(True), |
| f"a/{rel}" if old is not None else "/dev/null", f"b/{rel}", n=2)) |
|
|
| def grade(self) -> tuple[dict, dict]: |
| return self.grader.grade(self.ws) |
|
|
| def close(self) -> None: |
| shutil.rmtree(self.root, ignore_errors=True) |
|
|
