gh-stack 0.1.1 → 0.2.0

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/merge.ts

@@ -4,7 +4,7 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import { findStackForBranch, getOrderedBranches, writeMetadata } from "../lib/metadata.ts";
-import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";
+import { ensureMetadata, ensureCleanWorkingTree, ensureValidStack } from "../lib/safety.ts";
 import { takeSnapshot } from "../lib/snapshot.ts";
 import { closePr } from "../lib/github.ts";
 import { confirmAction } from "../lib/ui.ts";
@@ -39,6 +39,7 @@ This keeps all commits local (avoiding orphaned squash commits).
   }
 
   const stack = meta.stacks[stackName]!;
+  await ensureValidStack(meta, stackName);
   const ordered = getOrderedBranches(stack);
 
   if (ordered.length <= 1) {

package/src/commands/restack.ts

@@ -10,7 +10,12 @@ import {
   loadRestackState,
   clearRestackState,
 } from "../lib/metadata.ts";
-import { ensureMetadata, ensureCleanWorkingTree, ensureNotMain } from "../lib/safety.ts";
+import {
+  ensureMetadata,
+  ensureCleanWorkingTree,
+  ensureNotMain,
+  ensureValidStack,
+} from "../lib/safety.ts";
 import { takeSnapshot } from "../lib/snapshot.ts";
 import { confirmAction } from "../lib/ui.ts";
 import type { StackMetadata } from "../types.ts";
@@ -72,7 +77,7 @@ ALIASES
   }
 
   // Cleanup tags
-  await git.deleteTagsMatching("stack-sync-*");
+  await git.deleteTagsMatching(git.STACK_SYNC_TAG_GLOB);
 
   p.outro(pc.green("Stack Restack Complete!"));
 }
@@ -142,7 +147,7 @@ async function handleResume(
       const parent = stack.branches[branch]?.parent;
       if (!parent) continue;
 
-      const tagName = `stack-sync-base-${git.sanitizeBranchForTag(branch)}`;
+      const tagName = git.tempBaseTagName(branch);
       if (await git.tagExists(tagName)) {
         const tagSha = await git.revParse(tagName);
         console.log(
@@ -183,6 +188,7 @@ async function handleFreshRestack(
   }
 
   const stack = meta.stacks[stackName]!;
+  await ensureValidStack(meta, stackName);
 
   // Check for stale tags from previous runs
   await handleStaleTags();
@@ -247,7 +253,7 @@ async function handleFreshRestack(
 
       const mb = await git.mergeBase(branch, parent);
       if (mb) {
-        const tagName = `stack-sync-base-${git.sanitizeBranchForTag(branch)}`;
+        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)})`,
@@ -319,7 +325,7 @@ async function processChain(
     });
 
     // Use temporary tag as stable base reference
-    const tagName = `stack-sync-base-${git.sanitizeBranchForTag(branch)}`;
+    const tagName = git.tempBaseTagName(branch);
     let success: boolean;
 
     if (await git.tagExists(tagName)) {
@@ -433,11 +439,11 @@ async function promptPush(branch: string): Promise<void> {
 async function handleStaleTags(): Promise<void> {
   try {
     const { $ } = await import("bun");
-    const result = await $`git tag -l "stack-sync-*"`.text();
+    const result = await $`git tag -l ${git.STACK_SYNC_TAG_GLOB}`.text();
     const tags = result.trim();
     if (!tags) return;
 
-    p.log.warn("Found stale stack-sync-* tags from a previous run");
+    p.log.warn(`Found stale ${git.STACK_SYNC_TAG_GLOB} tags from a previous run`);
     console.log();
 
     const action = await p.select({
@@ -462,7 +468,7 @@ async function handleStaleTags(): Promise<void> {
 
     if (action === "clean") {
       p.log.info("Cleaning up stale tags...");
-      await git.deleteTagsMatching("stack-sync-*");
+      await git.deleteTagsMatching(git.STACK_SYNC_TAG_GLOB);
       p.log.success("Tags cleaned");
     }