@lifeaitools/rdc-skills 0.24.38 → 0.24.39

package/tests/require-work-item-on-commit.test.mjs

@@ -1,162 +1,162 @@
-#!/usr/bin/env node
-/**
- * Truth Gate L1 — commit-capture hook tests.
- *
- * Proves:
- *   1. parse: the work-item UUID is extracted from a commit message; absent UUID -> null.
- *   2. capture: on a PostToolUse(git commit), the captured `sha` EQUALS the real
- *      `git rev-parse HEAD` of the repo (verified against a throwaway git repo,
- *      via the RDC_COMMIT_CAPTURE_SINK file — no live DB required).
- *   3. no-item: capture NO-OPs (writes nothing) when the commit message carries
- *      no work-item UUID. No orphan row.
- *
- * Run: node tests/require-work-item-on-commit.test.mjs   (or `node --test tests/`)
- */
-import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawnSync, execFileSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = resolve(__dirname, '..');
-const HOOK = join(REPO_ROOT, 'hooks', 'require-work-item-on-commit.js');
-
-const require = createRequire(import.meta.url);
-const failures = [];
-function assert(name, condition, detail = '') {
-  if (!condition) failures.push(`${name}${detail ? `: ${detail}` : ''}`);
-}
-
-// ---------------------------------------------------------------------------
-// 1. Pure parse assertions
-// ---------------------------------------------------------------------------
-const hook = require(HOOK);
-const WI = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
-
-assert('parse: extracts UUID from message',
-  hook.parseCommitMessageWorkItem(`feat(x): do thing for ${WI}`) === WI);
-assert('parse: null when no UUID',
-  hook.parseCommitMessageWorkItem('feat(x): no work item here') === null);
-assert('isGitCommit: true for real commit',
-  hook.isGitCommit('git commit -m "feat: x"') === true);
-assert('isGitCommit: false for --help',
-  hook.isGitCommit('git commit --help') === false);
-assert('isGitCommit: false for unrelated',
-  hook.isGitCommit('git status') === false);
-assert('commitSucceeded: false on nothing-to-commit',
-  hook.commitSucceeded({ stdout: 'nothing to commit, working tree clean' }) === false);
-assert('commitSucceeded: true on exit 0',
-  hook.commitSucceeded({ exit_code: 0 }) === true);
-
-// ---------------------------------------------------------------------------
-// helper: build a throwaway git repo with one commit
-// ---------------------------------------------------------------------------
-function makeRepo() {
-  const dir = mkdtempSync(join(tmpdir(), 'wic-repo-'));
-  const g = (...args) => execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-  g('init', '-q');
-  g('config', 'user.email', 'test@example.com');
-  g('config', 'user.name', 'Test');
-  writeFileSync(join(dir, 'f.txt'), 'hello\n');
-  g('add', 'f.txt');
-  g('commit', '-q', '-m', `feat: seed for ${WI}`);
-  const head = g('rev-parse', 'HEAD').trim();
-  return { dir, head };
-}
-
-function runHook(payload, extraEnv = {}) {
-  return spawnSync(process.execPath, [HOOK], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    env: { ...process.env, ...extraEnv },
-  });
-}
-
-// ---------------------------------------------------------------------------
-// 2. Capture: sha == git rev-parse HEAD
-// ---------------------------------------------------------------------------
-{
-  const { dir, head } = makeRepo();
-  const sink = join(dir, 'sink.jsonl');
-  // Point Supabase at an unreachable host so the test never touches a real DB;
-  // capture still writes the sink, which is what we assert on.
-  const res = runHook({
-    hook_event_name: 'PostToolUse',
-    tool_name: 'Bash',
-    session_id: 'sess-capture-1',
-    cwd: dir,
-    tool_input: { command: `git commit -m "feat: thing for ${WI}"` },
-    tool_response: { exit_code: 0, stdout: '1 file changed' },
-  }, {
-    RDC_COMMIT_CAPTURE_SINK: sink,
-    SUPABASE_URL: 'http://127.0.0.1:9',     // unreachable -> DB insert fails fast, capture still records sink
-    SUPABASE_SERVICE_ROLE_KEY: 'test-key-not-real',
-  });
-  assert('capture: hook exits zero', res.status === 0, res.stderr);
-  assert('capture: sink written', existsSync(sink), 'no sink file');
-  if (existsSync(sink)) {
-    const row = JSON.parse(readFileSync(sink, 'utf8').trim().split('\n')[0]);
-    assert('capture: sha equals real HEAD', row.sha === head, `${row.sha} !== ${head}`);
-    assert('capture: work_item_id parsed', row.work_item_id === WI, row.work_item_id);
-    assert('capture: session_id recorded', row.session_id === 'sess-capture-1', row.session_id);
-  }
-  rmSync(dir, { recursive: true, force: true });
-}
-
-// ---------------------------------------------------------------------------
-// 3. No active work item -> NO-OP (no sink row)
-// ---------------------------------------------------------------------------
-{
-  const { dir } = makeRepo();
-  const sink = join(dir, 'sink.jsonl');
-  const res = runHook({
-    hook_event_name: 'PostToolUse',
-    tool_name: 'Bash',
-    session_id: 'sess-no-item',
-    cwd: dir,
-    tool_input: { command: 'git commit -m "feat: no work item ref"' },
-    tool_response: { exit_code: 0 },
-  }, { RDC_COMMIT_CAPTURE_SINK: sink });
-  assert('no-item: hook exits zero', res.status === 0, res.stderr);
-  assert('no-item: no sink row written', !existsSync(sink), 'orphan capture written for no-item commit');
-  rmSync(dir, { recursive: true, force: true });
-}
-
-// ---------------------------------------------------------------------------
-// 4. PreToolUse legacy behavior preserved (warn-only, never blocks)
-//    Uses a fresh temp dir as HOME/USERPROFILE so no fixit.marker is visible
-//    regardless of real machine state — makes the warn-path assertion deterministic.
-// ---------------------------------------------------------------------------
-{
-  const fakeHome = mkdtempSync(join(tmpdir(), 'wic-home-'));
-  try {
-    const preEnv = { HOME: fakeHome, USERPROFILE: fakeHome };
-
-    const res = runHook({
-      hook_event_name: 'PreToolUse',
-      tool_name: 'Bash',
-      tool_input: { command: 'git commit -m "no convention and no uuid"' },
-    }, preEnv);
-    assert('pre: warn exits zero (never blocks)', res.status === 0, res.stderr);
-    assert('pre: emits warn systemMessage', /no work item reference/.test(res.stdout), res.stdout);
-
-    const ok = runHook({
-      hook_event_name: 'PreToolUse',
-      tool_name: 'Bash',
-      tool_input: { command: 'git commit -m "feat(x): conventional"' },
-    }, preEnv);
-    assert('pre: conventional passes silently', ok.status === 0 && ok.stdout.trim() === '', ok.stdout);
-  } finally {
-    rmSync(fakeHome, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-if (failures.length > 0) {
-  console.error('\ncommit-capture hook tests — FAIL\n');
-  for (const f of failures) console.error(`  - ${f}`);
-  process.exit(1);
-}
-console.log('commit-capture hook tests — PASS');
+#!/usr/bin/env node
+/**
+ * Truth Gate L1 — commit-capture hook tests.
+ *
+ * Proves:
+ *   1. parse: the work-item UUID is extracted from a commit message; absent UUID -> null.
+ *   2. capture: on a PostToolUse(git commit), the captured `sha` EQUALS the real
+ *      `git rev-parse HEAD` of the repo (verified against a throwaway git repo,
+ *      via the RDC_COMMIT_CAPTURE_SINK file — no live DB required).
+ *   3. no-item: capture NO-OPs (writes nothing) when the commit message carries
+ *      no work-item UUID. No orphan row.
+ *
+ * Run: node tests/require-work-item-on-commit.test.mjs   (or `node --test tests/`)
+ */
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync, execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+const HOOK = join(REPO_ROOT, 'hooks', 'require-work-item-on-commit.js');
+
+const require = createRequire(import.meta.url);
+const failures = [];
+function assert(name, condition, detail = '') {
+  if (!condition) failures.push(`${name}${detail ? `: ${detail}` : ''}`);
+}
+
+// ---------------------------------------------------------------------------
+// 1. Pure parse assertions
+// ---------------------------------------------------------------------------
+const hook = require(HOOK);
+const WI = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
+
+assert('parse: extracts UUID from message',
+  hook.parseCommitMessageWorkItem(`feat(x): do thing for ${WI}`) === WI);
+assert('parse: null when no UUID',
+  hook.parseCommitMessageWorkItem('feat(x): no work item here') === null);
+assert('isGitCommit: true for real commit',
+  hook.isGitCommit('git commit -m "feat: x"') === true);
+assert('isGitCommit: false for --help',
+  hook.isGitCommit('git commit --help') === false);
+assert('isGitCommit: false for unrelated',
+  hook.isGitCommit('git status') === false);
+assert('commitSucceeded: false on nothing-to-commit',
+  hook.commitSucceeded({ stdout: 'nothing to commit, working tree clean' }) === false);
+assert('commitSucceeded: true on exit 0',
+  hook.commitSucceeded({ exit_code: 0 }) === true);
+
+// ---------------------------------------------------------------------------
+// helper: build a throwaway git repo with one commit
+// ---------------------------------------------------------------------------
+function makeRepo() {
+  const dir = mkdtempSync(join(tmpdir(), 'wic-repo-'));
+  const g = (...args) => execFileSync('git', args, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  g('init', '-q');
+  g('config', 'user.email', 'test@example.com');
+  g('config', 'user.name', 'Test');
+  writeFileSync(join(dir, 'f.txt'), 'hello\n');
+  g('add', 'f.txt');
+  g('commit', '-q', '-m', `feat: seed for ${WI}`);
+  const head = g('rev-parse', 'HEAD').trim();
+  return { dir, head };
+}
+
+function runHook(payload, extraEnv = {}) {
+  return spawnSync(process.execPath, [HOOK], {
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    env: { ...process.env, ...extraEnv },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// 2. Capture: sha == git rev-parse HEAD
+// ---------------------------------------------------------------------------
+{
+  const { dir, head } = makeRepo();
+  const sink = join(dir, 'sink.jsonl');
+  // Point Supabase at an unreachable host so the test never touches a real DB;
+  // capture still writes the sink, which is what we assert on.
+  const res = runHook({
+    hook_event_name: 'PostToolUse',
+    tool_name: 'Bash',
+    session_id: 'sess-capture-1',
+    cwd: dir,
+    tool_input: { command: `git commit -m "feat: thing for ${WI}"` },
+    tool_response: { exit_code: 0, stdout: '1 file changed' },
+  }, {
+    RDC_COMMIT_CAPTURE_SINK: sink,
+    SUPABASE_URL: 'http://127.0.0.1:9',     // unreachable -> DB insert fails fast, capture still records sink
+    SUPABASE_SERVICE_ROLE_KEY: 'test-key-not-real',
+  });
+  assert('capture: hook exits zero', res.status === 0, res.stderr);
+  assert('capture: sink written', existsSync(sink), 'no sink file');
+  if (existsSync(sink)) {
+    const row = JSON.parse(readFileSync(sink, 'utf8').trim().split('\n')[0]);
+    assert('capture: sha equals real HEAD', row.sha === head, `${row.sha} !== ${head}`);
+    assert('capture: work_item_id parsed', row.work_item_id === WI, row.work_item_id);
+    assert('capture: session_id recorded', row.session_id === 'sess-capture-1', row.session_id);
+  }
+  rmSync(dir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// 3. No active work item -> NO-OP (no sink row)
+// ---------------------------------------------------------------------------
+{
+  const { dir } = makeRepo();
+  const sink = join(dir, 'sink.jsonl');
+  const res = runHook({
+    hook_event_name: 'PostToolUse',
+    tool_name: 'Bash',
+    session_id: 'sess-no-item',
+    cwd: dir,
+    tool_input: { command: 'git commit -m "feat: no work item ref"' },
+    tool_response: { exit_code: 0 },
+  }, { RDC_COMMIT_CAPTURE_SINK: sink });
+  assert('no-item: hook exits zero', res.status === 0, res.stderr);
+  assert('no-item: no sink row written', !existsSync(sink), 'orphan capture written for no-item commit');
+  rmSync(dir, { recursive: true, force: true });
+}
+
+// ---------------------------------------------------------------------------
+// 4. PreToolUse legacy behavior preserved (warn-only, never blocks)
+//    Uses a fresh temp dir as HOME/USERPROFILE so no fixit.marker is visible
+//    regardless of real machine state — makes the warn-path assertion deterministic.
+// ---------------------------------------------------------------------------
+{
+  const fakeHome = mkdtempSync(join(tmpdir(), 'wic-home-'));
+  try {
+    const preEnv = { HOME: fakeHome, USERPROFILE: fakeHome };
+
+    const res = runHook({
+      hook_event_name: 'PreToolUse',
+      tool_name: 'Bash',
+      tool_input: { command: 'git commit -m "no convention and no uuid"' },
+    }, preEnv);
+    assert('pre: warn exits zero (never blocks)', res.status === 0, res.stderr);
+    assert('pre: emits warn systemMessage', /no work item reference/.test(res.stdout), res.stdout);
+
+    const ok = runHook({
+      hook_event_name: 'PreToolUse',
+      tool_name: 'Bash',
+      tool_input: { command: 'git commit -m "feat(x): conventional"' },
+    }, preEnv);
+    assert('pre: conventional passes silently', ok.status === 0 && ok.stdout.trim() === '', ok.stdout);
+  } finally {
+    rmSync(fakeHome, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+if (failures.length > 0) {
+  console.error('\ncommit-capture hook tests — FAIL\n');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('commit-capture hook tests — PASS');

package/tests/run-evidence-gate.test.mjs

@@ -1,82 +1,82 @@
-#!/usr/bin/env node
-/**
- * Truth Gate 3.0 — fused run-evidence-gate primitive tests.
- *
- * Proves the Nidus property: evidence cannot exist without a run.
- *   - a verdict is emitted ONLY after the command runs (no run => no pass).
- *   - the output hash is server-side and derived from the actual run.
- *   - isMachineArtifact rejects prose and accepts captured machine shapes.
- *
- * Run: node tests/run-evidence-gate.test.mjs
- */
-import { resolve, dirname, join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const LIB = pathToFileURL(join(resolve(__dirname, '..'), 'hooks', 'lib', 'run-evidence-gate.mjs')).href;
-const { runEvidenceGate, isMachineArtifact, hashOutput, EVIDENCE_KIND } = await import(LIB);
-
-const failures = [];
-function assert(name, cond, detail = '') {
-  if (!cond) failures.push(`${name}${detail ? `: ${detail}` : ''}`);
-  else process.stdout.write(`  ok  ${name}\n`);
-}
-
-// --- 1. A passing run produces verdict:'pass' WITH a hash, only after running.
-let ranCount = 0;
-const passArt = runEvidenceGate(
-  { command: 'noop', args: ['x'], label: 'unit-pass' },
-  () => { ranCount += 1; return { status: 0, stdout: 'ok', stderr: '' }; },
-);
-assert('runner invoked exactly once', ranCount === 1, String(ranCount));
-assert('pass: kind stamped', passArt.kind === EVIDENCE_KIND);
-assert('pass: ran=true', passArt.ran === true);
-assert('pass: verdict=pass', passArt.verdict === 'pass', passArt.verdict);
-assert('pass: output_sha256 present', typeof passArt.output_sha256 === 'string' && passArt.output_sha256.length === 64, passArt.output_sha256);
-
-// --- 2. A failing run -> verdict:'fail', never silently pass.
-const failArt = runEvidenceGate(
-  { command: 'noop' },
-  () => ({ status: 7, stdout: '', stderr: 'boom' }),
-);
-assert('fail: verdict=fail', failArt.verdict === 'fail', failArt.verdict);
-assert('fail: exit_code preserved', failArt.exit_code === 7, String(failArt.exit_code));
-
-// --- 3. NO RUN -> NO verdict (fail-closed). Invalid spec.
-const noCmd = runEvidenceGate({});
-assert('no-command: ran=false', noCmd.ran === false);
-assert('no-command: verdict=error (never pass)', noCmd.verdict === 'error', noCmd.verdict);
-
-// --- 4. Runner that yields no exit status -> cannot have run -> error.
-const noStatus = runEvidenceGate({ command: 'noop' }, () => ({ status: null, stdout: '', stderr: '' }));
-assert('no-status: ran=false', noStatus.ran === false);
-assert('no-status: verdict=error', noStatus.verdict === 'error', noStatus.verdict);
-
-// --- 5. Runner throws -> fail-closed error, never pass.
-const threw = runEvidenceGate({ command: 'noop' }, () => { throw new Error('spawn failed'); });
-assert('runner-throws: ran=false', threw.ran === false);
-assert('runner-throws: verdict=error', threw.verdict === 'error', threw.verdict);
-
-// --- 6. Hash is deterministic + derived from the captured combined output.
-assert('hash deterministic', hashOutput('abc') === hashOutput('abc'));
-assert('hash differs by content', hashOutput('abc') !== hashOutput('abd'));
-
-// --- 7. isMachineArtifact discrimination.
-assert('reject bare prose "HTTP 200"', isMachineArtifact('HTTP 200') === false);
-assert('reject bare prose "works"', isMachineArtifact('works') === false);
-assert('reject "107 nodes"', isMachineArtifact('107 nodes') === false);
-assert('accept fused artifact', isMachineArtifact(passArt) === true);
-assert('accept {exit_code}', isMachineArtifact({ exit_code: 0 }) === true);
-assert('accept {http_status}', isMachineArtifact({ http_status: 200 }) === true);
-assert('accept {rowcount}', isMachineArtifact({ rowcount: 12 }) === true);
-assert('accept {passed,total}', isMachineArtifact({ passed: 5, total: 5 }) === true);
-assert('accept JSON string of machine shape', isMachineArtifact('{"exit_code":0}') === true);
-assert('reject plain object', isMachineArtifact({ note: 'done' }) === false);
-assert('reject null', isMachineArtifact(null) === false);
-
-if (failures.length > 0) {
-  console.error('\nrun-evidence-gate tests — FAIL\n');
-  for (const f of failures) console.error(`  - ${f}`);
-  process.exit(1);
-}
-console.log('\nrun-evidence-gate tests — PASS');
+#!/usr/bin/env node
+/**
+ * Truth Gate 3.0 — fused run-evidence-gate primitive tests.
+ *
+ * Proves the Nidus property: evidence cannot exist without a run.
+ *   - a verdict is emitted ONLY after the command runs (no run => no pass).
+ *   - the output hash is server-side and derived from the actual run.
+ *   - isMachineArtifact rejects prose and accepts captured machine shapes.
+ *
+ * Run: node tests/run-evidence-gate.test.mjs
+ */
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LIB = pathToFileURL(join(resolve(__dirname, '..'), 'hooks', 'lib', 'run-evidence-gate.mjs')).href;
+const { runEvidenceGate, isMachineArtifact, hashOutput, EVIDENCE_KIND } = await import(LIB);
+
+const failures = [];
+function assert(name, cond, detail = '') {
+  if (!cond) failures.push(`${name}${detail ? `: ${detail}` : ''}`);
+  else process.stdout.write(`  ok  ${name}\n`);
+}
+
+// --- 1. A passing run produces verdict:'pass' WITH a hash, only after running.
+let ranCount = 0;
+const passArt = runEvidenceGate(
+  { command: 'noop', args: ['x'], label: 'unit-pass' },
+  () => { ranCount += 1; return { status: 0, stdout: 'ok', stderr: '' }; },
+);
+assert('runner invoked exactly once', ranCount === 1, String(ranCount));
+assert('pass: kind stamped', passArt.kind === EVIDENCE_KIND);
+assert('pass: ran=true', passArt.ran === true);
+assert('pass: verdict=pass', passArt.verdict === 'pass', passArt.verdict);
+assert('pass: output_sha256 present', typeof passArt.output_sha256 === 'string' && passArt.output_sha256.length === 64, passArt.output_sha256);
+
+// --- 2. A failing run -> verdict:'fail', never silently pass.
+const failArt = runEvidenceGate(
+  { command: 'noop' },
+  () => ({ status: 7, stdout: '', stderr: 'boom' }),
+);
+assert('fail: verdict=fail', failArt.verdict === 'fail', failArt.verdict);
+assert('fail: exit_code preserved', failArt.exit_code === 7, String(failArt.exit_code));
+
+// --- 3. NO RUN -> NO verdict (fail-closed). Invalid spec.
+const noCmd = runEvidenceGate({});
+assert('no-command: ran=false', noCmd.ran === false);
+assert('no-command: verdict=error (never pass)', noCmd.verdict === 'error', noCmd.verdict);
+
+// --- 4. Runner that yields no exit status -> cannot have run -> error.
+const noStatus = runEvidenceGate({ command: 'noop' }, () => ({ status: null, stdout: '', stderr: '' }));
+assert('no-status: ran=false', noStatus.ran === false);
+assert('no-status: verdict=error', noStatus.verdict === 'error', noStatus.verdict);
+
+// --- 5. Runner throws -> fail-closed error, never pass.
+const threw = runEvidenceGate({ command: 'noop' }, () => { throw new Error('spawn failed'); });
+assert('runner-throws: ran=false', threw.ran === false);
+assert('runner-throws: verdict=error', threw.verdict === 'error', threw.verdict);
+
+// --- 6. Hash is deterministic + derived from the captured combined output.
+assert('hash deterministic', hashOutput('abc') === hashOutput('abc'));
+assert('hash differs by content', hashOutput('abc') !== hashOutput('abd'));
+
+// --- 7. isMachineArtifact discrimination.
+assert('reject bare prose "HTTP 200"', isMachineArtifact('HTTP 200') === false);
+assert('reject bare prose "works"', isMachineArtifact('works') === false);
+assert('reject "107 nodes"', isMachineArtifact('107 nodes') === false);
+assert('accept fused artifact', isMachineArtifact(passArt) === true);
+assert('accept {exit_code}', isMachineArtifact({ exit_code: 0 }) === true);
+assert('accept {http_status}', isMachineArtifact({ http_status: 200 }) === true);
+assert('accept {rowcount}', isMachineArtifact({ rowcount: 12 }) === true);
+assert('accept {passed,total}', isMachineArtifact({ passed: 5, total: 5 }) === true);
+assert('accept JSON string of machine shape', isMachineArtifact('{"exit_code":0}') === true);
+assert('reject plain object', isMachineArtifact({ note: 'done' }) === false);
+assert('reject null', isMachineArtifact(null) === false);
+
+if (failures.length > 0) {
+  console.error('\nrun-evidence-gate tests — FAIL\n');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('\nrun-evidence-gate tests — PASS');

package/tests/skill-test-matrix.test.mjs

@@ -1,66 +1,66 @@
-#!/usr/bin/env node
-import assert from 'node:assert/strict';
-import { readdirSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-
-import { loadAllManifests } from '../scripts/lib/manifest-schema.mjs';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const root = resolve(__dirname, '..');
-const testsDir = join(root, 'skills', 'tests');
-const matrixPath = join(testsDir, 'MATRIX.md');
-const readmePath = join(testsDir, 'README.md');
-
-const manifestFiles = readdirSync(testsDir).filter((name) => name.endsWith('.test.json')).sort();
-const manifests = loadAllManifests(testsDir);
-const valid = manifests.filter((entry) => entry.ok && entry.manifest);
-const matrix = readFileSync(matrixPath, 'utf8');
-const readme = readFileSync(readmePath, 'utf8');
-
-assert.equal(valid.length, manifestFiles.length, 'all manifest files must validate');
-assert.match(matrix, new RegExp(`Current coverage: ${manifestFiles.length} manifests for ${manifestFiles.length} skill directories`));
-assert.match(readme, new RegExp(`There are currently ${manifestFiles.length} manifests for ${manifestFiles.length} skill directories`));
-
-const rows = new Map();
-for (const line of matrix.split(/\r?\n/)) {
-  const m = line.match(/^\| `([^`]+)` \| `([^`]+)` \| ([^|]+) \| ([^|]+) \| ([^|]+) \|$/);
-  if (!m) continue;
-  rows.set(m[1], {
-    manifest: m[2],
-    promptClass: m[3].trim(),
-    assertions: m[4].replace(/`/g, '').trim(),
-    acceptanceDepth: m[5].trim(),
-  });
-}
-
-assert.equal(rows.size, manifestFiles.length, 'MATRIX.md must list every manifest exactly once');
-
-for (const entry of valid) {
-  const manifest = entry.manifest;
-  const filename = entry.file.replace(/^skills\/tests\//, '');
-  const row = rows.get(manifest.skill);
-  assert.ok(row, `${manifest.skill} missing from MATRIX.md`);
-  assert.equal(row.manifest, filename, `${manifest.skill} matrix filename mismatch`);
-
-  for (const key of Object.keys(manifest.assertions || {}).sort()) {
-    assert.match(row.assertions, new RegExp(`(^|, )${key}(,|$)`), `${manifest.skill} matrix must mention assertion ${key}`);
-  }
-
-  const hasAcceptance = manifest.acceptance && Object.keys(manifest.acceptance).length > 0;
-  if (hasAcceptance) {
-    assert.notEqual(row.acceptanceDepth, 'Basic manifest', `${manifest.skill} has acceptance checks but matrix says Basic manifest`);
-  } else {
-    assert.equal(row.acceptanceDepth, 'Basic manifest', `${manifest.skill} has no acceptance block and should be documented as Basic manifest`);
-  }
-}
-
-const shallow = valid
-  .map((entry) => entry.manifest)
-  .filter((manifest) => !manifest.acceptance || Object.keys(manifest.acceptance).length === 0)
-  .map((manifest) => manifest.skill);
-assert.deepEqual(shallow, [], `all skill manifests must include acceptance checks; missing: ${shallow.join(', ')}`);
-assert.match(matrix, /All manifests now include a deeper acceptance block/);
-
-console.log('skill test matrix tests — PASS');
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+import { loadAllManifests } from '../scripts/lib/manifest-schema.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, '..');
+const testsDir = join(root, 'skills', 'tests');
+const matrixPath = join(testsDir, 'MATRIX.md');
+const readmePath = join(testsDir, 'README.md');
+
+const manifestFiles = readdirSync(testsDir).filter((name) => name.endsWith('.test.json')).sort();
+const manifests = loadAllManifests(testsDir);
+const valid = manifests.filter((entry) => entry.ok && entry.manifest);
+const matrix = readFileSync(matrixPath, 'utf8');
+const readme = readFileSync(readmePath, 'utf8');
+
+assert.equal(valid.length, manifestFiles.length, 'all manifest files must validate');
+assert.match(matrix, new RegExp(`Current coverage: ${manifestFiles.length} manifests for ${manifestFiles.length} skill directories`));
+assert.match(readme, new RegExp(`There are currently ${manifestFiles.length} manifests for ${manifestFiles.length} skill directories`));
+
+const rows = new Map();
+for (const line of matrix.split(/\r?\n/)) {
+  const m = line.match(/^\| `([^`]+)` \| `([^`]+)` \| ([^|]+) \| ([^|]+) \| ([^|]+) \|$/);
+  if (!m) continue;
+  rows.set(m[1], {
+    manifest: m[2],
+    promptClass: m[3].trim(),
+    assertions: m[4].replace(/`/g, '').trim(),
+    acceptanceDepth: m[5].trim(),
+  });
+}
+
+assert.equal(rows.size, manifestFiles.length, 'MATRIX.md must list every manifest exactly once');
+
+for (const entry of valid) {
+  const manifest = entry.manifest;
+  const filename = entry.file.replace(/^skills\/tests\//, '');
+  const row = rows.get(manifest.skill);
+  assert.ok(row, `${manifest.skill} missing from MATRIX.md`);
+  assert.equal(row.manifest, filename, `${manifest.skill} matrix filename mismatch`);
+
+  for (const key of Object.keys(manifest.assertions || {}).sort()) {
+    assert.match(row.assertions, new RegExp(`(^|, )${key}(,|$)`), `${manifest.skill} matrix must mention assertion ${key}`);
+  }
+
+  const hasAcceptance = manifest.acceptance && Object.keys(manifest.acceptance).length > 0;
+  if (hasAcceptance) {
+    assert.notEqual(row.acceptanceDepth, 'Basic manifest', `${manifest.skill} has acceptance checks but matrix says Basic manifest`);
+  } else {
+    assert.equal(row.acceptanceDepth, 'Basic manifest', `${manifest.skill} has no acceptance block and should be documented as Basic manifest`);
+  }
+}
+
+const shallow = valid
+  .map((entry) => entry.manifest)
+  .filter((manifest) => !manifest.acceptance || Object.keys(manifest.acceptance).length === 0)
+  .map((manifest) => manifest.skill);
+assert.deepEqual(shallow, [], `all skill manifests must include acceptance checks; missing: ${shallow.join(', ')}`);
+assert.match(matrix, /All manifests now include a deeper acceptance block/);
+
+console.log('skill test matrix tests — PASS');