gh-stack 0.3.1 → 0.7.0

package/src/commands/restack.ts

@@ -1,6 +1,6 @@
 // gh-stack restack — Rebase children onto updated parents
 // Port of reference/gh-stack-sync.sh — the most critical command
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import {
@@ -9,6 +9,7 @@ import {
   saveRestackState,
   loadRestackState,
   clearRestackState,
+  readMetadata,
 } from "../lib/metadata.ts";
 import {
   ensureMetadata,
@@ -16,7 +17,7 @@ import {
   ensureNotMain,
   ensureValidStack,
 } from "../lib/safety.ts";
-import { takeSnapshot } from "../lib/snapshot.ts";
+import { takeSnapshot, findPreRewriteSha } from "../lib/snapshot.ts";
 import { confirmAction } from "../lib/ui.ts";
 import type { StackMetadata } from "../types.ts";
 
@@ -36,7 +37,7 @@ OPTIONS
   --yes, -y   Skip confirmations (auto-accept all rebases and pushes)
   --resume    Resume after resolving rebase conflicts
   --dry-run   Show what would happen without executing
-  --verbose   Show diagnostic info (tag vs merge-base)
+  --verbose   Show diagnostic info (snapshot vs merge-base)
 
 EXAMPLES
   gh-stack restack              Interactive (prompts before each rebase)
@@ -49,6 +50,16 @@ ALIASES
     return;
   }
 
+  // Reject if a git rebase is already in progress (unless we're resuming).
+  // Letting commands run on top of a half-finished rebase produces deeply
+  // confusing state — better to make the user finish or abort first.
+  if (!resume && (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 restack")} (or ${pc.green("gh-stack restack --resume")} to continue).`,
+    );
+    process.exit(1);
+  }
+
   // Ensure clean working tree (unless resuming)
   if (!resume) {
     await ensureCleanWorkingTree();
@@ -59,6 +70,10 @@ ALIASES
 
   p.intro(pc.cyan("Git Stack Restack"));
 
+  // Silently drop any leftover temp tags from older versions of gh-stack
+  // (pre-snapshot). Keeps users upgrading from <0.4 from seeing stale tags.
+  await git.deleteTagsMatching(git.STACK_SYNC_TAG_GLOB);
+
   if (resume) {
     await handleResume(meta, rebasedBranches, verbose);
   } else {
@@ -76,9 +91,6 @@ ALIASES
     }
   }
 
-  // Cleanup tags
-  await git.deleteTagsMatching(git.STACK_SYNC_TAG_GLOB);
-
   p.outro(pc.green("Stack Restack Complete!"));
 }
 
@@ -137,38 +149,8 @@ async function handleResume(
   const currentIndex = state.current_index + 1;
 
   if (currentIndex < chain.length) {
-    // Ensure temporary tags exist for remaining branches.
-    // If sync created them upfront (correct!), they'll already be here.
-    // If not (e.g., old state file), we create them as a fallback —
-    // but NOTE: tags created after parent was rebased may be inaccurate.
-    p.log.info("Checking base tags for remaining branches...");
-    for (let i = currentIndex; i < chain.length; i++) {
-      const branch = chain[i]!;
-      const parent = stack.branches[branch]?.parent;
-      if (!parent) continue;
-
-      const tagName = git.tempBaseTagName(branch);
-      if (await git.tagExists(tagName)) {
-        const tagSha = await git.revParse(tagName);
-        console.log(
-          `  ${pc.green("✓")} Pre-existing tag for ${branch}: ${pc.cyan(tagName)} (${tagSha.slice(0, 8)})`,
-        );
-      } else {
-        // Fallback: create tag now (may be inaccurate if parent already rebased)
-        p.log.warn(`No pre-existing tag for ${branch} — creating from current merge-base`);
-        const mb = await git.mergeBase(branch, parent);
-        if (mb) {
-          await git.createTag(tagName, mb);
-          console.log(
-            `  ${pc.yellow("⚠")} Tagged base for ${branch}: ${pc.cyan(tagName)} (${mb.slice(0, 8)})`,
-          );
-        }
-      }
-    }
-    console.log();
+    await processChain(meta, stackName, chain, currentIndex, rebasedBranches, false, verbose);
   }
-
-  await processChain(meta, stackName, chain, currentIndex, rebasedBranches, false, verbose);
 }
 
 async function handleFreshRestack(
@@ -190,9 +172,6 @@ async function handleFreshRestack(
   const stack = meta.stacks[stackName]!;
   await ensureValidStack(meta, stackName);
 
-  // Check for stale tags from previous runs
-  await handleStaleTags();
-
   // Build the rebase chain from current branch
   p.log.info("Building rebase chain...");
   let chain = buildRebaseChain(stack, currentBranch);
@@ -242,25 +221,10 @@ async function handleFreshRestack(
   }
 
   if (!dryRun) {
-    // Take snapshot before destructive operation
+    // Take snapshot before destructive operation. This preserves the current
+    // tip of every branch so subsequent restacks (after a parent is rewritten)
+    // can find the correct rebase base.
     await takeSnapshot(meta, stackName, "restack");
-
-    // Create temporary tags for stable base references
-    p.log.info("Creating temporary base tags...");
-    for (const branch of chain) {
-      const parent = stack.branches[branch]?.parent;
-      if (!parent) continue;
-
-      const mb = await git.mergeBase(branch, parent);
-      if (mb) {
-        const tagName = git.tempBaseTagName(branch);
-        await git.createTag(tagName, mb);
-        console.log(
-          `  ${pc.green("✓")} Tagged base for ${branch}: ${pc.cyan(tagName)} (${mb.slice(0, 8)})`,
-        );
-      }
-    }
-    console.log();
   }
 
   // Process the chain
@@ -313,6 +277,49 @@ async function processChain(
       continue;
     }
 
+    // Resolve the rebase base.
+    //
+    //   Strategy:
+    //     1. Look for a recent snapshot where the parent's recorded tip is no
+    //        longer an ancestor of the parent's current tip AND is still an
+    //        ancestor of the child. That recorded SHA is the orphaned
+    //        old-parent tip — exactly the rebase base we need.
+    //     2. Fall back to `merge-base(branch, parent)` if no snapshot tells us
+    //        the parent was rewritten (typical case: parent only had commits
+    //        appended, not rebased).
+    //
+    //   The child-ancestry check (issue #5) prevents stale snapshots from
+    //   older sessions — where the child has already been rebased past the
+    //   recorded point — from being used as a rebase base.
+    //
+    //   Re-read metadata fresh because previous iterations of this loop may
+    //   have updated snapshots.
+    const freshMeta = (await readMetadata()) ?? meta;
+    const oldBaseFromSnapshot = await findPreRewriteSha(freshMeta, parent, branch);
+    const oldBaseFromMergeBase = await git.mergeBase(branch, parent);
+    const oldBase = oldBaseFromSnapshot ?? oldBaseFromMergeBase;
+
+    if (verbose) {
+      console.log();
+      console.log(pc.yellow("  Diagnostic: base resolution"));
+      console.log(
+        `  ${pc.cyan("Snapshot pre-rewrite tip:")} ${oldBaseFromSnapshot?.slice(0, 8) ?? "(none)"}`,
+      );
+      console.log(
+        `  ${pc.cyan("Current merge-base:")}      ${oldBaseFromMergeBase?.slice(0, 8) ?? "(none)"}`,
+      );
+      if (
+        oldBaseFromSnapshot &&
+        oldBaseFromMergeBase &&
+        oldBaseFromSnapshot !== oldBaseFromMergeBase
+      ) {
+        console.log(
+          `  ${pc.yellow("⚠ Parent was rewritten")} — using snapshot base (would have replayed parent commits otherwise)`,
+        );
+      }
+      console.log();
+    }
+
     // Checkout the branch
     p.log.info(`Checking out ${pc.yellow(branch)}...`);
     await git.checkout(branch);
@@ -324,49 +331,22 @@ async function processChain(
       chain,
     });
 
-    // Use temporary tag as stable base reference
-    const tagName = git.tempBaseTagName(branch);
     let success: boolean;
-
-    if (await git.tagExists(tagName)) {
-      const taggedBase = await git.revParse(tagName);
-      p.log.info(`Using tagged base: ${pc.cyan(tagName)} (${taggedBase.slice(0, 8)})`);
+    if (oldBase) {
+      const sourceLabel = oldBaseFromSnapshot ? "snapshot" : "merge-base";
+      p.log.info(
+        `Rebasing onto ${pc.yellow(parent)} (base: ${oldBase.slice(0, 8)} from ${sourceLabel})`,
+      );
 
       if (verbose) {
-        const currentMb = await git.mergeBase(branch, parent);
-        console.log();
-        console.log(pc.yellow("  Diagnostic: Tag vs Merge-Base"));
-        console.log(`  ${pc.cyan("Tagged base:")}      ${taggedBase.slice(0, 8)}`);
-        if (currentMb) {
-          console.log(`  ${pc.cyan("Current merge-base:")} ${currentMb.slice(0, 8)}`);
-          if (taggedBase === currentMb) {
-            console.log(`  ${pc.green("✓ Same")} — Parent hasn't been updated`);
-          } else {
-            console.log(`  ${pc.yellow("⚠ Different")} — Parent was rebased (tag protects us!)`);
-          }
-        }
-        console.log();
-      }
-
-      p.log.info(`Rebasing onto ${pc.yellow(parent)}...`);
-      const count = await git.commitCount(taggedBase, branch);
-      if (verbose) {
+        const count = await git.commitCount(oldBase, branch);
         console.log(`  Moving ${count} commit(s)`);
       }
 
-      success = await git.rebaseOnto(parent, tagName, branch);
+      success = await git.rebaseOnto(parent, oldBase, branch);
     } else {
-      // Fallback to merge-base
-      p.log.warn("Tag not found, calculating merge-base...");
-      const oldBase = await git.mergeBase(branch, parent);
-
-      if (!oldBase) {
-        p.log.warn("Could not find merge-base, using simple rebase");
-        success = await git.rebase(parent);
-      } else {
-        p.log.info(`Found merge-base: ${oldBase.slice(0, 8)}`);
-        success = await git.rebaseOnto(parent, oldBase, branch);
-      }
+      p.log.warn("Could not determine rebase base — using simple rebase");
+      success = await git.rebase(parent);
     }
 
     if (success) {
@@ -435,50 +415,3 @@ async function promptPush(branch: string): Promise<void> {
     p.log.warn("Skipping push (you'll need to push manually)");
   }
 }
-
-async function handleStaleTags(): Promise<void> {
-  try {
-    const { $ } = await import("bun");
-    const result = await $`git tag -l ${git.STACK_SYNC_TAG_GLOB}`.text();
-    const tags = result.trim();
-    if (!tags) return;
-
-    p.log.warn(`Found stale ${git.STACK_SYNC_TAG_GLOB} tags from a previous run`);
-    console.log();
-
-    const action = await p.select({
-      message: "What would you like to do?",
-      options: [
-        {
-          value: "clean",
-          label: "Clean up tags and start fresh",
-        },
-        {
-          value: "resume",
-          label: "Resume from previous sync (--resume)",
-        },
-        { value: "abort", label: "Abort (keep tags, exit)" },
-      ],
-    });
-
-    if (p.isCancel(action) || action === "abort") {
-      p.cancel("Aborted");
-      process.exit(0);
-    }
-
-    if (action === "clean") {
-      p.log.info("Cleaning up stale tags...");
-      await git.deleteTagsMatching(git.STACK_SYNC_TAG_GLOB);
-      p.log.success("Tags cleaned");
-    }
-
-    if (action === "resume") {
-      // Re-run with --resume flag
-      const { default: restack } = await import("./restack.ts");
-      await restack(["--resume"]);
-      process.exit(0);
-    }
-  } catch {
-    // No stale tags — carry on
-  }
-}

package/src/commands/submit.ts

@@ -1,12 +1,18 @@
 // gh-stack submit — Push branches and create/update PRs
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import pc from "picocolors";
 import { $ } from "bun";
 import * as git from "../lib/git.ts";
-import { findStackForBranch, getOrderedBranches, writeMetadata } from "../lib/metadata.ts";
-import { ensureMetadata } from "../lib/safety.ts";
+import {
+  findStackForBranch,
+  getOrderedBranches,
+  readMetadata,
+  writeMetadata,
+} from "../lib/metadata.ts";
 import { isAutoYes } from "../lib/ui.ts";
+import type { StackMetadata } from "../types.ts";
 import { getPrNumber, getPrInfo, getPrBody, updatePrBody, reviewEmoji } from "../lib/github.ts";
+import { resolveOrCreateStack } from "../lib/chain.ts";
 import { buildStackViz } from "./update-prs.ts";
 
 const HELP = `
@@ -19,6 +25,11 @@ Pushes all branches from trunk to the current branch, creating PRs
 for branches that don't have them and updating stack visualization
 in all PR descriptions. Idempotent — safe to run repeatedly.
 
+Self-healing: if the current branch isn't tracked in a stack yet,
+submit auto-detects the branch chain from trunk → current, registers
+(or reconciles into) a stack, then pushes + creates PRs for the whole
+chain. You never need to run \`gh-stack init\` first.
+
 OPTIONS
   -d, --draft          Create new PRs as drafts
   -n, --no-edit        Don't prompt for PR titles (auto-generate from branch name)
@@ -110,13 +121,50 @@ export default async function submit(args: string[]): Promise<void> {
 
   const noEdit = args.includes("--no-edit") || args.includes("-n") || isAutoYes() || !!titleFlag;
 
-  const meta = await ensureMetadata();
+  // Read metadata, or start with an empty in-memory store. submit self-heals,
+  // so a missing metadata file is fine — we'll build the stack from local
+  // branch ancestry and persist it (unless --dry-run).
+  const meta: StackMetadata = (await readMetadata()) ?? {
+    version: 2,
+    current_stack: null,
+    stacks: {},
+  };
   const branch = await git.currentBranch();
-  const stackName = findStackForBranch(meta, branch);
+  let stackName = findStackForBranch(meta, branch);
 
+  // ── Self-heal: branch isn't in any stack ──
+  // Reconstruct the stack from local branch ancestry so the end state is
+  // always stack registered + branches pushed + PRs created — no need to
+  // remember to run `gh-stack init` first.
+  let heal: { trunk: string; chain: string[]; created: boolean; added: string[] } | null = null;
   if (!stackName) {
-    p.cancel(`Branch ${pc.blue(branch)} not found in any stack`);
-    process.exit(1);
+    const trunk = await git.trunkBranch();
+
+    if (branch === trunk || branch === "main" || branch === "master") {
+      p.cancel(
+        `You're on ${pc.blue(branch)} — nothing to submit.\n\n  Checkout a feature branch first.`,
+      );
+      process.exit(1);
+    }
+
+    let resolution;
+    try {
+      resolution = await resolveOrCreateStack(meta, branch, trunk);
+    } catch (err) {
+      p.cancel((err as Error).message);
+      process.exit(1);
+    }
+
+    stackName = resolution.stackName;
+    heal = {
+      trunk,
+      chain: resolution.chain,
+      created: resolution.created,
+      added: resolution.addedBranches,
+    };
+
+    // Persist the reconstructed/updated stack before pushing (skip on dry-run)
+    if (!dryRun) await writeMetadata(meta);
   }
 
   const stack = meta.stacks[stackName]!;
@@ -127,6 +175,34 @@ export default async function submit(args: string[]): Promise<void> {
   const scope = currentIndex >= 0 ? ordered.slice(0, currentIndex + 1) : ordered;
 
   p.intro(pc.cyan("Submit Stack"));
+
+  // Report self-heal results (stack creation / reconciliation + detected chain)
+  if (heal) {
+    if (heal.created) {
+      p.log.success(
+        `No stack found — created ${pc.yellow(stackName)} from ${heal.chain.length} local branch(es)`,
+      );
+    } else if (heal.added.length > 0) {
+      p.log.success(
+        `Reconciled ${heal.added.length} untracked branch(es) into ${pc.yellow(stackName)}`,
+      );
+    }
+
+    console.log();
+    console.log(`  ${pc.dim(heal.trunk)}`);
+    for (let i = 0; i < heal.chain.length; i++) {
+      const b = heal.chain[i]!;
+      const isLast = i === heal.chain.length - 1;
+      const tree = isLast ? "  ┗━" : "  ┣━";
+      const isNew = heal.added.includes(b);
+      const label = b === branch ? pc.yellow(b) + pc.dim(" (current)") : b;
+      const tag = isNew ? pc.green(" +") : "";
+      console.log(`${tree} ${label}${tag}`);
+      if (!isLast) console.log("  ┃");
+    }
+    console.log();
+  }
+
   p.log.info(`Stack: ${pc.yellow(stackName)}`);
   p.log.info(
     `Scope: ${scope.length} of ${ordered.length} branch(es) (downstack from ${pc.blue(branch)})`,

package/src/commands/sync.ts

@@ -1,5 +1,5 @@
 // gh-stack sync — Fetch main, rebase base branch onto main, then restack all
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import { findStackForBranch, getOrderedBranches, saveRestackState } from "../lib/metadata.ts";
@@ -24,6 +24,16 @@ with the base branch included.
     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 ensureCleanWorkingTree();
 
   const meta = await ensureMetadata();
@@ -83,31 +93,11 @@ with the base branch included.
   await git.fetchMain();
   fetchSpinner.stop("Fetched latest main");
 
-  // Take snapshot
+  // Take snapshot BEFORE rebasing. This records every branch's pre-rebase
+  // tip — including the orphaned base-branch tip that restack will later
+  // need to find when restacking children. (See findPreRewriteSha.)
   await takeSnapshot(meta, stackName, "sync");
 
-  // Create temporary tags for ALL branches BEFORE any rebasing starts.
-  // This is critical: after rebasing PR1, `git merge-base PR2 PR1` returns
-  // wrong results. Tags capture the true divergence points while history
-  // is still intact.
-  p.log.info("Creating temporary base tags for all branches...");
-  for (const branch of ordered) {
-    const parent = stack.branches[branch]?.parent;
-    if (!parent) continue;
-
-    // For the base branch, the "parent" is main — tag its merge-base with main
-    const parentRef = parent === "main" ? "origin/main" : parent;
-    const mb = await git.mergeBase(branch, parentRef);
-    if (mb) {
-      const tagName = git.tempBaseTagName(branch);
-      await git.createTag(tagName, mb);
-      console.log(
-        `  ${pc.green("✓")} Tagged base for ${branch}: ${pc.cyan(tagName)} (${mb.slice(0, 8)})`,
-      );
-    }
-  }
-  console.log();
-
   // Step 1: Rebase base branch onto main
   console.log();
   console.log(pc.cyan("━".repeat(40)));

package/src/commands/top.ts

@@ -1,5 +1,5 @@
 // gh-stack top — Jump to the tip of the stack
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import {

package/src/commands/undo.ts

@@ -1,5 +1,5 @@
 // gh-stack undo — Restore from last snapshot
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import * as git from "../lib/git.ts";
 import pc from "picocolors";
 import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";

package/src/commands/up.ts

@@ -1,5 +1,5 @@
 // gh-stack up — Move to child branch (upstack)
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import { findStackForBranch, getChildren, writeMetadata } from "../lib/metadata.ts";

package/src/commands/update-prs.ts

@@ -1,6 +1,6 @@
 // gh-stack update-prs — Update PR descriptions with stack visualization
 // Port of reference/gh-stack-update-pr.sh
-import * as p from "@clack/prompts";
+import * as p from "../lib/output.ts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import { findStackForBranch, getOrderedBranches } from "../lib/metadata.ts";

package/src/index.ts

@@ -1,14 +1,23 @@
 #!/usr/bin/env bun
 // gh-stack — Unified stacked PR manager for squash-merge workflows
 
-// Map GH_STACK_NO_COLOR → NO_COLOR so picocolors (and other tools) respect it
-if (process.env.GH_STACK_NO_COLOR) {
+// Map GH_STACK_NO_COLOR → NO_COLOR so picocolors (and other tools) respect it.
+// Also pre-detect plain mode (--plain flag, GH_STACK_YES=1, or GH_STACK_PLAIN=1)
+// and set NO_COLOR *before* any import below — picocolors snapshots env at
+// load time, so this must run before the import block.
+const _earlyArgs = process.argv.slice(2);
+const _earlyPlain =
+  _earlyArgs.includes("--plain") ||
+  process.env.GH_STACK_YES === "1" ||
+  process.env.GH_STACK_PLAIN === "1";
+if (process.env.GH_STACK_NO_COLOR || _earlyPlain) {
   process.env.NO_COLOR = "1";
 }
 
 import { ensureGitRepo } from "./lib/safety.ts";
 import { parseCliArgs } from "./lib/cli.ts";
 import { setAutoYes } from "./lib/ui.ts";
+import { setPlain } from "./lib/output.ts";
 
 const { version: VERSION } = await import("../package.json");
 
@@ -32,6 +41,11 @@ if (parsed.autoYes) {
   setAutoYes(true);
 }
 
+// Global --plain (or GH_STACK_YES=1): drop intro/outro/spinner/color chrome.
+if (parsed.plain) {
+  setPlain(true);
+}
+
 // Ensure we're in a git repo for all commands
 await ensureGitRepo();
 
@@ -160,11 +174,13 @@ ${bold("INFO & MAINTENANCE")}
 
 ${bold("GLOBAL OPTIONS")}
   --yes, -y        Skip confirmations ${dim("(for agents/CI)")}
+  --plain          Plain output: no spinners, colors, or box drawing
   --help           Show help
   --version, -V    Show version
 
 ${bold("ENVIRONMENT")}
-  GH_STACK_YES=1       Same as --yes
+  GH_STACK_YES=1       Same as --yes (also enables --plain)
+  GH_STACK_PLAIN=1     Same as --plain
   GH_STACK_NO_COLOR    Disable colored output
 `);
 }