@onlooker-community/ecosystem 0.43.2 → 0.43.3

package/test/node/check-bus-coverage.test.mjs

@@ -0,0 +1,160 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { ALL_EVENT_TYPES } from '@onlooker-community/schema';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(HERE, '..', '..');
+const GATE = join(REPO_ROOT, 'scripts', 'lint', 'check-bus-coverage.mjs');
+
+function reportDir(lines) {
+  const dir = mkdtempSync(join(tmpdir(), 'bus-report-'));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, 'emissions.jsonl'),
+    lines.map((l) => JSON.stringify(l)).join('\n') + (lines.length ? '\n' : ''),
+  );
+  return dir;
+}
+
+function manifestFile(manifest) {
+  const dir = mkdtempSync(join(tmpdir(), 'bus-manifest-'));
+  const p = join(dir, 'bus-coverage.json');
+  writeFileSync(p, JSON.stringify(manifest, null, 2));
+  return p;
+}
+
+// Gate A's own tests exercise Gate A only. They must stay hermetic — immune
+// to whatever the real committed manifest expects — so they run against a
+// fixture that expects only session.start (the type the OK fixture below
+// actually emits) and excludes every other registered type. session.start
+// has to sit in `expected`, not `excluded`: Gate B's fourth assertion fails
+// an excluded type that turns up emitted-and-valid, and every Gate A test
+// using OK does emit it.
+function gateAManifest() {
+  const excluded = {};
+  for (const t of ALL_EVENT_TYPES) {
+    if (t !== 'session.start') excluded[t] = 'not exercised by this Gate A fixture';
+  }
+  return { expected: ['session.start'], excluded };
+}
+
+const GATE_A_MANIFEST = manifestFile(gateAManifest());
+
+function run(dir) {
+  const r = spawnSync('node', [GATE, '--report', dir, '--manifest', GATE_A_MANIFEST], {
+    encoding: 'utf8',
+  });
+  return { code: r.status, stdout: r.stdout, stderr: r.stderr };
+}
+
+const OK = { event_type: 'session.start', validated: true, valid: true };
+
+describe('check-bus-coverage gate A', () => {
+  it('passes when every emission validated', () => {
+    const r = run(reportDir([OK, OK]));
+    assert.equal(r.code, 0, r.stderr);
+  });
+
+  it('fails on a rejected emission and names the type', () => {
+    const bad = {
+      event_type: 'librarian.scan.complete',
+      validated: true,
+      valid: false,
+      errors: [{ path: '/outcome', message: 'must be equal to one of the allowed values' }],
+    };
+    const r = run(reportDir([OK, bad]));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /librarian\.scan\.complete/);
+  });
+
+  it('fails when validation never ran, rather than passing vacuously', () => {
+    const unvalidated = { event_type: 'session.start', validated: false, valid: null };
+    const r = run(reportDir([unvalidated, unvalidated]));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /did not resolve|never validated|no emission was validated/i);
+  });
+
+  it('fails when the report is missing entirely', () => {
+    const r = run(mkdtempSync(join(tmpdir(), 'bus-empty-')));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /no emissions recorded/i);
+  });
+});
+
+function runWith(dir, manifestPath) {
+  const r = spawnSync('node', [GATE, '--report', dir, '--manifest', manifestPath], {
+    encoding: 'utf8',
+  });
+  return { code: r.status, stdout: r.stdout, stderr: r.stderr };
+}
+
+// A manifest that accounts for all 125 types, expecting only session.start.
+function fullManifest(expected = ['session.start']) {
+  const excluded = {};
+  for (const t of ALL_EVENT_TYPES) {
+    if (!expected.includes(t)) excluded[t] = 'not emitted in tests';
+  }
+  return { expected, excluded };
+}
+
+describe('check-bus-coverage gate B', () => {
+  it('passes when every expected type has a validated emission', () => {
+    const r = runWith(reportDir([OK]), manifestFile(fullManifest()));
+    assert.equal(r.code, 0, r.stderr);
+  });
+
+  it('fails when an expected type never appeared', () => {
+    const m = fullManifest(['session.start', 'session.end']);
+    const r = runWith(reportDir([OK]), manifestFile(m));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /session\.end/);
+  });
+
+  it('fails when a registered type is in neither list', () => {
+    const m = fullManifest();
+    delete m.excluded[ALL_EVENT_TYPES.find((t) => t !== 'session.start')];
+    const r = runWith(reportDir([OK]), manifestFile(m));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /accounted for|neither/i);
+  });
+
+  it('fails when the manifest names a type the schema does not register', () => {
+    const m = fullManifest();
+    m.excluded['not.a.real.type'] = 'bogus';
+    const r = runWith(reportDir([OK]), manifestFile(m));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /not\.a\.real\.type/);
+  });
+
+  it('fails when an exclusion has an empty reason', () => {
+    const m = fullManifest();
+    m.excluded[Object.keys(m.excluded)[0]] = '';
+    const r = runWith(reportDir([OK]), manifestFile(m));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /reason/i);
+  });
+
+  it('fails when an excluded type is actually emitted and valid', () => {
+    // expected: [] puts session.start in excluded, but the fixture report
+    // still emits it as valid — coverage would be silently under-claimed.
+    const m = fullManifest([]);
+    const r = runWith(reportDir([OK]), manifestFile(m));
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /session\.start/);
+  });
+
+  it('the committed manifest accounts for every registered type', () => {
+    const committed = JSON.parse(readFileSync(join(REPO_ROOT, 'test', 'bus-coverage.json'), 'utf8'));
+    const accounted = new Set([...committed.expected, ...Object.keys(committed.excluded)]);
+    const missing = ALL_EVENT_TYPES.filter((t) => !accounted.has(t));
+    assert.deepEqual(missing, [], `unaccounted event types: ${missing.join(', ')}`);
+    for (const [type, reason] of Object.entries(committed.excluded)) {
+      assert.ok(reason?.trim() && reason !== 'FILL IN', `${type} needs a real reason`);
+    }
+  });
+});

package/test/node/check-managed-blocks.test.mjs

@@ -0,0 +1,179 @@
+// Tests for scripts/lint/check-managed-blocks.mjs. Each test stands up a
+// scratch git repo in a temp dir, writes markdown into it, runs the linter as a
+// subprocess, and asserts on exit code + emitted output.
+//
+// The linter reads its file list from `git ls-files`, so every fixture has to be
+// staged -- an unstaged file is invisible to it, same as in a real checkout.
+
+import assert from 'node:assert/strict';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(HERE, '..', '..');
+const LINTER = join(REPO_ROOT, 'scripts', 'lint', 'check-managed-blocks.mjs');
+
+const RULES = 'MD012 MD024 MD034';
+const DISABLE = `<!-- markdownlint-disable ${RULES} -->`;
+const ENABLE = `<!-- markdownlint-enable ${RULES} -->`;
+
+function scaffold() {
+  const root = mkdtempSync(join(tmpdir(), 'check-blocks-'));
+  execFileSync('git', ['init', '-q'], { cwd: root });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: root });
+  execFileSync('git', ['config', 'user.name', 'test'], { cwd: root });
+  return root;
+}
+
+function writeFile(root, relPath, text) {
+  const p = join(root, relPath);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, text);
+}
+
+function run(root) {
+  execFileSync('git', ['add', '-A'], { cwd: root });
+  const r = spawnSync('node', [LINTER, '--root', root], { encoding: 'utf8' });
+  return { code: r.status, stdout: r.stdout, stderr: r.stderr };
+}
+
+// A correctly fenced managed block, the shape this linter exists to enforce.
+function fencedBlock(name, body) {
+  return [DISABLE, `<!-- BEGIN ${name} -->`, body, `<!-- END ${name} -->`, ENABLE].join('\n');
+}
+
+describe('check-managed-blocks', () => {
+  it('passes on a repo with no markdown at all', () => {
+    const root = scaffold();
+    writeFile(root, 'README.txt', 'not markdown\n');
+    const r = run(root);
+    assert.equal(r.code, 0, r.stderr);
+    assert.match(r.stdout, /0 managed block\(s\)/);
+  });
+
+  it('passes on markdown with no managed blocks', () => {
+    const root = scaffold();
+    writeFile(root, 'doc.md', '# Doc\n\n<!-- an ordinary comment -->\n\nBody.\n');
+    const r = run(root);
+    assert.equal(r.code, 0, r.stderr);
+  });
+
+  it('passes on a correctly fenced managed block', () => {
+    const root = scaffold();
+    writeFile(root, 'AGENTS.md', `# Doc\n\n${fencedBlock('BEADS INTEGRATION v:1', 'See https://example.com/x')}\n`);
+    const r = run(root);
+    assert.equal(r.code, 0, r.stderr);
+    assert.match(r.stdout, /1 managed block\(s\) in 1 file\(s\)/);
+  });
+
+  it('counts multiple fenced blocks in one file', () => {
+    const root = scaffold();
+    const body = [
+      '# Doc',
+      '',
+      fencedBlock('BEADS INTEGRATION', 'a'),
+      '',
+      fencedBlock('BEADS CODEX SETUP: generated by bd setup codex', 'b'),
+      '',
+    ].join('\n');
+    writeFile(root, 'AGENTS.md', body);
+    const r = run(root);
+    assert.equal(r.code, 0, r.stderr);
+    assert.match(r.stdout, /2 managed block\(s\)/);
+  });
+
+  it('fails when a managed block has no fence -- the ecosystem-55g regression', () => {
+    const root = scaffold();
+    writeFile(root, 'AGENTS.md', '# Doc\n\n<!-- BEGIN BEADS INTEGRATION -->\nx\n<!-- END BEADS INTEGRATION -->\n');
+    const r = run(root);
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /AGENTS\.md:3: managed block is not fenced/);
+    assert.match(r.stderr, /AGENTS\.md:5: managed block is not closed/);
+  });
+
+  it('fails when the fence omits a required rule', () => {
+    const root = scaffold();
+    const body = [
+      '# Doc',
+      '',
+      '<!-- markdownlint-disable MD024 -->',
+      '<!-- BEGIN BEADS CODEX SETUP -->',
+      'See https://example.com/y',
+      '<!-- END BEADS CODEX SETUP -->',
+      '<!-- markdownlint-enable MD024 -->',
+      '',
+    ].join('\n');
+    writeFile(root, 'CLAUDE.md', body);
+    const r = run(root);
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /markdownlint-disable above this block omits MD012, MD034/);
+    assert.match(r.stderr, /markdownlint-enable below this block omits MD012, MD034/);
+  });
+
+  it('fails when only the opening half of the fence is present', () => {
+    const root = scaffold();
+    writeFile(root, 'CLAUDE.md', `# Doc\n\n${DISABLE}\n<!-- BEGIN X -->\nx\n<!-- END X -->\n`);
+    const r = run(root);
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /managed block is not closed/);
+    assert.doesNotMatch(r.stderr, /is not fenced/);
+  });
+
+  it('reports an unterminated block once, without cascading fence errors', () => {
+    const root = scaffold();
+    writeFile(root, 'doc.md', `# Doc\n\n${DISABLE}\n<!-- BEGIN THING -->\nbody with no end\n`);
+    const r = run(root);
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /doc\.md:4: managed block "<!-- BEGIN THING -->" has no matching/);
+    assert.match(r.stderr, /1 error\(s\)/);
+  });
+
+  it('skips files listed in .markdownlintignore', () => {
+    const root = scaffold();
+    writeFile(root, '.markdownlintignore', 'node_modules/\n**/CHANGELOG.md\n');
+    // Generated by release-please and never hand-authored, so an unfenced
+    // block inside it is not ours to fix.
+    writeFile(root, 'CHANGELOG.md', '<!-- BEGIN GENERATED -->\nx\n<!-- END GENERATED -->\n');
+    writeFile(root, 'packages/a/CHANGELOG.md', '<!-- BEGIN GENERATED -->\nx\n<!-- END GENERATED -->\n');
+    const r = run(root);
+    assert.equal(r.code, 0, r.stderr);
+    assert.match(r.stdout, /0 managed block\(s\)/);
+  });
+
+  it('still checks non-ignored files when an ignore file is present', () => {
+    const root = scaffold();
+    writeFile(root, '.markdownlintignore', '**/CHANGELOG.md\n');
+    writeFile(root, 'CHANGELOG.md', '<!-- BEGIN GENERATED -->\nx\n<!-- END GENERATED -->\n');
+    writeFile(root, 'AGENTS.md', '<!-- BEGIN BEADS INTEGRATION -->\nx\n<!-- END BEADS INTEGRATION -->\n');
+    const r = run(root);
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /AGENTS\.md:1: managed block is not fenced/);
+    assert.doesNotMatch(r.stderr, /CHANGELOG/);
+  });
+
+  it('accepts a fence that disables more rules than required', () => {
+    const root = scaffold();
+    const body = [
+      '# Doc',
+      '',
+      '<!-- markdownlint-disable MD012 MD024 MD034 MD041 -->',
+      '<!-- BEGIN X -->',
+      'x',
+      '<!-- END X -->',
+      '<!-- markdownlint-enable MD012 MD024 MD034 MD041 -->',
+      '',
+    ].join('\n');
+    writeFile(root, 'doc.md', body);
+    const r = run(root);
+    assert.equal(r.code, 0, r.stderr);
+  });
+
+  it('checks the real repository', () => {
+    const r = spawnSync('node', [LINTER, '--root', REPO_ROOT], { encoding: 'utf8' });
+    assert.equal(r.status, 0, r.stderr);
+  });
+});

package/test/node/emission-report.test.mjs

@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(HERE, '..', '..');
+const EMITTER = join(REPO_ROOT, 'scripts', 'lib', 'onlooker-event.mjs');
+
+// session.start requires only working_directory and forbids extra properties.
+// Verified against node_modules/@onlooker-community/schema/schemas/payload/session.json
+const VALID = {
+  plugin: 'onlooker',
+  session_id: '01JZZZZZZZZZZZZZZZZZZZZZZZ',
+  event_type: 'session.start',
+  payload: { working_directory: '/tmp/x' },
+};
+const INVALID = { ...VALID, payload: { working_directory: 42 } };
+
+function emit(params, { reportDir } = {}) {
+  const env = {
+    ...process.env,
+    ONLOOKER_DIR: mkdtempSync(join(tmpdir(), 'emit-onlooker-')),
+  };
+  if (reportDir) env.ONLOOKER_TEST_REPORT_DIR = reportDir;
+  else delete env.ONLOOKER_TEST_REPORT_DIR;
+  return spawnSync('node', [EMITTER, 'emit'], {
+    input: JSON.stringify(params),
+    encoding: 'utf8',
+    env,
+  });
+}
+
+function readReport(dir) {
+  const p = join(dir, 'emissions.jsonl');
+  if (!existsSync(p)) return null;
+  return readFileSync(p, 'utf8')
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l));
+}
+
+describe('emission report', () => {
+  it('records a valid emission as validated and valid', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'emit-report-'));
+    const r = emit(VALID, { reportDir: dir });
+    assert.equal(r.status, 0, r.stderr);
+    const lines = readReport(dir);
+    assert.equal(lines.length, 1);
+    assert.equal(lines[0].event_type, 'session.start');
+    assert.equal(lines[0].validated, true);
+    assert.equal(lines[0].valid, true);
+  });
+
+  it('records a rejected emission as invalid, with its errors', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'emit-report-'));
+    const r = emit(INVALID, { reportDir: dir });
+    assert.equal(r.status, 1);
+    const lines = readReport(dir);
+    assert.equal(lines.length, 1);
+    assert.equal(lines[0].validated, true);
+    assert.equal(lines[0].valid, false);
+    assert.ok(Array.isArray(lines[0].errors) && lines[0].errors.length > 0);
+  });
+
+  it('writes nothing when the report dir is unset', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'emit-report-'));
+    emit(VALID, { reportDir: dir });
+    assert.equal(readReport(dir).length, 1);
+    // Same directory, but this emission is never told about it. The count must
+    // not move. Asserting on an untouched temp dir would pass either way.
+    const r = emit(VALID);
+    assert.equal(r.status, 0, r.stderr);
+    assert.equal(readReport(dir).length, 1);
+  });
+
+  it('appends across emissions rather than truncating', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'emit-report-'));
+    emit(VALID, { reportDir: dir });
+    emit(VALID, { reportDir: dir });
+    assert.equal(readReport(dir).length, 2);
+  });
+
+  it('does not record for the validate subcommand', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'emit-report-'));
+    spawnSync('node', [EMITTER, 'validate'], {
+      input: JSON.stringify({ nonsense: true }),
+      encoding: 'utf8',
+      env: { ...process.env, ONLOOKER_TEST_REPORT_DIR: dir },
+    });
+    assert.equal(readReport(dir), null);
+  });
+});