gh-stack 0.1.1 → 0.2.0

package/src/lib/cli.ts

@@ -0,0 +1,32 @@
+export interface ParsedCliArgs {
+  command: string;
+  commandArgs: string[];
+  autoYes: boolean;
+  showVersion: boolean;
+  showGlobalHelp: boolean;
+}
+
+const LEADING_GLOBAL_FLAGS = new Set(["--yes", "-y", "--help", "--version", "-V"]);
+
+export function parseCliArgs(rawArgs: string[], env: NodeJS.ProcessEnv): ParsedCliArgs {
+  let commandIndex = 0;
+  const leadingFlags = new Set<string>();
+
+  while (commandIndex < rawArgs.length && LEADING_GLOBAL_FLAGS.has(rawArgs[commandIndex]!)) {
+    leadingFlags.add(rawArgs[commandIndex]!);
+    commandIndex++;
+  }
+
+  const command = rawArgs[commandIndex] || "log";
+  const commandArgs = rawArgs
+    .slice(commandIndex + 1)
+    .filter((arg) => arg !== "--yes" && arg !== "-y");
+
+  return {
+    command,
+    commandArgs,
+    autoYes: rawArgs.includes("--yes") || rawArgs.includes("-y") || env.GH_STACK_YES === "1",
+    showVersion: leadingFlags.has("--version") || leadingFlags.has("-V"),
+    showGlobalHelp: !rawArgs[commandIndex] && leadingFlags.has("--help"),
+  };
+}

package/src/lib/git.ts

@@ -1,5 +1,9 @@
 // Git command helpers using Bun's shell API
 import { $ } from "bun";
+import { createHash } from "node:crypto";
+
+export const STACK_SYNC_TAG_PREFIX = "stack-sync-base";
+export const STACK_SYNC_TAG_GLOB = `${STACK_SYNC_TAG_PREFIX}-*`;
 
 /**
  * Get the current branch name.
@@ -36,9 +40,12 @@ export async function gitDir(): Promise<string> {
 
 /**
  * Check if working tree is clean (no uncommitted changes).
+ * Refreshes the index first to avoid false positives from stale stat info.
  */
 export async function isCleanWorkingTree(): Promise<boolean> {
   try {
+    // Refresh index to avoid false positives from stat changes (timestamps, etc.)
+    await $`git update-index -q --refresh`.quiet().nothrow();
     await $`git diff-index --quiet HEAD --`.quiet();
     return true;
   } catch {
@@ -141,6 +148,16 @@ export async function remoteBranchExists(branch: string): Promise<boolean> {
   return exitCode === 0;
 }
 
+/**
+ * Check if a branch exists locally.
+ */
+export async function localBranchExists(branch: string): Promise<boolean> {
+  const { exitCode } = await $`git show-ref --verify --quiet refs/heads/${branch}`
+    .nothrow()
+    .quiet();
+  return exitCode === 0;
+}
+
 /**
  * Create a temporary tag at a specific commit.
  */
@@ -230,8 +247,24 @@ export async function commitCount(from: string, to: string): Promise<number> {
 }
 
 /**
- * Sanitize a branch name for use in tag names.
+ * Get all local branch names.
+ */
+export async function allLocalBranches(): Promise<string[]> {
+  const result = await $`git branch --format=${"%(refname:short)"}`.text();
+  return result.trim().split("\n").filter(Boolean);
+}
+
+/**
+ * Build a deterministic temp tag name for a branch.
+ * Includes a readable slug plus a stable hash to avoid collisions.
  */
-export function sanitizeBranchForTag(branch: string): string {
-  return branch.replace(/[^a-zA-Z0-9-]/g, "_");
+export function tempBaseTagName(branch: string): string {
+  const slug =
+    branch
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 24) || "branch";
+  const hash = createHash("sha256").update(branch).digest("hex").slice(0, 10);
+  return `${STACK_SYNC_TAG_PREFIX}-${slug}-${hash}`;
 }

package/src/lib/safety.ts

@@ -1,7 +1,7 @@
 // Pre-flight safety checks
 import * as git from "./git.ts";
 import { metadataExists, readMetadata, findStackForBranch } from "./metadata.ts";
-import type { StackMetadata } from "../types.ts";
+import type { StackMetadata, Stack } from "../types.ts";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 
@@ -58,7 +58,7 @@ export async function ensureBranchInStack(meta: StackMetadata): Promise<string>
 
   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")}`,
+      `Branch ${pc.blue(branch)} is not in any stack.\n\n  Add it with:\n    ${pc.green("gh-stack create")}\n\n  Or create a new stack:\n    ${pc.green("gh-stack init")}`,
     );
     process.exit(1);
   }
@@ -96,3 +96,111 @@ export function ensureNotMain(branch: string): void {
     process.exit(1);
   }
 }
+
+/**
+ * Validate stack metadata before destructive operations.
+ */
+export async function validateStack(meta: StackMetadata, stackName: string): Promise<string[]> {
+  const stack = meta.stacks[stackName];
+  if (!stack) return [`Stack "${stackName}" not found`];
+
+  const branchNames = Object.keys(stack.branches);
+  const errors: string[] = [];
+
+  for (const branchName of branchNames) {
+    const branch = stack.branches[branchName]!;
+
+    if (!(await git.localBranchExists(branchName))) {
+      errors.push(`Branch "${branchName}" does not exist locally`);
+    }
+
+    if (branch.parent === branchName) {
+      errors.push(`Branch "${branchName}" cannot be its own parent`);
+    }
+
+    if (branch.parent !== "main" && branch.parent !== "master" && !stack.branches[branch.parent]) {
+      errors.push(`Branch "${branchName}" has unknown parent "${branch.parent}"`);
+    }
+  }
+
+  errors.push(...validateStackGraph(stack));
+  return errors;
+}
+
+export async function ensureValidStack(meta: StackMetadata, stackName: string): Promise<void> {
+  const errors = await validateStack(meta, stackName);
+  if (errors.length === 0) return;
+
+  p.cancel(`Invalid stack metadata for ${pc.yellow(stackName)}`);
+  console.log();
+  for (const error of errors) {
+    console.log(`  ${pc.red("•")} ${error}`);
+  }
+  console.log();
+  console.log(
+    pc.dim("Fix .git/gh-stack-metadata.json or repair the local branches before retrying."),
+  );
+  process.exit(1);
+}
+
+function validateStackGraph(stack: Stack): string[] {
+  const branchNames = Object.keys(stack.branches);
+  if (branchNames.length === 0) return [];
+
+  const errors: string[] = [];
+  const roots = branchNames.filter((branchName) => {
+    const parent = stack.branches[branchName]!.parent;
+    return parent === "main" || parent === "master";
+  });
+
+  if (roots.length === 0) {
+    errors.push("Stack has no root branch with parent main/master");
+  }
+  if (roots.length > 1) {
+    errors.push(`Stack must have exactly one root branch; found ${roots.length}`);
+  }
+
+  const childrenByParent = new Map<string, string[]>();
+  for (const [branchName, branch] of Object.entries(stack.branches)) {
+    const siblings = childrenByParent.get(branch.parent) ?? [];
+    siblings.push(branchName);
+    childrenByParent.set(branch.parent, siblings);
+  }
+
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+
+  function walk(branchName: string) {
+    if (visiting.has(branchName)) {
+      errors.push(`Cycle detected involving "${branchName}"`);
+      return;
+    }
+    if (visited.has(branchName)) return;
+
+    visiting.add(branchName);
+    for (const child of childrenByParent.get(branchName) ?? []) {
+      walk(child);
+    }
+    visiting.delete(branchName);
+    visited.add(branchName);
+  }
+
+  for (const root of roots) {
+    walk(root);
+  }
+
+  // If the graph is malformed, walk any remaining nodes so we can report
+  // cycles/unreachable branches instead of stopping at the root error.
+  for (const branchName of branchNames) {
+    if (!visited.has(branchName)) {
+      walk(branchName);
+    }
+  }
+
+  if (visited.size !== branchNames.length) {
+    const unreachable = branchNames.filter((branchName) => !visited.has(branchName));
+    errors.push(`Unreachable or cyclic branches detected: ${unreachable.join(", ")}`);
+  }
+
+  return errors;
+}

package/src/commands/add.ts

@@ -1,139 +0,0 @@
-// gh-stack add — Add a branch to the current stack
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-import * as git from "../lib/git.ts";
-import { addBranchToStack, getTopOfStack, getOrderedBranches } from "../lib/metadata.ts";
-import { ensureMetadata, ensureCurrentStack } from "../lib/safety.ts";
-import { getPrNumber } from "../lib/github.ts";
-import { isAutoYes, selectParent } from "../lib/ui.ts";
-import type { Branch } from "../types.ts";
-
-export default async function add(args: string[]): Promise<void> {
-  // Parse flags
-  let parentFlag: string | undefined;
-  let descFlag: string | undefined;
-  let createFlag: string | undefined;
-  let branchArg: string | undefined;
-
-  for (let i = 0; i < args.length; i++) {
-    switch (args[i]) {
-      case "--parent":
-        parentFlag = args[++i];
-        break;
-      case "--description":
-        descFlag = args[++i];
-        break;
-      case "--create":
-        createFlag = args[++i];
-        break;
-      case "--help":
-        console.log(`
-gh-stack add — Add a branch to the current stack
-
-USAGE
-  gh-stack add [<branch>] [options]
-
-OPTIONS
-  --parent <branch>     Parent branch (default: top of stack)
-  --create <branch>     Create new branch off top of stack and add it
-  --description <desc>  Description for the branch
-`);
-        return;
-      default:
-        if (!args[i]!.startsWith("--")) {
-          branchArg = args[i];
-        }
-    }
-  }
-
-  const meta = await ensureMetadata();
-  const stackName = ensureCurrentStack(meta);
-  const stack = meta.stacks[stackName]!;
-
-  p.intro(pc.cyan(`Add branch to ${pc.yellow(stackName)}`));
-
-  let branchToAdd: string;
-
-  // --create: make a new branch off the top of the stack
-  if (createFlag) {
-    const topBranch = getTopOfStack(stack);
-    if (!topBranch) {
-      p.cancel("Stack has no branches yet. Add the base branch first.");
-      process.exit(1);
-    }
-
-    const currentBranch = await git.currentBranch();
-    if (currentBranch !== topBranch) {
-      p.log.info(`Switching to ${pc.yellow(topBranch)}...`);
-      await git.checkout(topBranch);
-    }
-
-    p.log.info(`Creating branch off top of stack: ${pc.yellow(topBranch)}`);
-    await git.createBranch(createFlag);
-    p.log.success(`Created branch: ${pc.yellow(createFlag)}`);
-
-    branchToAdd = createFlag;
-    parentFlag = topBranch;
-  } else {
-    branchToAdd = branchArg || (await git.currentBranch());
-  }
-
-  // Check if branch is already in the stack
-  if (stack.branches[branchToAdd]) {
-    p.cancel(`Branch ${pc.yellow(branchToAdd)} is already in stack ${pc.blue(stackName)}`);
-    process.exit(1);
-  }
-
-  console.log(`  Adding: ${pc.yellow(branchToAdd)}`);
-  console.log();
-
-  // Get parent
-  let parent = parentFlag;
-  if (!parent) {
-    // Default to top of stack
-    const ordered = getOrderedBranches(stack);
-
-    if (ordered.length === 0) {
-      parent = "main";
-    } else if (isAutoYes()) {
-      parent = getTopOfStack(stack) ?? "main";
-    } else {
-      parent = (await selectParent(stack, branchToAdd)) ?? undefined;
-      if (!parent) {
-        p.cancel("Cancelled");
-        process.exit(0);
-      }
-    }
-  }
-
-  p.log.info(`Parent: ${pc.yellow(parent)}`);
-
-  // Auto-detect PR number
-  const s = p.spinner();
-  s.start("Looking for PR...");
-  const prNumber = await getPrNumber(branchToAdd);
-  s.stop(prNumber ? `Found PR #${prNumber}` : "No PR found");
-
-  // Get description
-  let description = descFlag;
-  if (description === undefined && !createFlag) {
-    const result = await p.text({
-      message: "Branch description (optional)",
-      placeholder: "e.g., API layer",
-    });
-    if (!p.isCancel(result)) {
-      description = (result as string) || undefined;
-    }
-  }
-
-  // Add branch
-  const branchData: Branch = {
-    parent,
-    ...(prNumber && { pr: prNumber }),
-    ...(description && { description }),
-  };
-
-  await addBranchToStack(meta, stackName, branchToAdd, branchData);
-
-  p.outro(pc.green(`Added ${pc.yellow(branchToAdd)} to stack ${pc.blue(stackName)}`));
-}