a9a7a328e6
Mechanical rename produced by scripts/msd-rename.cjs: gsd/Gsd/GSD -> msd/Msd/MSD across contents and paths, upstream package/repo coordinates -> @golem15/msd-core and golem15com/msd-core. Deep links into upstream history, sibling upstream packages, the GSD-2 import feature, CHANGELOG.md and .changeset/ are kept as-is. Hand edits on top: MSD block-letter banner and logos, LICENSE copyright line, package/plugin identity, regenerated lockfile, install-tree fixtures, derived registries and benchmark baseline; migration checksum baseline re-locked (MSD keeps its own install state, so no install had applied the old sums); sort-order and regex-escaped expectations in tests adjusted.
631 lines
27 KiB
JavaScript
631 lines
27 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* plan-pre-hook-e2e.test.cjs — E2E content tests for plan:pre hook resolution.
|
|
*
|
|
* ADR-857 phase 6 capstone conformance — gap-backlog: plan:pre
|
|
* All tests drive real CLI subprocess or real resolver with real registry.
|
|
* No source-grep — RULESET.TESTS.no-source-grep.
|
|
*
|
|
* Covers:
|
|
* 1. intel.enabled=true → step ref.command='intel api-surface', rendered contains 'intel api-surface'
|
|
* 2. tdd_mode=true → tdd contribution fragment contains '<tdd_mode_active>'
|
|
* 3. security_enforcement=true + explicit asvs/block_on → configValues resolved from config
|
|
* 4. BVA: security defaults (asvs_level=1, block_on='high') when only enforcement=true
|
|
* 5. All plan:pre when-keys false → empty activeHooks + placeholder rendered
|
|
* 6. check ui.plan-gate: frontend + no-spec → block:true, exit 0
|
|
* 7. check ui.plan-gate: frontend + spec present → block:false, exit 0
|
|
* 8. check ui.plan-gate: missing phase arg → exit 1, clear error message
|
|
* 9. BVA: check ui.plan-gate phase=99 (nonexistent) → phaseLookupFailed:true, block:false
|
|
* 10. BVA: intel api-surface symbolCount=0 → stale:true + Incomplete banner
|
|
* 11. BVA: intel api-surface symbolCount=1 fresh → stale:false + symbol in file
|
|
* 12. ui cluster disabled via surface + tdd + intel on → no ui hooks, intel+tdd present
|
|
*/
|
|
|
|
const { describe, test, before, after } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const os = require('node:os');
|
|
const path = require('node:path');
|
|
const { spawnSync } = require('node:child_process');
|
|
|
|
const { cleanup, installSpawnEnv, withAmbientCapabilityHome } = require('./helpers.cjs');
|
|
|
|
const MSD_TOOLS = path.join(__dirname, '..', 'msd-core', 'bin', 'msd-tools.cjs');
|
|
|
|
/**
|
|
* Bounds a single msd-tools.cjs CLI subcommand invocation — the same call
|
|
* shape as the shared LOOP_HOOK_POINT_CLI_TIMEOUT_MS constant in
|
|
* tests/helpers/timeouts.cjs. This file's pre-existing bound (30000ms) is
|
|
* half that shared norm's value (60000ms) — kept as its own file-local
|
|
* constant rather than folded into the shared one, since no fresh bench
|
|
* data justifies raising this file's bound to match.
|
|
*/
|
|
const PLAN_PRE_HOOK_CLI_TIMEOUT_MS = 30000;
|
|
|
|
// ─── Subprocess helper (isolated env, no ambient MSD_ vars) ───────────────────
|
|
|
|
const CLEAN_ENV = {
|
|
MSD_SESSION_KEY: '',
|
|
CODEX_THREAD_ID: '',
|
|
CLAUDE_SESSION_ID: '',
|
|
CLAUDE_CODE_SSE_PORT: '',
|
|
OPENCODE_SESSION_ID: '',
|
|
GEMINI_SESSION_ID: '',
|
|
CURSOR_SESSION_ID: '',
|
|
WINDSURF_SESSION_ID: '',
|
|
TERM_SESSION_ID: '',
|
|
WT_SESSION: '',
|
|
TMUX_PANE: '',
|
|
ZELLIJ_SESSION_NAME: '',
|
|
TTY: '',
|
|
SSH_TTY: '',
|
|
MSD_WORKSTREAM: '',
|
|
MSD_PROJECT: '',
|
|
};
|
|
|
|
/**
|
|
* Run msd-tools via spawnSync. Returns { status, stdout, stderr }.
|
|
* Passes env overrides through the canonical sandboxed child environment.
|
|
*/
|
|
function runTools(args, cwd, envOverrides = {}) {
|
|
return spawnSync(
|
|
process.execPath,
|
|
[MSD_TOOLS, ...args],
|
|
{
|
|
cwd: cwd || process.cwd(),
|
|
encoding: 'utf8',
|
|
timeout: PLAN_PRE_HOOK_CLI_TIMEOUT_MS,
|
|
env: installSpawnEnv({ ...CLEAN_ENV, ...envOverrides }),
|
|
},
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Parse JSON stdout from runTools result — throws with diagnostic on failure.
|
|
*/
|
|
function parseEnvelope(result, label = '') {
|
|
try {
|
|
return JSON.parse(result.stdout.trim());
|
|
} catch (e) {
|
|
throw new Error(
|
|
`${label}: JSON.parse failed.\n` +
|
|
`stdout=${result.stdout?.slice(0, 300)}\n` +
|
|
`stderr=${result.stderr?.slice(0, 300)}\n` +
|
|
`status=${result.status}`
|
|
);
|
|
}
|
|
}
|
|
|
|
// ─── Fixture factory helpers ──────────────────────────────────────────────────
|
|
|
|
function makePlanningDir(tmpDir, configObj = null) {
|
|
fs.mkdirSync(path.join(tmpDir, '.planning', 'phases'), { recursive: true });
|
|
if (configObj !== null) {
|
|
fs.writeFileSync(
|
|
path.join(tmpDir, '.planning', 'config.json'),
|
|
JSON.stringify(configObj),
|
|
'utf8',
|
|
);
|
|
}
|
|
}
|
|
|
|
function makeProject(configObj = null) {
|
|
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-e2e-'));
|
|
makePlanningDir(tmpDir, configObj);
|
|
return tmpDir;
|
|
}
|
|
|
|
// ─── 1. intel.enabled=true emits step with ref.command and rendered text ──────
|
|
|
|
describe('plan:pre intel step — ref.command and rendered text', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = makeProject({ intel: { enabled: true } });
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[happy] intel.enabled=true: activeHooks has intel step with ref.command="intel api-surface"', () => {
|
|
const result = runTools(['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'intel-step');
|
|
|
|
assert.strictEqual(envelope.point, 'plan:pre');
|
|
assert.ok(Array.isArray(envelope.activeHooks), 'activeHooks must be array');
|
|
|
|
const intelHook = envelope.activeHooks.find(h => h.capId === 'intel');
|
|
assert.ok(intelHook !== undefined, 'intel hook must be present when intel.enabled=true');
|
|
assert.strictEqual(intelHook.kind, 'step', 'intel hook kind must be step');
|
|
assert.deepEqual(intelHook.ref, { command: 'intel api-surface' },
|
|
'ref must be {command:"intel api-surface"} not a JSON blob');
|
|
|
|
// Rendered text: check it contains "intel api-surface" (as part of the JSON or label)
|
|
assert.ok(
|
|
envelope.rendered.includes('intel api-surface'),
|
|
`rendered must contain 'intel api-surface'. Got: ${envelope.rendered.slice(0, 200)}`,
|
|
);
|
|
// Rendered must be structured step text, not a bare JSON object dump.
|
|
// A structured render includes human-readable step metadata (- produces:, - when:).
|
|
assert.ok(
|
|
envelope.rendered.includes('- produces:') && envelope.rendered.includes('- when:'),
|
|
'intel step must render as a structured step (with produces/when labels), not an opaque blob',
|
|
);
|
|
// Also assert the produces path appears
|
|
assert.ok(
|
|
envelope.rendered.includes('.planning/intel/API-SURFACE.md'),
|
|
'rendered must include the produced file path',
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 2. tdd_mode=true emits tdd contribution with <tdd_mode_active> ───────────
|
|
|
|
describe('plan:pre tdd contribution — fragment.inline contains <tdd_mode_active>', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = makeProject({ workflow: { tdd_mode: true } });
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[happy] tdd_mode=true: tdd contribution fragment.inline contains <tdd_mode_active>', () => {
|
|
const result = runTools(['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'tdd-contribution');
|
|
|
|
const tddHook = envelope.activeHooks.find(h => h.capId === 'tdd');
|
|
assert.ok(tddHook !== undefined, 'tdd hook must be present when tdd_mode=true');
|
|
assert.strictEqual(tddHook.kind, 'contribution', 'tdd hook kind must be contribution');
|
|
assert.ok(
|
|
tddHook.fragment && typeof tddHook.fragment.inline === 'string',
|
|
'tdd hook must have fragment.inline string',
|
|
);
|
|
assert.ok(
|
|
tddHook.fragment.inline.includes('<tdd_mode_active>'),
|
|
`fragment.inline must contain '<tdd_mode_active>'. Got: ${tddHook.fragment.inline.slice(0, 200)}`,
|
|
);
|
|
|
|
// Rendered text must also contain the tag
|
|
assert.ok(
|
|
envelope.rendered.includes('<tdd_mode_active>'),
|
|
`rendered must contain '<tdd_mode_active>'. Got: ${envelope.rendered.slice(0, 200)}`,
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 3. security contribution emits configValues from explicit config ──────────
|
|
|
|
describe('plan:pre security contribution — configValues from explicit config', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = makeProject({
|
|
workflow: {
|
|
security_enforcement: true,
|
|
security_asvs_level: 3,
|
|
security_block_on: 'critical',
|
|
},
|
|
});
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[happy] security_enforcement=true + explicit asvs=3 + block_on=critical: configValues match config', () => {
|
|
const result = runTools(['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'security-configValues-explicit');
|
|
|
|
const secHook = envelope.activeHooks.find(h => h.capId === 'security');
|
|
assert.ok(secHook !== undefined, 'security hook must be present when security_enforcement=true');
|
|
assert.strictEqual(secHook.kind, 'contribution', 'security hook kind must be contribution');
|
|
assert.ok(secHook.configValues !== undefined, 'security hook must have configValues');
|
|
assert.strictEqual(secHook.configValues.security_asvs_level, 3,
|
|
'security_asvs_level must be 3 (from config, not default 1)');
|
|
assert.strictEqual(secHook.configValues.security_block_on, 'critical',
|
|
'security_block_on must be critical (from config, not default high)');
|
|
});
|
|
});
|
|
|
|
// ─── 4. BVA: security defaults when enforcement=true but levels not set ────────
|
|
|
|
describe('plan:pre security contribution — BVA: default configValues', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = makeProject({ workflow: { security_enforcement: true } });
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[bva] security_enforcement=true only: configValues use schema defaults (asvs=1, block_on=high)', () => {
|
|
const result = runTools(['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'security-configValues-defaults');
|
|
|
|
const secHook = envelope.activeHooks.find(h => h.capId === 'security');
|
|
assert.ok(secHook !== undefined, 'security hook must be present');
|
|
assert.ok(secHook.configValues !== undefined, 'security hook must have configValues');
|
|
// BVA: schema defaults — must be 1 and 'high', NOT 3 or 'critical'
|
|
assert.strictEqual(secHook.configValues.security_asvs_level, 1,
|
|
'default asvs_level must be 1 when not set in config');
|
|
assert.strictEqual(secHook.configValues.security_block_on, 'high',
|
|
'default block_on must be high when not set in config');
|
|
});
|
|
});
|
|
|
|
// ─── 5. All plan:pre when-keys false → empty activeHooks + placeholder ─────────
|
|
|
|
describe('plan:pre all-off — empty resolution', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = makeProject({
|
|
workflow: {
|
|
ai_integration_phase: false,
|
|
api_coverage_gate: false,
|
|
tdd_mode: false,
|
|
security_enforcement: false,
|
|
ui_phase: false,
|
|
ui_safety_gate: false,
|
|
research: false,
|
|
pattern_mapper: false,
|
|
schema_push_detection: false,
|
|
plan_drift_precheck: false,
|
|
context_drift_precheck: false,
|
|
assumption_delta: false,
|
|
},
|
|
intel: { enabled: false },
|
|
});
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[negative] all plan:pre when-keys false: activeHooks empty, rendered is placeholder', () => {
|
|
const result = runTools(['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'all-off');
|
|
|
|
assert.deepStrictEqual(envelope.activeHooks, [],
|
|
`activeHooks must be empty when all flags false. Got: ${JSON.stringify(envelope.activeHooks.map(h=>h.capId))}`);
|
|
assert.strictEqual(envelope.rendered, '_No active hooks at plan:pre._',
|
|
'rendered must be placeholder when no active hooks');
|
|
});
|
|
|
|
test('#4485: an ambient plan:pre capability cannot perturb the empty resolution', (t) => {
|
|
withAmbientCapabilityHome(t, 'msd-ambient-plan-pre-', 'ambient-plan-pre', 'plan:pre');
|
|
|
|
const result = runTools(['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'all-off-ambient');
|
|
assert.deepStrictEqual(envelope.activeHooks, []);
|
|
});
|
|
});
|
|
|
|
// ─── 6. check ui.plan-gate: frontend + no-spec → block:true ──────────────────
|
|
|
|
describe('check ui.plan-gate — frontend phase, no UI-SPEC', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-ui-gate-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(path.join(planningDir, 'phases', '01-dashboard'), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDir, 'config.json'), '{}', 'utf8');
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'ROADMAP.md'),
|
|
[
|
|
'# Project Roadmap',
|
|
'',
|
|
'## Phase 1: Dashboard',
|
|
'',
|
|
'Build the user interface and frontend dashboard components.',
|
|
'',
|
|
].join('\n'),
|
|
'utf8',
|
|
);
|
|
// Static frontend evidence (#3312): block requires token match AND structural
|
|
// corroboration — this fixture is a real frontend repo.
|
|
fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
|
|
fs.writeFileSync(path.join(tmpDir, 'src', 'App.tsx'), 'export function App() { return null; }\n', 'utf8');
|
|
// No UI-SPEC.md in phase dir
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[happy] frontend phase + evidence + no UI-SPEC: block:true, frontend:true, hasUiSpec:false, exit 0', () => {
|
|
const result = runTools(['check', 'ui.plan-gate', '1', '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const out = parseEnvelope(result, 'ui-plan-gate-no-spec');
|
|
|
|
assert.strictEqual(out.frontend, true, 'frontend must be true for frontend-keyword phase');
|
|
assert.strictEqual(out.hasFrontendEvidence, true, 'src/App.tsx is frontend evidence');
|
|
assert.strictEqual(out.hasUiSpec, false, 'hasUiSpec must be false when no spec file exists');
|
|
assert.strictEqual(out.block, true, 'block must be true (frontend && hasFrontendEvidence && !hasUiSpec)');
|
|
assert.strictEqual(out.uiSpecPath, null, 'uiSpecPath must be null when spec absent');
|
|
// matchedToken is the FIRST match in the phase section — the "## Phase 1:
|
|
// Dashboard" heading precedes the body, so the first match is `dashboard`.
|
|
assert.strictEqual(out.matchedToken, 'dashboard', 'matchedToken surfaces what tripped the sniffer');
|
|
});
|
|
});
|
|
|
|
// ─── 6b. check ui.plan-gate: #3312 — token match without frontend evidence ────
|
|
|
|
describe('check ui.plan-gate — #3312 proper-noun token match, no frontend evidence', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-ui-gate-3312-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(path.join(planningDir, 'phases', '01-infra'), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDir, 'config.json'), '{}', 'utf8');
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'ROADMAP.md'),
|
|
[
|
|
'# Project Roadmap',
|
|
'',
|
|
'## Phase 1: Infra',
|
|
'',
|
|
'Fix broken references in dashboard-financeiro, update .env.tpl and CI workflows.',
|
|
'',
|
|
].join('\n'),
|
|
'utf8',
|
|
);
|
|
// Markdown/bash/config repo by design: no src/, no package.json, no component files.
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[regression] dashboard-financeiro mention in non-frontend repo: frontend:true but block:false', () => {
|
|
const result = runTools(['check', 'ui.plan-gate', '1', '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const out = parseEnvelope(result, 'ui-plan-gate-3312');
|
|
|
|
assert.strictEqual(out.frontend, true,
|
|
'sniffer still matches `dashboard` at the hyphen boundary (micro-frontend rule)');
|
|
assert.strictEqual(out.hasFrontendEvidence, false,
|
|
'markdown/bash repo has no component files and no UI-framework dependency');
|
|
assert.strictEqual(out.block, false,
|
|
'#3312: token match without structural evidence must NOT block planning');
|
|
assert.strictEqual(out.matchedToken, 'dashboard', 'matchedToken surfaces the proper-noun trigger');
|
|
assert.ok(
|
|
typeof out.matchedLine === 'string' && out.matchedLine.includes('dashboard-financeiro'),
|
|
'matchedLine surfaces the line for one-second operator triage',
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 7. check ui.plan-gate: frontend + spec present → block:false ─────────────
|
|
|
|
describe('check ui.plan-gate — frontend phase, UI-SPEC present', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-ui-gate-spec-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(path.join(planningDir, 'phases', '01-dashboard'), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDir, 'config.json'), '{}', 'utf8');
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'ROADMAP.md'),
|
|
[
|
|
'# Project Roadmap',
|
|
'',
|
|
'## Phase 1: Dashboard',
|
|
'',
|
|
'Build the frontend React dashboard with UI forms.',
|
|
'',
|
|
].join('\n'),
|
|
'utf8',
|
|
);
|
|
// Add a UI-SPEC.md
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'phases', '01-dashboard', '01-UI-SPEC.md'),
|
|
'# UI Design Contract\n',
|
|
'utf8',
|
|
);
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[happy] frontend phase + UI-SPEC present: block:false, hasUiSpec:true, uiSpecPath ends with -UI-SPEC.md', () => {
|
|
const result = runTools(['check', 'ui.plan-gate', '1', '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const out = parseEnvelope(result, 'ui-plan-gate-with-spec');
|
|
|
|
assert.strictEqual(out.frontend, true, 'frontend must be true');
|
|
assert.strictEqual(out.hasUiSpec, true, 'hasUiSpec must be true when spec file exists');
|
|
assert.strictEqual(out.block, false, 'block must be false (spec present)');
|
|
assert.ok(
|
|
typeof out.uiSpecPath === 'string' && out.uiSpecPath.endsWith('-UI-SPEC.md'),
|
|
`uiSpecPath must end with -UI-SPEC.md. Got: ${out.uiSpecPath}`,
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 8. check ui.plan-gate: missing phase arg → exit 1 + error message ────────
|
|
|
|
describe('check ui.plan-gate — missing phase argument', () => {
|
|
test('[negative] missing phase arg: exit code 1, stderr contains ui-plan-gate requires a phase argument', () => {
|
|
const result = runTools(['check', 'ui.plan-gate', '--raw']);
|
|
assert.strictEqual(result.exitCode ?? result.status, 1,
|
|
`exit code must be 1. Got: ${result.status}. stderr=${result.stderr?.slice(0, 300)}`);
|
|
assert.ok(
|
|
(result.stderr || '').includes('ui-plan-gate requires a phase argument'),
|
|
`stderr must include 'ui-plan-gate requires a phase argument'. Got: ${result.stderr?.slice(0, 300)}`,
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 9. BVA: check ui.plan-gate phase=99 → phaseLookupFailed:true ─────────────
|
|
|
|
describe('check ui.plan-gate — BVA: non-existent phase 99', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-ui-gate-99-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(path.join(planningDir, 'phases', '01-dashboard'), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDir, 'config.json'), '{}', 'utf8');
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'ROADMAP.md'),
|
|
[
|
|
'# Project Roadmap',
|
|
'',
|
|
'## Phase 1: Dashboard',
|
|
'',
|
|
'Build the frontend dashboard.',
|
|
'',
|
|
].join('\n'),
|
|
'utf8',
|
|
);
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[bva] phase=99 (nonexistent in ROADMAP.md with only Phase 1): phaseLookupFailed:true, block:false', () => {
|
|
const result = runTools(['check', 'ui.plan-gate', '99', '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit must be 0. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const out = parseEnvelope(result, 'ui-plan-gate-phase-99');
|
|
|
|
assert.strictEqual(out.phaseLookupFailed, true,
|
|
'phaseLookupFailed must be true for a phase not found in ROADMAP.md');
|
|
// When phase lookup fails, frontend defaults to false and block must be false
|
|
assert.strictEqual(out.frontend, false,
|
|
'frontend must be false when phase lookup fails (not silently block:false)');
|
|
assert.strictEqual(out.block, false,
|
|
'block must be false when phase not found — phaseLookupFailed distinguishes this from a clean pass');
|
|
});
|
|
});
|
|
|
|
// ─── 10. BVA: intel api-surface symbolCount=0 → stale:true + Incomplete ──────
|
|
|
|
describe('intel api-surface — BVA: symbolCount=0 (empty entries)', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-intel-empty-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(path.join(planningDir, 'intel'), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDir, 'config.json'), JSON.stringify({ intel: { enabled: true } }), 'utf8');
|
|
// api-map.json with empty object entries
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'intel', 'api-map.json'),
|
|
JSON.stringify({ entries: {} }),
|
|
'utf8',
|
|
);
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[bva] symbolCount=0: exit 0, stale:true, symbolCount:0, written file contains Incomplete banner', () => {
|
|
const result = runTools(['intel', 'api-surface', '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const out = parseEnvelope(result, 'intel-api-surface-empty');
|
|
|
|
assert.strictEqual(out.symbolCount, 0, 'symbolCount must be 0 for empty entries');
|
|
assert.strictEqual(out.stale, true, 'stale must be true when no _meta.updated_at');
|
|
assert.ok(typeof out.written === 'string' && out.written.endsWith('API-SURFACE.md'),
|
|
`written must be a path ending in API-SURFACE.md. Got: ${out.written}`);
|
|
|
|
// Content check — the written file must contain the Incomplete banner
|
|
const content = fs.readFileSync(out.written, 'utf8');
|
|
assert.ok(
|
|
content.includes('Incomplete'),
|
|
`API-SURFACE.md must contain 'Incomplete' banner when symbolCount=0. Got: ${content.slice(0, 300)}`,
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 11. BVA: intel api-surface symbolCount=1 fresh → stale:false ─────────────
|
|
|
|
describe('intel api-surface — BVA: symbolCount=1, fresh _meta', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-intel-one-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(path.join(planningDir, 'intel'), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDir, 'config.json'), JSON.stringify({ intel: { enabled: true } }), 'utf8');
|
|
// api-map.json with one entry object and fresh _meta
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'intel', 'api-map.json'),
|
|
JSON.stringify({
|
|
entries: {
|
|
getUserById: {
|
|
file: 'src/api/users.ts',
|
|
kind: 'function',
|
|
signature: 'getUserById(id: string): Promise<User>',
|
|
},
|
|
},
|
|
_meta: { updated_at: new Date().toISOString() },
|
|
}),
|
|
'utf8',
|
|
);
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[bva] symbolCount=1 with fresh _meta.updated_at: exit 0, stale:false, symbolCount:1', () => {
|
|
const result = runTools(['intel', 'api-surface', '--raw'], tmpDir);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const out = parseEnvelope(result, 'intel-api-surface-one-entry');
|
|
|
|
assert.strictEqual(out.symbolCount, 1, 'symbolCount must be 1 for one entry');
|
|
assert.strictEqual(out.stale, false, 'stale must be false when _meta.updated_at is fresh (<24h)');
|
|
assert.ok(typeof out.written === 'string' && out.written.endsWith('API-SURFACE.md'),
|
|
`written must be API-SURFACE.md path. Got: ${out.written}`);
|
|
|
|
// Content check — symbol must appear in the file
|
|
const content = fs.readFileSync(out.written, 'utf8');
|
|
assert.ok(
|
|
content.includes('getUserById'),
|
|
`API-SURFACE.md must contain 'getUserById' symbol. Got: ${content.slice(0, 300)}`,
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── 12. ui cluster disabled + tdd + intel on → no ui hooks, intel+tdd present ─
|
|
|
|
describe('plan:pre surface cluster filter — ui disabled, tdd+intel active', () => {
|
|
let tmpDir;
|
|
before(() => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-pre-surface-'));
|
|
const planningDir = path.join(tmpDir, '.planning');
|
|
fs.mkdirSync(planningDir, { recursive: true });
|
|
// Enable intel, tdd, and also ui things in project config
|
|
fs.writeFileSync(
|
|
path.join(planningDir, 'config.json'),
|
|
JSON.stringify({
|
|
intel: { enabled: true },
|
|
workflow: {
|
|
tdd_mode: true,
|
|
ui_phase: true,
|
|
ui_safety_gate: true,
|
|
security_enforcement: false,
|
|
research: false,
|
|
pattern_mapper: false,
|
|
schema_push_detection: false,
|
|
ai_integration_phase: false,
|
|
},
|
|
}),
|
|
'utf8',
|
|
);
|
|
// .msd-surface.json disabling UI cluster in same dir (config-dir = tmpDir)
|
|
fs.writeFileSync(
|
|
path.join(tmpDir, '.msd-surface.json'),
|
|
JSON.stringify({
|
|
baseProfile: 'full',
|
|
disabledClusters: ['ui'],
|
|
explicitAdds: [],
|
|
explicitRemoves: [],
|
|
}),
|
|
'utf8',
|
|
);
|
|
});
|
|
after(() => cleanup(tmpDir));
|
|
|
|
test('[empty-resolution/surface] ui cluster disabled: no ui hooks; intel and tdd hooks present', () => {
|
|
const result = runTools(
|
|
['loop', 'render-hooks', 'plan:pre', '--cwd', tmpDir, '--config-dir', tmpDir, '--raw'],
|
|
tmpDir,
|
|
);
|
|
assert.strictEqual(result.status, 0, `exit non-zero. stderr=${result.stderr?.slice(0, 300)}`);
|
|
const envelope = parseEnvelope(result, 'ui-cluster-disabled');
|
|
|
|
// No ui hooks — specific assertion on the differing field
|
|
const uiHooks = envelope.activeHooks.filter(h => h.capId === 'ui');
|
|
assert.strictEqual(uiHooks.length, 0,
|
|
`ui cluster disabled must suppress all ui hooks. Got ui hooks: ${JSON.stringify(uiHooks)}`);
|
|
|
|
// intel hook must be present (not suppressed by ui cluster disable)
|
|
const intelHooks = envelope.activeHooks.filter(h => h.capId === 'intel');
|
|
assert.strictEqual(intelHooks.length, 1,
|
|
`intel hook must be present. Got: ${JSON.stringify(envelope.activeHooks.map(h => h.capId))}`);
|
|
|
|
// tdd hook must be present
|
|
const tddHooks = envelope.activeHooks.filter(h => h.capId === 'tdd');
|
|
assert.strictEqual(tddHooks.length, 1,
|
|
`tdd hook must be present. Got: ${JSON.stringify(envelope.activeHooks.map(h => h.capId))}`);
|
|
});
|
|
});
|