@logickernel/agileflow 0.16.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logickernel/agileflow",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Automatic semantic versioning and changelog generation based on conventional commits",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -15,6 +15,7 @@ Commands:
   push [remote]  Push a semantic version tag to the remote repository (default: origin)
   gitlab   Create a semantic version tag via GitLab API (for GitLab CI)
   github   Create a semantic version tag via GitHub API (for GitHub Actions)
+  version  Print the agileflow tool version
 
 Options:
   --quiet        Only output the next version (or empty if no bump)
@@ -33,7 +34,7 @@ const VALID_OPTIONS = ['--quiet', '--help', '-h', '--version', '-v'];
 /**
  * Valid commands.
  */
-const VALID_COMMANDS = ['push', 'gitlab', 'github'];
+const VALID_COMMANDS = ['push', 'gitlab', 'github', 'version'];
 
 /**
  * Parses command line arguments and validates them.

package/src/utils.js

@@ -98,7 +98,9 @@ function fetchTags() {
   try {
     const remotes = runWithOutput('git remote').trim();
     if (!remotes) return false;
-    runWithOutput('git fetch --tags --prune --prune-tags');
+    // --force allows updating local tags that conflict with remote tags.
+    // Avoid --prune-tags which can fail in shallow CI clones.
+    runWithOutput('git fetch --tags --force');
     return true;
   } catch {
     return false;
@@ -106,22 +108,40 @@ function fetchTags() {
 }
 
 /**
- * Builds a map of commit SHA → tag names for all tags in the repository.
- * Uses a single git call instead of one per commit.
+ * Builds a tag map from locally stored tags.
  * @returns {Map<string, string[]>}
  */
-function buildTagMap() {
+function buildTagMapFromLocal() {
   try {
-    const output = runWithOutput('git tag --format=%(refname:short)|%(*objectname)|%(objectname)').trim();
+    // %(objecttype) distinguishes lightweight (commit) from annotated (tag) refs.
+    // %(*objectname) is the peeled commit SHA for annotated tags, but may be empty
+    // in shallow clones where git has not computed the peeled ref.
+    const output = runWithOutput('git tag --format=%(refname:short)|%(objecttype)|%(*objectname)|%(objectname)').trim();
     if (!output) return new Map();
     const map = new Map();
     for (const line of output.split('\n')) {
-      const [name, deref, obj] = line.split('|');
-      // Annotated tags dereference to the commit via %(*objectname);
-      // lightweight tags point directly via %(objectname).
-      const sha = (deref || obj || '').trim();
+      const [name, type, deref, obj] = line.split('|');
       const tagName = (name || '').trim();
-      if (!sha || !tagName) continue;
+      if (!tagName) continue;
+
+      let sha;
+      if (type === 'commit') {
+        // Lightweight tag: %(objectname) is the commit SHA directly.
+        sha = (obj || '').trim();
+      } else {
+        // Annotated tag: use peeled commit SHA if available.
+        sha = (deref || '').trim();
+        if (!sha) {
+          // Peeling unavailable (shallow clone) — dereference via rev-parse.
+          try {
+            sha = runWithOutput(`git rev-parse "${tagName}^{}"`).trim();
+          } catch {
+            continue;
+          }
+        }
+      }
+
+      if (!sha) continue;
       if (!map.has(sha)) map.set(sha, []);
       map.get(sha).push(tagName);
     }
@@ -131,6 +151,60 @@ function buildTagMap() {
   }
 }
 
+/**
+ * Builds a tag map by reading tags directly from the remote via ls-remote.
+ * Used as a fallback when git fetch --tags fails (e.g. in shallow CI clones).
+ * Does not store anything locally.
+ * @returns {Map<string, string[]>}
+ */
+function buildTagMapFromRemote() {
+  try {
+    const remotes = runWithOutput('git remote').trim();
+    if (!remotes) return new Map();
+    const remote = remotes.split('\n')[0].trim();
+    const output = runWithOutput(`git ls-remote --tags ${remote}`).trim();
+    if (!output) return new Map();
+
+    const map = new Map();
+    const direct = new Map(); // tagName -> SHA (tag obj or commit)
+    const peeled = new Map(); // tagName -> commit SHA (from ^{} entries)
+
+    for (const line of output.split('\n')) {
+      const tabIdx = line.indexOf('\t');
+      if (tabIdx === -1) continue;
+      const sha = line.slice(0, tabIdx).trim();
+      const ref = line.slice(tabIdx + 1).trim();
+      if (ref.endsWith('^{}')) {
+        // Annotated tag: peeled entry gives the commit SHA
+        peeled.set(ref.slice('refs/tags/'.length, -3), sha);
+      } else if (ref.startsWith('refs/tags/')) {
+        direct.set(ref.slice('refs/tags/'.length), sha);
+      }
+    }
+
+    for (const [name, sha] of direct) {
+      const commitSha = peeled.get(name) || sha;
+      if (!map.has(commitSha)) map.set(commitSha, []);
+      map.get(commitSha).push(name);
+    }
+    return map;
+  } catch {
+    return new Map();
+  }
+}
+
+/**
+ * Builds a map of commit SHA → tag names for all tags in the repository.
+ * Tries local tags first; falls back to reading from the remote when local
+ * tags are absent (common in shallow CI clones where git fetch --tags fails).
+ * @returns {Map<string, string[]>}
+ */
+function buildTagMap() {
+  const local = buildTagMapFromLocal();
+  if (local.size > 0) return local;
+  return buildTagMapFromRemote();
+}
+
 /**
  * Parses a conventional commit message.
  * @param {string} message - The commit message to parse
@@ -158,28 +232,50 @@ function expandCommitInfo(commits) {
   if (!commits?.length) {
     return { latestVersion: null, commits: [] };
   }
-  
-  const taggedIndex = commits.findIndex(commit => 
-    commit.tags?.some(tag => SEMVER_PATTERN.test(tag))
-  );
-  
-  if (taggedIndex === -1) {
-    return { latestVersion: null, commits };
-  }
-  
-  const latestVersion = commits[taggedIndex].tags
-    .filter(tag => SEMVER_PATTERN.test(tag))
-    .sort((a, b) => {
+
+  // Find the commit tagged with the highest semver version in the history.
+  // Using highest-version (not first-found) handles the case where a lower version
+  // was accidentally tagged on a recent commit (e.g. a failed CI run).
+  let bestIndex = -1;
+  let bestVersion = null;
+
+  for (let i = 0; i < commits.length; i++) {
+    const semverTags = commits[i].tags?.filter(tag => SEMVER_PATTERN.test(tag));
+    if (!semverTags?.length) continue;
+
+    const highest = semverTags.sort((a, b) => {
       const pa = parseVersion(a);
       const pb = parseVersion(b);
       if (pb.major !== pa.major) return pb.major - pa.major;
       if (pb.minor !== pa.minor) return pb.minor - pa.minor;
       return pb.patch - pa.patch;
     })[0];
-  // Exclude the tagged commit itself - only return commits since the tag
+
+    if (!bestVersion) {
+      bestVersion = highest;
+      bestIndex = i;
+    } else {
+      const pBest = parseVersion(bestVersion);
+      const pCand = parseVersion(highest);
+      const isHigher =
+        pCand.major > pBest.major ||
+        (pCand.major === pBest.major && pCand.minor > pBest.minor) ||
+        (pCand.major === pBest.major && pCand.minor === pBest.minor && pCand.patch > pBest.patch);
+      if (isHigher) {
+        bestVersion = highest;
+        bestIndex = i;
+      }
+    }
+  }
+
+  if (bestIndex === -1) {
+    return { latestVersion: null, commits };
+  }
+
+  // Return only commits newer than the highest-version tag
   return {
-    latestVersion,
-    commits: commits.slice(0, taggedIndex),
+    latestVersion: bestVersion,
+    commits: commits.slice(0, bestIndex),
   };
 }