@biffo/cli 0.68.0 → 0.68.2

package/dist/index.js

@@ -516,6 +516,26 @@ var GitAdapter = class {
     const { stdout } = await execa("git", ["status", "--porcelain"], { cwd });
     return stdout.trim().length > 0;
   }
+  /** Best-effort fetch of the tracking remote, so the ahead/behind check below
+   * compares against reality rather than a stale local ref (#394). Never throws:
+   * offline or a missing remote must not block an upgrade on its own — the
+   * ahead/behind check that follows simply works from whatever is local. */
+  async fetch(cwd, remote = "origin") {
+    await execa("git", ["fetch", "--quiet", remote], { cwd, reject: false });
+  }
+  /** HEAD's position relative to its upstream. `hasUpstream` is false when the
+   * branch tracks nothing (or HEAD is detached), in which case currency cannot
+   * be established and ahead/behind are 0 (#394). */
+  async aheadBehind(cwd) {
+    const { stdout, exitCode } = await execa(
+      "git",
+      ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"],
+      { cwd, reject: false }
+    );
+    if (exitCode !== 0) return { ahead: 0, behind: 0, hasUpstream: false };
+    const [ahead, behind] = stdout.trim().split(/\s+/).map((n) => Number.parseInt(n, 10));
+    return { ahead: ahead ?? 0, behind: behind ?? 0, hasUpstream: true };
+  }
   /** The fetch URL of a remote (default "origin"). */
   async getRemoteUrl(cwd, remote = "origin") {
     const { stdout } = await execa("git", ["remote", "get-url", remote], { cwd });
@@ -2031,6 +2051,9 @@ var coreUpgradeCommand = new Command3("upgrade").description("Three-way-merge te
 ).option("--apply", "Apply the plan on a new branch and open a PR (default: dry run)").option("--allow-conflicts", "With --apply, open the PR even if some files conflict").option(
   "--acknowledge-breaking",
   "With --apply, proceed even though this upgrade crosses a documented breaking change"
+).option(
+  "--allow-dirty",
+  "Compute the plan even with uncommitted changes in the instance tree (they become part of the merge)"
 ).option("--base <branch>", "Base branch for the PR (defaults to the repo\u2019s default branch)").option("--remote <name>", "Git remote to push to and open the PR on (default: origin)").action(
   async (options) => {
     const cwd = options.cwd ? resolve3(options.cwd) : process.cwd();
@@ -2038,7 +2061,8 @@ var coreUpgradeCommand = new Command3("upgrade").description("Three-way-merge te
       cwd,
       apply: options.apply ?? false,
       allowConflicts: options.allowConflicts ?? false,
-      acknowledgeBreaking: options.acknowledgeBreaking ?? false
+      acknowledgeBreaking: options.acknowledgeBreaking ?? false,
+      allowDirty: options.allowDirty ?? false
     };
     if (options.templateRepo) runOptions.templateRepo = resolve3(options.templateRepo);
     if (options.to) runOptions.toVersion = options.to;
@@ -2083,7 +2107,30 @@ async function runCoreUpgrade(options, deps = defaultDeps()) {
     for (const c of cleanups) c();
   }
 }
+async function checkInstanceCurrency(git, cwd, allowDirty) {
+  if (!await git.isGitRepo(cwd)) return;
+  const branch = await git.currentBranch(cwd);
+  if (branch === "HEAD" || branch === "") {
+    throw new Error(
+      `${cwd} has a detached HEAD, so the tree the plan would merge as "ours" has no branch identity. Check out the integration branch first (#394).`
+    );
+  }
+  await git.fetch(cwd);
+  const { ahead, behind, hasUpstream } = await git.aheadBehind(cwd);
+  if (hasUpstream && behind > 0) {
+    const diverged = ahead > 0 ? ` and ${ahead} ahead (diverged)` : "";
+    throw new Error(
+      `${cwd} is ${behind} commit(s) behind its upstream${diverged}. The plan would merge onto a stale tree and propose reintroducing superseded content. Run \`git pull\` first, or fix the divergence, then re-run (#394).`
+    );
+  }
+  if (!allowDirty && await git.hasUncommittedChanges(cwd)) {
+    throw new Error(
+      `${cwd} has uncommitted changes, which would silently become part of the merge's "ours" side. Commit or stash them, or pass --allow-dirty to accept them deliberately (#394).`
+    );
+  }
+}
 async function runCoreUpgradeResolved(options, deps, cleanups) {
+  await checkInstanceCurrency(deps.git, options.cwd, options.allowDirty ?? false);
   const materialize = deps.materialize ?? materializeTemplateAtTag;
   const templateRepo = options.templateRepo ? resolve3(options.templateRepo) : resolveTemplateRoot({ guidance: MISSING_TEMPLATE_ROOT_GUIDANCE2 });
   const instanceVersion = readInstanceCoreVersion(options.cwd);
@@ -2181,9 +2228,6 @@ async function applyAndOpenPr(options, deps, plan, migrations, fromVersion, toVe
   if (!await git.isGitRepo(options.cwd)) {
     throw new Error(`${options.cwd} is not a git repository.`);
   }
-  if (await git.hasUncommittedChanges(options.cwd)) {
-    throw new Error("The working tree has uncommitted changes. Commit or stash them first.");
-  }
   const branch = upgradeBranchName(fromVersion, toVersion);
   log.step(1, 4, `Creating branch ${branch}`);
   await git.createBranch(options.cwd, branch);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biffo/cli",
-  "version": "0.68.0",
+  "version": "0.68.2",
   "description": "Biffo project scaffolding CLI",
   "license": "MIT",
   "type": "module",