issue-flow 0.11.1 → 0.13.0

package/dist/chunk-KQHB7ZT3.js

@@ -0,0 +1,559 @@
+#!/usr/bin/env node
+import {
+  classify,
+  requiresHumanAction
+} from "./chunk-XEYH6ZZI.js";
+
+// src/utils/shell.ts
+import { basename } from "path";
+import { execa } from "execa";
+
+// src/resilience/policy.ts
+var CONFIG_KEYS = {
+  network: "network",
+  timeout: "timeout",
+  stalled: "stalled",
+  rate_limit: "rateLimit",
+  provider_down: "providerDown",
+  provider_crash: "providerCrash",
+  authentication: "authentication",
+  configuration: "configuration",
+  repository_state: "repositoryState",
+  task_execution: "taskExecution",
+  internal: "internal",
+  unknown: "unknown"
+};
+function retryConfigKey(kind) {
+  return CONFIG_KEYS[kind];
+}
+var RETRY_CONFIG_KEYS = Object.values(CONFIG_KEYS);
+var SECOND = 1e3;
+function policy(overrides) {
+  return {
+    maxAttempts: 0,
+    initialDelayMs: 0,
+    maxDelayMs: 0,
+    backoffFactor: 2,
+    jitter: "full",
+    retryForever: false,
+    failover: "never",
+    failoverAfterAttempts: 2,
+    onExhausted: "fail",
+    ...overrides
+  };
+}
+var BASE_POLICIES = {
+  network: policy({ maxAttempts: 8, initialDelayMs: 2 * SECOND, maxDelayMs: 120 * SECOND }),
+  timeout: policy({
+    maxAttempts: 2,
+    initialDelayMs: 30 * SECOND,
+    maxDelayMs: 120 * SECOND,
+    failover: "after_attempts"
+  }),
+  stalled: policy({
+    maxAttempts: 2,
+    initialDelayMs: 15 * SECOND,
+    maxDelayMs: 15 * SECOND,
+    failover: "after_attempts"
+  }),
+  rate_limit: policy({
+    maxAttempts: 6,
+    initialDelayMs: 60 * SECOND,
+    maxDelayMs: 900 * SECOND,
+    failover: "after_attempts"
+  }),
+  provider_down: policy({
+    maxAttempts: 4,
+    initialDelayMs: 10 * SECOND,
+    maxDelayMs: 300 * SECOND,
+    failover: "after_attempts"
+  }),
+  provider_crash: policy({
+    maxAttempts: 3,
+    initialDelayMs: 5 * SECOND,
+    maxDelayMs: 60 * SECOND,
+    failover: "after_attempts"
+  }),
+  authentication: policy({ maxAttempts: 0, onExhausted: "block" }),
+  configuration: policy({ maxAttempts: 0 }),
+  repository_state: policy({ maxAttempts: 0, onExhausted: "block" }),
+  task_execution: policy({ maxAttempts: 0 }),
+  internal: policy({ maxAttempts: 2, initialDelayMs: 5 * SECOND, maxDelayMs: 5 * SECOND }),
+  unknown: policy({ maxAttempts: 2, initialDelayMs: 5 * SECOND, maxDelayMs: 5 * SECOND })
+};
+var CONTINUOUS_OVERRIDES = {
+  network: { retryForever: true },
+  timeout: { maxAttempts: 3 },
+  stalled: { maxAttempts: 3 },
+  rate_limit: { retryForever: true },
+  provider_down: { retryForever: true, failover: "after_attempts" },
+  provider_crash: { maxAttempts: 5 }
+};
+function resolvePolicy(kind, config = {}) {
+  const base = BASE_POLICIES[kind];
+  const profile = config.profile === "continuous" ? CONTINUOUS_OVERRIDES[kind] : void 0;
+  const user = config.retry?.[retryConfigKey(kind)];
+  const resolved = { ...base, ...profile, ...user };
+  if (!requiresHumanAction(kind)) return sanitize(resolved);
+  return sanitize({
+    ...resolved,
+    maxAttempts: 0,
+    retryForever: false,
+    failover: kind === "authentication" && config.failoverOnAuth === true ? resolved.failover : "never"
+  });
+}
+function sanitize(value) {
+  return {
+    ...value,
+    maxAttempts: Math.max(0, Math.trunc(value.maxAttempts)),
+    initialDelayMs: Math.max(0, value.initialDelayMs),
+    maxDelayMs: Math.max(0, value.maxDelayMs),
+    backoffFactor: value.backoffFactor >= 1 ? value.backoffFactor : 1,
+    failoverAfterAttempts: Math.max(1, Math.trunc(value.failoverAfterAttempts))
+  };
+}
+function shouldRetry(policy2, attemptsMade) {
+  if (policy2.maxAttempts <= 0) return false;
+  if (policy2.retryForever) return true;
+  return attemptsMade < policy2.maxAttempts;
+}
+function shouldFailover(policy2, attemptsMade) {
+  if (policy2.failover === "never") return false;
+  if (policy2.failover === "immediate") return true;
+  return attemptsMade >= policy2.failoverAfterAttempts;
+}
+function computeDelayMs(policy2, attemptsMade, options = {}) {
+  if (options.retryAfterMs !== void 0 && options.retryAfterMs >= 0) {
+    return Math.round(options.retryAfterMs);
+  }
+  const exponent = Math.max(0, attemptsMade - 1);
+  const growth = policy2.initialDelayMs * policy2.backoffFactor ** exponent;
+  const ceiling = Math.min(policy2.maxDelayMs, growth);
+  if (ceiling <= 0) return 0;
+  if (policy2.jitter === "none") return Math.round(ceiling);
+  const random = options.random ?? Math.random;
+  return Math.round(random() * ceiling);
+}
+function abortableDelay(ms, options = {}) {
+  const { signal } = options;
+  if (signal?.aborted === true) return Promise.resolve(false);
+  if (ms <= 0) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve(false);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/resilience/retry.ts
+async function withRetry(fn, options) {
+  const { policy: policy2, evaluate, signal, onAttempt, random } = options;
+  const delay = options.delay ?? abortableDelay;
+  const policyFor = typeof policy2 === "function" ? policy2 : () => policy2;
+  for (let attempt = 1; ; attempt++) {
+    const value = await fn(attempt);
+    const failure = evaluate(value, attempt);
+    if (failure === null) {
+      await onAttempt?.({ attempt, value, failure, willRetry: false, delayMs: 0 });
+      return { value, attempts: attempt, failure: null, exhausted: false, aborted: false };
+    }
+    const active = policyFor(failure);
+    const eligible = failure.retryable && !requiresHumanAction(failure.kind);
+    const willRetry = eligible && shouldRetry(active, attempt);
+    const delayMs = willRetry ? computeDelayMs(active, attempt, { random, retryAfterMs: failure.retryAfterMs }) : 0;
+    await onAttempt?.({ attempt, value, failure, willRetry, delayMs });
+    if (!willRetry) {
+      return { value, attempts: attempt, failure, exhausted: eligible, aborted: false };
+    }
+    if (!await delay(delayMs, { signal })) {
+      return { value, attempts: attempt, failure, exhausted: false, aborted: true };
+    }
+  }
+}
+function fixedBackoffPolicy(maxAttempts, baseSeconds, maxSeconds, overrides = {}) {
+  return {
+    maxAttempts,
+    initialDelayMs: baseSeconds * 1e3,
+    maxDelayMs: maxSeconds * 1e3,
+    backoffFactor: 2,
+    jitter: "none",
+    retryForever: false,
+    failover: "never",
+    failoverAfterAttempts: 2,
+    onExhausted: "fail",
+    ...overrides
+  };
+}
+
+// src/utils/shell.ts
+var SOURCE_BY_COMMAND = {
+  git: "git",
+  gh: "github"
+};
+function inferSource(command) {
+  return SOURCE_BY_COMMAND[basename(command)] ?? "internal";
+}
+var GIT_GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--super-prefix"
+]);
+var DESTRUCTIVE_GIT_COMMANDS = {
+  rebase: true,
+  "cherry-pick": true,
+  revert: true,
+  merge: true,
+  am: true,
+  restore: true,
+  "filter-branch": true,
+  gc: true,
+  prune: true,
+  "update-ref": true,
+  push: ["-f", "--force", "--force-with-lease", "--force-if-includes", "--delete", "--mirror"],
+  reset: ["--hard", "--merge", "--keep"],
+  clean: ["-f", "--force"],
+  checkout: ["-f", "--force", "-B"],
+  switch: ["-f", "--force", "--discard-changes"],
+  branch: ["-d", "-D", "--delete", "-M"],
+  tag: ["-d", "--delete", "-f", "--force"],
+  stash: ["drop", "clear", "pop"],
+  worktree: ["remove", "prune"],
+  submodule: ["deinit"]
+};
+function gitSubcommand(args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (GIT_GLOBAL_OPTIONS_WITH_VALUE.has(arg)) {
+      index++;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    return { name: arg, rest: args.slice(index + 1) };
+  }
+  return null;
+}
+function hasToken(rest, token) {
+  if (token.startsWith("--")) {
+    return rest.some((arg) => arg === token || arg.startsWith(`${token}=`));
+  }
+  if (token.startsWith("-")) {
+    const letter = token.slice(1);
+    return rest.some((arg) => /^-[A-Za-z]+$/.test(arg) && arg.slice(1).includes(letter));
+  }
+  return rest.includes(token);
+}
+function isRetryableInvocation(command, args) {
+  if (basename(command) !== "git") return true;
+  const subcommand = gitSubcommand(args);
+  if (subcommand === null) return true;
+  const rule = DESTRUCTIVE_GIT_COMMANDS[subcommand.name];
+  if (rule === void 0) return true;
+  if (rule === true) return false;
+  return !rule.some((token) => hasToken(subcommand.rest, token));
+}
+function asString(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function toFailureSignal(raw, result, source) {
+  const fields = raw ?? {};
+  const errno = asString(fields.code);
+  const signal = asString(fields.signal);
+  const stderr = result.stderr.trim() !== "" ? result.stderr : asString(fields.originalMessage) ?? asString(fields.shortMessage) ?? "";
+  return {
+    source,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr,
+    ...errno === void 0 ? {} : { errno },
+    ...signal === void 0 ? {} : { signal },
+    ...fields.timedOut === true ? { timedOut: true } : {}
+  };
+}
+async function execOnce(command, args, options) {
+  const raw = await execa(command, args, {
+    reject: false,
+    ...options
+  });
+  return {
+    raw,
+    result: {
+      stdout: raw.stdout?.toString() ?? "",
+      stderr: raw.stderr?.toString() ?? "",
+      exitCode: raw.exitCode ?? 1
+    }
+  };
+}
+async function run(command, args = [], options) {
+  const { retry, source, retrySignal, onRetryAttempt, ...execaOptions } = options ?? {};
+  if (retry === void 0 || !isRetryableInvocation(command, args)) {
+    return (await execOnce(command, args, execaOptions)).result;
+  }
+  const failureSource = source ?? inferSource(command);
+  const outcome = await withRetry(
+    async () => {
+      const { result, raw } = await execOnce(command, args, execaOptions);
+      const failure = result.exitCode === 0 ? null : classify(toFailureSignal(raw, result, failureSource));
+      return { result, failure };
+    },
+    {
+      policy: retry,
+      evaluate: (attempt) => attempt.failure,
+      ...retrySignal === void 0 ? {} : { signal: retrySignal },
+      ...onRetryAttempt === void 0 ? {} : {
+        onAttempt: (info) => onRetryAttempt({
+          attempt: info.attempt,
+          result: info.value.result,
+          failure: info.value.failure,
+          willRetry: info.willRetry,
+          delayMs: info.delayMs
+        })
+      }
+    }
+  );
+  return {
+    ...outcome.value.result,
+    attempts: outcome.attempts,
+    ...outcome.failure === null ? {} : { failure: outcome.failure }
+  };
+}
+
+// src/utils/git.ts
+async function getProjectRoot() {
+  const result = await run("git", ["rev-parse", "--show-toplevel"]);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      "Not inside a git repository. Please run issue-flow from within a git project."
+    );
+  }
+  return result.stdout.trim();
+}
+async function getCurrentBranch() {
+  const result = await run("git", ["branch", "--show-current"]);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      "Failed to detect git branch. Ensure git is installed and you are inside a repository."
+    );
+  }
+  return result.stdout.trim();
+}
+async function getBaseBranch() {
+  const remoteHead = await run("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+  if (remoteHead.exitCode === 0) {
+    const name = remoteHead.stdout.trim().replace(/^origin\//, "");
+    if (name) return name;
+  }
+  for (const candidate of ["main", "master"]) {
+    const check = await run("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`]);
+    if (check.exitCode === 0) return candidate;
+  }
+  return "main";
+}
+async function getRemoteUrl(cwd) {
+  let result;
+  try {
+    result = await run("git", ["remote", "get-url", "origin"], { cwd });
+  } catch {
+    return null;
+  }
+  if (result.exitCode !== 0) return null;
+  const url = result.stdout.trim();
+  return url === "" ? null : url;
+}
+async function getHeadCommit(cwd) {
+  let result;
+  try {
+    result = await run("git", ["rev-parse", "--short", "HEAD"], { cwd });
+  } catch {
+    return null;
+  }
+  if (result.exitCode !== 0) return null;
+  const hash = result.stdout.trim();
+  return hash === "" ? null : hash;
+}
+function normalizeRemoteUrl(url) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  let authority;
+  let path;
+  const scheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.exec(trimmed);
+  if (scheme) {
+    const rest = trimmed.slice(scheme[0].length);
+    const slash = rest.indexOf("/");
+    if (slash === -1) return null;
+    authority = rest.slice(0, slash);
+    path = rest.slice(slash + 1);
+  } else {
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) return null;
+    authority = trimmed.slice(0, colon);
+    path = trimmed.slice(colon + 1);
+  }
+  const at = authority.lastIndexOf("@");
+  if (at !== -1) authority = authority.slice(at + 1);
+  const host = authority.replace(/:\d+$/, "").toLowerCase();
+  if (host === "") return null;
+  const normalizedPath = path.replace(/[?#].*$/, "").replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "").replace(/\/+$/, "").toLowerCase();
+  if (normalizedPath === "") return null;
+  return `${host}/${normalizedPath}`;
+}
+function stripRemoteUrlCredentials(url) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  const httpScheme = /^https?:\/\//i.exec(trimmed);
+  if (!httpScheme) return trimmed;
+  const rest = trimmed.slice(httpScheme[0].length);
+  const slash = rest.indexOf("/");
+  const authority = slash === -1 ? rest : rest.slice(0, slash);
+  const remainder = slash === -1 ? "" : rest.slice(slash);
+  const at = authority.lastIndexOf("@");
+  if (at === -1) return trimmed;
+  return `${httpScheme[0]}${authority.slice(at + 1)}${remainder}`;
+}
+async function getCommitsSince(base) {
+  const result = await run("git", ["log", "--pretty=format:%h%x09%s", `${base}..HEAD`]);
+  if (result.exitCode !== 0) return [];
+  return result.stdout.split("\n").filter((line) => line.trim() !== "").map((line) => {
+    const tab = line.indexOf("	");
+    return tab === -1 ? { hash: line.trim(), subject: "" } : { hash: line.slice(0, tab), subject: line.slice(tab + 1) };
+  });
+}
+async function refExists(ref, cwd) {
+  const result = await run("git", ["rev-parse", "--verify", "--quiet", ref], {
+    ...cwd === void 0 ? {} : { cwd }
+  });
+  return result.exitCode === 0;
+}
+var SEQUENCER_REFS = [
+  {
+    ref: "REBASE_HEAD",
+    kind: "rebase_in_progress",
+    name: "a rebase",
+    suggestion: "git rebase --continue (or git rebase --abort)"
+  },
+  {
+    ref: "MERGE_HEAD",
+    kind: "merge_in_progress",
+    name: "a merge",
+    suggestion: "git merge --continue (or git merge --abort)"
+  },
+  {
+    ref: "CHERRY_PICK_HEAD",
+    kind: "cherry_pick_in_progress",
+    name: "a cherry-pick",
+    suggestion: "git cherry-pick --continue (or git cherry-pick --abort)"
+  },
+  {
+    ref: "REVERT_HEAD",
+    kind: "revert_in_progress",
+    name: "a revert",
+    suggestion: "git revert --continue (or git revert --abort)"
+  }
+];
+async function preflightRepository(options = {}) {
+  const { cwd, expectedBranch, intent = "new-phase" } = options;
+  const at = cwd === void 0 ? {} : { cwd };
+  const blocks = [];
+  for (const sequencer of SEQUENCER_REFS) {
+    if (await refExists(sequencer.ref, cwd)) {
+      blocks.push({
+        kind: sequencer.kind,
+        message: `The repository is in the middle of ${sequencer.name} (${sequencer.ref} is present).`,
+        suggestion: sequencer.suggestion
+      });
+    }
+  }
+  const unmerged = await run("git", ["diff", "--name-only", "--diff-filter=U"], at);
+  const conflicted = unmerged.stdout.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  if (conflicted.length > 0) {
+    blocks.push({
+      kind: "unmerged_paths",
+      message: `${conflicted.length} file(s) still have unresolved conflicts: ${conflicted.slice(0, 5).join(", ")}${conflicted.length > 5 ? ", \u2026" : ""}.`,
+      suggestion: "Resolve them, then git add the files"
+    });
+  }
+  const symbolic = await run("git", ["symbolic-ref", "-q", "HEAD"], at);
+  const detached = symbolic.exitCode !== 0;
+  const branch = detached ? null : symbolic.stdout.trim().replace(/^refs\/heads\//, "");
+  if (detached) {
+    blocks.push({
+      kind: "detached_head",
+      message: "HEAD is detached, so a commit would belong to no branch.",
+      suggestion: `git switch ${expectedBranch ?? "<branch>"}`
+    });
+  } else if (expectedBranch !== void 0 && expectedBranch !== null && expectedBranch !== "" && branch !== expectedBranch) {
+    blocks.push({
+      kind: "branch_mismatch",
+      message: `The plan works on '${expectedBranch}' but the repository is on '${branch}'.`,
+      suggestion: `git switch ${expectedBranch}`
+    });
+  }
+  const status = await run("git", ["status", "--porcelain"], at);
+  const dirty = status.stdout.trim() !== "";
+  if (dirty && intent !== "resume-same-phase") {
+    blocks.push({
+      kind: "dirty_tree",
+      message: "The working tree has uncommitted changes that do not belong to this phase.",
+      suggestion: "Commit or stash them yourself, then run again"
+    });
+  }
+  return { ok: blocks.length === 0, blocks, branch, dirty };
+}
+function describePreflight(result) {
+  return result.blocks.map((block) => `${block.message} Suggested: ${block.suggestion}`);
+}
+var STORY_ID_IN_SUBJECT = /\bUS-\d+\b/g;
+async function committedStoryIds(baseBranch, cwd) {
+  const at = cwd === void 0 ? {} : { cwd };
+  const range = baseBranch === "" ? "HEAD" : `${baseBranch}..HEAD`;
+  const result = await run("git", ["log", range, "--format=%s"], at);
+  if (result.exitCode !== 0) return /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  for (const subject of result.stdout.split("\n")) {
+    for (const match of subject.matchAll(STORY_ID_IN_SUBJECT)) {
+      ids.add(match[0]);
+    }
+  }
+  return ids;
+}
+async function isWorkingTreeClean(cwd) {
+  const at = cwd === void 0 ? {} : { cwd };
+  const result = await run("git", ["status", "--porcelain"], at);
+  if (result.exitCode !== 0) return false;
+  return result.stdout.trim() === "";
+}
+
+export {
+  RETRY_CONFIG_KEYS,
+  resolvePolicy,
+  shouldFailover,
+  abortableDelay,
+  withRetry,
+  fixedBackoffPolicy,
+  run,
+  getProjectRoot,
+  getCurrentBranch,
+  getBaseBranch,
+  getRemoteUrl,
+  getHeadCommit,
+  normalizeRemoteUrl,
+  stripRemoteUrlCredentials,
+  getCommitsSince,
+  preflightRepository,
+  describePreflight,
+  committedStoryIds,
+  isWorkingTreeClean
+};
+//# sourceMappingURL=chunk-KQHB7ZT3.js.map