gh-stack 0.3.1 → 0.7.0

package/src/lib/chain.ts

@@ -0,0 +1,140 @@
+// Branch-chain detection and stack reconciliation.
+//
+// Shared by `init` (interactive stack creation) and `submit` (self-healing:
+// auto-create/register a stack from a bare set of local branches so the
+// end state is always stack registered + branches pushed + PRs created).
+import * as git from "./git.ts";
+import { findStackForBranch } from "./metadata.ts";
+import type { StackMetadata, Branch } from "../types.ts";
+
+/**
+ * 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. Branches already
+ * merged into trunk are skipped (stale/old branches).
+ *
+ * Returns branches in bottom-up order: [closest-to-trunk, ..., current].
+ * For a branch based directly off trunk, returns just [current].
+ */
+export 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 interface StackResolution {
+  stackName: string;
+  chain: string[]; // trunk→current order
+  created: boolean; // true if a brand-new stack was created
+  addedBranches: string[]; // branches newly registered into the stack
+}
+
+/**
+ * Ensure a stack exists for `branch`, reconstructing it from local branch
+ * ancestry if needed. Mutates `meta` in place but does NOT persist — the
+ * caller decides when to write (so `--dry-run` can preview without side
+ * effects).
+ *
+ * Behavior:
+ *   - Detects the chain trunk→current.
+ *   - If any branch in the chain already belongs to a stack, reconciles
+ *     into that existing stack (adds only the missing branches).
+ *   - Otherwise creates a new stack named after the current branch
+ *     (auto-suffixed if that name is taken).
+ *   - Registers missing branches with correct parent links (chain[0]'s
+ *     parent is trunk; each subsequent branch's parent is the prior one).
+ *
+ * Throws if the chain spans more than one existing stack (ambiguous).
+ */
+export async function resolveOrCreateStack(
+  meta: StackMetadata,
+  branch: string,
+  trunk: string,
+): Promise<StackResolution> {
+  const chain = await detectBranchChain(branch, trunk);
+
+  // Which existing stacks (if any) already own branches in this chain?
+  const owningStacks = new Set<string>();
+  for (const b of chain) {
+    const owner = findStackForBranch(meta, b);
+    if (owner) owningStacks.add(owner);
+  }
+
+  if (owningStacks.size > 1) {
+    throw new Error(
+      `Branches in this chain span multiple stacks (${[...owningStacks].join(
+        ", ",
+      )}). Resolve manually with gh-stack init / delete.`,
+    );
+  }
+
+  let stackName: string;
+  let created = false;
+
+  if (owningStacks.size === 1) {
+    // Reconcile into the existing stack
+    stackName = [...owningStacks][0]!;
+  } else {
+    // Create a new stack named after the current branch (auto-suffix on clash)
+    stackName = branch;
+    let n = 2;
+    while (meta.stacks[stackName]) {
+      stackName = `${branch}-${n++}`;
+    }
+    meta.stacks[stackName] = {
+      description: "",
+      last_branch: null,
+      branches: {},
+    };
+    meta.current_stack = stackName;
+    created = true;
+  }
+
+  const stack = meta.stacks[stackName]!;
+  const addedBranches: string[] = [];
+
+  // Register missing branches with correct parent links.
+  for (let i = 0; i < chain.length; i++) {
+    const name = chain[i]!;
+    if (stack.branches[name]) continue; // already tracked — leave as-is
+
+    const parent = i === 0 ? trunk : chain[i - 1]!;
+    const branchData: Branch = { parent };
+    stack.branches[name] = branchData;
+    stack.last_branch = name;
+    addedBranches.push(name);
+  }
+
+  return { stackName, chain, created, addedBranches };
+}

package/src/lib/cli.ts

@@ -2,11 +2,12 @@ export interface ParsedCliArgs {
   command: string;
   commandArgs: string[];
   autoYes: boolean;
+  plain: boolean;
   showVersion: boolean;
   showGlobalHelp: boolean;
 }
 
-const LEADING_GLOBAL_FLAGS = new Set(["--yes", "-y", "--help", "--version", "-V"]);
+const LEADING_GLOBAL_FLAGS = new Set(["--yes", "-y", "--plain", "--help", "--version", "-V"]);
 
 export function parseCliArgs(rawArgs: string[], env: NodeJS.ProcessEnv): ParsedCliArgs {
   let commandIndex = 0;
@@ -20,12 +21,18 @@ export function parseCliArgs(rawArgs: string[], env: NodeJS.ProcessEnv): ParsedC
   const command = rawArgs[commandIndex] || "log";
   const commandArgs = rawArgs
     .slice(commandIndex + 1)
-    .filter((arg) => arg !== "--yes" && arg !== "-y");
+    .filter((arg) => arg !== "--yes" && arg !== "-y" && arg !== "--plain");
+
+  const autoYes = rawArgs.includes("--yes") || rawArgs.includes("-y") || env.GH_STACK_YES === "1";
+  // Plain mode auto-enables under GH_STACK_YES=1 (agents skip the chrome anyway)
+  // or explicit --plain. Both compose with each other.
+  const plain = autoYes || rawArgs.includes("--plain") || env.GH_STACK_PLAIN === "1";
 
   return {
     command,
     commandArgs,
-    autoYes: rawArgs.includes("--yes") || rawArgs.includes("-y") || env.GH_STACK_YES === "1",
+    autoYes,
+    plain,
     showVersion: leadingFlags.has("--version") || leadingFlags.has("-V"),
     showGlobalHelp: !rawArgs[commandIndex] && leadingFlags.has("--help"),
   };

package/src/lib/git.ts

@@ -254,6 +254,16 @@ export async function allLocalBranches(): Promise<string[]> {
   return result.trim().split("\n").filter(Boolean);
 }
 
+/**
+ * Determine the trunk branch name. Prefers "main", falls back to "master"
+ * if only that exists locally. Defaults to "main" when neither is present.
+ */
+export async function trunkBranch(): Promise<string> {
+  if (await localBranchExists("main")) return "main";
+  if (await localBranchExists("master")) return "master";
+  return "main";
+}
+
 /**
  * Build a deterministic temp tag name for a branch.
  * Includes a readable slug plus a stable hash to avoid collisions.

package/src/lib/output.ts

@@ -0,0 +1,90 @@
+// Plain-mode-aware wrapper over @clack/prompts.
+//
+// In plain mode (--plain flag or GH_STACK_YES=1), we strip the decorative
+// chrome that makes gh-stack output painful for agents/log consumers:
+//   - no intro/outro boxes
+//   - no spinners (start/stop lines collapse to plain prints)
+//   - no ANSI colors (picocolors auto-disables via NO_COLOR; we also strip
+//     any residual escapes defensively)
+//
+// Interactive prompts (text, confirm, select) are re-exported unchanged —
+// plain mode is about output, not interactivity. Agents already pair --plain
+// with --yes/GH_STACK_YES so the interactive paths aren't reached.
+import * as clack from "@clack/prompts";
+
+let _plain = false;
+
+export function setPlain(enabled: boolean): void {
+  _plain = enabled;
+}
+
+export function isPlain(): boolean {
+  return _plain;
+}
+
+const ANSI_RE = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
+function strip(s: string | undefined): string {
+  return (s ?? "").replace(ANSI_RE, "");
+}
+
+// ── Interactive prompts (unchanged) ──
+export const isCancel = clack.isCancel;
+export const text = clack.text;
+export const confirm = clack.confirm;
+export const select = clack.select;
+
+// ── Banner / error ──
+export function intro(message?: string): void {
+  if (_plain) {
+    if (message) console.log(strip(message));
+  } else {
+    clack.intro(message);
+  }
+}
+
+export function outro(message?: string): void {
+  if (_plain) {
+    if (message) console.log(strip(message));
+  } else {
+    clack.outro(message);
+  }
+}
+
+export function cancel(message?: string): void {
+  if (_plain) {
+    if (message) console.error(strip(message));
+  } else {
+    clack.cancel(message);
+  }
+}
+
+// ── log.* ──
+export const log = {
+  info: (msg: string) => (_plain ? console.log(strip(msg)) : clack.log.info(msg)),
+  success: (msg: string) => (_plain ? console.log(strip(msg)) : clack.log.success(msg)),
+  warn: (msg: string) => (_plain ? console.warn(strip(msg)) : clack.log.warn(msg)),
+  error: (msg: string) => (_plain ? console.error(strip(msg)) : clack.log.error(msg)),
+  step: (msg: string) => (_plain ? console.log(strip(msg)) : clack.log.step(msg)),
+};
+
+// ── Spinner ──
+export interface Spinner {
+  start: (msg?: string) => void;
+  stop: (msg?: string, code?: number) => void;
+  message: (msg?: string) => void;
+}
+
+export function spinner(): Spinner {
+  if (!_plain) return clack.spinner() as Spinner;
+  return {
+    start: (msg) => {
+      if (msg) console.log(strip(msg));
+    },
+    stop: (msg) => {
+      if (msg) console.log(strip(msg));
+    },
+    message: (msg) => {
+      if (msg) console.log(strip(msg));
+    },
+  };
+}

package/src/lib/safety.ts

@@ -2,7 +2,7 @@
 import * as git from "./git.ts";
 import { metadataExists, readMetadata, findStackForBranch } from "./metadata.ts";
 import type { StackMetadata, Stack } from "../types.ts";
-import * as p from "@clack/prompts";
+import * as p from "./output.ts";
 import pc from "picocolors";
 
 /**

package/src/lib/snapshot.ts

@@ -1,8 +1,81 @@
-// Snapshot system for undo support
+// Snapshot system for undo support and pre-rewrite base recovery
 import type { StackMetadata, Snapshot } from "../types.ts";
 import * as git from "./git.ts";
 import { writeMetadata, getOrderedBranches } from "./metadata.ts";
 
+/**
+ * Find the pre-rewrite SHA for a parent branch by walking snapshots newest-first.
+ *
+ * Returns the SHA from the most recent snapshot whose recorded tip for
+ * `parentBranch` is NOT an ancestor of the parent's current tip — meaning
+ * that snapshot was taken before the parent's history got rewritten
+ * (typically by `sync` rebasing it onto a new main).
+ *
+ * That pre-rewrite SHA is the correct rebase base when restacking a child
+ * onto this parent — `git rebase --onto <new-tip> <pre-rewrite-tip> <child>`
+ * replays only the child's unique commits, never the parent's old history.
+ *
+ * **Child validation (issue #5)**: When `childBranch` is provided, any candidate
+ * SHA must also still be an ancestor of the child. If the child has already
+ * been rebased past this point (e.g., a previous restack already moved it),
+ * the recorded SHA is stale for this child and would cause `rebase --onto`
+ * to replay a wildly wrong range. We skip those candidates and keep walking.
+ *
+ * Returns null if no snapshots exist, no recorded tip qualifies, or every
+ * snapshot's recorded tip is still an ancestor of the parent's current tip
+ * (i.e., the parent has only had commits appended, never been rebased —
+ * `merge-base` is still correct).
+ */
+export async function findPreRewriteSha(
+  meta: StackMetadata,
+  parentBranch: string,
+  childBranch?: string,
+): Promise<string | null> {
+  if (!meta.snapshots || meta.snapshots.length === 0) return null;
+
+  let currentParentTip: string;
+  try {
+    currentParentTip = await git.revParse(parentBranch);
+  } catch {
+    return null;
+  }
+
+  let currentChildTip: string | null = null;
+  if (childBranch) {
+    try {
+      currentChildTip = await git.revParse(childBranch);
+    } catch {
+      // Child doesn't exist locally — fall back to parent-only validation
+      currentChildTip = null;
+    }
+  }
+
+  // Walk newest → oldest
+  for (let i = meta.snapshots.length - 1; i >= 0; i--) {
+    const recorded = meta.snapshots[i]!.branches[parentBranch];
+    if (!recorded) continue;
+    if (recorded === currentParentTip) continue;
+
+    // The recorded SHA must no longer be an ancestor of the parent's current
+    // tip — that's how we detect the parent's history was rewritten.
+    const stillAncestorOfParent = await git.isAncestor(recorded, currentParentTip);
+    if (stillAncestorOfParent) continue;
+
+    // Issue #5 guard: if we know the child, the recorded SHA must still be
+    // an ancestor of the child. Otherwise the child has already been rebased
+    // past this point (or never branched off it) and using it as a base
+    // would replay unrelated history.
+    if (currentChildTip) {
+      const stillAncestorOfChild = await git.isAncestor(recorded, currentChildTip);
+      if (!stillAncestorOfChild) continue;
+    }
+
+    return recorded;
+  }
+
+  return null;
+}
+
 const MAX_SNAPSHOTS = 10;
 
 /**

package/src/lib/ui.ts

@@ -1,5 +1,5 @@
 // TUI helpers: tree rendering, formatting, prompts
-import * as p from "@clack/prompts";
+import * as p from "./output.ts";
 import pc from "picocolors";
 import type { Stack, StackMetadata } from "../types.ts";
 import { getOrderedBranches } from "./metadata.ts";