@opengsd/gsd-core 1.9.1 → 1.11.0

package/scripts/gen-health-docs.cjs

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Generates the `<error_codes>` and `<repair_actions>` tables in
+ * `gsd-core/workflows/health.md` from `src/health-diagnostic.cts`'s `RULES`
+ * table (Phase 11 follow-up, #3309 "Proposed behavior": "health.md's tables
+ * are generated rather than hand-maintained, closing the 16-vs-30+
+ * documentation gap structurally").
+ *
+ * Sources:
+ *   - The 31 real rules in the compiled `RULES` array
+ *     (`gsd-core/bin/lib/health-diagnostic.cjs`, built from
+ *     `src/health-diagnostic.cts` + `src/health-diagnostic-rules/*.cts`),
+ *     each carrying a static `description`/`repairable` (see
+ *     `src/health-diagnostic-types.cts`'s `Rule` interface).
+ *   - `PRECHECK_CODES` below — E001, E010, I010 — the three diagnostics
+ *     `cmdValidateHealth` (`src/verify.cts`) emits as pre-checks OUTSIDE the
+ *     rule table entirely (ADR-3180 §8.2 rule 4, "no precedence system" —
+ *     see `.gsd/phase/refactor-3309-health-diagnostic-rule-table/40-design.md`,
+ *     "Two guards that stay OUTSIDE the rule table entirely"). These will
+ *     never appear in `RULES`, so they are a small, static, clearly-labeled
+ *     list merged in here instead.
+ *   - `REMEDY_ACTION_METADATA` below — the Effect/Risk prose for each of the
+ *     6 real repair actions (`REMEDY_ACTION`, excluding `ADVISE`, which never
+ *     acts). Static because the compiled module carries no Effect/Risk text
+ *     of its own — only the action identifier.
+ *
+ * Deliberately EXCLUDED from the generated `<error_codes>` table: `W025`
+ * (the `workflow.use_worktrees`/`dispatch.isolation` check, #2486). It is a
+ * workflow-layer diagnostic emitted directly by this same file's own
+ * `run_health_check` step (a bash block in `health.md` itself), never by
+ * `cmdValidateHealth`/`RULES` — it has no `Rule` entry and is not one of the
+ * three pre-checks above. It stays fully documented in prose at its own step
+ * (`<step name="run_health_check">`), which is the authoritative, more
+ * detailed source `<error_codes>` used to merely summarize; dropping the
+ * redundant table row is not a loss of information, and folding it back in
+ * here would require this generator to parse bash, which it does not do.
+ * Same reasoning for `I002` (stale Windows task-directory cleanup,
+ * `<stale_task_cleanup>` step) — it was never part of the `<error_codes>`
+ * tagged region even before this generator existed.
+ *
+ * Usage:
+ *   node scripts/gen-health-docs.cjs              # print both tables to stdout
+ *   node scripts/gen-health-docs.cjs --write       # rewrite the tagged regions in health.md
+ *   node scripts/gen-health-docs.cjs --check       # exit 1 if either region is stale
+ *   node scripts/gen-health-docs.cjs --write --target <path>  # test-only: target a fixture file
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+
+const ROOT = path.resolve(__dirname, '..');
+const HEALTH_MD_REL = 'gsd-core/workflows/health.md';
+const HEALTH_MD_PATH = path.join(ROOT, HEALTH_MD_REL);
+const COMPILED_MODULE_REL = 'gsd-core/bin/lib/health-diagnostic.cjs';
+const COMPILED_MODULE_PATH = path.join(ROOT, COMPILED_MODULE_REL);
+
+const ERROR_CODES_START = '<error_codes>';
+const ERROR_CODES_END = '</error_codes>';
+const REPAIR_ACTIONS_START = '<repair_actions>';
+const REPAIR_ACTIONS_END = '</repair_actions>';
+
+/**
+ * The 3 pre-check diagnostics `cmdValidateHealth` emits OUTSIDE the rule
+ * table (see module header). All three are non-repairable safety rails, not
+ * `.planning/` findings a remedy could act on.
+ */
+const PRECHECK_CODES = [
+  {
+    code: 'E001',
+    severity: 'error',
+    description: '.planning/ directory not found',
+    repairable: false,
+  },
+  {
+    code: 'E010',
+    severity: 'error',
+    description: "CWD resolves to the user's home directory — health check would target the wrong .planning/",
+    repairable: false,
+  },
+  {
+    code: 'I010',
+    severity: 'info',
+    description: 'Resolved CWD reported alongside the E010 home-directory guard',
+    repairable: false,
+  },
+];
+
+/**
+ * Effect/Risk prose per real `REMEDY_ACTION` (everything except `ADVISE`,
+ * which never acts and has no row in `<repair_actions>`). Text for the 5
+ * actions the hand-written table already documented is reused VERBATIM;
+ * `addAiIntegrationPhaseKey` is new — #3309 itself notes it was "live in
+ * code, missing from docs" (mirrors `addNyquistKey`, its structural sibling:
+ * same shape, one config key each).
+ */
+const REMEDY_ACTION_METADATA = new Map([
+  ['createConfig', { effect: 'Create config.json with defaults', risk: 'None' }],
+  ['resetConfig', { effect: 'Delete + recreate config.json', risk: 'Loses custom settings' }],
+  [
+    'regenerateState',
+    {
+      effect: 'Create STATE.md from ROADMAP structure when it is missing',
+      risk: 'Loses session history',
+    },
+  ],
+  [
+    'addNyquistKey',
+    { effect: 'Add workflow.nyquist_validation: true to config.json', risk: 'None — matches existing default' },
+  ],
+  [
+    'addAiIntegrationPhaseKey',
+    { effect: 'Add workflow.ai_integration_phase: true to config.json', risk: 'None — matches existing default' },
+  ],
+  [
+    'backfillMilestones',
+    {
+      effect: 'Synthesize missing MILESTONES.md entries from `.planning/milestones/vX.Y-ROADMAP.md` snapshots',
+      risk: 'None — additive only; triggered by `--backfill` flag',
+    },
+  ],
+]);
+
+/** Order the Effect/Risk table renders in — matches `REMEDY_ACTION`'s own declaration order. */
+const REMEDY_ACTION_ORDER = [
+  'createConfig',
+  'resetConfig',
+  'regenerateState',
+  'addNyquistKey',
+  'addAiIntegrationPhaseKey',
+  'backfillMilestones',
+];
+
+/**
+ * Per-code override for the "Repairable" cell's display text, for codes
+ * whose remedy is conditional on a flag the plain `Yes`/`No` can't express
+ * (mirrors the hand-written table's pre-existing `W018` row: `Yes (--backfill)`).
+ */
+const REPAIRABLE_DISPLAY_OVERRIDE = new Map([['W018', 'Yes (`--backfill`)']]);
+
+const STATIC_NOT_REPAIRABLE_BULLETS = [
+  'PROJECT.md, ROADMAP.md content',
+  'Phase directory renaming',
+  'Orphaned plan cleanup',
+];
+
+const FOOTNOTE_PARAGRAPH =
+  'Note: this table is **generated** — do not hand-edit it. It is produced by ' +
+  '`node scripts/gen-health-docs.cjs --write` from `src/health-diagnostic.cts`\'s `RULES` table ' +
+  '(31 rules as of #3309, each carrying a static `description`/`repairable` on its `Rule` entry — ' +
+  'see `src/health-diagnostic-types.cts`) plus the 3 pre-checks that stay outside the rule table by ' +
+  'design (`E001`, `E010`, `I010` — safety rails in `cmdValidateHealth`, `src/verify.cts`, never ' +
+  '`.planning/` findings). `scripts/lint-health-diagnostic-rule-table.cjs` already enforces the 1:1 ' +
+  'code invariant this table depends on (no duplicate codes; severity is always a `Rule` property, ' +
+  'never set per emit call) — before assigning a new code, add a `Rule` entry under ' +
+  '`src/health-diagnostic-rules/` (its `code` is simply the next free number the lint guard has not ' +
+  'yet seen) and run `node scripts/gen-health-docs.cjs --write` to regenerate this table; ' +
+  '`npm run lint:generated-sync` fails if it drifts. `W025` (the `workflow.use_worktrees`/' +
+  '`dispatch.isolation` check, #2486) is a workflow-layer diagnostic emitted directly by this file\'s ' +
+  'own `run_health_check` step, not by `cmdValidateHealth` — it stays documented in that step, not in ' +
+  'this generated table.';
+
+/**
+ * Load the compiled health-diagnostic module. Throws a clear ExitError (not
+ * a raw MODULE_NOT_FOUND) if `npm run build:lib` has not run — mirrors
+ * `scripts/lint-health-diagnostic-rule-table.cjs`'s `loadCompiledModule`.
+ */
+function loadCompiledModule(compiledPath = COMPILED_MODULE_PATH) {
+  if (!fs.existsSync(compiledPath)) {
+    throw new ExitError(
+      2,
+      `gen-health-docs: compiled artifact not found at ${COMPILED_MODULE_REL}.\n` +
+        'Run `npm run build:lib` first.',
+    );
+  }
+  return require(compiledPath);
+}
+
+/**
+ * Sort order for the `<error_codes>` table: E-codes, then W-codes
+ * numerically, then I-codes — matching the hand-written table's pre-existing
+ * order. NOT insertion order from `RULES` (which is grouped by
+ * subject-area file, not sorted by code).
+ */
+const PREFIX_RANK = { E: 0, W: 1, I: 2 };
+
+function parseCode(code) {
+  const m = code.match(/^([A-Z]+)(\d+)$/);
+  if (!m) throw new Error(`gen-health-docs: unparseable diagnostic code "${code}"`);
+  return { prefix: m[1], number: Number(m[2]) };
+}
+
+function compareCodes(a, b) {
+  const pa = parseCode(a.code);
+  const pb = parseCode(b.code);
+  const rankA = PREFIX_RANK[pa.prefix] ?? 99;
+  const rankB = PREFIX_RANK[pb.prefix] ?? 99;
+  if (rankA !== rankB) return rankA - rankB;
+  return pa.number - pb.number;
+}
+
+/**
+ * Combine the 31 real rules + the 3 static pre-checks into one sorted row
+ * list for the `<error_codes>` table.
+ *
+ * @param {Array<{code: string, severity: string, description: string, repairable: boolean}>} rules
+ */
+function buildErrorCodeRows(rules) {
+  const seen = new Set();
+  const rows = [];
+  for (const entry of [...rules, ...PRECHECK_CODES]) {
+    if (seen.has(entry.code)) {
+      throw new Error(`gen-health-docs: duplicate diagnostic code "${entry.code}" across RULES + PRECHECK_CODES`);
+    }
+    seen.add(entry.code);
+    rows.push(entry);
+  }
+  rows.sort(compareCodes);
+  return rows;
+}
+
+/** Escape a cell's markdown-table-hostile characters (mirrors gen-adr-index.cjs's `cellText`). */
+function cellText(text) {
+  return String(text)
+    .replace(/\\/g, '\\\\')
+    .replace(/\|/g, '\\|')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/\r?\n/g, ' ')
+    .trim();
+}
+
+function repairableCell(row) {
+  if (REPAIRABLE_DISPLAY_OVERRIDE.has(row.code)) return REPAIRABLE_DISPLAY_OVERRIDE.get(row.code);
+  return row.repairable ? 'Yes' : 'No';
+}
+
+function renderErrorCodesRegion(rules) {
+  const rows = buildErrorCodeRows(rules);
+  const lines = ['', '| Code | Severity | Description | Repairable |', '|------|----------|-------------|------------|'];
+  for (const row of rows) {
+    lines.push(`| ${row.code} | ${row.severity} | ${cellText(row.description)} | ${repairableCell(row)} |`);
+  }
+  lines.push('', FOOTNOTE_PARAGRAPH, '');
+  return lines.join('\n');
+}
+
+function renderRepairActionsRegion() {
+  const lines = ['', '| Action | Effect | Risk |', '|--------|--------|------|'];
+  for (const action of REMEDY_ACTION_ORDER) {
+    const meta = REMEDY_ACTION_METADATA.get(action);
+    if (!meta) {
+      throw new Error(
+        `gen-health-docs: no Effect/Risk metadata registered for repair action "${action}" — add an entry to REMEDY_ACTION_METADATA.`,
+      );
+    }
+    lines.push(`| ${action} | ${meta.effect} | ${meta.risk} |`);
+  }
+  lines.push('', '**Not repairable (too risky):**');
+  for (const bullet of STATIC_NOT_REPAIRABLE_BULLETS) lines.push(`- ${bullet}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Splice `newInner` between `${startTag}`/`${endTag}` inside `text`. Throws
+ * if either tag is missing, or if the tags appear more than once (this
+ * generator only ever targets the FIRST occurrence pair, and a duplicate
+ * tag anywhere in the file would silently corrupt the splice).
+ */
+function spliceRegion(text, startTag, endTag, newInner) {
+  const startIdx = text.indexOf(startTag);
+  const endIdx = text.indexOf(endTag);
+  if (startIdx === -1 || endIdx === -1) {
+    throw new ExitError(
+      1,
+      `gen-health-docs: ${HEALTH_MD_REL} is missing the ${startTag}/${endTag} tags.`,
+    );
+  }
+  if (text.indexOf(startTag, startIdx + 1) !== -1 || text.indexOf(endTag, endIdx + 1) !== -1) {
+    throw new ExitError(1, `gen-health-docs: ${HEALTH_MD_REL} has more than one ${startTag}/${endTag} pair.`);
+  }
+  const before = text.slice(0, startIdx + startTag.length);
+  const after = text.slice(endIdx);
+  return `${before}${newInner}\n${after}`;
+}
+
+/**
+ * Regenerate `health.md`'s full text from `rules` (the compiled `RULES`
+ * array) and the current on-disk `health.md` content.
+ */
+function regenerateHealthMd(rules, currentText) {
+  let out = spliceRegion(currentText, ERROR_CODES_START, ERROR_CODES_END, renderErrorCodesRegion(rules));
+  out = spliceRegion(out, REPAIR_ACTIONS_START, REPAIR_ACTIONS_END, renderRepairActionsRegion());
+  return out;
+}
+
+/**
+ * @param {string[]} argv
+ * @returns {{write: boolean, check: boolean, targetPath: string|null}}
+ */
+function parseArgs(argv) {
+  const opts = { write: false, check: false, targetPath: null };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--write') opts.write = true;
+    else if (arg === '--check') opts.check = true;
+    else if (arg === '--target') {
+      const value = argv[i + 1];
+      if (value === undefined) throw new ExitError(1, '--target requires a path argument.');
+      opts.targetPath = value;
+      i++;
+    } else {
+      throw new ExitError(1, `unknown flag: ${arg}\nRecognized flags: --write, --check, --target <path>.`);
+    }
+  }
+  return opts;
+}
+
+function main() {
+  const { write, check, targetPath } = parseArgs(process.argv.slice(2));
+  const { RULES } = loadCompiledModule();
+
+  // `--target` overrides the real committed health.md path, exclusively for
+  // test isolation (mirrors gen-section-manifest.cjs's `--manifest-path`
+  // override) — no production caller ever passes it.
+  const resolvedPath = targetPath ? path.resolve(targetPath) : HEALTH_MD_PATH;
+  const displayPath = targetPath ? targetPath : HEALTH_MD_REL;
+
+  const currentText = fs.existsSync(resolvedPath) ? fs.readFileSync(resolvedPath, 'utf8') : null;
+  if (currentText === null) {
+    throw new ExitError(1, `gen-health-docs: ${displayPath} not found.`);
+  }
+
+  const expected = regenerateHealthMd(RULES, currentText);
+
+  if (write) {
+    fs.writeFileSync(resolvedPath, expected, 'utf8');
+    process.stdout.write(
+      `Wrote ${displayPath} — ${RULES.length + PRECHECK_CODES.length} error/warning/info code(s), ` +
+        `${REMEDY_ACTION_ORDER.length} repair action(s).\n`,
+    );
+    return 0;
+  }
+
+  if (check) {
+    if (expected !== currentText) {
+      process.stderr.write(
+        `${displayPath} is stale — its <error_codes>/<repair_actions> tables do not match ` +
+          "src/health-diagnostic.cts's RULES table.\nRun:\n  node scripts/gen-health-docs.cjs --write\n\n",
+      );
+      throw new ExitError(1);
+    }
+    process.stdout.write(
+      `${displayPath} is up to date (${RULES.length + PRECHECK_CODES.length} codes, ${REMEDY_ACTION_ORDER.length} repair actions).\n`,
+    );
+    return 0;
+  }
+
+  process.stdout.write(renderErrorCodesRegion(RULES) + '\n\n' + renderRepairActionsRegion() + '\n');
+  return 0;
+}
+
+// Guarded: requiring this module (the test suite imports the pure render
+// functions directly) must not also run the generator as a side effect.
+if (require.main === module) runMain(main);
+
+module.exports = {
+  loadCompiledModule,
+  buildErrorCodeRows,
+  renderErrorCodesRegion,
+  renderRepairActionsRegion,
+  regenerateHealthMd,
+  spliceRegion,
+  compareCodes,
+  parseCode,
+  PRECHECK_CODES,
+  REMEDY_ACTION_METADATA,
+  REMEDY_ACTION_ORDER,
+  REPAIRABLE_DISPLAY_OVERRIDE,
+  HEALTH_MD_PATH,
+  COMPILED_MODULE_PATH,
+  ERROR_CODES_START,
+  ERROR_CODES_END,
+  REPAIR_ACTIONS_START,
+  REPAIR_ACTIONS_END,
+};

package/scripts/gen-inventory-manifest.cjs

@@ -60,14 +60,150 @@ const FAMILIES = [
   },
 ];
 
+/**
+ * One-level-nested families (#2996, epic #1671 Phase 6.5).
+ *
+ * `buildManifest`'s flat `readdirSync` + `isFile()` walk cannot see a workflow's
+ * own sub-files, so `gsd-core/workflows/<wf>/steps/*.md` (the fragment tree
+ * extracted by Phases 6.1-6.3) and `gsd-core/workflows/<wf>/modes/*.md` (the
+ * #717 progressive-disclosure pattern) shipped invisible to both the manifest
+ * and `docs/INVENTORY.md` — exactly the `DEFECT.INVENTORY-DRIFT` class.
+ *
+ * Keyed by `<parent>/<subdir>/<file>` rather than a bare basename ON PURPOSE:
+ * two workflows may each own a `regression-gate.md`, and a step file may share a
+ * name with a top-level workflow. A basename key would let one silently
+ * overwrite the other, and because the manifest is compared by JSON equality a
+ * collision would read as "up to date".
+ *
+ * Recursion is bounded at exactly one level, by named subdirectory. It is not a
+ * general recursive walk.
+ */
+const NESTED_FAMILIES = [
+  {
+    name: 'workflow_modes',
+    root: path.join(ROOT, 'gsd-core', 'workflows'),
+    subdir: 'modes',
+    filter: (f) => f.endsWith('.md'),
+  },
+  {
+    name: 'workflow_steps',
+    root: path.join(ROOT, 'gsd-core', 'workflows'),
+    subdir: 'steps',
+    filter: (f) => f.endsWith('.md'),
+  },
+];
+
+/**
+ * Collect `<root>/<parent>/<subdir>/<file>` entries as POSIX-relative keys.
+ *
+ * A parent that has no such subdirectory contributes nothing, and an EMPTY
+ * subdirectory contributes nothing — never an empty-array key, which would be a
+ * committed diff that signals nothing. `statSync().isDirectory()` is checked
+ * before every `readdirSync` so a plain FILE named `steps` cannot throw.
+ */
+/**
+ * `fs.statSync` throws on a dangling symlink and on an EACCES-denied path. An
+ * entry we cannot stat is, for inventory purposes, not a countable file — the
+ * same disposition as "not a directory" below. Swallowing the throw here keeps
+ * one unreadable entry from taking down `--check` for the entire repo, which is
+ * a manifest generator's worst failure mode: it turns a local filesystem oddity
+ * into a red gate on every PR.
+ */
+function statOrNull(p) {
+  try {
+    return fs.statSync(p);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Collect `<dir>/<subdir>/<file>` entries as `<subdir>/<file>` keys — ONE level of
+ * subdirectory beneath `dir` itself, where the subdirectory's NAME is the thing being
+ * collected (unlike `collectNested`, there is no fixed subdir name to look for; every
+ * child directory of `dir` is scanned). This is what makes `gsd-core/bin/lib/<subdir>/*.cjs`
+ * (e.g. `health-diagnostic-rules/`, `installer-migrations/`, `host-integration-adapters/`,
+ * `observability/`) visible to the `cli_modules` family, mirroring the shape
+ * `docs/INVENTORY.md`'s CLI Modules table already uses for these files.
+ *
+ * Same defensive `statOrNull`-based style as `collectNested`: a stat/readdir failure on
+ * one entry is swallowed rather than thrown, so one unreadable subdirectory cannot take
+ * down `--check` for the whole repo.
+ */
+function collectOneLevelSubdirs({ dir, filter }) {
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  let children;
+  try {
+    children = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  for (const child of children) {
+    const childStat = statOrNull(path.join(dir, child));
+    if (!childStat || !childStat.isDirectory()) continue;
+    const subdirPath = path.join(dir, child);
+    let files;
+    try {
+      files = fs.readdirSync(subdirPath);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const fileStat = statOrNull(path.join(subdirPath, file));
+      if (!fileStat || !fileStat.isFile() || !filter(file)) continue;
+      out.push([child, file].join('/'));
+    }
+  }
+  return out.sort();
+}
+
+function collectNested({ root, subdir, filter }) {
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  let parents;
+  try {
+    parents = fs.readdirSync(root);
+  } catch {
+    return [];
+  }
+  for (const parent of parents) {
+    const parentStat = statOrNull(path.join(root, parent));
+    if (!parentStat || !parentStat.isDirectory()) continue;
+    const nestedDir = path.join(root, parent, subdir);
+    const nestedStat = statOrNull(nestedDir);
+    if (!nestedStat || !nestedStat.isDirectory()) continue;
+    let files;
+    try {
+      files = fs.readdirSync(nestedDir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const fileStat = statOrNull(path.join(nestedDir, file));
+      if (!fileStat || !fileStat.isFile() || !filter(file)) continue;
+      out.push([parent, subdir, file].join('/'));
+    }
+  }
+  return out.sort();
+}
+
 function buildManifest() {
   const manifest = { families: {} };
   for (const { name, dir, filter, toName } of FAMILIES) {
-    manifest.families[name] = fs
+    const flat = fs
       .readdirSync(dir)
       .filter((f) => fs.statSync(path.join(dir, f)).isFile() && filter(f))
-      .map(toName)
-      .sort();
+      .map(toName);
+    // `cli_modules` also ships subdirectory modules (`health-diagnostic-rules/`,
+    // `installer-migrations/`, `host-integration-adapters/`, `observability/`) invisible to
+    // the flat readdirSync above; merge them into the SAME sorted array, matching the single
+    // "CLI Modules" table shape docs/INVENTORY.md already uses (#3309).
+    const nested = name === 'cli_modules' ? collectOneLevelSubdirs({ dir, filter }) : [];
+    manifest.families[name] = [...flat, ...nested].sort();
+  }
+  for (const family of NESTED_FAMILIES) {
+    manifest.families[family.name] = collectNested(family);
   }
   return manifest;
 }
@@ -109,4 +245,14 @@ function main() {
   }
 }
 
-runMain(main);
+/* c8 ignore next 3 -- CLI entry guard; this repo measures coverage with c8, which does not honor istanbul pragmas */
+if (require.main === module) {
+  runMain(main);
+}
+
+// Single source of truth for the family tables (#2996). `tests/inventory-manifest-sync.test.cjs`
+// previously carried its own duplicate copy of FAMILIES, which is the
+// `DEFECT.GENERATIVE-FIX` divergence class: adding a family here while the test kept
+// its own list meant the test silently verified fewer families than shipped, and still
+// passed. The test now imports these, so the two surfaces cannot drift.
+module.exports = { FAMILIES, NESTED_FAMILIES, collectNested, collectOneLevelSubdirs, buildManifest };

package/scripts/gen-loop-host-contract.cjs

@@ -20,6 +20,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+const { escapeRegex: escapeRegExp } = require('../gsd-core/bin/lib/pattern.cjs');
+const { normalizeEol } = require('../gsd-core/bin/lib/text-lines.cjs');
 
 const ROOT = path.resolve(__dirname, '..');
 const WORKFLOWS_DIR = path.join(ROOT, 'gsd-core', 'workflows');
@@ -191,13 +193,6 @@ function parseLoopHostBlock(content, fileName) {
  * @param {string}   fileName    For error messages
  * @returns {string[]}           Array of error strings; empty = OK
  */
-/**
- * Escape a string for literal use in a RegExp.
- */
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 function crossCheckRoles(content, agentRoles, fileName) {
   const errors = [];
   for (const role of agentRoles) {
@@ -375,21 +370,6 @@ function serializeContract(contract) {
   return lines.join('\n');
 }
 
-// ─── --check diff helper ──────────────────────────────────────────────────────
-
-/**
- * Normalize line endings to LF for CRLF-agnostic comparison.
- * FIX 4: The serializer has no nondeterministic content (no timestamp), so
- * the generated-by-line stripping that was here has been removed — full content
- * comparison is now used so header drift is caught by --check.
- *
- * @param {string} content
- * @returns {string}
- */
-function normalizeLineEndings(content) {
-  return content.replace(/\r/g, '');
-}
-
 // ─── Main ─────────────────────────────────────────────────────────────────────
 
 function main() {
@@ -415,7 +395,7 @@ function main() {
 
     const committed = fs.readFileSync(CONTRACT_PATH, 'utf8');
     // FIX 4: Compare full content (no generated-by stripping) so header drift is caught.
-    if (normalizeLineEndings(committed) !== normalizeLineEndings(live)) {
+    if (normalizeEol(committed) !== normalizeEol(live)) {
       process.stderr.write(
         'gsd-core/bin/lib/loop-host-contract.cjs is stale. Run:\n' +
         '  node scripts/gen-loop-host-contract.cjs --write\n',
@@ -509,7 +489,7 @@ module.exports = {
   assertPointsCoverage,
   buildContract,
   serializeContract,
-  normalizeLineEndings,
+  normalizeLineEndings: normalizeEol,
   STEP_WORKFLOWS,
   HOST_LOOP_FILES,
   CANONICAL_POINTS,