gh-stack 0.1.0

package/src/lib/github.ts

@@ -0,0 +1,184 @@
+// GitHub CLI (gh) helpers
+import { $ } from "bun";
+import type { PrInfo, PrStatus } from "../types.ts";
+
+/**
+ * Get PR number for a branch (auto-detect via gh).
+ * Returns null if no PR exists.
+ */
+export async function getPrNumber(branch: string): Promise<number | null> {
+  try {
+    const result = await $`gh pr list --head ${branch} --json number --jq '.[0].number'`.text();
+    const num = parseInt(result.trim(), 10);
+    return isNaN(num) ? null : num;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get PR info for a specific PR number.
+ */
+export async function getPrInfo(prNumber: number): Promise<PrInfo | null> {
+  try {
+    const result =
+      await $`gh pr view ${prNumber} --json number,title,state,reviewDecision,isDraft,url,updatedAt,statusCheckRollup`.text();
+    const data = JSON.parse(result.trim());
+    return {
+      number: data.number,
+      title: data.title,
+      state: data.state,
+      reviewDecision: data.reviewDecision || null,
+      isDraft: data.isDraft || false,
+      url: data.url,
+      updatedAt: data.updatedAt,
+      statusCheckRollup: data.statusCheckRollup || [],
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get all open PRs for the current user with full status info.
+ */
+export async function getMyOpenPrs(): Promise<PrStatus[]> {
+  try {
+    const result =
+      await $`gh pr list --author @me --state open --json number,title,headRefName,reviewDecision,statusCheckRollup,isDraft,state,updatedAt,url --limit 50`.text();
+    const data = JSON.parse(result.trim()) as any[];
+
+    return data.map((pr) => {
+      const checks = pr.statusCheckRollup || [];
+      const validChecks = checks.filter((c: any) => c.name != null);
+      const passed = validChecks.filter(
+        (c: any) => c.conclusion === "SUCCESS" || c.conclusion === "NEUTRAL",
+      ).length;
+      const failed = validChecks.filter(
+        (c: any) =>
+          c.conclusion === "FAILURE" ||
+          c.conclusion === "CANCELLED" ||
+          c.conclusion === "TIMED_OUT",
+      ).length;
+      const pending = validChecks.filter(
+        (c: any) => c.status === "IN_PROGRESS" || c.status === "QUEUED" || c.status === "PENDING",
+      ).length;
+      const failedNames = validChecks
+        .filter(
+          (c: any) =>
+            c.conclusion === "FAILURE" ||
+            c.conclusion === "CANCELLED" ||
+            c.conclusion === "TIMED_OUT",
+        )
+        .map((c: any) => c.name)
+        .slice(0, 3);
+
+      return {
+        number: pr.number,
+        title: pr.title,
+        state: pr.state,
+        reviewDecision: pr.reviewDecision || null,
+        isDraft: pr.isDraft || false,
+        url: pr.url,
+        updatedAt: pr.updatedAt,
+        headRefName: pr.headRefName,
+        statusCheckRollup: checks,
+        totalChecks: validChecks.length,
+        passedChecks: passed,
+        failedChecks: failed,
+        pendingChecks: pending,
+        failedNames,
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Update a PR's body (description).
+ */
+export async function updatePrBody(prNumber: number, body: string): Promise<boolean> {
+  try {
+    // Write to a temp file to avoid shell escaping issues
+    const tmpFile = `${await import("node:os").then((os) => os.tmpdir())}/gh-stack-pr-body-${prNumber}.md`;
+    await Bun.write(tmpFile, body);
+    await $`gh pr edit ${prNumber} --body-file ${tmpFile}`.quiet();
+    const { unlink } = await import("node:fs/promises");
+    await unlink(tmpFile);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get PR body text.
+ */
+export async function getPrBody(prNumber: number): Promise<string | null> {
+  try {
+    const result = await $`gh pr view ${prNumber} --json body --jq '.body'`.text();
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Close a PR with a comment.
+ */
+export async function closePr(prNumber: number, comment?: string): Promise<boolean> {
+  try {
+    if (comment) {
+      await $`gh pr close ${prNumber} --comment ${comment}`.quiet();
+    } else {
+      await $`gh pr close ${prNumber}`.quiet();
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get review decision emoji for display.
+ */
+export function reviewEmoji(decision: string | null | undefined): string {
+  switch (decision) {
+    case "APPROVED":
+      return "\u2705"; // ✅
+    case "CHANGES_REQUESTED":
+      return "\u274C"; // ❌
+    case "REVIEW_REQUIRED":
+      return "\uD83D\uDC40"; // 👀
+    default:
+      return "\u23F3"; // ⏳
+  }
+}
+
+/**
+ * Get CI status emoji for display.
+ */
+export function ciEmoji(status: {
+  totalChecks: number;
+  passedChecks: number;
+  failedChecks: number;
+  pendingChecks: number;
+}): { icon: string; text: string } {
+  if (status.totalChecks === 0) {
+    return { icon: "\u26AA", text: "No checks" };
+  }
+  if (status.failedChecks > 0) {
+    return { icon: "\u274C", text: `${status.failedChecks} failed` };
+  }
+  if (status.pendingChecks > 0) {
+    return { icon: "\uD83D\uDFE1", text: `${status.pendingChecks} running` };
+  }
+  if (status.passedChecks === status.totalChecks) {
+    return {
+      icon: "\u2705",
+      text: `All passing (${status.totalChecks})`,
+    };
+  }
+  return { icon: "\u26AA", text: "Unknown" };
+}

package/src/lib/metadata.ts

@@ -0,0 +1,307 @@
+// Read/write/validate .git/gh-stack-metadata.json
+import type { StackMetadata, StackMetadataV1, Stack, Branch, RestackState } from "../types.ts";
+import { gitDir } from "./git.ts";
+
+let cachedGitDir: string | null = null;
+
+async function getGitDir(): Promise<string> {
+  if (!cachedGitDir) {
+    cachedGitDir = await gitDir();
+  }
+  return cachedGitDir;
+}
+
+/**
+ * Get the path to the metadata file.
+ */
+export async function metadataPath(): Promise<string> {
+  const dir = await getGitDir();
+  return `${dir}/gh-stack-metadata.json`;
+}
+
+/**
+ * Get the path to the restack state file.
+ */
+export async function restackStatePath(): Promise<string> {
+  const dir = await getGitDir();
+  return `${dir}/.gh-stack-sync-state`;
+}
+
+/**
+ * Check if metadata file exists.
+ */
+export async function metadataExists(): Promise<boolean> {
+  const path = await metadataPath();
+  return Bun.file(path).exists();
+}
+
+/**
+ * Read and parse metadata, with auto-migration from v1.
+ * Returns null if file doesn't exist.
+ */
+export async function readMetadata(): Promise<StackMetadata | null> {
+  const path = await metadataPath();
+  const file = Bun.file(path);
+
+  if (!(await file.exists())) {
+    return null;
+  }
+
+  const raw = await file.json();
+
+  // Auto-migrate v1 -> v2
+  if (!raw.version) {
+    const v1 = raw as StackMetadataV1;
+    const v2: StackMetadata = {
+      version: 2,
+      current_stack: v1.current_stack,
+      stacks: v1.stacks,
+    };
+    await writeMetadata(v2);
+    return v2;
+  }
+
+  return raw as StackMetadata;
+}
+
+/**
+ * Write metadata to disk.
+ */
+export async function writeMetadata(data: StackMetadata): Promise<void> {
+  const path = await metadataPath();
+  await Bun.write(path, JSON.stringify(data, null, 2) + "\n");
+}
+
+/**
+ * Initialize an empty metadata file.
+ */
+export async function initMetadata(): Promise<StackMetadata> {
+  const data: StackMetadata = {
+    version: 2,
+    current_stack: null,
+    stacks: {},
+  };
+  await writeMetadata(data);
+  return data;
+}
+
+/**
+ * Get current stack name from metadata.
+ */
+export function getCurrentStack(meta: StackMetadata): string | null {
+  return meta.current_stack;
+}
+
+/**
+ * Set the current stack.
+ */
+export async function setCurrentStack(
+  meta: StackMetadata,
+  stackName: string,
+): Promise<StackMetadata> {
+  meta.current_stack = stackName;
+  await writeMetadata(meta);
+  return meta;
+}
+
+/**
+ * Find which stack contains a given branch.
+ */
+export function findStackForBranch(meta: StackMetadata, branch: string): string | null {
+  for (const [name, stack] of Object.entries(meta.stacks)) {
+    if (branch in stack.branches) {
+      return name;
+    }
+  }
+  return null;
+}
+
+/**
+ * Create a new stack.
+ */
+export async function createStack(
+  meta: StackMetadata,
+  name: string,
+  description: string,
+): Promise<StackMetadata> {
+  meta.stacks[name] = {
+    description,
+    last_branch: null,
+    branches: {},
+  };
+  meta.current_stack = name;
+  await writeMetadata(meta);
+  return meta;
+}
+
+/**
+ * Add a branch to a stack.
+ */
+export async function addBranchToStack(
+  meta: StackMetadata,
+  stackName: string,
+  branchName: string,
+  branch: Branch,
+): Promise<StackMetadata> {
+  const stack = meta.stacks[stackName];
+  if (!stack) {
+    throw new Error(`Stack "${stackName}" not found`);
+  }
+
+  stack.branches[branchName] = branch;
+  stack.last_branch = branchName;
+  await writeMetadata(meta);
+  return meta;
+}
+
+/**
+ * Remove a branch from a stack, re-parenting children to the removed branch's parent.
+ */
+export async function removeBranchFromStack(
+  meta: StackMetadata,
+  stackName: string,
+  branchName: string,
+): Promise<StackMetadata> {
+  const stack = meta.stacks[stackName];
+  if (!stack) {
+    throw new Error(`Stack "${stackName}" not found`);
+  }
+
+  const branch = stack.branches[branchName];
+  if (!branch) {
+    throw new Error(`Branch "${branchName}" not found in stack "${stackName}"`);
+  }
+
+  const removedParent = branch.parent;
+
+  // Re-parent children
+  for (const [, b] of Object.entries(stack.branches)) {
+    if (b.parent === branchName) {
+      b.parent = removedParent;
+    }
+  }
+
+  // Remove the branch
+  delete stack.branches[branchName];
+
+  // Update last_branch if it was the removed one
+  if (stack.last_branch === branchName) {
+    const remaining = Object.keys(stack.branches);
+    stack.last_branch = remaining.length > 0 ? remaining[remaining.length - 1]! : null;
+  }
+
+  await writeMetadata(meta);
+  return meta;
+}
+
+/**
+ * Get the ordered list of branches from main to leaf for a stack.
+ * Follows parent pointers to build the chain.
+ */
+export function getOrderedBranches(stack: Stack): string[] {
+  const ordered: string[] = [];
+  const visited = new Set<string>();
+
+  function addChildrenOf(parent: string) {
+    for (const [name, branch] of Object.entries(stack.branches)) {
+      if (branch.parent === parent && !visited.has(name)) {
+        visited.add(name);
+        ordered.push(name);
+        addChildrenOf(name);
+      }
+    }
+  }
+
+  addChildrenOf("main");
+  return ordered;
+}
+
+/**
+ * Get children of a branch in a stack.
+ */
+export function getChildren(stack: Stack, branchName: string): string[] {
+  return Object.entries(stack.branches)
+    .filter(([_, b]) => b.parent === branchName)
+    .map(([name]) => name);
+}
+
+/**
+ * Get the top (leaf) branch of a stack.
+ */
+export function getTopOfStack(stack: Stack): string | null {
+  return stack.last_branch;
+}
+
+/**
+ * Build the rebase chain: starting branch + all descendants (BFS order).
+ */
+export function buildRebaseChain(stack: Stack, startBranch: string): string[] {
+  const chain: string[] = [startBranch];
+  const queue: string[] = [startBranch];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const children = getChildren(stack, current);
+
+    for (const child of children) {
+      chain.push(child);
+      queue.push(child);
+    }
+  }
+
+  return chain;
+}
+
+/**
+ * Update the last_branch for a stack.
+ */
+export async function updateLastBranch(
+  meta: StackMetadata,
+  stackName: string,
+  branch: string,
+): Promise<StackMetadata> {
+  const stack = meta.stacks[stackName];
+  if (stack) {
+    stack.last_branch = branch;
+    await writeMetadata(meta);
+  }
+  return meta;
+}
+
+// ── Restack state (for --resume) ──
+
+/**
+ * Save restack state for resume.
+ */
+export async function saveRestackState(state: RestackState): Promise<void> {
+  const path = await restackStatePath();
+  await Bun.write(path, JSON.stringify(state, null, 2) + "\n");
+}
+
+/**
+ * Load restack state for resume.
+ * Returns null if no state file exists.
+ */
+export async function loadRestackState(): Promise<RestackState | null> {
+  const path = await restackStatePath();
+  const file = Bun.file(path);
+
+  if (!(await file.exists())) {
+    return null;
+  }
+
+  return file.json();
+}
+
+/**
+ * Clear restack state file.
+ */
+export async function clearRestackState(): Promise<void> {
+  const path = await restackStatePath();
+  const file = Bun.file(path);
+
+  if (await file.exists()) {
+    const { unlink } = await import("node:fs/promises");
+    await unlink(path);
+  }
+}

package/src/lib/safety.ts

@@ -0,0 +1,98 @@
+// Pre-flight safety checks
+import * as git from "./git.ts";
+import { metadataExists, readMetadata, findStackForBranch } from "./metadata.ts";
+import type { StackMetadata } from "../types.ts";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+/**
+ * Ensure we're in a git repository.
+ */
+export async function ensureGitRepo(): Promise<void> {
+  if (!(await git.isGitRepo())) {
+    p.cancel("Not in a git repository");
+    process.exit(1);
+  }
+}
+
+/**
+ * Ensure metadata file exists. Returns the metadata.
+ */
+export async function ensureMetadata(): Promise<StackMetadata> {
+  if (!(await metadataExists())) {
+    p.cancel(
+      `No stack metadata found.\n\n  Create your first stack with:\n    ${pc.green("gh-stack init")}`,
+    );
+    process.exit(1);
+  }
+
+  const meta = await readMetadata();
+  if (!meta) {
+    p.cancel("Failed to read stack metadata");
+    process.exit(1);
+  }
+
+  return meta;
+}
+
+/**
+ * Ensure there's a current stack set. Returns the stack name.
+ */
+export function ensureCurrentStack(meta: StackMetadata): string {
+  const stack = meta.current_stack;
+  if (!stack || !meta.stacks[stack]) {
+    p.cancel(
+      `No current stack set.\n\n  Create a new stack with:\n    ${pc.green("gh-stack init")}`,
+    );
+    process.exit(1);
+  }
+  return stack;
+}
+
+/**
+ * Ensure current branch is in a stack. Returns the stack name.
+ */
+export async function ensureBranchInStack(meta: StackMetadata): Promise<string> {
+  const branch = await git.currentBranch();
+  const stackName = findStackForBranch(meta, branch);
+
+  if (!stackName) {
+    p.cancel(
+      `Branch ${pc.blue(branch)} is not in any stack.\n\n  Add it with:\n    ${pc.green("gh-stack add")}\n\n  Or create a new stack:\n    ${pc.green("gh-stack init")}`,
+    );
+    process.exit(1);
+  }
+
+  return stackName;
+}
+
+/**
+ * Ensure working tree is clean (no uncommitted changes).
+ */
+export async function ensureCleanWorkingTree(): Promise<void> {
+  if (!(await git.isCleanWorkingTree())) {
+    p.cancel("Working tree is not clean.\n\n  Please commit or stash your changes first.");
+    process.exit(1);
+  }
+}
+
+/**
+ * Ensure we're not on main.
+ */
+export async function ensureNotOnMain(): Promise<void> {
+  const branch = await git.currentBranch();
+  if (branch === "main" || branch === "master") {
+    p.cancel(`Cannot run this command on ${pc.red(branch)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Guard against force-pushing main.
+ */
+export function ensureNotMain(branch: string): void {
+  if (branch === "main" || branch === "master") {
+    p.cancel(`${pc.red("REFUSED:")} Cannot force-push ${pc.red(branch)}`);
+    process.exit(1);
+  }
+}

package/src/lib/snapshot.ts

@@ -0,0 +1,74 @@
+// Snapshot system for undo support
+import type { StackMetadata, Snapshot } from "../types.ts";
+import * as git from "./git.ts";
+import { writeMetadata, getOrderedBranches } from "./metadata.ts";
+
+const MAX_SNAPSHOTS = 10;
+
+/**
+ * Take a snapshot of all branch HEADs in the current stack before a destructive operation.
+ */
+export async function takeSnapshot(
+  meta: StackMetadata,
+  stackName: string,
+  operation: string,
+): Promise<StackMetadata> {
+  const stack = meta.stacks[stackName];
+  if (!stack) return meta;
+
+  const branches: Record<string, string> = {};
+  const ordered = getOrderedBranches(stack);
+
+  for (const branch of ordered) {
+    try {
+      branches[branch] = await git.revParse(branch);
+    } catch {
+      // Branch might not exist locally — skip
+    }
+  }
+
+  const snapshot: Snapshot = {
+    timestamp: new Date().toISOString(),
+    operation,
+    branches,
+  };
+
+  if (!meta.snapshots) {
+    meta.snapshots = [];
+  }
+
+  meta.snapshots.push(snapshot);
+
+  // Keep only the last N snapshots
+  if (meta.snapshots.length > MAX_SNAPSHOTS) {
+    meta.snapshots = meta.snapshots.slice(-MAX_SNAPSHOTS);
+  }
+
+  await writeMetadata(meta);
+  return meta;
+}
+
+/**
+ * Get the last snapshot (for undo).
+ */
+export function getLastSnapshot(meta: StackMetadata): Snapshot | null {
+  if (!meta.snapshots || meta.snapshots.length === 0) {
+    return null;
+  }
+  return meta.snapshots[meta.snapshots.length - 1]!;
+}
+
+/**
+ * Pop the last snapshot (remove it after restoring).
+ */
+export async function popSnapshot(
+  meta: StackMetadata,
+): Promise<{ meta: StackMetadata; snapshot: Snapshot | null }> {
+  if (!meta.snapshots || meta.snapshots.length === 0) {
+    return { meta, snapshot: null };
+  }
+
+  const snapshot = meta.snapshots.pop()!;
+  await writeMetadata(meta);
+  return { meta, snapshot };
+}