feat(plan): plan 1.8, the plan gate, the design part and the plan-side checks
Wave 1, order 3 (P3 plan mode as the start, P2 design as its own part, P9
plan side). Contracts K3-K6 for the later merges.
- plan_version 1.8 (1.7 plans stay valid): Test first on every step, one
End-to-end ("run the thing") step, optional Interface in / Interface out /
Review focus fields, a ceremony class in the header (absent =
architectural), and for architectural plans a ## Design part: module map
without cycles, architecture rules that name their enforcer and the step
that proves them, a requirements check asked as keep / change.
- K3 lib/validators/plan-gate.mjs: the critic verdict is recorded INSIDE the
plan (Claude Code's plan approval hands a hook only the plan file's text),
bound to the hash taken before the reviewers read it; 0 go / 1 stop / 2
could not run; at most 3 critic rounds, then stop and ask.
- K5 lib/verification/arch-rules.mjs: runs the target repo's own
dependency-cruiser or import-linter (installs nothing; 2 = not measured,
never green); --prove --rule shows pass -> fail on a planted violation of
that rule -> pass. Verified against dependency-cruiser 18.5.0 and
import-linter 2.15; madge 8.0.0 left out (missed a planted .mjs cycle).
- K6 lib/verification/plan-scope-sweep.mjs: changed files no step names.
- /trekplan Phases 8-10: design part, bounded critic loop, the gate before
"execute", a plan-mode path through ExitPlanMode (not yet run end to end
inside plan mode). plan-critic 10 -> 12 dimensions; scope-guardian checks
the ceremony.
- Fixed on the way: plan-validator and plan-review-dedup used the
file://argv[1] main guard (no-op under a symlink or a space); CRLF plans
failed every manifest; the dedup dropped finding severity.
Borrowed, credited in place: obra/superpowers, Kiro (docs), addyosmani/
agent-skills, mattpocock/skills, GitHub Spec Kit, bashebr/ai-native-sdlc,
Boris Cherny's public threads.
Suite 1497 (1495 / 0 / 2), 86 new tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
2c89a6b580
commit
f5ca220bc0
SSH key fingerprint:
SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
24 changed files with 3115 additions and 61 deletions
265
tests/lib/arch-rules.test.mjs
Normal file
265
tests/lib/arch-rules.test.mjs
Normal file
|
|
@ -0,0 +1,265 @@
|
|||
// tests/lib/arch-rules.test.mjs
|
||||
// K5 — the architecture-rule runner. `arch-rules.mjs --repo <dir>`: 0 = passed,
|
||||
// 1 = violation, 2 = not measured (never green). JSON on stdout. It runs the
|
||||
// target repo's OWN tool and installs nothing: no local tool → 2.
|
||||
//
|
||||
// The tools are test doubles that print the shapes measured from the real tools
|
||||
// on 2026-10-06: dependency-cruiser 18.5.0 `--output-type json` (exit 0 even
|
||||
// with violations; the verdict is `summary.error`, the violation carries
|
||||
// `type: "cycle"`, `rule.name`, `from`, `to`) and import-linter 2.15 (exit 0
|
||||
// kept, exit 1 broken, summary line `Contracts: N kept, M broken.`). The
|
||||
// dependency-cruiser double really walks relative imports, so the planted
|
||||
// cycle below is a real cycle in the fixture source.
|
||||
|
||||
import { test } from 'node:test';
|
||||
import { strict as assert } from 'node:assert';
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync, existsSync, symlinkSync, lstatSync, readlinkSync } from 'node:fs';
|
||||
import { join, dirname } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url));
|
||||
const RUNNER = join(HERE, '..', '..', 'lib', 'verification', 'arch-rules.mjs');
|
||||
|
||||
const DEPCRUISE_DOUBLE = `#!/usr/bin/env node
|
||||
// Test double for dependency-cruiser: walks relative ESM imports and reports
|
||||
// cycles in the JSON shape dependency-cruiser 18.5.0 prints.
|
||||
const fs = require('node:fs'); const path = require('node:path');
|
||||
const args = process.argv.slice(2);
|
||||
if (process.env.DOUBLE_CRASH) { process.stderr.write('ERROR: boom'); process.exit(1); }
|
||||
const targets = []; for (let i = 0; i < args.length; i++) { if (args[i].startsWith('--')) { i++; continue; } targets.push(args[i]); }
|
||||
const files = [];
|
||||
const walk = d => { for (const e of fs.readdirSync(d, { withFileTypes: true })) { const p = path.join(d, e.name); if (e.isDirectory()) walk(p); else if (p.endsWith('.mjs')) files.push(p); } };
|
||||
for (const t of targets) { if (!fs.existsSync(t)) { process.stderr.write("ERROR: Can't open '" + t + "' for reading. Does it exist?"); process.exit(1); } walk(t); }
|
||||
const edges = {};
|
||||
for (const f of files) { edges[f] = []; for (const m of fs.readFileSync(f, 'utf8').matchAll(/from '(\\.[^']+)'/g)) edges[f].push(path.join(path.dirname(f), m[1])); }
|
||||
const violations = []; const seen = new Set();
|
||||
for (const a of files) for (const b of edges[a]) if ((edges[b] || []).includes(a) && !seen.has([a, b].sort().join())) {
|
||||
seen.add([a, b].sort().join());
|
||||
violations.push({ type: 'cycle', from: a, to: b, rule: { severity: 'error', name: 'no-circular' }, cycle: [{ name: b }, { name: a }] });
|
||||
}
|
||||
process.stdout.write(JSON.stringify({ modules: files.map(f => ({ source: f })), summary: { violations, error: violations.length, warn: 0, info: 0, ignore: 0, advisedExitCode: violations.length ? 1 : 0, totalCruised: process.env.DOUBLE_EMPTY ? 0 : files.length } }));
|
||||
`;
|
||||
|
||||
const LINT_IMPORTS_DOUBLE = `#!/usr/bin/env node
|
||||
const mode = require('node:fs').readFileSync(process.cwd() + '/linter-mode', 'utf8').trim();
|
||||
if (mode === 'kept') { console.log('ui above domain KEPT\\n\\nContracts: 1 kept, 0 broken.'); process.exit(0); }
|
||||
if (mode === 'broken') { console.log('ui above domain BROKEN\\n\\nContracts: 0 kept, 1 broken.\\n\\napp.domain is not allowed to import app.ui:\\n\\n- app.domain.core -> app.ui.view (l.1)'); process.exit(1); }
|
||||
if (mode === 'zero') { console.log('Contracts: 0 kept, 0 broken.'); process.exit(0); }
|
||||
console.log('Could not read any configuration.'); process.exit(1);
|
||||
`;
|
||||
|
||||
function exe(path, body) {
|
||||
mkdirSync(dirname(path), { recursive: true });
|
||||
writeFileSync(path, body);
|
||||
chmodSync(path, 0o755);
|
||||
}
|
||||
|
||||
function jsRepo({ cycle = false, binary = true } = {}) {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'arch-rules-'));
|
||||
mkdirSync(join(dir, 'src'));
|
||||
writeFileSync(join(dir, 'src', 'a.mjs'), "import { b } from './b.mjs';\nexport const a = 1;\n");
|
||||
writeFileSync(join(dir, 'src', 'b.mjs'), cycle ? "import { a } from './a.mjs';\nexport const b = 2;\n" : 'export const b = 2;\n');
|
||||
writeFileSync(join(dir, '.dependency-cruiser.cjs'), "module.exports = { forbidden: [{ name: 'no-circular', severity: 'error', from: {}, to: { circular: true } }] };\n");
|
||||
if (binary) exe(join(dir, 'node_modules', '.bin', 'depcruise'), DEPCRUISE_DOUBLE);
|
||||
return dir;
|
||||
}
|
||||
|
||||
function run(args, env = {}) {
|
||||
const r = spawnSync('node', [RUNNER, ...args], { encoding: 'utf-8', env: { ...process.env, ...env } });
|
||||
let json = null;
|
||||
try { json = JSON.parse(r.stdout); } catch { /* asserted by caller */ }
|
||||
return { code: r.status, json, out: r.stdout, err: r.stderr };
|
||||
}
|
||||
|
||||
const cleanup = d => rmSync(d, { recursive: true, force: true });
|
||||
|
||||
// ---- the tests that failed first ----
|
||||
test('K5: a planted cycle under the repo\'s own dependency-cruiser → 1, violation listed', () => {
|
||||
const dir = jsRepo({ cycle: true });
|
||||
try {
|
||||
const r = run(['--repo', dir]);
|
||||
assert.equal(r.code, 1, r.out + r.err);
|
||||
assert.equal(r.json.status, 'violation');
|
||||
const t = r.json.tools.find(x => x.tool === 'dependency-cruiser');
|
||||
assert.equal(t.status, 'violation');
|
||||
assert.equal(t.violations[0].rule, 'no-circular');
|
||||
assert.match(t.violations[0].text, /src\/a\.mjs/);
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: a repo with no architecture tool → 2 "not measured", never green', () => {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'arch-rules-none-'));
|
||||
try {
|
||||
writeFileSync(join(dir, 'index.mjs'), 'export {};\n');
|
||||
const r = run(['--repo', dir]);
|
||||
assert.equal(r.code, 2, r.out + r.err);
|
||||
assert.equal(r.json.status, 'not-measured');
|
||||
assert.deepEqual(r.json.tools, []);
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: the same repo without the cycle → 0', () => {
|
||||
const dir = jsRepo();
|
||||
try {
|
||||
const r = run(['--repo', dir]);
|
||||
assert.equal(r.code, 0, r.out + r.err);
|
||||
assert.equal(r.json.status, 'passed');
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: config without a local binary → 2 (never npx, never installs)', () => {
|
||||
const dir = jsRepo({ binary: false });
|
||||
try {
|
||||
const r = run(['--repo', dir]);
|
||||
assert.equal(r.code, 2);
|
||||
assert.match(r.json.tools[0].reason, /node_modules\/\.bin\/depcruise/);
|
||||
assert.ok(!existsSync(join(dir, 'node_modules')), 'the runner must not create node_modules');
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: a tool that crashes or cruises nothing → 2', () => {
|
||||
const dir = jsRepo({ cycle: true });
|
||||
try {
|
||||
assert.equal(run(['--repo', dir], { DOUBLE_CRASH: '1' }).code, 2);
|
||||
assert.equal(run(['--repo', dir], { DOUBLE_EMPTY: '1' }).code, 2);
|
||||
assert.equal(run(['--repo', dir, '--target', 'nosuchdir']).code, 2);
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: import-linter — kept → 0, broken → 1, no summary line → 2', () => {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'arch-rules-py-'));
|
||||
try {
|
||||
writeFileSync(join(dir, '.importlinter'), '[importlinter]\nroot_package = app\n');
|
||||
exe(join(dir, '.venv', 'bin', 'lint-imports'), LINT_IMPORTS_DOUBLE);
|
||||
writeFileSync(join(dir, 'linter-mode'), 'kept');
|
||||
assert.equal(run(['--repo', dir]).code, 0);
|
||||
writeFileSync(join(dir, 'linter-mode'), 'broken');
|
||||
const broken = run(['--repo', dir]);
|
||||
assert.equal(broken.code, 1);
|
||||
assert.equal(broken.json.tools[0].violations[0].rule, 'ui above domain', 'the broken contract is the rule');
|
||||
assert.match(broken.json.tools[0].violations[0].text, /not allowed to import/);
|
||||
writeFileSync(join(dir, 'linter-mode'), 'noconfig');
|
||||
assert.equal(run(['--repo', dir]).code, 2);
|
||||
writeFileSync(join(dir, 'linter-mode'), 'zero');
|
||||
assert.equal(run(['--repo', dir]).code, 2, '0 contracts checked is not measured, not passed');
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: a missing --repo dir → 2', () => {
|
||||
assert.equal(run(['--repo', '/nonexistent/repo']).code, 2);
|
||||
});
|
||||
|
||||
// ---- pass → fail on a planted violation → pass ----
|
||||
test('--prove: pass → fail on the planted cycle → pass, and the plant is removed', () => {
|
||||
const dir = jsRepo();
|
||||
const plantDir = mkdtempSync(join(tmpdir(), 'arch-plant-'));
|
||||
try {
|
||||
writeFileSync(join(plantDir, 'c.mjs'), "import { d } from './d.mjs';\nexport const c = 1;\n");
|
||||
writeFileSync(join(plantDir, 'd.mjs'), "import { c } from './c.mjs';\nexport const d = 1;\n");
|
||||
const r = run(['--repo', dir, '--prove', '--rule', 'no-circular',
|
||||
'--plant', `${join(plantDir, 'c.mjs')}=src/planted/c.mjs`,
|
||||
'--plant', `${join(plantDir, 'd.mjs')}=src/planted/d.mjs`]);
|
||||
assert.equal(r.code, 0, r.out + r.err);
|
||||
assert.equal(r.json.proven, true);
|
||||
assert.deepEqual(r.json.phases.map(p => p.code), [0, 1, 0]);
|
||||
assert.ok(!existsSync(join(dir, 'src', 'planted')), 'planted files and the dirs made for them are removed');
|
||||
} finally { cleanup(dir); cleanup(plantDir); }
|
||||
});
|
||||
|
||||
test('--prove: a plant the tool does not catch → 1 (the rule is not proven)', () => {
|
||||
const dir = jsRepo();
|
||||
const plantDir = mkdtempSync(join(tmpdir(), 'arch-plant-'));
|
||||
try {
|
||||
writeFileSync(join(plantDir, 'e.mjs'), 'export const e = 1;\n');
|
||||
const r = run(['--repo', dir, '--prove', '--rule', 'no-circular', '--plant', `${join(plantDir, 'e.mjs')}=src/e.mjs`]);
|
||||
assert.equal(r.code, 1, r.out);
|
||||
assert.equal(r.json.proven, false);
|
||||
assert.ok(!existsSync(join(dir, 'src', 'e.mjs')));
|
||||
} finally { cleanup(dir); cleanup(plantDir); }
|
||||
});
|
||||
|
||||
test('--prove refuses to overwrite an existing file → 2, file untouched', () => {
|
||||
const dir = jsRepo();
|
||||
const plantDir = mkdtempSync(join(tmpdir(), 'arch-plant-'));
|
||||
try {
|
||||
writeFileSync(join(plantDir, 'x.mjs'), 'export const x = 1;\n');
|
||||
const r = run(['--repo', dir, '--prove', '--rule', 'no-circular', '--plant', `${join(plantDir, 'x.mjs')}=src/a.mjs`]);
|
||||
assert.equal(r.code, 2, r.out);
|
||||
assert.ok(existsSync(join(dir, 'src', 'a.mjs')));
|
||||
} finally { cleanup(dir); cleanup(plantDir); }
|
||||
});
|
||||
|
||||
// ---- review findings (independent code review, 06.10) ----
|
||||
function cyclePlants() {
|
||||
const plantDir = mkdtempSync(join(tmpdir(), 'arch-plant-'));
|
||||
writeFileSync(join(plantDir, 'c.mjs'), "import { d } from './d.mjs';\nexport const c = 1;\n");
|
||||
writeFileSync(join(plantDir, 'd.mjs'), "import { c } from './c.mjs';\nexport const d = 1;\n");
|
||||
return plantDir;
|
||||
}
|
||||
|
||||
test('--prove refuses a plant destination outside the repo: ../ and through a symlink → 2, nothing written', () => {
|
||||
const dir = jsRepo();
|
||||
const outside = mkdtempSync(join(tmpdir(), 'arch-outside-'));
|
||||
const plantDir = cyclePlants();
|
||||
try {
|
||||
symlinkSync(outside, join(dir, 'src', 'link'));
|
||||
for (const dest of ['../escaped.mjs', 'src/link/escaped.mjs']) {
|
||||
const r = run(['--repo', dir, '--prove', '--rule', 'no-circular', '--plant', `${join(plantDir, 'c.mjs')}=${dest}`]);
|
||||
assert.equal(r.code, 2, `${dest}: ${r.out}`);
|
||||
assert.match(r.json.reason, /outside the repo/);
|
||||
}
|
||||
assert.ok(!existsSync(join(outside, 'escaped.mjs')));
|
||||
assert.ok(!existsSync(join(dir, '..', 'escaped.mjs')));
|
||||
} finally { cleanup(dir); cleanup(outside); cleanup(plantDir); }
|
||||
});
|
||||
|
||||
test('--prove refuses a dangling symlink at the destination and leaves it in place', () => {
|
||||
const dir = jsRepo();
|
||||
const plantDir = cyclePlants();
|
||||
try {
|
||||
symlinkSync(join(dir, 'nowhere.mjs'), join(dir, 'src', 'dangling.mjs'));
|
||||
const r = run(['--repo', dir, '--prove', '--rule', 'no-circular', '--plant', `${join(plantDir, 'c.mjs')}=src/dangling.mjs`]);
|
||||
assert.equal(r.code, 2, r.out);
|
||||
assert.ok(lstatSync(join(dir, 'src', 'dangling.mjs')).isSymbolicLink());
|
||||
assert.equal(readlinkSync(join(dir, 'src', 'dangling.mjs')), join(dir, 'nowhere.mjs'));
|
||||
assert.ok(!existsSync(join(dir, 'nowhere.mjs')));
|
||||
} finally { cleanup(dir); cleanup(plantDir); }
|
||||
});
|
||||
|
||||
test('--prove: a plant that trips another rule proves nothing about the named one → 1', () => {
|
||||
const dir = jsRepo();
|
||||
const plantDir = cyclePlants();
|
||||
try {
|
||||
const r = run(['--repo', dir, '--prove', '--rule', 'no-orphans',
|
||||
'--plant', `${join(plantDir, 'c.mjs')}=src/p/c.mjs`, '--plant', `${join(plantDir, 'd.mjs')}=src/p/d.mjs`]);
|
||||
assert.equal(r.code, 1, r.out);
|
||||
assert.match(r.json.reason, /not no-orphans/);
|
||||
assert.ok(!existsSync(join(dir, 'src', 'p')));
|
||||
assert.equal(run(['--repo', dir, '--prove', '--plant', `${join(plantDir, 'c.mjs')}=src/p/c.mjs`]).code, 2, '--rule is required');
|
||||
} finally { cleanup(dir); cleanup(plantDir); }
|
||||
});
|
||||
|
||||
test('K5: with src/ and lib/ both present, a cycle in lib/ is caught (every default dir is cruised)', () => {
|
||||
const dir = jsRepo();
|
||||
try {
|
||||
mkdirSync(join(dir, 'lib'));
|
||||
writeFileSync(join(dir, 'lib', 'x.mjs'), "import { y } from './y.mjs';\nexport const x = 1;\n");
|
||||
writeFileSync(join(dir, 'lib', 'y.mjs'), "import { x } from './x.mjs';\nexport const y = 1;\n");
|
||||
const r = run(['--repo', dir]);
|
||||
assert.equal(r.code, 1, r.out);
|
||||
assert.deepEqual(r.json.tools[0].targets, ['src', 'lib']);
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
||||
test('K5: a flag without its value → 2, never a crash', () => {
|
||||
const dir = jsRepo();
|
||||
try {
|
||||
for (const args of [['--repo', dir, '--target'], ['--repo'], ['--repo', dir, '--prove', '--rule']]) {
|
||||
const r = run(args);
|
||||
assert.equal(r.code, 2, `${args.join(' ')}: ${r.err}`);
|
||||
assert.ok(r.json, 'JSON on stdout');
|
||||
}
|
||||
} finally { cleanup(dir); }
|
||||
});
|
||||
|
|
@ -139,9 +139,9 @@ test('every command frontmatter name matches its filename', () => {
|
|||
}
|
||||
});
|
||||
|
||||
test('templates/plan-template.md declares plan_version: 1.7', () => {
|
||||
test('templates/plan-template.md declares plan_version: 1.8', () => {
|
||||
const tpl = read('templates/plan-template.md');
|
||||
assert.match(tpl, /plan_version:\s*['"]?1\.7['"]?/);
|
||||
assert.match(tpl, /plan_version:\s*['"]?1\.8['"]?/);
|
||||
});
|
||||
|
||||
test('HANDOVER-CONTRACTS.md locates plan_version in the plan header line, not frontmatter (S28)', () => {
|
||||
|
|
@ -162,8 +162,8 @@ test('HANDOVER-CONTRACTS.md locates plan_version in the plan header line, not fr
|
|||
// "commands/trekexecute.md still parses v1.7 plan schema" was an OR-chain
|
||||
// (`includes('plan_version') || includes('Step N:') || includes('### Step ')`)
|
||||
// that is ~always true and asserts almost nothing. The real v1.7 coverage lives
|
||||
// in the structural pin "templates/plan-template.md declares plan_version: 1.7"
|
||||
// (above) + the plan-validator / plan-schema behavior tests.
|
||||
// in the structural pin "templates/plan-template.md declares plan_version: 1.8"
|
||||
// (above; 1.7 plans stay valid) + the plan-validator / plan-schema behavior tests.
|
||||
|
||||
test('settings.json has only known top-level scopes after Spor 0 cleanup', () => {
|
||||
const cfg = JSON.parse(read('settings.json'));
|
||||
|
|
|
|||
129
tests/lib/plan-prose-pins.test.mjs
Normal file
129
tests/lib/plan-prose-pins.test.mjs
Normal file
|
|
@ -0,0 +1,129 @@
|
|||
// tests/lib/plan-prose-pins.test.mjs
|
||||
// Prose pins for the plan process (wave 1, order 3): /trekplan Phases 8-10, the
|
||||
// plan and design templates, plan-critic and the Handover 4 contract must keep
|
||||
// saying what the plan gate, the validator and the verification CLIs do.
|
||||
// Counted as doc pins by lib/util/test-census.mjs (PIN_FILE_RE).
|
||||
|
||||
import { test } from 'node:test';
|
||||
import { strict as assert } from 'node:assert';
|
||||
import { readFileSync, existsSync } from 'node:fs';
|
||||
import { join, dirname } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { MAX_ROUNDS } from '../../lib/validators/plan-gate.mjs';
|
||||
import { DESIGN_SUBSECTIONS, OPTIONAL_STEP_FIELDS } from '../../lib/validators/plan-validator.mjs';
|
||||
import { findSteps, PLAN_VERSION_CURRENT } from '../../lib/parsers/plan-schema.mjs';
|
||||
|
||||
const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
|
||||
const read = rel => readFileSync(join(ROOT, rel), 'utf-8');
|
||||
|
||||
function phase(text, n) {
|
||||
const start = text.indexOf(`\n## Phase ${n} `);
|
||||
assert.ok(start >= 0, `## Phase ${n} missing`);
|
||||
const end = text.indexOf('\n## Phase ', start + 1);
|
||||
return text.slice(start, end < 0 ? undefined : end);
|
||||
}
|
||||
|
||||
const PLAN_CMD = read('commands/trekplan.md');
|
||||
|
||||
test('Phase 9 is a bounded loop: --record after the dedup, the cap equals MAX_ROUNDS, stop and ask after it', () => {
|
||||
const p9 = phase(PLAN_CMD, 9);
|
||||
assert.match(p9, /plan-review-dedup\.mjs --stdin <<'JSON' \| node \$\{CLAUDE_PLUGIN_ROOT\}\/lib\/validators\/plan-gate\.mjs --record/);
|
||||
assert.ok(p9.includes(`at most **${MAX_ROUNDS} critic rounds**`), `Phase 9 must state the cap of ${MAX_ROUNDS}`);
|
||||
assert.match(p9, /After round 3 with a BLOCKER open/);
|
||||
assert.match(p9, /never goes on silently/);
|
||||
assert.match(p9, /--extra-round/);
|
||||
assert.ok(p9.indexOf('plan-gate.mjs --hash') < p9.indexOf('Then launch two review agents'), 'the hash is taken before the reviewers read the plan');
|
||||
assert.match(p9, /--record "\{plan_path\}" --reviewed \{the hash from --hash\}/);
|
||||
assert.match(p9, /Kiro/, 'the bounded loop is borrowed and credited');
|
||||
});
|
||||
|
||||
test('Phase 10 runs the plan gate before offering "execute", and covers plan mode', () => {
|
||||
const p10 = phase(PLAN_CMD, 10);
|
||||
assert.ok(p10.indexOf('plan-gate.mjs --json') < p10.indexOf('Say **"execute"**'), 'the gate runs before the offer');
|
||||
assert.match(p10, /only when the gate exited 0/);
|
||||
assert.match(p10, /ExitPlanMode/);
|
||||
assert.match(p10, /\*\*Not\s+verified:\*\* that `\/trekplan` runs end to end inside plan mode/);
|
||||
assert.match(p10, /hedged reply/i);
|
||||
});
|
||||
|
||||
test('Phase 8 reads ceremony (absent = architectural), the design template and the arch-rules runner', () => {
|
||||
const p8 = phase(PLAN_CMD, 8);
|
||||
assert.match(p8, /Absent means `architectural`/);
|
||||
assert.ok(p8.includes('templates/design-template.md'));
|
||||
assert.ok(p8.includes('lib/verification/arch-rules.mjs --repo .'));
|
||||
assert.ok(p8.includes('--prove --rule <rule name> --plant'), 'the proof names the rule the plant must trip');
|
||||
assert.match(p8, /End-to-end:/);
|
||||
for (const f of OPTIONAL_STEP_FIELDS) assert.ok(p8.includes(`${f}:`), `Phase 8 names the optional field ${f}:`);
|
||||
for (const credit of ['obra/superpowers', 'Spec Kit', 'mattpocock/skills', 'Cherny']) {
|
||||
assert.ok(p8.includes(credit), `Phase 8 credits ${credit}`);
|
||||
}
|
||||
});
|
||||
|
||||
test('the CLIs and templates /trekplan points at exist', () => {
|
||||
for (const rel of [
|
||||
'lib/validators/plan-gate.mjs', 'lib/verification/arch-rules.mjs',
|
||||
'lib/verification/plan-scope-sweep.mjs', 'templates/design-template.md',
|
||||
]) assert.ok(existsSync(join(ROOT, rel)), `${rel} missing`);
|
||||
});
|
||||
|
||||
test('the hard rules carry the bounded critic loop and the gate', () => {
|
||||
const rules = PLAN_CMD.slice(PLAN_CMD.indexOf('\n## Hard rules'));
|
||||
assert.match(rules, /\*\*Bounded critic loop\*\*: at most 3 critic rounds/);
|
||||
assert.match(rules, /never while `plan-gate\.mjs` exits non-zero/);
|
||||
});
|
||||
|
||||
test('design template: every subsection the validator requires is a ### heading, and the borrowings are credited', () => {
|
||||
const t = read('templates/design-template.md');
|
||||
for (const s of DESIGN_SUBSECTIONS) assert.match(t, new RegExp(`^### ${s}$`, 'm'), `design template lacks ### ${s}`);
|
||||
for (const credit of ['Kiro', 'obra/superpowers', 'addyosmani/agent-skills', 'mattpocock/skills', 'Spec Kit', 'ai-native-sdlc']) {
|
||||
assert.ok(t.includes(credit), `design template credits ${credit}`);
|
||||
}
|
||||
});
|
||||
|
||||
test(`plan template: plan_version ${PLAN_VERSION_CURRENT} with ceremony, Test first on every example step, one End-to-end step, no hand-written Critic Verdict`, () => {
|
||||
const t = read('templates/plan-template.md');
|
||||
assert.ok(t.includes(`\`plan_version: ${PLAN_VERSION_CURRENT}\` · \`ceremony:`));
|
||||
const steps = findSteps(t);
|
||||
assert.ok(steps.length >= 2);
|
||||
const bodies = steps.map((s, i) => t.slice(s.offset, i + 1 < steps.length ? steps[i + 1].offset : undefined));
|
||||
for (const [i, b] of bodies.entries()) assert.match(b, /- \*\*Test first:\*\*/, `example Step ${i + 1} lacks Test first`);
|
||||
assert.equal(bodies.filter(b => /- \*\*End-to-end:\*\* `/.test(b)).length, 1);
|
||||
assert.doesNotMatch(t, /^## Critic Verdict$/m, 'the planner must not copy a verdict heading: only plan-gate --record writes it');
|
||||
assert.match(t, /plan-gate\.mjs\s+--record` appends it/);
|
||||
assert.match(t, /^## Global Constraints$/m);
|
||||
assert.doesNotMatch(t, /omit "Test first"/, 'a 1.8 plan never omits Test first');
|
||||
});
|
||||
|
||||
test('plan-critic carries dimensions 11 (interfaces and slices) and 12 (design and architecture rules)', () => {
|
||||
const c = read('agents/plan-critic.md');
|
||||
assert.match(c, /^### 11\. Interfaces and slices$/m);
|
||||
assert.match(c, /^### 12\. Design and architecture rules$/m);
|
||||
assert.match(c, /`severity` is exactly one of `blocker`, `major`, `minor`/);
|
||||
});
|
||||
|
||||
test('Handover 4 documents every PLAN_* code the validator and the gate emit', () => {
|
||||
const contract = read('docs/HANDOVER-CONTRACTS.md');
|
||||
const h4 = contract.slice(contract.indexOf('## Handover 4'), contract.indexOf('## Handover 5'));
|
||||
const codes = new Set();
|
||||
for (const rel of ['lib/validators/plan-validator.mjs', 'lib/validators/plan-gate.mjs']) {
|
||||
for (const m of read(rel).matchAll(/'(PLAN_[A-Z_]+)'/g)) codes.add(m[1]);
|
||||
}
|
||||
assert.ok(codes.size >= 15, `expected the 1.8 and gate codes, found ${codes.size}`);
|
||||
const missing = [...codes].filter(c => !h4.includes(c));
|
||||
assert.deepEqual(missing, [], `Handover 4 does not document: ${missing.join(', ')}`);
|
||||
});
|
||||
|
||||
test('Handover 4 states 1.8 as current and 1.7 as still valid', () => {
|
||||
const contract = read('docs/HANDOVER-CONTRACTS.md');
|
||||
assert.match(contract, /\| `plan\.md` \| `plan_version` \(plan header line\) \| `1\.8` \(1\.7 still valid\) \|/);
|
||||
assert.match(contract, /`"1\.8"` \(current\), `"1\.7"` \(valid\)/);
|
||||
});
|
||||
|
||||
test('the verification CLIs credit what they borrow and say they install nothing', () => {
|
||||
const arch = read('lib/verification/arch-rules.mjs');
|
||||
assert.match(arch, /installs nothing/);
|
||||
assert.match(arch, /agent-skills/);
|
||||
assert.match(arch, /Pocock/);
|
||||
assert.match(read('lib/verification/plan-scope-sweep.mjs'), /ai-native-sdlc \(MIT\)/);
|
||||
assert.match(read('lib/validators/plan-gate.mjs'), /Kiro/);
|
||||
});
|
||||
|
|
@ -164,6 +164,31 @@ test('CLI --stdin tolerates a single present payload (other key absent)', () =>
|
|||
assert.deepEqual(parsed.findings[0].raised_by, ['plan-critic']);
|
||||
});
|
||||
|
||||
test('severity survives the dedup, and a merge keeps the more severe of the two (the plan gate reads it)', () => {
|
||||
const sources = [
|
||||
{ agent: 'plan-critic', payload: { findings: [{ file: 'plan.md', line: 42, rule_key: 'PC1', severity: 'Minor', text: 'Step 4 lacks verifiable acceptance criteria' }] } },
|
||||
{ agent: 'scope-guardian', payload: { findings: [{ file: 'plan.md', line: 42, rule_key: 'PC1', severity: 'blocker', text: 'Step 4 lacks verifiable acceptance criteria' }] } },
|
||||
];
|
||||
const r = dedupFindings(sources);
|
||||
assert.equal(r.findings.length, 1);
|
||||
assert.equal(r.findings[0].severity, 'blocker');
|
||||
const lone = dedupFindings([{ agent: 'plan-critic', payload: { findings: [{ file: 'p', line: 1, rule_key: 'k', severity: 'MAJOR', text: 't' }] } }]);
|
||||
assert.equal(lone.findings[0].severity, 'major');
|
||||
const unrated = dedupFindings([{ agent: 'plan-critic', payload: { findings: [{ file: 'p', line: 1, rule_key: 'k', text: 't' }] } }]);
|
||||
assert.equal(unrated.findings[0].severity, null, 'an unrated finding stays unrated here; the gate decides what that means');
|
||||
});
|
||||
|
||||
test('sources says which reviewers delivered a findings block (null, misnamed or findings-less = absent)', () => {
|
||||
const stdin = JSON.stringify({ plan_critic: { agent: 'plan-critic', findings: [] }, scopeGuardian: { findings: [] } });
|
||||
const parsed = JSON.parse(execFileSync(process.execPath, [SHIM, '--stdin'], { input: stdin, encoding: 'utf-8' }));
|
||||
assert.deepEqual(parsed.sources, [
|
||||
{ agent: 'plan-critic', present: true },
|
||||
{ agent: 'scope-guardian', present: false },
|
||||
]);
|
||||
const noFindings = dedupFindings([{ agent: 'plan-critic', payload: { agent: 'plan-critic' } }]);
|
||||
assert.deepEqual(noFindings.sources, [{ agent: 'plan-critic', present: false }]);
|
||||
});
|
||||
|
||||
test('CLI --stdin exits non-zero on malformed input (loud, not a silent empty merge)', () => {
|
||||
assert.throws(
|
||||
() => execFileSync(process.execPath, [SHIM, '--stdin'], { input: 'not json{', encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }),
|
||||
|
|
|
|||
|
|
@ -150,5 +150,5 @@ test('extractPlanVersion — recognizes the canonical plan template (regression
|
|||
// The real generated artifact: no test exercised the parser against the
|
||||
// actual template, which is why defect S26 went unnoticed.
|
||||
const tpl = readFileSync(new URL('../../templates/plan-template.md', import.meta.url), 'utf-8');
|
||||
assert.equal(extractPlanVersion(tpl), '1.7');
|
||||
assert.equal(extractPlanVersion(tpl), '1.8');
|
||||
});
|
||||
|
|
|
|||
177
tests/lib/plan-scope-sweep.test.mjs
Normal file
177
tests/lib/plan-scope-sweep.test.mjs
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
// tests/lib/plan-scope-sweep.test.mjs
|
||||
// K6 — the sweep for files the plan does not name.
|
||||
// `plan-scope-sweep.mjs --plan <plan.md> --base <ref>`: changed files since the
|
||||
// merge base, minus every step's `Files:` / `Test first:` file / manifest
|
||||
// `expected_paths`, minus a named process-file list, must be empty.
|
||||
// 0 = nothing outside the plan, 1 = deviation (listed), 2 = could not run.
|
||||
|
||||
import { test } from 'node:test';
|
||||
import { strict as assert } from 'node:assert';
|
||||
import { spawnSync, execFileSync } from 'node:child_process';
|
||||
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
|
||||
import { join, dirname } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { plannedPaths, PROCESS_FILES } from '../../lib/verification/plan-scope-sweep.mjs';
|
||||
import { buildPlan } from '../helpers/plan-v18-builder.mjs';
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url));
|
||||
const SWEEP = join(HERE, '..', '..', 'lib', 'verification', 'plan-scope-sweep.mjs');
|
||||
|
||||
const git = (dir, ...args) => execFileSync('git', ['-C', dir, ...args], { encoding: 'utf-8', stdio: 'pipe' });
|
||||
|
||||
function repo() {
|
||||
const dir = mkdtempSync(join(tmpdir(), 'scope-sweep-'));
|
||||
git(dir, 'init', '-q', '-b', 'main');
|
||||
git(dir, 'config', 'user.email', 't@example.invalid');
|
||||
git(dir, 'config', 'user.name', 't');
|
||||
git(dir, 'config', 'commit.gpgsign', 'false');
|
||||
writeFileSync(join(dir, 'README.md'), '# r\n');
|
||||
git(dir, 'add', 'README.md');
|
||||
git(dir, 'commit', '-q', '-m', 'base');
|
||||
mkdirSync(join(dir, '.claude', 'projects', 'p1'), { recursive: true });
|
||||
writeFileSync(join(dir, '.claude', 'projects', 'p1', 'plan.md'), buildPlan());
|
||||
mkdirSync(join(dir, 'src'));
|
||||
mkdirSync(join(dir, 'tests'));
|
||||
return dir;
|
||||
}
|
||||
|
||||
function put(dir, rel, body = 'x\n') {
|
||||
mkdirSync(dirname(join(dir, rel)), { recursive: true });
|
||||
writeFileSync(join(dir, rel), body);
|
||||
}
|
||||
|
||||
function run(dir, extra = []) {
|
||||
const r = spawnSync('node', [SWEEP, '--plan', '.claude/projects/p1/plan.md', '--base', 'main', ...extra],
|
||||
{ cwd: dir, encoding: 'utf-8' });
|
||||
let json = null;
|
||||
try { json = JSON.parse(r.stdout); } catch { /* asserted by caller */ }
|
||||
return { code: r.status, json, out: r.stdout, err: r.stderr };
|
||||
}
|
||||
|
||||
// ---- the test that failed first ----
|
||||
test('K6: one changed file outside the plan → 1, and it is listed', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
git(dir, 'checkout', '-q', '-b', 'work');
|
||||
put(dir, 'src/mod1.mjs');
|
||||
put(dir, 'tests/mod1.test.mjs');
|
||||
put(dir, 'src/unplanned.mjs');
|
||||
git(dir, 'add', 'src', 'tests', '.claude');
|
||||
git(dir, 'commit', '-q', '-m', 'work');
|
||||
const r = run(dir);
|
||||
assert.equal(r.code, 1, r.out + r.err);
|
||||
assert.deepEqual(r.json.outside, ['src/unplanned.mjs']);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('K6: only planned files and process files changed → 0', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
git(dir, 'checkout', '-q', '-b', 'work');
|
||||
put(dir, 'src/mod1.mjs');
|
||||
put(dir, 'tests/mod2.test.mjs');
|
||||
put(dir, '.claude/projects/p1/progress.json', '{}');
|
||||
git(dir, 'add', 'src', 'tests', '.claude');
|
||||
git(dir, 'commit', '-q', '-m', 'work');
|
||||
const r = run(dir);
|
||||
assert.equal(r.code, 0, r.out + r.err);
|
||||
assert.deepEqual(r.json.outside, []);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('K6: uncommitted and untracked changes count too', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
git(dir, 'add', '.claude');
|
||||
git(dir, 'commit', '-q', '-m', 'plan');
|
||||
put(dir, 'README.md', '# changed\n');
|
||||
put(dir, 'stray.txt');
|
||||
const r = run(dir);
|
||||
assert.equal(r.code, 1);
|
||||
assert.deepEqual(r.json.outside, ['README.md', 'stray.txt']);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('K6: --process names extra process files; a deviation is allowed once the plan names the file', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
put(dir, 'CHANGELOG.md');
|
||||
assert.equal(run(dir).code, 1);
|
||||
assert.equal(run(dir, ['--process', 'CHANGELOG.md']).code, 0);
|
||||
const plan = buildPlan().replace('- **Files:** `src/mod1.mjs`', '- **Files:** `src/mod1.mjs`, `CHANGELOG.md`');
|
||||
writeFileSync(join(dir, '.claude', 'projects', 'p1', 'plan.md'), plan);
|
||||
assert.equal(run(dir).code, 0);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('K6: a bad ref, a missing plan, or a plan without steps → 2', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
assert.equal(run(dir, ['--base', 'no-such-ref']).code, 2);
|
||||
const r = spawnSync('node', [SWEEP, '--plan', 'missing.md', '--base', 'main'], { cwd: dir, encoding: 'utf-8' });
|
||||
assert.equal(r.status, 2);
|
||||
writeFileSync(join(dir, '.claude', 'projects', 'p1', 'plan.md'), '# no steps\n');
|
||||
assert.equal(run(dir).code, 2);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('plannedPaths collects Files, Test first files and manifest expected_paths', () => {
|
||||
const p = plannedPaths(buildPlan());
|
||||
for (const f of ['src/mod1.mjs', 'tests/mod1.test.mjs', 'src/mod2.mjs', 'tests/mod2.test.mjs']) {
|
||||
assert.ok(p.includes(f), `${f} missing from ${p.join(',')}`);
|
||||
}
|
||||
assert.ok(PROCESS_FILES.length > 0);
|
||||
});
|
||||
|
||||
// ---- review findings (independent code review, 06.10) ----
|
||||
test('K6: renames list both paths, deletions count, non-ASCII and spaced names match when planned', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
put(dir, 'src/old name.mjs');
|
||||
put(dir, 'src/gone.mjs');
|
||||
git(dir, 'add', 'src');
|
||||
git(dir, 'commit', '-q', '-m', 'more');
|
||||
git(dir, 'checkout', '-q', '-b', 'work');
|
||||
git(dir, 'mv', 'src/old name.mjs', 'src/prøve fil.mjs');
|
||||
git(dir, 'rm', '-q', 'src/gone.mjs');
|
||||
git(dir, 'commit', '-q', '-m', 'work');
|
||||
const r = run(dir);
|
||||
assert.equal(r.code, 1);
|
||||
assert.deepEqual(r.json.outside, ['src/gone.mjs', 'src/old name.mjs', 'src/prøve fil.mjs']);
|
||||
const plan = buildPlan().replace('- **Files:** `src/mod1.mjs`',
|
||||
'- **Files:** `src/mod1.mjs`, `src/old name.mjs`, `src/prøve fil.mjs`, `src/gone.mjs`');
|
||||
writeFileSync(join(dir, '.claude', 'projects', 'p1', 'plan.md'), plan);
|
||||
const ok = run(dir);
|
||||
assert.equal(ok.code, 0, ok.out);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('K6: a glob with no fixed directory (`**/*`) plans nothing and is reported as ignored', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
put(dir, 'src/anything.mjs');
|
||||
const plan = buildPlan().replace('- **Files:** `src/mod1.mjs`', '- **Files:** `src/mod1.mjs`, `**/*`');
|
||||
writeFileSync(join(dir, '.claude', 'projects', 'p1', 'plan.md'), plan);
|
||||
const r = run(dir);
|
||||
assert.equal(r.code, 1);
|
||||
assert.deepEqual(r.json.ignored, ['**/*']);
|
||||
assert.ok(r.json.outside.includes('src/anything.mjs'));
|
||||
const scoped = buildPlan().replace('- **Files:** `src/mod1.mjs`', '- **Files:** `src/**`');
|
||||
writeFileSync(join(dir, '.claude', 'projects', 'p1', 'plan.md'), scoped);
|
||||
assert.equal(run(dir).code, 0, 'a glob under a fixed directory still plans');
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
|
||||
test('K6: a flag without its value, or a directory as the plan → 2, never a crash', () => {
|
||||
const dir = repo();
|
||||
try {
|
||||
for (const extra of [['--process'], ['--repo']]) {
|
||||
const r = run(dir, extra);
|
||||
assert.equal(r.code, 2, `${extra.join(' ')}: ${r.err}`);
|
||||
assert.ok(r.json);
|
||||
}
|
||||
const r = spawnSync('node', [SWEEP, '--plan', 'src', '--base', 'main'], { cwd: dir, encoding: 'utf-8' });
|
||||
assert.equal(r.status, 2, r.stderr);
|
||||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue