import { readFileSync } from "node:fs";
import { basename } from "node:path";
import yaml from "js-yaml";
import Ajv2020 from "ajv/dist/2020.js";
import addFormats from "ajv-formats";

const ajv = new Ajv2020({ allErrors: true, strict: true });
addFormats(ajv);

const SCHEMA_BY_FILENAME: Record<string, string> = {
  "SKILL.md": "frontmatter-skill-md.schema.json",
  "AGENTS.md": "frontmatter-agents-md.schema.json",
  "MCP-SERVER.md": "frontmatter-mcp-server-md.schema.json",
  "CLAUDE.md": "frontmatter-claude-md.schema.json",
};

function extractFrontmatter(raw: string): { frontmatter: unknown; body: string } {
  // §02-1.1: strip BOM, normalize CRLF→LF
  const normalized = raw.replace(/^/, "").replace(/\r\n/g, "\n");
  if (!normalized.startsWith("---\n")) {
    return { frontmatter: null, body: normalized };
  }
  // Closing fence on its own line, not a horizontal rule mid-body.
  const closingIdx = normalized.indexOf("\n---\n", 4);
  if (closingIdx === -1) {
    throw new Error("unterminated-frontmatter");
  }
  const yamlSrc = normalized.slice(4, closingIdx);
  const body = normalized.slice(closingIdx + 5);
  return { frontmatter: yaml.load(yamlSrc, { schema: yaml.JSON_SCHEMA }), body };
}

function validateArtifact(path: string, schemas: Record<string, object>) {
  const filename = basename(path);
  const schemaPath = SCHEMA_BY_FILENAME[filename];
  if (!schemaPath) {
    throw new Error(`unknown-target: ${filename}`);
  }
  const raw = readFileSync(path, "utf8");
  const { frontmatter } = extractFrontmatter(raw);

  const validate = ajv.compile(schemas[schemaPath]);
  if (!validate(frontmatter)) {
    return { ok: false, errors: validate.errors };
  }

  // Cross-field check (§07-2.1).
  const fm = frontmatter as { metadata?: { mda?: { integrity?: { digest?: string }; signatures?: Array<{ "payload-digest"?: string }> } } };
  const integrity = fm.metadata?.mda?.integrity?.digest;
  const sigs = fm.metadata?.mda?.signatures ?? [];
  for (const sig of sigs) {
    if (sig["payload-digest"] !== integrity) {
      return { ok: false, errors: [{ keyword: "payload-digest-mismatch" }] };
    }
  }

  return { ok: true };
}

from pathlib import Path
import yaml
import jsonschema

SCHEMA_BY_FILENAME = {
    "SKILL.md": "frontmatter-skill-md.schema.json",
    "AGENTS.md": "frontmatter-agents-md.schema.json",
    "MCP-SERVER.md": "frontmatter-mcp-server-md.schema.json",
    "CLAUDE.md": "frontmatter-claude-md.schema.json",
}

def extract_frontmatter(raw: str) -> tuple[dict | None, str]:
    # §02-1.1: BOM strip, CRLF normalize.
    normalized = raw.lstrip("").replace("\r\n", "\n")
    if not normalized.startswith("---\n"):
        return None, normalized
    closing = normalized.find("\n---\n", 4)
    if closing == -1:
        raise ValueError("unterminated-frontmatter")
    yaml_src = normalized[4:closing]
    body = normalized[closing + 5:]
    # YAML 1.2 only (§02-1.1): yes/no/on/off must round-trip as strings.
    return yaml.safe_load(yaml_src), body

def validate_artifact(path: Path, schemas: dict[str, dict]) -> dict:
    schema_key = SCHEMA_BY_FILENAME.get(path.name)
    if schema_key is None:
        raise ValueError(f"unknown-target: {path.name}")
    raw = path.read_text(encoding="utf-8")
    frontmatter, _ = extract_frontmatter(raw)

    try:
        jsonschema.validate(frontmatter, schemas[schema_key])
    except jsonschema.ValidationError as exc:
        return {"ok": False, "error": exc.message}

    mda = (frontmatter or {}).get("metadata", {}).get("mda", {})
    integrity = (mda.get("integrity") or {}).get("digest")
    for sig in mda.get("signatures", []):
        if sig.get("payload-digest") != integrity:
            return {"ok": False, "error": "payload-digest-mismatch"}

    return {"ok": True}

node scripts/validate-conformance.mjs