gh-stack 0.2.3 → 0.3.1

package/README.md

@@ -129,11 +129,12 @@ sync [--dry-run]
     Fetch main, rebase the base branch onto main, then restack all
     children. Creates tags for ALL branches before any rebasing starts.
 
-merge [--dry-run]
-    Squash-merge the stack top-down locally (PR3 → PR2 → PR1),
-    then rebases onto main, closes intermediate PRs, pushes the
-    base branch, and enables GitHub auto-merge (squash). Archives
-    the stack on completion.
+merge [--dry-run] [-d|--delete-branch]
+    Squash-merge the stack top-down via GitHub (PR3 → PR2 → PR1),
+    then enables auto-merge for the base PR into main. All merges
+    happen on GitHub so PRs show as "Merged", Linear tickets close
+    automatically, and GitHub Actions fire normally. Skips already-
+    merged PRs (safe to re-run). Waits for GitHub between merges.
 
 delete [<branch>]
     Remove a branch from the stack and re-parent its children.

package/package.json

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

package/src/commands/merge.ts

@@ -1,35 +1,70 @@
-// gh-stack merge — Local squash-merge top-down
-// From reference/gh-stack-merge-design.md
+// gh-stack merge — Squash-merge stack top-down via GitHub
 import * as p from "@clack/prompts";
 import pc from "picocolors";
+import { $ } from "bun";
 import * as git from "../lib/git.ts";
 import { findStackForBranch, getOrderedBranches, writeMetadata } from "../lib/metadata.ts";
-import { ensureMetadata, ensureCleanWorkingTree, ensureValidStack } from "../lib/safety.ts";
+import { ensureMetadata, ensureValidStack } from "../lib/safety.ts";
 import { takeSnapshot } from "../lib/snapshot.ts";
-import { $ } from "bun";
-import { closePr } from "../lib/github.ts";
+import { getPrMergeState } from "../lib/github.ts";
 import { confirmAction } from "../lib/ui.ts";
 
+const MAX_RETRIES = 12;
+const RETRY_DELAY_MS = 5000;
+
+/**
+ * Wait for a PR to become mergeable after a previous merge lands.
+ * GitHub needs time to process the new commit on the target branch.
+ */
+async function waitForMergeable(
+  prNumber: number,
+  spinner: ReturnType<typeof p.spinner>,
+): Promise<boolean> {
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    const state = await getPrMergeState(prNumber);
+    if (!state) return false;
+
+    if (state.state === "MERGED") return true; // Already merged
+    if (state.state === "CLOSED") return false;
+
+    // "CLEAN", "HAS_HOOKS", "UNSTABLE" are all mergeable states
+    if (state.mergeable === "MERGEABLE" && state.mergeStateStatus !== "BLOCKED") {
+      return true;
+    }
+
+    spinner.message(`Waiting for PR #${prNumber} to be ready... (${attempt}/${MAX_RETRIES})`);
+    await Bun.sleep(RETRY_DELAY_MS);
+  }
+  return false;
+}
+
 export default async function merge(args: string[]): Promise<void> {
   const dryRun = args.includes("--dry-run");
+  const deleteFlag = args.includes("--delete-branch") || args.includes("-d");
 
   if (args.includes("--help")) {
     console.log(`
-gh-stack merge — Local squash-merge top-down
+gh-stack merge — Squash-merge stack via GitHub
 
 USAGE
-  gh-stack merge [--dry-run]
+  gh-stack merge [--dry-run] [-d|--delete-branch]
 
-Squash-merges the stack from top to bottom locally:
-  PR3 → PR2 → PR1, then optionally rebases PR1 onto main.
+Squash-merges the stack from top to bottom via GitHub:
+  PR3 → squash into PR2, PR2 → squash into PR1, PR1 → auto-merge into main.
 
-This keeps all commits local (avoiding orphaned squash commits).
+All merges happen on GitHub, so PRs show as "Merged", Linear tickets
+close automatically, and all GitHub Actions/webhooks fire normally.
+
+Skips PRs that are already merged (safe to re-run after partial failure).
+Waits for GitHub to process between merges if needed.
+
+OPTIONS
+  -d, --delete-branch  Delete remote branches after merging
+      --dry-run        Show what would happen without doing anything
 `);
     return;
   }
 
-  await ensureCleanWorkingTree();
-
   const meta = await ensureMetadata();
   const currentBranch = await git.currentBranch();
   const stackName = findStackForBranch(meta, currentBranch);
@@ -44,26 +79,51 @@ This keeps all commits local (avoiding orphaned squash commits).
   const ordered = getOrderedBranches(stack);
 
   if (ordered.length <= 1) {
-    p.log.info("Single branch stack — nothing to merge down.");
-    p.log.info("Just merge via GitHub as normal.");
+    // Single branch — just enable auto-merge
+    const basePr = stack.branches[ordered[0]!]?.pr;
+    if (basePr) {
+      p.log.info("Single branch stack — enabling auto-merge on GitHub.");
+      if (!dryRun) {
+        try {
+          await $`gh pr merge ${basePr} --squash --auto`.quiet();
+          p.log.success(`Auto-merge enabled for PR #${basePr}`);
+        } catch {
+          p.log.info(`Enable manually: ${pc.dim(`gh pr merge ${basePr} --squash --auto`)}`);
+        }
+      }
+    } else {
+      p.log.info("Single branch stack — merge via GitHub as normal.");
+    }
     return;
   }
 
-  p.intro(pc.cyan("Git Stack Merge (Top-Down)"));
-
+  p.intro(pc.cyan("Stack Merge (via GitHub)"));
   p.log.info(`Stack: ${pc.yellow(stackName)}`);
   console.log();
 
-  // Show the merge plan: from top to bottom
+  // Check PR states and build the merge plan
   const reversed = ordered.toReversed();
+  const baseBranch = ordered[0]!;
+  const basePr = stack.branches[baseBranch]?.pr;
+
   console.log(`  ${pc.bold("Merge plan:")}`);
   for (let i = 0; i < reversed.length - 1; i++) {
     const child = reversed[i]!;
     const parent = stack.branches[child]?.parent || "???";
     const childPr = stack.branches[child]?.pr;
-    console.log(`    ${pc.yellow(child)}${childPr ? ` (#${childPr})` : ""} → ${pc.blue(parent)}`);
+
+    // Check if already merged
+    const prState = childPr ? await getPrMergeState(childPr) : null;
+    const isMerged = prState?.state === "MERGED";
+    const mergedLabel = isMerged ? pc.dim(" (already merged)") : "";
+
+    console.log(
+      `    ${pc.yellow(child)}${childPr ? ` (#${childPr})` : ""} → squash into ${pc.blue(parent)}${mergedLabel}`,
+    );
   }
-  console.log(`    ${pc.blue(ordered[0]!)} → ${pc.green("main")} (via GitHub)`);
+  console.log(
+    `    ${pc.blue(baseBranch)}${basePr ? ` (#${basePr})` : ""} → ${pc.green("main")} (auto-merge)`,
+  );
   console.log();
 
   if (dryRun) {
@@ -71,7 +131,16 @@ This keeps all commits local (avoiding orphaned squash commits).
     return;
   }
 
-  const confirmed = await confirmAction("Merge stack top-down?");
+  // Check all PRs in stack have PR numbers
+  const missingPrs = ordered.filter((b) => !stack.branches[b]?.pr);
+  if (missingPrs.length > 0) {
+    p.cancel(
+      `Missing PR numbers for: ${missingPrs.join(", ")}\n\n  Run ${pc.green("gh-stack submit")} first to create PRs.`,
+    );
+    process.exit(1);
+  }
+
+  const confirmed = await confirmAction("Squash-merge stack top-down via GitHub?");
   if (!confirmed) {
     p.cancel("Cancelled");
     process.exit(0);
@@ -80,82 +149,105 @@ This keeps all commits local (avoiding orphaned squash commits).
   // Take snapshot
   await takeSnapshot(meta, stackName, "merge");
 
-  // Merge top-down: for each branch from top to bottom (skip the base)
+  // Merge top-down via GitHub: for each PR from top, squash-merge into parent
   for (let i = 0; i < reversed.length - 1; i++) {
     const childBranch = reversed[i]!;
-    const parentBranch = stack.branches[childBranch]?.parent;
-    if (!parentBranch || parentBranch === "main") continue;
+    const childPrNum = stack.branches[childBranch]!.pr!;
+    const parentBranch = stack.branches[childBranch]!.parent;
 
-    const childPr = stack.branches[childBranch]?.pr;
-    const childTitle = stack.branches[childBranch]?.description || childBranch;
+    if (parentBranch === "main" || parentBranch === "master") continue;
+
+    // Check if already merged (skip)
+    const prState = await getPrMergeState(childPrNum);
+    if (prState?.state === "MERGED") {
+      p.log.info(`${pc.dim("✓")} PR #${childPrNum} already merged — skipping`);
+      continue;
+    }
 
     console.log();
     console.log(pc.cyan("━".repeat(40)));
-    console.log(`${pc.blue("Merge:")} ${pc.yellow(childBranch)} → ${pc.blue(parentBranch)}`);
+    console.log(
+      `${pc.blue("Merge:")} PR #${childPrNum} ${pc.yellow(childBranch)} → ${pc.blue(parentBranch)}`,
+    );
     console.log(pc.cyan("━".repeat(40)));
-    console.log();
-
-    // Checkout parent
-    p.log.info(`Checking out ${pc.yellow(parentBranch)}...`);
-    await git.checkout(parentBranch);
 
-    // Squash merge child
-    p.log.info(`Squash-merging ${pc.yellow(childBranch)}...`);
-    const success = await git.mergeSquash(childBranch);
+    // Wait for PR to be mergeable (GitHub may need time after previous merge)
+    const s = p.spinner();
+    s.start(`Checking PR #${childPrNum} is ready to merge...`);
+    const ready = await waitForMergeable(childPrNum, s);
 
-    if (!success) {
-      p.log.error("Merge conflict — resolve and try again");
+    if (!ready) {
+      s.stop(pc.red(`PR #${childPrNum} is not mergeable`));
+      p.log.info("Check the PR on GitHub for merge conflicts or required checks.");
+      p.log.info("Re-run merge to continue from where you left off.");
       process.exit(2);
     }
 
-    // Commit
-    const commitMsg = childPr ? `squash: ${childTitle} (#${childPr})` : `squash: ${childTitle}`;
+    s.message(`Squash-merging PR #${childPrNum} via GitHub...`);
 
-    await git.commit(commitMsg);
-    p.log.success(`Merged ${childBranch} into ${parentBranch}`);
-  }
-
-  // Optionally rebase base onto main
-  console.log();
-  const baseBranch = ordered[0]!;
-  const rebaseConfirmed = await confirmAction(`Rebase ${pc.yellow(baseBranch)} onto latest main?`);
+    const ghArgs = ["pr", "merge", String(childPrNum), "--squash"];
+    if (deleteFlag) ghArgs.push("--delete-branch");
 
-  if (rebaseConfirmed) {
-    p.log.info("Fetching latest main...");
-    await git.fetchMain();
+    const proc = Bun.spawn(["gh", ...ghArgs], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
 
-    p.log.info(`Checking out ${pc.yellow(baseBranch)}...`);
-    await git.checkout(baseBranch);
-
-    const success = await git.rebase("origin/main");
-    if (success) {
-      p.log.success("Rebased onto main");
+    if (exitCode === 0) {
+      s.stop(`Merged PR #${childPrNum} into ${pc.blue(parentBranch)}`);
     } else {
-      p.log.error("Rebase conflict — resolve manually");
+      s.stop(pc.red(`Failed to merge PR #${childPrNum}`));
+      p.log.error(stderr.trim());
+      p.log.info("Re-run merge to continue from where you left off.");
       process.exit(2);
     }
   }
 
-  // Close intermediate PRs
+  // Base PR → enable auto-merge into main
   console.log();
-  const closePrs = await confirmAction("Close intermediate PRs on GitHub?");
+  console.log(pc.cyan("━".repeat(40)));
+  console.log(
+    `${pc.blue("Auto-merge:")} PR #${basePr} ${pc.yellow(baseBranch)} → ${pc.green("main")}`,
+  );
+  console.log(pc.cyan("━".repeat(40)));
 
-  if (closePrs) {
-    const basePr = stack.branches[ordered[0]!]?.pr;
-    for (let i = 1; i < ordered.length; i++) {
-      const prNum = stack.branches[ordered[i]!]?.pr;
-      if (prNum) {
-        const comment = basePr
-          ? `Merged locally into base PR #${basePr}. See the base PR for the full stack.`
-          : "Merged locally into base PR.";
-        const ok = await closePr(prNum, comment);
-        if (ok) {
-          p.log.success(`Closed PR #${prNum}`);
-        } else {
-          p.log.warn(`Could not close PR #${prNum}`);
-        }
-      }
-    }
+  const autoSpinner = p.spinner();
+
+  // Wait for base PR to be ready (may need time after last intermediate merge)
+  autoSpinner.start(`Waiting for PR #${basePr} to be ready...`);
+  await waitForMergeable(basePr!, autoSpinner);
+
+  autoSpinner.message(`Enabling auto-merge for PR #${basePr}...`);
+
+  try {
+    const ghArgs = ["pr", "merge", String(basePr), "--squash", "--auto"];
+    if (deleteFlag) ghArgs.push("--delete-branch");
+
+    const proc = Bun.spawn(["gh", ...ghArgs], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+
+    autoSpinner.stop(`Auto-merge enabled for PR #${basePr} — will merge into main when CI passes`);
+  } catch {
+    autoSpinner.stop(pc.yellow(`Could not enable auto-merge for PR #${basePr}`));
+    p.log.info(`Enable manually: ${pc.dim(`gh pr merge ${basePr} --squash --auto`)}`);
+  }
+
+  // Update local main and clean up
+  console.log();
+  const pullSpinner = p.spinner();
+  pullSpinner.start("Syncing local branches...");
+  try {
+    await $`git fetch origin`.quiet();
+    await git.checkout("main");
+    await $`git pull origin main`.quiet();
+    pullSpinner.stop("Local branches synced");
+  } catch {
+    pullSpinner.stop(pc.dim("Could not sync local branches — run git pull manually"));
   }
 
   // Archive the stack
@@ -168,40 +260,5 @@ This keeps all commits local (avoiding orphaned squash commits).
   }
   await writeMetadata(meta);
 
-  // Push base branch and enable auto-merge
-  console.log();
-  const pushAndMerge = await confirmAction(
-    `Push ${pc.yellow(baseBranch)} and enable auto-merge (squash)?`,
-  );
-
-  if (pushAndMerge) {
-    const pushSpinner = p.spinner();
-    pushSpinner.start(`Pushing ${pc.blue(baseBranch)}...`);
-    const pushOk = await git.forcePushWithLease(baseBranch);
-    if (pushOk) {
-      pushSpinner.stop(`Pushed ${pc.blue(baseBranch)}`);
-    } else {
-      pushSpinner.stop(pc.red(`Failed to push ${baseBranch}`));
-      p.outro(
-        pc.yellow("Stack merged locally but push failed. Push manually and merge via GitHub."),
-      );
-      return;
-    }
-
-    // Enable auto-merge via gh CLI
-    const basePrNum = stack.branches[baseBranch]?.pr;
-    if (basePrNum) {
-      const mergeSpinner = p.spinner();
-      mergeSpinner.start("Enabling auto-merge...");
-      try {
-        await $`gh pr merge ${basePrNum} --squash --auto`.quiet();
-        mergeSpinner.stop(`Auto-merge enabled for PR #${basePrNum} — will merge when CI passes`);
-      } catch {
-        mergeSpinner.stop(pc.yellow(`Could not enable auto-merge for PR #${basePrNum}`));
-        p.log.info(`Enable manually: ${pc.dim(`gh pr merge ${basePrNum} --squash --auto`)}`);
-      }
-    }
-  }
-
   p.outro(pc.green("Stack merge complete! Stack archived."));
 }

package/src/lib/github.ts

@@ -124,6 +124,21 @@ export async function getPrBody(prNumber: number): Promise<string | null> {
   }
 }
 
+/**
+ * Get the merge state of a PR.
+ * Returns { state, mergeable, mergeStateStatus }.
+ */
+export async function getPrMergeState(
+  prNumber: number,
+): Promise<{ state: string; mergeable: string; mergeStateStatus: string } | null> {
+  try {
+    const result = await $`gh pr view ${prNumber} --json state,mergeable,mergeStateStatus`.text();
+    return JSON.parse(result.trim());
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Close a PR with a comment.
  */