gh-stack 0.1.0

package/src/commands/status.ts

@@ -0,0 +1,372 @@
+// gh-stack status — PR dashboard (CI, reviews)
+// Port of reference/check-my-prs-fast.sh
+import pc from "picocolors";
+import * as git from "../lib/git.ts";
+import {
+  readMetadata,
+  metadataExists,
+  getOrderedBranches,
+  findStackForBranch,
+} from "../lib/metadata.ts";
+import { getMyOpenPrs, reviewEmoji, ciEmoji } from "../lib/github.ts";
+import type { PrStatus } from "../types.ts";
+
+export default async function status(args: string[]): Promise<void> {
+  if (args.includes("--help")) {
+    console.log(`
+gh-stack status — PR dashboard
+
+USAGE
+  gh-stack status [options]
+
+OPTIONS
+  --current        Show only the current stack (or current PR if standalone)
+  --json           Output as JSON (progress goes to stderr)
+
+Shows open PRs across stacks with review state, CI status, and merge readiness.
+Progress/spinner output goes to stderr so stdout stays clean for piping.
+`);
+    return;
+  }
+
+  const jsonMode = args.includes("--json");
+  const currentOnly = args.includes("--current");
+
+  // Progress goes to stderr so stdout is clean for agents
+  process.stderr.write("Fetching open PRs...\n");
+
+  const prs = await getMyOpenPrs();
+
+  process.stderr.write(`Found ${prs.length} open PR(s)\n`);
+
+  if (prs.length === 0) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ stacks: [], standalone: [] }, null, 2));
+    } else {
+      console.log("No open PRs found. 🎉");
+    }
+    return;
+  }
+
+  // Build lookup by PR number
+  const prMap = new Map<number, PrStatus>();
+  for (const pr of prs) {
+    prMap.set(pr.number, pr);
+  }
+
+  // Determine current branch and stack for --current filtering.
+  // --current means: "show me the status of whatever branch I'm ON right now."
+  // If that branch is in a stack → show that stack's PRs.
+  // If standalone → show just that branch's PR.
+  // Do NOT fall back to metadata's current_stack — that's stale state.
+  let currentStackName: string | null = null;
+  let currentBranch: string | null = null;
+  let currentPrNumber: number | null = null;
+
+  if (currentOnly) {
+    try {
+      currentBranch = await git.currentBranch();
+    } catch {
+      // Not on a branch — show nothing for --current
+    }
+
+    if (currentBranch && (await metadataExists())) {
+      const meta = await readMetadata();
+      if (meta) {
+        // Only use findStackForBranch — no fallback to current_stack
+        currentStackName = findStackForBranch(meta, currentBranch);
+
+        // If not in any stack, find the PR for this branch directly
+        if (!currentStackName) {
+          for (const pr of prs) {
+            if (pr.headRefName === currentBranch) {
+              currentPrNumber = pr.number;
+              break;
+            }
+          }
+          // Also check metadata for the PR number
+          if (!currentPrNumber && meta) {
+            for (const stack of Object.values(meta.stacks)) {
+              const branch = stack.branches[currentBranch];
+              if (branch?.pr) {
+                currentPrNumber = branch.pr;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // If not in metadata at all, try to match by branch name from open PRs
+    if (!currentStackName && !currentPrNumber && currentBranch) {
+      for (const pr of prs) {
+        if (pr.headRefName === currentBranch) {
+          currentPrNumber = pr.number;
+          break;
+        }
+      }
+    }
+  }
+
+  // ── JSON mode ──
+  if (jsonMode) {
+    outputJson(prs, prMap, currentOnly, currentStackName, currentPrNumber);
+    return;
+  }
+
+  // ── Human mode ──
+  outputHuman(prs, prMap, currentOnly, currentStackName, currentBranch, currentPrNumber);
+}
+
+// ────────────────────────────────────────────────────────
+// JSON output
+// ────────────────────────────────────────────────────────
+
+async function outputJson(
+  prs: PrStatus[],
+  prMap: Map<number, PrStatus>,
+  currentOnly: boolean,
+  currentStackName: string | null,
+  currentPrNumber: number | null,
+): Promise<void> {
+  const stackedPrNumbers = new Set<number>();
+  const stacks: any[] = [];
+
+  if (await metadataExists()) {
+    const meta = await readMetadata();
+    if (meta) {
+      for (const [stackName, stack] of Object.entries(meta.stacks)) {
+        if (currentOnly && stackName !== currentStackName) continue;
+
+        const ordered = getOrderedBranches(stack);
+        const branches: any[] = [];
+
+        for (const branchName of ordered) {
+          const branch = stack.branches[branchName]!;
+          const prNum = branch.pr;
+          const pr = prNum ? prMap.get(prNum) : undefined;
+
+          if (prNum && pr) {
+            stackedPrNumbers.add(prNum);
+            branches.push({
+              branch: branchName,
+              pr: prNum,
+              title: pr.title,
+              state: pr.state,
+              isDraft: pr.isDraft,
+              url: pr.url,
+              review: pr.reviewDecision || "PENDING",
+              ci: {
+                total: pr.totalChecks,
+                passed: pr.passedChecks,
+                failed: pr.failedChecks,
+                pending: pr.pendingChecks,
+                failedNames: pr.failedNames,
+              },
+            });
+          } else if (prNum) {
+            // PR exists in metadata but not in open PRs (merged/closed)
+            stackedPrNumbers.add(prNum);
+            branches.push({
+              branch: branchName,
+              pr: prNum,
+              title: branch.description || branchName,
+              state: "CLOSED",
+              isDraft: false,
+              url: null,
+              review: null,
+              ci: null,
+            });
+          }
+        }
+
+        if (branches.length > 0 || !currentOnly) {
+          stacks.push({
+            name: stackName,
+            description: stack.description,
+            branches,
+          });
+        }
+      }
+    }
+  }
+
+  // Standalone PRs
+  // In --current mode: only show the specific standalone PR for this branch
+  // (and only if the branch isn't already in a stack)
+  // Otherwise: show all standalone PRs
+  const filteredStandalone = prs
+    .filter((pr) => {
+      if (stackedPrNumbers.has(pr.number)) return false;
+      if (currentOnly) return pr.number === currentPrNumber;
+      return true;
+    })
+    .toSorted(
+      (a, b) => new Date(b.updatedAt || "").getTime() - new Date(a.updatedAt || "").getTime(),
+    );
+
+  const standalone = filteredStandalone.map((pr) => ({
+    pr: pr.number,
+    title: pr.title,
+    state: pr.state,
+    isDraft: pr.isDraft,
+    url: pr.url,
+    review: pr.reviewDecision || "PENDING",
+    ci: {
+      total: pr.totalChecks,
+      passed: pr.passedChecks,
+      failed: pr.failedChecks,
+      pending: pr.pendingChecks,
+      failedNames: pr.failedNames,
+    },
+  }));
+
+  // --current mode: return a single unwrapped object (stack or standalone PR)
+  if (currentOnly) {
+    if (stacks.length > 0) {
+      console.log(JSON.stringify(stacks[0], null, 2));
+    } else if (standalone.length > 0) {
+      console.log(JSON.stringify(standalone[0], null, 2));
+    } else {
+      console.log(JSON.stringify(null));
+    }
+    return;
+  }
+
+  console.log(JSON.stringify({ stacks, standalone }, null, 2));
+}
+
+// ────────────────────────────────────────────────────────
+// Human-readable output
+// ────────────────────────────────────────────────────────
+
+async function outputHuman(
+  prs: PrStatus[],
+  prMap: Map<number, PrStatus>,
+  currentOnly: boolean,
+  currentStackName: string | null,
+  currentBranch: string | null,
+  currentPrNumber: number | null,
+): Promise<void> {
+  const stackedPrNumbers = new Set<number>();
+
+  console.log();
+  console.log(`${pc.bold("📊 My Open PRs")}  ${pc.dim(`(${prs.length} open)`)}`);
+  console.log();
+
+  // ── Stacked PRs ──
+  if (await metadataExists()) {
+    const meta = await readMetadata();
+    if (meta) {
+      for (const [stackName, stack] of Object.entries(meta.stacks)) {
+        if (currentOnly && stackName !== currentStackName) continue;
+
+        const ordered = getOrderedBranches(stack);
+
+        // Find which PRs in this stack are still open
+        const openPrsInStack: number[] = [];
+        for (const branch of ordered) {
+          const prNum = stack.branches[branch]?.pr;
+          if (prNum && prMap.has(prNum)) {
+            openPrsInStack.push(prNum);
+            stackedPrNumbers.add(prNum);
+          }
+        }
+
+        if (openPrsInStack.length === 0) continue;
+
+        console.log(`${pc.cyan("📚 Stack:")} ${pc.yellow(stackName)}`);
+        if (stack.description) {
+          console.log(`   ${pc.dim(stack.description)}`);
+        }
+        console.log();
+
+        for (let i = 0; i < openPrsInStack.length; i++) {
+          const prNum = openPrsInStack[i]!;
+          const pr = prMap.get(prNum)!;
+          const isLast = i === openPrsInStack.length - 1;
+          const tree = isLast ? "┗━" : "┣━";
+
+          if (i > 0) {
+            console.log("   ┃");
+          }
+
+          const formatted = formatPr(pr);
+          console.log(`   ${tree} ${formatted.line1}`);
+          console.log(`      ${formatted.line2}`);
+          console.log(`      ${pc.dim(pr.url)}`);
+
+          for (const name of pr.failedNames) {
+            console.log(`      ${pc.red(`↳ ${name}`)}`);
+          }
+        }
+
+        console.log();
+      }
+    }
+  }
+
+  // ── Standalone PRs ──
+  // In --current mode: only show if current branch is a standalone PR
+  // Otherwise: show all standalone PRs
+  {
+    const standalonePrs = prs
+      .filter((pr) => {
+        if (stackedPrNumbers.has(pr.number)) return false;
+        if (currentOnly) return pr.number === currentPrNumber;
+        return true;
+      })
+      .toSorted(
+        (a, b) => new Date(b.updatedAt || "").getTime() - new Date(a.updatedAt || "").getTime(),
+      );
+
+    if (standalonePrs.length > 0) {
+      if (!currentOnly) {
+        console.log(`${pc.cyan("📋 Standalone PRs")}`);
+        console.log();
+      }
+
+      for (const pr of standalonePrs) {
+        const formatted = formatPr(pr);
+        console.log(formatted.line1);
+        console.log(`   ${formatted.line2}`);
+        console.log(`   ${pc.dim(pr.url)}`);
+
+        for (const name of pr.failedNames) {
+          console.log(`   ${pc.red(`↳ ${name}`)}`);
+        }
+        console.log();
+      }
+    }
+  }
+
+  // Footer
+  console.log(pc.dim("─".repeat(40)));
+}
+
+function formatPr(pr: PrStatus): { line1: string; line2: string } {
+  const stateIcon = pr.isDraft ? "📝" : "🔵";
+  const reviewIcon = reviewEmoji(pr.reviewDecision);
+  const reviewStr = reviewText(pr.reviewDecision);
+  const ci = ciEmoji(pr);
+  const title = pr.title.length > 70 ? pr.title.slice(0, 67) + "..." : pr.title;
+
+  return {
+    line1: `${stateIcon} #${pr.number}: ${title}`,
+    line2: `${reviewIcon} ${reviewStr}  │  ${ci.icon} ${ci.text}`,
+  };
+}
+
+function reviewText(decision: string | null | undefined): string {
+  switch (decision) {
+    case "APPROVED":
+      return "Approved";
+    case "CHANGES_REQUESTED":
+      return "Changes requested";
+    case "REVIEW_REQUIRED":
+      return "Needs review";
+    default:
+      return "Pending";
+  }
+}

package/src/commands/switch.ts

@@ -0,0 +1,114 @@
+// gh-stack switch — Switch between branches or stacks
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import * as git from "../lib/git.ts";
+import { writeMetadata, getOrderedBranches, findStackForBranch } from "../lib/metadata.ts";
+import { ensureMetadata } from "../lib/safety.ts";
+import { selectBranch, selectStack } from "../lib/ui.ts";
+
+export default async function switchCmd(args: string[]): Promise<void> {
+  const isStackMode = args.includes("--stack");
+  const numberArg = args.find((a) => /^\d+$/.test(a));
+
+  if (args.includes("--help")) {
+    console.log(`
+gh-stack switch — Switch branch or stack
+
+USAGE
+  gh-stack switch <number>      Switch to branch by position (non-interactive)
+  gh-stack switch               Interactive branch picker (arrow keys)
+  gh-stack switch --stack       Switch between stacks (interactive)
+
+EXAMPLES
+  gh-stack switch 1             Jump to first branch in stack (base)
+  gh-stack switch 2             Jump to second branch in stack
+
+TIP
+  Use 'gh-stack list' to see branch numbers.
+`);
+    return;
+  }
+
+  const meta = await ensureMetadata();
+  const currentBranch = await git.currentBranch();
+
+  if (isStackMode) {
+    // ── Stack switching ──
+    p.intro(pc.cyan("Switch Stack"));
+
+    const stackName = await selectStack(meta, "Switch to stack");
+    if (!stackName) {
+      p.cancel("Cancelled");
+      process.exit(0);
+    }
+
+    // Update current_stack
+    meta.current_stack = stackName;
+    await writeMetadata(meta);
+
+    // Checkout last branch in stack
+    const stack = meta.stacks[stackName]!;
+    const lastBranch = stack.last_branch;
+
+    if (lastBranch && lastBranch !== currentBranch) {
+      p.log.info(`Switching to stack ${pc.yellow(stackName)}`);
+      p.log.info(`Checking out ${pc.yellow(lastBranch)}`);
+      await git.checkout(lastBranch);
+    }
+
+    p.outro(pc.green(`Switched to stack ${pc.yellow(stackName)}`));
+  } else {
+    // ── Branch switching ──
+    // Find current stack
+    let stackName = findStackForBranch(meta, currentBranch);
+    if (!stackName) stackName = meta.current_stack;
+
+    if (!stackName || !meta.stacks[stackName]) {
+      p.cancel(`No active stack found.\n\n  Create one with:\n    ${pc.green("gh-stack init")}`);
+      process.exit(1);
+    }
+
+    const stack = meta.stacks[stackName]!;
+    const ordered = getOrderedBranches(stack);
+
+    if (ordered.length === 0) {
+      p.cancel("No branches in this stack");
+      process.exit(1);
+    }
+
+    let targetBranch: string | null = null;
+
+    if (numberArg) {
+      // Switch by number
+      const index = parseInt(numberArg, 10) - 1;
+      if (index < 0 || index >= ordered.length) {
+        p.cancel(`Invalid branch number. Valid range: 1-${ordered.length}`);
+        process.exit(1);
+      }
+      targetBranch = ordered[index]!;
+    } else {
+      // Interactive selector
+      targetBranch = await selectBranch(stack, "Switch to branch", currentBranch);
+    }
+
+    if (!targetBranch) {
+      p.cancel("Cancelled");
+      process.exit(0);
+    }
+
+    if (targetBranch === currentBranch) {
+      p.log.info(`Already on ${pc.yellow(targetBranch)}`);
+      return;
+    }
+
+    p.log.info(`Switching to ${pc.yellow(targetBranch)}`);
+    await git.checkout(targetBranch);
+
+    // Update last_branch
+    stack.last_branch = targetBranch;
+    meta.current_stack = stackName;
+    await writeMetadata(meta);
+
+    p.log.success(`On branch ${pc.yellow(targetBranch)}`);
+  }
+}

package/src/commands/sync.ts

@@ -0,0 +1,189 @@
+// gh-stack sync — Fetch main, rebase base branch onto main, then restack all
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import * as git from "../lib/git.ts";
+import { findStackForBranch, getOrderedBranches, saveRestackState } from "../lib/metadata.ts";
+import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";
+import { takeSnapshot } from "../lib/snapshot.ts";
+import { confirmAction } from "../lib/ui.ts";
+
+export default async function sync(args: string[]): Promise<void> {
+  const dryRun = args.includes("--dry-run");
+
+  if (args.includes("--help")) {
+    console.log(`
+gh-stack sync — Sync base with main + restack all
+
+USAGE
+  gh-stack sync [--dry-run]
+
+Fetches latest main, rebases the base branch onto main,
+then restacks all children. Equivalent to running restack
+with the base branch included.
+`);
+    return;
+  }
+
+  await ensureCleanWorkingTree();
+
+  const meta = await ensureMetadata();
+  const currentBranch = await git.currentBranch();
+  const stackName = findStackForBranch(meta, currentBranch);
+
+  if (!stackName) {
+    p.cancel(`Branch ${pc.blue(currentBranch)} not found in any stack`);
+    process.exit(1);
+  }
+
+  const stack = meta.stacks[stackName]!;
+  const 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 base branch (first branch, parent = main)
+  const baseBranch = ordered[0]!;
+  const baseParent = stack.branches[baseBranch]?.parent;
+
+  if (baseParent !== "main") {
+    p.cancel(`Base branch ${pc.yellow(baseBranch)} doesn't have main as parent`);
+    process.exit(1);
+  }
+
+  // Fetch main
+  const fetchSpinner = p.spinner();
+  fetchSpinner.start("Fetching latest main...");
+  await git.fetchMain();
+  fetchSpinner.stop("Fetched latest main");
+
+  // Take snapshot
+  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 = `stack-sync-base-${git.sanitizeBranchForTag(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)));
+  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);
+    }
+
+    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,
+    });
+
+    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);
+    }
+
+    p.log.success("Base branch rebased onto main");
+
+    // Prompt to push base
+    await promptForcePush(baseBranch);
+  }
+
+  // Step 2: Restack children
+  const children = ordered.slice(1);
+
+  if (children.length === 0) {
+    p.outro(pc.green("Sync complete! (no children to restack)"));
+    return;
+  }
+
+  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"] : []);
+  }
+}
+
+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");
+  }
+}