@glossarist/concept-browser 0.7.115 → 0.7.116

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);
+});

package/scripts/validate-yaml.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// scripts/validate-yaml.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import { join, extname, resolve } from "node:path";
+import { cwd } from "node:process";
+import yaml from "js-yaml";
+var SCHEMA_PATH = join(cwd(), "data", "concept-model", "shapes", "glossarist.concept.yaml.schema.json");
+function loadSchema() {
+  if (!existsSync(SCHEMA_PATH)) {
+    throw new Error(`Schema not found: ${SCHEMA_PATH}`);
+  }
+  return JSON.parse(readFileSync(SCHEMA_PATH, "utf8"));
+}
+function validateValue(value, schema, path, rootSchema, errors) {
+  if (schema.$ref) {
+    const ref = schema.$ref.replace(/^#\/\$defs\//, "");
+    validateValue(value, rootSchema.$defs?.[ref] ?? {}, path, rootSchema, errors);
+    return;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      errors.push({ path, message: `Expected array, got ${typeof value}` });
+      return;
+    }
+    for (let i = 0; i < value.length; i++) {
+      validateValue(value[i], schema.items ?? {}, `${path}[${i}]`, rootSchema, errors);
+    }
+    return;
+  }
+  if (schema.type && typeof value !== schema.type) {
+    errors.push({ path, message: `Expected ${schema.type}, got ${typeof value}` });
+    return;
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    errors.push({ path, message: `"${value}" is not one of [${schema.enum.join(", ")}]` });
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    for (const [key, subSchema] of Object.entries(schema.properties)) {
+      if (value[key] !== void 0) {
+        validateValue(value[key], subSchema, `${path}.${key}`, rootSchema, errors);
+      }
+    }
+    if (schema.required) {
+      for (const req of schema.required) {
+        if (!(req in value)) {
+          errors.push({ path: `${path}.${req}`, message: `Missing required field: ${req}` });
+        }
+      }
+    }
+    if (schema.patternProperties) {
+      for (const [pattern, subSchema] of Object.entries(schema.patternProperties)) {
+        const re = new RegExp(pattern);
+        for (const key of Object.keys(value)) {
+          if (re.test(key) && !(key in (schema.properties ?? {}))) {
+            validateValue(value[key], subSchema, `${path}.${key}`, rootSchema, errors);
+          }
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      validateValue(value[i], schema.items ?? {}, `${path}[${i}]`, rootSchema, errors);
+    }
+  }
+}
+function validateYaml(yamlContent, schema) {
+  const data = yaml.load(yamlContent);
+  const errors = [];
+  if (Array.isArray(data)) {
+    for (let i = 0; i < data.length; i++) {
+      validateValue(data[i], schema, `doc[${i}]`, schema, errors);
+    }
+  } else if (data && typeof data === "object") {
+    validateValue(data, schema, "root", schema, errors);
+  } else {
+    errors.push({ path: "root", message: "YAML must be an object or array of objects" });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function walkYaml(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) out.push(...walkYaml(full));
+    else if ([".yaml", ".yml"].includes(extname(entry))) out.push(full);
+  }
+  return out;
+}
+function main() {
+  const target = process.argv[2];
+  if (!target) {
+    console.error("Usage: validate-yaml <path-to-yaml-or-dir>");
+    process.exit(1);
+  }
+  const schema = loadSchema();
+  const resolvedTarget = resolve(target);
+  if (!existsSync(resolvedTarget)) {
+    console.error(`Path not found: ${resolvedTarget}`);
+    process.exit(1);
+  }
+  const files = statSync(resolvedTarget).isDirectory() ? walkYaml(resolvedTarget) : [resolvedTarget];
+  let totalValid = 0;
+  let totalErrors = 0;
+  for (const file of files) {
+    const content = readFileSync(file, "utf8");
+    const result = validateYaml(content, schema);
+    if (result.valid) {
+      totalValid++;
+    } else {
+      totalErrors += result.errors.length;
+      console.error(`FAIL: ${file}`);
+      for (const err of result.errors) console.error(`  ${err.path}: ${err.message}`);
+    }
+  }
+  console.log(`
+${totalValid}/${files.length} files valid, ${totalErrors} errors`);
+  process.exit(totalErrors > 0 ? 1 : 0);
+}
+var isDirect = process.argv[1] && resolve(process.argv[1]) === fileURLToPathPath();
+function fileURLToPathPath() {
+  return resolve(new URL(import.meta.url).pathname);
+}
+if (isDirect) main();
+export {
+  loadSchema,
+  validateValue,
+  validateYaml
+};

package/src/__tests__/published-package-contract.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..', '..');
+const SCRIPTS_DIR = join(ROOT, 'scripts');
+
+const LIBRARY_SCRIPTS = [
+  'load-site-config',
+  'validate-yaml',
+  'normalize-yaml',
+  'extract-source-refs',
+  'migrate-v1-to-v3',
+];
+
+const PIPELINE_SCRIPTS = [
+  'fetch-datasets',
+  'generate-data',
+  'build-edges',
+  'process-about-pages',
+  'smoke',
+  'generate-ontology-data',
+  'generate-ontology-schema',
+  'doctor',
+  'validate-shacl',
+  'bridge-to-astro',
+  'sync-concept-model',
+  'generate-404',
+];
+
+function runPlain(args: string[], opts?: Parameters<typeof spawnSync>[2]): { status: number | null; stdout: string; stderr: string } {
+  const result = spawnSync('node', args, { encoding: 'utf8', cwd: ROOT, ...opts });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === 'string' ? result.stdout : result.stdout?.toString('utf8') ?? '',
+    stderr: typeof result.stderr === 'string' ? result.stderr : result.stderr?.toString('utf8') ?? '',
+  };
+}
+
+describe('published-package contract — compiled .js scripts load under plain node (no tsx)', () => {
+  it('npm run build:scripts produces .js for every script', () => {
+    const build = spawnSync('node', [join(ROOT, 'scripts', 'build-scripts.mjs')], {
+      encoding: 'utf8',
+      cwd: ROOT,
+    });
+    expect(build.status).toBe(0);
+
+    for (const name of [...LIBRARY_SCRIPTS, ...PIPELINE_SCRIPTS]) {
+      const jsPath = join(SCRIPTS_DIR, `${name}.js`);
+      expect(existsSync(jsPath)).toBe(true);
+    }
+  }, 30000);
+
+  it('library scripts export functions under plain node (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING regression)', () => {
+    for (const name of LIBRARY_SCRIPTS) {
+      const jsPath = `./scripts/${name}.js`;
+      const result = runPlain(['--input-type=module', '-e', `import(${JSON.stringify(jsPath)}).then(m => console.log('OK', Object.keys(m).length)).catch(e => { console.error('FAIL', e.message); process.exit(1); })`]);
+      expect(result.stderr).not.toContain('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING');
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('OK');
+    }
+  }, 60000);
+
+  it('pipeline scripts do not throw ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING (may fail on missing config, that is OK)', () => {
+    for (const name of PIPELINE_SCRIPTS) {
+      const result = runPlain(['--input-type=module', '-e', `import(${JSON.stringify(`./scripts/${name}.js`)}).then(() => console.log('OK')).catch(e => { console.error(e.message); })`]);
+      expect(result.stderr).not.toContain('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING');
+    }
+  }, 60000);
+
+  it('validate-yaml.js exports validateYaml function', () => {
+    const result = runPlain(['--input-type=module', '-e', `
+      import { validateYaml } from './scripts/validate-yaml.js';
+      const schema = { type: 'object', required: ['termid'], properties: { termid: { type: 'string' } } };
+      const r = validateYaml('termid: test', schema);
+      console.log('valid=' + r.valid);
+    `]);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('valid=true');
+  });
+});

package/src/__tests__/scripts-syntax.test.ts

@@ -13,7 +13,7 @@ describe('scripts syntax gate', () => {
     const result = spawnSync(
       process.execPath,
       ['--import', 'tsx', path.join(repoRoot, 'scripts', 'check-syntax.ts')],
-      { encoding: 'utf8' },
+      { encoding: 'utf8', timeout: 60000 },
     );
 
     if (result.status !== 0) {
@@ -24,5 +24,5 @@ describe('scripts syntax gate', () => {
 
     expect(result.status).toBe(0);
     expect(result.stdout).toMatch(/syntax OK:/);
-  });
+  }, 120000);
 });