gh-stack 0.1.1 → 0.1.2

package/README.md

@@ -130,7 +130,7 @@ undo
 
 ## Not Implemented Yet
 
-These are still intended, but not shipped in `v0.1.1`:
+These are still intended, but not shipped in `v0.1.2`:
 
 ```text
 split

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "gh-stack",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Stacked PR manager for squash-merge workflows",
   "author": "Kiliman <kiliman@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/kiliman/gh-stack"
+    "url": "git+https://github.com/kiliman/gh-stack.git"
   },
   "keywords": [
     "git",

package/src/commands/add.ts

@@ -3,7 +3,7 @@ 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 { ensureMetadata, ensureCurrentStack, ensureValidStack } from "../lib/safety.ts";
 import { getPrNumber } from "../lib/github.ts";
 import { isAutoYes, selectParent } from "../lib/ui.ts";
 import type { Branch } from "../types.ts";
@@ -48,6 +48,7 @@ OPTIONS
 
   const meta = await ensureMetadata();
   const stackName = ensureCurrentStack(meta);
+  await ensureValidStack(meta, stackName);
   const stack = meta.stacks[stackName]!;
 
   p.intro(pc.cyan(`Add branch to ${pc.yellow(stackName)}`));

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

@@ -2,7 +2,7 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { removeBranchFromStack, getChildren } from "../lib/metadata.ts";
-import { ensureMetadata, ensureCurrentStack } from "../lib/safety.ts";
+import { ensureMetadata, ensureCurrentStack, ensureValidStack } from "../lib/safety.ts";
 import { takeSnapshot } from "../lib/snapshot.ts";
 import { selectBranch } from "../lib/ui.ts";
 import * as git from "../lib/git.ts";
@@ -23,6 +23,7 @@ If no branch is specified, shows interactive selector.
 
   const meta = await ensureMetadata();
   const stackName = ensureCurrentStack(meta);
+  await ensureValidStack(meta, stackName);
   const stack = meta.stacks[stackName]!;
   const currentBranch = await git.currentBranch();
 

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");
     }
 

package/src/commands/sync.ts

@@ -3,7 +3,7 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import * as git from "../lib/git.ts";
 import { findStackForBranch, getOrderedBranches, saveRestackState } 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 { confirmAction } from "../lib/ui.ts";
 
@@ -36,6 +36,7 @@ with the base branch included.
   }
 
   const stack = meta.stacks[stackName]!;
+  await ensureValidStack(meta, stackName);
   const ordered = getOrderedBranches(stack);
 
   if (ordered.length === 0) {
@@ -98,7 +99,7 @@ with the base branch included.
     const parentRef = parent === "main" ? "origin/main" : parent;
     const mb = await git.mergeBase(branch, parentRef);
     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)})`,

package/src/commands/undo.ts

@@ -1,5 +1,6 @@
 // gh-stack undo — Restore from last snapshot
 import * as p from "@clack/prompts";
+import * as git from "../lib/git.ts";
 import pc from "picocolors";
 import { ensureMetadata, ensureCleanWorkingTree } from "../lib/safety.ts";
 import { getLastSnapshot, popSnapshot } from "../lib/snapshot.ts";
@@ -47,10 +48,21 @@ a destructive operation (restack, merge, sync, remove).
     process.exit(0);
   }
 
+  let activeBranch: string | null = null;
+  try {
+    activeBranch = await git.currentBranch();
+  } catch {
+    // Detached HEAD is fine — we can restore all branches with branch -f.
+  }
+
   // Restore each branch HEAD
   for (const [branch, sha] of Object.entries(snapshot.branches)) {
     try {
-      await $`git branch -f ${branch} ${sha}`.quiet();
+      if (branch === activeBranch) {
+        await $`git reset --hard ${sha}`.quiet();
+      } else {
+        await $`git branch -f ${branch} ${sha}`.quiet();
+      }
       p.log.success(`Restored ${pc.yellow(branch)} → ${sha.slice(0, 8)}`);
     } catch {
       p.log.error(`Failed to restore ${branch}`);

package/src/index.ts

@@ -7,26 +7,28 @@ if (process.env.GH_STACK_NO_COLOR) {
 }
 
 import { ensureGitRepo } from "./lib/safety.ts";
+import { parseCliArgs } from "./lib/cli.ts";
 import { setAutoYes } from "./lib/ui.ts";
 
 const { version: VERSION } = await import("../package.json");
 
 const args = process.argv.slice(2);
-const command = args[0] || "show";
+const parsed = parseCliArgs(args, process.env);
+const command = parsed.command;
 
 // Handle global flags
-if (args.includes("--version") || args.includes("-V")) {
+if (parsed.showVersion) {
   console.log(`gh-stack v${VERSION}`);
   process.exit(0);
 }
 
-if (args.includes("--help") && !args[0]) {
+if (parsed.showGlobalHelp) {
   printHelp();
   process.exit(0);
 }
 
 // Global --yes flag: skip all interactive confirmations (for agents/CI)
-if (args.includes("--yes") || args.includes("-y") || process.env.GH_STACK_YES === "1") {
+if (parsed.autoYes) {
   setAutoYes(true);
 }
 
@@ -34,7 +36,7 @@ if (args.includes("--yes") || args.includes("-y") || process.env.GH_STACK_YES ==
 await ensureGitRepo();
 
 // Route to subcommand — strip global flags from command args
-const commandArgs = args.slice(1).filter((a) => a !== "--yes" && a !== "-y");
+const commandArgs = parsed.commandArgs;
 
 switch (command) {
   case "show":

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] || "show";
+  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.
@@ -141,6 +145,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 +244,16 @@ export async function commitCount(from: string, to: string): Promise<number> {
 }
 
 /**
- * Sanitize a branch name for use in tag names.
+ * 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";
 
@@ -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;
+}