calver-bump 0.1.2 → 0.1.4

package/README.md

@@ -18,7 +18,7 @@ Example:
 
 1. Bumps `package.json` to the next CalVer version.
 2. Updates `package-lock.json` or `npm-shrinkwrap.json` when present.
-3. Creates or prepends a `CHANGELOG.md` entry from conventional commits since the latest reachable tag.
+3. Creates or prepends a `CHANGELOG.md` entry from conventional commits since the nearest reachable tag.
 4. Creates a release commit.
 5. Creates an annotated git tag.
 
@@ -95,11 +95,11 @@ Project defaults can be stored in `.calverbumprc.json`:
 - 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.
 - Existing `v`-prefixed tags are considered when calculating the next sequence number.
-- Changelog ranges start from the latest reachable tag, even when it is not a CalVer tag.
+- 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.
-- Later releases prepend only commits since the previous reachable tag.
+- 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.
 - If tag creation fails after the release commit, the CLI rolls back its own release commit.

package/package.json

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

package/src/index.js

@@ -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,16 @@ 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,
+    date,
+    previousTag: notes.previousTag,
+    tag: `${options.tagPrefix ?? ''}${version}`,
+    compareUrlBuilder: notes.compareUrlBuilder,
+  });
+  const entry = `${heading}\n\n${formatReleaseNotes(notes.changes)}\n`;
+
   const body = existing.trim().startsWith('# Changelog')
     ? existing.replace(/^# Changelog\s*/, `# Changelog\n\n${entry}\n`)
     : `# Changelog\n\n${entry}\n${existing}`;
@@ -136,19 +144,39 @@ async function prependChangelog(cwd, version, date, options = {}) {
 }
 
 async function releaseNotes(cwd, options = {}) {
+  await fetchTags(cwd, options.remote ?? 'origin');
   const latestTag = await latestReachableTag(cwd);
   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 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,
       url: commitUrlBuilder ? commitUrlBuilder(commit.hash) : null,
     }));
-  return conventionalCommits.length > 0 ? conventionalCommits : ['No conventional commits in this release.'];
+  return {
+    previousTag: latestTag,
+    compareUrlBuilder,
+    changes: conventionalCommits.length > 0 ? conventionalCommits : ['No conventional commits in this release.'],
+  };
+}
+
+function formatReleaseHeading({ version, date, previousTag, tag, compareUrlBuilder }) {
+  const label = previousTag && compareUrlBuilder
+    ? `[${version}](${compareUrlBuilder(previousTag, tag)})`
+    : version;
+  return `## ${label} - ${isoDate(date)}`;
+}
+
+function isCommitInChangelog(commit, changelog) {
+  if (!changelog) return false;
+  return changelog.includes(commit.hash) || changelog.includes(commit.hash.slice(0, 7));
 }
 
 function isConventionalCommit(subject) {
@@ -196,16 +224,16 @@ async function gitCommits(cwd, range) {
     });
 }
 
-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 +250,23 @@ 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 parseGitRemote(remote) {
   const sshMatch = /^git@(?<host>[^:]+):(?<repo>.+?)(?:\.git)?$/.exec(remote);
   if (sshMatch) {
@@ -237,15 +282,21 @@ function parseGitRemote(remote) {
 }
 
 async function latestReachableTag(cwd) {
-  const tags = await gitLines(cwd, [
-    'for-each-ref',
-    '--merged',
-    'HEAD',
-    '--sort=-creatordate',
-    '--format=%(refname:short)',
-    'refs/tags',
-  ]);
-  return tags[0] ?? null;
+  try {
+    const { stdout } = await git(cwd, ['describe', '--tags', '--abbrev=0']);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+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) {

package/test/release.test.js

@@ -104,7 +104,7 @@ test('runRelease updates package-lock.json when it exists', async () => {
   assert.equal(lock.packages[''].version, '26.0529');
 });
 
-test('runRelease uses the latest reachable tag as the changelog base', async () => {
+test('runRelease uses the nearest reachable tag as the changelog base', async () => {
   const repo = await makeRepo();
   execFileSync('git', ['tag', '26.0528.1'], { cwd: repo });
   await writeFile(path.join(repo, 'feature-a.txt'), 'a\n');
@@ -122,7 +122,7 @@ test('runRelease uses the latest reachable tag as the changelog base', async ()
 
   const changelog = await readFile(path.join(repo, 'CHANGELOG.md'), 'utf8');
   assert.match(changelog, /- fix: after non-release tag/);
-  assert.match(changelog, /- feat: after calver tag/);
+  assert.doesNotMatch(changelog, /- feat: after calver tag/);
   assert.doesNotMatch(changelog, /- feat: initial app/);
 });
 
@@ -187,6 +187,7 @@ test('runRelease groups changelog entries by conventional commit type', async ()
 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\) - 2026-05-29/,
+  );
 });
 
 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,10 @@ 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\) - 2026-05-29/,
+  );
 });
 
 test('runRelease prepends only commits since the previous CalVer tag on later releases', async () => {
@@ -265,6 +275,83 @@ test('runRelease uses the latest reachable tag as the changelog base even when i
   assert.doesNotMatch(changelog, /- feat: initial app/);
 });
 
+test('runRelease uses the nearest history tag, not the newest-created reachable tag, as the changelog base', async () => {
+  const repo = await makeRepo();
+  execFileSync('git', ['tag', 'old-tag'], { cwd: repo });
+  await writeFile(path.join(repo, 'first.txt'), 'first\n');
+  execFileSync('git', ['add', 'first.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'feat: already released'], { cwd: repo });
+  execFileSync('git', ['tag', 'v1.35.0'], { cwd: repo });
+  execFileSync('git', ['tag', '-f', 'newer-created-old-tag', 'old-tag'], { cwd: repo });
+  await writeFile(path.join(repo, 'second.txt'), 'second\n');
+  execFileSync('git', ['add', 'second.txt'], { cwd: repo });
+  execFileSync('git', ['commit', '-m', 'fix: unreleased change'], { 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: unreleased change/);
+  assert.doesNotMatch(changelog, /feat: already released/);
+  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 rolls back its release commit when tag creation fails', async () => {
   const repo = await makeRepo();
   execFileSync('git', ['tag', '26.0529'], { cwd: repo });
@@ -338,3 +425,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;
+}