@glossarist/concept-browser 0.7.115 → 0.7.117

package/scripts/migrate-v1-to-v3.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+// scripts/migrate-v1-to-v3.ts
+import fs from "fs";
+import path from "path";
+function isV1PartitiveRelation(rel) {
+  return rel && Array.isArray(rel.parts);
+}
+function migrateRelation(rel) {
+  if (!isV1PartitiveRelation(rel)) return null;
+  return {
+    comprehensive: rel.comprehensive,
+    completeness: rel.enumeration === "open" ? "partial" : rel.enumeration === "closed" || rel.enumeration == null ? "complete" : rel.enumeration,
+    partitives: (rel.parts ?? []).map((p) => ({
+      ref: p,
+      certainty: "confirmed"
+    })),
+    ...rel.content ? { content: rel.content } : {}
+  };
+}
+function migrateConceptData(data) {
+  if (!data?.partitive_relations?.length) return null;
+  const migrated = data.partitive_relations.map(migrateRelation).filter((r) => r !== null);
+  if (migrated.length === 0) return null;
+  return { ...data, partitive_relations: migrated };
+}
+function isAlreadyMigrated(content) {
+  return Boolean(content?.data?.partitive_relations?.some?.((rel) => Array.isArray(rel.partitives)));
+}
+function walkFiles(input) {
+  const stat = fs.statSync(input);
+  if (stat.isFile()) return [input];
+  const out = [];
+  for (const entry of fs.readdirSync(input, { withFileTypes: true })) {
+    const full = path.join(input, entry.name);
+    if (entry.isDirectory()) out.push(...walkFiles(full));
+    else if (entry.isFile() && /\.(ya?ml)$/i.test(entry.name)) out.push(full);
+  }
+  return out;
+}
+async function loadYamlModule() {
+  try {
+    return await import("js-yaml");
+  } catch {
+    return null;
+  }
+}
+function outputPath(input, file, outRoot) {
+  const stat = fs.statSync(input);
+  if (stat.isFile()) return outRoot;
+  const rel = path.relative(input, file);
+  return path.join(outRoot, rel);
+}
+async function migrateFile(input, file, options, yaml) {
+  const raw = fs.readFileSync(file, "utf8");
+  const parsed = yaml ? yaml.load(raw) : JSON.parse(raw);
+  if (!parsed?.data) return { changed: false };
+  if (isAlreadyMigrated(parsed)) return { changed: false, skipped: true };
+  const migrated = migrateConceptData(parsed.data);
+  if (!migrated) return { changed: false };
+  parsed.data = { ...parsed.data, ...migrated };
+  const out = outputPath(input, file, options.out);
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  const outText = yaml ? yaml.dump(parsed) : JSON.stringify(parsed, null, 2);
+  if (!options.dryRun) fs.writeFileSync(out, outText);
+  return { changed: true, out, in: file };
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const opts = { in: null, out: null, dryRun: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--in") opts.in = args[++i];
+    else if (a === "--out") opts.out = args[++i];
+    else if (a === "--dry-run") opts.dryRun = true;
+    else if (!opts.in) opts.in = a;
+    else if (!opts.out) opts.out = a;
+  }
+  if (!opts.in) {
+    console.error("Usage: node scripts/migrate-v1-to-v3.mjs --in <dir|file> [--out <dir|file>] [--dry-run]");
+    process.exit(1);
+  }
+  if (!opts.out) opts.out = opts.dryRun ? opts.in : `${opts.in}.v3`;
+  const yaml = await loadYamlModule();
+  if (!yaml) {
+    console.error("js-yaml is required; install via npm install js-yaml");
+    process.exit(1);
+  }
+  const files = walkFiles(opts.in);
+  let changed = 0, skipped = 0, total = 0;
+  for (const f of files) {
+    total++;
+    const res = await migrateFile(opts.in, f, opts, yaml);
+    if (res.changed) {
+      changed++;
+      console.log(`\u2713 ${res.in} \u2192 ${res.out}`);
+    } else if (res.skipped) {
+      skipped++;
+    }
+  }
+  console.log(`
+${changed} migrated, ${skipped} skipped (already v3), ${total - changed - skipped} unchanged.`);
+  if (opts.dryRun) console.log("(dry-run \u2014 no files written)");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+export {
+  isAlreadyMigrated,
+  isV1PartitiveRelation,
+  migrateConceptData,
+  migrateRelation
+};

package/scripts/normalize-yaml.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+// scripts/normalize-yaml.ts
+import { readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, extname, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+var YAML_EXTS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+function walk(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    if (SKIP_DIRS.has(entry)) continue;
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      out.push(...walk(full));
+    } else if (YAML_EXTS.has(extname(entry))) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function normalizeYaml({ root = ROOT, check = false, paths = [] } = {}) {
+  const searchDirs = paths.length > 0 ? paths.map((p) => join(root, p)) : [join(root, ".datasets")];
+  const files = [];
+  for (const dir of searchDirs) {
+    try {
+      statSync(dir);
+    } catch {
+      continue;
+    }
+    files.push(...walk(dir));
+  }
+  files.sort();
+  let checked = 0;
+  let nonNfc = 0;
+  const fixed = [];
+  for (const file of files) {
+    const original = readFileSync(file, "utf8");
+    checked++;
+    if (!isNfc(original)) {
+      nonNfc++;
+      if (!check) {
+        writeFileSync(file, original.normalize("NFC"), "utf8");
+        fixed.push(relative(root, file));
+      } else {
+        fixed.push(relative(root, file));
+      }
+    }
+  }
+  return { checked, nonNfc, fixed, check };
+}
+function isNfc(s) {
+  return s === s.normalize("NFC");
+}
+function main() {
+  const args = process.argv.slice(2);
+  const check = args.includes("--check");
+  const paths = args.filter((a) => !a.startsWith("-") && a !== "normalize");
+  const { checked, nonNfc, fixed } = normalizeYaml({ check, paths });
+  if (check) {
+    if (nonNfc === 0) {
+      process.stdout.write(`NFC OK: ${checked} file(s) checked, all normalized
+`);
+      return;
+    }
+    process.stderr.write(`NFC check failed: ${nonNfc} of ${checked} file(s) are not NFC-normalized
+
+`);
+    for (const f of fixed) {
+      process.stderr.write(`  ${f}
+`);
+    }
+    process.exit(1);
+  } else {
+    if (nonNfc === 0) {
+      process.stdout.write(`NFC OK: ${checked} file(s) checked, all already normalized
+`);
+      return;
+    }
+    process.stdout.write(`Normalized ${nonNfc} of ${checked} file(s)
+`);
+    for (const f of fixed) {
+      process.stdout.write(`  ${f}
+`);
+    }
+  }
+}
+var isDirectEntry = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isDirectEntry) {
+  main();
+}
+export {
+  normalizeYaml
+};

package/scripts/process-about-pages.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+// scripts/process-about-pages.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { join, basename, extname, resolve as resolve2 } from "node:path";
+import { cwd } from "node:process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// 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 };
+}
+
+// scripts/process-about-pages.ts
+function loadSiteConfigForAbout() {
+  try {
+    const { config } = loadSiteConfig([]);
+    return config;
+  } catch {
+    return null;
+  }
+}
+function roots() {
+  const ROOT = cwd();
+  return {
+    ROOT,
+    PUBLIC_PAGES: join(ROOT, "public", "pages"),
+    DATASETS_DIR: join(ROOT, ".datasets"),
+    GROUPS_CONTENT_DIR: join(ROOT, "site-content", "groups")
+  };
+}
+function renderMarkdown(text) {
+  const lines = text.split("\n");
+  const html = [];
+  let inList = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      continue;
+    }
+    if (/^#{1}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h1>${inline(trimmed.replace(/^#\s/, ""))}</h1>`);
+    } else if (/^#{2}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h2>${inline(trimmed.replace(/^##\s/, ""))}</h2>`);
+    } else if (/^#{3}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h3>${inline(trimmed.replace(/^###\s/, ""))}</h3>`);
+    } else if (/^[-*]\s/.test(trimmed)) {
+      if (!inList) {
+        html.push("<ul>");
+        inList = true;
+      }
+      html.push(`<li>${inline(trimmed.replace(/^[-*]\s/, ""))}</li>`);
+    } else {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<p>${inline(trimmed)}</p>`);
+    }
+  }
+  if (inList) html.push("</ul>");
+  return html.join("\n");
+}
+function inline(text) {
+  return text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>").replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2">$1</a>').replace(/`(.+?)`/g, "<code>$1</code>");
+}
+function processAboutDir(sourceDir, outputPrefix, publicPagesDir) {
+  if (!existsSync2(sourceDir)) return 0;
+  let count = 0;
+  for (const file of readdirSync(sourceDir)) {
+    const fullPath = join(sourceDir, file);
+    if (!statSync(fullPath).isFile()) continue;
+    const ext = extname(file);
+    if (ext !== ".md" && ext !== ".adoc" && ext !== ".html") continue;
+    const base = basename(file, ext);
+    const langMatch = base.match(/^about\.(\w+)$/);
+    const lang = langMatch ? langMatch[1] : "eng";
+    const outputName = lang === "eng" ? `${outputPrefix}.json` : `${outputPrefix}.${lang}.json`;
+    const raw = readFileSync2(fullPath, "utf8");
+    let html;
+    let title;
+    if (ext === ".html") {
+      html = raw;
+      const titleMatch = raw.match(/<h1[^>]*>(.+?)<\/h1>/);
+      title = titleMatch ? titleMatch[1] : "About";
+    } else if (ext === ".md") {
+      html = renderMarkdown(raw);
+      const titleMatch = raw.match(/^#\s+(.+)$/m);
+      title = titleMatch ? titleMatch[1] : "About";
+    } else {
+      html = `<p>${raw.split("\n").filter((l) => l.trim() && !l.startsWith("=")).join("</p>\n<p>")}</p>`;
+      const titleMatch = raw.match(/^=\s+(.+)$/m);
+      title = titleMatch ? titleMatch[1] : "About";
+    }
+    const output = { title, html };
+    mkdirSync(publicPagesDir, { recursive: true });
+    writeFileSync(join(publicPagesDir, outputName), JSON.stringify(output));
+    count++;
+    console.log(`  Compiled: ${file} \u2192 public/pages/${outputName}`);
+  }
+  return count;
+}
+function main() {
+  const { ROOT, PUBLIC_PAGES, DATASETS_DIR, GROUPS_CONTENT_DIR } = roots();
+  mkdirSync(PUBLIC_PAGES, { recursive: true });
+  let total = 0;
+  const siteConfig = loadSiteConfigForAbout();
+  const localPathMap = /* @__PURE__ */ new Map();
+  for (const ds of siteConfig?.datasets || []) {
+    if (ds.id && ds.localPath) {
+      localPathMap.set(ds.id, resolve2(ROOT, ds.localPath));
+    }
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  if (existsSync2(DATASETS_DIR)) {
+    for (const dsId of readdirSync(DATASETS_DIR)) {
+      seenIds.add(dsId);
+      const aboutDir = join(DATASETS_DIR, dsId, "about");
+      if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+        console.log(`Processing dataset: ${dsId}`);
+        total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+      }
+    }
+  }
+  for (const [dsId, dsPath] of localPathMap) {
+    if (seenIds.has(dsId)) continue;
+    const aboutDir = join(dsPath, "about");
+    if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+      console.log(`Processing dataset (localPath): ${dsId}`);
+      total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+    }
+  }
+  if (existsSync2(GROUPS_CONTENT_DIR)) {
+    for (const groupId of readdirSync(GROUPS_CONTENT_DIR)) {
+      const aboutDir = join(GROUPS_CONTENT_DIR, groupId, "about");
+      if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+        console.log(`Processing group: ${groupId}`);
+        total += processAboutDir(aboutDir, `group-${groupId}-about`, PUBLIC_PAGES);
+      }
+    }
+  }
+  console.log(total > 0 ? `
+Compiled ${total} about page(s).` : "\nNo about pages found.");
+}
+var isDirectInvocation = process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath2(import.meta.url));
+if (isDirectInvocation) {
+  main();
+}
+export {
+  loadSiteConfigForAbout,
+  main,
+  processAboutDir,
+  renderMarkdown,
+  roots
+};

package/scripts/sync-concept-model.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+// scripts/sync-concept-model.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+var ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var OUT_DIR = resolve(ROOT, "data", "concept-model");
+var REPO = "glossarist/concept-model";
+function parseArgs(argv) {
+  const out = { ref: null };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--ref") out.ref = argv[++i];
+    else if (!a.startsWith("--")) out.ref = a;
+  }
+  return out;
+}
+function latestTag() {
+  return execSync(`gh api repos/${REPO}/releases/latest --jq .tag_name`, { encoding: "utf8" }).trim();
+}
+function fetchFile(ref2, path) {
+  const url = `https://raw.githubusercontent.com/${REPO}/${ref2}/${path}`;
+  return execSync(`curl -fsSL ${url}`, { encoding: "utf8" });
+}
+var args = parseArgs(process.argv);
+var ref = args.ref || latestTag();
+if (!ref) {
+  console.error("Could not determine concept-model ref to sync.");
+  process.exit(1);
+}
+console.log(`Syncing from ${REPO}@${ref}`);
+mkdirSync(resolve(OUT_DIR, "shapes"), { recursive: true });
+function fetchAny(ref2, candidates) {
+  for (const p of candidates) {
+    try {
+      return fetchFile(ref2, p);
+    } catch (e) {
+    }
+  }
+  throw new Error(`Could not fetch any of: ${candidates.join(", ")}`);
+}
+var targets = {
+  "glossarist.context.jsonld": ["ontologies/glossarist.context.jsonld", "glossarist.context.jsonld"],
+  "glossarist.ttl": ["ontologies/glossarist.ttl", "glossarist.ttl"],
+  "prefixes.ttl": ["ontologies/prefixes.ttl"],
+  "shapes/glossarist.shacl.ttl": ["ontologies/shapes/glossarist.shacl.ttl", "shapes/glossarist.shacl.ttl"]
+};
+var updated = 0;
+for (const [outPath, candidates] of Object.entries(targets)) {
+  const content = fetchAny(ref, candidates);
+  writeFileSync(resolve(OUT_DIR, outPath), content);
+  console.log(`  \u2713 ${outPath} (${content.length} bytes)`);
+  updated++;
+}
+writeFileSync(
+  resolve(OUT_DIR, "SOURCE.json"),
+  JSON.stringify({ repo: REPO, ref, syncedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
+);
+console.log(`
+Synced ${updated} file(s) from ${REPO}@${ref}.`);
+console.log("Review the diff, then commit.");

package/scripts/validate-shacl.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+// scripts/validate-shacl.ts
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, extname, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Parser as N3Parser } from "n3";
+import rdfDataset from "@rdfjs/dataset";
+import { validateShacl } from "glossarist/rdf/shacl";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var VENDORED_SHAPES = resolve(__dirname, "..", "data", "concept-model", "shapes", "glossarist.shacl.ttl");
+var createDataset = rdfDataset.dataset.bind(rdfDataset);
+function parseArgs(argv) {
+  const out = { dataRoot: "public/data", shapesPath: null };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--shapes") {
+      out.shapesPath = argv[++i];
+      if (!out.shapesPath) throw new Error("--shapes requires a path argument");
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      out.dataRoot = arg;
+    }
+  }
+  if (process.env.SHAPES_PATH && !out.shapesPath) {
+    out.shapesPath = process.env.SHAPES_PATH;
+  }
+  return out;
+}
+var USAGE = `Usage: validate-shacl.mjs [options] [data-root]
+
+Options:
+  --shapes <path>   Path to a SHACL shapes .ttl file (overrides the default
+                    vendored shapes under data/concept-model/shapes/).
+  --help, -h        Show this help.
+
+Environment:
+  SHAPES_PATH       Same as --shapes. Lower priority than the CLI flag.
+
+Default data-root is public/data.
+`;
+function resolveShapesPath(cliPath) {
+  if (cliPath) return cliPath;
+  if (!statSync(VENDORED_SHAPES, { throwIfNoEntry: false })) {
+    throw new Error(
+      `Vendored SHACL shapes not found at ${VENDORED_SHAPES}.
+Run \`npm run sync:model\` to fetch them from glossarist/concept-model, or pass --shapes <path>, or set SHAPES_PATH=<path>.`
+    );
+  }
+  return VENDORED_SHAPES;
+}
+function parseTurtle(text, baseIri) {
+  const parser = new N3Parser({ baseIRI: baseIri });
+  const out = createDataset();
+  return new Promise((resolve2, reject) => {
+    parser.parse(text, (err, quad) => {
+      if (err) reject(err);
+      else if (quad) out.add(quad);
+      else resolve2(out);
+    });
+  });
+}
+function* walkTtl(dir) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) yield* walkTtl(full);
+    else if (extname(full) === ".ttl") yield full;
+  }
+}
+function formatViolation(v) {
+  const focus = v.focusNode?.value ?? "(unknown)";
+  const shape = v.shape?.value ?? "(unknown)";
+  const path = v.path?.value ?? "";
+  const message = v.message && v.message.length > 0 ? v.message.map((m) => m.value).join("; ") : "(no message)";
+  const pathPart = path ? `
+    path:    ${path}` : "";
+  return `    shape:   ${shape}${pathPart}
+    node:    ${focus}
+    message: ${message}`;
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  const shapesPath = resolveShapesPath(args.shapesPath);
+  let shapesDataset;
+  try {
+    const shapesText = readFileSync(shapesPath, "utf8");
+    shapesDataset = await parseTurtle(shapesText, `file://${shapesPath}`);
+  } catch (e) {
+    console.error(`Failed to load SHACL shapes from ${shapesPath}: ${e.message}`);
+    process.exit(2);
+  }
+  let statDir;
+  try {
+    statDir = statSync(args.dataRoot);
+  } catch (e) {
+    console.error(`Data root not found: ${args.dataRoot}`);
+    process.exit(2);
+  }
+  if (!statDir.isDirectory()) {
+    console.error(`Data root is not a directory: ${args.dataRoot}`);
+    process.exit(2);
+  }
+  const files = [...walkTtl(args.dataRoot)];
+  if (files.length === 0) {
+    console.log(`No .ttl files under ${args.dataRoot} \u2014 SHACL gate skipped.`);
+    return;
+  }
+  const violations = [];
+  for (const path of files) {
+    let graph;
+    try {
+      const text = readFileSync(path, "utf8");
+      graph = await parseTurtle(text, `file://${path}`);
+    } catch (e) {
+      violations.push({ path, parseError: e.message });
+      continue;
+    }
+    const report = await validateShacl(graph, { shapes: shapesDataset });
+    if (!report.conforms) {
+      for (const v of report.results) {
+        violations.push({ path, result: v });
+      }
+    }
+  }
+  if (violations.length === 0) {
+    console.log(`SHACL validation passed \u2014 ${files.length} file(s) conform.`);
+    return;
+  }
+  console.error(`SHACL validation FAILED \u2014 ${violations.length} violation(s) in ${files.length} file(s):
+`);
+  let currentPath = null;
+  for (const v of violations) {
+    if (v.path !== currentPath) {
+      currentPath = v.path;
+      console.error(`
+  ${v.path}`);
+    }
+    if (v.parseError) {
+      console.error(`    PARSE ERROR: ${v.parseError}`);
+    } else {
+      console.error(formatViolation(v.result));
+    }
+  }
+  console.error("");
+  process.exit(1);
+}
+main().catch((e) => {
+  console.error(`validate-shacl: unexpected error: ${e.stack ?? e}`);
+  process.exit(2);
+});