gitxplain 0.1.3 → 0.1.6

package/cli/services/gitService.js

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import os from "node:os";
 import { mkdtempSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
@@ -87,6 +87,33 @@ export function runGitCommandUnchecked(args, cwd) {
   }
 }
 
+export function listGitSubcommands() {
+  const output = execFileSync("git", ["help", "-a"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+
+  return new Set(
+    output
+      .split("\n")
+      .map((line) => line.match(/^\s{3}([a-z0-9][a-z0-9-]*)\s{2,}/i)?.[1] ?? null)
+      .filter(Boolean)
+  );
+}
+
+export function runNativeGitPassthrough(args, cwd) {
+  const result = spawnSync("git", args, {
+    cwd,
+    stdio: "inherit"
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result.status ?? 0;
+}
+
 export function isGitRepository(cwd) {
   try {
     return runGitCommand(["rev-parse", "--is-inside-work-tree"], cwd) === "true";
@@ -231,6 +258,21 @@ export function gitPush(cwd, remote = null, branch = null, runner = runGitComman
   return runner(args, cwd);
 }
 
+export function gitPull(cwd, remote = null, branch = null, runner = runGitCommand) {
+  const args = ["pull"];
+
+  if (remote) {
+    args.push(remote);
+  }
+
+  if (branch) {
+    args.push(branch);
+  }
+
+  return runner(args, cwd);
+}
+
+
 export function gitCreateAnnotatedTag(tagName, ref, message, cwd) {
   return runGitCommand(["tag", "-a", tagName, ref, "-m", message], cwd);
 }
@@ -438,8 +480,8 @@ export function isAncestorCommit(ancestorRef, descendantRef, cwd) {
   throw new Error(result.stderr || "Unable to determine commit ancestry.");
 }
 
-export function gitResetHard(ref, cwd) {
-  return runGitCommand(["reset", "--hard", ref], cwd);
+export function gitResetHard(ref, cwd, runner = runGitCommand) {
+  return runner(["reset", "--hard", ref], cwd);
 }
 
 export function gitCherryPickNoCommit(ref, cwd) {

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";
@@ -315,15 +311,8 @@ export function selectReleaseWindows(sourceCommits, releaseCommits = []) {
   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
   };
@@ -353,37 +342,63 @@ export function selectReleaseTags(sourceCommits, existingTagNames = []) {
   };
 }
 
-function getReleaseTrackSourceCommitShas(releaseExists, baseRef, cwd) {
+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,6 +416,15 @@ 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) {
@@ -409,9 +433,14 @@ export function buildReleaseTagPlan(cwd) {
 
   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));
+  const { mergeBase, sourceCommitShas } = getReleaseTrackSourceCommitShas(releaseExists, baseRef, "HEAD", cwd);
+  const existingTagNames = listTags(cwd);
+  const selection = releaseExists
+    ? selectReleaseTagsFromReleaseCommits(
+        listBranchCommits(RELEASE_BRANCH, cwd).map((sha) => inspectCommit(sha, cwd)),
+        existingTagNames
+      )
+    : selectReleaseTags(sourceCommits.map((sha) => inspectCommit(sha, cwd)), existingTagNames);
 
   return {
     sourceBranch,
@@ -438,6 +467,132 @@ 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) {
+    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\` first, then \`gitxplain tag --execute\` to finish tagging release commits.`;
+  }
+
+  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 release 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 tagSelection = releaseExists
+    ? selectReleaseTagsFromReleaseCommits(releaseCommits, listTags(cwd))
+    : { tags: [], taggedVersions: [], latestDetectedVersion: null };
+  const drift = buildDriftStatus(sourceRef, sourceBranch, releaseExists, cwd);
+  const missingTagVersions = tagSelection.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: findLatestTaggedReleaseVersion(releaseCommits, tagSelection.taggedVersions),
+    unmergedVersions,
+    missingTagVersions,
+    drift,
+    mergePlan,
+    tagPlan: finalizeReleaseTagPlan({
+      sourceBranch,
+      baseRef: mergePlan.baseRef,
+      mergeBase: mergePlan.mergeBase,
+      releaseExists,
+      taggedVersions: tagSelection.taggedVersions,
+      latestDetectedVersion: tagSelection.latestDetectedVersion,
+      tags: tagSelection.tags
+    }),
+    nextRecommendedAction: getNextRecommendedAction({
+      releaseExists,
+      mergePlan,
+      missingTagCount: missingTagVersions.length
+    })
+  };
+}
+
 export function formatReleaseMergePlan(plan) {
   const lines = [
     colorize("Release Merge Plan", ANSI.bold + ANSI.cyan),
@@ -504,6 +659,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 +717,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 +738,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
+      );
     }
-  } catch (error) {
-    gitCherryPickAbort(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);
+    }
+
+    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 +796,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) {