issue-flow 0.7.0 → 0.7.2

package/dist/chunk-G3TJHMAS.js

@@ -0,0 +1,759 @@
+#!/usr/bin/env node
+import {
+  isoNow,
+  issuesConfigSchema,
+  prReviewConfigSchema,
+  printInfo,
+  printWarning,
+  webConfigSchema,
+  writeFileAtomic
+} from "./chunk-JNEHVQH5.js";
+
+// src/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { platform } from "os";
+import { join as join4 } from "path";
+
+// src/storage/paths.ts
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { basename, join, resolve } from "path";
+
+// src/utils/shell.ts
+import { execa } from "execa";
+async function run(command, args = [], options) {
+  const result = await execa(command, args, {
+    reject: false,
+    ...options
+  });
+  return {
+    stdout: result.stdout?.toString() ?? "",
+    stderr: result.stderr?.toString() ?? "",
+    exitCode: result.exitCode ?? 1
+  };
+}
+
+// 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;
+}
+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}`;
+}
+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) };
+  });
+}
+
+// src/storage/paths.ts
+var GLOBAL_DIR_NAME = ".issue-flow";
+var GLOBAL_ROOT_ENV = "ISSUE_FLOW_HOME";
+var PROJECTS_DIR_NAME = "projects";
+var ISSUES_DIR_NAME = "issues";
+function getGlobalRoot(options = {}) {
+  const env = options.env ?? process.env;
+  const override = env[GLOBAL_ROOT_ENV]?.trim();
+  if (override) {
+    return resolve(override);
+  }
+  let home;
+  try {
+    home = homedir();
+  } catch {
+    home = "";
+  }
+  if (home.trim() === "") {
+    throw new Error(
+      `Unable to resolve the home directory for the global storage. Set ${GLOBAL_ROOT_ENV} to an explicit path.`
+    );
+  }
+  return join(home, GLOBAL_DIR_NAME);
+}
+var SLUG_MAX_LENGTH = 32;
+var HASH_LENGTH = 12;
+var FALLBACK_SLUG = "project";
+function slugify(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, SLUG_MAX_LENGTH).replace(/-+$/g, "");
+  return slug === "" ? FALLBACK_SLUG : slug;
+}
+function projectIdFromRemote(remote, projectRoot) {
+  let seed;
+  let name;
+  if (remote) {
+    seed = `remote:${remote}`;
+    name = remote.split("/").pop() ?? "";
+  } else {
+    const absolute = resolve(projectRoot);
+    seed = `path:${absolute}`;
+    name = basename(absolute);
+  }
+  const hash = createHash("sha256").update(seed).digest("hex").slice(0, HASH_LENGTH);
+  return `${slugify(name)}-${hash}`;
+}
+function getProjectDir(projectId, options = {}) {
+  return join(getGlobalRoot(options), PROJECTS_DIR_NAME, projectId);
+}
+function normalizeIssueNumber(issueNumber) {
+  const normalized = String(issueNumber).trim().replace(/^#/, "");
+  if (normalized.length === 0) {
+    throw new Error("Issue identifier cannot be empty");
+  }
+  if (/[/\\]/.test(normalized) || normalized === "." || normalized === "..") {
+    throw new Error(`Invalid issue identifier: '${issueNumber}'`);
+  }
+  return normalized;
+}
+function getIssuePaths(projectId, issueNumber, options = {}) {
+  const issueDir = join(
+    getProjectDir(projectId, options),
+    ISSUES_DIR_NAME,
+    normalizeIssueNumber(issueNumber)
+  );
+  return {
+    issueDir,
+    issueFile: join(issueDir, "issue.md"),
+    metadataFile: join(issueDir, "metadata.json"),
+    prdFile: join(issueDir, "prd.md"),
+    tasksFile: join(issueDir, "tasks.json"),
+    progressFile: join(issueDir, "progress.txt"),
+    analysisFile: join(issueDir, "analysis.md"),
+    sessionFile: join(issueDir, "session.json"),
+    lastBranchFile: join(issueDir, ".last-branch"),
+    archiveDir: join(issueDir, "archive"),
+    prReviewDir: join(issueDir, "pr-review")
+  };
+}
+
+// src/storage/resolve.ts
+import { stat as stat2 } from "fs/promises";
+import { basename as basename2, join as join3, resolve as resolve3 } from "path";
+
+// src/storage/compat.ts
+import { copyFile, mkdir, readdir, readFile, stat } from "fs/promises";
+import { join as join2, resolve as resolve2, sep } from "path";
+
+// src/storage/schemas.ts
+import { z } from "zod";
+var STORAGE_SCHEMA_VERSION = 1;
+var projectMetadataSchema = z.object({
+  schemaVersion: z.number().int().positive(),
+  projectId: z.string().min(1),
+  root: z.string().min(1),
+  /** Normalized remote (`host/org/repo`), or null when the project has none. */
+  remoteUrl: z.string().nullable(),
+  createdAt: z.string().min(1),
+  updatedAt: z.string().min(1),
+  /** Null until the project is used by a pipeline run. */
+  lastAttemptAt: z.string().nullable()
+});
+var webShape = webConfigSchema.shape;
+var globalWebConfigSchema = z.object({
+  port: webShape.port.unwrap(),
+  host: webShape.host.unwrap(),
+  refreshSeconds: webShape.refreshSeconds.unwrap(),
+  logLimit: webShape.logLimit.unwrap()
+}).partial();
+var globalRetryConfigSchema = z.object({
+  retryLimit: z.number().int().nonnegative(),
+  retryForever: z.boolean(),
+  backoffBaseSeconds: z.number().nonnegative(),
+  backoffMaxSeconds: z.number().nonnegative()
+}).partial();
+var globalCommitConfigSchema = z.object({
+  signoff: z.boolean(),
+  conventional: z.boolean()
+}).partial();
+var globalConfigSchema = z.object({
+  schemaVersion: z.number().int().positive(),
+  /** Override for the directory holding `projects/`. */
+  storageDir: z.string().min(1),
+  web: globalWebConfigSchema,
+  retry: globalRetryConfigSchema,
+  commit: globalCommitConfigSchema
+}).partial();
+
+// src/storage/compat.ts
+var LEGACY_ISSUES_DIR_NAME = "issues";
+var METADATA_FILENAME = "metadata.json";
+async function directoryExists(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveStorageMode(projectRoot, options = {}) {
+  const remoteUrl = normalizeRemoteUrl(await getRemoteUrl(projectRoot));
+  const projectId = projectIdFromRemote(remoteUrl, projectRoot);
+  const globalDir = getProjectDir(projectId, options);
+  const legacyDir = join2(resolve2(projectRoot), LEGACY_ISSUES_DIR_NAME);
+  const [globalExists, legacyExists] = await Promise.all([
+    directoryExists(globalDir),
+    directoryExists(legacyDir)
+  ]);
+  return {
+    // Only one state calls for work: legacy content that has nowhere to be read
+    // from yet. Everything else — including "neither exists" — is already the
+    // global layout.
+    mode: legacyExists && !globalExists ? "needs-migration" : "global",
+    projectId,
+    globalDir,
+    legacyDir,
+    globalExists,
+    legacyExists,
+    remoteUrl
+  };
+}
+function migrationFailure(issue, relativePath, err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  return new Error(
+    `Failed to migrate '${relativePath}' (issue '${issue}'): ${reason}. The legacy directory was left untouched \u2014 fix the cause and run the migration again.`
+  );
+}
+function issueOf(relativePath) {
+  return relativePath.split(sep)[0] || ".";
+}
+async function copyTree(sourceRoot, targetRoot, relativeDir, result) {
+  const source = join2(sourceRoot, relativeDir);
+  const target = join2(targetRoot, relativeDir);
+  let entries;
+  try {
+    entries = await readdir(source, { withFileTypes: true });
+  } catch (err) {
+    throw migrationFailure(issueOf(relativeDir), relativeDir || ".", err);
+  }
+  try {
+    await mkdir(target, { recursive: true });
+  } catch (err) {
+    throw migrationFailure(issueOf(relativeDir), relativeDir || ".", err);
+  }
+  for (const entry of entries) {
+    const relativePath = join2(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyTree(sourceRoot, targetRoot, relativePath, result);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const to = join2(targetRoot, relativePath);
+    try {
+      if (await pathExists(to)) {
+        result.skipped.push(relativePath);
+        continue;
+      }
+      await copyFile(join2(sourceRoot, relativePath), to);
+      result.copied.push(relativePath);
+    } catch (err) {
+      throw migrationFailure(issueOf(relativePath), relativePath, err);
+    }
+  }
+}
+async function readExistingMetadata(file) {
+  let raw;
+  try {
+    raw = await readFile(file, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = projectMetadataSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function migrateLegacyStorage(projectRoot, options = {}) {
+  const status = await resolveStorageMode(projectRoot, { env: options.env });
+  const result = { copied: [], skipped: [] };
+  try {
+    await mkdir(status.globalDir, { recursive: true });
+  } catch (err) {
+    throw migrationFailure(".", status.globalDir, err);
+  }
+  if (status.legacyExists) {
+    await copyTree(status.legacyDir, join2(status.globalDir, ISSUES_DIR_NAME), "", result);
+  }
+  const now = (options.now ?? isoNow)();
+  const metadataFile = join2(status.globalDir, METADATA_FILENAME);
+  const existing = await readExistingMetadata(metadataFile);
+  const metadata = {
+    schemaVersion: STORAGE_SCHEMA_VERSION,
+    projectId: status.projectId,
+    root: resolve2(projectRoot),
+    remoteUrl: status.remoteUrl,
+    // The project was first seen whenever it was first written, not now.
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    lastAttemptAt: existing?.lastAttemptAt ?? null
+  };
+  await writeFileAtomic(metadataFile, `${JSON.stringify(metadata, null, 2)}
+`);
+  return {
+    projectId: status.projectId,
+    globalDir: status.globalDir,
+    legacyDir: status.legacyDir,
+    previousMode: status.mode,
+    ...result,
+    metadataFile,
+    metadata
+  };
+}
+
+// src/storage/resolve.ts
+var projectCache = /* @__PURE__ */ new Map();
+var checkedIssues = /* @__PURE__ */ new Set();
+async function directoryExists2(path) {
+  try {
+    return (await stat2(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function announceMigration(result) {
+  if (result.copied.length === 0) return;
+  const count = result.copied.length;
+  const target = join3(result.globalDir, ISSUES_DIR_NAME);
+  printInfo(
+    `Migrated ${count} file${count === 1 ? "" : "s"} from ${result.legacyDir} to ${target}`
+  );
+  printInfo(
+    `The legacy directory was not modified or removed \u2014 ${result.legacyDir} is kept as-is, read-only, for compatibility.`
+  );
+}
+async function resolveProject(projectRoot, options) {
+  const status = await resolveStorageMode(projectRoot, options);
+  if (status.mode === "needs-migration") {
+    announceMigration(await migrateLegacyStorage(projectRoot, options));
+  }
+  return {
+    projectId: status.projectId,
+    legacyDir: status.legacyDir
+  };
+}
+function getProjectResolution(projectRoot, options) {
+  const key = `${getGlobalRoot(options)}::${projectRoot}`;
+  const cached = projectCache.get(key);
+  if (cached) return cached;
+  const pending = resolveProject(projectRoot, options).catch((err) => {
+    projectCache.delete(key);
+    throw err;
+  });
+  projectCache.set(key, pending);
+  return pending;
+}
+async function resolveProjectPaths(options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve3(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const projectDir = getProjectDir(project.projectId, rootOptions);
+  return {
+    projectId: project.projectId,
+    projectDir,
+    issuesDir: join3(projectDir, ISSUES_DIR_NAME)
+  };
+}
+async function resolveIssuePaths(issueNumber, options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve3(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const paths = getIssuePaths(project.projectId, issueNumber, rootOptions);
+  if (!checkedIssues.has(paths.issueDir)) {
+    const legacyIssueDir = join3(project.legacyDir, basename2(paths.issueDir));
+    if (!await directoryExists2(paths.issueDir) && await directoryExists2(legacyIssueDir)) {
+      announceMigration(await migrateLegacyStorage(projectRoot, rootOptions));
+    }
+    checkedIssues.add(paths.issueDir);
+  }
+  return paths;
+}
+
+// src/config.ts
+var DEFAULTS = {
+  retryLimit: 10,
+  retryForever: false,
+  backoffBaseSeconds: 30,
+  backoffMaxSeconds: 900
+};
+function createConfig(options) {
+  return {
+    issueNumber: options.issueNumber,
+    maxIterations: options.maxIterations,
+    retryLimit: options.retryLimit ?? DEFAULTS.retryLimit,
+    retryForever: options.retryForever ?? DEFAULTS.retryForever,
+    backoffBaseSeconds: options.backoffBaseSeconds ?? DEFAULTS.backoffBaseSeconds,
+    backoffMaxSeconds: options.backoffMaxSeconds ?? DEFAULTS.backoffMaxSeconds
+  };
+}
+async function resolvePaths(config, scriptDir) {
+  const projectRoot = await getProjectRoot();
+  if (config.issueNumber) {
+    const issuePaths = await resolveIssuePaths(config.issueNumber, { projectRoot });
+    return {
+      prdFile: issuePaths.tasksFile,
+      progressFile: issuePaths.progressFile,
+      archiveDir: issuePaths.archiveDir,
+      lastBranchFile: issuePaths.lastBranchFile,
+      projectRoot
+    };
+  }
+  const base = scriptDir ?? projectRoot;
+  return {
+    prdFile: join4(base, "prd.json"),
+    progressFile: join4(base, "progress.txt"),
+    archiveDir: join4(base, "archive"),
+    lastBranchFile: join4(base, ".last-branch"),
+    projectRoot
+  };
+}
+function getInstallHint(pkg) {
+  const os = platform();
+  if (os === "darwin") {
+    return `brew install ${pkg}`;
+  }
+  if (os === "linux") {
+    return `apt install ${pkg}  (or your distro's package manager)`;
+  }
+  if (os === "win32") {
+    return `winget install ${pkg}  (or choco install ${pkg})`;
+  }
+  return `install ${pkg} using your system package manager`;
+}
+async function validateDependencies() {
+  const errors = [];
+  const gitResult = await run("git", ["--version"]);
+  if (gitResult.exitCode !== 0) {
+    errors.push(`  - git  (install with: ${getInstallHint("git")})`);
+  }
+  const claudeResult = await run("claude", ["--version"]);
+  if (claudeResult.exitCode !== 0) {
+    errors.push("  - claude  (install with: npm install -g @anthropic-ai/claude-code)");
+  }
+  return errors;
+}
+var PROJECT_CONFIG_FILENAME = ".issue-flow.json";
+var WEB_CONFIG_FILENAME = PROJECT_CONFIG_FILENAME;
+async function readProjectConfigFile(projectRoot, warn) {
+  let root = projectRoot;
+  if (root === void 0) {
+    try {
+      root = await getProjectRoot();
+    } catch {
+      return null;
+    }
+  }
+  const filePath = join4(root, PROJECT_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: invalid JSON.`);
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: expected a JSON object.`);
+    return null;
+  }
+  return parsed;
+}
+var GLOBAL_CONFIG_FILENAME = "config.json";
+async function loadGlobalConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  let root;
+  try {
+    root = options.globalRoot ?? getGlobalRoot({ env: options.env ?? process.env });
+  } catch (err) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    return {};
+  }
+  const filePath = join4(root, GLOBAL_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    }
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: invalid JSON.`);
+    return {};
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: expected a JSON object.`);
+    return {};
+  }
+  const config = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    const result = globalConfigSchema.safeParse({ [key]: value });
+    if (!result.success) {
+      warn(
+        `Ignoring "${key}" key of ${GLOBAL_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+      );
+      continue;
+    }
+    Object.assign(config, result.data);
+  }
+  return config;
+}
+function mergeConfigLayers(layers) {
+  const merged = {};
+  for (const layer of [layers.defaults, layers.global, layers.project, layers.env, layers.cli]) {
+    for (const [key, value] of Object.entries(layer ?? {})) {
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+var webCliOverrides = {};
+function setWebCliOverrides(overrides) {
+  webCliOverrides = overrides;
+}
+var FALSY_ENV_VALUES = /* @__PURE__ */ new Set(["", "0", "false", "no", "off"]);
+function parseBooleanEnv(value) {
+  return !FALSY_ENV_VALUES.has(value.trim().toLowerCase());
+}
+function readNumberEnv(env, name, warn) {
+  const raw = env[name];
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`Ignoring ${name}="${raw}": not a number.`);
+    return void 0;
+  }
+  return parsed;
+}
+function readWebConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_WEB !== void 0) {
+    layer.enabled = parseBooleanEnv(env.ISSUE_FLOW_WEB);
+  }
+  const port = readNumberEnv(env, "ISSUE_FLOW_WEB_PORT", warn);
+  if (port !== void 0) {
+    layer.port = port;
+  }
+  if (env.ISSUE_FLOW_WEB_HOST !== void 0) {
+    layer.host = env.ISSUE_FLOW_WEB_HOST;
+  }
+  const refresh = readNumberEnv(env, "ISSUE_FLOW_WEB_REFRESH", warn);
+  if (refresh !== void 0) {
+    layer.refreshSeconds = refresh;
+  }
+  const logLimit = readNumberEnv(env, "ISSUE_FLOW_WEB_LOG_LIMIT", warn);
+  if (logLimit !== void 0) {
+    layer.logLimit = logLimit;
+  }
+  return layer;
+}
+async function readWebConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const web = file?.web;
+  if (web === void 0) {
+    return {};
+  }
+  const result = webConfigSchema.partial().safeParse(web);
+  if (!result.success) {
+    warn(
+      `Ignoring "web" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadWebConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? webCliOverrides;
+  const env = options.env ?? process.env;
+  const fileLayer = await readWebConfigFile(options.projectRoot, warn);
+  const envLayer = readWebConfigEnv(env, warn);
+  const merged = { ...fileLayer, ...envLayer, ...cli };
+  const result = webConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid web monitoring configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return webConfigSchema.parse({});
+}
+var issuesCliOverrides = {};
+function setIssuesCliOverrides(overrides) {
+  issuesCliOverrides = overrides;
+}
+async function readIssuesConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const issues = file?.issues;
+  if (issues === void 0) {
+    return {};
+  }
+  const result = issuesConfigSchema.partial().safeParse(issues);
+  if (!result.success) {
+    warn(
+      `Ignoring "issues" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadIssuesConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? issuesCliOverrides;
+  const fileLayer = await readIssuesConfigFile(options.projectRoot, warn);
+  const merged = { ...fileLayer, ...cli };
+  const result = issuesConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid Issue provider configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return issuesConfigSchema.parse({});
+}
+function readPrReviewConfigEnv(env) {
+  const publisher = env.ISSUE_FLOW_PR_REVIEW_PUBLISHER;
+  return publisher === void 0 ? {} : { publisher };
+}
+async function readPrReviewConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const prReview = file?.prReview;
+  if (prReview === void 0) {
+    return {};
+  }
+  const result = prReviewConfigSchema.partial().safeParse(prReview);
+  if (!result.success) {
+    warn(
+      `Ignoring "prReview" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadPrReviewConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const env = options.env ?? process.env;
+  const fileLayer = await readPrReviewConfigFile(options.projectRoot, warn);
+  const envLayer = readPrReviewConfigEnv(env);
+  const merged = { ...fileLayer, ...envLayer, ...options.cli ?? {} };
+  const result = prReviewConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid PR review configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return prReviewConfigSchema.parse({});
+}
+
+export {
+  run,
+  getProjectRoot,
+  getCurrentBranch,
+  getBaseBranch,
+  getCommitsSince,
+  resolveProjectPaths,
+  resolveIssuePaths,
+  DEFAULTS,
+  createConfig,
+  resolvePaths,
+  getInstallHint,
+  validateDependencies,
+  PROJECT_CONFIG_FILENAME,
+  WEB_CONFIG_FILENAME,
+  GLOBAL_CONFIG_FILENAME,
+  loadGlobalConfig,
+  mergeConfigLayers,
+  setWebCliOverrides,
+  loadWebConfig,
+  setIssuesCliOverrides,
+  loadIssuesConfig,
+  loadPrReviewConfig
+};
+//# sourceMappingURL=chunk-G3TJHMAS.js.map