src/explicit_learning/c2/record.py

"""Emit ``compiled_program`` records for the C2 dual-compile (``docs/02`` §7).

Each model produces one ``compiled_program`` row conforming to
``schemas/compiled_program.schema.json``. The record is content-addressed:
``compile_id`` is the SHA-256 of the canonical-JSON of the record's identity
fields (role + pinned model + base id + question/choices hashes + request +
response), so the same ``(model, request, response)`` always reproduces the same
``compile_id`` and a different response always changes it.

A compiled program carries the full envelope (``dsl`` / ``program`` /
``referent_selector`` / ``required_referent_cardinality`` /
``referenced_node_ids`` / ``canonical_program_sha256``). A non-compiled outcome
(``invalid_response`` for a parse failure, ``unsupported`` for a model-declined
compile) carries a ``reason_code`` and no program — never a fabricated program.
"""

from __future__ import annotations

from functools import lru_cache
from typing import Any, Literal

from ..dsl.ast import CompileStatus
from ..hashing import canonical_json_hash
from ..paths import repo_root
from ..schema_io import is_valid, load_schema
from .parse import ParsedProgram

CompilerRole = Literal["program_proposer", "independent_program_verifier"]
ParseStatus = Literal["valid_first_response", "valid_after_one_repair", "invalid"]


@lru_cache(maxsize=1)
def _schema() -> dict[str, Any]:
    return load_schema(repo_root() / "schemas" / "compiled_program.schema.json")


def build_compiled_program(
    *,
    base_id: str,
    question_sha256: str,
    choices_sha256: str,
    compiler_role: CompilerRole,
    model_repo_id: str,
    model_revision: str,
    request_sha256: str,
    response_sha256: str,
    parse_status: ParseStatus,
    parsed: ParsedProgram | None = None,
    compile_status: CompileStatus | None = None,
    reason_code: str | None = None,
) -> dict[str, Any]:
    """Assemble a schema-valid ``compiled_program`` record.

    ``parsed.ok`` ⇒ ``compile_status="compiled"`` with the full envelope; else
    ``compile_status`` defaults to ``"invalid_response"`` (or the caller-supplied
    ``"unsupported"``) with a required ``reason_code``. The returned dict is
    validated against the schema; a non-conforming record raises (never silently
    emitted).
    """
    record: dict[str, Any] = {
        "schema_version": 1,
        "base_id": base_id,
        "compiler_role": compiler_role,
        "model": {"repo_id": model_repo_id, "revision": model_revision},
        "question_sha256": question_sha256,
        "choices_sha256": choices_sha256,
        "request_sha256": request_sha256,
        "response_sha256": response_sha256,
        "parse_status": parse_status,
    }

    if parsed is not None and parsed.ok and parsed.program is not None:
        prog = parsed.program
        record["compile_status"] = "compiled"
        record["dsl"] = prog.dsl
        record["program"] = prog.program.to_ast_node_dict()
        record["referent_selector"] = (
            prog.referent_selector.to_ast_node_dict() if prog.referent_selector else None
        )
        record["required_referent_cardinality"] = prog.required_referent_cardinality
        record["referenced_node_ids"] = list(prog.referenced_node_ids)
        record["canonical_program_sha256"] = parsed.canonical_program_sha256
    else:
        record["compile_status"] = compile_status or "invalid_response"
        record["reason_code"] = reason_code or _default_reason(parse_status, parsed)

    record["compile_id"] = _compile_id(record)
    _validate(record)
    return record


def _default_reason(parse_status: ParseStatus, parsed: ParsedProgram | None) -> str:
    if parsed is not None and not parsed.ok and parsed.errors:
        return "parse_failed: " + "; ".join(parsed.errors[:3])
    if parse_status == "invalid":
        return "invalid_response"
    return "unsupported"


def _compile_id(record: dict[str, Any]) -> str:
    """Content-addressed id over the stable identity fields (not compile_status)."""
    identity = {
        "compiler_role": record["compiler_role"],
        "model": record["model"],
        "base_id": record["base_id"],
        "question_sha256": record["question_sha256"],
        "choices_sha256": record["choices_sha256"],
        "request_sha256": record["request_sha256"],
        "response_sha256": record["response_sha256"],
    }
    return canonical_json_hash(identity)


def _validate(record: dict[str, Any]) -> None:
    schema = _schema()
    if not is_valid(record, schema):
        from ..schema_io import validate

        errors = validate(record, schema)
        raise ValueError("compiled_program record failed schema: " + "; ".join(errors))


__all__ = ["build_compiled_program"]