gh-stack 0.17.0 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gh-stack",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Stacked PR manager for squash-merge workflows",
   "author": "Kiliman <kiliman@gmail.com>",
   "license": "MIT",

package/src/commands/restack.ts

@@ -15,7 +15,7 @@ import {
   writeMetadata,
 } from "../lib/metadata.ts";
 import { ensureMetadata, ensureCleanWorkingTree, ensureValidStack } from "../lib/safety.ts";
-import { takeSnapshot, findPreRewriteSha } from "../lib/snapshot.ts";
+import { takeSnapshot, findPreRewriteSha, findRecordedBaseTip } from "../lib/snapshot.ts";
 import { confirmAction } from "../lib/ui.ts";
 import type { StackMetadata } from "../types.ts";
 
@@ -345,6 +345,36 @@ async function handleFreshRestack(
  * the new base (the now-merged parent commits are dropped). Children then
  * restack onto the moved root via the normal chain logic.
  */
+// Resolve the boundary commit for re-rooting a stack's root off its old base:
+// the tip of the old base branch that the root was built on. Returns null when
+// it can't be determined safely, so the caller refuses rather than replaying
+// already-merged commits (issue #13).
+async function resolveRerootBoundary(
+  meta: StackMetadata,
+  oldBase: string,
+  root: string,
+): Promise<{ sha: string | null; source: string }> {
+  // 1. The live base branch tip — but only if the root still sits on it. If the
+  //    base was rewritten after the root forked, its current tip isn't the
+  //    boundary; fall through to the recorded tip.
+  if (await git.localBranchExists(oldBase)) {
+    const tip = await git.revParse(oldBase);
+    if (tip && (await git.isAncestor(tip, root))) {
+      return { sha: tip, source: "old-base branch tip" };
+    }
+  }
+
+  // 2. The tip recorded in a snapshot — survives the base branch being deleted
+  //    or rewritten by a squash-merge of the parent stack.
+  const recorded = await findRecordedBaseTip(meta, oldBase, root);
+  if (recorded) {
+    return { sha: recorded, source: "snapshot (old base branch gone/rewritten)" };
+  }
+
+  // 3. Unknown — refuse rather than replay merged commits.
+  return { sha: null, source: "" };
+}
+
 async function handleReroot(
   meta: StackMetadata,
   newBase: string,
@@ -383,20 +413,25 @@ async function handleReroot(
   }
 
   // The rebase base = the tip the root was built on (the old base branch).
-  // Prefer the live branch tip; fall back to merge-base if it's already gone.
-  let oldBaseTip: string | null = null;
-  let oldBaseSource = "old-base branch tip";
-  if (await git.localBranchExists(oldBase)) {
-    oldBaseTip = await git.revParse(oldBase);
-  } else {
-    oldBaseTip = await git.mergeBase(root, newBase);
-    oldBaseSource = "merge-base (old base branch is gone — verify the result)";
-  }
+  // Getting this right matters: rebasing from the wrong boundary replays the
+  // old base's commits onto the new base, and when the old base was a
+  // squash-merged parent stack those commits collide with their own squashed
+  // result on main — a self-inflicted conflict storm (issue #13). So we never
+  // guess with merge-base; we refuse instead.
+  const { sha: oldBaseTip, source: oldBaseSource } = await resolveRerootBoundary(
+    meta,
+    oldBase,
+    root,
+  );
 
   if (!oldBaseTip) {
     p.cancel(
-      `Could not determine the old base for ${pc.yellow(root)}.\n\n  Re-root manually with: ${pc.green(
-        `git rebase --onto ${newBase} <old-base> ${root}`,
+      `Can't safely re-root ${pc.yellow(stackName)}: its old base ${pc.yellow(
+        oldBase,
+      )} is gone (or was rewritten) and no snapshot recorded where ${pc.yellow(
+        root,
+      )} forked off it.\n\n  Rebasing from the merge-base would replay already-merged commits and conflict.\n  Re-root manually once you know the old base tip:\n    ${pc.green(
+        `git rebase --onto ${newBase} <old-base-tip> ${root}`,
       )}`,
     );
     process.exit(1);

package/src/lib/snapshot.ts

@@ -7,7 +7,7 @@
 // stack's only record while a busy sibling stack churned (see issue #13).
 import type { StackMetadata, Snapshot } from "../types.ts";
 import * as git from "./git.ts";
-import { getOrderedBranches } from "./metadata.ts";
+import { getOrderedBranches, stackBase } from "./metadata.ts";
 import { snapshotsDir } from "./paths.ts";
 import { mkdir, readdir, unlink } from "node:fs/promises";
 
@@ -86,6 +86,48 @@ export async function findPreRewriteSha(
   return null;
 }
 
+/**
+ * Find the recorded tip of a stack's (non-main) base branch — the boundary a
+ * re-root needs to replay only the dependent stack's own commits.
+ *
+ * Walks snapshots newest-first for one whose recorded `baseBranch` matches and
+ * whose recorded `baseTip` is still an ancestor of `rootBranch` (the dependent
+ * stack's root). That tip is exactly where the root forked off the base, so
+ * `git rebase --onto <new-base> <baseTip> <root>` drops the already-merged
+ * prefix instead of replaying it.
+ *
+ * Unlike `findPreRewriteSha`, this does NOT require the base branch to still
+ * exist locally — that's the whole point: after a squash-merge deletes the base
+ * branch, its tip survives only in these snapshots. The ancestor-of-root check
+ * rejects stale candidates (an older base tip the root no longer sits on).
+ *
+ * Returns null if no snapshot recorded this base, or none is still an ancestor
+ * of the root (in which case the caller must refuse rather than guess).
+ */
+export async function findRecordedBaseTip(
+  meta: StackMetadata,
+  baseBranch: string,
+  rootBranch: string,
+): Promise<string | null> {
+  if (!meta.snapshots || meta.snapshots.length === 0) return null;
+
+  let rootTip: string;
+  try {
+    rootTip = await git.revParse(rootBranch);
+  } catch {
+    return null;
+  }
+
+  // Walk newest → oldest; first base tip that the root still sits on wins.
+  for (let i = meta.snapshots.length - 1; i >= 0; i--) {
+    const snap = meta.snapshots[i]!;
+    if (snap.baseBranch !== baseBranch || !snap.baseTip) continue;
+    if (await git.isAncestor(snap.baseTip, rootTip)) return snap.baseTip;
+  }
+
+  return null;
+}
+
 // Snapshot files are named `<sortable-timestamp>__<encoded-stack>.json`. The
 // timestamp keeps colons/dots out of the filename (Windows-safe) while sorting
 // chronologically as a plain string; the stack name is URL-encoded so `/` in a
@@ -161,6 +203,20 @@ export async function takeSnapshot(
     stack: stackName,
   };
 
+  // For a non-main base (a stack stacked on top of another stack), record the
+  // base branch's tip too — kept out of `branches` so `undo` won't reset a
+  // branch that belongs to the parent stack. This is the boundary a later
+  // re-root needs if the base branch is deleted by a squash-merge (issue #13).
+  const base = stackBase(stack);
+  if (base !== "main" && base !== "master") {
+    try {
+      snapshot.baseTip = await git.revParse(base);
+      snapshot.baseBranch = base;
+    } catch {
+      // Base branch already gone locally — nothing to record.
+    }
+  }
+
   await writeSnapshotFile(snapshot);
 
   // Keep in-memory array consistent for callers that read it afterward.

package/src/types.ts

@@ -50,6 +50,13 @@ export interface Snapshot {
   operation: string; // "restack" | "merge" | "sync" | "remove"
   branches: Record<string, string>; // branch name -> commit SHA
   stack?: string; // owning stack (v3: drives per-stack retention + file naming)
+  // For a stack with a non-main base: the base branch and its tip at snapshot
+  // time. Recorded separately from `branches` (which `undo` force-resets) so a
+  // dependent stack can re-root onto main after its base branch is deleted by a
+  // squash-merge — without that recorded boundary the reroot would replay the
+  // already-merged commits and conflict (issue #13).
+  baseBranch?: string;
+  baseTip?: string;
 }
 
 // Resume state for restack --resume