@glossarist/concept-browser 0.7.115 → 0.7.116

package/scripts/generate-ontology-data.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+// scripts/generate-ontology-data.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var ROOT = resolve(__dirname, "..");
+var TAXONOMY_DIR = resolve(ROOT, "data", "concept-model", "taxonomies");
+var OUTPUT = resolve(ROOT, "src", "data", "taxonomies.json");
+function parseTurtle(text) {
+  const cleaned = text.replace(/#[^\n]*/g, "");
+  const subjectBlocks = splitSubjects(cleaned);
+  const concepts = {};
+  let scheme = null;
+  let schemeLabel = null;
+  let schemeDefinition = null;
+  for (const block of subjectBlocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    const subjectMatch = trimmed.match(/^([^\s]+)\s+a\s+(.+?)(?:\s*[;.,]|$)/s);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+    const types = subjectMatch[2];
+    const isScheme = /\bskos:ConceptScheme\b/.test(types);
+    const isConcept = /\bskos:Concept\b/.test(types);
+    if (isScheme) {
+      scheme = subject;
+      schemeLabel = findLiteral(trimmed, "skos:prefLabel");
+      schemeDefinition = findLiteral(trimmed, "skos:definition");
+    }
+    if (isConcept && !isScheme) {
+      const id = subject.includes("/") ? subject.split("/").pop() : subject;
+      const prefLabel = findLiteral(trimmed, "skos:prefLabel");
+      const altLabel = findLiteral(trimmed, "skos:altLabel");
+      const definition = findLiteral(trimmed, "skos:definition");
+      const broader = findResource(trimmed, "skos:broader");
+      concepts[id] = {
+        id,
+        iri: subject,
+        prefLabel: prefLabel || id,
+        ...altLabel && { altLabel },
+        ...definition && { definition },
+        ...broader && { broader }
+      };
+    }
+  }
+  return { scheme, schemeLabel, schemeDefinition, concepts };
+}
+function splitSubjects(text) {
+  const blocks = [];
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"') {
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "[") depth++;
+    if (ch === "]") depth--;
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (depth === 0 && ch === "." && start >= 0) {
+      blocks.push(text.slice(start, i));
+      start = -1;
+    } else if (start < 0 && ch === "\n") {
+      const rest = text.slice(i).trimStart();
+      if (rest && !rest.startsWith("#")) {
+        start = i + 1;
+      }
+    } else if (start < 0 && /[^\s]/.test(ch)) {
+      start = i;
+    }
+  }
+  return blocks;
+}
+function findLiteral(block, predicate) {
+  const tripleQuoted = new RegExp(predicate + '\\s+"""([^"]*?)"""@en');
+  let m = block.match(tripleQuoted);
+  if (m) return m[1].replace(/\s+/g, " ").trim();
+  const singleQuoted = new RegExp(predicate + '\\s+"([^"]*?)"@en');
+  m = block.match(singleQuoted);
+  return m ? m[1].replace(/\s+/g, " ").trim() : null;
+}
+function findResource(block, predicate) {
+  const re = new RegExp(predicate + "\\s+([^\\s,;]+)");
+  const m = block.match(re);
+  if (!m) return null;
+  const val = m[1].replace(/[;.]+$/, "");
+  return val.includes("/") ? val.split("/").pop() : val;
+}
+var TAXONOMY_MAP = {
+  "concept-status.ttl": "conceptStatus",
+  "entry-status.ttl": "entryStatus",
+  "normative-status.ttl": "normativeStatus",
+  "source-type.ttl": "sourceType",
+  "source-status.ttl": "sourceStatus",
+  "relationship-type.ttl": "relationshipType",
+  "designation-type.ttl": "designationType",
+  "term-type.ttl": "termType",
+  "grammar-gender.ttl": "grammarGender",
+  "grammar-number.ttl": "grammarNumber"
+};
+function main() {
+  if (!existsSync(TAXONOMY_DIR)) {
+    console.error(`Taxonomy directory not found: ${TAXONOMY_DIR}`);
+    console.error("Run `npm run sync:model` to vendor concept-model data.");
+    process.exit(1);
+  }
+  const result = {};
+  for (const [filename, key] of Object.entries(TAXONOMY_MAP)) {
+    const filepath = join(TAXONOMY_DIR, filename);
+    if (!existsSync(filepath)) {
+      console.warn(`  Skipping ${filename} (not found)`);
+      continue;
+    }
+    const text = readFileSync(filepath, "utf-8");
+    const parsed = parseTurtle(text);
+    result[key] = {
+      scheme: parsed.scheme,
+      schemeLabel: parsed.schemeLabel,
+      schemeDefinition: parsed.schemeDefinition,
+      concepts: parsed.concepts
+    };
+    const count = Object.keys(parsed.concepts).length;
+    console.log(`  ${key}: ${count} concepts`);
+  }
+  mkdirSync(dirname(OUTPUT), { recursive: true });
+  writeFileSync(OUTPUT, JSON.stringify(result, null, 2) + "\n");
+  console.log(`
+Wrote ${OUTPUT}`);
+  console.log(`Total taxonomies: ${Object.keys(result).length}`);
+}
+main();

package/scripts/generate-ontology-schema.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+
+// scripts/generate-ontology-schema.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var ROOT = resolve(__dirname, "..");
+var CONCEPT_MODEL = resolve(ROOT, "data", "concept-model");
+var ONTOLOGY_TTL = resolve(CONCEPT_MODEL, "glossarist.ttl");
+var SHACL_TTL = resolve(CONCEPT_MODEL, "shapes", "glossarist.shacl.ttl");
+var OUTPUT = resolve(ROOT, "src", "data", "ontology-schema.json");
+var KNOWN_PREFIXES = {
+  gloss: "https://www.glossarist.org/ontologies/",
+  owl: "http://www.w3.org/2002/07/owl#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  xl: "http://www.w3.org/2008/05/skos-xl#",
+  "iso-thes": "http://purl.org/iso25964/skos-thes#",
+  dcterms: "http://purl.org/dc/terms/",
+  prov: "http://www.w3.org/ns/prov#",
+  xsd: "http://www.w3.org/2001/XMLSchema#",
+  sh: "http://www.w3.org/ns/shacl#",
+  vann: "http://purl.org/vocab/vann/"
+};
+function expandPrefixed(term) {
+  for (const [prefix, uri] of Object.entries(KNOWN_PREFIXES)) {
+    if (term.startsWith(prefix + ":")) {
+      return uri + term.slice(prefix.length + 1);
+    }
+  }
+  return term;
+}
+function compactIri(iri) {
+  for (const [prefix, uri] of Object.entries(KNOWN_PREFIXES)) {
+    if (iri.startsWith(uri)) {
+      return prefix + ":" + iri.slice(uri.length);
+    }
+  }
+  return iri;
+}
+function splitSubjectBlocks(text) {
+  const blocks = [];
+  let depth = 0;
+  let start = -1;
+  let inTripleQuote = false;
+  let inUri = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inTripleQuote) {
+      if (ch === '"' && text.slice(i, i + 3) === '"""') {
+        inTripleQuote = false;
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === '"' && text.slice(i, i + 3) === '"""') {
+      inTripleQuote = true;
+      i += 2;
+      continue;
+    }
+    if (ch === '"') {
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (inUri) {
+      if (ch === ">") inUri = false;
+      continue;
+    }
+    if (ch === "<") {
+      inUri = true;
+      if (start < 0) start = i;
+      continue;
+    }
+    if (ch === "[" || ch === "(") depth++;
+    if (ch === "]" || ch === ")") depth--;
+    if (!inUri && depth === 0 && ch === ".") {
+      if (start >= 0) {
+        blocks.push(text.slice(start, i));
+        start = -1;
+      }
+    } else if (start < 0 && /\S/.test(ch)) {
+      start = i;
+    }
+  }
+  return blocks;
+}
+function extractLiteral(block, predicate) {
+  const tripleQuoted = new RegExp(predicate + '\\s+"""([^]*?)"""@en');
+  let m = block.match(tripleQuoted);
+  if (m) return m[1].replace(/\s+/g, " ").trim();
+  const singleQuoted = new RegExp(predicate + '\\s+"([^"]*?)"@en');
+  m = block.match(singleQuoted);
+  if (m) return m[1];
+  const plain = new RegExp(predicate + '\\s+"""([^]*?)"""');
+  m = block.match(plain);
+  if (m) return m[1].replace(/\s+/g, " ").trim();
+  const plainSingle = new RegExp(predicate + '\\s+"([^"]*?)"');
+  m = block.match(plainSingle);
+  return m ? m[1] : null;
+}
+function extractResource(block, predicate) {
+  const re = new RegExp(predicate + "\\s+([^\\s,;]+)");
+  const m = block.match(re);
+  if (!m) return null;
+  let val = m[1].replace(/[;.]+$/, "");
+  if (val === "a") return null;
+  return val;
+}
+function preprocessTtl(ttlText) {
+  const lines = ttlText.split("\n");
+  const filtered = lines.filter((l) => !l.trimStart().startsWith("@prefix") && !l.trimStart().startsWith("@base"));
+  const text = filtered.join("\n");
+  let result = "";
+  let inTriple = false;
+  let inSingle = false;
+  let inUri = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inTriple) {
+      result += ch;
+      if (ch === '"' && text.slice(i, i + 3) === '"""') {
+        result += text.slice(i + 1, i + 3);
+        i += 2;
+        inTriple = false;
+      }
+      continue;
+    }
+    if (inSingle) {
+      result += ch;
+      if (ch === "\\") {
+        result += text[i + 1];
+        i++;
+        continue;
+      }
+      if (ch === '"') inSingle = false;
+      continue;
+    }
+    if (inUri) {
+      result += ch;
+      if (ch === ">") inUri = false;
+      continue;
+    }
+    if (ch === '"' && text.slice(i, i + 3) === '"""') {
+      result += '"""';
+      inTriple = true;
+      i += 2;
+      continue;
+    }
+    if (ch === '"') {
+      result += ch;
+      inSingle = true;
+      continue;
+    }
+    if (ch === "<") {
+      result += ch;
+      inUri = true;
+      continue;
+    }
+    if (ch === "#") {
+      while (i < text.length && text[i] !== "\n") i++;
+      if (i < text.length) result += "\n";
+      continue;
+    }
+    result += ch;
+  }
+  return result;
+}
+function parseOntology(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+  const classes = [];
+  const properties = [];
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    const subjectMatch = trimmed.match(/^([^\s]+)/);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+    if (subject.includes("glossarist>") && !subject.startsWith("gloss:")) continue;
+    const typeMatch = trimmed.match(/\ba\s+(.+?)(?:\s*[;.\n]|$)/);
+    if (!typeMatch) continue;
+    const typeStr = typeMatch[1];
+    const isClass = /\bowl:Class\b/.test(typeStr);
+    const isObjectProperty = /\bowl:ObjectProperty\b/.test(typeStr);
+    const isDatatypeProperty = /\bowl:DatatypeProperty\b/.test(typeStr);
+    if (!isClass && !isObjectProperty && !isDatatypeProperty) continue;
+    const label = extractLiteral(trimmed, "rdfs:label");
+    const comment = extractLiteral(trimmed, "rdfs:comment");
+    const iri = expandPrefixed(subject);
+    const compact = compactIri(iri);
+    if (isClass) {
+      const subClassOf = extractResource(trimmed, "rdfs:subClassOf");
+      const disjointWith = extractResource(trimmed, "owl:disjointWith");
+      classes.push({
+        iri,
+        compact,
+        label: label || subject.replace("gloss:", ""),
+        comment,
+        subClassOf: subClassOf ? compactIri(expandPrefixed(subClassOf)) : null,
+        disjointWith: disjointWith ? compactIri(expandPrefixed(disjointWith)) : null
+      });
+    } else {
+      const domain = extractResource(trimmed, "rdfs:domain");
+      const range = extractResource(trimmed, "rdfs:range");
+      const inverseOf = extractResource(trimmed, "owl:inverseOf");
+      let domainUnion = null;
+      let rangeUnion = null;
+      const unionDomainMatch = trimmed.match(/rdfs:domain\s+\[\s*a\s+owl:Class\s*;\s*owl:unionOf\s*\(([^)]+)\)\s*\]/);
+      if (unionDomainMatch) {
+        domainUnion = unionDomainMatch[1].trim().split(/\s+/).map((t) => compactIri(expandPrefixed(t)));
+      }
+      const unionRangeMatch = trimmed.match(/rdfs:range\s+\[\s*a\s+owl:Class\s*;\s*owl:unionOf\s*\(([^)]+)\)\s*\]/);
+      if (unionRangeMatch) {
+        rangeUnion = unionRangeMatch[1].trim().split(/\s+/).map((t) => compactIri(expandPrefixed(t)));
+      }
+      properties.push({
+        iri,
+        compact,
+        label: label || subject.replace("gloss:", ""),
+        comment,
+        type: isObjectProperty ? "object" : "datatype",
+        domain: domain ? compactIri(expandPrefixed(domain)) : null,
+        domainUnion,
+        range: range ? compactIri(expandPrefixed(range)) : null,
+        rangeUnion,
+        inverseOf: inverseOf ? compactIri(expandPrefixed(inverseOf)) : null
+      });
+    }
+  }
+  return { classes, properties };
+}
+function buildClassHierarchy(classes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const c of classes) {
+    map.set(c.compact, c);
+    c.children = [];
+    c.ancestors = [];
+  }
+  for (const c of classes) {
+    if (c.subClassOf && map.has(c.subClassOf)) {
+      map.get(c.subClassOf).children.push(c.compact);
+    }
+  }
+  for (const c of classes) {
+    const chain = [];
+    let current = c.subClassOf;
+    while (current && map.has(current)) {
+      chain.push(current);
+      current = map.get(current).subClassOf;
+    }
+    if (current) chain.push(current);
+    c.ancestors = chain;
+  }
+  const roots = classes.filter((c) => !c.subClassOf || !map.has(c.subClassOf)).map((c) => c.compact);
+  return { roots, map: Object.fromEntries(map) };
+}
+function groupPropertiesByDomain(properties) {
+  const groups = {};
+  for (const p of properties) {
+    const domains = p.domainUnion || (p.domain ? [p.domain] : ["(unspecified)"]);
+    for (const d of domains) {
+      if (!groups[d]) groups[d] = { object: [], datatype: [] };
+      groups[d][p.type].push(p.compact);
+    }
+  }
+  return groups;
+}
+function extractPropertyBlocks(shapeBlock) {
+  const blocks = [];
+  const re = /sh:property\s+\[/g;
+  let match;
+  while ((match = re.exec(shapeBlock)) !== null) {
+    const start = match.index + match[0].length - 1;
+    let depth = 1;
+    let i = start + 1;
+    while (i < shapeBlock.length && depth > 0) {
+      if (shapeBlock[i] === "[") depth++;
+      else if (shapeBlock[i] === "]") depth--;
+      i++;
+    }
+    blocks.push(shapeBlock.slice(start + 1, i - 1));
+  }
+  return blocks;
+}
+function parseConstraint(propBlock) {
+  const c = {};
+  const path = extractResource(propBlock, "sh:path");
+  c.path = path ? compactIri(expandPrefixed(path)) : null;
+  const dt = extractResource(propBlock, "sh:datatype");
+  c.datatype = dt ? compactIri(expandPrefixed(dt)) : null;
+  const cls = extractResource(propBlock, "sh:class");
+  c.class = cls ? compactIri(expandPrefixed(cls)) : null;
+  const vf = extractResource(propBlock, "sh:valuesFrom");
+  c.valuesFrom = vf ? compactIri(expandPrefixed(vf)) : null;
+  const nk = extractResource(propBlock, "sh:nodeKind");
+  c.nodeKind = nk ? compactIri(expandPrefixed(nk)) : null;
+  const minMatch = propBlock.match(/sh:minCount\s+(\d+)/);
+  c.minCount = minMatch ? parseInt(minMatch[1], 10) : null;
+  const maxMatch = propBlock.match(/sh:maxCount\s+(\d+)/);
+  c.maxCount = maxMatch ? parseInt(maxMatch[1], 10) : null;
+  const inMatch = propBlock.match(/sh:in\s*\(([^)]+)\)/);
+  if (inMatch) {
+    c.in = inMatch[1].match(/"([^"]+)"/g)?.map((s) => s.replace(/"/g, "")) || null;
+  } else {
+    c.in = null;
+  }
+  return c;
+}
+function parseShaclShapes(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+  const shapes = [];
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    const subjectMatch = trimmed.match(/^([^\s]+)/);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+    if (!/\ba\s+sh:NodeShape\b/.test(trimmed)) continue;
+    const iri = expandPrefixed(subject);
+    const compact = compactIri(iri);
+    const label = extractLiteral(trimmed, "rdfs:label");
+    const comment = extractLiteral(trimmed, "rdfs:comment");
+    const targetClass = extractResource(trimmed, "sh:targetClass");
+    const propBlocks = extractPropertyBlocks(trimmed);
+    const constraints = propBlocks.map(parseConstraint).filter((c) => c.path);
+    const shapeClassMatch = trimmed.match(/^\s*[^[]*?\ba\s+sh:NodeShape\s[^[]*?sh:class\s+([^\s,;]+)/);
+    const shapeClass = shapeClassMatch ? shapeClassMatch[1].replace(/[;.]+$/, "") : null;
+    shapes.push({
+      iri,
+      compact,
+      label: label || subject.replace("gloss:", "").replace("Shape", ""),
+      comment,
+      targetClass: targetClass ? compactIri(expandPrefixed(targetClass)) : null,
+      shapeClass: shapeClass ? compactIri(expandPrefixed(shapeClass)) : null,
+      constraints
+    });
+  }
+  return shapes;
+}
+var IMPORT_LABELS = {
+  "http://www.w3.org/2004/02/skos/core": "SKOS",
+  "http://www.w3.org/2004/02/skos/core#": "SKOS",
+  "http://www.w3.org/2008/05/skos-xl": "SKOS-XL",
+  "http://www.w3.org/2008/05/skos-xl#": "SKOS-XL",
+  "http://purl.org/iso25964/skos-thes": "ISO 25964",
+  "http://purl.org/iso25964/skos-thes#": "ISO 25964",
+  "http://www.w3.org/ns/prov#": "PROV-O",
+  "http://purl.org/dc/terms/": "Dublin Core Terms"
+};
+function parseOntologyDeclaration(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    if (!/\ba\s+owl:Ontology\b/.test(trimmed)) continue;
+    const subjectMatch = trimmed.match(/^<([^>]+)>/);
+    const iri = subjectMatch ? subjectMatch[1] : null;
+    const label = extractLiteral(trimmed, "rdfs:label") || extractLiteral(trimmed, "dcterms:title");
+    const comment = extractLiteral(trimmed, "rdfs:comment") || extractLiteral(trimmed, "dcterms:description");
+    const prefix = extractLiteral(trimmed, "vann:preferredNamespacePrefix");
+    const nsUri = extractLiteral(trimmed, "vann:preferredNamespaceUri");
+    const license = extractResource(trimmed, "dcterms:license")?.replace(/[<>]/g, "") || null;
+    const created = extractLiteral(trimmed, "dcterms:created");
+    const imports = [];
+    const importRe = /owl:imports\s+<([^>]+)>/g;
+    let im;
+    while ((im = importRe.exec(trimmed)) !== null) {
+      const iri2 = im[1];
+      imports.push({
+        iri: iri2,
+        label: IMPORT_LABELS[iri2] || IMPORT_LABELS[iri2.replace(/#?$/, "#")] || compactIri(iri2)
+      });
+    }
+    return { iri, label, comment, prefix, namespaceUri: nsUri, imports, license, created };
+  }
+  return null;
+}
+function parseAnnotationProperties(ttlText) {
+  const cleaned = preprocessTtl(ttlText);
+  const blocks = splitSubjectBlocks(cleaned);
+  const props = [];
+  for (const block of blocks) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    if (!/\ba\s+owl:AnnotationProperty\b/.test(trimmed)) continue;
+    const subjectMatch = trimmed.match(/^([^\s]+)/);
+    if (!subjectMatch) continue;
+    const subject = subjectMatch[1];
+    const iri = expandPrefixed(subject);
+    const compact = compactIri(iri);
+    const label = extractLiteral(trimmed, "rdfs:label");
+    props.push({ iri, compact, label: label || compact });
+  }
+  return props;
+}
+function main() {
+  if (!existsSync(ONTOLOGY_TTL)) {
+    console.error(`Ontology file not found: ${ONTOLOGY_TTL}`);
+    console.error("Run `npm run sync:model` to vendor from glossarist/concept-model.");
+    process.exit(1);
+  }
+  const ttlText = readFileSync(ONTOLOGY_TTL, "utf-8");
+  const { classes, properties } = parseOntology(ttlText);
+  const hierarchy = buildClassHierarchy(classes);
+  const propsByDomain = groupPropertiesByDomain(properties);
+  let shapes = [];
+  if (existsSync(SHACL_TTL)) {
+    const shaclText = readFileSync(SHACL_TTL, "utf-8");
+    shapes = parseShaclShapes(shaclText);
+  } else {
+    console.warn(`SHACL shapes file not found: ${SHACL_TTL}`);
+  }
+  const ontologyDecl = parseOntologyDeclaration(ttlText);
+  let annotationProps = parseAnnotationProperties(ttlText);
+  if (annotationProps.length === 0) {
+    annotationProps = [
+      { iri: "http://www.w3.org/2000/01/rdf-schema#label", compact: "rdfs:label", label: "label" },
+      { iri: "http://www.w3.org/2000/01/rdf-schema#comment", compact: "rdfs:comment", label: "comment" },
+      { iri: "http://www.w3.org/2000/01/rdf-schema#seeAlso", compact: "rdfs:seeAlso", label: "seeAlso" },
+      { iri: "http://www.w3.org/2000/01/rdf-schema#isDefinedBy", compact: "rdfs:isDefinedBy", label: "isDefinedBy" },
+      { iri: "http://purl.org/dc/terms/title", compact: "dcterms:title", label: "title" },
+      { iri: "http://purl.org/dc/terms/description", compact: "dcterms:description", label: "description" },
+      { iri: "http://purl.org/dc/terms/source", compact: "dcterms:source", label: "source" },
+      { iri: "http://purl.org/dc/terms/license", compact: "dcterms:license", label: "license" },
+      { iri: "http://purl.org/dc/terms/created", compact: "dcterms:created", label: "created" },
+      { iri: "http://purl.org/vocab/vann/preferredNamespacePrefix", compact: "vann:preferredNamespacePrefix", label: "preferredNamespacePrefix" },
+      { iri: "http://purl.org/vocab/vann/preferredNamespaceUri", compact: "vann:preferredNamespaceUri", label: "preferredNamespaceUri" }
+    ];
+  }
+  const shapesByTargetClass = {};
+  for (const s of shapes) {
+    const tc = s.targetClass || "(unspecified)";
+    if (!shapesByTargetClass[tc]) shapesByTargetClass[tc] = [];
+    shapesByTargetClass[tc].push(s.compact);
+  }
+  const output = {
+    ontology: ontologyDecl,
+    ontologyIri: ontologyDecl?.iri || "https://www.glossarist.org/ontologies/glossarist",
+    ontologyLabel: ontologyDecl?.label || "Glossarist Ontology",
+    classes: hierarchy.map,
+    classHierarchyRoots: hierarchy.roots,
+    properties: Object.fromEntries(properties.map((p) => [p.compact, p])),
+    propertiesByDomain: propsByDomain,
+    shapes: Object.fromEntries(shapes.map((s) => [s.compact, s])),
+    shapesByTargetClass,
+    annotationProperties: annotationProps,
+    stats: {
+      classCount: classes.length,
+      objectPropertyCount: properties.filter((p) => p.type === "object").length,
+      datatypePropertyCount: properties.filter((p) => p.type === "datatype").length,
+      shapeCount: shapes.length,
+      annotationPropertyCount: annotationProps.length
+    }
+  };
+  mkdirSync(dirname(OUTPUT), { recursive: true });
+  writeFileSync(OUTPUT, JSON.stringify(output, null, 2) + "\n");
+  console.log(`Parsed ${output.stats.classCount} classes, ${output.stats.objectPropertyCount} object properties, ${output.stats.datatypePropertyCount} datatype properties, ${output.stats.shapeCount} SHACL shapes, ${output.stats.annotationPropertyCount} annotation properties`);
+  if (ontologyDecl) {
+    console.log(`Ontology: ${ontologyDecl.iri}`);
+    console.log(`  imports: ${ontologyDecl.imports.map((i) => i.label).join(", ")}`);
+  }
+  console.log(`Wrote ${OUTPUT}`);
+}
+main();

package/scripts/load-site-config.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+// scripts/load-site-config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import yaml from "js-yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var projectRoot = resolve(__dirname, "..");
+var SNAKE_TO_CAMEL = {
+  // Site-level
+  uri_base: "uriBase",
+  base_path: "basePath",
+  ui_languages: "uiLanguages",
+  dataset_groups: "datasetGroups",
+  dataset_translations: "datasetTranslations",
+  primary_color: "primaryColor",
+  dark_color: "darkColor",
+  owner_name: "ownerName",
+  owner_url: "ownerUrl",
+  powered_by: "poweredBy",
+  footer_nav: "footerNav",
+  footer_logo: "footerLogo",
+  news_dir: "newsDir",
+  // Dataset-level
+  gcr_package: "gcrPackage",
+  source_repo: "sourceRepo",
+  local_path: "localPath",
+  local_light: "localLight",
+  local_dark: "localDark",
+  uri_aliases: "uriAliases",
+  language_order: "languageOrder",
+  ref_aliases: "refAliases",
+  urn_aliases: "urnAliases",
+  existing_site_url: "existingSiteUrl",
+  edition_status: "editionStatus",
+  dataset_uri: "datasetUri",
+  schema_version: "schemaVersion"
+};
+function normalizeKey(key) {
+  if (typeof key !== "string") return key;
+  if (Object.prototype.hasOwnProperty.call(SNAKE_TO_CAMEL, key)) {
+    return SNAKE_TO_CAMEL[key];
+  }
+  if (key.includes("_") && /^[a-z][a-z0-9_]*$/.test(key)) {
+    return key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  }
+  return key;
+}
+function normalizeObject(obj) {
+  if (Array.isArray(obj)) return obj.map(normalizeObject);
+  if (obj && typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[normalizeKey(k)] = normalizeObject(v);
+    }
+    return out;
+  }
+  return obj;
+}
+function findConfigFile(args = []) {
+  if (process.env.SITE_CONFIG) {
+    return resolve(process.env.SITE_CONFIG);
+  }
+  for (const dir of [process.cwd(), projectRoot]) {
+    const p = resolve(dir, "site-config.yml");
+    if (existsSync(p)) return p;
+  }
+  throw new Error("No site config found. Set SITE_CONFIG or create site-config.yml");
+}
+function loadSiteConfig(args = []) {
+  const configPath = findConfigFile(args);
+  const raw = yaml.load(readFileSync(configPath, "utf-8"));
+  const config = normalizeObject(raw);
+  return { config, configPath };
+}
+function getProjectRoot() {
+  return projectRoot;
+}
+export {
+  getProjectRoot,
+  loadSiteConfig
+};