@bongos/core 1.20.6 → 1.20.8

package/tests/craft_mode.mjs

@@ -0,0 +1,141 @@
+// tests/craft_mode.mjs — the claimed craft's pack pointer is INJECTED, not
+// printed (task 1002992).
+//
+// Four altitudes: the server helper over the real registry, the /me wiring, the
+// Conductor's worktree-scoped relay, and claim.js — which now prints one role line
+// but must still land a ui claim's module-owned skills (the regression this task
+// was most likely to ship). The hook itself is run end to end, against the
+// helper's real output, in tests/conductor_main_e2e.mjs.
+//
+// Run:  node tests/craft_mode.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const craft = require('../src/bongos/craft-mode.js');
+const conductor = require('../.claude/hooks/conductor.js');
+const { test, summary } = makeRunner();
+
+const REGISTRY = path.join(ROOT, 'scripts', 'gds', 'discipline-modes.json');
+const MODES = craft.readModes();
+
+// ---- the helper, over the ONE registry ---------------------------------------
+await test('the server reads the same registry file claim.js and fitness read', () => {
+  assert.deepEqual(MODES, JSON.parse(fs.readFileSync(REGISTRY, 'utf8')).modes);
+});
+
+await test('every registry craft yields a contract naming its pack or skill, with its directive', () => {
+  const names = Object.keys(MODES);
+  assert.ok(names.length >= 3, 'the registry was read at all');
+  for (const d of names) {
+    const m = craft.describeCraftMode(d, MODES);
+    assert.ok(m && m.inject, `${d} injects`);
+    assert.equal(m.discipline, d);
+    const pointer = MODES[d].pack || `/${MODES[d].skill}`;
+    assert.ok(m.contract.includes(pointer), `${d} names ${pointer}`);
+    assert.ok(m.contract.includes(MODES[d].directive.slice(0, 40)), `${d} carries its directive`);
+  }
+  assert.match(craft.describeCraftMode('engineer', MODES).contract, /read docs\/packs\/engineer\.md/);
+  assert.match(craft.describeCraftMode('ui', MODES).contract, /— \/design/, 'a skill is a command to invoke, not a file to read');
+});
+
+await test('fail-open: no craft, an unknown craft, or an unreadable registry yields nothing', () => {
+  assert.equal(craft.describeCraftMode(null, MODES), null);
+  assert.equal(craft.describeCraftMode('governor', MODES), null);
+  assert.equal(craft.describeCraftMode('engineer', null), null);
+  assert.deepEqual(craft.readModes(path.join(os.tmpdir(), 'no-such-registry.json')), {});
+  const bad = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'craft-')), 'modes.json');
+  fs.writeFileSync(bad, '{ not json');
+  assert.deepEqual(craft.readModes(bad), {});
+});
+
+await test('the default registry is read once per process; an explicit file is read fresh', () => {
+  assert.equal(craft.readModes(), craft.readModes(), 'GET /me does not re-read and re-parse per request');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'craft-'));
+  const f = path.join(dir, 'modes.json');
+  fs.writeFileSync(f, JSON.stringify({ modes: { a: { directive: 'x' } } }));
+  assert.deepEqual(Object.keys(craft.readModes(f)), ['a']);
+  fs.writeFileSync(f, JSON.stringify({ modes: { b: { directive: 'y' } } }));
+  assert.deepEqual(Object.keys(craft.readModes(f)), ['b'], 'claim.js always sees the file as it is now');
+});
+
+// ---- /me carries it on each claim ---------------------------------------------
+await test('GET /me puts each claim\'s craft_mode on the claim, from the helper', () => {
+  const me = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/me.js'), 'utf8');
+  assert.match(me, /require\('\.\.\/craft-mode'\)/);
+  assert.match(me, /craft_mode: describeCraftMode\(c\.discipline, craftModes\)/);
+  assert.doesNotMatch(me, /"modes"\s*:/, 'no second copy of the registry in the route');
+});
+
+// ---- the Conductor relays THIS worktree's craft only ---------------------------
+const claim = (id, discipline) => ({ task_id: String(id), title: 't', touches: [], worktree_name: `task-${id}`, discipline, craft_mode: craft.describeCraftMode(discipline, MODES) });
+const craftIds = (out) => out.filter((a) => String(a.id).startsWith('craft:')).map((a) => a.id);
+
+await test('the claim bound to this worktree gets its craft; the other tree\'s does not', () => {
+  const claims = [claim(1, 'engineer'), claim(2, 'ideator')];
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: 'task-1' })), ['craft:engineer']);
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: 'task-2' })), ['craft:ideator']);
+});
+
+await test('no bound claim, no session, or no registry entry: nothing is injected', () => {
+  const claims = [claim(1, 'engineer')];
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: 'task-9' })), [], 'an unrelated tree');
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: null })), [], 'not in a worktree');
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: null, worktree: 'task-1' })), [], 'no session / no network');
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: [{ ...claim(1, 'governor') }], worktree: 'task-1' })), [], 'a craft with no entry');
+  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: [{ ...claim(1, 'engineer'), craft_mode: { inject: true, contract: '' } }], worktree: 'task-1' })), [], 'an empty contract');
+});
+
+// ---- claim.js: one role line, and the ui skills still land ---------------------
+const claimCli = require('../scripts/gds/claim.js');
+const materialize = require('../scripts/gds/claude-materialize.js');
+
+function capture(fn) {
+  const lines = [];
+  const orig = console.log;
+  console.log = (...a) => { lines.push(a.join(' ')); };
+  try { fn(); } finally { console.log = orig; }
+  return lines.filter((l) => l !== '');
+}
+
+await test('claim.js prints exactly one role line and no directive block', () => {
+  const lines = capture(() => claimCli.printRoleLine({ discipline: 'engineer' }));
+  assert.deepEqual(lines, ['▶ Engineering session — read docs/packs/engineer.md']);
+  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/claim.js'), 'utf8');
+  assert.doesNotMatch(src, /mode\.directive\}/, 'the directive is no longer printed');
+  assert.doesNotMatch(src, /Your pack:/);
+});
+
+await test('claiming a ui task STILL materialises its module-owned skills', () => {
+  const saved = { into: materialize.materializeModuleSkillsIntoCore, root: materialize.isCoreCheckoutRoot };
+  const calls = [];
+  materialize.isCoreCheckoutRoot = () => true;
+  materialize.materializeModuleSkillsIntoCore = (opts) => { calls.push(opts); return { materialized: ['impeccable', 'minimalist-ui'] }; };
+  try {
+    const lines = capture(() => claimCli.printRoleLine({ discipline: 'ui' }));
+    assert.equal(calls.length, 1, 'the ui claim landed its skills');
+    assert.equal(lines[0], '▶ UI design session — /design');
+    assert.match(lines[1], /2 module-owned skill\(s\)/);
+    calls.length = 0;
+    capture(() => claimCli.printRoleLine({ discipline: 'engineer' }));
+    assert.equal(calls.length, 0, 'a craft that did not opt in lands nothing');
+  } finally {
+    materialize.materializeModuleSkillsIntoCore = saved.into;
+    materialize.isCoreCheckoutRoot = saved.root;
+  }
+});
+
+await test('claim.js fails open: no craft or an unknown craft prints nothing and never throws', () => {
+  assert.deepEqual(capture(() => claimCli.printRoleLine({})), []);
+  assert.deepEqual(capture(() => claimCli.printRoleLine({ discipline: 'governor' })), []);
+  assert.deepEqual(capture(() => claimCli.printRoleLine(null)), []);
+});
+
+summary();

package/tests/find_untested.mjs

@@ -0,0 +1,137 @@
+// tests/find_untested.mjs
+//
+// Unit test for scripts/gds/find-untested.js (task 1002458) — the finder the newcomer
+// "add a unit test" chore runs instead of a hardcoded target list. The cases pin the two
+// failures that made the naive scans unusable, measured before it was built:
+//   - BASENAME matching falsely marks a common-word module (settings.js) as tested because
+//     some unrelated test mentions a different settings.js;
+//   - LITERAL-require-only scanning misses tests that reach a module through
+//     path.join(ROOT, …), a `const GOV = path.join(…)` prefix, or a spawned script — which is
+//     how it once flagged the well-tested memory-map.js as untested.
+// Plus the purity heuristic, the ranking, and one pass over the live tree. Run:
+// node tests/find_untested.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const fu = require('../scripts/gds/find-untested.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); } catch (e) { failed++; console.log(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+const MODS = new Set([
+  'modules/builder-settings/settings.js',
+  'modules/hall-ui/settings.js',
+  'modules/government/db.js',
+  'modules/government/board.js',
+  'scripts/gds/memory-map.js',
+  'scripts/gds/grade-smoke.js',
+  'modules/lifecycle/index.js',
+]);
+const hits = (src, file) => [...fu.extractPathRefs(src, file)].map((r) => fu.resolveRef(r, MODS)).filter(Boolean).sort();
+
+test('a basename alone never resolves to a module (the common-word false drop)', () => {
+  assert.deepEqual(hits("const s = require('./settings.js'); // settings.js", 'tests/x.mjs'), []);
+  assert.deepEqual(hits("import x from 'settings.js'", 'tests/x.mjs'), []);
+});
+
+test('a full or relative path resolves to exactly that module, not its namesake', () => {
+  assert.deepEqual(hits("require('../modules/hall-ui/settings.js')", 'tests/x.mjs'), ['modules/hall-ui/settings.js']);
+  assert.deepEqual(hits("require('modules/builder-settings/settings')", 'tests/x.mjs'), ['modules/builder-settings/settings.js']);
+});
+
+test('path.join(ROOT, …) segments, and a const prefix, are evaluated (the memory-map miss)', () => {
+  const src = [
+    "const ROOT = path.resolve(__dirname, '..');",
+    "const GOV = path.join(ROOT, 'modules', 'government');",
+    "const db = require(path.join(GOV, 'db.js'));",
+    "const mm = require(path.join(ROOT, 'scripts', 'gds', 'memory-map.js'));",
+  ].join('\n');
+  assert.deepEqual(hits(src, 'tests/x.mjs'), ['modules/government/db.js', 'scripts/gds/memory-map.js']);
+});
+
+test('an unknown leading identifier stands for the repo root; one in the middle does not', () => {
+  assert.deepEqual(hits("path.join(REPO, 'modules/government/board.js')", 'tests/x.mjs'), ['modules/government/board.js']);
+  assert.deepEqual(hits("path.join('modules', someVar, 'board.js')", 'tests/x.mjs'), []);
+});
+
+test('a spawned script, new URL(…, import.meta.url) and a directory index all count', () => {
+  assert.deepEqual(hits("spawnSync(process.execPath, ['scripts/gds/grade-smoke.js', '--dry'])", 'tests/x.mjs'), ['scripts/gds/grade-smoke.js']);
+  assert.deepEqual(hits("await import(new URL('../scripts/gds/memory-map.js', import.meta.url))", 'tests/x.mjs'), ['scripts/gds/memory-map.js']);
+  assert.deepEqual(hits("require('../modules/lifecycle')", 'tests/x.mjs'), ['modules/lifecycle/index.js']);
+});
+
+test('template literals with interpolation and URLs are ignored, not mis-resolved', () => {
+  assert.deepEqual(hits('require(`../modules/${k}/settings.js`)', 'tests/x.mjs'), []);
+  assert.deepEqual(hits("fetch('https://example.com/scripts/gds/memory-map.js')", 'tests/x.mjs'), []);
+});
+
+test('extractRequires separates packages from local edges and ignores comment mentions', () => {
+  const r = fu.extractRequires("const pg = require('pg');\nconst fs = require('node:fs');\nconst b = require('./board');\n// see ./db.js", 'modules/government/x.js');
+  assert.deepEqual([...r.packages].sort(), ['fs', 'pg']);
+  assert.deepEqual([...r.local], ['modules/government/board']);
+});
+
+test('ownImpurity: pg, a db module, child_process and fetch are hard; fs is soft', () => {
+  const imp = (src, file = 'modules/a/x.js') => fu.ownImpurity(src, fu.extractRequires(src, file));
+  assert.deepEqual([...imp("require('pg')").hard], ['postgres']);
+  assert.deepEqual([...imp("require('./db-claims.js')").hard], ['postgres']);
+  assert.deepEqual([...imp("require('node:child_process')").hard], ['subprocess']);
+  assert.deepEqual([...imp('const r = await fetch(url)').hard], ['network']);
+  const f = imp("require('fs')");
+  assert.equal(f.hard.size, 0);
+  assert.equal(f.fs, true);
+  // A name that merely contains "db" is not a database module.
+  assert.equal(imp("require('./feedback.js')").hard.size, 0);
+});
+
+test('isTestPath covers every test root and *.test.js siblings, and nothing else', () => {
+  assert.equal(fu.isTestPath('tests/a.mjs'), true);
+  assert.equal(fu.isTestPath('modules/lifecycle/tests/a.mjs'), true);
+  assert.equal(fu.isTestPath('scripts/gds/newcomer-floor.test.js'), true);
+  assert.equal(fu.isTestPath('scripts/gds/latest.js'), false);
+});
+
+test('hasExports / countExports read CommonJS and ESM', () => {
+  assert.equal(fu.hasExports('function a(){}'), false);
+  assert.equal(fu.countExports('module.exports = {\n  a,\n  b, // note\n  c: 1,\n};'), 3);
+  assert.equal(fu.countExports('exports.x = 1; module.exports.y = 2;'), 2);
+  assert.equal(fu.countExports('export function f(){}\nexport const g = 1;'), 2);
+});
+
+test('normRel clamps a climb above the root instead of escaping it', () => {
+  assert.equal(fu.normRel('tests/../../../scripts/gds/x.js'), 'scripts/gds/x.js');
+  assert.equal(fu.normRel('./a//b/./c'), 'a/b/c');
+  assert.equal(fu.normRel('..'), '');
+});
+
+test('rankCandidates: unreachable first, then no-fs, then smallest', () => {
+  const rows = [
+    { path: 'c', reach: 'indirect', fs: false, lines: 10 },
+    { path: 'b', reach: 'unreachable', fs: true, lines: 500 },
+    { path: 'a', reach: 'indirect', fs: true, lines: 5 },
+    { path: 'd', reach: 'indirect', fs: false, lines: 90 },
+  ];
+  assert.deepEqual(fu.rankCandidates(rows).map((r) => r.path), ['b', 'c', 'd', 'a']);
+});
+
+test('the live tree: tested modules the naive scans got wrong are NOT candidates', () => {
+  const rows = fu.scanTree();
+  const by = new Map(rows.map((r) => [r.path, r]));
+  // A scan that finds nothing looks exactly like a clean tree, so assert it found a lot.
+  assert.ok(rows.length > 300, `expected hundreds of exported modules, scanned ${rows.length}`);
+  for (const p of ['scripts/gds/memory-map.js', 'modules/grading/grader-workers/worker-verdict.js', 'scripts/gds/find-untested.js']) {
+    assert.ok(by.has(p), `${p} should be scanned`);
+    assert.equal(by.get(p).tested, true, `${p} has a test naming it`);
+  }
+  const untested = rows.filter((r) => !r.tested);
+  assert.ok(untested.length > 0 && untested.length < rows.length / 2,
+    `untested should be a minority, got ${untested.length} of ${rows.length}`);
+});
+
+console.log(`\nfind-untested (task 1002458) tests: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/tests/visual_review.mjs

@@ -90,10 +90,12 @@ await test('a backend task is not nudged — no noise on work that renders nothi
   assert.equal(visualReviewNudge(task()), null);
 });
 
-await test('claim.js prints the nudge after the craft directive, and cannot fail a claim with it', () => {
+await test('claim.js prints the nudge after the craft role line, and cannot fail a claim with it', () => {
   const src = read('scripts/gds/claim.js');
   const at = src.indexOf('visualReviewNudge(task)');
-  assert.ok(at > src.indexOf('printDisciplineMode(task);'), 'right after the craft directive');
+  const role = src.indexOf('printRoleLine(task);');
+  assert.ok(role > -1, 'the role line call exists (task 1002992 renamed it from printDisciplineMode)');
+  assert.ok(at > role, 'right after the craft role line');
   assert.match(src.slice(at - 200, at + 300), /catch \(_\)/, 'wrapped, so a hint can never break a successful claim');
 });