feat: harden CAD showcase skill and delivery pipeline
This commit is contained in:
283
scripts/verify_delivery.py
Normal file
283
scripts/verify_delivery.py
Normal file
@@ -0,0 +1,283 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Strict, machine-readable verification for final CAD showcase delivery."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import gzip
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import showcase_schema
|
||||
|
||||
|
||||
def sha256(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as stream:
|
||||
for chunk in iter(lambda: stream.read(1024 * 1024), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def add_check(checks: list[dict[str, Any]], name: str, status: str, detail: str, **data) -> None:
|
||||
checks.append({"name": name, "status": status, "detail": detail, **data})
|
||||
|
||||
|
||||
def inspect_glb(path: Path, budget_mb: float, checks: list[dict[str, Any]]) -> dict[str, Any] | None:
|
||||
if not path.exists() or path.stat().st_size == 0:
|
||||
add_check(checks, f"glb:{path.name}", "FAIL", f"Missing or empty GLB: {path}")
|
||||
return None
|
||||
with path.open("rb") as stream:
|
||||
header = stream.read(4)
|
||||
if header != b"glTF":
|
||||
add_check(checks, f"glb:{path.name}", "FAIL", "File does not have a GLB header")
|
||||
return None
|
||||
try:
|
||||
from pygltflib import GLTF2
|
||||
|
||||
model = GLTF2().load(str(path))
|
||||
nodes = [node.name or "" for node in model.nodes]
|
||||
named = [name for name in nodes if "__" in name]
|
||||
meshes = len(model.meshes or [])
|
||||
primitives = sum(len(mesh.primitives) for mesh in model.meshes or [])
|
||||
if meshes == 0 or primitives == 0:
|
||||
add_check(checks, f"glb:{path.name}", "FAIL", "GLB contains no mesh primitives")
|
||||
return None
|
||||
if not named:
|
||||
add_check(checks, f"glb:{path.name}:names", "FAIL", "No <floor>__<category> node names found")
|
||||
else:
|
||||
add_check(checks, f"glb:{path.name}:names", "PASS", f"{len(named)} named node(s)")
|
||||
extensions = list(model.extensionsUsed or [])
|
||||
detail = f"{meshes} meshes, {primitives} primitives, {path.stat().st_size / 1024 / 1024:.2f} MB"
|
||||
status = "PASS" if path.stat().st_size <= budget_mb * 1024 * 1024 else "FAIL"
|
||||
if status == "FAIL":
|
||||
detail += f"; exceeds {budget_mb:.2f} MB budget"
|
||||
add_check(checks, f"glb:{path.name}:structure", status, detail)
|
||||
return {
|
||||
"path": str(path),
|
||||
"bytes": path.stat().st_size,
|
||||
"sha256": sha256(path),
|
||||
"meshes": meshes,
|
||||
"primitives": primitives,
|
||||
"nodes": named,
|
||||
"extensions": extensions,
|
||||
}
|
||||
except Exception as exc:
|
||||
add_check(checks, f"glb:{path.name}", "FAIL", f"GLB parser failed: {exc}")
|
||||
return None
|
||||
|
||||
|
||||
def inspect_render(path: Path, checks: list[dict[str, Any]]) -> None:
|
||||
if not path.exists() or path.stat().st_size == 0:
|
||||
add_check(checks, f"render:{path.name}", "FAIL", f"Missing render: {path}")
|
||||
return
|
||||
try:
|
||||
from PIL import Image, ImageStat
|
||||
|
||||
image = Image.open(path).convert("RGB")
|
||||
stat = ImageStat.Stat(image.resize((128, 128)))
|
||||
spread = max(stat.var)
|
||||
status = "PASS" if image.width >= 320 and image.height >= 240 and spread > 2.0 else "FAIL"
|
||||
add_check(
|
||||
checks,
|
||||
f"render:{path.name}",
|
||||
status,
|
||||
f"{image.width}x{image.height}, max channel variance {spread:.2f}",
|
||||
)
|
||||
except Exception as exc:
|
||||
add_check(checks, f"render:{path.name}", "FAIL", f"Image inspection failed: {exc}")
|
||||
|
||||
|
||||
def inspect_web(web_dir: Path, checks: list[dict[str, Any]]) -> None:
|
||||
required = [
|
||||
"index.html",
|
||||
"app.js",
|
||||
"styles.css",
|
||||
"model.glb",
|
||||
"model_metadata.json",
|
||||
"node_modules/three/build/three.module.js",
|
||||
"node_modules/lucide/dist/umd/lucide.js",
|
||||
]
|
||||
missing = [name for name in required if not (web_dir / name).exists()]
|
||||
if missing:
|
||||
add_check(checks, "web:files", "FAIL", "Missing Web files: " + ", ".join(missing))
|
||||
return
|
||||
text = (web_dir / "index.html").read_text(encoding="utf-8") + (web_dir / "app.js").read_text(encoding="utf-8")
|
||||
placeholders = sorted(set(re.findall(r"\{\{[^}]+\}\}", text)))
|
||||
if placeholders:
|
||||
add_check(checks, "web:placeholders", "FAIL", f"Unexpanded placeholders: {placeholders}")
|
||||
else:
|
||||
add_check(checks, "web:placeholders", "PASS", "Template placeholders expanded")
|
||||
features = ("window.__renders", "invalidate(", "DRACOLoader", "restoreStateFromHash", "switchVariant")
|
||||
absent = [feature for feature in features if feature not in text]
|
||||
add_check(
|
||||
checks,
|
||||
"web:features",
|
||||
"FAIL" if absent else "PASS",
|
||||
"Missing features: " + ", ".join(absent) if absent else "Required viewer features present",
|
||||
)
|
||||
try:
|
||||
metadata = json.loads((web_dir / "model_metadata.json").read_text(encoding="utf-8"))
|
||||
missing_variants = [
|
||||
item.get("file", "?")
|
||||
for item in metadata.get("model_variants", [])
|
||||
if not (web_dir / item.get("file", "")).exists()
|
||||
]
|
||||
add_check(
|
||||
checks,
|
||||
"web:variants",
|
||||
"FAIL" if missing_variants else "PASS",
|
||||
"Missing variant assets: " + ", ".join(missing_variants)
|
||||
if missing_variants
|
||||
else "Variant assets accounted for",
|
||||
)
|
||||
except Exception as exc:
|
||||
add_check(checks, "web:metadata", "FAIL", f"Metadata parse failed: {exc}")
|
||||
|
||||
|
||||
def inspect_offline(path: Path, checks: list[dict[str, Any]]) -> None:
|
||||
if not path.exists():
|
||||
add_check(checks, "offline:viewer", "FAIL", f"Offline viewer missing: {path}")
|
||||
return
|
||||
text = path.read_text(encoding="utf-8")
|
||||
match = re.search(r'const GLB_B64="([A-Za-z0-9+/=]+)";', text)
|
||||
if not match:
|
||||
add_check(checks, "offline:payload", "FAIL", "Embedded GLB payload not found")
|
||||
return
|
||||
try:
|
||||
payload = gzip.decompress(base64.b64decode(match.group(1)))
|
||||
if payload[:4] != b"glTF":
|
||||
raise ValueError("decoded payload is not a GLB")
|
||||
add_check(checks, "offline:payload", "PASS", f"Decoded {len(payload)} GLB bytes")
|
||||
except Exception as exc:
|
||||
add_check(checks, "offline:payload", "FAIL", f"Embedded payload decode failed: {exc}")
|
||||
|
||||
|
||||
def inspect_browser_report(path: Path, checks: list[dict[str, Any]]) -> None:
|
||||
try:
|
||||
report = json.loads(path.read_text(encoding="utf-8"))
|
||||
passed = report.get("status") == "PASS" and not report.get("console_errors")
|
||||
detail = report.get("detail") or json.dumps(report, ensure_ascii=False)[:500]
|
||||
add_check(checks, "browser:smoke", "PASS" if passed else "FAIL", detail)
|
||||
except Exception as exc:
|
||||
add_check(checks, "browser:smoke", "FAIL", f"Browser report invalid: {exc}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--spec", required=True)
|
||||
parser.add_argument("--source-report", required=True)
|
||||
parser.add_argument("--glb", nargs="*", default=[])
|
||||
parser.add_argument("--variants-manifest")
|
||||
parser.add_argument("--web-dir")
|
||||
parser.add_argument("--offline-viewer")
|
||||
parser.add_argument("--render", nargs="*", default=[])
|
||||
parser.add_argument("--browser-report")
|
||||
parser.add_argument("--require-browser-report", action="store_true")
|
||||
parser.add_argument("--budget-mb", type=float, default=25.0)
|
||||
parser.add_argument("--evidence-out", default="evidence_manifest.json")
|
||||
args = parser.parse_args()
|
||||
|
||||
checks: list[dict[str, Any]] = []
|
||||
artifacts: list[dict[str, Any]] = []
|
||||
try:
|
||||
source_report = json.loads(Path(args.source_report).read_text(encoding="utf-8"))
|
||||
showcase_schema.validate_source_report(source_report)
|
||||
add_check(
|
||||
checks,
|
||||
"cad_source_report",
|
||||
"PASS",
|
||||
f"Source gate PASS; {len(source_report['files'])} readable DXF file(s)",
|
||||
)
|
||||
except Exception as exc:
|
||||
add_check(checks, "cad_source_report", "FAIL", str(exc))
|
||||
spec_path = Path(args.spec)
|
||||
try:
|
||||
spec = json.loads(spec_path.read_text(encoding="utf-8"))
|
||||
showcase_schema.validate_spec(spec)
|
||||
add_check(checks, "building_spec", "PASS", f"Schema v{spec['schema_version']}; {len(spec['floors'])} floor(s)")
|
||||
except Exception as exc:
|
||||
add_check(checks, "building_spec", "FAIL", str(exc))
|
||||
|
||||
glb_paths = [Path(item) for item in args.glb]
|
||||
if args.variants_manifest:
|
||||
manifest_path = Path(args.variants_manifest)
|
||||
try:
|
||||
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
||||
showcase_schema.validate_manifest(manifest)
|
||||
add_check(checks, "variants_manifest", "PASS", f"{len(manifest['variants'])} variant(s)")
|
||||
for variant in manifest["variants"]:
|
||||
source = Path(variant["source_glb"])
|
||||
if not source.is_absolute():
|
||||
source = manifest_path.parent / source
|
||||
glb_paths.append(source)
|
||||
spec_file = Path(variant["spec"])
|
||||
if not spec_file.is_absolute():
|
||||
spec_file = manifest_path.parent / spec_file
|
||||
variant_spec = json.loads(spec_file.read_text(encoding="utf-8"))
|
||||
showcase_schema.validate_spec(variant_spec)
|
||||
metadata_file = Path(variant["metadata"])
|
||||
if not metadata_file.is_absolute():
|
||||
metadata_file = manifest_path.parent / metadata_file
|
||||
metadata = json.loads(metadata_file.read_text(encoding="utf-8"))
|
||||
if metadata.get("metadata_version") != 1:
|
||||
raise ValueError(f"{metadata_file}: metadata_version must be 1")
|
||||
if metadata.get("schema_version") != variant_spec.get("schema_version"):
|
||||
raise ValueError(f"{metadata_file}: schema_version does not match {spec_file}")
|
||||
except Exception as exc:
|
||||
add_check(checks, "variants_manifest", "FAIL", str(exc))
|
||||
seen = set()
|
||||
for path in glb_paths:
|
||||
resolved = path.resolve()
|
||||
if resolved in seen:
|
||||
continue
|
||||
seen.add(resolved)
|
||||
artifact = inspect_glb(path, args.budget_mb, checks)
|
||||
if artifact:
|
||||
artifacts.append(artifact)
|
||||
if not glb_paths:
|
||||
add_check(checks, "glb", "FAIL", "No GLB supplied")
|
||||
|
||||
for path in args.render:
|
||||
inspect_render(Path(path), checks)
|
||||
if not args.render:
|
||||
add_check(checks, "render", "FAIL", "At least one inspected render is required")
|
||||
if args.web_dir:
|
||||
inspect_web(Path(args.web_dir), checks)
|
||||
if args.offline_viewer:
|
||||
inspect_offline(Path(args.offline_viewer), checks)
|
||||
if args.browser_report:
|
||||
inspect_browser_report(Path(args.browser_report), checks)
|
||||
elif args.require_browser_report:
|
||||
add_check(checks, "browser:smoke", "FAIL", "Browser smoke report required but not supplied")
|
||||
else:
|
||||
add_check(checks, "browser:smoke", "WARN", "No browser smoke report supplied")
|
||||
|
||||
status = "FAIL" if any(item["status"] == "FAIL" for item in checks) else "PASS"
|
||||
evidence = {
|
||||
"evidence_version": 1,
|
||||
"generated_at": datetime.now(timezone.utc).isoformat(),
|
||||
"status": status,
|
||||
"checks": checks,
|
||||
"artifacts": artifacts,
|
||||
}
|
||||
out = Path(args.evidence_out)
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
out.write_text(json.dumps(evidence, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
print(json.dumps({"status": status, "evidence": str(out), "checks": len(checks)}, ensure_ascii=False))
|
||||
if status == "FAIL":
|
||||
for item in checks:
|
||||
if item["status"] == "FAIL":
|
||||
print(f"GATE FAIL [{item['name']}]: {item['detail']}", file=sys.stderr)
|
||||
return 3
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user