golem15/msd-core
3
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

fix(3496): include all version patterns in changelog extraction (#90)

Browse Source 
* fix(3496): include all version patterns in changelog extraction

parseChangelog now handles multi-line bullets (continuation lines
starting with two or more spaces) where the (#NNNN) PR trailer
appears on a continuation line, not the opening dash line. The
previous single-line regex silently dropped every such bullet,
causing Feature/Enhancement sections to return 0 entries.

Also adds an `extract` subcommand to scripts/changeset/cli.cjs:
  changeset/cli.cjs extract --from VERSION --to VERSION [--changelog FILE] [--json]
Extracts releases strictly after --from (exclusive) and up to and
including --to (inclusive). Accepts v-prefixed versions. Exits 2
when no releases fall in range, giving /gsd:update a deterministic
range-aware helper instead of vague/manual extraction.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* test(3496): use production parseChangelog in markdown-mode assertion

Replace raw stdout.includes() in the emits-markdown test with a
parseChangelog call on the output so the assertion targets version
strings via the production parser rather than a raw substring match.
Eliminates the output-grep anti-pattern flagged by test-rigor.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* chore(changeset): add fragment for fix #3796 (issue #3496)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(3496): reject malformed --from/--to semver in extract with structured error

`parseSemver` coerced non-numeric components to 0 (e.g. `1.41.x` → `1.41.0`),
making range selection silently wrong under typos or version-shape drift.

Add a strict N.N.N validation gate before comparison; exit 1 with a JSON
error report when either bound fails.  Add two regression tests covering
alphabetic and dotted-letter inputs.

Codex adversarial review finding: high severity (scripts/changeset/cli.cjs:226-244)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(3496): preserve bullets without PR trailer in parseChangelog (pr: null)

Previously flushBullet() silently discarded any bullet that lacked a
trailing (# NNNN) token.  On the real CHANGELOG.md this dropped 7 entries
from v1.41.0 alone, so cmdExtract returned incomplete release notes to the
/gsd:update confirmation step.

Store PR-less bullets as { body, pr: null } instead.  Update cmdExtract's
textOutput renderer to emit `- body` (no trailer) for null-pr bullets.

Add regression tests:
  - serialize: preserves bullets without trailer as pr:null (not dropped)
  - cli extract: preserves PR-less and PR bullets together in extracted JSON
  - cli extract: rejects malformed --from/--to (1.41.x, foo) with exit 1

Codex adversarial review finding: high severity (scripts/changeset/serialize.cjs:64-73)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(3496): wire extract into update.md + reject pre-release in range, fix CHANGELOG parser edge cases

BLOCKER fixes:
- F1: workflows/update.md show_changes_and_confirm step now invokes
  `scripts/changeset/cli.cjs extract --from $INSTALLED_VERSION --to
  $LATEST_VERSION --changelog $CHANGELOG_TMP --json` with explicit exit-2
  handling ("no releases in range") and fallback text.  The prior prose
  ("extract entries between versions") was never wired to the binary and
  silently skipped intermediate versions (#3496).
- F2: releases.filter in cmdExtract now rejects any rel.version that does
  not pass SEMVER_RE before numeric-tuple comparison.  parseSemver('1.0.0-rc.1')
  previously returned [1,0,0] (same as '1.0.0'), causing pre-release entries to
  corrupt range queries.  Architectural choice: skip pre-release + 4-part
  versions with a stderr warning; full semver §11 pre-release ordering deferred
  to a consolidation issue (see F8 note below).

MAJOR fixes:
- F3 (serialize.cjs): releaseMatch regex updated to
  /^##\s+\[([^\]]+)\](?:\([^)]*\))?\s*(?:-\s*(\S+))?/ so linked-header
  format `## [1.42.1](url) - 2026-05-15` captures the date correctly.
- F4 (serialize.cjs): continuation-line test now checks `!/^\s+-\s/`
  so `  - nested item` terminates the current bullet instead of folding in.
- F5 (cli.cjs): 4-part versions (e.g. 1.0.0.1) fail SEMVER_RE and are
  skipped by the same guard added for F2.  No separate code path needed.
- F6 (serialize.cjs): v-prefix stripped from in-file version capture;
  `## [v1.0.0]` now parses as version "1.0.0".
- F7 (serialize.cjs): continuation-line indentation relaxed from /^[ \t]{2}/
  to /^\s+/ so 1-space-indented continuations fold correctly (F4's
  bullet-terminator guard prevents nested bullets from being folded).

MINOR fixes:
- F9 (cli.cjs): unknown-command path now exits 1 instead of 2 (exit 2
  is reserved for "no releases in range" semantic).
- F10 (cli.cjs): text-mode exit-2 path now writes
  "no releases found in range (from=X, to=Y)" to stderr.
- F11 (tests): exit-2 test now asserts r.json is present and
  r.json.releases.length === 0.

NOTE — F8 (semver consolidation): this codebase has 5+ distinct semver
comparators with divergent pre-release policies; this PR adds a 6th (the
SEMVER_RE guard in cmdExtract).  A follow-up consolidation issue should be
filed to unify all call sites.  Out of scope for this PR.

Regression tests added for F1–F6: pre-release exclusion, linked-header
date parsing, nested-bullet termination, 4-part/v-prefix edge cases, and
workflow wiring.  All 15 tests pass.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(lint): add allow-test-rule annotation to F1 workflow wiring test

The F1 test reads get-shit-done/workflows/update.md (a product markdown
file, not CJS source) to assert the extract subcommand invocation was
wired.  The lint-no-source-grep detector flags any readFileSync-bound
variable used with .includes() regardless of file extension; annotate
with // allow-test-rule to exempt this legitimate product-content
assertion.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* test: apply deterministic barrier to locking-bugs #1927 config-set test

The 'both concurrent config-set calls persist their values' test used
Promise.all([execAsync(A), execAsync(B)]) without a barrier, which is
non-deterministic under Docker load: one subprocess can complete before
the other starts (no real contention) or both can race O_EXCL and observe
stale fs state (lost write / assertion failure).

Mirrors the locking-bugs:180 and :235 redesigns: erect a barrier file,
spawn both subprocesses, wait for both to signal readiness via ready files,
then drop the barrier simultaneously so both config-set calls genuinely
contend on withPlanningLock.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Tom Boucher
2026-05-22 11:51:37 -04:00
committed by GitHub
parent 6f123778d2
commit ea67479bfb
7 changed files with 712 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.changeset/noble-tigers-parade.md Normal file
View File

@@ -0,0 +1,5 @@
---
type: Fixed
pr: 3796
---
**`parseChangelog` now captures multi-line bullets** — bullets where the `(#NNNN)` PR trailer appears on a continuation line are no longer silently dropped. Adds `changeset/cli.cjs extract --from VERSION --to VERSION` for deterministic range-aware changelog extraction in `/gsd:update`.

48
get-shit-done/workflows/update.md
View File

@@ -372,28 +372,48 @@ Exit.
<step name="show_changes_and_confirm">
**If update available**, fetch and show what's new BEFORE updating:
1. Fetch changelog from GitHub raw URL
2. Extract entries between installed and latest versions
3. Display preview and ask for confirmation:
1. Fetch changelog from GitHub raw URL and save to a temp file, e.g. `/tmp/gsd-changelog-$$.md`.
2. Extract entries between installed and latest versions using the deterministic range helper (fix for #3496 — do NOT use ad-hoc grep/awk extraction which silently skips intermediate versions):
```bash
CHANGELOG_TMP="/tmp/gsd-changelog-$$.md"
curl -fsSL "https://raw.githubusercontent.com/gsd-build/get-shit-done/main/CHANGELOG.md" -o "$CHANGELOG_TMP" 2>/dev/null \
|| wget -qO "$CHANGELOG_TMP" "https://raw.githubusercontent.com/gsd-build/get-shit-done/main/CHANGELOG.md" 2>/dev/null
EXTRACT_JSON=$(node "$GSD_DIR/get-shit-done/scripts/changeset/cli.cjs" extract \
--from "$INSTALLED_VERSION" \
--to "$LATEST_VERSION" \
--changelog "$CHANGELOG_TMP" \
--json 2>/dev/null)
EXTRACT_EXIT=$?
rm -f "$CHANGELOG_TMP"
if [ "$EXTRACT_EXIT" -eq 2 ]; then
# Exit 2 = no releases in range (e.g. versions are equal or changelog is sparse)
CHANGELOG_PREVIEW="No changelog updates between v${INSTALLED_VERSION} and v${LATEST_VERSION}."
elif [ "$EXTRACT_EXIT" -ne 0 ] || [ -z "$EXTRACT_JSON" ]; then
CHANGELOG_PREVIEW="(Could not extract changelog — update will still proceed)"
else
# Re-run without --json to get the human-readable markdown for display
CHANGELOG_PREVIEW=$(node "$GSD_DIR/get-shit-done/scripts/changeset/cli.cjs" extract \
--from "$INSTALLED_VERSION" \
--to "$LATEST_VERSION" \
--changelog "$CHANGELOG_TMP" 2>/dev/null || echo "(changelog unavailable)")
fi
```
3. Display preview and ask for confirmation, using `$CHANGELOG_PREVIEW` from the extract step above:
```
## GSD Update Available
**Installed:** 1.5.10
**Latest:** 1.5.15
**Installed:** {INSTALLED_VERSION}
**Latest:** {LATEST_VERSION}
### What's New
────────────────────────────────────────────────────────────
## [1.5.15] - 2026-01-20
### Added
- Feature X
## [1.5.14] - 2026-01-18
### Fixed
- Bug fix Y
{CHANGELOG_PREVIEW}
────────────────────────────────────────────────────────────

147
scripts/changeset/cli.cjs
View File

@@ -19,7 +19,7 @@ const path = require('node:path');
const { parseFragment, FRAGMENT_ERROR } = require('./parse.cjs');
const { renderChangelog } = require('./render.cjs');
const { serializeChangelog } = require('./serialize.cjs');
const { serializeChangelog, parseChangelog } = require('./serialize.cjs');
const { renderGithubReleaseNotes } = require('./github-release-notes.cjs');
function parseArgs(argv) {
@@ -30,6 +30,7 @@ function parseArgs(argv) {
date: null,
fromRef: null,
toRef: null,
changelog: null,
output: null,
repoSlug: 'GSD-redux/get-shit-done-redux',
installCommand: 'npx get-shit-done-redux@latest',
@@ -59,6 +60,7 @@ function parseArgs(argv) {
a === '--date' ||
a === '--from' ||
a === '--to' ||
a === '--changelog' ||
a === '--output' ||
a === '--repo-slug' ||
a === '--install-command'
@@ -70,6 +72,7 @@ function parseArgs(argv) {
else if (a === '--date') opts.date = r.value;
else if (a === '--from') opts.fromRef = r.value;
else if (a === '--to') opts.toRef = r.value;
else if (a === '--changelog') opts.changelog = r.value;
else if (a === '--output') opts.output = r.value;
else if (a === '--repo-slug') opts.repoSlug = r.value;
else if (a === '--install-command') opts.installCommand = r.value;
@@ -180,6 +183,121 @@ function cmdRender(opts) {
};
}
/**
* extract subcommand: extracts all changelog release blocks strictly after
* `--from` (exclusive) up to and including `--to` (inclusive). Both
* arguments accept `v`-prefixed semver (e.g. `v1.5.13`).
*
* Exit codes:
* 0 — one or more releases matched, output written.
* 2 — no releases fall in the specified range (matches nothing).
* 1 — I/O error or missing required flags.
*
* Fix for #3496: provides a deterministic range-aware helper so the
* `/gsd:update` show_changes_and_confirm step no longer relies on
* vague/manual extraction that can silently skip intermediate versions.
*/
function cmdExtract(opts) {
const stripV = (v) => (typeof v === 'string' ? v.replace(/^v/, '') : v);
const from = stripV(opts.fromRef);
const to = stripV(opts.toRef);
// Validate that both bounds are strict semver (N.N.N, digits only).
// Coercing a malformed bound like "1.41.x" to "1.41.0" makes range
// selection silently wrong; reject early with a structured error.
const SEMVER_RE = /^\d+\.\d+\.\d+$/;
if (!SEMVER_RE.test(from)) {
return {
exitCode: 1,
report: { error: `invalid semver for --from: "${from}" (expected N.N.N)`, releases: [] },
textOutput: null,
};
}
if (!SEMVER_RE.test(to)) {
return {
exitCode: 1,
report: { error: `invalid semver for --to: "${to}" (expected N.N.N)`, releases: [] },
textOutput: null,
};
}
const changelogPath = opts.changelog
? path.resolve(opts.changelog)
: path.join(path.resolve(opts.repo), 'CHANGELOG.md');
if (!fs.existsSync(changelogPath)) {
return {
exitCode: 1,
report: { error: `CHANGELOG not found: ${changelogPath}`, releases: [] },
textOutput: null,
};
}
const text = fs.readFileSync(changelogPath, 'utf8');
const { releases } = parseChangelog(text);
// Walk the releases in document order (newest-first in a standard
// Keep-a-Changelog file). Collect every release whose version is
// strictly after `from` and up to and including `to`.
//
// The comparison is semver-aware via the standard numeric-tuple approach
// so that "1.5.9" < "1.5.10" (string comparison would fail here).
function parseSemver(v) {
const parts = String(v).split('.').map(Number);
return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
}
function semverCmp(a, b) {
const [a0, a1, a2] = parseSemver(a);
const [b0, b1, b2] = parseSemver(b);
return a0 !== b0 ? a0 - b0 : a1 !== b1 ? a1 - b1 : a2 - b2;
}
const matched = releases.filter((rel) => {
if (rel.version === 'Unreleased') return false;
// Skip pre-release entries (e.g. 1.0.0-rc.1, 1.0.0-beta.2) — they cannot
// be range-compared via numeric tuples without implementing full pre-release
// ordering (semver §11). Exclude them silently for now; a consolidation
// issue (#F8) will address pre-release ordering across all comparators.
if (!SEMVER_RE.test(rel.version)) {
process.stderr.write(`[extract] skipping pre-release/non-semver entry: ${rel.version}\n`);
return false;
}
// from is exclusive: cmp > 0 means rel.version > from
const afterFrom = semverCmp(rel.version, from) > 0;
// to is inclusive: cmp <= 0 means rel.version <= to
const upToTo = semverCmp(rel.version, to) <= 0;
return afterFrom && upToTo;
});
if (matched.length === 0) {
return {
exitCode: 2,
report: { releases: [], from, to },
textOutput: null,
};
}
return {
exitCode: 0,
report: { releases: matched, from, to },
textOutput: matched
.map((rel) => {
const header = `## [${rel.version}]${rel.date ? ` - ${rel.date}` : ''}`;
const sections = (rel.sections || [])
.map((s) => {
const bullets = s.bullets
.map((b) => (b.pr !== null ? `- ${b.body} (#${b.pr})` : `- ${b.body}`))
.join('\n');
return `### ${s.type}\n\n${bullets}`;
})
.join('\n\n');
return sections ? `${header}\n\n${sections}` : header;
})
.join('\n\n'),
};
}
function cmdGithubReleaseNotes(opts) {
const repo = path.resolve(opts.repo);
const report = renderGithubReleaseNotes({
@@ -222,6 +340,10 @@ function usage() {
'usage:',
' changeset/cli.cjs render --repo <dir> --version V --date D [--json]',
' changeset/cli.cjs github-release-notes --repo <dir> --from REF --to REF [--output FILE] [--repo-slug OWNER/REPO] [--install-command CMD] [--json]',
' changeset/cli.cjs extract --from VERSION --to VERSION [--changelog FILE] [--repo <dir>] [--json]',
' Extracts changelog entries strictly after --from (exclusive) and up to',
' and including --to (inclusive). Accepts v-prefixed versions.',
' Exit 2 when no releases fall in range.',
'',
].join('\n');
}
@@ -234,9 +356,9 @@ function main() {
process.exit(2);
}
const { opts } = parsed;
if (opts.cmd !== 'render' && opts.cmd !== 'github-release-notes') {
if (opts.cmd !== 'render' && opts.cmd !== 'github-release-notes' && opts.cmd !== 'extract') {
process.stderr.write(usage());
process.exit(2);
process.exit(1);
}
if (opts.cmd === 'render' && (!opts.version || !opts.date)) {
process.stderr.write('--version and --date are required for render\n');
@@ -246,6 +368,23 @@ function main() {
process.stderr.write('--from and --to are required for github-release-notes\n');
process.exit(2);
}
if (opts.cmd === 'extract' && (!opts.fromRef || !opts.toRef)) {
process.stderr.write('--from and --to are required for extract\n');
process.stderr.write(usage());
process.exit(1);
}
if (opts.cmd === 'extract') {
const { exitCode, report, textOutput } = cmdExtract(opts);
if (opts.json) {
process.stdout.write(JSON.stringify(report, null, 2) + '\n');
} else if (textOutput) {
process.stdout.write(textOutput + '\n');
} else if (exitCode === 2) {
process.stderr.write(`no releases found in range (from=${report.from}, to=${report.to})\n`);
}
process.exit(exitCode);
}
const { exitCode, report } = opts.cmd === 'render' ? cmdRender(opts) : cmdGithubReleaseNotes(opts);
if (opts.json) {
@@ -266,4 +405,4 @@ function main() {
if (require.main === module) main();
module.exports = { cmdRender, cmdGithubReleaseNotes, parseArgs, splitChangelog, listFragmentFiles, usage };
module.exports = { cmdRender, cmdExtract, cmdGithubReleaseNotes, parseArgs, splitChangelog, listFragmentFiles, usage };

66
scripts/changeset/serialize.cjs
View File

@@ -41,16 +41,54 @@ function serializeChangelog(ir) {
* Inverse parser: extracts the structured releases from a CHANGELOG.md
* text. Returns { releases: [{ version, date, sections: [{ type, bullets:
* [{ pr, body }] }] }] }. Tolerates the actual repo's CHANGELOG dialect.
*
* Multi-line bullets are supported: a bullet opens on a line starting with
* `- ` and continues on lines starting with two or more spaces (or a tab).
* The `(#NNNN)` PR trailer may appear on any continuation line. Single-line
* bullets (entire entry on one `- ` line) are still handled as before.
*
* Fix for #3496: the previous implementation only matched single-line bullets
* whose `(#NNNN)` suffix was on the same line as the opening `- `. Long
* bullets — which wrap onto indented continuation lines — returned 0 entries
* for their section even when the markdown was well-formed.
*/
function parseChangelog(text) {
const releases = [];
const lines = text.split(/\r?\n/);
let cur = null;
let curSection = null;
// Accumulates lines belonging to the current in-flight bullet (may span
// multiple lines). Flushed when a new block-level element is encountered.
let bulletLines = null;
function flushBullet() {
if (bulletLines === null || !curSection) return;
const joined = bulletLines.join(' ').trim();
// Locate the (# pr) trailer anywhere in the joined text. The trailer is
// expected to be at the very end, but we tolerate trailing whitespace.
const trailMatch = joined.match(/^(.*?)\s*\(#(\d+)\)\s*$/);
if (trailMatch) {
curSection.bullets.push({ body: trailMatch[1].trim(), pr: Number(trailMatch[2]) });
} else {
// Bullet has no PR trailer — preserve it with pr: null so callers
// (e.g. cmdExtract) do not silently drop authored content.
curSection.bullets.push({ body: joined, pr: null });
}
bulletLines = null;
}
for (const line of lines) {
const releaseMatch = line.match(/^##\s+\[([^\]]+)\](?:\s*-\s*(\S+))?/);
// F3: match linked headers: ## [1.42.1](url) - 2026-05-15
// The (?:\([^)]*\))? group skips an optional (url) after the closing ]
// before looking for the optional date suffix.
// F6: strip a leading `v` from the captured version so `## [v1.0.0]`
// parses as version "1.0.0" instead of "v1.0.0".
const releaseMatch = line.match(/^##\s+\[([^\]]+)\](?:\([^)]*\))?\s*(?:-\s*(\S+))?/);
if (releaseMatch) {
cur = { version: releaseMatch[1], date: releaseMatch[2] || null, sections: [] };
flushBullet();
const rawVersion = releaseMatch[1];
const version = rawVersion.replace(/^v/, '');
cur = { version, date: releaseMatch[2] || null, sections: [] };
curSection = null;
releases.push(cur);
continue;
@@ -58,16 +96,34 @@ function parseChangelog(text) {
if (!cur) continue;
const sectionMatch = line.match(/^###\s+(.+?)\s*$/);
if (sectionMatch) {
flushBullet();
curSection = { type: sectionMatch[1], bullets: [] };
cur.sections.push(curSection);
continue;
}
if (!curSection) continue;
const bulletMatch = line.match(/^-\s+(.*?)\s*\(#(\d+)\)\s*$/);
if (bulletMatch) {
curSection.bullets.push({ body: bulletMatch[1], pr: Number(bulletMatch[2]) });
// New bullet: line begins with `- ` (after optional leading spaces that
// would indicate a nested list — we only handle top-level bullets here).
if (/^-\s+/.test(line)) {
flushBullet();
bulletLines = [line.replace(/^-\s+/, '')];
continue;
}
// Continuation line: any indentation (F7: relaxed from /^[ \t]{2}/ so that
// 1-space-indented continuations also fold) BUT NOT a nested bullet marker
// (F4: ` - nested item` terminates the current bullet rather than folding).
if (bulletLines !== null && /^\s+/.test(line) && !/^\s+-\s/.test(line)) {
bulletLines.push(line.trim());
continue;
}
// Any other line (blank, heading, nested bullet, etc.) terminates a pending bullet.
flushBullet();
}
flushBullet();
return { releases };
}

309
tests/changeset-cli.test.cjs
View File

@@ -38,6 +38,315 @@ function runRender(args = []) {
before(() => { tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-changeset-')); });
after(() => { fs.rmSync(tmp, { recursive: true, force: true }); });
// Fixtures for extract tests (#3496)
// Written as arrays to avoid template-literal indentation injecting
// leading spaces that would break the ^## regex anchor.
const EXTRACT_CHANGELOG = [
'# Changelog',
'',
'## [1.5.15] - 2026-01-20',
'',
'### Added',
'',
'- Feature X. (#200)',
'',
'## [1.5.14] - 2026-01-18',
'',
'### Fixed',
'',
'- Single-line fix. (#101)',
'- **Multi-line fix** — first line of a long',
' description that spans two lines. (#102)',
'',
'## [1.5.13] - 2026-01-15',
'',
'### Fixed',
'',
'- Old fix. (#100)',
'',
'## [1.5.10] - 2026-01-01',
'',
'### Fixed',
'',
'- Very old fix. (#50)',
].join('\n');
function runExtract(args = [], changelogText = null) {
const changelogFile = path.join(tmp, 'CHANGELOG-extract-test.md');
if (changelogText !== null) {
fs.writeFileSync(changelogFile, changelogText);
}
const r = cp.spawnSync(
process.execPath,
[SCRIPT, 'extract', '--changelog', changelogFile, ...args],
{ encoding: 'utf8' },
);
return {
status: r.status,
stdout: r.stdout || '',
stderr: r.stderr || '',
json: (() => {
try { return JSON.parse(r.stdout); } catch { return null; }
})(),
};
}
describe('changeset cli extract: version-range changelog extraction (#3496)', () => {
test('exits 2 with no output when no versions fall in range', (t) => {
const r = runExtract(['--from', '1.5.15', '--to', '1.5.15', '--json'], EXTRACT_CHANGELOG);
assert.equal(r.status, 2, `expected exit 2 for empty range, stderr=${r.stderr}`);
// F11: assert JSON structure is present and releases is empty array
assert.ok(r.json, 'stdout must be valid JSON even on exit 2');
assert.strictEqual(r.json.releases.length, 0, 'releases must be empty array on exit 2');
});
test('extracts versions strictly after from and up to and including to', (t) => {
const r = runExtract(['--from', '1.5.13', '--to', '1.5.15', '--json'], EXTRACT_CHANGELOG);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
assert.ok(r.json, 'stdout must be valid JSON');
const versions = r.json.releases.map((rel) => rel.version);
assert.ok(versions.includes('1.5.15'), '1.5.15 must be in range (inclusive to)');
assert.ok(versions.includes('1.5.14'), '1.5.14 must be in range (between from and to)');
assert.ok(!versions.includes('1.5.13'), '1.5.13 must NOT be in range (exclusive from)');
assert.ok(!versions.includes('1.5.10'), '1.5.10 must NOT be in range (below from)');
});
test('accepts v-prefixed version arguments', (t) => {
const r = runExtract(['--from', 'v1.5.13', '--to', 'v1.5.15', '--json'], EXTRACT_CHANGELOG);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
assert.ok(r.json, 'stdout must be valid JSON');
const versions = r.json.releases.map((rel) => rel.version);
assert.ok(versions.includes('1.5.15'));
assert.ok(versions.includes('1.5.14'));
assert.ok(!versions.includes('1.5.13'));
});
test('captures multi-line bullets in extracted range', (t) => {
const r = runExtract(['--from', '1.5.13', '--to', '1.5.14', '--json'], EXTRACT_CHANGELOG);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
const release = r.json.releases.find((rel) => rel.version === '1.5.14');
assert.ok(release, '1.5.14 must be in result');
const prs = release.sections.flatMap((s) => s.bullets.map((b) => b.pr));
assert.ok(prs.includes(101), 'single-line bullet pr=101 must be captured');
assert.ok(prs.includes(102), 'multi-line bullet pr=102 must be captured');
});
test('emits markdown text (non-JSON) when --json is not passed', (t) => {
// Without --json the output is human-readable markdown, not JSON.
// Assert on structural facts derivable from the text: exactly the two
// matched releases appear as ## headers, using parseChangelog so we
// assert on version strings via the production parser rather than
// raw substring matches.
const { parseChangelog: _pc } = require(path.join(ROOT, 'scripts', 'changeset', 'serialize.cjs'));
const r = runExtract(['--from', '1.5.13', '--to', '1.5.15'], EXTRACT_CHANGELOG);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
assert.ok(r.stdout.trim().length > 0, 'stdout must be non-empty');
const parsed = _pc(r.stdout);
const versions = parsed.releases.map((rel) => rel.version);
assert.ok(versions.includes('1.5.15'), '1.5.15 in markdown output');
assert.ok(versions.includes('1.5.14'), '1.5.14 in markdown output');
assert.ok(!versions.includes('1.5.13'), '1.5.13 must not appear in output (excluded by --from)');
});
test('missing --from or --to emits usage and exits non-zero', (t) => {
const r = runExtract(['--from', '1.0.0'], EXTRACT_CHANGELOG);
assert.notEqual(r.status, 0);
assert.ok(r.stderr.length > 0 || r.stdout.length > 0, 'must emit usage text');
});
test('rejects malformed --from semver (non-numeric component) with exit 1', (t) => {
const r = runExtract(['--from', '1.41.x', '--to', '1.5.15', '--json'], EXTRACT_CHANGELOG);
assert.equal(r.status, 1, `expected exit 1 for malformed --from, stderr=${r.stderr}`);
assert.ok(r.json, 'stdout must be valid JSON on error');
assert.ok(typeof r.json.error === 'string', 'error field must be present');
assert.ok(r.json.error.includes('--from'), 'error must mention --from');
});
test('rejects malformed --to semver (alphabetic) with exit 1', (t) => {
const r = runExtract(['--from', '1.5.13', '--to', 'foo', '--json'], EXTRACT_CHANGELOG);
assert.equal(r.status, 1, `expected exit 1 for malformed --to, stderr=${r.stderr}`);
assert.ok(r.json, 'stdout must be valid JSON on error');
assert.ok(typeof r.json.error === 'string', 'error field must be present');
assert.ok(r.json.error.includes('--to'), 'error must mention --to');
});
test('preserves bullets without PR trailer in extracted output', (t) => {
// Fixture with one no-PR bullet and one PR bullet.
const CHANGELOG_NO_PR = [
'# Changelog',
'',
'## [2.0.0] - 2026-01-01',
'',
'### Fixed',
'',
'- Documented fix without PR reference.',
'- Fix with PR reference. (#999)',
].join('\n');
const r = runExtract(['--from', '1.9.9', '--to', '2.0.0', '--json'], CHANGELOG_NO_PR);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
assert.ok(r.json, 'stdout must be valid JSON');
const section = r.json.releases[0].sections[0];
assert.equal(section.bullets.length, 2, 'both bullets (with and without PR) must be captured');
const noPrBullet = section.bullets.find((b) => b.pr === null);
assert.ok(noPrBullet, 'bullet without PR trailer must be present with pr: null');
assert.ok(noPrBullet.body.includes('Documented fix'), 'body text preserved');
const prBullet = section.bullets.find((b) => b.pr === 999);
assert.ok(prBullet, 'bullet with PR trailer must still be captured');
});
// F2: pre-release entries must be excluded from range queries
test('F2: pre-release entry 1.0.0-rc.1 is excluded from range --from 0.9.9 --to 1.0.0', (t) => {
const CHANGELOG_WITH_PRERELEASE = [
'# Changelog',
'',
'## [1.0.0] - 2026-03-01',
'',
'### Added',
'',
'- Stable release. (#10)',
'',
'## [1.0.0-rc.1] - 2026-02-28',
'',
'### Added',
'',
'- Release candidate. (#9)',
'',
'## [0.9.9] - 2026-02-01',
'',
'### Fixed',
'',
'- Prior fix. (#8)',
].join('\n');
const r = runExtract(['--from', '0.9.9', '--to', '1.0.0', '--json'], CHANGELOG_WITH_PRERELEASE);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
assert.ok(r.json, 'stdout must be valid JSON');
const versions = r.json.releases.map((rel) => rel.version);
assert.ok(versions.includes('1.0.0'), '1.0.0 must be in range');
assert.ok(!versions.includes('1.0.0-rc.1'), '1.0.0-rc.1 (pre-release) must be excluded from range');
assert.ok(!versions.includes('0.9.9'), '0.9.9 must not be in range (exclusive from)');
});
// F3: linked-header format ## [1.42.1](url) - date must parse date correctly
test('F3: linked-header ## [1.42.1](url) - date parses date correctly', (t) => {
const CHANGELOG_LINKED = [
'# Changelog',
'',
'## [1.42.1](https://github.com/example/repo/releases/tag/v1.42.1) - 2026-05-15',
'',
'### Fixed',
'',
'- Linked header fix. (#300)',
'',
'## [1.42.0](https://github.com/example/repo/releases/tag/v1.42.0) - 2026-05-10',
'',
'### Added',
'',
'- Linked header feature. (#299)',
].join('\n');
const { parseChangelog: _pc } = require(path.join(ROOT, 'scripts', 'changeset', 'serialize.cjs'));
const parsed = _pc(CHANGELOG_LINKED);
const r1421 = parsed.releases.find((r) => r.version === '1.42.1');
assert.ok(r1421, '1.42.1 must parse from linked header');
assert.equal(r1421.date, '2026-05-15', 'date must be extracted from linked header');
const r1420 = parsed.releases.find((r) => r.version === '1.42.0');
assert.ok(r1420, '1.42.0 must parse from linked header');
assert.equal(r1420.date, '2026-05-10', 'date must be extracted from linked header');
});
// F4: nested bullets must remain as separate bullets, not fold into parent
test('F4: nested bullets are not folded into parent bullet', (t) => {
const CHANGELOG_NESTED = [
'# Changelog',
'',
'## [3.0.0] - 2026-06-01',
'',
'### Changed',
'',
'- Parent bullet. (#400)',
' - Nested child item.',
'- Second top-level bullet. (#401)',
].join('\n');
const { parseChangelog: _pc } = require(path.join(ROOT, 'scripts', 'changeset', 'serialize.cjs'));
const parsed = _pc(CHANGELOG_NESTED);
const rel = parsed.releases.find((r) => r.version === '3.0.0');
assert.ok(rel, '3.0.0 must parse');
const section = rel.sections[0];
// The nested bullet terminates the parent; second top-level bullet is separate.
// We must have both PR 400 and PR 401 as distinct bullets.
const prs = section.bullets.map((b) => b.pr);
assert.ok(prs.includes(400), 'parent bullet pr=400 must be captured');
assert.ok(prs.includes(401), 'second top-level bullet pr=401 must be captured');
// The nested child must NOT have been folded into parent body
const parentBullet = section.bullets.find((b) => b.pr === 400);
assert.ok(!parentBullet.body.includes('Nested child'), 'nested child must not be folded into parent body');
});
// F5+F6: 4-part headers and v-prefix in-file headers
test('F5+F6: 4-part version in CHANGELOG is skipped, v-prefixed version parses without v', (t) => {
const CHANGELOG_EDGE = [
'# Changelog',
'',
'## [v1.0.0] - 2026-04-01',
'',
'### Fixed',
'',
'- v-prefixed header fix. (#500)',
'',
'## [1.0.0.1] - 2026-03-15',
'',
'### Fixed',
'',
'- 4-part version fix. (#501)',
'',
'## [0.9.9] - 2026-03-01',
'',
'### Fixed',
'',
'- Old fix. (#499)',
].join('\n');
const { parseChangelog: _pc } = require(path.join(ROOT, 'scripts', 'changeset', 'serialize.cjs'));
const parsed = _pc(CHANGELOG_EDGE);
// F6: v-prefixed version should be stored without the leading v
const v100 = parsed.releases.find((r) => r.version === '1.0.0');
assert.ok(v100, 'v-prefixed header must parse as version 1.0.0 (v stripped)');
// Confirm extract skips 1.0.0.1 (4-part) — it appears in parsed but won't
// satisfy SEMVER_RE inside the range filter
const r = runExtract(['--from', '0.9.9', '--to', '1.0.0', '--json'], CHANGELOG_EDGE);
assert.equal(r.status, 0, `stderr=${r.stderr}`);
const versions = r.json.releases.map((rel) => rel.version);
assert.ok(versions.includes('1.0.0'), '1.0.0 must be in range');
assert.ok(!versions.includes('1.0.0.1'), '1.0.0.1 (4-part) must be excluded from range');
});
// F1: workflows/update.md must reference the extract subcommand invocation.
// allow-test-rule: reads a product workflow .md file (not CJS source) to verify
// the user-facing instruction was wired; there is no behavioural runtime to invoke.
test('F1: workflows/update.md contains concrete extract subcommand invocation', (t) => {
const workflowPath = path.join(ROOT, 'get-shit-done', 'workflows', 'update.md');
const workflowText = fs.readFileSync(workflowPath, 'utf8');
// The invocation is: node "$GSD_DIR/get-shit-done/scripts/changeset/cli.cjs" extract
// so the literal substring is 'cli.cjs" extract' (quote between script path and subcommand)
assert.ok(
workflowText.includes('cli.cjs" extract') || workflowText.includes('cli.cjs extract'),
'update.md must invoke cli.cjs extract (fix for #3496 BLOCKER 1)',
);
assert.ok(
workflowText.includes('--from') && workflowText.includes('--to'),
'update.md extract invocation must include --from and --to flags',
);
assert.ok(
workflowText.includes('--json'),
'update.md extract invocation must use --json for structured output',
);
assert.ok(
workflowText.includes('EXTRACT_EXIT') || workflowText.includes('EXTRACT_JSON'),
'update.md must capture exit code or JSON output from extract',
);
});
});
describe('changeset cli render: file-I/O wrapper (#2975)', () => {
test('exits 0 with consumed=N when N fragments are folded into CHANGELOG.md and deleted', () => {
fs.rmSync(path.join(tmp, '.changeset'), { recursive: true, force: true });

82
tests/changeset-serialize.test.cjs
View File

@@ -31,6 +31,88 @@ describe('changeset serialize: IR → markdown round-trip (#2975)', () => {
});
});
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/gsd-build/get-shit-done/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'));

85
tests/locking-bugs-1909-1916-1925-1927.test.cjs
View File

@@ -543,6 +543,15 @@ describe('#1927 config.json: setConfigValue must hold planning lock', () => {
});
test('both concurrent config-set calls persist their values', async () => {
// Deterministic concurrency via file-barrier synchronization (mirrors the
// locking-bugs:180 and :235 redesigns).
//
// The old Promise.all([execAsync(A), execAsync(B)]) design is non-deterministic:
// on a loaded Docker runner one subprocess can complete before the other has
// even started, meaning there is no real lock contention — or the opposite:
// both race O_EXCL and one observes stale fs state, causing a lost write that
// fails the assertion. A barrier file forces both to be alive simultaneously
// before either runs the actual config-set.
writeConfig(tmpDir, {
model_profile: 'balanced',
workflow: {
@@ -551,14 +560,76 @@ describe('#1927 config.json: setConfigValue must hold planning lock', () => {
},
});
const nodeBin = process.execPath;
const cmdA = `"${nodeBin}" "${TOOLS_PATH}" config-set model_profile quality --cwd "${tmpDir}"`;
const cmdB = `"${nodeBin}" "${TOOLS_PATH}" config-set workflow.research false --cwd "${tmpDir}"`;
// ── Barrier infrastructure ────────────────────────────────────────────────
const barrierPath = path.join(tmpDir, '.barrier-1927');
const readyA = path.join(tmpDir, '.ready-1927-a');
const readyB = path.join(tmpDir, '.ready-1927-b');
fs.writeFileSync(barrierPath, '1');
if (fs.existsSync(readyA)) fs.unlinkSync(readyA);
if (fs.existsSync(readyB)) fs.unlinkSync(readyB);
await Promise.all([
execAsync(cmdA, { encoding: 'utf-8' }).catch(() => {}),
execAsync(cmdB, { encoding: 'utf-8' }).catch(() => {}),
]);
// ── Wrapper script ────────────────────────────────────────────────────────
const wrapperPath = path.join(tmpDir, '.barrier-wrapper-config-set.cjs');
fs.writeFileSync(wrapperPath, [
"'use strict';",
'const fs = require("fs");',
'const { execFileSync } = require("child_process");',
'const { TOOLS_PATH, BARRIER_FILE, READY_FILE, CONFIG_KEY, CONFIG_VAL, CWD_PATH } = process.env;',
'',
'fs.writeFileSync(READY_FILE, String(process.pid));',
'',
'const sab = new SharedArrayBuffer(4);',
'const sai = new Int32Array(sab);',
'const deadline = Date.now() + 10000;',
'while (fs.existsSync(BARRIER_FILE)) {',
' if (Date.now() > deadline) { process.stderr.write("barrier timeout\\n"); process.exit(1); }',
' Atomics.wait(sai, 0, 0, 10);',
'}',
'',
'execFileSync(process.execPath, [TOOLS_PATH, "config-set", CONFIG_KEY, CONFIG_VAL, "--cwd", CWD_PATH], {',
' stdio: "pipe",',
'});',
].join('\n'));
const nodeBin = process.execPath;
function spawnWrapper(configKey, configVal, readyFile) {
return new Promise((resolve, reject) => {
const child = spawn(nodeBin, [wrapperPath], {
env: {
...process.env,
TOOLS_PATH,
BARRIER_FILE: barrierPath,
READY_FILE: readyFile,
CONFIG_KEY: configKey,
CONFIG_VAL: configVal,
CWD_PATH: tmpDir,
},
stdio: 'pipe',
});
let stderr = '';
child.stderr.on('data', (d) => { stderr += d.toString(); });
child.on('close', (code) => {
if (code !== 0) reject(new Error(`wrapper exited ${code}: ${stderr}`));
else resolve();
});
});
}
const promiseA = spawnWrapper('model_profile', 'quality', readyA);
const promiseB = spawnWrapper('workflow.research', 'false', readyB);
// ── Wait for both to reach barrier, then release ──────────────────────────
const sab2 = new SharedArrayBuffer(4);
const sai2 = new Int32Array(sab2);
const deadline2 = Date.now() + 10000;
while (!fs.existsSync(readyA) || !fs.existsSync(readyB)) {
if (Date.now() > deadline2) throw new Error('Timed out waiting for both config-set subprocesses to reach barrier');
Atomics.wait(sai2, 0, 0, 10);
}
fs.unlinkSync(barrierPath);
await Promise.all([promiseA, promiseB]);
const config = readConfig(tmpDir);
assert.strictEqual(