eval/validate.py

"""Validate one world.html against one test, several tests, or the full WC* ladder.

1. checks.structural.check_input_ready — fail fast if the file is missing/wrong.
2. eval.capture.run.capture — once per world, if any selected test.yaml says
   needs_capture: the daytime preview, fixed views and the navigator agent's
   biome frames that every visual judge reads. A capture failure is recorded,
   not fatal; each visual test then reports its own failure.
3. For each selected test.yaml check: load + run_audited_check (LangSmith).

Direct test scripts do not call this. Harness does — that is what makes a
run auditable.
"""

from __future__ import annotations

import json
from pathlib import Path

from dotenv import load_dotenv

load_dotenv(Path(__file__).resolve().parent.parent / ".env")

from langsmith import traceable

from checks.structural import check_input_ready
from eval.audit import run_audited_check
from eval.capture.run import capture
from eval.loader import discover_tests, load_check, resolve_test
from eval.score import score_records
from eval.capture.llm import JudgeUnavailable  # noqa: E402
from harness.status import log, timed


def validate(
    output_dir: Path,
    test_dir_name: str | None = None,
    *,
    test_dir_names: list[str] | None = None,
) -> dict:
    output_dir = Path(output_dir)
    model = output_dir.name.split("__", 1)[0]
    selected = _selected_tests(test_dir_name, test_dir_names)

    @traceable(
        name=f"{model}::pipeline",
        run_type="chain",
        metadata={
            "model": model,
            "tests": [t["dir_name"] for t in selected],
        },
    )
    def _run() -> dict:
        return _validate(output_dir, model, selected)

    return _run()


def _selected_tests(
    test_dir_name: str | None,
    test_dir_names: list[str] | None,
) -> list[dict]:
    all_tests = discover_tests()
    if test_dir_names:
        return [resolve_test(name, all_tests) for name in test_dir_names]
    if test_dir_name:
        return [resolve_test(test_dir_name, all_tests)]
    return all_tests


def _is_full_ladder(selected: list[dict]) -> bool:
    return [t["dir_name"] for t in selected] == [t["dir_name"] for t in discover_tests()]


def _validate(output_dir: Path, model: str, selected: list[dict]) -> dict:
    structural = check_input_ready(output_dir)
    existing_checks: dict = {}
    # Keys of checks that still exist in some test.yaml. Anything else in an
    # old validation.json (a removed test like the retired keyword-coverage test, a removed check like
    # check_voxel_world or check_bedrock) is dropped, so totals only ever sum
    # the current ladder.
    live_keys = {f"{t['dir_name']}::{c['function']}" for t in discover_tests() for c in t["checks"]}
    prev_path = output_dir / "validation.json"
    if prev_path.is_file() and not _is_full_ladder(selected):
        try:
            existing_checks = dict(json.loads(prev_path.read_text(encoding="utf-8")).get("checks") or {})
        except (OSError, json.JSONDecodeError):
            existing_checks = {}
        # Drop stale entries for tests being re-run this pass — otherwise a
        # check removed from a test's own test.yaml (or renamed) lingers in
        # validation.json forever, since nothing in this run ever overwrites
        # it. Only checks for tests NOT selected this run should carry over.
        selected_prefixes = tuple(f"{t['dir_name']}::" for t in selected)
        existing_checks = {
            key: record
            for key, record in existing_checks.items()
            if not key.startswith(selected_prefixes) and key in live_keys
        }

    result = {
        "model": model,
        "tests": [t["dir_name"] for t in selected],
        "structural": {
            "passed": structural.passed,
            "reason": structural.reason,
            "details": structural.details,
        },
        "checks": existing_checks,
    }

    if not structural.passed:
        log(f"structural  fail  {structural.reason}")
        result["passed"] = False
        result.update(score_records({}))
        _write(output_dir, result)
        return result

    world_html = str(output_dir / "world.html")
    if any(t.get("needs_capture") for t in selected):
        with timed("capture  views for the visual judges") as info:
            try:
                manifest = capture(output_dir)
                framed = sum(1 for b in manifest.get("biomes", {}).values() if b.get("status") == "found")
                info["detail"] = f"{len(manifest.get('views', {}))} views, {framed}/10 biomes framed"
                result["capture"] = {
                    "views": len(manifest.get("views", {})),
                    "biomes": {k: v.get("status") for k, v in manifest.get("biomes", {}).items()},
                    "time": manifest.get("time"),
                    "preview_ok": manifest.get("preview", {}).get("ok"),
                }
            except JudgeUnavailable:
                raise  # every test is judged by this model: nothing left to run
            except Exception as exc:
                info["detail"] = f"failed: {exc}"
                result["capture"] = {"error": str(exc)}
    n = len(selected)
    for i, test in enumerate(selected, 1):
        test_out = output_dir / test["dir_name"]
        test_out.mkdir(parents=True, exist_ok=True)
        title = test.get("title") or test["dir_name"]
        label = f"[{i}/{n}] {test['id']}  {title}"
        for check in test["checks"]:
            key = f"{test['dir_name']}::{check['function']}"
            with timed(label) as info:
                try:
                    check_fn = load_check(test["path"] / check["script"], check["function"])
                    record = run_audited_check(
                        check_fn,
                        world_html,
                        test_id=test["dir_name"],
                        model=model,
                        out_dir=test_out,
                    )
                except JudgeUnavailable:
                    raise
                except Exception as exc:
                    record = {
                        "passed": False,
                        "reason": str(exc),
                        "score": 0,
                        "max_score": 0,
                        "details": {"error": str(exc)},
                    }
                status = "pass" if record.get("passed") else "fail"
                info["detail"] = f"{record.get('score', 0)}/{record.get('max_score', 0)}  {status}"
            result["checks"][key] = record

    present = []
    for test in discover_tests():
        prefix = f"{test['dir_name']}::"
        if any(key.startswith(prefix) for key in result["checks"]):
            present.append(test["dir_name"])
    result["tests"] = present or [t["dir_name"] for t in selected]
    result["passed"] = all(bool(record.get("passed")) for record in result["checks"].values())
    result.update(score_records(result["checks"]))
    _write(output_dir, result)
    return result


def _write(output_dir: Path, result: dict) -> None:
    (output_dir / "validation.json").write_text(json.dumps(result, indent=2, default=str))