@bongos/core 1.19.817 → 1.19.819

package/tests/routine_capture_kind.mjs

@@ -0,0 +1,147 @@
+// tests/routine_capture_kind.mjs — a routine that files its findings must name a
+// kind the server accepts (task 1003694).
+//
+// THE FAILURE THIS PINS. .claude/scheduled-tasks/dep-audit-nightly/SKILL.md filed
+// with `--kind security`. That is not one of the kinds — captureIdea throws BAD_KIND
+// and the route 400s — so the capture step of that nightly routine had NEVER filed
+// anything.
+//
+// It is quiet in the worst way. The routine still runs, still does the audit, and
+// only the step that turns a finding into a durable row fails. There is no
+// accumulating queue whose emptiness would look wrong, so nothing ever looked wrong.
+// A scheduled routine cannot notice its own silence, which is exactly why this is a
+// test and not a runtime check.
+//
+// Run:  node tests/routine_capture_kind.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { VALID_KINDS } = require('../modules/ideas/inbox.js');
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Every SKILL.md that could carry a capture command: the scheduled routines and the
+// skills. A routine is the dangerous case (nobody reads its output), but a skill with
+// a bad kind wastes a builder's time the same way.
+function skillFiles() {
+  const out = [];
+  const roots = [
+    path.join(REPO_ROOT, '.claude', 'scheduled-tasks'),
+    path.join(REPO_ROOT, '.claude', 'skills'),
+  ];
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+    for (const d of readdirSync(root, { withFileTypes: true })) {
+      if (!d.isDirectory()) continue;
+      const p = path.join(root, d.name, 'SKILL.md');
+      if (existsSync(p)) out.push(p);
+    }
+  }
+  return out;
+}
+
+// `--kind foo` — a LITERAL kind, on a CAPTURE command only.
+//
+// Both narrowings are load-bearing, and I got each wrong first:
+//
+//   - CAPTURE ONLY. `--kind` is not unique to capture.js. recall.js takes its own
+//     `--kind doc|db`, and a matcher that reads every `--kind` in the tree reports
+//     three recall invocations as broken. A guard whose first run is mostly noise
+//     is a guard people learn to suppress.
+//   - LITERAL ONLY. A placeholder (`--kind <bug|cleanup>`, `--kind cleanup|refactor`)
+//     documents a CHOICE rather than passing a value; overnight-code-review and
+//     repo-simplify-sweep both use that form deliberately.
+const CAPTURE_LINE_RE = /capture\.js/;
+const KIND_RE = /--kind\s+([a-z][a-z0-9-]*)(?=[\s`'"]|$)/g;
+
+// A capture command can wrap across lines with a trailing backslash, so the unit of
+// inspection is the command, not the line: a run of lines joined while the previous
+// one ends in `\`.
+function captureCommands(text) {
+  const lines = String(text || '').split('\n');
+  const out = [];
+  let buf = null;
+  for (const line of lines) {
+    const continues = /\\\s*$/.test(line);
+    if (buf !== null) {
+      buf += ' ' + line;
+      if (!continues) { out.push(buf); buf = null; }
+    } else if (CAPTURE_LINE_RE.test(line)) {
+      if (continues) buf = line;
+      else out.push(line);
+    }
+  }
+  if (buf !== null) out.push(buf);
+  return out;
+}
+
+function literalKinds(text) {
+  const out = [];
+  for (const cmd of captureCommands(text)) {
+    for (const m of cmd.matchAll(KIND_RE)) {
+      const after = cmd.slice(m.index + m[0].length, m.index + m[0].length + 1);
+      if (after === '|') continue; // `--kind cleanup|refactor` — a menu, not a value
+      out.push(m[1]);
+    }
+  }
+  return out;
+}
+
+test('every literal --kind in a routine or skill is a kind the server accepts', () => {
+  const files = skillFiles();
+  // The scan must not pass by finding nothing: these files exist, and at least one of
+  // them documents a capture command.
+  assert.ok(files.length > 0, 'found no SKILL.md files at all — the scan is broken, not clean');
+
+  const bad = [];
+  let seen = 0;
+  for (const f of files) {
+    for (const kind of literalKinds(readFileSync(f, 'utf8'))) {
+      seen += 1;
+      if (!VALID_KINDS.includes(kind)) bad.push(`${path.relative(REPO_ROOT, f)}: --kind ${kind}`);
+    }
+  }
+  assert.ok(seen > 0, 'no literal --kind found anywhere — the pattern has drifted, and this test would pass an empty repo');
+  assert.deepEqual(bad, [],
+    `these file a kind the server rejects with a 400 — for a SCHEDULED routine that means its findings are silently never filed:\n  ${bad.join('\n  ')}\n`
+    + `Valid kinds: ${VALID_KINDS.join(', ')}`);
+});
+
+test('the matcher reads a literal kind on a capture command', () => {
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind infra --body-file x'), ['infra']);
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind security'), ['security'],
+    'the real bug is still caught');
+});
+
+test('a DIFFERENT tool\'s --kind is not this guard\'s business', () => {
+  // recall.js takes --kind doc|db. Reading every --kind in the tree reported three
+  // recall invocations as broken on the first run of this guard.
+  assert.deepEqual(literalKinds('node scripts/gds/recall.js nightly backup --kind doc'), []);
+  assert.deepEqual(literalKinds('add `--kind doc` for ADRs/recipes'), []);
+});
+
+test('a documented menu is not a value', () => {
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind <bug|cleanup|refactor>'), []);
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind cleanup|refactor \\'), []);
+});
+
+test('a capture command wrapped over lines is still read', () => {
+  const text = ['node scripts/gds/capture.js "t" \\', '  --kind security \\', '  --body-file /tmp/x'].join('\n');
+  assert.deepEqual(literalKinds(text), ['security'],
+    'dep-audit-nightly writes exactly this shape — a line-at-a-time matcher misses it');
+});
+
+test('dep-audit-nightly specifically now files with an accepted kind (task 1003694)', () => {
+  const p = path.join(REPO_ROOT, '.claude', 'scheduled-tasks', 'dep-audit-nightly', 'SKILL.md');
+  const src = readFileSync(p, 'utf8');
+  assert.ok(!/--kind\s+security\b/.test(src), 'security is not a kind and never was');
+  const kinds = literalKinds(src);
+  assert.ok(kinds.length > 0, 'the routine must still file something');
+  for (const k of kinds) assert.ok(VALID_KINDS.includes(k), `${k} is not a valid kind`);
+});

package/tests/skill_preflight.mjs

@@ -140,6 +140,51 @@ test('the live tree passes the declare-check', () => {
   assert.equal(r.hardFail, false, `unexpected:\n  ${r.violations.join('\n  ')}`);
 });
 
+// ---- CRLF (task 1003754) --------------------------------------------------
+//
+// Every regex in skill-preflight is anchored on \n, starting with the frontmatter
+// fence /^---\n/. SKILL.md files are CRLF in a Windows checkout — .gitattributes
+// pins *.js, *.json, *.sh and *.sql, but Markdown falls through `* text=auto` — so
+// the frontmatter never matched and parseRequires reported `declared: false` for
+// EVERY skill.
+//
+// The visible symptom was one red test below. The real damage was quieter: fitness
+// check G03 compares a skill's fenced commands against its declaration, and with
+// nothing parsed as declared it had nothing to compare — '0 declare a machine
+// contract'. The guard against a skill's ops commands outrunning its declaration was
+// INERT on Windows, which is a false green, not a false red.
+
+test('parseRequires reads a CRLF frontmatter identically to an LF one (task 1003754)', () => {
+  const lf = '---\nname: x\nrequires: [gh, main-checkout]\n---\nbody\n';
+  const crlf = lf.replace(/\n/g, '\r\n');
+  assert.deepEqual(sp.parseRequires(crlf), sp.parseRequires(lf),
+    'a checkout\'s line endings must not change what a skill is understood to require');
+  assert.deepEqual(sp.parseRequires(crlf).requires, ['gh', 'main-checkout']);
+  assert.equal(sp.parseRequires(crlf).declared, true);
+});
+
+test('the dash-list form survives CRLF too', () => {
+  const crlf = '---\r\nname: x\r\nrequires:\r\n  - gh\r\n  - droplet-ssh\r\n---\r\nbody\r\n';
+  assert.deepEqual(sp.parseRequires(crlf).requires, ['gh', 'droplet-ssh']);
+});
+
+test('inferRequired reads CRLF fenced commands (task 1003754)', () => {
+  // The half that would silently stop CATCHING an undeclared ops command.
+  const crlf = '---\r\nname: x\r\n---\r\n```bash\r\ngit push origin main\r\n```\r\n';
+  assert.ok(sp.inferRequired(crlf).includes('push-credential'),
+    'a main-push in a CRLF skill must still imply a push credential, or G03 cannot catch it');
+});
+
+test('the live corpus is NOT empty — G03 has something to compare (task 1003754)', () => {
+  // The check\'s own note read "0 declare a machine contract" on Windows. A guard
+  // with an empty corpus passes whatever the skills do.
+  const r = sp.checkOpsSkillsDeclareMachine();
+  const n = Number(/(\d+) declare a machine contract/.exec(r.note || '')?.[1] ?? 0);
+  assert.ok(n > 0,
+    `no skill parsed as declaring a machine contract, so check G03 has nothing to compare and `
+    + `cannot fail. Note was: ${r.note}`);
+});
+
 test('merge-mode really declares the machine it needs', () => {
   // The skill at the centre of the incident.
   const r = sp.preflightSkill('merge-mode', caps);