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.
816 lines
38 KiB
JavaScript
816 lines
38 KiB
JavaScript
// allow-test-rule: source-text-is-the-product
|
|
// Workflow .md / agent .md / command .md / reference .md files — their text
|
|
// IS what the runtime loads. Testing text content tests the deployed contract.
|
|
// Per CONTRIBUTING.md exception matrix.
|
|
|
|
/**
|
|
* MSD Tools Tests - frontmatter CLI integration
|
|
*
|
|
* Integration tests for the 4 frontmatter subcommands (get, set, merge, validate)
|
|
* exercised through msd-tools.cjs via execSync.
|
|
*
|
|
* Each test creates its own temp file, runs the CLI command, asserts output,
|
|
* and cleans up in afterEach (per-test cleanup with individual temp files).
|
|
*/
|
|
|
|
const { test, describe, afterEach } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const os = require('os');
|
|
const { runNode } = require('./helpers/process-seam.cjs');
|
|
const { toLegacyResult } = require('./helpers/git-fixture.cjs');
|
|
const { PROBE_TIMEOUT_MS } = require('./helpers/timeouts.cjs');
|
|
const { runMsdTools, parseFrontmatter } = require('./helpers.cjs');
|
|
|
|
// Track temp files for cleanup
|
|
let tempFiles = [];
|
|
|
|
function writeTempFile(content) {
|
|
const tmpFile = path.join(os.tmpdir(), `msd-fm-test-${Date.now()}-${Math.random().toString(36).slice(2)}.md`);
|
|
fs.writeFileSync(tmpFile, content, 'utf-8');
|
|
tempFiles.push(tmpFile);
|
|
return tmpFile;
|
|
}
|
|
|
|
afterEach(() => {
|
|
for (const f of tempFiles) {
|
|
try { fs.unlinkSync(f); } catch { /* already cleaned */ }
|
|
}
|
|
tempFiles = [];
|
|
});
|
|
|
|
// ─── frontmatter get ────────────────────────────────────────────────────────
|
|
|
|
describe('frontmatter get', () => {
|
|
test('returns all fields as JSON', () => {
|
|
const file = writeTempFile('---\nphase: 01\nplan: 01\ntype: execute\n---\nbody text');
|
|
const result = runMsdTools(['frontmatter', 'get', file]);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.phase, '01');
|
|
assert.strictEqual(parsed.plan, '01');
|
|
assert.strictEqual(parsed.type, 'execute');
|
|
});
|
|
|
|
test('returns specific field with --field', () => {
|
|
const file = writeTempFile('---\nphase: 01\nplan: 02\ntype: tdd\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'get', file, '--field', 'phase']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.phase, '01');
|
|
});
|
|
|
|
test('returns error for missing field', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\n');
|
|
const result = runMsdTools(['frontmatter', 'get', file, '--field', 'nonexistent']);
|
|
// The command succeeds (exit 0) but returns an error object in JSON
|
|
assert.ok(result.success, 'Command should exit 0');
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(parsed.error, 'Should have error field');
|
|
assert.ok(parsed.error.includes('Field not found'), 'Error should mention "Field not found"');
|
|
});
|
|
|
|
test('returns error for missing file', () => {
|
|
const result = runMsdTools('frontmatter get /nonexistent/path/file.md');
|
|
assert.ok(result.success, 'Command should exit 0 with error JSON');
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(parsed.error, 'Should have error field');
|
|
});
|
|
|
|
test('handles file with no frontmatter', () => {
|
|
const file = writeTempFile('Plain text with no frontmatter delimiters.');
|
|
const result = runMsdTools(['frontmatter', 'get', file]);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.deepStrictEqual(parsed, {}, 'Should return empty object for no frontmatter');
|
|
});
|
|
});
|
|
|
|
// ─── frontmatter set ────────────────────────────────────────────────────────
|
|
|
|
describe('frontmatter set', () => {
|
|
test('updates existing field', () => {
|
|
const file = writeTempFile('---\nphase: 01\ntype: execute\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'set', file, '--field', 'phase', '--value', '02']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
|
|
// Read back and verify
|
|
const content = fs.readFileSync(file, 'utf-8');
|
|
const { extractFrontmatter } = require('../msd-core/bin/lib/frontmatter.cjs');
|
|
const fm = extractFrontmatter(content);
|
|
assert.strictEqual(fm.phase, '02');
|
|
});
|
|
|
|
test('adds new field', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'set', file, '--field', 'status', '--value', 'active']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
|
|
const content = fs.readFileSync(file, 'utf-8');
|
|
const { extractFrontmatter } = require('../msd-core/bin/lib/frontmatter.cjs');
|
|
const fm = extractFrontmatter(content);
|
|
assert.strictEqual(fm.status, 'active');
|
|
});
|
|
|
|
test('handles JSON array value', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'set', file, '--field', 'tags', '--value', '["a","b"]']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
|
|
const content = fs.readFileSync(file, 'utf-8');
|
|
const { extractFrontmatter } = require('../msd-core/bin/lib/frontmatter.cjs');
|
|
const fm = extractFrontmatter(content);
|
|
assert.ok(Array.isArray(fm.tags), 'tags should be an array');
|
|
assert.deepStrictEqual(fm.tags, ['a', 'b']);
|
|
});
|
|
|
|
test('returns error for missing file', () => {
|
|
const result = runMsdTools('frontmatter set /nonexistent/file.md --field phase --value "01"');
|
|
assert.ok(result.success, 'Command should exit 0 with error JSON');
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(parsed.error, 'Should have error field');
|
|
});
|
|
|
|
test('preserves body content after set', () => {
|
|
const bodyText = '\n\n# My Heading\n\nSome paragraph with special chars: $, %, &.';
|
|
const file = writeTempFile('---\nphase: 01\n---' + bodyText);
|
|
runMsdTools(['frontmatter', 'set', file, '--field', 'phase', '--value', '02']);
|
|
|
|
const content = fs.readFileSync(file, 'utf-8');
|
|
assert.ok(content.includes('# My Heading'), 'heading should be preserved');
|
|
assert.ok(content.includes('Some paragraph with special chars: $, %, &.'), 'body content should be preserved');
|
|
});
|
|
});
|
|
|
|
// ─── frontmatter merge ──────────────────────────────────────────────────────
|
|
|
|
describe('frontmatter merge', () => {
|
|
test('merges multiple fields into frontmatter', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'merge', file, '--data', '{"plan":"02","type":"tdd"}']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
|
|
const content = fs.readFileSync(file, 'utf-8');
|
|
const { extractFrontmatter } = require('../msd-core/bin/lib/frontmatter.cjs');
|
|
const fm = extractFrontmatter(content);
|
|
assert.strictEqual(fm.phase, '01', 'original field should be preserved');
|
|
assert.strictEqual(fm.plan, '02', 'merged field should be present');
|
|
assert.strictEqual(fm.type, 'tdd', 'merged field should be present');
|
|
});
|
|
|
|
test('overwrites existing fields on conflict', () => {
|
|
const file = writeTempFile('---\nphase: 01\ntype: execute\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'merge', file, '--data', '{"phase":"02"}']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
|
|
const content = fs.readFileSync(file, 'utf-8');
|
|
const { extractFrontmatter } = require('../msd-core/bin/lib/frontmatter.cjs');
|
|
const fm = extractFrontmatter(content);
|
|
assert.strictEqual(fm.phase, '02', 'conflicting field should be overwritten');
|
|
assert.strictEqual(fm.type, 'execute', 'non-conflicting field should be preserved');
|
|
});
|
|
|
|
test('returns error for missing file', () => {
|
|
const result = runMsdTools(`frontmatter merge /nonexistent/file.md --data '{"phase":"01"}'`);
|
|
assert.ok(result.success, 'Command should exit 0 with error JSON');
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(parsed.error, 'Should have error field');
|
|
});
|
|
|
|
test('returns error for invalid JSON data', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'merge', file, '--data', 'not json']);
|
|
// cmdFrontmatterMerge calls error() which exits with code 1
|
|
assert.ok(!result.success, 'Command should fail with non-zero exit code');
|
|
assert.ok(result.error.includes('Invalid JSON'), 'Error should mention invalid JSON');
|
|
});
|
|
});
|
|
|
|
// ─── frontmatter validate ───────────────────────────────────────────────────
|
|
|
|
describe('frontmatter validate', () => {
|
|
test('reports valid for complete plan frontmatter', () => {
|
|
const content = `---
|
|
phase: 01
|
|
plan: 01
|
|
type: execute
|
|
wave: 1
|
|
depends_on: []
|
|
files_modified: [src/auth.ts]
|
|
autonomous: true
|
|
must_haves:
|
|
truths:
|
|
- "All tests pass"
|
|
---
|
|
body`;
|
|
const file = writeTempFile(content);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, true, 'Should be valid');
|
|
assert.deepStrictEqual(parsed.missing, [], 'No fields should be missing');
|
|
assert.strictEqual(parsed.schema, 'plan');
|
|
});
|
|
|
|
test('reports invalid with missing fields', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, false, 'Should be invalid');
|
|
assert.ok(parsed.missing.length > 0, 'Should have missing fields');
|
|
// plan schema requires: phase, plan, type, wave, depends_on, files_modified, autonomous, must_haves
|
|
// phase is present, so 7 should be missing
|
|
assert.strictEqual(parsed.missing.length, 7, 'Should have 7 missing required fields');
|
|
assert.ok(parsed.missing.includes('plan'), 'plan should be in missing');
|
|
assert.ok(parsed.missing.includes('type'), 'type should be in missing');
|
|
assert.ok(parsed.missing.includes('must_haves'), 'must_haves should be in missing');
|
|
});
|
|
|
|
test('validates against summary schema', () => {
|
|
const content = `---
|
|
phase: 01
|
|
plan: 01
|
|
subsystem: testing
|
|
tags: [unit-tests, yaml]
|
|
duration: 5min
|
|
completed: 2026-02-25
|
|
---
|
|
body`;
|
|
const file = writeTempFile(content);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'summary']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, true, 'Should be valid for summary schema');
|
|
assert.strictEqual(parsed.schema, 'summary');
|
|
});
|
|
|
|
test('validates against verification schema', () => {
|
|
const content = `---
|
|
phase: 01
|
|
verified: 2026-02-25
|
|
status: passed
|
|
score: 5/5
|
|
---
|
|
body`;
|
|
const file = writeTempFile(content);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'verification']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, true, 'Should be valid for verification schema');
|
|
assert.strictEqual(parsed.schema, 'verification');
|
|
});
|
|
|
|
test('returns error for unknown schema', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\n');
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'unknown']);
|
|
// cmdFrontmatterValidate calls error() which exits with code 1
|
|
assert.ok(!result.success, 'Command should fail with non-zero exit code');
|
|
assert.ok(result.error.includes('Unknown schema'), 'Error should mention unknown schema');
|
|
});
|
|
|
|
// #2847 review finding: a bare FRONTMATTER_SCHEMAS[schemaName] lookup resolves
|
|
// prototype-chain keys to Object.prototype members instead of undefined, so the
|
|
// `!schema` guard never fires and the command crashes with an uncaught TypeError
|
|
// ("Cannot read properties of undefined (reading 'filter')") and a stack trace
|
|
// instead of reporting "Unknown schema". Now that --schema is an agent-bound
|
|
// variable ($SCHEMA in agents/msd-planner.md's validate_plan step) rather than a
|
|
// fixed literal, this is reachable from prompt state.
|
|
for (const schemaName of ['__proto__', 'constructor', 'toString', 'hasOwnProperty', 'valueOf']) {
|
|
test(`--schema ${schemaName} reports Unknown schema, not a crash`, () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\n');
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', schemaName]);
|
|
assert.ok(!result.success, `--schema ${schemaName} should fail with a non-zero exit code, not crash`);
|
|
assert.ok(
|
|
result.error.includes('Unknown schema'),
|
|
`--schema ${schemaName} error should be "Unknown schema...", not a TypeError stack trace; got: ${result.error}`
|
|
);
|
|
assert.ok(
|
|
!result.error.includes('TypeError') && !result.error.includes('Cannot read properties'),
|
|
`--schema ${schemaName} must not surface a raw TypeError; got: ${result.error}`
|
|
);
|
|
});
|
|
}
|
|
|
|
test('returns error for missing file', () => {
|
|
const result = runMsdTools('frontmatter validate /nonexistent/file.md --schema plan');
|
|
assert.ok(result.success, 'Command should exit 0 with error JSON');
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(parsed.error, 'Should have error field');
|
|
});
|
|
});
|
|
|
|
// ─── frontmatter validate: plan-gap-closure schema (#2847) ───────────────────
|
|
//
|
|
// Regression coverage for #2847: "--gaps does not load planner-gap-closure.md,
|
|
// so generated gap plans may miss gap_closure metadata". A gap-closure plan
|
|
// with every other required field but no `gap_closure` used to report
|
|
// `valid: true` against the only schema the planner validated against
|
|
// (`plan`). Row 1 below is the failing-first regression test: it fails on
|
|
// pre-fix `FRONTMATTER_SCHEMAS` (no `plan-gap-closure` key exists — the CLI
|
|
// exits 1 with "Unknown schema: plan-gap-closure") and passes after the fix.
|
|
|
|
describe('frontmatter validate: plan-gap-closure schema (#2847)', () => {
|
|
const PLAN_BODY_NO_GAP_CLOSURE = `---
|
|
phase: 01
|
|
plan: 01
|
|
type: execute
|
|
wave: 1
|
|
depends_on: []
|
|
files_modified: [src/auth.ts]
|
|
autonomous: true
|
|
must_haves:
|
|
truths:
|
|
- "All tests pass"
|
|
---
|
|
body`;
|
|
|
|
// Row 1 — failing-first regression test.
|
|
test('rejects plan-gap-closure frontmatter missing gap_closure (#2847)', () => {
|
|
const file = writeTempFile(PLAN_BODY_NO_GAP_CLOSURE);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan-gap-closure']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, false, 'Should be invalid: gap_closure is missing');
|
|
assert.ok(parsed.missing.includes('gap_closure'), 'gap_closure should be reported missing');
|
|
assert.strictEqual(parsed.missing.length, 1, 'Only gap_closure should be missing; all other fields are present');
|
|
assert.deepStrictEqual(parsed.invalidValue, [], 'gap_closure is ABSENT here, not wrong-valued — invalidValue must stay empty');
|
|
assert.strictEqual(parsed.schema, 'plan-gap-closure');
|
|
});
|
|
|
|
// Row 2 — happy path.
|
|
test('accepts complete plan-gap-closure frontmatter', () => {
|
|
const content = `---
|
|
phase: 01
|
|
plan: 01
|
|
type: execute
|
|
wave: 1
|
|
depends_on: []
|
|
files_modified: [src/auth.ts]
|
|
autonomous: true
|
|
must_haves:
|
|
truths:
|
|
- "All tests pass"
|
|
gap_closure: true
|
|
---
|
|
body`;
|
|
const file = writeTempFile(content);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan-gap-closure']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, true, 'Should be valid: gap_closure is present');
|
|
assert.deepStrictEqual(parsed.missing, []);
|
|
assert.ok(parsed.present.includes('gap_closure'));
|
|
assert.deepStrictEqual(parsed.invalidValue, [], 'gap_closure has the correct value here — invalidValue must be empty');
|
|
assert.strictEqual(parsed.schema, 'plan-gap-closure');
|
|
});
|
|
|
|
// Row 3 — empty/near-empty input boundary.
|
|
test('reports all plan-gap-closure fields missing except phase for near-empty frontmatter', () => {
|
|
const file = writeTempFile('---\nphase: 01\n---\nbody');
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan-gap-closure']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, false);
|
|
// plan-gap-closure requires 9 fields; phase is present, so 8 should be missing.
|
|
assert.strictEqual(parsed.missing.length, 8, 'Should have 8 missing required fields');
|
|
assert.ok(parsed.missing.includes('gap_closure'), 'gap_closure should be among the missing fields');
|
|
});
|
|
|
|
// Row 4 — negative space: standard-mode ('plan' schema) plans are unaffected by #2847's fix.
|
|
test('plan schema (standard/reviews mode) still reports valid without gap_closure — unaffected by #2847 fix', () => {
|
|
const file = writeTempFile(PLAN_BODY_NO_GAP_CLOSURE);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, true, 'plan schema must not require gap_closure (AC(3): standard mode unaffected)');
|
|
assert.deepStrictEqual(parsed.missing, []);
|
|
assert.strictEqual(parsed.schema, 'plan');
|
|
});
|
|
|
|
// Row 5 — CRLF cross-platform newline handling.
|
|
test('parses plan-gap-closure frontmatter with CRLF line endings', () => {
|
|
const content = [
|
|
'---',
|
|
'phase: 01',
|
|
'plan: 01',
|
|
'type: execute',
|
|
'wave: 1',
|
|
'depends_on: []',
|
|
'files_modified: [src/auth.ts]',
|
|
'autonomous: true',
|
|
'must_haves:',
|
|
' truths:',
|
|
' - "All tests pass"',
|
|
'gap_closure: true',
|
|
'---',
|
|
'body',
|
|
].join('\r\n');
|
|
const file = writeTempFile(content);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan-gap-closure']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, true, 'CRLF frontmatter must parse identically to LF for plan-gap-closure');
|
|
assert.ok(parsed.present.includes('gap_closure'));
|
|
});
|
|
|
|
// Row 6 — gap_closure: false must be REJECTED, not merely present.
|
|
//
|
|
// #2847 review finding: --gaps-only filters strictly on gap_closure === true
|
|
// (execute-phase.md, partial-wave.md). A presence-only check (matching every
|
|
// other required field) lets `gap_closure: false` validate as valid:true,
|
|
// which is #2847's exact reported symptom — --gaps-only still spawns zero
|
|
// executors — one value away. plan-gap-closure's requiredValues entry closes
|
|
// this: gap_closure must be present AND equal "true" (extractFrontmatter
|
|
// parses every scalar as a string; FrontmatterValue has no boolean member).
|
|
test('gap_closure: false is rejected — plan-gap-closure requires the value true, not mere presence', () => {
|
|
const content = `---
|
|
phase: 01
|
|
plan: 01
|
|
type: execute
|
|
wave: 1
|
|
depends_on: []
|
|
files_modified: [src/auth.ts]
|
|
autonomous: true
|
|
must_haves:
|
|
truths:
|
|
- "All tests pass"
|
|
gap_closure: false
|
|
---
|
|
body`;
|
|
const file = writeTempFile(content);
|
|
const result = runMsdTools(['frontmatter', 'validate', file, '--schema', 'plan-gap-closure']);
|
|
assert.ok(result.success, `Command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.valid, false, 'gap_closure: false must NOT satisfy plan-gap-closure');
|
|
assert.ok(parsed.missing.includes('gap_closure'), 'gap_closure must be reported missing when its value is false');
|
|
assert.ok(!parsed.present.includes('gap_closure'), 'gap_closure must not be reported present when its value is false');
|
|
// #2847 review: presence alone is not the whole story here — the field IS in the
|
|
// file, just wrong-valued. invalidValue distinguishes that from a genuinely absent
|
|
// field (Row 1) so a caller (or a human) gets an actionable "the value is wrong",
|
|
// not "this field is missing" for a field they can plainly see in the plan.
|
|
assert.ok(
|
|
parsed.invalidValue.includes('gap_closure'),
|
|
'gap_closure must be reported in invalidValue — present but wrong-valued, distinct from genuinely absent'
|
|
);
|
|
});
|
|
|
|
// Row 7 — invalidValue vs missing distinction, spelled out directly (not just
|
|
// implied by Rows 1/2/6 individually).
|
|
test('invalidValue distinguishes "present but wrong value" from "absent" for the same missing-reporting field', () => {
|
|
const absentResult = JSON.parse(
|
|
runMsdTools(['frontmatter', 'validate', writeTempFile(PLAN_BODY_NO_GAP_CLOSURE), '--schema', 'plan-gap-closure']).output
|
|
);
|
|
const wrongValueContent = PLAN_BODY_NO_GAP_CLOSURE.replace('---\nbody', 'gap_closure: TRUE\n---\nbody');
|
|
const wrongValueResult = JSON.parse(
|
|
runMsdTools(['frontmatter', 'validate', writeTempFile(wrongValueContent), '--schema', 'plan-gap-closure']).output
|
|
);
|
|
|
|
// Both report gap_closure as missing (the field does not satisfy the schema either way)...
|
|
assert.ok(absentResult.missing.includes('gap_closure'));
|
|
assert.ok(wrongValueResult.missing.includes('gap_closure'));
|
|
// ...but only the wrong-VALUE case appears in invalidValue.
|
|
assert.deepStrictEqual(absentResult.invalidValue, [], 'a genuinely absent field must not appear in invalidValue');
|
|
assert.ok(
|
|
wrongValueResult.invalidValue.includes('gap_closure'),
|
|
'gap_closure: TRUE (capitalized YAML boolean, rejected — the validator requires the exact literal lowercase true) must appear in invalidValue'
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── frontmatter set/merge: must_haves object-list preservation (#1572) ──────
|
|
// `frontmatter set`/`merge` round-tripped the WHOLE frontmatter through the lossy
|
|
// extractFrontmatter → reconstructFrontmatter pair, which flattens must_haves
|
|
// object-list items ({path, provides} maps) to scalar strings and re-emits them as a
|
|
// malformed inline array — destroying `provides:` whenever an UNRELATED field changed.
|
|
// The fix preserves the original raw text for any structurally-unchanged top-level key.
|
|
const { parseMustHavesBlock } = require('../msd-core/bin/lib/frontmatter.cjs');
|
|
|
|
describe('frontmatter set/merge preserves must_haves object-lists (#1572)', () => {
|
|
const ARTIFACTS_PLAN = [
|
|
'---',
|
|
'phase: 1',
|
|
'wave: 1',
|
|
'plan: 01-01',
|
|
'type: implementation',
|
|
'depends_on: []',
|
|
'files_modified: []',
|
|
'autonomous: true',
|
|
'must_haves:',
|
|
' artifacts:',
|
|
' - path: src/foo.ts',
|
|
' provides: the foo',
|
|
' - path: src/bar.ts',
|
|
' provides: the bar',
|
|
'---',
|
|
'# body',
|
|
'',
|
|
].join('\n');
|
|
|
|
const PROHIBITIONS_PLAN = [
|
|
'---',
|
|
'phase: 1',
|
|
'wave: 1',
|
|
'must_haves:',
|
|
' prohibitions:',
|
|
' - statement: no direct DB calls',
|
|
' status: enforced',
|
|
' - statement: no print statements',
|
|
' status: pending',
|
|
'---',
|
|
'# body',
|
|
'',
|
|
].join('\n');
|
|
|
|
function runAndParse(plan, cmdArgsForFile) {
|
|
const file = writeTempFile(plan);
|
|
runMsdTools(cmdArgsForFile(file));
|
|
const after = fs.readFileSync(file, 'utf-8');
|
|
return after;
|
|
}
|
|
|
|
test('set on an unrelated scalar preserves every must_haves.artifacts entry (path + provides)', () => {
|
|
const after = runAndParse(ARTIFACTS_PLAN, f => ['frontmatter', 'set', f, '--field', 'wave', '--value', '2']);
|
|
assert.deepEqual(
|
|
parseMustHavesBlock(after, 'artifacts'),
|
|
[
|
|
{ path: 'src/foo.ts', provides: 'the foo' },
|
|
{ path: 'src/bar.ts', provides: 'the bar' },
|
|
],
|
|
'must_haves.artifacts object-list must survive a set on an unrelated field (#1572)',
|
|
);
|
|
});
|
|
|
|
test('merge of an unrelated field preserves every must_haves.artifacts entry', () => {
|
|
const after = runAndParse(ARTIFACTS_PLAN, f => ['frontmatter', 'merge', f, '--data', JSON.stringify({ wave: 2 })]);
|
|
assert.deepEqual(
|
|
parseMustHavesBlock(after, 'artifacts'),
|
|
[
|
|
{ path: 'src/foo.ts', provides: 'the foo' },
|
|
{ path: 'src/bar.ts', provides: 'the bar' },
|
|
],
|
|
'must_haves.artifacts object-list must survive a merge of an unrelated field (#1572)',
|
|
);
|
|
});
|
|
|
|
test('must_haves.prohibitions object-list is preserved on an unrelated set (same code path)', () => {
|
|
const after = runAndParse(PROHIBITIONS_PLAN, f => ['frontmatter', 'set', f, '--field', 'wave', '--value', '2']);
|
|
assert.deepEqual(
|
|
parseMustHavesBlock(after, 'prohibitions'),
|
|
[
|
|
{ statement: 'no direct DB calls', status: 'enforced' },
|
|
{ statement: 'no print statements', status: 'pending' },
|
|
],
|
|
'must_haves.prohibitions object-list must survive a set on an unrelated field (#1572)',
|
|
);
|
|
});
|
|
|
|
test('round-trip is stable: setting wave twice still preserves artifacts (per-key preservation is idempotent)', () => {
|
|
const file = writeTempFile(ARTIFACTS_PLAN);
|
|
runMsdTools(['frontmatter', 'set', file, '--field', 'wave', '--value', '2']);
|
|
runMsdTools(['frontmatter', 'set', file, '--field', 'wave', '--value', '3']);
|
|
const after = fs.readFileSync(file, 'utf-8');
|
|
assert.deepEqual(
|
|
parseMustHavesBlock(after, 'artifacts'),
|
|
[
|
|
{ path: 'src/foo.ts', provides: 'the foo' },
|
|
{ path: 'src/bar.ts', provides: 'the bar' },
|
|
],
|
|
'must_haves.artifacts must survive repeated sets on an unrelated field',
|
|
);
|
|
});
|
|
|
|
test('directly setting must_haves to a new object-list fails closed instead of emitting [object Object] (#1572 codex review)', () => {
|
|
// A CHANGED key whose value is an object-list cannot be faithfully serialized by the
|
|
// lossy writer (it would emit "[object Object]"). Rather than silently destroy the
|
|
// data, spliceFrontmatter throws — the command fails and the file is left unchanged.
|
|
const file = writeTempFile(ARTIFACTS_PLAN);
|
|
const result = runMsdTools([
|
|
'frontmatter', 'set', file, '--field', 'must_haves',
|
|
'--value', JSON.stringify({ artifacts: [{ path: 'src/new.ts', provides: 'new thing' }] }),
|
|
]);
|
|
assert.ok(
|
|
!result.success,
|
|
'frontmatter set of a must_haves object-list must fail closed (refuse to emit "[object Object]")',
|
|
);
|
|
const after = fs.readFileSync(file, 'utf-8');
|
|
assert.ok(!/\[object Object\]/.test(after), 'the file must not contain "[object Object]" after a refused set');
|
|
assert.deepEqual(
|
|
parseMustHavesBlock(after, 'artifacts'),
|
|
[
|
|
{ path: 'src/foo.ts', provides: 'the foo' },
|
|
{ path: 'src/bar.ts', provides: 'the bar' },
|
|
],
|
|
'the original must_haves.artifacts must be intact after the refused set',
|
|
);
|
|
});
|
|
});
|
|
|
|
// Bug #1660 — frontmatter set of an object-list field (e.g. must_haves) is a silent no-op
|
|
// when the new value's lossy parse projection equals the original's. Folded into the owning
|
|
// frontmatter-cli test (no new top-level bug-NNNN file).
|
|
describe('Bug #1660: frontmatter set of an object-list field fails closed instead of a silent no-op', () => {
|
|
const PLAN_WITH_MUST_HAVES = [
|
|
'---', 'phase: 1', 'wave: 1',
|
|
'must_haves:', ' artifacts:', ' - path: src/foo.ts', ' provides: the foo',
|
|
'---', '# body', '',
|
|
].join('\n');
|
|
|
|
test('setting must_haves to a value that flattens to the original projection fails closed (no silent no-op)', () => {
|
|
const file = writeTempFile(PLAN_WITH_MUST_HAVES);
|
|
const before = fs.readFileSync(file, 'utf-8');
|
|
// New value {artifacts:["path: src/foo.ts"]} — its extractFrontmatter projection equals
|
|
// the original's flattened projection, so the set would otherwise be a silent no-op.
|
|
const result = runMsdTools(['frontmatter', 'set', file, '--field', 'must_haves', '--value', JSON.stringify({ artifacts: ['path: src/foo.ts'] })]);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(parsed.error, 'a no-op set of an object-list field must surface an error, not silent {updated:true}');
|
|
const after = fs.readFileSync(file, 'utf-8');
|
|
assert.equal(after, before, 'the file must be unchanged when the set is refused (no silent partial write)');
|
|
});
|
|
|
|
test('an idempotent set of a scalar (wave, same value) still reports updated (no false positive)', () => {
|
|
const file = writeTempFile('---\nphase: 1\nwave: 1\n---\n# body\n');
|
|
const result = runMsdTools(['frontmatter', 'set', file, '--field', 'wave', '--value', '1']);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.equal(parsed.updated, true, 'an idempotent SCALAR set must still report {updated:true} (not fail-closed)');
|
|
assert.ok(!parsed.error, 'an idempotent scalar set must not produce an error');
|
|
});
|
|
|
|
test('an idempotent set of a scalar array (tags, same value) still reports updated (no false positive)', () => {
|
|
const file = writeTempFile('---\nphase: 1\ntags: ["a","b"]\n---\n# body\n');
|
|
const result = runMsdTools(['frontmatter', 'set', file, '--field', 'tags', '--value', '["a","b"]']);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.equal(parsed.updated, true, 'an idempotent scalar-ARRAY set must still report {updated:true} (arrays round-trip; not fail-closed)');
|
|
assert.ok(!parsed.error, 'an idempotent scalar-array set must not produce an error');
|
|
});
|
|
});
|
|
|
|
// ─── #1778: thread workflow must use the 1.6 named-flag frontmatter.set form ─
|
|
//
|
|
// The thread workflow's CLOSE and RESUME branches previously invoked the
|
|
// pre-1.6 positional shape (frontmatter.set <file> <field> <value>). Since 1.6
|
|
// the dispatcher (msd-tools.cjs) reads field/value from the named --field/
|
|
// --value flags via parseNamedArgs; the positional form leaves field/value
|
|
// undefined, cmdFrontmatterSet errors `file, field, and value required`, and
|
|
// the status/updated writes are silently skipped — so closing a thread never
|
|
// marked it status: resolved and resuming never marked it status: in_progress.
|
|
describe('#1778: thread workflow uses the 1.6 named-flag frontmatter.set form', () => {
|
|
test('behavioral: named-flag form writes the field; positional form errors and does not mutate', () => {
|
|
// 1.6 named-flag form — must succeed and write status: resolved.
|
|
const goodFile = writeTempFile('---\nstatus: open\nupdated: "2025-01-01"\n---\n\n# thread body\n');
|
|
const good = runMsdTools(['frontmatter', 'set', goodFile, '--field', 'status', '--value', 'resolved']);
|
|
assert.ok(good.success, `named-flag form must succeed; stderr: ${good.error}`);
|
|
assert.strictEqual(
|
|
parseFrontmatter(fs.readFileSync(goodFile, 'utf-8')).status,
|
|
'resolved',
|
|
'named-flag form must write status: resolved into the file',
|
|
);
|
|
|
|
// Pre-1.6 positional form — must fail and NOT mutate.
|
|
//
|
|
// #3884 (ADR-3473 §8.4): the strict parser now rejects the stray
|
|
// positional tokens ("status", "resolved") BEFORE cmdFrontmatterSet's own
|
|
// "file, field, and value required" guard ever runs, so the error text
|
|
// changed. The behavioral contract this test guards — fails, and does
|
|
// NOT mutate the file — is unchanged and, if anything, strengthened (the
|
|
// rejection now happens earlier, at argv-parsing time, not deep inside
|
|
// the command).
|
|
const badFile = writeTempFile('---\nstatus: open\nupdated: "2025-01-01"\n---\n\n# thread body\n');
|
|
const bad = runMsdTools(['frontmatter', 'set', badFile, 'status', 'resolved']);
|
|
assert.ok(!bad.success, 'positional form must fail (it is the bug being guarded against)');
|
|
assert.ok(
|
|
(bad.error + bad.output).includes('unexpected positional argument'),
|
|
`positional form must error with the documented message; got:\n${bad.error}${bad.output}`,
|
|
);
|
|
assert.strictEqual(
|
|
parseFrontmatter(fs.readFileSync(badFile, 'utf-8')).status,
|
|
'open',
|
|
'positional form must NOT mutate the file (the silent-failure bug)',
|
|
);
|
|
});
|
|
|
|
test('workflow parity: no msd-core/workflows/*.md emits the positional frontmatter.set form', () => {
|
|
const workflowsDir = path.join(__dirname, '..', 'msd-core', 'workflows');
|
|
const files = fs.readdirSync(workflowsDir).filter((f) => f.endsWith('.md'));
|
|
assert.ok(files.length > 0, 'expected at least one workflow under msd-core/workflows/');
|
|
|
|
const offenders = [];
|
|
for (const name of files) {
|
|
const full = path.join(workflowsDir, name);
|
|
const lines = fs.readFileSync(full, 'utf-8').split(/\r?\n/);
|
|
lines.forEach((line, i) => {
|
|
// Match any frontmatter.set invocation (dot or space form, with or
|
|
// without the `msd_run query` prefix). The 1.6 contract requires
|
|
// --field AND --value on every set call; a set line missing --field
|
|
// is the pre-1.6 positional form (#1778).
|
|
if (!/frontmatter[.\s]+set\b/.test(line)) return;
|
|
if (!/--field\b/.test(line) || !/--value\b/.test(line)) {
|
|
offenders.push(`${name}:${i + 1}: ${line.trim()}`);
|
|
}
|
|
});
|
|
}
|
|
|
|
assert.deepStrictEqual(
|
|
offenders,
|
|
[],
|
|
`These workflow frontmatter.set invocations are missing the 1.6 --field/--value named flags (the #1778 positional-form bug):\n ${offenders.join('\n ')}\n\nUse: msd_run query frontmatter.set <file> --field <field> --value <value>`,
|
|
);
|
|
});
|
|
|
|
test('thread workflow CLOSE writes status: resolved and RESUME writes status: in_progress via named flags', () => {
|
|
const src = fs.readFileSync(path.join(__dirname, '..', 'msd-core', 'workflows', 'thread.md'), 'utf-8');
|
|
|
|
// CLOSE mode: status resolved + updated, both via named flags.
|
|
assert.ok(
|
|
/frontmatter\.set\s+\S*\.planning\/threads\/\{SLUG\}\.md\s+--field\s+status\s+--value\s+resolved\b/.test(src),
|
|
'CLOSE mode must invoke: frontmatter.set .planning/threads/{SLUG}.md --field status --value resolved',
|
|
);
|
|
assert.ok(
|
|
/frontmatter\.set\s+\S*\.planning\/threads\/\{SLUG\}\.md\s+--field\s+updated\s+--value\s+YYYY-MM-DD\b/.test(src),
|
|
'CLOSE mode must invoke: frontmatter.set .planning/threads/{SLUG}.md --field updated --value YYYY-MM-DD',
|
|
);
|
|
|
|
// RESUME mode: status in_progress + updated, both via named flags.
|
|
assert.ok(
|
|
/frontmatter\.set\s+\S*\.planning\/threads\/\{SLUG\}\.md\s+--field\s+status\s+--value\s+in_progress\b/.test(src),
|
|
'RESUME mode must invoke: frontmatter.set .planning/threads/{SLUG}.md --field status --value in_progress',
|
|
);
|
|
});
|
|
});
|
|
|
|
// ─── #1882: the user-reachable surface actually distinguishes the two cases ───
|
|
|
|
describe('frontmatter get — truncated vs absent frontmatter (#1882)', () => {
|
|
const TOOLS = path.join(__dirname, '..', 'msd-core', 'bin', 'msd-tools.cjs');
|
|
|
|
function runCapturingStderr(file) {
|
|
const r = runNode([TOOLS, 'frontmatter', 'get', file, '--raw'], {
|
|
env: { ...process.env, MSD_TEST_MODE: '1' },
|
|
timeoutMs: PROBE_TIMEOUT_MS,
|
|
});
|
|
const legacy = toLegacyResult(r);
|
|
return { status: legacy.status, stdout: legacy.stdout.trim(), stderr: legacy.stderr.trim() };
|
|
}
|
|
|
|
// This is the wired keystone for #1882: the diagnostic is only "delivered" if it reaches
|
|
// the surface a user actually invokes. The assertion is a DIFFERENTIAL between two runs —
|
|
// whether stderr is empty — which is a behavioural claim, not a match against the message
|
|
// wording, so it stays inside CONTRIBUTING.md's ban on raw text matching.
|
|
test('a truncated file is reported while an absent-frontmatter file stays silent', () => {
|
|
const truncated = writeTempFile('---\nphase: 01\nplan: half-written\n');
|
|
const absent = writeTempFile('plain body with no frontmatter\n');
|
|
|
|
const bad = runCapturingStderr(truncated);
|
|
const good = runCapturingStderr(absent);
|
|
|
|
// The contract every one of the ~50 callers depends on is unchanged for both.
|
|
assert.strictEqual(bad.status, 0, 'truncated file must not change the exit code');
|
|
assert.strictEqual(good.status, 0);
|
|
assert.deepStrictEqual(JSON.parse(bad.stdout), {}, 'return value must be preserved');
|
|
assert.deepStrictEqual(JSON.parse(good.stdout), {});
|
|
|
|
// ...and the only difference is that corruption is no longer silent.
|
|
assert.notStrictEqual(bad.stderr, '', 'a truncated frontmatter must be reported');
|
|
assert.strictEqual(good.stderr, '', 'a file with no frontmatter is not corrupt');
|
|
});
|
|
|
|
test('a Markdown thematic break at byte 0 is not reported as corruption', () => {
|
|
const thematicBreak = writeTempFile('---\nSome heading text\n\nA paragraph, no more dashes.\n');
|
|
const r = runCapturingStderr(thematicBreak);
|
|
assert.strictEqual(r.status, 0);
|
|
assert.deepStrictEqual(JSON.parse(r.stdout), {});
|
|
assert.strictEqual(r.stderr, '', 'a horizontal rule is valid Markdown, not a truncated file');
|
|
});
|
|
});
|
|
|
|
// ─── #4806: unparseable frontmatter is a distinct error, not "Field not found" ──
|
|
|
|
describe('#4806 frontmatter get — unparseable frontmatter', () => {
|
|
test('reports a parse error naming the field, not "Field not found"', () => {
|
|
// An invalid backslash escape inside a double-quoted value is a YAML
|
|
// SYNTAX error: the file HAS a status key but its frontmatter cannot be
|
|
// read. Reporting "Field not found" tells the caller the key is absent —
|
|
// indistinguishable from a file that genuinely lacks it.
|
|
const file = writeTempFile('---\nstatus: "passed\n---\n\n# Verification Report\n');
|
|
const result = runMsdTools(['frontmatter', 'get', file, '--field', 'status']);
|
|
// The verb answers exit-0 JSON with an `error` FIELD (its documented
|
|
// error shape) — the assertion is on the error text, not the exit code.
|
|
assert.strictEqual(result.success, true, `command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.ok(
|
|
(parsed.error || '').includes('not parseable YAML'),
|
|
`must report a parse error, got: ${JSON.stringify(parsed)}`,
|
|
);
|
|
assert.ok(!parsed.error.includes('Field not found'), 'parse failure must not read as Field not found');
|
|
});
|
|
|
|
test('a well-formed file still returns the field', () => {
|
|
const file = writeTempFile('---\nstatus: passed\n---\n\n# V\n');
|
|
const result = runMsdTools(['frontmatter', 'get', file, '--field', 'status']);
|
|
assert.ok(result.success, `command failed: ${result.error}`);
|
|
const parsed = JSON.parse(result.output);
|
|
assert.strictEqual(parsed.status, 'passed');
|
|
});
|
|
});
|