@glossarist/concept-browser 0.1.0

package/scripts/generate-data.mjs

@@ -0,0 +1,606 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { naturalSort } from 'glossarist';
+import { loadSiteConfig } from './load-site-config.mjs';
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const ROOT = process.cwd();
+const PUBLIC = path.join(ROOT, 'public');
+const DATA = path.join(PUBLIC, 'data');
+
+const DS_PALETTE = [
+  '#3366ff', '#0d9488', '#d97706', '#8b5cf6',
+  '#ec4899', '#059669', '#dc2626', '#6366f1',
+  '#0891b2', '#65a30d',
+];
+
+function readYaml(filePath) {
+  return yaml.load(fs.readFileSync(filePath, 'utf8'));
+}
+
+function loadConceptFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const docs = yaml.loadAll(content, null, { schema: yaml.DEFAULT_SCHEMA });
+
+  if (docs.length === 1 && docs[0].termid !== undefined) {
+    return docs[0];
+  }
+
+  if (docs.length >= 1 && docs[0].data && docs[0].data.identifier !== undefined) {
+    const mc = docs[0];
+    const result = { termid: String(mc.data.identifier) };
+    for (const doc of docs.slice(1)) {
+      if (!doc || !doc.data || !doc.data.language_code) continue;
+      const lang = doc.data.language_code;
+      const lcData = { ...doc.data };
+      delete lcData.language_code;
+      result[lang] = lcData;
+    }
+    return result;
+  }
+
+  return docs[0];
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+function termToDesignation(term) {
+  const doc = {
+    '@type': term.type === 'expression' ? 'gl:Expression'
+      : term.type === 'symbol' ? 'gl:Symbol'
+      : term.type === 'abbreviation' ? 'gl:Abbreviation'
+      : 'gl:Designation',
+    'gl:normativeStatus': term.normative_status || 'preferred',
+    'gl:term': term.designation,
+  };
+  if (term.gender) doc['gl:gender'] = term.gender;
+  if (term.plurality) doc['gl:plurality'] = term.plurality;
+  if (term.international !== undefined) doc['gl:international'] = term.international;
+  return doc;
+}
+
+function defsToJsonLd(defs) {
+  if (!defs || !Array.isArray(defs)) return [];
+  return defs
+    .map(d => ({
+      '@type': 'gl:DetailedDefinition',
+      'gl:content': d.content || '',
+    }))
+    .filter(d => d['gl:content']);
+}
+
+function sourcesToJsonLd(sources) {
+  if (!sources || !Array.isArray(sources)) return [];
+  return sources.map(s => {
+    const doc = { '@type': 'gl:ConceptSource' };
+    if (s.type) doc['gl:sourceType'] = s.type;
+    if (s.status) doc['gl:sourceStatus'] = s.status;
+    if (s.origin) {
+      const origin = { '@type': 'gl:Citation' };
+      if (s.origin.ref) origin['gl:ref'] = s.origin.ref;
+      if (s.origin.clause) origin['gl:clause'] = s.origin.clause;
+      if (s.origin.link) origin['gl:link'] = s.origin.link;
+      doc['gl:origin'] = origin;
+    }
+    return doc;
+  });
+}
+
+function refsToJsonLd(refs) {
+  if (!refs || !Array.isArray(refs)) return [];
+  return refs.map(r => ({
+    '@id': r.id,
+    'gl:term': r.term,
+  })).filter(r => r['@id']);
+}
+
+const LANG_CODES = ['eng', 'ara', 'deu', 'fra', 'spa', 'ita', 'jpn', 'kor', 'pol', 'por', 'srp', 'swe', 'zho', 'rus', 'fin', 'dan', 'nld', 'msa', 'nob', 'nno', 'zho'];
+
+function yamlToJsonLd(conceptYaml, register) {
+  const termid = String(conceptYaml.termid);
+  const doc = {
+    '@context': 'https://glossarist.org/ns/context.jsonld',
+    '@id': `https://glossarist.org/${register}/concept/${termid}`,
+    '@type': 'gl:Concept',
+    'gl:identifier': termid,
+  };
+
+  const localizations = {};
+  for (const lang of LANG_CODES) {
+    const lc = conceptYaml[lang];
+    if (!lc) continue;
+
+    const lDoc = {
+      '@id': `https://glossarist.org/${register}/concept/${termid}/${lang}`,
+      '@type': 'gl:LocalizedConcept',
+      'gl:languageCode': lang,
+    };
+
+    if (lc.entry_status) lDoc['gl:entryStatus'] = lc.entry_status;
+    if (lc.terms && lc.terms.length > 0) lDoc['gl:designation'] = lc.terms.map(termToDesignation);
+    if (lc.definition) lDoc['gl:definition'] = defsToJsonLd(lc.definition);
+    if (lc.notes && lc.notes.length > 0) lDoc['gl:notes'] = defsToJsonLd(lc.notes);
+    if (lc.examples && lc.examples.length > 0) lDoc['gl:examples'] = defsToJsonLd(lc.examples);
+    if (lc.sources && lc.sources.length > 0) lDoc['gl:source'] = sourcesToJsonLd(lc.sources);
+    if (lc.lineage_source_similarity !== undefined) lDoc['gl:lineageSourceSimilarity'] = lc.lineage_source_similarity;
+    if (lc.release) lDoc['gl:release'] = lc.release;
+    if (lc.review_date) lDoc['gl:reviewDate'] = lc.review_date;
+    if (lc.review_decision_date) lDoc['gl:reviewDecisionDate'] = lc.review_decision_date;
+    if (lc.review_decision_event) lDoc['gl:reviewDecisionEvent'] = lc.review_decision_event;
+    if (lc.review_status) lDoc['gl:reviewStatus'] = lc.review_status;
+    if (lc.review_decision) lDoc['gl:reviewDecision'] = lc.review_decision;
+    if (lc.review_decision_notes) lDoc['gl:reviewDecisionNotes'] = lc.review_decision_notes;
+    if (lc.dates && lc.dates.length > 0) {
+      lDoc['gl:dates'] = lc.dates.map(d => ({
+        'gl:dateType': d.type,
+        'gl:date': d.date,
+      }));
+    }
+    if (lc.references && lc.references.length > 0) {
+      lDoc['gl:references'] = refsToJsonLd(lc.references);
+    }
+
+    localizations[lang] = lDoc;
+  }
+
+  if (Object.keys(localizations).length > 0) {
+    doc['gl:localizedConcept'] = localizations;
+  }
+
+  return doc;
+}
+
+function getPrimaryDesignation(conceptYaml) {
+  const descs = {};
+  for (const lang of LANG_CODES) {
+    const lc = conceptYaml[lang];
+    if (lc && lc.terms && lc.terms.length > 0) {
+      const preferredExpr = lc.terms.find(t => t.normative_status === 'preferred' && t.type === 'expression');
+      const preferred = preferredExpr || lc.terms.find(t => t.normative_status === 'preferred') || lc.terms[0];
+      descs[lang] = preferred.designation;
+    }
+  }
+  return descs;
+}
+
+function getGroups(conceptYaml) {
+  if (conceptYaml.eng && conceptYaml.eng.groups) return conceptYaml.eng.groups;
+  const termid = String(conceptYaml.termid);
+  if (/^\d{3}-/.test(termid)) return [termid.substring(0, 3)];
+  if (/^\d+\.\d+\.\d+/.test(termid)) {
+    const parts = termid.split('.');
+    return [`${parts[0]}.${parts[1]}.${parts[2]}`];
+  }
+  return [];
+}
+
+function escapeTurtle(s) {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+
+function conceptJsonToTurtle(concept) {
+  const uri = concept['@id'] || '';
+  const id = concept['gl:identifier'] || '';
+  const lines = [
+    '@prefix skos: <http://www.w3.org/2004/02/skos/core#> .',
+    '@prefix dcterms: <http://purl.org/dc/terms/> .',
+    '',
+  ];
+
+  const props = ['  a skos:Concept'];
+  props.push(`  skos:notation "${escapeTurtle(id)}"`);
+
+  for (const [lang, lc] of Object.entries(concept['gl:localizedConcept'] || {})) {
+    if (lc['gl:designation']) {
+      for (const d of lc['gl:designation']) {
+        const term = d['gl:term'];
+        if (!term) continue;
+        const pred = d['gl:normativeStatus'] === 'preferred' ? 'skos:prefLabel' : 'skos:altLabel';
+        props.push(`  ${pred} "${escapeTurtle(term)}"@${lang}`);
+      }
+    }
+    if (lc['gl:definition']) {
+      for (const d of lc['gl:definition']) {
+        if (d['gl:content']) props.push(`  skos:definition "${escapeTurtle(d['gl:content'])}"@${lang}`);
+      }
+    }
+    if (lc['gl:notes']) {
+      for (const d of lc['gl:notes']) {
+        if (d['gl:content']) props.push(`  skos:scopeNote "${escapeTurtle(d['gl:content'])}"@${lang}`);
+      }
+    }
+  }
+
+  lines.push(`<${uri}>`);
+  lines.push(props.join(' ;\n'));
+  lines.push(' .');
+  return lines.join('\n');
+}
+
+function processDataset(dir, register, opts) {
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.yaml')).sort((a, b) => naturalSort(a.replace('.yaml', ''), b.replace('.yaml', '')));
+
+  console.log(`Processing ${register}: ${files.length} files`);
+
+  const conceptsDir = path.join(DATA, register, 'concepts');
+  const concepts = [];
+  const langTermCounts = {};
+  const langDefCounts = {};
+  const availableFormats = ['ttl', 'yaml'];
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    try {
+      const conceptYaml = loadConceptFile(path.join(dir, file));
+      if (!conceptYaml || !conceptYaml.termid) continue;
+
+      const termid = String(conceptYaml.termid);
+      const jsonld = yamlToJsonLd(conceptYaml, register);
+      writeJson(path.join(conceptsDir, `${termid}.json`), jsonld);
+
+      // Generate Turtle format
+      const ttlContent = conceptJsonToTurtle(jsonld);
+      fs.writeFileSync(path.join(conceptsDir, `${termid}.ttl`), ttlContent);
+
+      // Copy source YAML
+      fs.copyFileSync(path.join(dir, file), path.join(conceptsDir, `${termid}.yaml`));
+
+      concepts.push({
+        id: termid,
+        designations: getPrimaryDesignation(conceptYaml),
+        groups: getGroups(conceptYaml),
+        status: conceptYaml.eng?.entry_status || 'valid',
+      });
+
+      for (const lang of opts.languages) {
+        const lc = conceptYaml[lang];
+        if (lc) {
+          if (lc.terms && lc.terms.length > 0) {
+            langTermCounts[lang] = (langTermCounts[lang] || 0) + 1;
+          }
+          if (lc.definition && (Array.isArray(lc.definition) ? lc.definition.some(d => d.content) : lc.definition)) {
+            langDefCounts[lang] = (langDefCounts[lang] || 0) + 1;
+          }
+        }
+      }
+    } catch (e) {
+      console.warn(`  Skipping ${file}: ${e.message}`);
+    }
+  }
+
+  const CHUNK_SIZE = 500;
+  const chunks = [];
+  for (let i = 0; i < concepts.length; i += CHUNK_SIZE) {
+    const chunk = concepts.slice(i, i + CHUNK_SIZE);
+    const chunkIndex = Math.floor(i / CHUNK_SIZE);
+    const chunkFile = `index-${String(chunkIndex).padStart(4, '0')}.json`;
+    writeJson(path.join(DATA, register, 'chunks', chunkFile), {
+      registerId: register,
+      chunkIndex,
+      concepts: chunk,
+    });
+    chunks.push({ file: chunkFile, count: chunk.length });
+  }
+
+  const summary = concepts.map(c => ({
+    id: c.id,
+    eng: c.designations.eng || Object.values(c.designations)[0] || '',
+    status: c.status,
+  }));
+
+  const graphNodeEntries = concepts.map(c => {
+    let term = '', lang = '';
+    if (c.designations.eng) { term = c.designations.eng; lang = 'eng'; }
+    else { for (const [l, t] of Object.entries(c.designations)) { if (t) { term = t; lang = l; break; } } }
+    return [c.id, term, lang, c.status];
+  });
+  fs.mkdirSync(path.join(DATA, register), { recursive: true });
+  fs.writeFileSync(
+    path.join(DATA, register, 'graph-nodes.json'),
+    JSON.stringify({
+      uriPrefix: `https://glossarist.org/${register}/concept/`,
+      registerId: register,
+      nodes: graphNodeEntries,
+    }),
+  );
+
+  writeJson(path.join(DATA, register, 'index.json'), {
+    registerId: register,
+    schemaVersion: '1.0.0',
+    conceptCount: concepts.length,
+    chunkSize: CHUNK_SIZE,
+    chunks,
+    concepts: summary,
+  });
+
+  writeJson(path.join(DATA, register, 'index-meta.json'), {
+    registerId: register,
+    schemaVersion: '1.0.0',
+    conceptCount: concepts.length,
+    chunkSize: CHUNK_SIZE,
+    chunks,
+  });
+
+  const langStats = {};
+  for (const lang of opts.languages) {
+    langStats[lang] = {
+      terms: langTermCounts[lang] || 0,
+      definitions: langDefCounts[lang] || 0,
+    };
+  }
+
+  const manifest = {
+    id: register,
+    datasetUri: opts.datasetUri,
+    uriAliases: opts.uriAliases,
+    title: opts.title,
+    description: opts.description,
+    owner: opts.owner,
+    baseUrl: `/data/${register}`,
+    languages: opts.languages,
+    conceptCount: concepts.length,
+    conceptUrlTemplate: '{baseUrl}/concepts/{conceptId}.json',
+    indexUrl: '{baseUrl}/index.json',
+    contextUrl: 'https://glossarist.org/ns/context.jsonld',
+    uriBase: 'https://glossarist.org',
+    status: 'valid',
+    schemaVersion: '1.0.0',
+    tags: opts.tags,
+    lastUpdated: new Date().toISOString().split('T')[0],
+    sourceRepo: opts.sourceRepo,
+    chunkSize: CHUNK_SIZE,
+    color: opts.color,
+    languageStats: langStats,
+    availableFormats,
+  };
+  if (opts.languageOrder) manifest.languageOrder = opts.languageOrder;
+  writeJson(path.join(DATA, register, 'manifest.json'), manifest);
+
+  console.log(`  Generated ${concepts.length} concepts, manifest, ${chunks.length} index chunks`);
+  return concepts.length;
+}
+
+// --- Main ---
+console.log('Generating Glossarist vocabulary browser data...\n');
+
+const { config } = loadSiteConfig();
+const counts = {};
+const registry = [];
+
+for (let i = 0; i < config.datasets.length; i++) {
+  const ds = config.datasets[i];
+
+  const dir = path.join(ROOT, '.datasets', ds.id, 'concepts');
+  if (!fs.existsSync(dir)) {
+    console.warn(`Skipping ${ds.id}: source directory not found (${dir})`);
+    console.warn(`  Run: npm run fetch-datasets`);
+    continue;
+  }
+
+  const registerDir = path.join(ROOT, '.datasets', ds.id);
+  const registerYamlPath = path.join(registerDir, 'register.yaml');
+  let registerMeta = {};
+  if (fs.existsSync(registerYamlPath)) {
+    try { registerMeta = readYaml(registerYamlPath) || {}; } catch {}
+  }
+
+  const dsLanguages = ds.languages || (registerMeta.subregisters ? Object.keys(registerMeta.subregisters) : ['eng']);
+
+  counts[ds.id] = processDataset(dir, ds.id, {
+    title: ds.title || registerMeta.name || ds.id,
+    description: ds.description || registerMeta.description || '',
+    owner: ds.owner,
+    languages: dsLanguages,
+    sourceRepo: ds.sourceRepo,
+    languageOrder: ds.languageOrder,
+    tags: ds.tags,
+    color: ds.color || DS_PALETTE[i % DS_PALETTE.length],
+    datasetUri: ds.uri,
+    uriAliases: ds.uriAliases,
+  });
+  registry.push({ id: ds.id, manifestUrl: `/data/${ds.id}/manifest.json` });
+}
+writeJson(path.join(PUBLIC, 'datasets.json'), registry);
+
+// Generate routing.json from site config
+writeJson(path.join(PUBLIC, 'routing.json'), config.routing || []);
+console.log('Generated routing.json');
+
+// Copy/download logos
+async function processLogo(logoConfig, filename) {
+  if (!logoConfig) return;
+  const destDir = path.join(PUBLIC, 'logos');
+  fs.mkdirSync(destDir, { recursive: true });
+  const destPath = path.join(destDir, filename);
+
+  // Local file in deployment repo
+  if (logoConfig.localPath) {
+    const src = path.resolve(process.cwd(), logoConfig.localPath);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, destPath);
+      console.log(`  Copied logo: ${src} → ${destPath}`);
+      return;
+    }
+    console.warn(`  Logo not found at: ${src}`);
+  }
+
+  // Remote URL
+  if (logoConfig.remoteUrl) {
+    try {
+      console.log(`  Downloading logo: ${logoConfig.remoteUrl}`);
+      const resp = await fetch(logoConfig.remoteUrl);
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      const buf = Buffer.from(await resp.arrayBuffer());
+      fs.writeFileSync(destPath, buf);
+      console.log(`  Saved logo: ${destPath}`);
+    } catch (e) {
+      console.warn(`  Logo download failed: ${e.message}`);
+    }
+  }
+}
+
+await processLogo(config.branding?.logo, `${config.id}-logo.svg`);
+await processLogo(config.branding?.footerLogo, `${config.id}-footer-logo.svg`);
+
+// === Page processors ===
+
+function processNewsPage(config, page) {
+  const newsDir = page.source
+    ? path.resolve(process.cwd(), page.source)
+    : config.newsDir
+      ? path.resolve(process.cwd(), config.newsDir)
+      : null;
+
+  if (!newsDir || !fs.existsSync(newsDir)) {
+    if (newsDir) console.warn(`News directory not found: ${newsDir}`);
+    return;
+  }
+
+  const index = [];
+  const newsOutDir = path.join(PUBLIC, 'news');
+  fs.mkdirSync(newsOutDir, { recursive: true });
+  const postFiles = fs.readdirSync(newsDir).filter(f => f.endsWith('.adoc') || f.endsWith('.md')).sort().reverse();
+
+  for (const file of postFiles) {
+    const content = fs.readFileSync(path.join(newsDir, file), 'utf8');
+    const frontmatter = {};
+    const bodyLines = [];
+
+    let inFm = false;
+    const lines = content.split('\n');
+    if (lines[0] === '---') {
+      inFm = true;
+      for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === '---') { inFm = false; continue; }
+        if (inFm) {
+          const m = lines[i].match(/^(\w[\w\s]*):\s*(.*)/);
+          if (m) frontmatter[m[1].trim()] = m[2].trim().replace(/^["']|["']$/g, '');
+        } else {
+          bodyLines.push(lines[i]);
+        }
+      }
+    } else {
+      bodyLines.push(...lines);
+    }
+
+    const slug = file.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/\.(adoc|md)$/, '');
+    const body = bodyLines.join('\n').trim();
+
+    const ext = path.extname(file);
+    const destFile = path.join(newsOutDir, `${slug}${ext}`);
+    fs.copyFileSync(path.join(newsDir, file), destFile);
+
+    index.push({
+      slug,
+      title: frontmatter.title || slug,
+      date: frontmatter.date || '',
+      categories: frontmatter.categories ? frontmatter.categories.split(',').map(s => s.trim()) : [],
+      file: `/news/${slug}${ext}`,
+      excerpt: body.split('\n').find(l => l.trim())?.slice(0, 200) || '',
+    });
+  }
+
+  writeJson(path.join(PUBLIC, 'news.json'), index);
+  console.log(`Generated news index: ${index.length} posts, ${postFiles.length} files copied to public/news/`);
+}
+
+function processContributorsPage(config, page) {
+  const contributors = { register: config.id, contributors: [] };
+
+  for (const ds of config.datasets) {
+    const infoYamlPath = path.join(ROOT, '.datasets', ds.id, 'info.yaml');
+    if (!fs.existsSync(infoYamlPath)) continue;
+
+    try {
+      const info = readYaml(infoYamlPath);
+      if (info.header) {
+        contributors.owner = info.header['register-owner'];
+        contributors.manager = info.header['register-manager'];
+      }
+      if (info.languages) {
+        for (const [lang, data] of Object.entries(info.languages)) {
+          contributors.contributors.push({
+            language: lang,
+            registerName: data['register-name'] || '',
+            organization: data['submitting-organisation-name'] || '',
+            contact: data['submitting-organisation-contact'] || '',
+            email: data['submitting-organisation-contact-email'] || '',
+            uri: data['uniform-resource-identifier-uri'] || '',
+            country: data['operating-language-country'] || '',
+          });
+        }
+      }
+    } catch (e) {
+      console.warn(`  Skipping contributors for ${ds.id}: ${e.message}`);
+    }
+  }
+
+  if (contributors.contributors.length > 0 || contributors.owner) {
+    writeJson(path.join(PUBLIC, 'contributors.json'), contributors);
+    console.log(`Generated contributors: ${contributors.contributors.length} languages`);
+  }
+}
+
+const pageProcessors = {
+  news: processNewsPage,
+  contributors: processContributorsPage,
+};
+
+function synthesizePages(config) {
+  const pages = [];
+  if (config.newsDir) pages.push({ type: 'news', route: 'news', title: 'News', icon: 'newspaper' });
+  return pages;
+}
+
+function processPages(config) {
+  const pages = config.pages || synthesizePages(config);
+  for (const page of pages) {
+    const processor = pageProcessors[page.type];
+    if (processor) processor(config, page);
+  }
+  return pages;
+}
+
+const processedPages = processPages(config);
+
+// Generate site-config.json from site config
+const siteBranding = { ...config.branding };
+// Rewrite logo paths to downloaded filenames
+if (siteBranding.logo?.remoteUrl) {
+  siteBranding.logo = { ...siteBranding.logo, path: `/logos/${config.id}-logo.svg` };
+  delete siteBranding.logo.remoteUrl;
+}
+if (siteBranding.footerLogo?.remoteUrl) {
+  siteBranding.footerLogo = { ...siteBranding.footerLogo, path: `/logos/${config.id}-footer-logo.svg` };
+  delete siteBranding.footerLogo.remoteUrl;
+}
+
+writeJson(path.join(PUBLIC, 'site-config.json'), {
+  id: config.id,
+  domain: config.domain,
+  title: config.title,
+  subtitle: config.subtitle,
+  description: config.description,
+  datasets: config.datasets.map(d => d.id),
+  defaultDataset: config.datasets.length === 1 ? config.datasets[0].id : undefined,
+  branding: siteBranding,
+  analytics: config.analytics,
+  features: config.features,
+  social: config.social,
+  nav: config.nav,
+  footerNav: config.footerNav,
+  defaults: config.defaults,
+  email: config.email,
+  pages: processedPages.length > 0 ? processedPages : undefined,
+});
+console.log('Generated site-config.json');
+
+const total = Object.values(counts).reduce((s, n) => s + n, 0);
+console.log(`\nDone! Generated data for ${total} concepts across ${registry.length} datasets.`);
+for (const [id, count] of Object.entries(counts)) {
+  console.log(`  ${id}: ${count} concepts`);
+}

package/scripts/load-site-config.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+/**
+ * Site config discovery and loading.
+ *
+ * Resolution order:
+ *   1. SITE_CONFIG env var → file path directly
+ *   2. SITE_ID env var → configs/{SITE_ID}.yml
+ *   3. --site CLI flag → same as SITE_ID
+ *   4. Fallback → site-config.yml in project root
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '..');
+
+function findConfigFile(args = []) {
+  if (process.env.SITE_CONFIG) {
+    return resolve(process.env.SITE_CONFIG);
+  }
+
+  const siteId = process.env.SITE_ID || args.find(a => !a.startsWith('-')) || null;
+  if (siteId) {
+    // Check project configs/ dir first
+    const p = resolve(projectRoot, 'configs', `${siteId}.yml`);
+    if (existsSync(p)) return p;
+    // Check CWD (deployment repo may have configs locally)
+    for (const name of [`${siteId}.yml`, 'site-config.yml']) {
+      const cwdP = resolve(process.cwd(), name);
+      if (existsSync(cwdP)) return cwdP;
+    }
+    throw new Error(`Site config not found for '${siteId}'. Checked configs/${siteId}.yml, ${siteId}.yml, site-config.yml in CWD`);
+  }
+
+  // Check CWD first (deployment repos), then project root
+  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, SITE_ID, or create site-config.yml');
+}
+
+export function loadSiteConfig(args = []) {
+  const configPath = findConfigFile(args);
+  const raw = yaml.load(readFileSync(configPath, 'utf-8'));
+  return { config: raw, configPath };
+}
+
+export function getProjectRoot() {
+  return projectRoot;
+}