gh-stack 0.1.2 → 0.2.1

package/src/commands/init.ts

@@ -1,4 +1,4 @@
-// gh-stack init — Create a new stack with the current branch
+// gh-stack init — Create a new stack, auto-detecting branch chains
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
@@ -8,14 +8,80 @@ import {
   createStack,
   addBranchToStack,
   metadataExists,
+  findStackForBranch,
 } from "../lib/metadata.ts";
 import { getPrNumber } from "../lib/github.ts";
-import { selectParent } from "../lib/ui.ts";
+import { isAutoYes } from "../lib/ui.ts";
 import type { StackMetadata, Branch } from "../types.ts";
 
-export default async function init(args: string[]): Promise<void> {
-  const branch = await git.currentBranch();
+const HELP = `
+gh-stack init — Create a new stack from the current branch
+
+USAGE
+  gh-stack init [options]
+
+Creates a new stack and adds the current branch. If the current branch
+is part of a chain of branches (e.g. main → feat-1 → feat-2), init
+auto-detects the chain and offers to add all branches to the stack.
+
+Best used from the TOP of your branch chain so all branches are found.
+
+OPTIONS
+  --name <name>         Stack name (default: current branch name)
+  --description <desc>  Stack description
+  --parent <branch>     Parent/trunk branch (default: main)
+
+EXAMPLES
+  gh-stack init                              # Auto-detect chain, use defaults
+  gh-stack init --name my-feature            # Custom stack name
+  gh-stack init --parent develop             # Different trunk branch
+`;
+
+/**
+ * Detect a chain of branches from trunk to the current branch.
+ *
+ * Walks down from the current branch by finding local branches whose
+ * tips are strict ancestors of the current branch. Sorts by commit
+ * distance (closest = direct parent) to reconstruct the chain.
+ *
+ * Returns branches in bottom-up order: [closest-to-trunk, ..., current]
+ */
+async function detectBranchChain(currentBranch: string, trunk: string): Promise<string[]> {
+  const allBranches = await git.allLocalBranches();
+
+  // Branches to exclude: current, trunk, and always main/master
+  const excluded = new Set([currentBranch, trunk, "main", "master"]);
+
+  // Find branches that are strict ancestors of current (and not trunk)
+  const ancestors: { name: string; distance: number }[] = [];
+
+  for (const branch of allBranches) {
+    if (excluded.has(branch)) continue;
+
+    // Is this branch's tip an ancestor of current?
+    if (await git.isAncestor(branch, currentBranch)) {
+      // Skip branches already merged into trunk (stale/old branches)
+      if (await git.isAncestor(branch, trunk)) continue;
+
+      // How many commits between this branch and current?
+      const distance = await git.commitCount(branch, currentBranch);
+      if (distance > 0) {
+        ancestors.push({ name: branch, distance });
+      }
+    }
+  }
 
+  // Sort by distance descending (furthest from current = closest to trunk)
+  ancestors.sort((a, b) => b.distance - a.distance);
+
+  // Build chain: ancestors (sorted trunk→current) + current branch
+  const chain = ancestors.map((a) => a.name);
+  chain.push(currentBranch);
+
+  return chain;
+}
+
+export default async function init(args: string[]): Promise<void> {
   // Parse flags
   let nameFlag: string | undefined;
   let descFlag: string | undefined;
@@ -33,25 +99,15 @@ export default async function init(args: string[]): Promise<void> {
         parentFlag = args[++i];
         break;
       case "--help":
-        console.log(`
-gh-stack init — Create a new stack
-
-USAGE
-  gh-stack init [--name <name>] [--description <desc>] [--parent <branch>]
-
-OPTIONS
-  --name <name>         Stack name (skip prompt)
-  --description <desc>  Stack description
-  --parent <branch>     Parent branch for current branch (default: main)
-`);
+        console.log(HELP);
         return;
     }
   }
 
-  p.intro(pc.cyan("Create New Stack"));
+  const branch = await git.currentBranch();
+  const trunk = parentFlag || "main";
 
-  console.log(`  Initializing stack with: ${pc.yellow(branch)}`);
-  console.log();
+  p.intro(pc.cyan("Create New Stack"));
 
   // Get or create metadata
   let meta: StackMetadata;
@@ -59,98 +115,91 @@ OPTIONS
     meta = (await readMetadata())!;
   } else {
     meta = await initMetadata();
-    p.log.success("Initialized empty stack metadata");
   }
 
-  // Get stack name
-  let stackName = nameFlag;
-  if (!stackName) {
-    const result = await p.text({
-      message: "Stack name",
-      placeholder: "e.g., podcast-mvp",
-      validate: (val = "") => {
-        if (!val.trim()) return "Stack name is required";
-        if (meta.stacks[val.trim()]) return `Stack "${val}" already exists`;
-      },
-    });
-    if (p.isCancel(result)) {
-      p.cancel("Cancelled");
-      process.exit(0);
+  // Check if current branch is already in a stack
+  const existingStack = findStackForBranch(meta, branch);
+  if (existingStack) {
+    p.cancel(`Branch ${pc.yellow(branch)} is already in stack ${pc.yellow(existingStack)}`);
+    process.exit(1);
+  }
+
+  // ── Detect branch chain ──
+  const s = p.spinner();
+  s.start("Detecting branch chain...");
+  const chain = await detectBranchChain(branch, trunk);
+  s.stop(chain.length > 1 ? `Found ${chain.length} branches in chain` : `Single branch: ${branch}`);
+
+  // Show detected chain
+  if (chain.length > 1) {
+    console.log();
+    console.log(`  ${pc.dim(trunk)}`);
+    for (let i = 0; i < chain.length; i++) {
+      const isLast = i === chain.length - 1;
+      const tree = isLast ? "  ┗━" : "  ┣━";
+      const label = chain[i] === branch ? pc.yellow(chain[i]!) + pc.dim(" (current)") : chain[i];
+      console.log(`${tree} ${label}`);
+      if (!isLast) console.log("  ┃");
+    }
+    console.log();
+
+    // Confirm chain
+    if (!isAutoYes()) {
+      const confirmed = await p.confirm({
+        message: "Create stack with all branches?",
+      });
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Cancelled");
+        process.exit(0);
+      }
     }
-    stackName = result as string;
   }
 
-  // Check if stack already exists
+  // ── Determine stack name ──
+  const stackName = nameFlag || branch;
+
   if (meta.stacks[stackName]) {
     p.cancel(`Stack "${stackName}" already exists`);
     process.exit(1);
   }
 
-  // Get stack description
-  let description = descFlag;
-  if (description === undefined) {
-    const result = await p.text({
-      message: "Stack description (optional)",
-      placeholder: "e.g., Podcast MVP features",
-    });
-    if (p.isCancel(result)) {
-      p.cancel("Cancelled");
-      process.exit(0);
-    }
-    description = (result as string) || "";
-  }
+  // ── Create stack ──
+  meta = await createStack(meta, stackName, descFlag || "");
 
-  // Create the stack
-  meta = await createStack(meta, stackName, description);
-  p.log.success(`Created stack: ${pc.blue(stackName)}`);
-
-  // Get parent branch
-  let parent: string | undefined = parentFlag;
-  if (!parent) {
-    parent = (await selectParent(null, branch)) ?? undefined;
-    if (!parent) {
-      p.cancel("Cancelled");
-      process.exit(0);
-    }
-  }
+  // ── Add branches with PR detection ──
+  const prSpinner = p.spinner();
+  prSpinner.start("Detecting PRs...");
 
-  p.log.info(`Parent: ${pc.yellow(parent)}`);
+  let prCount = 0;
+  for (let i = 0; i < chain.length; i++) {
+    const branchName = chain[i]!;
+    const parent = i === 0 ? trunk : chain[i - 1]!;
 
-  // Auto-detect PR number
-  const s = p.spinner();
-  s.start("Looking for PR...");
-  const prNumber = await getPrNumber(branch);
-  s.stop(prNumber ? `Found PR #${prNumber}` : "No PR found");
-
-  // Get branch description
-  let branchDesc: string | undefined;
-  if (!nameFlag) {
-    // Only prompt for branch description in interactive mode
-    const result = await p.text({
-      message: "Branch description (optional)",
-      placeholder: "e.g., Backend models",
-    });
-    if (!p.isCancel(result)) {
-      branchDesc = (result as string) || undefined;
-    }
-  }
+    // Auto-detect PR
+    const prNumber = await getPrNumber(branchName);
+    if (prNumber) prCount++;
 
-  // Add branch to stack
-  const branchData: Branch = {
-    parent,
-    ...(prNumber && { pr: prNumber }),
-    ...(branchDesc && { description: branchDesc }),
-  };
+    const branchData: Branch = {
+      parent,
+      ...(prNumber && { pr: prNumber }),
+    };
 
-  meta = await addBranchToStack(meta, stackName, branch, branchData);
+    meta = await addBranchToStack(meta, stackName, branchName, branchData);
+  }
 
-  p.log.success(`Added ${pc.yellow(branch)} to stack`);
+  prSpinner.stop(prCount > 0 ? `Found ${prCount} PR(s)` : "No PRs found");
 
-  p.outro(pc.green("Stack initialized!"));
+  p.outro(pc.green(`Stack ${pc.yellow(stackName)} created with ${chain.length} branch(es)!`));
 
+  // Next steps
+  console.log();
+  if (chain.length === 1) {
+    console.log("  Next steps:");
+    console.log(`    ${pc.blue("gh-stack create <branch>")}  — Add a branch to the stack`);
+  } else {
+    console.log("  Next steps:");
+    console.log(`    ${pc.blue("gh-stack submit")}           — Push and create PRs`);
+  }
+  console.log(`    ${pc.blue("gh-stack log")}              — View stack`);
   console.log();
-  console.log("  Next steps:");
-  console.log(`    ${pc.blue("gh-stack add")}          — Add more branches`);
-  console.log(`    ${pc.blue("gh-stack")}              — View stack`);
-  console.log(`    ${pc.blue("gh-stack restack")}      — Sync stack`);
 }

package/src/commands/list.ts

@@ -14,7 +14,7 @@ USAGE
   gh-stack ls
 
 Lightweight branch listing for quick reference and scripting.
-Use the number with 'gh-stack switch <number>' to jump to a branch.
+Use the number with 'gh-stack checkout <number>' to jump to a branch.
 
 ALIASES
   gh-stack ls

package/src/commands/{show.ts → log.ts}

@@ -1,4 +1,4 @@
-// gh-stack show — Display current stack tree (default command)
+// gh-stack log — Display current stack tree (default command)
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
@@ -10,7 +10,7 @@ import {
 } from "../lib/metadata.ts";
 import { renderStackTree } from "../lib/ui.ts";
 
-export default async function show(_args: string[]): Promise<void> {
+export default async function log(_args: string[]): Promise<void> {
   // Check if metadata exists
   if (!(await metadataExists())) {
     p.log.warn("No stack metadata found");
@@ -71,6 +71,6 @@ export default async function show(_args: string[]): Promise<void> {
   console.log();
 
   // Tip
-  console.log(pc.dim(`Tip: Switch stacks with 'gh-stack switch --stack'`));
+  console.log(pc.dim(`Tip: Switch stacks with 'gh-stack checkout --stack'`));
   console.log();
 }

package/src/commands/submit.ts

@@ -0,0 +1,326 @@
+// gh-stack submit — Push branches and create/update PRs
+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 } from "../lib/safety.ts";
+import { isAutoYes } from "../lib/ui.ts";
+import { getPrNumber, getPrInfo, getPrBody, updatePrBody, reviewEmoji } from "../lib/github.ts";
+import { buildStackViz } from "./update-prs.ts";
+
+const HELP = `
+gh-stack submit — Push branches and create/update PRs
+
+USAGE
+  gh-stack submit [options]
+
+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.
+
+OPTIONS
+  -d, --draft      Create new PRs as drafts
+  -n, --no-edit    Don't prompt for PR titles (auto-generate from branch name)
+      --dry-run    Show what would happen without doing anything
+
+EXAMPLES
+  gh-stack submit                # Push + create PRs interactively
+  gh-stack submit -n             # Push + create PRs with auto-titles
+  gh-stack submit --draft        # Create new PRs as drafts
+  gh-stack submit --dry-run      # Preview what would happen
+`;
+
+/**
+ * Generate a PR title from a branch name.
+ * Strips common prefixes like "kiliman/", replaces hyphens with spaces,
+ * and capitalizes the first letter.
+ */
+function branchToTitle(branch: string): string {
+  // Strip common prefixes like "kiliman/", "user/"
+  let name = branch.includes("/") ? branch.split("/").slice(1).join("/") : branch;
+  // Replace hyphens with spaces
+  name = name.replace(/-/g, " ");
+  // Capitalize first letter
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+/**
+ * Check if a local branch is up-to-date with its remote counterpart.
+ */
+async function isBranchUpToDate(branch: string): Promise<boolean> {
+  try {
+    const localSha = (await $`git rev-parse ${branch}`.text()).trim();
+    const remoteSha = (await $`git rev-parse origin/${branch}`.text()).trim();
+    return localSha === remoteSha;
+  } catch {
+    // Remote branch doesn't exist yet
+    return false;
+  }
+}
+
+/**
+ * Push a branch to origin with upstream tracking and force-with-lease.
+ */
+async function pushBranch(branch: string): Promise<boolean> {
+  try {
+    await $`git push -u --force-with-lease origin ${branch}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export default async function submit(args: string[]): Promise<void> {
+  if (args.includes("--help")) {
+    console.log(HELP);
+    return;
+  }
+
+  const draftFlag = args.includes("--draft") || args.includes("-d");
+  const dryRun = args.includes("--dry-run");
+  const noEdit = args.includes("--no-edit") || args.includes("-n") || isAutoYes();
+
+  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);
+
+  // Determine downstack scope: branches from trunk up to and including current
+  const currentIndex = ordered.indexOf(branch);
+  const scope = currentIndex >= 0 ? ordered.slice(0, currentIndex + 1) : ordered;
+
+  p.intro(pc.cyan("Submit Stack"));
+  p.log.info(`Stack: ${pc.yellow(stackName)}`);
+  p.log.info(
+    `Scope: ${scope.length} of ${ordered.length} branch(es) (downstack from ${pc.blue(branch)})`,
+  );
+  console.log();
+
+  if (dryRun) {
+    p.log.info(pc.dim("Dry run — no changes will be made"));
+    console.log();
+  }
+
+  // ── Phase 1: Push branches and create/update PRs ──
+  let pushed = 0;
+  let created = 0;
+  let existing = 0;
+  let metadataChanged = false;
+
+  for (const branchName of scope) {
+    const branchMeta = stack.branches[branchName]!;
+    const parentBranch = branchMeta.parent;
+
+    // ── Push (skip if already up-to-date) ──
+    if (dryRun) {
+      p.log.step(`${pc.dim("push")} ${branchName} → origin/${branchName}`);
+    } else if (await isBranchUpToDate(branchName)) {
+      p.log.info(`${pc.dim("✓")} ${pc.blue(branchName)} already up to date`);
+    } else {
+      const s = p.spinner();
+      s.start(`Pushing ${pc.blue(branchName)}...`);
+      const ok = await pushBranch(branchName);
+      if (ok) {
+        s.stop(`Pushed ${pc.blue(branchName)}`);
+        pushed++;
+      } else {
+        s.stop(pc.red(`Failed to push ${branchName}`));
+        p.cancel(`Push failed for ${pc.blue(branchName)}. Aborting.`);
+        process.exit(1);
+      }
+    }
+
+    // ── Check for existing PR ──
+    let prNumber = branchMeta.pr ?? null;
+
+    if (!prNumber && !dryRun) {
+      prNumber = await getPrNumber(branchName);
+      if (prNumber) {
+        // Found an existing PR not tracked in metadata — save it
+        branchMeta.pr = prNumber;
+        metadataChanged = true;
+      }
+    }
+
+    if (prNumber) {
+      // ── Existing PR: update base if needed ──
+      existing++;
+      if (dryRun) {
+        p.log.step(`${pc.dim("exists")} PR #${prNumber} for ${branchName}`);
+      } else {
+        // Ensure the PR base is correct
+        try {
+          await $`gh pr edit ${prNumber} --base ${parentBranch}`.quiet();
+        } catch {
+          // Best effort — base might already be correct
+        }
+        p.log.info(`${pc.dim("✓")} PR #${prNumber} for ${pc.blue(branchName)}`);
+      }
+    } else {
+      // ── Create new PR ──
+      const defaultTitle = branchToTitle(branchName);
+      let title = defaultTitle;
+
+      if (!noEdit && !dryRun) {
+        const input = await p.text({
+          message: `PR title for ${pc.blue(branchName)}`,
+          initialValue: defaultTitle,
+          placeholder: defaultTitle,
+        });
+        if (p.isCancel(input)) {
+          p.cancel("Cancelled");
+          process.exit(0);
+        }
+        title = (input as string).trim() || defaultTitle;
+      }
+
+      if (dryRun) {
+        p.log.step(
+          `${pc.dim("create")} PR for ${branchName} → ${parentBranch} "${title}"${draftFlag ? " (draft)" : ""}`,
+        );
+        created++;
+      } else {
+        const s = p.spinner();
+        s.start(`Creating PR for ${pc.blue(branchName)}...`);
+
+        const ghArgs = [
+          "pr",
+          "create",
+          "--base",
+          parentBranch,
+          "--head",
+          branchName,
+          "--title",
+          title,
+          "--body",
+          "",
+        ];
+        if (draftFlag) ghArgs.push("--draft");
+
+        const proc = Bun.spawn(["gh", ...ghArgs], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const output = await new Response(proc.stdout).text();
+        const exitCode = await proc.exited;
+
+        if (exitCode === 0) {
+          // Extract PR number from URL output
+          const prUrl = output.trim();
+          const prNumMatch = prUrl.match(/\/pull\/(\d+)/);
+          const newPrNumber = prNumMatch ? parseInt(prNumMatch[1]!, 10) : null;
+
+          if (newPrNumber) {
+            branchMeta.pr = newPrNumber;
+            metadataChanged = true;
+            s.stop(`Created PR #${newPrNumber} for ${pc.blue(branchName)}`);
+          } else {
+            s.stop(`Created PR for ${pc.blue(branchName)} (could not parse PR number)`);
+          }
+          created++;
+        } else {
+          const stderr = await new Response(proc.stderr).text();
+          s.stop(pc.red(`Failed to create PR for ${branchName}`));
+          p.log.error(stderr.trim());
+        }
+      }
+    }
+  }
+
+  // Save metadata if we discovered or created PRs
+  if (metadataChanged && !dryRun) {
+    await writeMetadata(meta);
+  }
+
+  console.log();
+
+  if (dryRun) {
+    p.outro(
+      pc.dim(
+        `Dry run complete: would push ${scope.length}, create ${created}, update ${existing} PR(s)`,
+      ),
+    );
+    return;
+  }
+
+  // ── Phase 2: Update stack visualization in all PR descriptions ──
+  p.log.info(pc.cyan("Updating stack visualization..."));
+
+  // Collect PR info for ALL branches in the stack (not just scope)
+  interface BranchPrInfo {
+    branch: string;
+    prNumber: number | null;
+    prTitle: string;
+    prUrl: string | null;
+    reviewEmojiStr: string;
+  }
+
+  const branchInfos: BranchPrInfo[] = [];
+
+  for (const branchName of ordered) {
+    const branchMeta = stack.branches[branchName]!;
+    const prNum = branchMeta.pr ?? null;
+    let prTitle = branchMeta.description || branchName;
+    let prUrl: string | null = null;
+    let review = "PENDING";
+
+    if (prNum) {
+      const info = await getPrInfo(prNum);
+      if (info) {
+        prTitle = info.title || prTitle;
+        prUrl = info.url;
+        review = info.reviewDecision || "PENDING";
+      }
+    }
+
+    branchInfos.push({
+      branch: branchName,
+      prNumber: prNum,
+      prTitle,
+      prUrl,
+      reviewEmojiStr: reviewEmoji(review),
+    });
+  }
+
+  // Update each PR that has a number
+  let vizUpdated = 0;
+
+  for (let i = 0; i < branchInfos.length; i++) {
+    const info = branchInfos[i]!;
+    if (!info.prNumber) continue;
+
+    const stackViz = buildStackViz(branchInfos, i);
+
+    const currentBody = await getPrBody(info.prNumber);
+    if (currentBody === null) 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;
+
+    const ok = await updatePrBody(info.prNumber, newBody);
+    if (ok) vizUpdated++;
+  }
+
+  // ── Summary ──
+  console.log();
+  p.outro(
+    pc.green(
+      `Done! Pushed ${pushed} branch(es), created ${created} PR(s), updated ${vizUpdated} description(s)`,
+    ),
+  );
+}