| """Build TerminalBench-DockerLess.jsonl from tasks/. |
| |
| A Terminal-Bench task is a directory: instruction, environment, solution, tests. |
| Docker supplies the environment; here `environment/setup.sh` builds the same |
| state in a throwaway directory instead, so a row is self-contained. |
| |
| For every task this script: |
| 1. flattens the task directory into a row (instruction, files, tests, solution, |
| dockerfile) and renders both a classic `task.yaml` and a Harbor `task.toml`; |
| 2. runs the task with no agent at all, to record which verifier tests fail on |
| the untouched environment (`dockerless.baseline_failures`); |
| 3. writes the JSONL; |
| 4. re-runs the whole file through run_harness.py with --solution and |
| --baseline, and fails loudly unless the oracle scores 4/4 and the baseline |
| scores 0/4. |
| |
| Run with: python build_dataset.py |
| """ |
|
|
| import json |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent |
| TASKS_DIR = ROOT / "tasks" |
| OUT = ROOT / "TerminalBench-DockerLess.jsonl" |
| REPORTS = ROOT / "reports" |
|
|
| sys.path.insert(0, str(ROOT)) |
| import run_harness |
|
|
| AUTHOR = {"name": "WorkBuddy Benchmarks", "email": "benchmarks@example.invalid"} |
|
|
| TASKS = [ |
| { |
| "dir": "access-log-report", |
| "task_id": "tbdl-access-log-report", |
| "difficulty": "medium", |
| "category": "data-processing", |
| "tags": ["log-parsing", "text-processing", "json", "python"], |
| "description": "Aggregate a damaged access log into a canonical JSON report, a malformed-line index and a gzip archive.", |
| "expert_time_estimate_min": 25, |
| "junior_time_estimate_min": 90, |
| "max_agent_timeout_sec": 600.0, |
| "max_test_timeout_sec": 120.0, |
| "requires": ["bash", "python"], |
| }, |
| { |
| "dir": "git-recovery", |
| "task_id": "tbdl-git-recovery", |
| "difficulty": "hard", |
| "category": "software-engineering", |
| "tags": ["git", "forensics", "history-recovery"], |
| "description": "Restore a deleted module from history, resurrect an unreachable commit, tag a release and leave a clean tree.", |
| "expert_time_estimate_min": 20, |
| "junior_time_estimate_min": 75, |
| "max_agent_timeout_sec": 600.0, |
| "max_test_timeout_sec": 120.0, |
| "requires": ["bash", "git"], |
| }, |
| { |
| "dir": "csv-canon", |
| "task_id": "tbdl-csv-canon", |
| "difficulty": "hard", |
| "category": "data-processing", |
| "tags": ["csv", "cli", "spec-compliance", "exit-codes"], |
| "description": "Write a byte-exact CSV-to-TSV canonicaliser with strict error codes and numeric normalisation.", |
| "expert_time_estimate_min": 35, |
| "junior_time_estimate_min": 120, |
| "max_agent_timeout_sec": 900.0, |
| "max_test_timeout_sec": 120.0, |
| "requires": ["bash", "python"], |
| }, |
| { |
| "dir": "build-repair", |
| "task_id": "tbdl-build-repair", |
| "difficulty": "hard", |
| "category": "software-engineering", |
| "tags": ["build", "shell", "debugging"], |
| "description": "Repair a shell build with three independent faults so it produces the expected report and passes its own suite.", |
| "expert_time_estimate_min": 25, |
| "junior_time_estimate_min": 90, |
| "max_agent_timeout_sec": 600.0, |
| "max_test_timeout_sec": 120.0, |
| "requires": ["bash", "python"], |
| }, |
| ] |
|
|
|
|
| def read_text(path): |
| """Decode without newline translation so CRLF/BOM fixtures survive.""" |
| return path.read_bytes().decode("utf-8") |
|
|
|
|
| def workspace_files(environment_dir): |
| files = {} |
| for path in sorted(environment_dir.rglob("*")): |
| if not path.is_file(): |
| continue |
| rel = path.relative_to(environment_dir).as_posix() |
| if rel in ("Dockerfile", "setup.sh"): |
| continue |
| files[rel] = read_text(path) |
| return files |
|
|
|
|
| def render_task_yaml(meta, instruction): |
| lines = [ |
| "# Terminal-Bench task definition", |
| "instruction: |", |
| ] |
| for line in instruction.rstrip("\n").split("\n"): |
| lines.append(" " + line if line else "") |
| lines += [ |
| "author_name: %s" % AUTHOR["name"], |
| "author_email: %s" % AUTHOR["email"], |
| "difficulty: %s" % meta["difficulty"], |
| "category: %s" % meta["category"], |
| "tags:", |
| ] |
| for tag in meta["tags"]: |
| lines.append(" - %s" % tag) |
| lines += [ |
| "parser_name: pytest", |
| "max_agent_timeout_sec: %.1f" % meta["max_agent_timeout_sec"], |
| "max_test_timeout_sec: %.1f" % meta["max_test_timeout_sec"], |
| "expert_time_estimate_min: %d" % meta["expert_time_estimate_min"], |
| "junior_time_estimate_min: %d" % meta["junior_time_estimate_min"], |
| ] |
| return "\n".join(lines) + "\n" |
|
|
|
|
| def render_task_toml(meta): |
| keywords = ", ".join('"%s"' % tag for tag in meta["tags"]) |
| return ( |
| 'schema_version = "1.4"\n' |
| 'source = "TerminalBench-DockerLess"\n' |
| "\n" |
| "[task]\n" |
| 'name = "swedl/%s"\n' |
| 'authors = [{ name = "%s", email = "%s" }]\n' |
| 'description = "%s"\n' |
| "keywords = [%s]\n" |
| "\n" |
| "[metadata]\n" |
| 'difficulty = "%s"\n' |
| 'category = "%s"\n' |
| "tags = [%s]\n" |
| "expert_time_estimate_min = %d\n" |
| "junior_time_estimate_min = %d\n" |
| "\n" |
| "[verifier]\n" |
| "timeout_sec = %.1f\n" |
| "\n" |
| "[agent]\n" |
| "timeout_sec = %.1f\n" |
| "\n" |
| "[environment]\n" |
| 'network_mode = "no-network"\n' |
| 'os = "linux"\n' |
| 'workdir = "/workspace"\n' |
| % ( |
| meta["dir"], |
| AUTHOR["name"], |
| AUTHOR["email"], |
| meta["description"], |
| keywords, |
| meta["difficulty"], |
| meta["category"], |
| keywords, |
| meta["expert_time_estimate_min"], |
| meta["junior_time_estimate_min"], |
| meta["max_test_timeout_sec"], |
| meta["max_agent_timeout_sec"], |
| ) |
| ) |
|
|
|
|
| def build_row(meta): |
| task_dir = TASKS_DIR / meta["dir"] |
| environment = task_dir / "environment" |
|
|
| instruction = read_text(task_dir / "instruction.md") |
| setup_path = environment / "setup.sh" |
| setup = read_text(setup_path) if setup_path.is_file() else "" |
|
|
| row = { |
| "task_id": meta["task_id"], |
| "instruction": instruction, |
| "author_name": AUTHOR["name"], |
| "author_email": AUTHOR["email"], |
| "difficulty": meta["difficulty"], |
| "category": meta["category"], |
| "tags": list(meta["tags"]), |
| "parser_name": "pytest", |
| "max_agent_timeout_sec": meta["max_agent_timeout_sec"], |
| "max_test_timeout_sec": meta["max_test_timeout_sec"], |
| "expert_time_estimate_min": meta["expert_time_estimate_min"], |
| "junior_time_estimate_min": meta["junior_time_estimate_min"], |
| "task_yaml": render_task_yaml(meta, instruction), |
| "task_toml": render_task_toml(meta), |
| "dockerfile": read_text(environment / "Dockerfile"), |
| "solution": read_text(task_dir / "solution" / "solve.sh"), |
| "tests": { |
| path.name: read_text(path) |
| for path in sorted((task_dir / "tests").iterdir()) |
| if path.is_file() |
| }, |
| "dockerless": { |
| "setup": setup, |
| "setup_timeout_sec": 120, |
| "files": workspace_files(environment), |
| "test_cmd": "", |
| "workdir": "workspace", |
| "requires": list(meta["requires"]), |
| "baseline_failures": [], |
| }, |
| } |
| return row |
|
|
|
|
| def baseline(row): |
| root = Path(tempfile.mkdtemp(prefix="tbdl-build-")) |
| try: |
| result, _ = run_harness.evaluate(row, "", root) |
| finally: |
| shutil.rmtree(root, ignore_errors=True) |
| return result |
|
|
|
|
| def main(): |
| rows = [] |
| print("%-24s %-7s %-8s %s" % ("task_id", "diff", "files", "baseline")) |
| for meta in TASKS: |
| row = build_row(meta) |
| result = baseline(row) |
| row["dockerless"]["baseline_failures"] = result["failing"] |
| if result["resolved"]: |
| raise RuntimeError( |
| "%s passes with no agent at all -- the task is not solvable-proof" |
| % row["task_id"] |
| ) |
| if not result["tests_total"]: |
| raise RuntimeError("%s: verifier collected no tests" % row["task_id"]) |
| rows.append(row) |
| print( |
| "%-24s %-7s %-8d %d/%d failing" |
| % ( |
| row["task_id"], |
| row["difficulty"], |
| len(row["dockerless"]["files"]), |
| result["tests_total"] - result["tests_passed"], |
| result["tests_total"], |
| ) |
| ) |
|
|
| with open(OUT, "w", encoding="utf-8", newline="\n") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, ensure_ascii=False) + "\n") |
| print("\nwrote %s (%d rows, %.1f KiB)" % (OUT.name, len(rows), OUT.stat().st_size / 1024.0)) |
|
|
| REPORTS.mkdir(exist_ok=True) |
| failures = [] |
| for mode, expected in (("--solution", len(rows)), ("--baseline", 0)): |
| report_path = REPORTS / ("%s.json" % mode.lstrip("-")) |
| proc = subprocess.run( |
| [ |
| sys.executable, |
| str(ROOT / "run_harness.py"), |
| "--dataset", |
| str(OUT), |
| mode, |
| "--out", |
| str(report_path), |
| ], |
| capture_output=True, |
| text=True, |
| encoding="utf-8", |
| ) |
| tail = (proc.stdout.strip().splitlines() or ["<no output>"])[-1] |
| print("%-12s %s" % (mode, tail)) |
| if proc.returncode != 0: |
| failures.append("%s exited %d: %s" % (mode, proc.returncode, proc.stderr[-800:])) |
| continue |
| resolved = json.loads(report_path.read_text(encoding="utf-8"))["resolved"] |
| if resolved != expected: |
| failures.append("%s resolved %d, expected %d" % (mode, resolved, expected)) |
|
|
| if failures: |
| print("\nVERIFICATION FAILED") |
| for message in failures: |
| print(" - %s" % message) |
| return 1 |
| print("\nverification passed: oracle %d/%d, baseline 0/%d" % (len(rows), len(rows), len(rows))) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
