dubstack 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,125 +1,1104 @@
 #!/usr/bin/env node
-/**
- * DubStack CLI — manage stacked diffs with ease.
- *
- * A local-first tool for managing chains of dependent git branches
- * (stacked diffs) without manually dealing with complex rebase chains.
- *
- * @example
- * ```bash
- * dub init                    # Initialize in current repo
- * dub create feat/my-branch   # Create stacked branch
- * dub log                     # View stack tree
- * dub restack                 # Rebase stack onto updated parent
- * dub undo                    # Undo last dub operation
- * ```
- *
- * @packageDocumentation
- */
-import { createRequire } from "node:module";
+
+// src/index.ts
+import { createRequire } from "module";
 import chalk from "chalk";
 import { Command } from "commander";
-import { create } from "./commands/create.js";
-import { init } from "./commands/init.js";
-import { log } from "./commands/log.js";
-import { restack, restackContinue } from "./commands/restack.js";
-import { undo } from "./commands/undo.js";
-import { DubError } from "./lib/errors.js";
-const require = createRequire(import.meta.url);
-const { version } = require("../package.json");
-const program = new Command();
-program
-    .name("dub")
-    .description("Manage stacked diffs (dependent git branches) with ease")
-    .version(version);
-program
-    .command("init")
-    .description("Initialize DubStack in the current git repository")
-    .addHelpText("after", `
-Examples:
-  $ dub init    Initialize DubStack, creating .git/dubstack/ and updating .gitignore`)
-    .action(async () => {
-    const result = await init(process.cwd());
-    if (result.status === "created") {
-        console.log(chalk.green("✔ DubStack initialized"));
+
+// src/lib/errors.ts
+var DubError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DubError";
+  }
+};
+
+// src/lib/git.ts
+import { execa } from "execa";
+async function isGitRepo(cwd) {
+  try {
+    const { stdout } = await execa(
+      "git",
+      ["rev-parse", "--is-inside-work-tree"],
+      { cwd }
+    );
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+async function getRepoRoot(cwd) {
+  try {
+    const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"], {
+      cwd
+    });
+    return stdout.trim();
+  } catch {
+    throw new DubError(
+      "Not a git repository. Run this command inside a git repo."
+    );
+  }
+}
+async function getCurrentBranch(cwd) {
+  try {
+    const { stdout } = await execa(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      { cwd }
+    );
+    const branch = stdout.trim();
+    if (branch === "HEAD") {
+      throw new DubError(
+        "HEAD is detached. Checkout a branch before running this command."
+      );
     }
-    else {
-        console.log(chalk.yellow("⚠ DubStack already initialized"));
+    return branch;
+  } catch (error) {
+    if (error instanceof DubError) throw error;
+    throw new DubError(
+      "Repository has no commits. Make at least one commit first."
+    );
+  }
+}
+async function branchExists(name, cwd) {
+  try {
+    await execa("git", ["rev-parse", "--verify", `refs/heads/${name}`], {
+      cwd
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBranch(name, cwd) {
+  if (await branchExists(name, cwd)) {
+    throw new DubError(`Branch '${name}' already exists.`);
+  }
+  await execa("git", ["checkout", "-b", name], { cwd });
+}
+async function checkoutBranch(name, cwd) {
+  try {
+    await execa("git", ["checkout", name], { cwd });
+  } catch {
+    throw new DubError(`Branch '${name}' not found.`);
+  }
+}
+async function deleteBranch(name, cwd) {
+  try {
+    await execa("git", ["branch", "-D", name], { cwd });
+  } catch {
+    throw new DubError(`Failed to delete branch '${name}'. It may not exist.`);
+  }
+}
+async function forceBranchTo(name, sha, cwd) {
+  try {
+    const current = await getCurrentBranch(cwd).catch(() => null);
+    if (current === name) {
+      await execa("git", ["reset", "--hard", sha], { cwd });
+    } else {
+      await execa("git", ["branch", "-f", name, sha], { cwd });
     }
-});
-program
-    .command("create")
-    .argument("<branch-name>", "Name of the new branch to create")
-    .description("Create a new branch stacked on top of the current branch")
-    .addHelpText("after", `
+  } catch (error) {
+    if (error instanceof DubError) throw error;
+    throw new DubError(`Failed to reset branch '${name}' to ${sha}.`);
+  }
+}
+async function isWorkingTreeClean(cwd) {
+  const { stdout } = await execa("git", ["status", "--porcelain"], { cwd });
+  return stdout.trim() === "";
+}
+async function rebaseOnto(newBase, oldBase, branch, cwd) {
+  try {
+    await execa("git", ["rebase", "--onto", newBase, oldBase, branch], { cwd });
+  } catch {
+    throw new DubError(
+      `Conflict while restacking '${branch}'.
+  Resolve conflicts, stage changes, then run: dub restack --continue`
+    );
+  }
+}
+async function rebaseContinue(cwd) {
+  try {
+    await execa("git", ["rebase", "--continue"], {
+      cwd,
+      env: { GIT_EDITOR: "true" }
+    });
+  } catch {
+    throw new DubError(
+      "Failed to continue rebase. Ensure all conflicts are resolved and staged."
+    );
+  }
+}
+async function getMergeBase(a, b, cwd) {
+  try {
+    const { stdout } = await execa("git", ["merge-base", a, b], { cwd });
+    return stdout.trim();
+  } catch {
+    throw new DubError(
+      `Could not find common ancestor between '${a}' and '${b}'.`
+    );
+  }
+}
+async function getBranchTip(name, cwd) {
+  try {
+    const { stdout } = await execa("git", ["rev-parse", name], { cwd });
+    return stdout.trim();
+  } catch {
+    throw new DubError(`Branch '${name}' not found.`);
+  }
+}
+async function getLastCommitMessage(branch, cwd) {
+  try {
+    const { stdout } = await execa(
+      "git",
+      ["log", "-1", "--format=%s", branch],
+      { cwd }
+    );
+    const message = stdout.trim();
+    if (!message) {
+      throw new DubError(`Branch '${branch}' has no commits.`);
+    }
+    return message;
+  } catch (error) {
+    if (error instanceof DubError) throw error;
+    throw new DubError(`Failed to read commit message for '${branch}'.`);
+  }
+}
+async function pushBranch(branch, cwd) {
+  try {
+    await execa("git", ["push", "--force-with-lease", "origin", branch], {
+      cwd
+    });
+  } catch {
+    throw new DubError(
+      `Failed to push '${branch}'. The remote ref may have been updated by someone else.`
+    );
+  }
+}
+async function stageAll(cwd) {
+  try {
+    await execa("git", ["add", "-A"], { cwd });
+  } catch {
+    throw new DubError("Failed to stage changes.");
+  }
+}
+async function hasStagedChanges(cwd) {
+  try {
+    await execa("git", ["diff", "--cached", "--quiet"], { cwd });
+    return false;
+  } catch (error) {
+    const exitCode = error.exitCode;
+    if (exitCode === 1) return true;
+    throw new DubError("Failed to check staged changes.");
+  }
+}
+async function commitStaged(message, cwd) {
+  try {
+    await execa("git", ["commit", "-m", message], { cwd });
+  } catch {
+    throw new DubError(
+      `Commit failed. Ensure there are staged changes and git hooks pass.`
+    );
+  }
+}
+
+// src/lib/state.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+async function getStatePath(cwd) {
+  const root = await getRepoRoot(cwd);
+  return path.join(root, ".git", "dubstack", "state.json");
+}
+async function getDubDir(cwd) {
+  const root = await getRepoRoot(cwd);
+  return path.join(root, ".git", "dubstack");
+}
+async function readState(cwd) {
+  const statePath = await getStatePath(cwd);
+  if (!fs.existsSync(statePath)) {
+    throw new DubError("DubStack is not initialized. Run 'dub init' first.");
+  }
+  try {
+    const raw = fs.readFileSync(statePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    throw new DubError(
+      "State file is corrupted. Delete .git/dubstack and run 'dub init' to re-initialize."
+    );
+  }
+}
+async function writeState(state, cwd) {
+  const statePath = await getStatePath(cwd);
+  const dir = path.dirname(statePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
+`);
+}
+async function initState(cwd) {
+  const statePath = await getStatePath(cwd);
+  const dir = path.dirname(statePath);
+  if (fs.existsSync(statePath)) {
+    return "already_exists";
+  }
+  fs.mkdirSync(dir, { recursive: true });
+  const emptyState = { stacks: [] };
+  fs.writeFileSync(statePath, `${JSON.stringify(emptyState, null, 2)}
+`);
+  return "created";
+}
+async function ensureState(cwd) {
+  try {
+    return await readState(cwd);
+  } catch (error) {
+    if (error instanceof DubError && error.message.includes("not initialized")) {
+      await initState(cwd);
+      return await readState(cwd);
+    }
+    throw error;
+  }
+}
+function findStackForBranch(state, name) {
+  return state.stacks.find(
+    (stack) => stack.branches.some((b) => b.name === name)
+  );
+}
+function addBranchToStack(state, child, parent) {
+  if (findStackForBranch(state, child)) {
+    throw new DubError(`Branch '${child}' is already tracked in a stack.`);
+  }
+  const childBranch = {
+    name: child,
+    parent,
+    pr_number: null,
+    pr_link: null
+  };
+  const existingStack = findStackForBranch(state, parent);
+  if (existingStack) {
+    existingStack.branches.push(childBranch);
+  } else {
+    const rootBranch = {
+      name: parent,
+      type: "root",
+      parent: null,
+      pr_number: null,
+      pr_link: null
+    };
+    state.stacks.push({
+      id: crypto.randomUUID(),
+      branches: [rootBranch, childBranch]
+    });
+  }
+}
+function topologicalOrder(stack) {
+  const result = [];
+  const root = stack.branches.find((b) => b.type === "root");
+  if (!root) return result;
+  const childMap = /* @__PURE__ */ new Map();
+  for (const branch of stack.branches) {
+    if (branch.parent) {
+      const children = childMap.get(branch.parent) ?? [];
+      children.push(branch);
+      childMap.set(branch.parent, children);
+    }
+  }
+  const queue = [root];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) break;
+    result.push(current);
+    const children = childMap.get(current.name) ?? [];
+    queue.push(...children);
+  }
+  return result;
+}
+
+// src/lib/undo-log.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+async function getUndoPath(cwd) {
+  const dubDir = await getDubDir(cwd);
+  return path2.join(dubDir, "undo.json");
+}
+async function saveUndoEntry(entry, cwd) {
+  const undoPath = await getUndoPath(cwd);
+  fs2.writeFileSync(undoPath, `${JSON.stringify(entry, null, 2)}
+`);
+}
+async function readUndoEntry(cwd) {
+  const undoPath = await getUndoPath(cwd);
+  if (!fs2.existsSync(undoPath)) {
+    throw new DubError("Nothing to undo.");
+  }
+  const raw = fs2.readFileSync(undoPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function clearUndoEntry(cwd) {
+  const undoPath = await getUndoPath(cwd);
+  if (fs2.existsSync(undoPath)) {
+    fs2.unlinkSync(undoPath);
+  }
+}
+
+// src/commands/create.ts
+async function create(name, cwd, options) {
+  if (options?.all && !options.message) {
+    throw new DubError("'-a' requires '-m'. Pass a commit message.");
+  }
+  const state = await ensureState(cwd);
+  const parent = await getCurrentBranch(cwd);
+  if (await branchExists(name, cwd)) {
+    throw new DubError(`Branch '${name}' already exists.`);
+  }
+  if (options?.message) {
+    if (options.all) {
+      await stageAll(cwd);
+    }
+    if (!await hasStagedChanges(cwd)) {
+      const hint = options.all ? "No changes to commit." : "No staged changes. Stage files with 'git add' or use '-a' to stage all.";
+      throw new DubError(hint);
+    }
+  }
+  await saveUndoEntry(
+    {
+      operation: "create",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      previousBranch: parent,
+      previousState: structuredClone(state),
+      branchTips: {},
+      createdBranches: [name]
+    },
+    cwd
+  );
+  await createBranch(name, cwd);
+  addBranchToStack(state, name, parent);
+  await writeState(state, cwd);
+  if (options?.message) {
+    try {
+      await commitStaged(options.message, cwd);
+    } catch (error) {
+      const reason = error instanceof DubError ? error.message : String(error);
+      throw new DubError(
+        `Branch '${name}' was created but commit failed: ${reason}. Run 'dub undo' to clean up.`
+      );
+    }
+    return { branch: name, parent, committed: options.message };
+  }
+  return { branch: name, parent };
+}
+
+// src/commands/init.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+async function init(cwd) {
+  if (!await isGitRepo(cwd)) {
+    throw new DubError(
+      "Not a git repository. Run this command inside a git repo."
+    );
+  }
+  const status = await initState(cwd);
+  const repoRoot = await getRepoRoot(cwd);
+  const gitignorePath = path3.join(repoRoot, ".gitignore");
+  const entry = ".git/dubstack";
+  let gitignoreUpdated = false;
+  if (fs3.existsSync(gitignorePath)) {
+    const content = fs3.readFileSync(gitignorePath, "utf-8");
+    const lines = content.split("\n");
+    if (!lines.some((line) => line.trim() === entry)) {
+      const separator = content.endsWith("\n") ? "" : "\n";
+      fs3.writeFileSync(gitignorePath, `${content}${separator}${entry}
+`);
+      gitignoreUpdated = true;
+    }
+  } else {
+    fs3.writeFileSync(gitignorePath, `${entry}
+`);
+    gitignoreUpdated = true;
+  }
+  return { status, gitignoreUpdated };
+}
+
+// src/commands/log.ts
+async function log(cwd) {
+  const state = await readState(cwd);
+  if (state.stacks.length === 0) {
+    return "No stacks. Run 'dub create' to start.";
+  }
+  let currentBranch = null;
+  try {
+    currentBranch = await getCurrentBranch(cwd);
+  } catch {
+  }
+  const sections = [];
+  for (const stack of state.stacks) {
+    const tree = await renderStack(stack, currentBranch, cwd);
+    sections.push(tree);
+  }
+  return sections.join("\n\n");
+}
+async function renderStack(stack, currentBranch, cwd) {
+  const root = stack.branches.find((b) => b.type === "root");
+  if (!root) return "";
+  const childMap = /* @__PURE__ */ new Map();
+  for (const branch of stack.branches) {
+    if (branch.parent) {
+      const children = childMap.get(branch.parent) ?? [];
+      children.push(branch);
+      childMap.set(branch.parent, children);
+    }
+  }
+  const lines = [];
+  await renderNode(root, currentBranch, childMap, "", true, true, lines, cwd);
+  return lines.join("\n");
+}
+async function renderNode(branch, currentBranch, childMap, prefix, isRoot, isLast, lines, cwd) {
+  let label;
+  const exists = await branchExists(branch.name, cwd);
+  if (isRoot) {
+    label = `(${branch.name})`;
+  } else if (branch.name === currentBranch) {
+    label = `*${branch.name} (Current)*`;
+  } else if (!exists) {
+    label = `${branch.name} \u26A0 (missing)`;
+  } else {
+    label = branch.name;
+  }
+  if (isRoot) {
+    lines.push(label);
+  } else {
+    const connector = isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
+    lines.push(`${prefix}${connector}${label}`);
+  }
+  const children = childMap.get(branch.name) ?? [];
+  const childPrefix = isRoot ? "  " : `${prefix}${isLast ? "     " : "\u2502    "}`;
+  for (let i = 0; i < children.length; i++) {
+    const isChildLast = i === children.length - 1;
+    await renderNode(
+      children[i],
+      currentBranch,
+      childMap,
+      childPrefix,
+      false,
+      isChildLast,
+      lines,
+      cwd
+    );
+  }
+}
+
+// src/commands/restack.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+async function restack(cwd) {
+  const state = await readState(cwd);
+  if (!await isWorkingTreeClean(cwd)) {
+    throw new DubError(
+      "Working tree has uncommitted changes. Commit or stash them before restacking."
+    );
+  }
+  const originalBranch = await getCurrentBranch(cwd);
+  const targetStacks = getTargetStacks(state.stacks, originalBranch);
+  if (targetStacks.length === 0) {
+    throw new DubError(
+      `Branch '${originalBranch}' is not part of any stack. Run 'dub create' first.`
+    );
+  }
+  const allBranches = targetStacks.flatMap((s) => s.branches);
+  for (const branch of allBranches) {
+    if (!await branchExists(branch.name, cwd)) {
+      throw new DubError(
+        `Branch '${branch.name}' is tracked in state but no longer exists in git.
+  Remove it from the stack or recreate it before restacking.`
+      );
+    }
+  }
+  const branchTips = {};
+  for (const branch of allBranches) {
+    branchTips[branch.name] = await getBranchTip(branch.name, cwd);
+  }
+  const steps = await buildRestackSteps(targetStacks, cwd);
+  if (steps.length === 0) {
+    return { status: "up-to-date", rebased: [] };
+  }
+  await saveUndoEntry(
+    {
+      operation: "restack",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      previousBranch: originalBranch,
+      previousState: structuredClone(state),
+      branchTips,
+      createdBranches: []
+    },
+    cwd
+  );
+  const progress = { originalBranch, steps };
+  await writeProgress(progress, cwd);
+  return executeRestackSteps(progress, cwd);
+}
+async function restackContinue(cwd) {
+  const progress = await readProgress(cwd);
+  if (!progress) {
+    throw new DubError("No restack in progress. Run 'dub restack' to start.");
+  }
+  await rebaseContinue(cwd);
+  const conflictedStep = progress.steps.find((s) => s.status === "conflicted");
+  if (conflictedStep) {
+    conflictedStep.status = "done";
+  }
+  return executeRestackSteps(progress, cwd);
+}
+async function executeRestackSteps(progress, cwd) {
+  const rebased = [];
+  for (const step of progress.steps) {
+    if (step.status !== "pending") {
+      if (step.status === "done") rebased.push(step.branch);
+      continue;
+    }
+    const parentNewTip = await getBranchTip(step.parent, cwd);
+    if (parentNewTip === step.parentOldTip) {
+      step.status = "skipped";
+      await writeProgress(progress, cwd);
+      continue;
+    }
+    try {
+      await rebaseOnto(parentNewTip, step.parentOldTip, step.branch, cwd);
+      step.status = "done";
+      rebased.push(step.branch);
+      await writeProgress(progress, cwd);
+    } catch (error) {
+      if (error instanceof DubError && error.message.includes("Conflict")) {
+        step.status = "conflicted";
+        await writeProgress(progress, cwd);
+        return { status: "conflict", rebased, conflictBranch: step.branch };
+      }
+      throw error;
+    }
+  }
+  await clearProgress(cwd);
+  await checkoutBranch(progress.originalBranch, cwd);
+  const allSkipped = progress.steps.every(
+    (s) => s.status === "skipped" || s.status === "done"
+  );
+  return {
+    status: rebased.length === 0 && allSkipped ? "up-to-date" : "success",
+    rebased
+  };
+}
+function getTargetStacks(stacks, currentBranch) {
+  const rootStacks = stacks.filter(
+    (s) => s.branches.some((b) => b.name === currentBranch && b.type === "root")
+  );
+  if (rootStacks.length > 0) return rootStacks;
+  const stack = stacks.find(
+    (s) => s.branches.some((b) => b.name === currentBranch)
+  );
+  return stack ? [stack] : [];
+}
+async function buildRestackSteps(stacks, cwd) {
+  const steps = [];
+  for (const stack of stacks) {
+    const ordered = topologicalOrder(stack);
+    for (const branch of ordered) {
+      if (branch.type === "root" || !branch.parent) continue;
+      const mergeBase = await getMergeBase(branch.parent, branch.name, cwd);
+      steps.push({
+        branch: branch.name,
+        parent: branch.parent,
+        parentOldTip: mergeBase,
+        status: "pending"
+      });
+    }
+  }
+  return steps;
+}
+async function getProgressPath(cwd) {
+  const dubDir = await getDubDir(cwd);
+  return path4.join(dubDir, "restack-progress.json");
+}
+async function writeProgress(progress, cwd) {
+  const progressPath = await getProgressPath(cwd);
+  fs4.writeFileSync(progressPath, `${JSON.stringify(progress, null, 2)}
+`);
+}
+async function readProgress(cwd) {
+  const progressPath = await getProgressPath(cwd);
+  if (!fs4.existsSync(progressPath)) return null;
+  const raw = fs4.readFileSync(progressPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function clearProgress(cwd) {
+  const progressPath = await getProgressPath(cwd);
+  if (fs4.existsSync(progressPath)) {
+    fs4.unlinkSync(progressPath);
+  }
+}
+
+// src/commands/submit.ts
+import * as fs5 from "fs";
+import * as os from "os";
+import * as path5 from "path";
+
+// src/lib/github.ts
+import { execa as execa2 } from "execa";
+async function ensureGhInstalled() {
+  try {
+    await execa2("gh", ["--version"]);
+  } catch {
+    throw new DubError("gh CLI not found. Install it: https://cli.github.com");
+  }
+}
+async function checkGhAuth() {
+  try {
+    await execa2("gh", ["auth", "status"]);
+  } catch {
+    throw new DubError("Not authenticated with GitHub. Run 'gh auth login'.");
+  }
+}
+async function getPr(branch, cwd) {
+  const { stdout } = await execa2(
+    "gh",
+    [
+      "pr",
+      "list",
+      "--head",
+      branch,
+      "--state",
+      "open",
+      "--json",
+      "number,url,title,body",
+      "--jq",
+      ".[0]"
+    ],
+    { cwd }
+  );
+  const trimmed = stdout.trim();
+  if (!trimmed || trimmed === "null") return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    throw new DubError(`Failed to parse PR info for branch '${branch}'.`);
+  }
+}
+async function createPr(branch, base, title, bodyFile, cwd) {
+  let stdout;
+  try {
+    const result = await execa2(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--head",
+        branch,
+        "--base",
+        base,
+        "--title",
+        title,
+        "--body-file",
+        bodyFile
+      ],
+      { cwd }
+    );
+    stdout = result.stdout;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("403") || message.includes("insufficient")) {
+      throw new DubError(
+        "GitHub token lacks required permissions. Run 'gh auth login' with the 'repo' scope."
+      );
+    }
+    throw new DubError(`Failed to create PR for '${branch}': ${message}`);
+  }
+  const url = stdout.trim();
+  const numberMatch = url.match(/\/pull\/(\d+)$/);
+  if (!numberMatch) {
+    throw new DubError(`Unexpected output from 'gh pr create': ${url}`);
+  }
+  return {
+    number: Number.parseInt(numberMatch[1], 10),
+    url,
+    title,
+    body: ""
+  };
+}
+async function updatePrBody(prNumber, bodyFile, cwd) {
+  try {
+    await execa2(
+      "gh",
+      ["pr", "edit", String(prNumber), "--body-file", bodyFile],
+      { cwd }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("403") || message.includes("insufficient")) {
+      throw new DubError(
+        "GitHub token lacks required permissions. Run 'gh auth login' with the 'repo' scope."
+      );
+    }
+    throw new DubError(`Failed to update PR #${prNumber}: ${message}`);
+  }
+}
+
+// src/lib/pr-body.ts
+var DUBSTACK_START = "<!-- dubstack:start -->";
+var DUBSTACK_END = "<!-- dubstack:end -->";
+var METADATA_START = "<!-- dubstack-metadata";
+var METADATA_END = "-->";
+function buildStackTable(orderedBranches, prMap, currentBranch) {
+  const lines = orderedBranches.map((branch) => {
+    const entry = prMap.get(branch.name);
+    if (!entry) return `- ${branch.name}`;
+    const marker = branch.name === currentBranch ? " \u{1F448}" : "";
+    return `- #${entry.number} ${entry.title}${marker}`;
+  });
+  return [
+    DUBSTACK_START,
+    "---",
+    "### \u{1F95E} DubStack",
+    ...lines,
+    DUBSTACK_END
+  ].join("\n");
+}
+function buildMetadataBlock(stackId, prNumber, prevPr, nextPr, branch) {
+  const metadata = {
+    stack_id: stackId,
+    pr_number: prNumber,
+    prev_pr: prevPr,
+    next_pr: nextPr,
+    branch
+  };
+  return `${METADATA_START}
+${JSON.stringify(metadata, null, 2)}
+${METADATA_END}`;
+}
+function stripDubstackSections(body) {
+  let result = body;
+  const startIdx = result.indexOf(DUBSTACK_START);
+  const endIdx = result.indexOf(DUBSTACK_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    result = result.slice(0, startIdx) + result.slice(endIdx + DUBSTACK_END.length);
+  }
+  const metaStart = result.indexOf(METADATA_START);
+  if (metaStart !== -1) {
+    const metaEnd = result.indexOf(
+      METADATA_END,
+      metaStart + METADATA_START.length
+    );
+    if (metaEnd !== -1) {
+      result = result.slice(0, metaStart) + result.slice(metaEnd + METADATA_END.length);
+    }
+  }
+  return result.trimEnd();
+}
+function composePrBody(existingBody, stackTable, metadataBlock) {
+  const userContent = stripDubstackSections(existingBody);
+  const parts = [userContent, stackTable, metadataBlock].filter(Boolean);
+  return parts.join("\n\n");
+}
+
+// src/commands/submit.ts
+async function submit(cwd, dryRun) {
+  await ensureGhInstalled();
+  await checkGhAuth();
+  const state = await readState(cwd);
+  const currentBranch = await getCurrentBranch(cwd);
+  const stack = findStackForBranch(state, currentBranch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${currentBranch}' is not part of any stack. Run 'dub create' first.`
+    );
+  }
+  const ordered = topologicalOrder(stack);
+  const currentEntry = ordered.find((b) => b.name === currentBranch);
+  if (currentEntry?.type === "root") {
+    throw new DubError(
+      "Cannot submit from a root branch. Checkout a stack branch first."
+    );
+  }
+  const nonRootBranches = ordered.filter((b) => b.type !== "root");
+  validateLinearStack(ordered);
+  const result = { pushed: [], created: [], updated: [] };
+  const prMap = /* @__PURE__ */ new Map();
+  for (const branch of nonRootBranches) {
+    if (dryRun) {
+      console.log(`[dry-run] would push ${branch.name}`);
+    } else {
+      await pushBranch(branch.name, cwd);
+    }
+    result.pushed.push(branch.name);
+  }
+  for (const branch of nonRootBranches) {
+    const base = branch.parent;
+    if (dryRun) {
+      console.log(`[dry-run] would check/create PR: ${branch.name} \u2192 ${base}`);
+      continue;
+    }
+    const existing = await getPr(branch.name, cwd);
+    if (existing) {
+      prMap.set(branch.name, existing);
+      result.updated.push(branch.name);
+    } else {
+      const title = await getLastCommitMessage(branch.name, cwd);
+      const tmpFile = writeTempBody("");
+      try {
+        const created = await createPr(branch.name, base, title, tmpFile, cwd);
+        prMap.set(branch.name, created);
+        result.created.push(branch.name);
+      } finally {
+        cleanupTempFile(tmpFile);
+      }
+    }
+  }
+  if (!dryRun) {
+    await updateAllPrBodies(nonRootBranches, prMap, stack.id, cwd);
+    for (const branch of nonRootBranches) {
+      const pr = prMap.get(branch.name);
+      if (pr) {
+        const stateBranch = stack.branches.find((b) => b.name === branch.name);
+        if (stateBranch) {
+          stateBranch.pr_number = pr.number;
+          stateBranch.pr_link = pr.url;
+        }
+      }
+    }
+    await writeState(state, cwd);
+  }
+  return result;
+}
+function validateLinearStack(ordered) {
+  const childCount = /* @__PURE__ */ new Map();
+  for (const branch of ordered) {
+    if (branch.parent) {
+      childCount.set(branch.parent, (childCount.get(branch.parent) ?? 0) + 1);
+    }
+  }
+  for (const [parent, count] of childCount) {
+    if (count > 1) {
+      throw new DubError(
+        `Branch '${parent}' has ${count} children. Branching stacks are not supported by submit. Ensure each branch has at most one child.`
+      );
+    }
+  }
+}
+async function updateAllPrBodies(branches, prMap, stackId, cwd) {
+  const tableEntries = /* @__PURE__ */ new Map();
+  for (const branch of branches) {
+    const pr = prMap.get(branch.name);
+    if (pr) {
+      tableEntries.set(branch.name, { number: pr.number, title: pr.title });
+    }
+  }
+  for (let i = 0; i < branches.length; i++) {
+    const branch = branches[i];
+    const pr = prMap.get(branch.name);
+    if (!pr) continue;
+    const prevPr = i > 0 ? prMap.get(branches[i - 1].name)?.number ?? null : null;
+    const nextPr = i < branches.length - 1 ? prMap.get(branches[i + 1].name)?.number ?? null : null;
+    const stackTable = buildStackTable(branches, tableEntries, branch.name);
+    const metadataBlock = buildMetadataBlock(
+      stackId,
+      pr.number,
+      prevPr,
+      nextPr,
+      branch.name
+    );
+    const existingBody = pr.body;
+    const finalBody = composePrBody(existingBody, stackTable, metadataBlock);
+    const tmpFile = writeTempBody(finalBody);
+    try {
+      await updatePrBody(pr.number, tmpFile, cwd);
+    } finally {
+      cleanupTempFile(tmpFile);
+    }
+  }
+}
+function writeTempBody(content) {
+  const tmpDir = os.tmpdir();
+  const tmpFile = path5.join(tmpDir, `dubstack-body-${Date.now()}.md`);
+  fs5.writeFileSync(tmpFile, content);
+  return tmpFile;
+}
+function cleanupTempFile(filePath) {
+  try {
+    fs5.unlinkSync(filePath);
+  } catch {
+  }
+}
+
+// src/commands/undo.ts
+async function undo(cwd) {
+  const entry = await readUndoEntry(cwd);
+  if (!await isWorkingTreeClean(cwd)) {
+    throw new DubError(
+      "Working tree has uncommitted changes. Commit or stash them before undoing."
+    );
+  }
+  const currentBranch = await getCurrentBranch(cwd);
+  if (entry.operation === "create") {
+    const needsCheckout = entry.createdBranches.includes(currentBranch);
+    if (needsCheckout) {
+      await checkoutBranch(entry.previousBranch, cwd);
+    }
+    for (const branch of entry.createdBranches) {
+      await deleteBranch(branch, cwd);
+    }
+    if (!needsCheckout && currentBranch !== entry.previousBranch) {
+      await checkoutBranch(entry.previousBranch, cwd);
+    }
+    await writeState(entry.previousState, cwd);
+    await clearUndoEntry(cwd);
+    return {
+      undone: "create",
+      details: `Deleted branch${entry.createdBranches.length > 1 ? "es" : ""} '${entry.createdBranches.join("', '")}'`
+    };
+  }
+  await checkoutBranch(entry.previousBranch, cwd);
+  for (const [name, sha] of Object.entries(entry.branchTips)) {
+    if (name === entry.previousBranch) continue;
+    await forceBranchTo(name, sha, cwd);
+  }
+  if (entry.branchTips[entry.previousBranch]) {
+    await forceBranchTo(
+      entry.previousBranch,
+      entry.branchTips[entry.previousBranch],
+      cwd
+    );
+  }
+  await writeState(entry.previousState, cwd);
+  await clearUndoEntry(cwd);
+  return {
+    undone: "restack",
+    details: `Reset ${Object.keys(entry.branchTips).length} branches to pre-restack state`
+  };
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("dub").description("Manage stacked diffs (dependent git branches) with ease").version(version);
+program.command("init").description("Initialize DubStack in the current git repository").addHelpText(
+  "after",
+  `
 Examples:
-  $ dub create feat/api-endpoint      Create a branch on top of current branch
-  $ dub create feat/ui-component      Stack another branch on top`)
-    .action(async (branchName) => {
-    const result = await create(branchName, process.cwd());
-    console.log(chalk.green(`✔ Created branch '${result.branch}' on top of '${result.parent}'`));
+  $ dub init    Initialize DubStack, creating .git/dubstack/ and updating .gitignore`
+).action(async () => {
+  const result = await init(process.cwd());
+  if (result.status === "created") {
+    console.log(chalk.green("\u2714 DubStack initialized"));
+  } else {
+    console.log(chalk.yellow("\u26A0 DubStack already initialized"));
+  }
 });
-program
-    .command("log")
-    .description("Display an ASCII tree of the current stack")
-    .addHelpText("after", `
+program.command("create").argument("<branch-name>", "Name of the new branch to create").description("Create a new branch stacked on top of the current branch").option("-m, --message <message>", "Commit staged changes with this message").option("-a, --all", "Stage all changes before committing (requires -m)").addHelpText(
+  "after",
+  `
 Examples:
-  $ dub log    Show the branch tree with current branch highlighted`)
-    .action(async () => {
-    const output = await log(process.cwd());
-    // Apply chalk styling to the output
-    const styled = output
-        .replace(/\*(.+?) \(Current\)\*/g, chalk.bold.cyan("$1 (Current)"))
-        .replace(/⚠ \(missing\)/g, chalk.yellow("⚠ (missing)"));
-    console.log(styled);
+  $ dub create feat/api                       Create branch only
+  $ dub create feat/api -m "feat: add API"    Create branch + commit staged
+  $ dub create feat/api -am "feat: add API"   Stage all + create + commit`
+).action(
+  async (branchName, options) => {
+    const result = await create(branchName, process.cwd(), {
+      message: options.message,
+      all: options.all
+    });
+    if (result.committed) {
+      console.log(
+        chalk.green(
+          `\u2714 Created '${result.branch}' on '${result.parent}' \u2022 ${result.committed}`
+        )
+      );
+    } else {
+      console.log(
+        chalk.green(
+          `\u2714 Created branch '${result.branch}' on top of '${result.parent}'`
+        )
+      );
+    }
+  }
+);
+program.command("log").description("Display an ASCII tree of the current stack").addHelpText(
+  "after",
+  `
+Examples:
+  $ dub log    Show the branch tree with current branch highlighted`
+).action(async () => {
+  const output = await log(process.cwd());
+  const styled = output.replace(/\*(.+?) \(Current\)\*/g, chalk.bold.cyan("$1 (Current)")).replace(/⚠ \(missing\)/g, chalk.yellow("\u26A0 (missing)"));
+  console.log(styled);
 });
-program
-    .command("restack")
-    .description("Rebase all branches in the stack onto their updated parents")
-    .option("--continue", "Continue restacking after resolving conflicts")
-    .addHelpText("after", `
+program.command("restack").description("Rebase all branches in the stack onto their updated parents").option("--continue", "Continue restacking after resolving conflicts").addHelpText(
+  "after",
+  `
 Examples:
   $ dub restack              Rebase the current stack
-  $ dub restack --continue   Continue after resolving conflicts`)
-    .action(async (options) => {
-    const result = options.continue
-        ? await restackContinue(process.cwd())
-        : await restack(process.cwd());
-    if (result.status === "up-to-date") {
-        console.log(chalk.green("✔ Stack is already up to date"));
-    }
-    else if (result.status === "conflict") {
-        console.log(chalk.yellow(`⚠ Conflict while restacking '${result.conflictBranch}'`));
-        console.log(chalk.dim("  Resolve conflicts, stage changes, then run: dub restack --continue"));
-    }
-    else {
-        console.log(chalk.green(`✔ Restacked ${result.rebased.length} branch(es)`));
-        for (const branch of result.rebased) {
-            console.log(chalk.dim(`  ↳ ${branch}`));
-        }
+  $ dub restack --continue   Continue after resolving conflicts`
+).action(async (options) => {
+  const result = options.continue ? await restackContinue(process.cwd()) : await restack(process.cwd());
+  if (result.status === "up-to-date") {
+    console.log(chalk.green("\u2714 Stack is already up to date"));
+  } else if (result.status === "conflict") {
+    console.log(
+      chalk.yellow(`\u26A0 Conflict while restacking '${result.conflictBranch}'`)
+    );
+    console.log(
+      chalk.dim(
+        "  Resolve conflicts, stage changes, then run: dub restack --continue"
+      )
+    );
+  } else {
+    console.log(
+      chalk.green(`\u2714 Restacked ${result.rebased.length} branch(es)`)
+    );
+    for (const branch of result.rebased) {
+      console.log(chalk.dim(`  \u21B3 ${branch}`));
     }
+  }
 });
-program
-    .command("undo")
-    .description("Undo the last dub create or dub restack operation")
-    .addHelpText("after", `
+program.command("undo").description("Undo the last dub create or dub restack operation").addHelpText(
+  "after",
+  `
 Examples:
-  $ dub undo    Roll back the last dub operation`)
-    .action(async () => {
-    const result = await undo(process.cwd());
-    console.log(chalk.green(`✔ Undid '${result.undone}': ${result.details}`));
+  $ dub undo    Roll back the last dub operation`
+).action(async () => {
+  const result = await undo(process.cwd());
+  console.log(chalk.green(`\u2714 Undid '${result.undone}': ${result.details}`));
 });
-async function main() {
-    try {
-        await program.parseAsync(process.argv);
+program.command("submit").description(
+  "Push branches and create/update GitHub PRs for the current stack"
+).option("--dry-run", "Print what would happen without executing").addHelpText(
+  "after",
+  `
+Examples:
+  $ dub submit           Push and create/update PRs
+  $ dub submit --dry-run Preview what would happen`
+).action(runSubmit);
+program.command("ss").description("Submit the current stack (alias for submit)").option("--dry-run", "Print what would happen without executing").action(runSubmit);
+async function runSubmit(options) {
+  const result = await submit(process.cwd(), options.dryRun ?? false);
+  if (result.pushed.length > 0) {
+    console.log(
+      chalk.green(
+        `\u2714 Pushed ${result.pushed.length} branch(es), created ${result.created.length} PR(s), updated ${result.updated.length} PR(s)`
+      )
+    );
+    for (const branch of [...result.created, ...result.updated]) {
+      console.log(chalk.dim(`  \u21B3 ${branch}`));
     }
-    catch (error) {
-        if (error instanceof DubError) {
-            console.error(chalk.red(`✖ ${error.message}`));
-            process.exit(1);
-        }
-        throw error;
+  }
+}
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof DubError) {
+      console.error(chalk.red(`\u2716 ${error.message}`));
+      process.exit(1);
     }
+    throw error;
+  }
 }
 main();
 //# sourceMappingURL=index.js.map