gh-stack 0.18.0 → 0.19.1

package/src/commands/sync.ts

@@ -7,28 +7,34 @@ import {
   findStackForBranch,
   getOrderedBranches,
   removeBranchFromStack,
-  saveRestackState,
   stackBase,
   writeMetadata,
 } from "../lib/metadata.ts";
 import { ensureMetadata, ensureCleanWorkingTree, ensureValidStack } from "../lib/safety.ts";
+import { resolveFlag } from "../lib/config.ts";
 import { takeSnapshot } from "../lib/snapshot.ts";
-import { confirmAction } from "../lib/ui.ts";
+import { guardRemoteContent } from "../lib/remote-guard.ts";
 import { getPrInfo } from "../lib/github.ts";
-import { planMerges, advanceNewBottom, type BranchReview } from "../lib/advance.ts";
+import { planMerges, advanceNewBottom, type BranchReview, type MergePlan } from "../lib/advance.ts";
 import type { StackMetadata } from "../types.ts";
-import { wantsNoPush } from "./restack.ts";
+import restack, {
+  notePendingRun,
+  refuseRebaseInProgress,
+  resolvePush,
+  routePendingRun,
+  syncChain,
+} from "./restack.ts";
 
 export default async function sync(args: string[]): Promise<void> {
   const dryRun = args.includes("--dry-run");
-  const noPush = wantsNoPush(args);
+  const fresh = args.includes("--fresh");
 
   if (args.includes("--help")) {
     console.log(`
 gh-stack sync — Sync base with main + restack all
 
 USAGE
-  gh-stack sync [--dry-run] [--no-push]
+  gh-stack sync [--dry-run] [--no-push | --push] [--fresh]
 
 Fetches latest main, rebases the base branch onto main,
 then restacks all children. Equivalent to running restack
@@ -37,68 +43,96 @@ with the base branch included.
 OPTIONS
   --dry-run   Show what would happen without executing
   --no-push   Rebase locally only — never push or retarget PRs
-              (also GH_STACK_NO_PUSH=1). Wins over --yes for pushes
+              (also GH_STACK_NO_PUSH=1, or \`[restack] push = false\` in
+              config; see gh-stack config). Wins over --yes for pushes
+  --push      Push even when a config default or env var says not to
+  --resume    Same as \`gh-stack restack --resume\`
+  --fresh     Discard an interrupted restack/sync instead of resuming it
+  --overwrite-remote
+              Rewrite branches even though origin has commits they lack.
+              Those commits are dropped from origin
+
+If an interrupted restack or sync is pending, sync asks whether to resume it
+(with --yes it resumes) rather than starting over on top of it.
+
+Before rewriting anything, sync stops if a branch's copy on origin has
+commits the local branch never had (e.g. the squash commit \`merge --collapse\`
+adds on GitHub). Pull or cherry-pick them first; see \`gh-stack restack --help\`.
 `);
     return;
   }
 
+  // Only explicit push flags (and --overwrite-remote) carry over to a resume:
+  // it otherwise keeps the push decision of the run it resumes.
+  const pushFlags = args.filter(
+    (a) => a === "--push" || a === "--no-push" || a === "--overwrite-remote",
+  );
+  const resumeRun = () => restack(["--resume", ...pushFlags]);
+  if (args.includes("--resume")) {
+    await resumeRun();
+    return;
+  }
+
   // Reject if a git rebase is already in progress. Letting sync run on top
   // of a half-finished rebase produces deeply confusing state — make the
   // user finish or abort it first.
   if (await git.isRebaseInProgress()) {
-    p.cancel(
-      `Git rebase already in progress.\n\n  Finish or abort it first:\n    ${pc.green("git rebase --continue")}\n    ${pc.red("git rebase --abort")}\n\n  Then re-run ${pc.green("gh-stack sync")}.`,
-    );
-    process.exit(1);
+    await refuseRebaseInProgress("sync");
   }
 
-  await ensureCleanWorkingTree();
-
-  const meta = await ensureMetadata();
-  const currentBranch = await git.currentBranch();
-  const stackName = findStackForBranch(meta, currentBranch);
-
-  if (!stackName) {
-    p.cancel(
-      `Branch ${pc.blue(currentBranch)} is not in any stack.\n\n  Track it first (no push/PR):\n    ${pc.green("gh-stack add")}\n\n  Or open its PR with:\n    ${pc.green("gh-stack submit")}`,
-    );
-    process.exit(1);
+  // An interrupted restack/sync is pending: resume it rather than starting a
+  // new sync on top of it (#29).
+  if (dryRun) {
+    await notePendingRun();
+  } else if (
+    (await routePendingRun("sync", {
+      fresh,
+      preflight: async () => void (await syncPreconditions(args)),
+    })) === "resume"
+  ) {
+    await resumeRun();
+    return;
   }
 
+  const push = await resolvePush(args);
+  const noPush = !push.value;
+  const { meta, stackName } = await syncPreconditions(args);
   let stack = meta.stacks[stackName]!;
-  await ensureValidStack(meta, stackName);
   let ordered = getOrderedBranches(stack);
 
-  if (ordered.length === 0) {
-    p.cancel("No branches in this stack");
-    process.exit(1);
-  }
-
   p.intro(pc.cyan("Git Stack Sync"));
 
   // Find the root branch (whose parent is the stack's base)
   const base = stackBase(stack);
-  const baseIsTrunk = base === "main" || base === "master";
-
-  // sync only makes sense for trunk-rooted stacks — it fetches main and
-  // rebases onto it. A split stack is rooted on a branch in another stack, so
-  // syncing it means restacking onto that base (handled by `restack`), or
-  // re-rooting onto main once the parent stack has merged.
-  if (!baseIsTrunk) {
-    p.cancel(
-      `${pc.yellow(stackName)} is based on ${pc.yellow(base)}, not main — sync doesn't apply.\n\n` +
-        `  • Parent moved? Restack onto it:   ${pc.green("gh-stack restack")}\n` +
-        `  • Parent stack merged to main?     ${pc.green("gh-stack restack --onto main")}`,
-    );
-    process.exit(1);
-  }
 
   // Catch up to reality first: if the bottom PR(s) already landed on the trunk
   // outside gh-stack (e.g. the GitHub web UI), the stack metadata still lists
   // them. A plain rebase onto main would then replay their now-squashed commits
   // and conflict — so advance past them (re-rooting the survivor onto main with
   // `--onto`) before the normal sync runs. (#20)
-  const advance = await advanceMergedBottoms(meta, stackName, base, dryRun, noPush);
+  const merged = await findMergedBottoms(meta, stackName);
+
+  // Nothing is rewritten yet: stop here if origin holds commits the local
+  // branches lack, e.g. a collapse's squash commit on the base branch (#28).
+  // Bottoms whose PRs already merged are skipped: the advance drops them
+  // rather than rewriting them, and after `merge --approved` they're exactly
+  // where the collapse's squash commits live.
+  const mergedBranches = new Set(merged.steps.map((step) => step.branch));
+  const verified = await guardRemoteContent(
+    meta,
+    ordered.filter((b) => !mergedBranches.has(b)),
+    { command: "sync", overwrite: args.includes("--overwrite-remote"), dryRun },
+  );
+
+  const advance = await advanceMergedBottoms(
+    meta,
+    stackName,
+    base,
+    dryRun,
+    noPush,
+    merged,
+    verified,
+  );
   if (advance.drained) {
     p.outro(pc.green("Bottom PR(s) already merged — stack fully drained & archived."));
     return;
@@ -156,82 +190,55 @@ OPTIONS
   // need to find when restacking children. (See resolveRestackBoundary.)
   await takeSnapshot(meta, stackName, "sync");
 
-  // Step 1: Rebase base branch onto main
-  console.log();
-  console.log(pc.cyan("━".repeat(40)));
-  console.log(`${pc.blue("Step 1:")} Rebase ${pc.yellow(baseBranch)} onto main`);
-  console.log(pc.cyan("━".repeat(40)));
-  console.log();
-
-  // Check if already up to date
-  if (await git.isAncestor("origin/main", baseBranch)) {
-    p.log.success(`${baseBranch} is already up to date with main`);
-  } else if (dryRun) {
-    p.log.warn(`[DRY RUN] Would rebase ${baseBranch} onto origin/main`);
-  } else {
-    const confirmed = await confirmAction(`Rebase ${pc.yellow(baseBranch)} onto origin/main?`);
-    if (!confirmed) {
-      p.cancel("Cancelled");
-      process.exit(0);
-    }
+  // Rebase the root onto main, push it, then restack every branch above it —
+  // one run, saved after every step, so `restack --resume` can finish it.
+  await syncChain(meta, stackName, ordered, { trunkRef: "origin/main", push, verified });
+}
 
-    p.log.info(`Checking out ${pc.yellow(baseBranch)}...`);
-    await git.checkout(baseBranch);
-
-    // Save restack state BEFORE rebasing so --resume can find it.
-    // The chain is the full ordered list — base branch at index 0,
-    // so resume knows where we were and can continue with children.
-    await saveRestackState({
-      current_index: 0,
-      stack_name: stackName,
-      chain: ordered,
-      ...(noPush && { no_push: true }),
-    });
-
-    p.log.info("Rebasing onto origin/main...");
-    const success = await git.rebase("origin/main");
-
-    if (!success) {
-      console.log();
-      p.log.error("Rebase conflict — resolve and run:");
-      console.log(`  ${pc.green("git rebase --continue")}`);
-      console.log(`  ${pc.green("gh-stack restack --resume")}`);
-      process.exit(2);
-    }
+/**
+ * What a new sync needs before it changes anything: a clean tree, a valid push
+ * setting, and the current branch in a trunk-rooted stack. Also the preflight
+ * for discarding an interrupted run, so a sync that would refuse leaves that
+ * run intact.
+ */
+async function syncPreconditions(
+  args: string[],
+): Promise<{ meta: StackMetadata; stackName: string }> {
+  await resolveFlag("restack.push", args); // a bad setting stops here
+  await ensureCleanWorkingTree();
 
-    p.log.success("Base branch rebased onto main");
+  const meta = await ensureMetadata();
+  const currentBranch = await git.currentBranch();
+  const stackName = findStackForBranch(meta, currentBranch);
 
-    // Prompt to push base
-    if (noPush) {
-      p.log.info(`Not pushing ${pc.yellow(baseBranch)} (--no-push) — it's now ahead of origin`);
-    } else {
-      await promptForcePush(baseBranch);
-    }
+  if (!stackName) {
+    p.cancel(
+      `Branch ${pc.blue(currentBranch)} is not in any stack.\n\n  Track it first (no push/PR):\n    ${pc.green("gh-stack add")}\n\n  Or open its PR with:\n    ${pc.green("gh-stack submit")}`,
+    );
+    process.exit(1);
   }
 
-  // Step 2: Restack children
-  const children = ordered.slice(1);
-
-  if (children.length === 0) {
-    p.outro(pc.green("Sync complete! (no children to restack)"));
-    return;
+  const stack = meta.stacks[stackName]!;
+  await ensureValidStack(meta, stackName);
+  if (getOrderedBranches(stack).length === 0) {
+    p.cancel("No branches in this stack");
+    process.exit(1);
   }
 
-  console.log();
-  console.log(pc.cyan("━".repeat(40)));
-  console.log(`${pc.blue("Step 2:")} Restack ${children.length} child branch(es)`);
-  console.log(pc.cyan("━".repeat(40)));
-  console.log();
-
-  // Delegate to restack for the remaining branches
-  // We import and run restack in --rebase mode effectively
-  const { default: restack } = await import("./restack.ts");
-
-  // Switch to first child and run restack
-  if (children.length > 0) {
-    await git.checkout(children[0]!);
-    await restack([...(dryRun ? ["--dry-run"] : []), ...(noPush ? ["--no-push"] : [])]);
+  // sync only makes sense for trunk-rooted stacks — it fetches main and
+  // rebases onto it. A split stack is rooted on a branch in another stack, so
+  // syncing it means restacking onto that base (handled by `restack`), or
+  // re-rooting onto main once the parent stack has merged.
+  const base = stackBase(stack);
+  if (base !== "main" && base !== "master") {
+    p.cancel(
+      `${pc.yellow(stackName)} is based on ${pc.yellow(base)}, not main — sync doesn't apply.\n\n` +
+        `  • Parent moved? Restack onto it:   ${pc.green("gh-stack restack")}\n` +
+        `  • Parent stack merged to main?     ${pc.green("gh-stack restack --onto main")}`,
+    );
+    process.exit(1);
   }
+  return { meta, stackName };
 }
 
 /** Result of the merged-bottom catch-up pass. */
@@ -253,20 +260,15 @@ interface AdvanceOutcome {
  * Returns what happened so the caller can re-derive the root or short-circuit.
  * In dry-run it reports and makes no changes.
  */
-async function advanceMergedBottoms(
-  meta: StackMetadata,
-  stackName: string,
-  trunk: string,
-  dryRun: boolean,
-  noPush: boolean,
-): Promise<AdvanceOutcome> {
+/**
+ * The contiguous bottom branches whose PRs already merged (outside gh-stack,
+ * or the base of a `merge --approved`), walking bottom-up and stopping at the
+ * first that isn't.
+ */
+async function findMergedBottoms(meta: StackMetadata, stackName: string): Promise<MergePlan> {
   const stack = meta.stacks[stackName]!;
-  const ordered = getOrderedBranches(stack);
-
-  // Walk bottom-up gathering PR state; stop at the first branch that isn't a
-  // merged PR (only contiguous merged bottoms can be advanced past).
   const reviews: BranchReview[] = [];
-  for (const branch of ordered) {
+  for (const branch of getOrderedBranches(stack)) {
     const pr = stack.branches[branch]?.pr ?? null;
     let prState: string | null = null;
     if (pr != null) {
@@ -276,8 +278,21 @@ async function advanceMergedBottoms(
     reviews.push({ branch, pr, prState, reviewDecision: null });
     if (prState !== "MERGED") break;
   }
+  return planMerges(reviews, { approveAndMerge: false });
+}
+
+async function advanceMergedBottoms(
+  meta: StackMetadata,
+  stackName: string,
+  trunk: string,
+  dryRun: boolean,
+  noPush: boolean,
+  plan: MergePlan,
+  verified: Map<string, string>,
+): Promise<AdvanceOutcome> {
+  const stack = meta.stacks[stackName]!;
+  const ordered = getOrderedBranches(stack);
 
-  const plan = planMerges(reviews, { approveAndMerge: false });
   if (plan.steps.length === 0) {
     return { detected: false, advanced: false, drained: false };
   }
@@ -316,14 +331,17 @@ async function advanceMergedBottoms(
         targetRef,
         recordedBase: trunk,
         push: !noPush,
+        expect: verified.get(child),
       });
       if (!res.ok) {
         console.log();
         if (res.reason === "conflict") {
           p.log.error(`Rebase conflict re-rooting ${pc.yellow(child)} onto ${trunk}.`);
-          console.log(`  Resolve it, then finish the restack:`);
+          console.log(`  Resolve it, then finish the sync:`);
           console.log(`    ${pc.green("git rebase --continue")}`);
-          console.log(`    ${pc.green("gh-stack restack")}`);
+          console.log(
+            `    ${pc.green("gh-stack sync")}   ${pc.dim(`(picks up the re-rooted ${child}; not restack, which would put it back on ${mergedBranch})`)}`,
+          );
         } else {
           p.log.error(
             `Could not determine a safe rebase base for ${pc.yellow(child)} (${res.reason}).`,
@@ -358,33 +376,3 @@ async function advanceMergedBottoms(
 
   return { detected: true, advanced: true, drained: false };
 }
-
-async function promptForcePush(branch: string): Promise<void> {
-  if (branch === "main" || branch === "master") return;
-  if (!(await git.remoteBranchExists(branch))) return;
-
-  const localSha = await git.revParse(branch);
-  let remoteSha: string;
-  try {
-    remoteSha = await git.revParse(`origin/${branch}`);
-  } catch {
-    return;
-  }
-
-  if (localSha === remoteSha) return;
-
-  console.log();
-  p.log.info(`${pc.yellow("⚠")} ${branch} is out of sync with remote`);
-
-  const confirmed = await confirmAction("Push with --force-with-lease?");
-  if (confirmed) {
-    const ok = await git.forcePushWithLease(branch);
-    if (ok) {
-      p.log.success("Pushed successfully");
-    } else {
-      p.log.error("Push failed");
-    }
-  } else {
-    p.log.warn("Skipping push");
-  }
-}

package/src/commands/undo.ts

@@ -4,6 +4,7 @@ import * as git from "../lib/git.ts";
 import pc from "picocolors";
 import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";
 import { getLastSnapshot, popSnapshot } from "../lib/snapshot.ts";
+import { clearRestackState, loadRestackState } from "../lib/metadata.ts";
 import { confirmAction } from "../lib/ui.ts";
 import { $ } from "bun";
 
@@ -72,5 +73,15 @@ a destructive operation (restack, merge, sync, remove).
   // Pop the snapshot
   await popSnapshot(meta);
 
+  // An unfinished run on this stack was rewriting the branches just restored;
+  // resuming it would push the restored tips as if they were its results.
+  const run = await loadRestackState().catch(() => null); // an unusable state is left for --fresh
+  if (run && !run.finished_at && run.stack_name === snapshot.stack) {
+    await clearRestackState();
+    p.log.info(
+      `Discarded the interrupted ${run.command}'s saved state (its branches were restored).`,
+    );
+  }
+
   p.outro(pc.green("Undo complete!"));
 }

package/src/commands/update-prs.ts

@@ -162,6 +162,7 @@ export function numberedTitle(title: string, position: number, total: number): s
 
 export interface TitleResult {
   updated: number; // PR titles we edited on GitHub
+  updatedBranches: string[]; // …and their branches, for per-branch reporting (submit --json)
   dirty: boolean; // metadata mutated (cached prTitle changed) — caller persists
 }
 
@@ -211,21 +212,24 @@ export async function reconcilePrTitles(
 
   const items = ordered.map((name) => {
     const bm = stack.branches[name]!;
-    return { pr: bm.pr, prTitle: bm.prTitle, override: overrides[name], bm };
+    return { name, pr: bm.pr, prTitle: bm.prTitle, override: overrides[name], bm };
   });
 
-  const oks = await mapLimit(planTitleEdits(items), 8, async ({ item, desired }) => {
+  const edits = planTitleEdits(items);
+  const oks = await mapLimit(edits, 8, async ({ item, desired }) => {
     const ok = await updatePrTitle(item.pr!, desired);
     if (ok) item.bm.prTitle = desired;
     return ok;
   });
 
-  const updated = oks.filter(Boolean).length;
-  return { updated, dirty: dirtyBackfill || updated > 0 };
+  const updatedBranches = edits.filter((_, i) => oks[i]).map(({ item }) => item.name);
+  const updated = updatedBranches.length;
+  return { updated, updatedBranches, dirty: dirtyBackfill || updated > 0 };
 }
 
 export interface VizResult {
   updated: number; // PRs whose description we PATCHed
+  updatedBranches: string[]; // …and their branches, for per-branch reporting (submit --json)
   unchanged: number; // PRs skipped because their rendered block was identical
   skipped: number; // branches with no PR
   skippedBranches: string[]; // …and their names, so callers can say which
@@ -306,10 +310,11 @@ export async function refreshStackViz(
     return ok;
   });
 
-  const updated = oks.filter(Boolean).length;
+  const updatedBranches = toUpdate.filter((_, i) => oks[i]).map((plan) => plan.info.branch);
+  const updated = updatedBranches.length;
   if (updated > 0) dirty = true;
 
-  return { updated, unchanged, skipped, skippedBranches, dirty };
+  return { updated, updatedBranches, unchanged, skipped, skippedBranches, dirty };
 }
 
 export default async function updatePrs(args: string[]): Promise<void> {