scripts/validate_asset.py

#!/usr/bin/env python3
import argparse
import json
import sys
import xml.etree.ElementTree as ET
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
MANIFEST = ROOT / "manifest" / "assets.jsonl"


def load_manifest():
    entries = {}
    if not MANIFEST.exists():
        return entries
    for line_no, line in enumerate(MANIFEST.read_text().splitlines(), start=1):
        line = line.strip()
        if not line:
            continue
        try:
            row = json.loads(line)
        except json.JSONDecodeError as exc:
            raise RuntimeError(f"{MANIFEST}:{line_no}: invalid JSON: {exc}") from exc
        entries[row.get("path")] = row
    return entries


def parse_simple_yaml(path):
    data = {}
    current_key = None
    list_mode = False
    for raw in path.read_text().splitlines():
        if not raw.strip() or raw.lstrip().startswith("#"):
            continue
        if raw.startswith("  - ") and current_key:
            data.setdefault(current_key, []).append(raw.strip()[2:].strip())
            continue
        if ":" in raw and not raw.startswith(" "):
            key, value = raw.split(":", 1)
            key = key.strip()
            value = value.strip()
            current_key = key
            if value == "":
                data[key] = []
                list_mode = True
            else:
                data[key] = value.strip('"').strip("'")
                list_mode = False
    return data


def validate_one(asset_dir, manifest):
    errors = []
    asset_dir = asset_dir.resolve()
    rel = asset_dir.relative_to(ROOT).as_posix()
    parts = asset_dir.relative_to(ROOT / "assets").parts

    metadata_path = asset_dir / "metadata.yaml"
    if not metadata_path.exists():
        errors.append(f"missing metadata.yaml: {metadata_path}")
        metadata = {}
    else:
        metadata = parse_simple_yaml(metadata_path)

    entry_file = metadata.get("entry_file", "model.xml")
    entry_path = asset_dir / entry_file
    if not entry_path.exists():
        errors.append(f"missing entry_file: {entry_path}")

    if len(parts) < 5:
        errors.append(f"asset path must follow assets/<source>/(raw|derived)/<asset_type>/<category>/<asset_id>: {rel}")
    else:
        source, storage_kind, asset_type, category, asset_id = parts[:5]
        if storage_kind not in {"raw", "derived"}:
            errors.append(f"asset storage kind must be raw or derived: {rel}")
        expected_asset_id = f"{source}.{asset_type}.{category}.{asset_id}"
        if metadata.get("source") != source:
            errors.append(f"metadata source mismatch: {rel}: expected {source}, got {metadata.get('source')}")
        if metadata.get("asset_type") != asset_type:
            errors.append(f"metadata asset_type mismatch: {rel}: expected {asset_type}, got {metadata.get('asset_type')}")
        if metadata.get("category") != category:
            errors.append(f"metadata category mismatch: {rel}: expected {category}, got {metadata.get('category')}")
        if metadata.get("asset_id") != expected_asset_id:
            errors.append(f"metadata asset_id mismatch: {rel}: expected {expected_asset_id}, got {metadata.get('asset_id')}")
        if metadata.get("path") != rel:
            errors.append(f"metadata path mismatch: {rel}: got {metadata.get('path')}")
        if storage_kind == "derived" and metadata.get("storage_mode") not in {"derived", "converted", "generated"}:
            errors.append(f"derived asset missing storage_mode metadata: {rel}")

    if rel not in manifest:
        errors.append(f"missing manifest entry for path: {rel}")
    else:
        row = manifest[rel]
        for key in ("asset_id", "source", "asset_type", "category", "entry_file", "path"):
            if metadata.get(key) is not None and row.get(key) != metadata.get(key):
                errors.append(f"manifest {key} mismatch: {rel}: metadata={metadata.get(key)} manifest={row.get(key)}")

    if entry_path.exists() and entry_path.is_file() and entry_path.suffix == ".xml":
        try:
            root = ET.parse(entry_path).getroot()
            for elem in root.iter():
                file_ref = elem.get("file")
                if file_ref:
                    ref_path = (entry_path.parent / file_ref).resolve()
                    if not ref_path.exists():
                        errors.append(f"missing XML file reference: {entry_path} -> {file_ref}")
        except ET.ParseError as exc:
            errors.append(f"invalid XML: {entry_path}: {exc}")

    return errors


def discover_assets():
    assets_root = ROOT / "assets"
    return sorted(p.parent for p in assets_root.rglob("metadata.yaml"))


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("asset_dir", nargs="?")
    parser.add_argument("--all", action="store_true")
    args = parser.parse_args()

    manifest = load_manifest()

    if args.all:
        asset_dirs = discover_assets()
    elif args.asset_dir:
        asset_dirs = [Path(args.asset_dir)]
    else:
        parser.error("provide asset_dir or --all")

    all_errors = []
    for asset_dir in asset_dirs:
        errors = validate_one(Path(asset_dir), manifest)
        if errors:
            all_errors.extend(errors)

    if all_errors:
        for error in all_errors:
            print(f"ERROR: {error}", file=sys.stderr)
        return 1

    print(f"validated_assets={len(asset_dirs)}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())