@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-XGU6PBO5.js

@@ -0,0 +1,645 @@
+import {
+  VALIDATION_BRANCH_PREFIX,
+  isBuildOwnedBranch,
+  isBuildWorktreeScopedBranch,
+  isValidationBranch
+} from "./chunk-F55YABKV.js";
+import {
+  slugify
+} from "./chunk-2VLJUXJU.js";
+import {
+  execGit,
+  execGitSync
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/git/protected-branches.ts
+import { execFileSync } from "child_process";
+import { execa } from "execa";
+var _defaultBranchCache = /* @__PURE__ */ new Map();
+async function resolveDefaultBranchEvidence(cwd) {
+  const opts = { cwd, stdio: "pipe" };
+  try {
+    const { stdout } = await execa("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], opts);
+    const match = stdout.match(/refs\/remotes\/origin\/(.+)/);
+    if (match?.[1]) return match[1];
+  } catch {
+  }
+  try {
+    await execa("git", ["rev-parse", "--verify", "refs/heads/main"], opts);
+    return "main";
+  } catch {
+  }
+  try {
+    await execa("git", ["rev-parse", "--verify", "refs/heads/master"], opts);
+    return "master";
+  } catch {
+  }
+  return null;
+}
+async function resolveManagedSyncDefaultBranch(cwd) {
+  return resolveDefaultBranchEvidence(cwd);
+}
+async function resolveDefaultBranch(cwd) {
+  const key = cwd ?? "";
+  const cached = _defaultBranchCache.get(key);
+  if (cached !== void 0) return cached;
+  const memo = (v) => {
+    _defaultBranchCache.set(key, v);
+    return v;
+  };
+  const evidenced = await resolveDefaultBranchEvidence(cwd);
+  if (evidenced) return memo(evidenced);
+  const opts = { cwd, stdio: "pipe" };
+  try {
+    const { stdout } = await execa("git", ["rev-parse", "--symbolic-full-name", "HEAD"], opts);
+    const currentBranch = parseCurrentBranchRef(stdout);
+    if (currentBranch && currentBranch !== "HEAD") {
+      return memo(currentBranch);
+    }
+  } catch {
+  }
+  return memo("main");
+}
+function resetDefaultBranchCache() {
+  _defaultBranchCache.clear();
+  _localDefaultBranchCache.clear();
+}
+var _localDefaultBranchCache = /* @__PURE__ */ new Map();
+function localDefaultBranchSync(cwd) {
+  const dir = cwd ?? process.cwd();
+  const cached = _localDefaultBranchCache.get(dir);
+  if (cached !== void 0) return cached;
+  const read = (args) => {
+    try {
+      const result = execGitSync(args, { cwd: dir, timeoutMs: 5e3 });
+      return result.exitCode === 0 ? String(result.stdout).trim() : "";
+    } catch {
+      return "";
+    }
+  };
+  const originHead = read(["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+  const fromOrigin = originHead.startsWith("refs/remotes/origin/") ? originHead.slice("refs/remotes/origin/".length) : "";
+  const resolved = fromOrigin || (read(["remote"]) ? "" : read(["config", "--get", "init.defaultBranch"])) || null;
+  _localDefaultBranchCache.set(dir, resolved);
+  return resolved;
+}
+var DEFAULT_PROTECTED_BRANCHES = /* @__PURE__ */ new Set([
+  "main",
+  "master",
+  "develop",
+  "development",
+  "staging",
+  "production"
+]);
+var DEFAULT_PROTECTED_PATTERNS = [/^release\/.*/, /^hotfix\/.*/, /^origin\/.*/];
+var PRODUCT_BRANCH_PREFIXES = ["fix/", "feature/", "feat/", "refactor/", "docs/", "test/"];
+var LOCAL_SCRATCH_BRANCH_PREFIXES = ["local/", "wip/", "tmp/", "scratch/", "throwaway/"];
+function classifyBranchRole(branch, protectedBranchEnv, cwd) {
+  if (!branch || branch === "HEAD") {
+    return "detached";
+  }
+  if (isProtectedPipelineBranch(branch, protectedBranchEnv, cwd)) {
+    return "protected";
+  }
+  if (isValidationBranch(branch)) {
+    return "validation";
+  }
+  if (branch.startsWith("run/")) {
+    return "run";
+  }
+  if (isBuildOwnedBranch(branch)) {
+    return "generated-artifact";
+  }
+  if (PRODUCT_BRANCH_PREFIXES.some((prefix) => branch.startsWith(prefix))) {
+    return "product-fix";
+  }
+  if (LOCAL_SCRATCH_BRANCH_PREFIXES.some((prefix) => branch.startsWith(prefix))) {
+    return "local-scratch";
+  }
+  return "unknown-user";
+}
+function isDisposableBranchRole(role) {
+  return role === "validation" || role === "run" || role === "generated-artifact";
+}
+function needsNewWorkingBranch(branch) {
+  return branch === void 0 || classifyBranchRole(branch) !== "product-fix";
+}
+function isEphemeralBuildBranchDeletionCandidate(branch, protectedBranchEnv) {
+  const role = classifyBranchRole(branch, protectedBranchEnv);
+  if (role !== "unknown-user" && !isDisposableBranchRole(role)) {
+    return false;
+  }
+  return isBuildWorktreeScopedBranch(branch);
+}
+function branchRoleLabel(role) {
+  switch (role) {
+    case "generated-artifact":
+      return "generated artifact";
+    case "local-scratch":
+      return "local scratch";
+    case "product-fix":
+      return "product fix";
+    default:
+      return role;
+  }
+}
+function isProtectedPipelineBranch(branch, protectedBranchEnv = process.env.BUILD_PROTECTED_BRANCHES, cwd) {
+  const protectedBranches = new Set(DEFAULT_PROTECTED_BRANCHES);
+  for (const entry of (protectedBranchEnv ?? "").split(",")) {
+    const trimmed = entry.trim();
+    if (trimmed) protectedBranches.add(trimmed);
+  }
+  if (protectedBranches.has(branch)) {
+    return true;
+  }
+  if (DEFAULT_PROTECTED_PATTERNS.some((pattern) => pattern.test(branch))) {
+    return true;
+  }
+  return branch !== "" && branch === localDefaultBranchSync(cwd);
+}
+var CURRENT_BRANCH_REV_PARSE_ARGS = ["rev-parse", "--symbolic-full-name", "HEAD"];
+function parseCurrentBranchRef(stdout) {
+  const ref = stdout.trim();
+  return ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref || "HEAD";
+}
+function getCurrentBranch(cwd) {
+  try {
+    const result = execGitSync([...CURRENT_BRANCH_REV_PARSE_ARGS], {
+      cwd: cwd ?? process.cwd(),
+      timeoutMs: 1e4
+    });
+    if (result.exitCode !== 0) return "HEAD";
+    return parseCurrentBranchRef(result.stdout);
+  } catch {
+    return "HEAD";
+  }
+}
+var CompeteProtectedBranchCompletionError = class extends Error {
+  branch;
+  completionMode;
+  constructor(branch, completionMode, command = "compete") {
+    super(formatCompeteCompletionProtectedBranchMessage({ branch, command, completionMode }));
+    this.name = "CompeteProtectedBranchCompletionError";
+    this.branch = branch;
+    this.completionMode = completionMode;
+  }
+};
+function commandAcceptsAllowCommingleFlag(command) {
+  const head = command.trim().split(/\s+/)[0];
+  return head === "compete" || head === "build";
+}
+var BranchRoleCodeApplyError = class extends Error {
+  branch;
+  role;
+  constructor(options) {
+    const slug = slugify2(options.command);
+    const displayedCommand = buildCommandLine(options.command);
+    const guidance = `Cannot apply code changes on ${branchRoleLabel(options.role)} branch '${options.branch}'.
+This branch is disposable evidence, not a product landing branch.
+
+Create a safe working branch first:
+  git checkout -b fix/${slug}
+
+Then rerun the apply command from that branch:
+  ${displayedCommand}
+
+Guided setup:
+  build init quickstart "<task>" --branch`;
+    const override = commandAcceptsAllowCommingleFlag(options.command) ? `
+
+Override (not recommended): ${displayedCommand} ${ALLOW_COMMINGLE_FLAG}` : "";
+    super(`${guidance}${override}`);
+    this.name = "BranchRoleCodeApplyError";
+    this.branch = options.branch;
+    this.role = options.role;
+  }
+};
+var BacklogExecutionBranchRoleError = class extends Error {
+  branch;
+  role;
+  constructor(branch, role) {
+    super(
+      `Cannot start backlog execution from ${branchRoleLabel(role)} branch '${branch}'.
+Backlog execution would create a run branch from the current checkout, so disposable validation/run/generated state must not be inherited.
+
+Checkout a product or source branch first, for example:
+  git checkout main
+  build plan backlog execute <id>`
+    );
+    this.name = "BacklogExecutionBranchRoleError";
+    this.branch = branch;
+    this.role = role;
+  }
+};
+function buildCommandLine(command) {
+  if (command === "build" || command.startsWith("build --")) return command;
+  const bareCommand = command.startsWith("build ") ? command.slice("build ".length) : command;
+  if (bareCommand === "compete" || bareCommand.startsWith("compete ")) {
+    return `build run competition${bareCommand.slice("compete".length)}`;
+  }
+  if (bareCommand === "fusion" || bareCommand.startsWith("fusion ")) {
+    return `build run ${bareCommand}`;
+  }
+  return `build ${bareCommand}`;
+}
+function isPlannedExecution(command) {
+  return command.startsWith("build --planned") || command.startsWith("plan approve --to-sprint");
+}
+var QUICKSTART_BRANCH_COMMAND = 'build init quickstart "<task>" --branch';
+function quickFixBlock(command, preface = [], rerun) {
+  return "Quick fix:\n" + [
+    ...preface,
+    QUICKSTART_BRANCH_COMMAND,
+    rerun ?? `Then rerun your original command: ${buildCommandLine(command)} ...`
+  ].map((line) => `  ${line}`).join("\n");
+}
+function safeBranchHint(command) {
+  if (command === "compete" || command.startsWith("compete ")) {
+    return 'Safe working-branch path:\n  1. build init quickstart "<task>" --branch\n  2. build run competition "<task>" --variant <provider>\n  3. build run competition apply <competition-id>\n  (AI judging is the default; one variant gives graded feedback, more variants enable comparison.)';
+  }
+  if (command === "fusion") {
+    return 'Safe working-branch path:\n  1. build init quickstart "<task>" --branch\n  2. build run fusion "<question>"';
+  }
+  if (command === "run") {
+    return 'Safe working-branch path:\n  1. build init quickstart "<task>" --branch\n  2. build run "<task>"\n  (build run uses isolated worktrees and may return a patch artifact.)\n  Need judge feedback or comparison instead? build run competition "<task>" --variant <provider>';
+  }
+  if (isPlannedExecution(command)) {
+    return `Safe first path:
+  1. ${QUICKSTART_BRANCH_COMMAND}
+  2. ${buildCommandLine(command)} ...
+  (The fix/* branch is where the result is applied. A run/* branch only reviews: nothing is applied there.)`;
+  }
+  return `Safe first path:
+  1. ${QUICKSTART_BRANCH_COMMAND}
+  2. ${buildCommandLine(command)} ...
+  3. apply or merge results from the working branch`;
+}
+function formatProtectedBranchMessage(options) {
+  const {
+    branch,
+    command,
+    detachedHead = false,
+    unbornBranch = false,
+    notGitRepository = false
+  } = options;
+  if (notGitRepository) {
+    return `Refusing to run '${command}': this directory is not a Git repository.
+Pipeline commands need a Git repository with a branch to write metadata to.
+
+Run Build inside the intended repository, or create one here first:
+  git init -b main
+  git add <files>
+  git commit -m "Initial commit"`;
+  }
+  if (unbornBranch) {
+    return `Refusing to run '${command}' on unborn branch '${branch}'.
+Pipeline commands must not write metadata before the repository has an initial commit.
+
+${safeBranchHint(command)}
+
+` + quickFixBlock(command, ["git add <files>", 'git commit -m "Initial commit"']);
+  }
+  if (detachedHead) {
+    return `Refusing to run '${command}' in detached HEAD state.
+Pipeline commands must not write metadata without an active branch.
+
+${safeBranchHint(command)}
+
+` + quickFixBlock(command);
+  }
+  return `Refusing to run '${command}' on protected branch '${branch}'.
+Pipeline commands must not write metadata on protected branches.
+
+${safeBranchHint(command)}
+
+${quickFixBlock(command)}
+
+${protectedBranchOverrideHint(command, branch)}
+
+` + protectedBranchValidationLine(command);
+}
+function formatCompeteCompletionProtectedBranchMessage(options) {
+  return `Refusing completion-mode=${options.completionMode} on protected branch '${options.branch}'.
+This mode applies the winner diff directly to the current checkout.
+
+Safe working-branch path:
+  1. build init quickstart "<task>" --branch
+  2. build run competition "<task>" --variant <provider>
+  3. build run competition apply <competition-id>
+  (AI judging is the default.)
+
+${quickFixBlock(
+    options.command,
+    [],
+    "Then rerun your original command, or apply with: build run competition apply <competition-id>"
+  )}
+
+` + protectedBranchOverrideHint(options.command, options.branch);
+}
+function protectedBranchValidationLine(command) {
+  const checkoutHint = `git checkout -b ${VALIDATION_BRANCH_PREFIX}/YYYYMMDD-${slugify2(command)}`;
+  if (command === "compete") {
+    return `Or for disposable validation: build run competition --validation-run ...
+Manual equivalent: ${checkoutHint}`;
+  }
+  return `Or for disposable validation: ${checkoutHint}`;
+}
+function protectedBranchOverrideHint(command, branch) {
+  if (branch === "main" || branch === "master") {
+    return `Or override (not recommended):
+  ${buildCommandLine(command)} --allow-main
+  ${buildCommandLine(command)} --allow-protected`;
+  }
+  return `Or override (not recommended):
+  ${buildCommandLine(command)} --allow-protected`;
+}
+var ProtectedBranchError = class extends Error {
+  branch;
+  detachedHead;
+  unbornBranch;
+  notGitRepository;
+  constructor(branch, command, detachedHead = false, unbornBranch = false, notGitRepository = false) {
+    super(
+      formatProtectedBranchMessage({
+        branch,
+        command,
+        detachedHead,
+        unbornBranch,
+        notGitRepository
+      })
+    );
+    this.name = "ProtectedBranchError";
+    this.branch = branch;
+    this.detachedHead = detachedHead && !notGitRepository;
+    this.unbornBranch = unbornBranch;
+    this.notGitRepository = notGitRepository;
+  }
+};
+function isOutsideGitWorkTree(cwd) {
+  try {
+    const result = execGitSync(["rev-parse", "--is-inside-work-tree"], {
+      cwd: cwd ?? process.cwd(),
+      timeoutMs: 1e4
+    });
+    return result.exitCode !== 0 && /not a git repository/i.test(result.stderr);
+  } catch {
+    return false;
+  }
+}
+function headRefusal(command, cwd) {
+  const notGit = isOutsideGitWorkTree(cwd);
+  return new ProtectedBranchError("HEAD", command, true, false, notGit);
+}
+async function detectUnbornBranch(cwd) {
+  try {
+    const symbolicBranch = await execGit(["symbolic-ref", "--short", "HEAD"], { cwd });
+    if (symbolicBranch.exitCode !== 0) return void 0;
+    const branch = symbolicBranch.stdout.trim();
+    if (!branch) return void 0;
+    const head = await execGit(["rev-parse", "--verify", "HEAD"], { cwd });
+    return head.exitCode === 0 ? void 0 : branch;
+  } catch {
+    return void 0;
+  }
+}
+function detectUnbornBranchSync(cwd) {
+  try {
+    const symbolicBranch = execFileSync("git", ["symbolic-ref", "--short", "HEAD"], {
+      cwd,
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString().trim();
+    if (!symbolicBranch) return void 0;
+    try {
+      execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+        cwd,
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return void 0;
+    } catch {
+      return symbolicBranch;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function requireNonProtectedBranch(options) {
+  const branch = options.currentBranch ?? getCurrentBranch(options.cwd);
+  if (branch === "HEAD") {
+    const unbornBranch = detectUnbornBranchSync(options.cwd);
+    if (unbornBranch) {
+      throw new ProtectedBranchError(unbornBranch, options.command, false, true);
+    }
+    throw headRefusal(options.command, options.cwd);
+  }
+  if (options.allowProtected) {
+    return;
+  }
+  if (options.allowMain) {
+    if (branch === "main" || branch === "master") return;
+  }
+  if (isProtectedPipelineBranch(branch, void 0, options.cwd)) {
+    throw new ProtectedBranchError(branch, options.command);
+  }
+}
+async function branchExists(branch, cwd) {
+  const result = await execa("git", ["rev-parse", "--verify", `refs/heads/${branch}`], {
+    cwd,
+    reject: false,
+    stdio: "pipe"
+  });
+  return result.exitCode === 0;
+}
+function validationDateStamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().slice(0, 10).replace(/-/g, "");
+}
+async function allocateValidationBranchName(options) {
+  const slug = options.baseSlug || "compete";
+  const base = `${VALIDATION_BRANCH_PREFIX}/${validationDateStamp(options.now)}-${slug}`;
+  if (!await branchExists(base, options.cwd)) {
+    return base;
+  }
+  for (let i = 2; i <= 99; i += 1) {
+    const candidate = `${base}-${i}`;
+    if (!await branchExists(candidate, options.cwd)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to allocate a unique validation branch for ${base}`);
+}
+async function checkoutOrThrow(args, cwd) {
+  const result = await execGit(args, { cwd: cwd ?? process.cwd() });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || `git ${args.join(" ")} exited ${result.exitCode}`);
+  }
+}
+async function checkoutValidationBranchForRun(options) {
+  const fromBranch = options.currentBranch ?? getCurrentBranch(options.cwd);
+  if (fromBranch === "HEAD") {
+    throw headRefusal(options.command, options.cwd);
+  }
+  if (isValidationBranch(fromBranch)) {
+    return { branch: fromBranch, created: false, fromBranch };
+  }
+  const baseSlug = slugify2(options.slugSource ?? options.command);
+  const branch = await allocateValidationBranchName({
+    baseSlug,
+    cwd: options.cwd,
+    now: options.now
+  });
+  await checkoutOrThrow(["checkout", "-b", branch], options.cwd);
+  return { branch, created: true, fromBranch };
+}
+async function restoreCheckoutFromBranch(options) {
+  const branch = options.branch.trim();
+  if (!branch || branch === "HEAD") {
+    return;
+  }
+  if (getCurrentBranch(options.cwd) === branch) {
+    return;
+  }
+  await checkoutOrThrow(["checkout", branch], options.cwd);
+}
+function requireNonDetachedHead(options) {
+  const branch = options.currentBranch ?? getCurrentBranch(options.cwd);
+  if (branch !== "HEAD") return;
+  const refusal = headRefusal(options.command, options.cwd);
+  if (options.allowDetached && !refusal.notGitRepository) return;
+  throw refusal;
+}
+function assertCompeteProtectedBranchForExecutionIntent(options) {
+  if (options.executionIntent === "analysis") {
+    return;
+  }
+  const branch = options.currentBranch ?? getCurrentBranch(options.cwd);
+  if (branch === "HEAD") {
+    throw headRefusal(options.command, options.cwd);
+  }
+  if (options.allowProtected) {
+    return;
+  }
+  if (options.allowMain) {
+    if (branch === "main" || branch === "master") return;
+  }
+  if (isProtectedPipelineBranch(branch, void 0, options.cwd)) {
+    throw new ProtectedBranchError(branch, options.command);
+  }
+}
+var ALLOW_COMMINGLE_FLAG = "--allow-commingle-validation-output";
+function assertCompeteProtectedBranchForCompletionMode(options) {
+  if (options.effectiveCompletionMode !== "branch") {
+    return;
+  }
+  const branch = options.currentBranch ?? getCurrentBranch(options.cwd);
+  if (branch === "HEAD") {
+    throw headRefusal(options.command, options.cwd);
+  }
+  const role = classifyBranchRole(branch, void 0, options.cwd);
+  if (isDisposableBranchRole(role) && !options.allowCommingleValidationOutput) {
+    throw new BranchRoleCodeApplyError({ branch, role, command: options.command });
+  }
+  if (options.allowProtected) {
+    return;
+  }
+  if (options.allowMain) {
+    if (branch === "main" || branch === "master") return;
+  }
+  if (isProtectedPipelineBranch(branch, void 0, options.cwd)) {
+    throw new CompeteProtectedBranchCompletionError(branch, "branch", options.command);
+  }
+}
+function assertBranchAllowsCodeApply(options) {
+  const branch = options.currentBranch ?? getCurrentBranch(options.cwd);
+  assertCompeteProtectedBranchForCompletionMode({
+    allowMain: options.allowMain,
+    allowProtected: options.allowProtected,
+    allowCommingleValidationOutput: options.allowCommingleValidationOutput,
+    command: options.command,
+    cwd: options.cwd,
+    currentBranch: branch,
+    effectiveCompletionMode: "branch"
+  });
+  const role = classifyBranchRole(branch, void 0, options.cwd);
+  return {
+    branch,
+    role,
+    commingled: Boolean(options.allowCommingleValidationOutput) && isDisposableBranchRole(role)
+  };
+}
+function assertBacklogExecutionCanBranchFrom(options) {
+  const branch = options.currentBranch;
+  if (!branch || branch === "HEAD") {
+    return {
+      branch: branch ?? null,
+      role: branch === "HEAD" ? "detached" : null,
+      branchFromCurrentHead: false
+    };
+  }
+  const role = classifyBranchRole(branch, void 0, options.cwd);
+  if (role === "validation" || role === "run" || role === "generated-artifact" || role === "local-scratch") {
+    throw new BacklogExecutionBranchRoleError(branch, role);
+  }
+  return {
+    branch,
+    role,
+    branchFromCurrentHead: role !== "protected"
+  };
+}
+var BacklogLocalApplyProtectedError = class extends Error {
+  branch;
+  constructor(branch) {
+    super(
+      `Cannot run backlog execute --no-open-pr from protected branch '${branch}'.
+--no-open-pr applies the result onto '${branch}', and protected branches do not accept local applies.
+
+Start from a product branch, or drop --no-open-pr to deliver through a pull request:
+  git checkout -b fix/<slug>
+  build plan backlog execute <id> --no-open-pr`
+    );
+    this.name = "BacklogLocalApplyProtectedError";
+    this.branch = branch;
+  }
+};
+function assertBacklogLocalApplyTarget(applyTarget, cwd) {
+  if (classifyBranchRole(applyTarget, void 0, cwd) === "protected") {
+    throw new BacklogLocalApplyProtectedError(applyTarget);
+  }
+}
+function slugify2(text) {
+  return slugify(text).slice(0, 40);
+}
+
+export {
+  resolveManagedSyncDefaultBranch,
+  resolveDefaultBranch,
+  resetDefaultBranchCache,
+  classifyBranchRole,
+  isDisposableBranchRole,
+  needsNewWorkingBranch,
+  isEphemeralBuildBranchDeletionCandidate,
+  branchRoleLabel,
+  isProtectedPipelineBranch,
+  CURRENT_BRANCH_REV_PARSE_ARGS,
+  parseCurrentBranchRef,
+  getCurrentBranch,
+  CompeteProtectedBranchCompletionError,
+  BranchRoleCodeApplyError,
+  BacklogExecutionBranchRoleError,
+  formatProtectedBranchMessage,
+  formatCompeteCompletionProtectedBranchMessage,
+  ProtectedBranchError,
+  detectUnbornBranch,
+  requireNonProtectedBranch,
+  checkoutValidationBranchForRun,
+  restoreCheckoutFromBranch,
+  requireNonDetachedHead,
+  assertCompeteProtectedBranchForExecutionIntent,
+  ALLOW_COMMINGLE_FLAG,
+  assertCompeteProtectedBranchForCompletionMode,
+  assertBranchAllowsCodeApply,
+  assertBacklogExecutionCanBranchFrom,
+  BacklogLocalApplyProtectedError,
+  assertBacklogLocalApplyTarget
+};
+//# sourceMappingURL=chunk-XGU6PBO5.js.map

package/dist/chunk-XHOI4V62.js

@@ -0,0 +1,43 @@
+import {
+  execGit,
+  execGitSync
+} from "./chunk-MHLEZQQI.js";
+
+// src/core/git/exec-checked.ts
+var GitCommandFailedError = class extends Error {
+  args;
+  cwd;
+  exitCode;
+  stdout;
+  stderr;
+  constructor(args, cwd, result) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    super(
+      `git ${args.join(" ")} exited with code ${result.exitCode} (cwd: ${cwd})${detail ? `: ${detail}` : ""}`
+    );
+    this.name = "GitCommandFailedError";
+    this.args = args;
+    this.cwd = cwd;
+    this.exitCode = result.exitCode;
+    this.stdout = result.stdout;
+    this.stderr = result.stderr;
+  }
+};
+function assertSucceeded(args, opts, result) {
+  if (result.exitCode !== 0) {
+    throw new GitCommandFailedError(args, opts.cwd, result);
+  }
+  return result;
+}
+async function execGitChecked(args, opts) {
+  return assertSucceeded(args, opts, await execGit(args, opts));
+}
+function execGitSyncChecked(args, opts) {
+  return assertSucceeded(args, opts, execGitSync(args, opts));
+}
+
+export {
+  execGitChecked,
+  execGitSyncChecked
+};
+//# sourceMappingURL=chunk-XHOI4V62.js.map