105 lines
4.8 KiB
Python
105 lines
4.8 KiB
Python
"""Load admitted text by registered generation type or legacy family ID.
|
|
|
|
This offline loader checks document admission and integrity.
|
|
It does not resolve free-text queries or evaluate variant applicability facts;
|
|
the production CAD assistant's knowledge router remains a separate interface.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import re
|
|
|
|
|
|
def _generation_ids(kb):
|
|
ids = set(kb.families)
|
|
path = kb.root / "generation/catalog.json"
|
|
if not path.exists():
|
|
return ids
|
|
catalog = json.loads(path.read_text(encoding="utf-8"))
|
|
if catalog.get("schema_version") != 1 or not isinstance(catalog.get("types"), list):
|
|
raise ValueError("Invalid generation catalog")
|
|
registered = set()
|
|
for entry in catalog["types"]:
|
|
type_id = entry.get("id") if isinstance(entry, dict) else None
|
|
if not isinstance(type_id, str) or not re.fullmatch(r"[a-z][a-z0-9]*(?:-[a-z0-9]+)*", type_id):
|
|
raise ValueError(f"Invalid generation catalog type ID: {type_id}")
|
|
if type_id in registered:
|
|
raise ValueError(f"Duplicate generation catalog type ID: {type_id}")
|
|
registered.add(type_id)
|
|
return ids | registered
|
|
|
|
|
|
def _require_generation_id(value, registered):
|
|
if not isinstance(value, str) or value not in registered:
|
|
raise ValueError(f"Unknown registered generation ID: {value}")
|
|
|
|
|
|
def build_generation_context(kb, family_ids, engine_build=None, *, experimental=False):
|
|
"""Load selected IDs only, without inferring or checking variant conditions."""
|
|
if isinstance(family_ids, str) or not isinstance(family_ids, (list, tuple)):
|
|
raise ValueError("Family IDs must be a list")
|
|
registered = _generation_ids(kb)
|
|
for family_id in family_ids:
|
|
_require_generation_id(family_id, registered)
|
|
selected = set(family_ids)
|
|
registry = kb.root / "generation/policy.json"
|
|
result = {"mode": "experimental" if experimental else "admitted_only",
|
|
"engine_build": engine_build, "manifest": [], "skipped": [], "text": ""}
|
|
if not registry.exists():
|
|
result["skipped"].append({"reason": "generation_registry_missing"})
|
|
return result
|
|
policy = json.loads(registry.read_text(encoding="utf-8"))
|
|
if policy.get("schema_version") != 1 or not isinstance(policy.get("documents"), list):
|
|
raise ValueError("Invalid generation policy")
|
|
seen, sections = set(), []
|
|
for entry in policy["documents"]:
|
|
doc_id = entry["doc_id"]
|
|
if doc_id in seen:
|
|
raise ValueError(f"Duplicate generation document ID: {doc_id}")
|
|
seen.add(doc_id)
|
|
families = entry["family_ids"]
|
|
if not isinstance(families, list) or not families:
|
|
raise ValueError(f"Generation document needs family IDs: {doc_id}")
|
|
for family_id in families:
|
|
_require_generation_id(family_id, registered)
|
|
if not selected.intersection(families):
|
|
continue
|
|
reason = None
|
|
status = entry["status"]
|
|
if status not in {"experimental", "approved", "retired"}:
|
|
raise ValueError(f"Invalid generation status: {doc_id}")
|
|
if status != "approved" and not (experimental and status == "experimental"):
|
|
reason = "not_approved"
|
|
path = (kb.root / entry["path"]).resolve()
|
|
if not path.is_relative_to((kb.root / "generation").resolve()):
|
|
raise ValueError(f"Generation document outside registry: {doc_id}")
|
|
if reason:
|
|
result["skipped"].append({"doc_id": doc_id, "reason": reason})
|
|
continue
|
|
content = path.read_bytes()
|
|
digest = hashlib.sha256(content).hexdigest()
|
|
if digest != entry["sha256"]:
|
|
result["skipped"].append({"doc_id": doc_id, "reason": "content_changed"})
|
|
continue
|
|
if status == "approved":
|
|
evidence = entry.get("evidence", {})
|
|
required = ("engine_replay", "ab_comparison", "parameter_transfer")
|
|
if evidence.get("verdict") != "benefit_observed" or not all(evidence.get(key) for key in required):
|
|
result["skipped"].append({"doc_id": doc_id, "reason": "benefit_evidence_missing"})
|
|
continue
|
|
text = content.decode("utf-8").strip()
|
|
if text.startswith("---\n"):
|
|
raise ValueError(f"Generation text must be plain Markdown without metadata: {doc_id}")
|
|
if not text:
|
|
raise ValueError(f"Empty generation document: {doc_id}")
|
|
manifest = {key: entry[key] for key in ("doc_id", "version", "path", "sha256", "status")}
|
|
# Build metadata is diagnostic only; independently deployed clients
|
|
# must not lose knowledge because a deployment identifier changed.
|
|
manifest.update(engine_build=engine_build)
|
|
result["manifest"].append(manifest)
|
|
sections.append(text)
|
|
result["text"] = "\n\n---\n\n".join(sections)
|
|
return result
|