gitxplain 0.1.3 → 0.1.8

package/cli/services/mergeService.js

@@ -1,26 +1,22 @@
 import process from "node:process";
 import {
-  deletePaths,
+  createCommitFromTree,
+  getCommitMetadata,
   getCurrentBranchName,
-  getCurrentHeadSha,
   getDefaultBaseRef,
   getMergeBase,
   gitCheckout,
-  gitCheckoutOrphan,
-  gitCherryPickAbort,
-  gitCherryPickNoCommit,
-  gitCommit,
+  gitCreateBranch,
   gitCreateAnnotatedTag,
   gitDeleteBranch,
+  gitForceBranch,
   gitDeleteTag,
-  gitRemoveCachedAll,
-  gitResetHard,
   isWorkingTreeClean,
   listBranchCommits,
   listCommitsAfter,
-  listFilesInRef,
   listTags,
   localBranchExists,
+  resolveTreeSha,
   resolveCommitSha,
   runGitCommand
 } from "./gitService.js";
@@ -310,27 +306,37 @@ export function buildReleaseWindows(sourceCommits) {
   return windows;
 }
 
+function selectLatestWindowsPerVersion(windows) {
+  const seenVersions = new Set();
+  const latestWindows = [];
+
+  for (let index = windows.length - 1; index >= 0; index -= 1) {
+    const window = windows[index];
+    if (!window.version || seenVersions.has(window.version)) {
+      continue;
+    }
+
+    seenVersions.add(window.version);
+    latestWindows.push(window);
+  }
+
+  return latestWindows.reverse();
+}
+
 export function selectReleaseWindows(sourceCommits, releaseCommits = []) {
   const windows = buildReleaseWindows(sourceCommits);
   const releasedVersions = getReleasedVersions(releaseCommits);
   const unreleasedWindows = windows.filter((window) => !releasedVersions.has(window.version));
 
-  const selectedWindows =
-    releasedVersions.size === 0
-      ? unreleasedWindows
-      : unreleasedWindows.length > 0
-        ? [unreleasedWindows.at(-1)]
-        : [];
-
   return {
-    windows: selectedWindows,
+    windows: unreleasedWindows,
     releasedVersions: [...releasedVersions],
     latestDetectedVersion: windows.at(-1)?.version ?? null
   };
 }
 
 export function selectReleaseTags(sourceCommits, existingTagNames = []) {
-  const windows = buildReleaseWindows(sourceCommits);
+  const windows = selectLatestWindowsPerVersion(buildReleaseWindows(sourceCommits));
   const taggedVersions = extractTaggedVersions(existingTagNames);
   const tags = windows
     .filter((window) => !taggedVersions.has(window.version))
@@ -353,37 +359,88 @@ export function selectReleaseTags(sourceCommits, existingTagNames = []) {
   };
 }
 
-function getReleaseTrackSourceCommitShas(releaseExists, baseRef, cwd) {
+function findLatestTaggedSourceVersion(sourceCommits, taggedVersions) {
+  const tagged = new Set(taggedVersions);
+  return selectLatestWindowsPerVersion(buildReleaseWindows(sourceCommits))
+    .map((window) => window.version)
+    .filter((version) => version && tagged.has(version))
+    .at(-1) ?? null;
+}
+
+function buildReleaseTagPlanForSource(sourceBranch, sourceRef, cwd) {
+  const sourceCommits = listBranchCommits(sourceRef, cwd).map((sha) => inspectCommit(sha, cwd));
+  const existingTagNames = listTags(cwd);
+  const selection = selectReleaseTags(sourceCommits, existingTagNames);
+
+  return {
+    sourceBranch,
+    baseRef: sourceRef,
+    mergeBase: null,
+    releaseExists: localBranchExists(RELEASE_BRANCH, cwd),
+    taggedVersions: selection.taggedVersions,
+    latestDetectedVersion: selection.latestDetectedVersion,
+    latestTaggedVersion: findLatestTaggedSourceVersion(sourceCommits, selection.taggedVersions),
+    tags: selection.tags
+  };
+}
+
+export function selectReleaseTagsFromReleaseCommits(releaseCommits, existingTagNames = []) {
+  const taggedVersions = extractTaggedVersions(existingTagNames);
+  const tags = releaseCommits
+    .map((commit) => ({
+      commit,
+      version: commit.subject.match(RELEASE_SUBJECT_PATTERN)?.[1]?.trim() ?? null
+    }))
+    .filter((entry) => entry.version)
+    .filter((entry) => !taggedVersions.has(entry.version))
+    .map(({ commit, version }) => ({
+      version,
+      tagName: version,
+      startRef: commit.shortSha,
+      endRef: commit.shortSha,
+      targetSha: commit.sha,
+      targetShortSha: commit.shortSha,
+      targetSubject: commit.subject,
+      commits: [commit]
+    }));
+
+  return {
+    tags,
+    taggedVersions: [...taggedVersions],
+    latestDetectedVersion:
+      releaseCommits
+        .map((commit) => commit.subject.match(RELEASE_SUBJECT_PATTERN)?.[1]?.trim() ?? null)
+        .filter(Boolean)
+        .at(-1) ?? null
+  };
+}
+
+function getReleaseTrackSourceCommitShas(releaseExists, baseRef, sourceRef, cwd) {
   if (!releaseExists) {
     return {
       mergeBase: null,
-      sourceCommitShas: listBranchCommits("HEAD", cwd)
+      sourceCommitShas: listBranchCommits(sourceRef, cwd)
     };
   }
 
   try {
-    const mergeBase = getMergeBase(baseRef, "HEAD", cwd);
+    const mergeBase = getMergeBase(baseRef, sourceRef, cwd);
     return {
       mergeBase,
-      sourceCommitShas: listCommitsAfter(mergeBase, "HEAD", cwd)
+      sourceCommitShas: listCommitsAfter(mergeBase, sourceRef, cwd)
     };
   } catch {
     return {
       mergeBase: null,
-      sourceCommitShas: listBranchCommits("HEAD", cwd)
+      sourceCommitShas: listBranchCommits(sourceRef, cwd)
     };
   }
 }
 
-export function buildReleaseMergePlan(cwd) {
-  const sourceBranch = getCurrentBranchName(cwd);
-  if (sourceBranch === RELEASE_BRANCH) {
-    throw new Error(`Already on "${RELEASE_BRANCH}". Switch to a source branch before running --merge.`);
-  }
-
+function buildReleaseMergePlanForSource(sourceBranch, sourceRef, cwd) {
   const releaseExists = localBranchExists(RELEASE_BRANCH, cwd);
   const baseRef = releaseExists ? RELEASE_BRANCH : getDefaultBaseRef(cwd);
-  const { mergeBase, sourceCommitShas } = getReleaseTrackSourceCommitShas(releaseExists, baseRef, cwd);
+  const { mergeBase, sourceCommitShas } = getReleaseTrackSourceCommitShas(releaseExists, baseRef, sourceRef, cwd);
   const sourceCommits = sourceCommitShas.map((sha) => inspectCommit(sha, cwd));
   const releaseCommits = releaseExists ? listBranchCommits(RELEASE_BRANCH, cwd).map((sha) => inspectCommit(sha, cwd)) : [];
   const selection = selectReleaseWindows(sourceCommits, releaseCommits);
@@ -401,27 +458,22 @@ export function buildReleaseMergePlan(cwd) {
   };
 }
 
+export function buildReleaseMergePlan(cwd) {
+  const sourceBranch = getCurrentBranchName(cwd);
+  if (sourceBranch === RELEASE_BRANCH) {
+    throw new Error(`Already on "${RELEASE_BRANCH}". Switch to a source branch before running --merge.`);
+  }
+
+  return buildReleaseMergePlanForSource(sourceBranch, "HEAD", cwd);
+}
+
 export function buildReleaseTagPlan(cwd) {
   const sourceBranch = getCurrentBranchName(cwd);
   if (sourceBranch === RELEASE_BRANCH) {
     throw new Error(`Already on "${RELEASE_BRANCH}". Switch to a source branch before running --tag.`);
   }
 
-  const releaseExists = localBranchExists(RELEASE_BRANCH, cwd);
-  const baseRef = releaseExists ? RELEASE_BRANCH : getDefaultBaseRef(cwd);
-  const { mergeBase, sourceCommitShas } = getReleaseTrackSourceCommitShas(releaseExists, baseRef, cwd);
-  const sourceCommits = sourceCommitShas.map((sha) => inspectCommit(sha, cwd));
-  const selection = selectReleaseTags(sourceCommits, listTags(cwd));
-
-  return {
-    sourceBranch,
-    baseRef,
-    mergeBase,
-    releaseExists,
-    taggedVersions: selection.taggedVersions,
-    latestDetectedVersion: selection.latestDetectedVersion,
-    tags: selection.tags
-  };
+  return buildReleaseTagPlanForSource(sourceBranch, "HEAD", cwd);
 }
 
 export function finalizeReleaseMergePlan(plan) {
@@ -438,6 +490,126 @@ export function finalizeReleaseTagPlan(plan) {
   };
 }
 
+function findLatestReleaseVersion(releaseCommits) {
+  return releaseCommits
+    .map((commit) => commit.subject.match(RELEASE_SUBJECT_PATTERN)?.[1]?.trim() ?? null)
+    .filter(Boolean)
+    .at(-1) ?? null;
+}
+
+function findLatestTaggedReleaseVersion(releaseCommits, taggedVersions) {
+  const tagged = new Set(taggedVersions);
+  return releaseCommits
+    .map((commit) => commit.subject.match(RELEASE_SUBJECT_PATTERN)?.[1]?.trim() ?? null)
+    .filter((version) => version && tagged.has(version))
+    .at(-1) ?? null;
+}
+
+function buildDriftStatus(sourceRef, sourceLabel, releaseExists, cwd) {
+  if (!releaseExists) {
+    return {
+      hasReleaseBranch: false,
+      disconnectedHistory: false,
+      sourceOnlyCount: listBranchCommits(sourceRef, cwd).length,
+      releaseOnlyCount: 0,
+      summary: `Release branch "${RELEASE_BRANCH}" does not exist yet.`
+    };
+  }
+
+  try {
+    const mergeBase = getMergeBase(sourceRef, RELEASE_BRANCH, cwd);
+    const sourceOnlyCount = listCommitsAfter(mergeBase, sourceRef, cwd).length;
+    const releaseOnlyCount = listCommitsAfter(mergeBase, RELEASE_BRANCH, cwd).length;
+
+    return {
+      hasReleaseBranch: true,
+      disconnectedHistory: false,
+      mergeBase,
+      sourceOnlyCount,
+      releaseOnlyCount,
+      summary:
+        sourceOnlyCount === 0 && releaseOnlyCount === 0
+          ? `${sourceLabel} and ${RELEASE_BRANCH} point at the same history.`
+          : `${sourceLabel} has ${sourceOnlyCount} unique commit(s); ${RELEASE_BRANCH} has ${releaseOnlyCount} unique commit(s).`
+    };
+  } catch {
+    return {
+      hasReleaseBranch: true,
+      disconnectedHistory: true,
+      mergeBase: null,
+      sourceOnlyCount: listBranchCommits(sourceRef, cwd).length,
+      releaseOnlyCount: listBranchCommits(RELEASE_BRANCH, cwd).length,
+      summary: `${sourceLabel} and ${RELEASE_BRANCH} do not share a merge base. This is expected when the release branch is orphaned.`
+    };
+  }
+}
+
+function getNextRecommendedAction({ releaseExists, mergePlan, missingTagCount }) {
+  if (!releaseExists && mergePlan.windows.length > 0) {
+    return `Run \`gitxplain --merge --execute\` to create ${RELEASE_BRANCH} and promote ${mergePlan.windows.length} unreleased version(s).`;
+  }
+
+  if (!releaseExists && missingTagCount > 0) {
+    return `Run \`gitxplain --tag --execute\` to create ${missingTagCount} missing version tag(s) on the current branch.`;
+  }
+
+  if (!releaseExists) {
+    return `No ${RELEASE_BRANCH} branch exists yet, and no releasable version bumps were detected.`;
+  }
+
+  if (mergePlan.windows.length > 0 && missingTagCount > 0) {
+    return `Run \`gitxplain --merge --execute\` to update ${RELEASE_BRANCH}, and \`gitxplain --tag --execute\` to create ${missingTagCount} missing version tag(s).`;
+  }
+
+  if (mergePlan.windows.length > 0) {
+    return `Run \`gitxplain --merge --execute\` to promote ${mergePlan.windows.length} unreleased version(s) to ${RELEASE_BRANCH}.`;
+  }
+
+  if (missingTagCount > 0) {
+    return `Run \`gitxplain --tag --execute\` to create ${missingTagCount} missing version tag(s).`;
+  }
+
+  return "No action required. Release branch and tags are up to date.";
+}
+
+export function buildReleaseStatus(cwd) {
+  const currentBranch = getCurrentBranchName(cwd);
+  const releaseExists = localBranchExists(RELEASE_BRANCH, cwd);
+  const sourceBranch = currentBranch === RELEASE_BRANCH ? getDefaultBaseRef(cwd) : currentBranch;
+  const sourceRef = currentBranch === RELEASE_BRANCH ? sourceBranch : "HEAD";
+  const mergePlan = finalizeReleaseMergePlan(buildReleaseMergePlanForSource(sourceBranch, sourceRef, cwd));
+  const releaseCommits = releaseExists ? listBranchCommits(RELEASE_BRANCH, cwd).map((sha) => inspectCommit(sha, cwd)) : [];
+  const tagPlan = finalizeReleaseTagPlan(buildReleaseTagPlanForSource(sourceBranch, sourceRef, cwd));
+  const drift = buildDriftStatus(sourceRef, sourceBranch, releaseExists, cwd);
+  const missingTagVersions = tagPlan.tags.map((tag) => tag.tagName);
+  const unmergedVersions = mergePlan.windows.map((window) => window.version);
+
+  return {
+    sourceBranch,
+    sourceRef,
+    releaseBranch: RELEASE_BRANCH,
+    releaseExists,
+    currentBranch,
+    health:
+      !releaseExists || unmergedVersions.length > 0 || missingTagVersions.length > 0
+        ? "needs attention"
+        : "healthy",
+    latestSourceVersion: mergePlan.latestDetectedVersion,
+    latestReleaseVersion: findLatestReleaseVersion(releaseCommits),
+    latestTaggedVersion: tagPlan.latestTaggedVersion,
+    unmergedVersions,
+    missingTagVersions,
+    drift,
+    mergePlan,
+    tagPlan,
+    nextRecommendedAction: getNextRecommendedAction({
+      releaseExists,
+      mergePlan,
+      missingTagCount: missingTagVersions.length
+    })
+  };
+}
+
 export function formatReleaseMergePlan(plan) {
   const lines = [
     colorize("Release Merge Plan", ANSI.bold + ANSI.cyan),
@@ -504,6 +676,50 @@ export function formatReleaseTagPlan(plan) {
   return lines.join("\n");
 }
 
+export function formatReleaseStatus(status) {
+  const lines = [
+    colorize("Release Status", ANSI.bold + ANSI.cyan),
+    `${colorize("Source Branch:", ANSI.bold + ANSI.cyan)} ${status.sourceBranch}`,
+    `${colorize("Release Branch:", ANSI.bold + ANSI.cyan)} ${status.releaseBranch}`,
+    `${colorize("Current Branch:", ANSI.bold + ANSI.cyan)} ${status.currentBranch}`,
+    `${colorize("Overall:", ANSI.bold + ANSI.cyan)} ${status.health}`,
+    `${colorize("Latest Source Version:", ANSI.bold + ANSI.cyan)} ${status.latestSourceVersion ?? "none"}`,
+    `${colorize("Latest Release Version:", ANSI.bold + ANSI.cyan)} ${status.latestReleaseVersion ?? "none"}`,
+    `${colorize("Latest Tagged Version:", ANSI.bold + ANSI.cyan)} ${status.latestTaggedVersion ?? "none"}`
+  ];
+
+  lines.push("");
+  lines.push(colorize("Unmerged Version Bumps", ANSI.bold + ANSI.yellow));
+  if (status.unmergedVersions.length === 0) {
+    lines.push("none");
+  } else {
+    for (const window of status.mergePlan.windows) {
+      lines.push(`- ${window.version} (${window.startRef}..${window.endRef})`);
+    }
+  }
+
+  lines.push("");
+  lines.push(colorize("Missing Release Tags", ANSI.bold + ANSI.yellow));
+  if (status.missingTagVersions.length === 0) {
+    lines.push("none");
+  } else {
+    for (const tag of status.tagPlan.tags) {
+      lines.push(`- ${tag.tagName} -> ${tag.targetShortSha} ${tag.targetSubject}`);
+    }
+  }
+
+  lines.push("");
+  lines.push(colorize("Branch Drift", ANSI.bold + ANSI.yellow));
+  lines.push(status.drift.summary);
+  lines.push(`- Commits only on ${status.sourceBranch}: ${status.drift.sourceOnlyCount}`);
+  lines.push(`- Commits only on ${status.releaseBranch}: ${status.drift.releaseOnlyCount}`);
+
+  lines.push("");
+  lines.push(`${colorize("Next Recommended Action:", ANSI.bold + ANSI.cyan)} ${status.nextRecommendedAction}`);
+
+  return lines.join("\n");
+}
+
 function buildRecoveryMessage({ originalBranch, originalReleaseSha, createdReleaseBranch }) {
   const lines = ["Release promotion failed. Recovery steps:"];
 
@@ -518,6 +734,15 @@ function buildRecoveryMessage({ originalBranch, originalReleaseSha, createdRelea
   return lines.join("\n");
 }
 
+function buildReleaseCommitMetadata(ref, version, cwd) {
+  const metadata = getCommitMetadata(ref, cwd);
+
+  return {
+    ...metadata,
+    message: `release ${version}`
+  };
+}
+
 export function executeReleaseMerge(plan, cwd) {
   if (plan.windows.length === 0) {
     throw new Error("No unreleased release commits detected. Nothing to merge.");
@@ -530,36 +755,50 @@ export function executeReleaseMerge(plan, cwd) {
   const originalBranch = getCurrentBranchName(cwd);
   const releaseExists = localBranchExists(RELEASE_BRANCH, cwd);
   const originalReleaseSha = releaseExists ? resolveCommitSha(RELEASE_BRANCH, cwd) : null;
-  const originalHeadSha = getCurrentHeadSha(cwd);
-  const originalHeadFiles = releaseExists ? [] : listFilesInRef("HEAD", cwd);
+  let updatedReleaseSha = originalReleaseSha;
 
   try {
-    if (releaseExists) {
-      gitCheckout(RELEASE_BRANCH, cwd);
-    } else {
-      gitCheckoutOrphan(RELEASE_BRANCH, cwd);
-      gitRemoveCachedAll(cwd);
-      deletePaths(originalHeadFiles, cwd);
-    }
-
     for (const window of plan.windows) {
-      for (const commit of window.commits) {
-        gitCherryPickNoCommit(commit.sha, cwd);
+      const targetCommit = window.commits.at(-1);
+      if (targetCommit?.sha == null) {
+        throw new Error(`Unable to determine the source commit for release ${window.version}.`);
       }
 
-      gitCommit(`release ${window.version}`, cwd);
+      const treeSha = resolveTreeSha(targetCommit.sha, cwd);
+      const metadata = buildReleaseCommitMetadata(targetCommit.sha, window.version, cwd);
+      updatedReleaseSha = createCommitFromTree(
+        treeSha,
+        updatedReleaseSha == null ? [] : [updatedReleaseSha],
+        metadata,
+        cwd
+      );
+    }
+
+    if (updatedReleaseSha == null || updatedReleaseSha === originalReleaseSha) {
+      throw new Error("Release merge did not create any new commits.");
+    }
+
+    if (releaseExists) {
+      gitForceBranch(RELEASE_BRANCH, updatedReleaseSha, cwd);
+    } else {
+      gitCreateBranch(RELEASE_BRANCH, updatedReleaseSha, cwd);
     }
-  } catch (error) {
-    gitCherryPickAbort(cwd);
 
+    gitCheckout(RELEASE_BRANCH, cwd);
+  } catch (error) {
     try {
       if (releaseExists) {
-        gitResetHard(originalReleaseSha, cwd);
-        gitCheckout(originalBranch, cwd);
-      } else {
-        gitCheckout(originalBranch, cwd);
+        gitForceBranch(RELEASE_BRANCH, originalReleaseSha, cwd);
+      } else if (localBranchExists(RELEASE_BRANCH, cwd)) {
+        if (getCurrentBranchName(cwd) === RELEASE_BRANCH) {
+          gitCheckout(originalBranch, cwd);
+        }
         gitDeleteBranch(RELEASE_BRANCH, cwd);
       }
+
+      if (getCurrentBranchName(cwd) !== originalBranch) {
+        gitCheckout(originalBranch, cwd);
+      }
     } catch {
       // Preserve original failure and print recovery guidance below.
     }
@@ -574,11 +813,6 @@ export function executeReleaseMerge(plan, cwd) {
     );
     throw new Error("Release merge aborted.");
   }
-
-  const updatedReleaseSha = getCurrentHeadSha(cwd);
-  if (updatedReleaseSha === originalHeadSha) {
-    throw new Error("Release merge did not create any new commits.");
-  }
 }
 
 export function executeReleaseTagPlan(plan, cwd) {

package/cli/services/outputFormatter.js

@@ -138,18 +138,6 @@ function classifyTone(line) {
 }
 
 function colorizeByTone(line, tone) {
-  if (tone === "good") {
-    return colorize(line, ANSI.green);
-  }
-
-  if (tone === "bad") {
-    return colorize(line, ANSI.red);
-  }
-
-  if (tone === "neutral") {
-    return colorize(line, ANSI.yellow);
-  }
-
   return line;
 }
 
@@ -161,17 +149,7 @@ function formatBulletLine(line) {
   }
 
   const [, indent, marker, content] = match;
-  const tone = classifyTone(content);
-  const coloredMarker =
-    tone === "good"
-      ? colorize(marker, ANSI.green)
-      : tone === "bad"
-        ? colorize(marker, ANSI.red)
-        : tone === "neutral"
-          ? colorize(marker, ANSI.yellow)
-          : colorize(marker, ANSI.cyan);
-
-  return `${indent}${coloredMarker} ${colorizeByTone(content, tone)}`;
+  return `${indent}${colorize(marker, ANSI.cyan)} ${content}`;
 }
 
 function formatSeverityLine(line) {
@@ -179,19 +157,7 @@ function formatSeverityLine(line) {
     return null;
   }
 
-  if (/\blow\b/i.test(line)) {
-    return colorize(line, ANSI.green);
-  }
-
-  if (/\bmedium\b/i.test(line)) {
-    return colorize(line, ANSI.yellow);
-  }
-
-  if (/\bhigh\b/i.test(line)) {
-    return colorize(line, ANSI.red);
-  }
-
-  return colorize(line, ANSI.bold + ANSI.yellow);
+  return line;
 }
 
 function formatLine(line) {