calver-bump 0.1.3 → 0.1.5

package/README.md

@@ -94,11 +94,14 @@ Project defaults can be stored in `.calverbumprc.json`:
 - The default `short` format is `YY.MMDD` for the first release of the day, then `YY.MMDD.1`, `YY.MMDD.2`, etc.
 - The optional `compact` format is `YYMMDD` for the first release of the day, then `YYMMDD.1`, `YYMMDD.2`, etc.
 - The optional `long` format is `YYYY.MM.DD` for the first release of the day, then `YYYY.MM.DD.1`, `YYYY.MM.DD.2`, etc.
+- Changelog release headings use the CalVer version only and do not append a separate `YYYY-MM-DD` date.
 - Existing `v`-prefixed tags are considered when calculating the next sequence number.
 - Changelog ranges start from the nearest reachable tag, even when it is not a CalVer tag.
 - Changelog entries include conventional commit subjects only, such as `feat:`, `fix(scope):`, or `chore!:`.
 - Changelog entries are grouped into `Features`, `Fixes`, and `Other Changes`.
-- Changelog entries link to their commit hash for GitHub and GitLab-style `origin` remotes.
+- Changelog entries link to GitHub pull requests or GitLab merge requests when the local git message includes references such as `#123`, `Merge pull request #123`, `!123`, or `See merge request group/project!123`.
+- Changelog entries fall back to commit hash links for GitHub and GitLab-style remotes when no pull/merge request reference is found.
+- Release entries include a `Full Changelog` section with a deduped list of pull/merge requests found in the release range, including the local commit title when available.
 - Later releases prepend only commits since the previous nearest reachable tag.
 - Release tags are annotated so `git push --follow-tags <remote> <branch>` pushes them.
 - The working tree must be clean before creating a real release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calver-bump",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Release CLI for internal applications using readable CalVer versions.",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -3,7 +3,7 @@ import { access, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 
-import { isoDate, nextCalVer } from './calver.js';
+import { nextCalVer } from './calver.js';
 
 const execFile = promisify(execFileCallback);
 
@@ -118,8 +118,6 @@ async function fileExists(filePath) {
 
 async function prependChangelog(cwd, version, date, options = {}) {
   const changelogPath = path.join(cwd, 'CHANGELOG.md');
-  const changes = await releaseNotes(cwd, options);
-  const entry = `## ${version} - ${isoDate(date)}\n\n${formatReleaseNotes(changes)}\n`;
   let existing = '';
 
   try {
@@ -128,6 +126,15 @@ async function prependChangelog(cwd, version, date, options = {}) {
     if (error.code !== 'ENOENT') throw error;
   }
 
+  const notes = await releaseNotes(cwd, { ...options, existingChangelog: existing });
+  const heading = formatReleaseHeading({
+    version,
+    previousTag: notes.previousTag,
+    tag: `${options.tagPrefix ?? ''}${version}`,
+    compareUrlBuilder: notes.compareUrlBuilder,
+  });
+  const entry = `${heading}\n\n${formatReleaseNotes(notes.changes)}${formatFullChangelog(notes.requests)}\n`;
+
   const body = existing.trim().startsWith('# Changelog')
     ? existing.replace(/^# Changelog\s*/, `# Changelog\n\n${entry}\n`)
     : `# Changelog\n\n${entry}\n${existing}`;
@@ -136,19 +143,43 @@ async function prependChangelog(cwd, version, date, options = {}) {
 }
 
 async function releaseNotes(cwd, options = {}) {
-  const latestTag = await latestReachableTag(cwd);
+  await fetchTags(cwd, options.remote ?? 'origin');
+  const latestTag = await latestReleaseTag(cwd, options.existingChangelog ?? '');
   const range = latestTag ? [`${latestTag}..HEAD`] : [];
   const commits = await gitCommits(cwd, range);
-  const commitUrlBuilder = await commitUrlBuilderForOrigin(cwd);
+  const remoteUrl = await getRemoteUrl(cwd, options.remote ?? 'origin');
+  const commitUrlBuilder = remoteUrl ? buildCommitUrlBuilder(remoteUrl) : null;
+  const compareUrlBuilder = remoteUrl ? buildCompareUrlBuilder(remoteUrl) : null;
+  const requestUrlBuilder = remoteUrl ? buildRequestUrlBuilder(remoteUrl) : null;
   const allowedTypes = options.types ?? ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'build', 'ci', 'chore', 'revert'];
   const conventionalCommits = commits
     .filter((commit) => isConventionalCommit(commit.subject))
     .filter((commit) => allowedTypes.includes(conventionalType(commit.subject)))
+    .filter((commit) => !isCommitInChangelog(commit, options.existingChangelog ?? ''))
     .map((commit) => ({
       ...commit,
+      request: requestForCommit(commit, requestUrlBuilder),
       url: commitUrlBuilder ? commitUrlBuilder(commit.hash) : null,
     }));
-  return conventionalCommits.length > 0 ? conventionalCommits : ['No conventional commits in this release.'];
+  const requests = uniqueRequests(commits.map((commit) => requestForCommit(commit, requestUrlBuilder)).filter(Boolean));
+  return {
+    previousTag: latestTag,
+    compareUrlBuilder,
+    changes: conventionalCommits.length > 0 ? conventionalCommits : ['No conventional commits in this release.'],
+    requests,
+  };
+}
+
+function formatReleaseHeading({ version, previousTag, tag, compareUrlBuilder }) {
+  const label = previousTag && compareUrlBuilder
+    ? `[${version}](${compareUrlBuilder(previousTag, tag)})`
+    : version;
+  return `## ${label}`;
+}
+
+function isCommitInChangelog(commit, changelog) {
+  if (!changelog) return false;
+  return changelog.includes(commit.hash) || changelog.includes(commit.hash.slice(0, 7));
 }
 
 function isConventionalCommit(subject) {
@@ -175,37 +206,54 @@ function formatReleaseNotes(changes) {
     .join('\n\n');
 }
 
+function formatFullChangelog(requests) {
+  if (requests.length === 0) {
+    return '';
+  }
+  return `\n\n### Full Changelog\n\n${requests.map((request) => `- ${formatRequestEntry(request)}`).join('\n')}`;
+}
+
 function conventionalType(subject) {
   return /^(?<type>[a-z]+)(\([^)]+\))?!?: .+/.exec(subject)?.groups.type;
 }
 
 function formatCommitEntry(commit) {
   const shortHash = commit.hash.slice(0, 7);
-  const suffix = commit.url ? ` ([${shortHash}](${commit.url}))` : ` (${shortHash})`;
+  const suffix = commit.request
+    ? ` (${formatRequestLink(commit.request)})`
+    : commit.url ? ` ([${shortHash}](${commit.url}))` : ` (${shortHash})`;
   return `${commit.subject}${suffix}`;
 }
 
+function formatRequestLink(request) {
+  return request.url ? `[${request.label}](${request.url})` : request.label;
+}
+
+function formatRequestEntry(request) {
+  return request.title ? `${formatRequestLink(request)} ${request.title}` : formatRequestLink(request);
+}
+
 async function gitCommits(cwd, range) {
-  const { stdout } = await git(cwd, ['log', '--pretty=format:%H%x00%s', ...range]);
+  const { stdout } = await git(cwd, ['log', '--pretty=format:%H%x00%s%x00%B%x1e', ...range]);
   return stdout
-    .split('\n')
+    .split('\x1e')
     .filter(Boolean)
-    .map((line) => {
-      const [hash, subject] = line.split('\0');
-      return { hash, subject };
+    .map((record) => {
+      const [hash, subject, body = ''] = record.replace(/^\n+|\n+$/g, '').split('\0');
+      return { hash, subject, body };
     });
 }
 
-async function commitUrlBuilderForOrigin(cwd) {
+async function getRemoteUrl(cwd, remote) {
   try {
-    const { stdout } = await git(cwd, ['remote', 'get-url', 'origin']);
-    return commitUrlBuilder(stdout.trim());
+    const { stdout } = await git(cwd, ['remote', 'get-url', remote]);
+    return stdout.trim();
   } catch {
     return null;
   }
 }
 
-function commitUrlBuilder(remote) {
+function buildCommitUrlBuilder(remote) {
   const parsed = parseGitRemote(remote);
   if (!parsed) {
     return null;
@@ -222,6 +270,95 @@ function commitUrlBuilder(remote) {
   return null;
 }
 
+function buildCompareUrlBuilder(remote) {
+  const parsed = parseGitRemote(remote);
+  if (!parsed) {
+    return null;
+  }
+
+  const baseUrl = `https://${parsed.host}/${parsed.repo}`;
+  if (parsed.host === 'github.com') {
+    return (from, to) => `${baseUrl}/compare/${from}...${to}`;
+  }
+  if (parsed.host.includes('gitlab')) {
+    return (from, to) => `${baseUrl}/-/compare/${from}...${to}`;
+  }
+
+  return null;
+}
+
+function buildRequestUrlBuilder(remote) {
+  const parsed = parseGitRemote(remote);
+  if (!parsed) {
+    return null;
+  }
+
+  const baseUrl = `https://${parsed.host}/${parsed.repo}`;
+  if (parsed.host === 'github.com') {
+    return (request) => request.provider === 'github' ? `${baseUrl}/pull/${request.number}` : null;
+  }
+  if (parsed.host.includes('gitlab')) {
+    return (request) => request.provider === 'gitlab' ? `${baseUrl}/-/merge_requests/${request.number}` : null;
+  }
+
+  return null;
+}
+
+function requestForCommit(commit, requestUrlBuilder) {
+  const request = parseRequestReference(`${commit.subject}\n${commit.body ?? ''}`);
+  if (!request) {
+    return null;
+  }
+  return {
+    ...request,
+    title: requestTitleForCommit(commit),
+    url: requestUrlBuilder ? requestUrlBuilder(request) : null,
+  };
+}
+
+function requestTitleForCommit(commit) {
+  if (isConventionalCommit(commit.subject)) {
+    return commit.subject;
+  }
+
+  return (commit.body ?? '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find((line) => line && !parseRequestReference(line) && !/^Merge\b/i.test(line)) ?? null;
+}
+
+function parseRequestReference(message) {
+  const gitlabMerge = /(?:^|\s)(?:See merge request\s+\S+!|!)(?<number>\d+)(?=\D|$)/i.exec(message);
+  if (gitlabMerge) {
+    return { provider: 'gitlab', number: gitlabMerge.groups.number, label: `!${gitlabMerge.groups.number}` };
+  }
+
+  const githubPull = /(?:Merge pull request\s+#|#)(?<number>\d+)(?=\D|$)/i.exec(message);
+  if (githubPull) {
+    return { provider: 'github', number: githubPull.groups.number, label: `#${githubPull.groups.number}` };
+  }
+
+  return null;
+}
+
+function uniqueRequests(requests) {
+  const seen = new Set();
+  const unique = [];
+  for (const request of requests) {
+    const key = `${request.provider}:${request.number}`;
+    if (seen.has(key)) {
+      const existing = unique.find((candidate) => `${candidate.provider}:${candidate.number}` === key);
+      if (existing && !existing.title && request.title) {
+        existing.title = request.title;
+      }
+      continue;
+    }
+    seen.add(key);
+    unique.push(request);
+  }
+  return unique;
+}
+
 function parseGitRemote(remote) {
   const sshMatch = /^git@(?<host>[^:]+):(?<repo>.+?)(?:\.git)?$/.exec(remote);
   if (sshMatch) {
@@ -236,6 +373,28 @@ function parseGitRemote(remote) {
   return null;
 }
 
+async function latestReleaseTag(cwd, changelog) {
+  const changelogTag = latestChangelogCompareTarget(changelog);
+  if (changelogTag && await tagExists(cwd, changelogTag)) {
+    return changelogTag;
+  }
+  return latestReachableTag(cwd);
+}
+
+function latestChangelogCompareTarget(changelog) {
+  const match = /^## \[[^\]]+\]\([^)]*\/(?:-\/)?compare\/[^)]*?\.{3}(?<tag>[^)\s]+)\)/m.exec(changelog);
+  return match?.groups.tag ?? null;
+}
+
+async function tagExists(cwd, tag) {
+  try {
+    await git(cwd, ['rev-parse', '--verify', '--quiet', `refs/tags/${tag}^{}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function latestReachableTag(cwd) {
   try {
     const { stdout } = await git(cwd, ['describe', '--tags', '--abbrev=0']);
@@ -245,6 +404,15 @@ async function latestReachableTag(cwd) {
   }
 }
 
+async function fetchTags(cwd, remote) {
+  try {
+    await git(cwd, ['remote', 'get-url', remote]);
+    await git(cwd, ['fetch', '--tags', remote]);
+  } catch {
+    // Local/offline repos can still release using tags already present.
+  }
+}
+
 async function currentBranch(cwd) {
   try {
     const { stdout } = await git(cwd, ['branch', '--show-current']);

package/test/release.test.js

@@ -64,7 +64,7 @@ test('runRelease updates package.json, prepends changelog, commits, and tags', a
   assert.equal(pkg.version, '26.0529');
 
   const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
-  assert.match(changelog, /^# Changelog\n\n## 26\.0529 - 2026-05-29\n\n### Features\n\n- feat: initial app/);
+  assert.match(changelog, /^# Changelog\n\n## 26\.0529\n\n### Features\n\n- feat: initial app/);
 
   const tag = execFileSync('git', ['tag', '--list', '26.0529'], {
     cwd: repo,
@@ -180,13 +180,14 @@ test('runRelease groups changelog entries by conventional commit type', async ()
   const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
   assert.match(
     changelog,
-    /## 26\.0529 - 2026-05-29\n\n### Features\n\n- feat: add release grouping \([a-f0-9]{7}\)\n- feat: initial app \([a-f0-9]{7}\)\n\n### Fixes\n\n- fix\(auth\): repair token refresh \([a-f0-9]{7}\)/,
+    /## 26\.0529\n\n### Features\n\n- feat: add release grouping \([a-f0-9]{7}\)\n- feat: initial app \([a-f0-9]{7}\)\n\n### Fixes\n\n- fix\(auth\): repair token refresh \([a-f0-9]{7}\)/,
   );
 });
 
 test('runRelease links each changelog entry to its commit on GitHub', async () => {
   const repo = await makeRepo();
   execFileSync('git', ['remote', 'add', 'origin', 'git@github.com:msako/demo-app.git'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.0.0'], { cwd: repo });
   await writeFile(path.join(repo, 'feature.txt'), 'feature\n');
   execFileSync('git', ['add', 'feature.txt'], { cwd: repo });
   execFileSync('git', ['commit', '-m', 'feat: add linked changelog entry'], { cwd: repo });
@@ -203,11 +204,16 @@ test('runRelease links each changelog entry to its commit on GitHub', async () =
     changelog,
     new RegExp(`- feat: add linked changelog entry \\(\\[${shortHash}\\]\\(https://github\\.com/msako/demo-app/commit/${hash}\\)\\)`),
   );
+  assert.match(
+    changelog,
+    /^# Changelog\n\n## \[26\.0529\]\(https:\/\/github\.com\/msako\/demo-app\/compare\/v1\.0\.0\.\.\.26\.0529\)/,
+  );
 });
 
 test('runRelease links changelog entries for private GitLab-style remotes', async () => {
   const repo = await makeRepo();
   execFileSync('git', ['remote', 'add', 'origin', 'git@gitlab.internal.example.com:platform/demo-app.git'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.0.0'], { cwd: repo });
   await writeFile(path.join(repo, 'feature.txt'), 'feature\n');
   execFileSync('git', ['add', 'feature.txt'], { cwd: repo });
   execFileSync('git', ['commit', '-m', 'fix: link private gitlab commit'], { cwd: repo });
@@ -224,6 +230,75 @@ test('runRelease links changelog entries for private GitLab-style remotes', asyn
     changelog,
     new RegExp(`- fix: link private gitlab commit \\(\\[${shortHash}\\]\\(https://gitlab\\.internal\\.example\\.com/platform/demo-app/-/commit/${hash}\\)\\)`),
   );
+  assert.match(
+    changelog,
+    /^# Changelog\n\n## \[26\.0529\]\(https:\/\/gitlab\.internal\.example\.com\/platform\/demo-app\/-\/compare\/v1\.0\.0\.\.\.26\.0529\)/,
+  );
+});
+
+test('runRelease links changelog entries to GitHub pull requests when commit subjects include PR numbers', async () => {
+  const repo = await makeRepo();
+  execFileSync('git', ['remote', 'add', 'origin', 'git@github.com:msako/demo-app.git'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.0.0'], { cwd: repo });
+  await writeFile(path.join(repo, 'feature.txt'), 'feature\n');
+  execFileSync('git', ['add', 'feature.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'feat: add pull request links (#42)'], { cwd: repo });
+
+  await runRelease({
+    cwd: repo,
+    date: new Date('2026-05-29T12:00:00-07:00'),
+  });
+
+  const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
+  assert.match(
+    changelog,
+    /- feat: add pull request links \(#42\) \(\[#42\]\(https:\/\/github\.com\/msako\/demo-app\/pull\/42\)\)/,
+  );
+  assert.match(
+    changelog,
+    /### Full Changelog\n\n- \[#42\]\(https:\/\/github\.com\/msako\/demo-app\/pull\/42\) feat: add pull request links \(#42\)/,
+  );
+});
+
+test('runRelease links changelog entries to GitLab merge requests and dedupes the full changelog', async () => {
+  const repo = await makeRepo();
+  execFileSync('git', ['remote', 'add', 'origin', 'git@gitlab.internal.example.com:platform/demo-app.git'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.0.0'], { cwd: repo });
+  await writeFile(path.join(repo, 'fix.txt'), 'fix\n');
+  execFileSync('git', ['add', 'fix.txt'], { cwd: repo });
+  execFileSync('git', [
+    'commit',
+    '-m',
+    'fix(review): block rule-listed reviewers',
+    '-m',
+    'See merge request platform/demo-app!77',
+  ], { cwd: repo });
+  await writeFile(path.join(repo, 'merge.txt'), 'merge\n');
+  execFileSync('git', ['add', 'merge.txt'], { cwd: repo });
+  execFileSync('git', [
+    'commit',
+    '-m',
+    'Merge branch feature/review into main',
+    '-m',
+    'See merge request platform/demo-app!77',
+  ], { cwd: repo });
+
+  await runRelease({
+    cwd: repo,
+    date: new Date('2026-05-29T12:00:00-07:00'),
+  });
+
+  const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
+  assert.match(
+    changelog,
+    /- fix\(review\): block rule-listed reviewers \(\[!77\]\(https:\/\/gitlab\.internal\.example\.com\/platform\/demo-app\/-\/merge_requests\/77\)\)/,
+  );
+  const fullChangelogEntries = changelog.match(/\[!77\]\(https:\/\/gitlab\.internal\.example\.com\/platform\/demo-app\/-\/merge_requests\/77\)/g) ?? [];
+  assert.equal(fullChangelogEntries.length, 2);
+  assert.match(
+    changelog,
+    /### Full Changelog\n\n- \[!77\]\(https:\/\/gitlab\.internal\.example\.com\/platform\/demo-app\/-\/merge_requests\/77\) fix\(review\): block rule-listed reviewers/,
+  );
 });
 
 test('runRelease prepends only commits since the previous CalVer tag on later releases', async () => {
@@ -242,8 +317,8 @@ test('runRelease prepends only commits since the previous CalVer tag on later re
   });
 
   const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
-  const latestEntry = changelog.split('## 26.0529 - 2026-05-29')[0];
-  assert.match(latestEntry, /## 26\.0529\.1 - 2026-05-29/);
+  const latestEntry = changelog.split('\n## 26.0529\n')[0];
+  assert.match(latestEntry, /## 26\.0529\.1/);
   assert.match(latestEntry, /- fix: second release only/);
   assert.doesNotMatch(latestEntry, /feat: initial app/);
 });
@@ -288,6 +363,94 @@ test('runRelease uses the nearest history tag, not the newest-created reachable
   assert.doesNotMatch(changelog, /feat: initial app/);
 });
 
+test('runRelease fetches remote tags before choosing the changelog base', async () => {
+  const repo = await makeRepo();
+  const remote = await makeBareRepo();
+  execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: repo });
+  await writeFile(path.join(repo, 'released.txt'), 'released\n');
+  execFileSync('git', ['add', 'released.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'feat: already in remote tagged release'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.35.0'], { cwd: repo });
+  execFileSync('git', ['push', 'origin', 'main', '--tags'], { cwd: repo });
+  execFileSync('git', ['tag', '-d', 'v1.35.0'], { cwd: repo });
+  await writeFile(
+    path.join(repo, 'CHANGELOG.md'),
+    '# Changelog\n\n## [1.35.0](https://gitlab.ops/example/repo/compare/v1.34.0...v1.35.0) (2026-06-01)\n\n### Features\n\n* feat: already in remote tagged release\n',
+  );
+  await writeFile(path.join(repo, 'unreleased.txt'), 'unreleased\n');
+  execFileSync('git', ['add', 'CHANGELOG.md', 'unreleased.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'fix: unreleased after remote tag'], { cwd: repo });
+
+  await runRelease({
+    cwd: repo,
+    date: new Date('2026-06-02T12:00:00-07:00'),
+  });
+
+  const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
+  const latestEntry = changelog.split('## [1.35.0]')[0];
+  assert.match(latestEntry, /- fix: unreleased after remote tag/);
+  assert.doesNotMatch(latestEntry, /feat: already in remote tagged release/);
+});
+
+test('runRelease does not duplicate commits already present in an existing changelog', async () => {
+  const repo = await makeRepo();
+  await writeFile(path.join(repo, 'released.txt'), 'released\n');
+  execFileSync('git', ['add', 'released.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'feat: already documented'], { cwd: repo });
+  const documentedHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repo, encoding: 'utf8' }).trim();
+  await writeFile(
+    path.join(repo, 'CHANGELOG.md'),
+    `# Changelog\n\n## [1.35.0](https://gitlab.ops/example/repo/compare/v1.34.0...v1.35.0) (2026-06-01)\n\n### Features\n\n* **site-map:** already documented ([${documentedHash.slice(0, 7)}](https://gitlab.ops/example/repo/-/commit/${documentedHash}))\n`,
+  );
+  await writeFile(path.join(repo, 'unreleased.txt'), 'unreleased\n');
+  execFileSync('git', ['add', 'CHANGELOG.md', 'unreleased.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'fix: not yet documented'], { cwd: repo });
+
+  await runRelease({
+    cwd: repo,
+    date: new Date('2026-06-02T12:00:00-07:00'),
+  });
+
+  const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
+  const latestEntry = changelog.split('## [1.35.0]')[0];
+  assert.match(latestEntry, /- fix: not yet documented/);
+  assert.doesNotMatch(latestEntry, /feat: already documented/);
+});
+
+test('runRelease uses the previous changelog compare target for the new compare link', async () => {
+  const repo = await makeRepo();
+  execFileSync('git', ['remote', 'add', 'origin', 'git@gitlab.ops:pss/d2pass/d2p_next.git'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.34.0'], { cwd: repo });
+  await writeFile(path.join(repo, 'released.txt'), 'released\n');
+  execFileSync('git', ['add', 'released.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'feat: already documented release'], { cwd: repo });
+  const releaseHead = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: repo, encoding: 'utf8' }).trim();
+  await writeFile(
+    path.join(repo, 'CHANGELOG.md'),
+    '# Changelog\n\n## [1.35.0](https://gitlab.ops/pss/d2pass/d2p_next/compare/v1.34.0...v1.35.0) (2026-06-01)\n\n### Features\n\n* **site-map:** already documented release\n',
+  );
+  await writeFile(path.join(repo, 'unreleased.txt'), 'unreleased\n');
+  execFileSync('git', ['add', 'CHANGELOG.md', 'unreleased.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'fix: new release change'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.35.0', releaseHead], { cwd: repo });
+
+  await runRelease({
+    cwd: repo,
+    date: new Date('2026-06-02T12:00:00-07:00'),
+    tagPrefix: 'v',
+    types: ['feat', 'fix'],
+  });
+
+  const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
+  assert.match(
+    changelog,
+    /^# Changelog\n\n## \[26\.0602\]\(https:\/\/gitlab\.ops\/pss\/d2pass\/d2p_next\/-\/compare\/v1\.35\.0\.\.\.v26\.0602\)/,
+  );
+  const latestEntry = changelog.split('## [1.35.0]')[0];
+  assert.match(latestEntry, /- fix: new release change/);
+  assert.doesNotMatch(latestEntry, /feat: already documented release/);
+});
+
 test('runRelease rolls back its release commit when tag creation fails', async () => {
   const repo = await makeRepo();
   execFileSync('git', ['tag', '26.0529'], { cwd: repo });
@@ -361,3 +524,9 @@ async function makeRepo({ packageLock = false } = {}) {
   execFileSync('git', ['commit', '-m', 'feat: initial app'], { cwd: repo });
   return repo;
 }
+
+async function makeBareRepo() {
+  const repo = await mkdtemp(path.join(tmpdir(), 'calver-bump-remote-'));
+  execFileSync('git', ['init', '--bare'], { cwd: repo });
+  return repo;
+}