gh-stack 0.1.0

package/src/commands/undo.ts

@@ -0,0 +1,64 @@
+// gh-stack undo — Restore from last snapshot
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";
+import { getLastSnapshot, popSnapshot } from "../lib/snapshot.ts";
+import { confirmAction } from "../lib/ui.ts";
+import { $ } from "bun";
+
+export default async function undo(args: string[]): Promise<void> {
+  if (args.includes("--help")) {
+    console.log(`
+gh-stack undo — Restore from last snapshot
+
+USAGE
+  gh-stack undo
+
+Restores branch HEADs from the last snapshot taken before
+a destructive operation (restack, merge, sync, remove).
+`);
+    return;
+  }
+
+  await ensureCleanWorkingTree();
+
+  const meta = await ensureMetadata();
+
+  const snapshot = getLastSnapshot(meta);
+  if (!snapshot) {
+    p.cancel("No snapshots available to undo");
+    process.exit(1);
+  }
+
+  p.intro(pc.cyan("Undo Last Operation"));
+
+  p.log.info(`Operation: ${pc.yellow(snapshot.operation)}`);
+  p.log.info(`Timestamp: ${pc.dim(snapshot.timestamp)}`);
+  console.log();
+  p.log.info("Will restore:");
+  for (const [branch, sha] of Object.entries(snapshot.branches)) {
+    console.log(`  ${branch} → ${pc.dim(sha.slice(0, 8))}`);
+  }
+  console.log();
+
+  const confirmed = await confirmAction("Restore these branch positions?");
+  if (!confirmed) {
+    p.cancel("Cancelled");
+    process.exit(0);
+  }
+
+  // Restore each branch HEAD
+  for (const [branch, sha] of Object.entries(snapshot.branches)) {
+    try {
+      await $`git branch -f ${branch} ${sha}`.quiet();
+      p.log.success(`Restored ${pc.yellow(branch)} → ${sha.slice(0, 8)}`);
+    } catch {
+      p.log.error(`Failed to restore ${branch}`);
+    }
+  }
+
+  // Pop the snapshot
+  await popSnapshot(meta);
+
+  p.outro(pc.green("Undo complete!"));
+}

package/src/commands/update-prs.ts

@@ -0,0 +1,177 @@
+// 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 pc from "picocolors";
+import * as git from "../lib/git.ts";
+import { findStackForBranch, getOrderedBranches } from "../lib/metadata.ts";
+import { ensureMetadata } from "../lib/safety.ts";
+import { getPrInfo, getPrBody, updatePrBody, reviewEmoji } from "../lib/github.ts";
+
+export default async function updatePrs(args: string[]): Promise<void> {
+  if (args.includes("--help")) {
+    console.log(`
+gh-stack update-prs — Update PR descriptions with stack visualization
+
+USAGE
+  gh-stack update-prs
+
+Updates all PRs in the current stack with a standardized stack section
+showing the tree structure, PR links, and review status.
+`);
+    return;
+  }
+
+  const meta = await ensureMetadata();
+  const branch = await git.currentBranch();
+  const stackName = findStackForBranch(meta, branch);
+
+  if (!stackName) {
+    p.cancel(`Branch ${pc.blue(branch)} not found in any stack`);
+    process.exit(1);
+  }
+
+  const stack = meta.stacks[stackName]!;
+  const ordered = getOrderedBranches(stack);
+
+  p.intro(pc.cyan("Update PR Descriptions"));
+  p.log.info(`Stack: ${pc.yellow(stackName)}`);
+  p.log.info(`Found ${ordered.length} branch(es) in stack`);
+  console.log();
+
+  // Collect PR info for all branches
+  const s = p.spinner();
+  s.start("Fetching PR info from GitHub...");
+
+  interface BranchPrInfo {
+    branch: string;
+    prNumber: number | null;
+    prTitle: string;
+    reviewEmojiStr: string;
+  }
+
+  const branchInfos: BranchPrInfo[] = [];
+
+  for (const branchName of ordered) {
+    const branchMeta = stack.branches[branchName]!;
+    const prNumber = branchMeta.pr ?? null;
+    let prTitle = branchMeta.description || branchName;
+    let review = "PENDING";
+
+    if (prNumber) {
+      const info = await getPrInfo(prNumber);
+      if (info) {
+        prTitle = info.title || prTitle;
+        review = info.reviewDecision || "PENDING";
+      }
+    }
+
+    branchInfos.push({
+      branch: branchName,
+      prNumber,
+      prTitle,
+      reviewEmojiStr: reviewEmoji(review),
+    });
+  }
+
+  s.stop("Fetched PR info");
+
+  // Update each PR
+  let updated = 0;
+  let skipped = 0;
+
+  for (let targetIdx = 0; targetIdx < branchInfos.length; targetIdx++) {
+    const target = branchInfos[targetIdx]!;
+
+    if (!target.prNumber) {
+      p.log.info(`${pc.dim("⏭")} ${target.branch} — no PR, skipping`);
+      skipped++;
+      continue;
+    }
+
+    // Build stack visualization for this PR
+    const stackViz = buildStackViz(branchInfos, targetIdx);
+
+    // Get current PR body and replace/append stack section
+    const currentBody = await getPrBody(target.prNumber);
+    if (currentBody === null) {
+      p.log.warn(`Could not fetch body for PR #${target.prNumber}`);
+      skipped++;
+      continue;
+    }
+
+    // Remove existing stack section
+    let updatedBody = currentBody;
+    const stackSectionIdx = updatedBody.indexOf("### 📚 Stacked on");
+    if (stackSectionIdx !== -1) {
+      updatedBody = updatedBody.slice(0, stackSectionIdx).trimEnd();
+    }
+
+    // Append new stack section
+    const newBody = updatedBody ? `${updatedBody}\n\n${stackViz}` : stackViz;
+
+    // Update PR
+    const ok = await updatePrBody(target.prNumber, newBody);
+    if (ok) {
+      p.log.success(`PR #${target.prNumber} ${target.prTitle}`);
+      updated++;
+    } else {
+      p.log.error(`Failed to update PR #${target.prNumber}`);
+    }
+  }
+
+  console.log();
+  p.outro(
+    pc.green(
+      `Done! Updated ${updated} PR(s)${skipped > 0 ? `, skipped ${skipped} without PRs` : ""}`,
+    ),
+  );
+}
+
+interface BranchPrInfo {
+  branch: string;
+  prNumber: number | null;
+  prTitle: string;
+  reviewEmojiStr: string;
+}
+
+function buildStackViz(branches: BranchPrInfo[], targetIndex: number): string {
+  const lines: string[] = ["### 📚 Stacked on", ""];
+
+  if (branches.length === 1) {
+    lines.push("- ⚫ **main**");
+    return lines.join("\n");
+  }
+
+  lines.push("<pre>");
+  lines.push("⚫ main");
+  lines.push("┃");
+
+  for (let i = 0; i < branches.length; i++) {
+    const info = branches[i]!;
+    const isLast = i === branches.length - 1;
+    const isTarget = i === targetIndex;
+
+    // PR link
+    let prLink: string;
+    if (info.prNumber) {
+      prLink = `<a href="https://github.com/beehiiv/swarm/pull/${info.prNumber}">#${info.prNumber}</a>`;
+    } else {
+      prLink = "(no PR yet)";
+    }
+
+    // 👈 marker for the current PR
+    const marker = isTarget ? " 👈" : "";
+
+    // Tree character
+    const tree = isLast ? "┗━" : "┣━";
+
+    lines.push(`${tree} ${info.reviewEmojiStr} ${prLink} ${info.prTitle}${marker}`);
+
+    if (!isLast) {
+      lines.push("┃");
+    }
+  }
+
+  lines.push("</pre>");
+  return lines.join("\n");
+}

package/src/index.ts

@@ -0,0 +1,146 @@
+#!/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) {
+  process.env.NO_COLOR = "1";
+}
+
+import { ensureGitRepo } from "./lib/safety.ts";
+import { setAutoYes } from "./lib/ui.ts";
+
+const { version: VERSION } = await import("../package.json");
+
+const args = process.argv.slice(2);
+const command = args[0] || "show";
+
+// Handle global flags
+if (args.includes("--version") || args.includes("-V")) {
+  console.log(`gh-stack v${VERSION}`);
+  process.exit(0);
+}
+
+if (args.includes("--help") && !args[0]) {
+  printHelp();
+  process.exit(0);
+}
+
+// Global --yes flag: skip all interactive confirmations (for agents/CI)
+if (args.includes("--yes") || args.includes("-y") || process.env.GH_STACK_YES === "1") {
+  setAutoYes(true);
+}
+
+// Ensure we're in a git repo for all commands
+await ensureGitRepo();
+
+// Route to subcommand — strip global flags from command args
+const commandArgs = args.slice(1).filter((a) => a !== "--yes" && a !== "-y");
+
+switch (command) {
+  case "show":
+    await (await import("./commands/show.ts")).default(commandArgs);
+    break;
+
+  case "init":
+    await (await import("./commands/init.ts")).default(commandArgs);
+    break;
+
+  case "add":
+    await (await import("./commands/add.ts")).default(commandArgs);
+    break;
+
+  case "remove":
+    await (await import("./commands/remove.ts")).default(commandArgs);
+    break;
+
+  case "switch":
+    await (await import("./commands/switch.ts")).default(commandArgs);
+    break;
+
+  case "list":
+  case "ls":
+    await (await import("./commands/list.ts")).default(commandArgs);
+    break;
+
+  case "restack":
+  case "rebase":
+    await (await import("./commands/restack.ts")).default(commandArgs);
+    break;
+
+  case "sync":
+    await (await import("./commands/sync.ts")).default(commandArgs);
+    break;
+
+  case "update-prs":
+    await (await import("./commands/update-prs.ts")).default(commandArgs);
+    break;
+
+  case "status":
+    await (await import("./commands/status.ts")).default(commandArgs);
+    break;
+
+  case "merge":
+    await (await import("./commands/merge.ts")).default(commandArgs);
+    break;
+
+  case "undo":
+    await (await import("./commands/undo.ts")).default(commandArgs);
+    break;
+
+  case "archive":
+    await (await import("./commands/archive.ts")).default(commandArgs);
+    break;
+
+  case "--help":
+  case "help":
+    printHelp();
+    break;
+
+  default:
+    console.error(`Unknown command: ${command}\n`);
+    printHelp();
+    process.exit(1);
+}
+
+function printHelp() {
+  console.log(`
+gh-stack v${VERSION} — Stacked PR manager for squash-merge workflows
+
+${bold("USAGE")}
+  gh-stack <command> [options]
+
+${bold("COMMANDS")}
+  ${green("show")}           Display current stack tree ${dim("(default)")}
+  ${green("list")}           List branches with numbers ${dim("(alias: ls)")}
+  ${green("init")}           Create a new stack
+  ${green("add")}            Add a branch to the current stack
+  ${green("remove")}         Remove a branch from the stack
+  ${green("switch")}         Switch branch or stack
+  ${green("restack")}        Rebase children onto updated parents
+  ${green("sync")}           Sync base with main + restack all
+  ${green("update-prs")}     Update PR descriptions with stack viz
+  ${green("status")}         PR dashboard (CI, reviews)
+  ${green("merge")}          Local squash-merge top-down
+  ${green("undo")}           Restore from last snapshot
+  ${green("archive")}        Manage archived stacks
+
+${bold("GLOBAL OPTIONS")}
+  --yes, -y        Skip confirmations ${dim("(for agents/CI)")}
+  --help           Show help
+  --version, -V    Show version
+
+${bold("ENVIRONMENT")}
+  GH_STACK_YES=1       Same as --yes
+  GH_STACK_NO_COLOR    Disable colored output
+`);
+}
+
+function bold(s: string) {
+  return process.env.NO_COLOR ? s : `\x1b[1m${s}\x1b[0m`;
+}
+function green(s: string) {
+  return process.env.NO_COLOR ? s : `\x1b[32m${s}\x1b[0m`;
+}
+function dim(s: string) {
+  return process.env.NO_COLOR ? s : `\x1b[2m${s}\x1b[0m`;
+}

package/src/lib/git.ts

@@ -0,0 +1,237 @@
+// Git command helpers using Bun's shell API
+import { $ } from "bun";
+
+/**
+ * Get the current branch name.
+ * Throws if in detached HEAD state.
+ */
+export async function currentBranch(): Promise<string> {
+  const result = await $`git rev-parse --abbrev-ref HEAD`.text();
+  const branch = result.trim();
+  if (branch === "HEAD") {
+    throw new Error("Detached HEAD state — please checkout a branch first");
+  }
+  return branch;
+}
+
+/**
+ * Check if we're inside a git repository.
+ */
+export async function isGitRepo(): Promise<boolean> {
+  try {
+    await $`git rev-parse --git-dir`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the path to the .git directory (handles worktrees too).
+ */
+export async function gitDir(): Promise<string> {
+  const result = await $`git rev-parse --git-dir`.text();
+  return result.trim();
+}
+
+/**
+ * Check if working tree is clean (no uncommitted changes).
+ */
+export async function isCleanWorkingTree(): Promise<boolean> {
+  try {
+    await $`git diff-index --quiet HEAD --`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a rebase is currently in progress.
+ */
+export async function isRebaseInProgress(): Promise<boolean> {
+  const dir = await gitDir();
+
+  // Check if either directory exists by trying to read a known file
+  try {
+    const stat1 = await Bun.file(`${dir}/rebase-merge/interactive`).exists();
+    if (stat1) return true;
+  } catch {}
+
+  try {
+    const stat2 = await Bun.file(`${dir}/rebase-apply/rebasing`).exists();
+    if (stat2) return true;
+  } catch {}
+
+  // Also check the directories themselves
+  const { exitCode: code1 } = await $`test -d ${dir}/rebase-merge`.nothrow().quiet();
+  const { exitCode: code2 } = await $`test -d ${dir}/rebase-apply`.nothrow().quiet();
+
+  return code1 === 0 || code2 === 0;
+}
+
+/**
+ * Checkout a branch.
+ */
+export async function checkout(branch: string): Promise<void> {
+  await $`git checkout ${branch}`.quiet();
+}
+
+/**
+ * Create and checkout a new branch from the current HEAD.
+ */
+export async function createBranch(name: string): Promise<void> {
+  await $`git checkout -b ${name}`;
+}
+
+/**
+ * Get the SHA of a ref.
+ */
+export async function revParse(ref: string): Promise<string> {
+  const result = await $`git rev-parse ${ref}`.text();
+  return result.trim();
+}
+
+/**
+ * Get the merge-base of two refs.
+ * Returns null if no common ancestor is found.
+ */
+export async function mergeBase(ref1: string, ref2: string): Promise<string | null> {
+  try {
+    const result = await $`git merge-base ${ref1} ${ref2}`.text();
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if ref1 is an ancestor of ref2.
+ */
+export async function isAncestor(ancestor: string, descendant: string): Promise<boolean> {
+  const { exitCode } = await $`git merge-base --is-ancestor ${ancestor} ${descendant}`
+    .nothrow()
+    .quiet();
+  return exitCode === 0;
+}
+
+/**
+ * Force-push a branch with lease protection.
+ */
+export async function forcePushWithLease(branch?: string): Promise<boolean> {
+  try {
+    if (branch) {
+      await $`git push --force-with-lease origin ${branch}`;
+    } else {
+      await $`git push --force-with-lease`;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a branch exists on the remote.
+ */
+export async function remoteBranchExists(branch: string): Promise<boolean> {
+  const { exitCode } = await $`git ls-remote --exit-code --heads origin ${branch}`
+    .nothrow()
+    .quiet();
+  return exitCode === 0;
+}
+
+/**
+ * Create a temporary tag at a specific commit.
+ */
+export async function createTag(name: string, commit: string): Promise<void> {
+  await $`git tag -f ${name} ${commit}`.quiet();
+}
+
+/**
+ * Delete tags matching a pattern.
+ */
+export async function deleteTagsMatching(pattern: string): Promise<void> {
+  try {
+    const result = await $`git tag -l ${pattern}`.text();
+    const tags = result.trim().split("\n").filter(Boolean);
+    for (const tag of tags) {
+      await $`git tag -d ${tag}`.quiet();
+    }
+  } catch {
+    // No tags to delete — that's fine
+  }
+}
+
+/**
+ * Check if a tag exists.
+ */
+export async function tagExists(name: string): Promise<boolean> {
+  const { exitCode } = await $`git rev-parse --verify ${name}`.nothrow().quiet();
+  return exitCode === 0;
+}
+
+/**
+ * Perform a rebase: rebase branch onto newBase, starting from oldBase.
+ * Uses `git rebase --onto <newBase> <oldBase> <branch>`.
+ * Returns true if successful, false if conflicts occurred.
+ */
+export async function rebaseOnto(
+  newBase: string,
+  oldBase: string,
+  branch: string,
+): Promise<boolean> {
+  const { exitCode } = await $`git rebase --onto ${newBase} ${oldBase} ${branch}`.nothrow();
+  return exitCode === 0;
+}
+
+/**
+ * Simple rebase onto a target.
+ * Returns true if successful, false if conflicts occurred.
+ */
+export async function rebase(target: string): Promise<boolean> {
+  const { exitCode } = await $`git rebase ${target}`.nothrow();
+  return exitCode === 0;
+}
+
+/**
+ * Squash-merge a branch into the current branch.
+ * Returns true if successful.
+ */
+export async function mergeSquash(branch: string): Promise<boolean> {
+  const { exitCode } = await $`git merge --squash ${branch}`.nothrow();
+  return exitCode === 0;
+}
+
+/**
+ * Commit with a message.
+ */
+export async function commit(message: string): Promise<void> {
+  await $`git commit -m ${message}`;
+}
+
+/**
+ * Fetch origin main.
+ */
+export async function fetchMain(): Promise<void> {
+  await $`git fetch origin main`.quiet();
+}
+
+/**
+ * Get count of commits between two refs.
+ */
+export async function commitCount(from: string, to: string): Promise<number> {
+  try {
+    const result = await $`git rev-list --count ${from}..${to}`.text();
+    return parseInt(result.trim(), 10);
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Sanitize a branch name for use in tag names.
+ */
+export function sanitizeBranchForTag(branch: string): string {
+  return branch.replace(/[^a-zA-Z0-9-]/g, "_");
+}