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.
246 lines
11 KiB
JavaScript
246 lines
11 KiB
JavaScript
'use strict';
|
|
process.env.MSD_TEST_MODE = '1';
|
|
|
|
const { test, describe } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
|
|
const { serializeChangelog, parseChangelog } = require(path.join(__dirname, '..', 'scripts', 'changeset', 'serialize.cjs'));
|
|
|
|
// Round-trip property: serialize(IR) → parse(text) → IR equals original.
|
|
// Tests assert on the parsed IR shape, not the serialized text contents.
|
|
|
|
describe('changeset serialize: IR → markdown round-trip (#2975)', () => {
|
|
test('a single-section IR round-trips through serialize → parse', () => {
|
|
const ir = {
|
|
releaseHeader: { version: '1.0.0', date: '2026-01-01' },
|
|
sections: [
|
|
{ type: 'Fixed', bullets: [{ pr: 1, body: 'fix something.' }] },
|
|
],
|
|
priorChangelog: null,
|
|
};
|
|
const text = serializeChangelog(ir);
|
|
const back = parseChangelog(text);
|
|
|
|
assert.equal(back.releases[0].version, '1.0.0');
|
|
assert.equal(back.releases[0].date, '2026-01-01');
|
|
assert.equal(back.releases[0].sections.length, 1);
|
|
assert.equal(back.releases[0].sections[0].type, 'Fixed');
|
|
assert.equal(back.releases[0].sections[0].bullets.length, 1);
|
|
assert.equal(back.releases[0].sections[0].bullets[0].pr, 1);
|
|
});
|
|
});
|
|
|
|
describe('changeset serialize: multi-line bullet parsing (#3496)', () => {
|
|
// Regression: parseChangelog silently dropped bullets whose text wrapped
|
|
// across multiple indented continuation lines. The PR number (#NNNN) appears
|
|
// on the final continuation line, not the opening `-` line, so the
|
|
// single-line bullet regex never matched. Every such bullet returned 0
|
|
// entries for its section even though the markdown was well-formed.
|
|
test('parses a multi-line bullet whose (# pr) trailer is on a continuation line', () => {
|
|
const text = [
|
|
'## [1.41.0] - 2026-05-07',
|
|
'',
|
|
'### Feature',
|
|
'',
|
|
'- **Short title** — first line of a long description',
|
|
' that wraps onto a second line and terminates with. (#2792)',
|
|
'- Single-line bullet with pr. (#2800)',
|
|
].join('\n');
|
|
const result = parseChangelog(text);
|
|
assert.equal(result.releases.length, 1);
|
|
const section = result.releases[0].sections[0];
|
|
assert.equal(section.type, 'Feature');
|
|
assert.equal(section.bullets.length, 2, 'both bullets (multi-line and single-line) must be captured');
|
|
assert.equal(section.bullets[0].pr, 2792, 'multi-line bullet pr');
|
|
assert.equal(section.bullets[1].pr, 2800, 'single-line bullet pr');
|
|
});
|
|
|
|
test('parses a bullet with (# pr) on the opening line even when followed by multi-line bullets', () => {
|
|
const text = [
|
|
'## [1.42.1] - 2026-05-15',
|
|
'',
|
|
'### Fixed',
|
|
'',
|
|
'- Simple fix. (#3261)',
|
|
'- **Complex fix** — first line of',
|
|
' a multi-line description. (#3287)',
|
|
].join('\n');
|
|
const result = parseChangelog(text);
|
|
const section = result.releases[0].sections[0];
|
|
assert.equal(section.bullets.length, 2);
|
|
assert.equal(section.bullets[0].pr, 3261);
|
|
assert.equal(section.bullets[1].pr, 3287);
|
|
});
|
|
|
|
test('a multi-line bullet with linked release header is parsed correctly', () => {
|
|
const text = [
|
|
'## [1.42.1](https://github.com/open-gsd/gsd-core/compare/v1.41.0...v1.42.1) - 2026-05-15',
|
|
'',
|
|
'### Fixed',
|
|
'',
|
|
'- **Multi-line with linked header** — description spans',
|
|
' multiple lines and version header has an inline URL. (#3287)',
|
|
].join('\n');
|
|
const result = parseChangelog(text);
|
|
assert.equal(result.releases[0].version, '1.42.1');
|
|
assert.equal(result.releases[0].sections[0].bullets.length, 1);
|
|
assert.equal(result.releases[0].sections[0].bullets[0].pr, 3287);
|
|
});
|
|
|
|
test('preserves bullets without (# pr) trailer as { body, pr: null } instead of dropping them', () => {
|
|
// Regression guard for Codex finding: bullets that lack a trailing
|
|
// (# NNNN) were silently discarded. They must be stored with pr: null
|
|
// so callers (e.g. cmdExtract) can render them without silent loss.
|
|
const text = [
|
|
'## [1.43.0] - 2026-05-20',
|
|
'',
|
|
'### Fixed',
|
|
'',
|
|
'- Fix with a PR reference. (#4000)',
|
|
'- Documented fix without a PR reference.',
|
|
'- **Multi-line fix without trailer** — first line of description',
|
|
' that continues on a second line but has no (# NNN) at the end.',
|
|
].join('\n');
|
|
const result = parseChangelog(text);
|
|
const section = result.releases[0].sections[0];
|
|
assert.equal(section.bullets.length, 3, 'all three bullets must be captured');
|
|
assert.equal(section.bullets[0].pr, 4000, 'PR bullet preserved');
|
|
assert.equal(section.bullets[1].pr, null, 'no-PR bullet has pr: null');
|
|
assert.ok(section.bullets[1].body.includes('Documented fix'), 'no-PR bullet body preserved');
|
|
assert.equal(section.bullets[2].pr, null, 'multi-line no-PR bullet has pr: null');
|
|
assert.ok(section.bullets[2].body.includes('Multi-line fix without trailer'), 'multi-line no-PR body preserved');
|
|
});
|
|
});
|
|
|
|
describe('changeset serialize: multi-section + prior content (#2975)', () => {
|
|
const { serializeChangelog, parseChangelog } = require(require('node:path').join(__dirname, '..', 'scripts', 'changeset', 'serialize.cjs'));
|
|
|
|
test('round-trips an IR with three section types and multiple bullets per section', () => {
|
|
const ir = {
|
|
releaseHeader: { version: '1.42.0', date: '2026-05-01' },
|
|
sections: [
|
|
{ type: 'Added', bullets: [{ pr: 1, body: 'add A' }, { pr: 2, body: 'add B' }] },
|
|
{ type: 'Changed', bullets: [{ pr: 3, body: 'change C' }] },
|
|
{ type: 'Fixed', bullets: [{ pr: 4, body: 'fix D' }, { pr: 5, body: 'fix E' }] },
|
|
],
|
|
priorChangelog: null,
|
|
};
|
|
const back = parseChangelog(serializeChangelog(ir));
|
|
assert.equal(back.releases.length, 1);
|
|
assert.deepEqual(
|
|
back.releases[0].sections.map((s) => ({ type: s.type, prs: s.bullets.map((b) => b.pr) })),
|
|
[
|
|
{ type: 'Added', prs: [1, 2] },
|
|
{ type: 'Changed', prs: [3] },
|
|
{ type: 'Fixed', prs: [4, 5] },
|
|
],
|
|
);
|
|
});
|
|
|
|
test('prior CHANGELOG content survives serialize → parse as a separate release block', () => {
|
|
const priorText = '## [0.9.0] - 2025-12-01\n\n### Fixed\n\n- old fix (#100)\n';
|
|
const ir = {
|
|
releaseHeader: { version: '1.0.0', date: '2026-01-01' },
|
|
sections: [{ type: 'Added', bullets: [{ pr: 200, body: 'new feature' }] }],
|
|
priorChangelog: priorText,
|
|
};
|
|
const back = parseChangelog(serializeChangelog(ir));
|
|
assert.equal(back.releases.length, 2);
|
|
assert.equal(back.releases[0].version, '1.0.0');
|
|
assert.equal(back.releases[1].version, '0.9.0');
|
|
assert.equal(back.releases[1].sections[0].bullets[0].pr, 100);
|
|
});
|
|
});
|
|
|
|
// ─── #3001: multi-paragraph body round-trip ────────────────────────────────
|
|
|
|
describe('#3001: multi-paragraph changeset body round-trips without truncation', () => {
|
|
test('a body containing \\n\\n retains content from both paragraphs AND its PR number', () => {
|
|
const ir = {
|
|
releaseHeader: { version: '1.42.0', date: '2026-08-05' },
|
|
sections: [{
|
|
type: 'Fixed',
|
|
bullets: [{
|
|
pr: 2595,
|
|
body: 'First paragraph, load-bearing.\n\nSecond paragraph, also load-bearing.',
|
|
}],
|
|
}],
|
|
priorChangelog: null,
|
|
};
|
|
const text = serializeChangelog(ir);
|
|
const back = parseChangelog(text);
|
|
const bullet = back.releases[0].sections[0].bullets[0];
|
|
// PR trailer must survive (was lost pre-fix because the trailer was on the dropped side).
|
|
assert.equal(bullet.pr, 2595,
|
|
`PR number must survive round-trip; got: ${bullet.pr}`);
|
|
// Content from BOTH paragraphs must be present (was truncated pre-fix).
|
|
assert.ok(bullet.body.includes('First paragraph'),
|
|
`first paragraph must survive; got: ${JSON.stringify(bullet.body)}`);
|
|
assert.ok(bullet.body.includes('Second paragraph'),
|
|
`second paragraph must survive; got: ${JSON.stringify(bullet.body)}`);
|
|
});
|
|
});
|
|
|
|
describe('changeset serialize: shipped CHANGELOG citation integrity (#2359)', () => {
|
|
// Regression: the `## [1.4.0]` Cursor commands-surface entry carried the
|
|
// trailing reference (#803) — the *Cline* PR, cited correctly by the entry two
|
|
// lines below it. The Cursor surface actually shipped in #805. Two adjacent
|
|
// bullets therefore claimed one PR, and only the second was right.
|
|
//
|
|
// This is not cosmetic: the trailing (#NNNN) is machine-parsed here and
|
|
// consumed by `cmdExtract`, so a wrong number propagates into extracted
|
|
// release-note ranges. It had already propagated to a human reporter (#2341,
|
|
// quoted there as "#785 / #803").
|
|
//
|
|
// The obvious bad fix is a global s/(#803)/(#805)/, which repairs the Cursor
|
|
// entry and silently corrupts the Cline one. The Cline assertion below is the
|
|
// guard for exactly that, and is expected to pass both before and after.
|
|
const CHANGELOG = fs.readFileSync(path.join(__dirname, '..', 'CHANGELOG.md'), 'utf8');
|
|
const CURSOR_MARKER = /`\.cursor\/commands\/gsd-<name>\.md`/; // CHANGELOG.md is unswept history
|
|
const CLINE_MARKER = /Elevate the Cline runtime to hook parity/;
|
|
|
|
function bulletsOf(version) {
|
|
const release = parseChangelog(CHANGELOG).releases.find((r) => r.version === version);
|
|
assert.ok(release, `CHANGELOG.md must still carry a \`## [${version}]\` release section`);
|
|
return release.sections.flatMap((s) => s.bullets);
|
|
}
|
|
|
|
// Asserts cardinality before returning, so a reworded or deleted entry fails
|
|
// with a readable message instead of a TypeError on an undefined bullet.
|
|
function locateBullet(version, marker, label) {
|
|
const matches = bulletsOf(version).filter((b) => marker.test(b.body));
|
|
assert.equal(matches.length, 1,
|
|
`expected exactly one ${label} bullet in the ${version} section, found ${matches.length}`);
|
|
return matches[0];
|
|
}
|
|
|
|
test('the 1.4.0 Cursor commands-surface bullet cites PR 805', () => {
|
|
const cursor = locateBullet('1.4.0', CURSOR_MARKER, 'Cursor commands-surface');
|
|
assert.equal(cursor.pr, 805,
|
|
'the .cursor/commands/ surface shipped in PR #805 (feat(#785)), not #803 (the Cline PR)');
|
|
});
|
|
|
|
test('the adjacent 1.4.0 Cline bullet still cites PR 803', () => {
|
|
const cline = locateBullet('1.4.0', CLINE_MARKER, 'Cline hook-parity');
|
|
assert.equal(cline.pr, 803,
|
|
"the Cline entry's #803 is correct and must survive the Cursor correction");
|
|
});
|
|
|
|
test('both 1.4.0 entries survive the correction exactly once each', () => {
|
|
const bullets = bulletsOf('1.4.0');
|
|
assert.equal(bullets.filter((b) => CURSOR_MARKER.test(b.body)).length, 1,
|
|
'the Cursor entry must be corrected in place — neither dropped nor duplicated');
|
|
assert.equal(bullets.filter((b) => CLINE_MARKER.test(b.body)).length, 1,
|
|
'the Cline entry must be left alone — neither dropped nor duplicated');
|
|
});
|
|
|
|
test('the adjacent Cursor and Cline bullets do not cite the same PR', () => {
|
|
const cursor = locateBullet('1.4.0', CURSOR_MARKER, 'Cursor commands-surface');
|
|
const cline = locateBullet('1.4.0', CLINE_MARKER, 'Cline hook-parity');
|
|
assert.notEqual(cursor.pr, cline.pr,
|
|
'two adjacent entries describing different runtimes cannot share one PR');
|
|
});
|
|
});
|