remote-ralph 0.1.0

package/dist/index.js

@@ -0,0 +1,1732 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js
+var require_quote = __commonJS({
+  "node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js"(exports, module) {
+    "use strict";
+    module.exports = function quote(xs) {
+      return xs.map(function(s) {
+        if (s === "") {
+          return "''";
+        }
+        if (s && typeof s === "object") {
+          return s.op.replace(/(.)/g, "\\$1");
+        }
+        if (/["\s\\]/.test(s) && !/'/.test(s)) {
+          return "'" + s.replace(/(['])/g, "\\$1") + "'";
+        }
+        if (/["'\s]/.test(s)) {
+          return '"' + s.replace(/(["\\$`!])/g, "\\$1") + '"';
+        }
+        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+      }).join(" ");
+    };
+  }
+});
+
+// node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js
+var require_parse = __commonJS({
+  "node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js"(exports, module) {
+    "use strict";
+    var CONTROL = "(?:" + [
+      "\\|\\|",
+      "\\&\\&",
+      ";;",
+      "\\|\\&",
+      "\\<\\(",
+      "\\<\\<\\<",
+      ">>",
+      ">\\&",
+      "<\\&",
+      "[&;()|<>]"
+    ].join("|") + ")";
+    var controlRE = new RegExp("^" + CONTROL + "$");
+    var META = "|&;()<> \\t";
+    var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+    var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+    var hash = /^#$/;
+    var SQ = "'";
+    var DQ = '"';
+    var DS = "$";
+    var TOKEN = "";
+    var mult = 4294967296;
+    for (i = 0; i < 4; i++) {
+      TOKEN += (mult * Math.random()).toString(16);
+    }
+    var i;
+    var startsWithToken = new RegExp("^" + TOKEN);
+    function matchAll(s, r) {
+      var origIndex = r.lastIndex;
+      var matches = [];
+      var matchObj;
+      while (matchObj = r.exec(s)) {
+        matches.push(matchObj);
+        if (r.lastIndex === matchObj.index) {
+          r.lastIndex += 1;
+        }
+      }
+      r.lastIndex = origIndex;
+      return matches;
+    }
+    function getVar(env, pre, key) {
+      var r = typeof env === "function" ? env(key) : env[key];
+      if (typeof r === "undefined" && key != "") {
+        r = "";
+      } else if (typeof r === "undefined") {
+        r = "$";
+      }
+      if (typeof r === "object") {
+        return pre + TOKEN + JSON.stringify(r) + TOKEN;
+      }
+      return pre + r;
+    }
+    function parseInternal(string3, env, opts) {
+      if (!opts) {
+        opts = {};
+      }
+      var BS = opts.escape || "\\";
+      var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
+      var chunker = new RegExp([
+        "(" + CONTROL + ")",
+        // control chars
+        "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"
+      ].join("|"), "g");
+      var matches = matchAll(string3, chunker);
+      if (matches.length === 0) {
+        return [];
+      }
+      if (!env) {
+        env = {};
+      }
+      var commented = false;
+      return matches.map(function(match) {
+        var s = match[0];
+        if (!s || commented) {
+          return void 0;
+        }
+        if (controlRE.test(s)) {
+          return { op: s };
+        }
+        var quote = false;
+        var esc2 = false;
+        var out = "";
+        var isGlob = false;
+        var i2;
+        function parseEnvVar() {
+          i2 += 1;
+          var varend;
+          var varname;
+          var char = s.charAt(i2);
+          if (char === "{") {
+            i2 += 1;
+            if (s.charAt(i2) === "}") {
+              throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
+            }
+            varend = s.indexOf("}", i2);
+            if (varend < 0) {
+              throw new Error("Bad substitution: " + s.slice(i2));
+            }
+            varname = s.slice(i2, varend);
+            i2 = varend;
+          } else if (/[*@#?$!_-]/.test(char)) {
+            varname = char;
+            i2 += 1;
+          } else {
+            var slicedFromI = s.slice(i2);
+            varend = slicedFromI.match(/[^\w\d_]/);
+            if (!varend) {
+              varname = slicedFromI;
+              i2 = s.length;
+            } else {
+              varname = slicedFromI.slice(0, varend.index);
+              i2 += varend.index - 1;
+            }
+          }
+          return getVar(env, "", varname);
+        }
+        for (i2 = 0; i2 < s.length; i2++) {
+          var c = s.charAt(i2);
+          isGlob = isGlob || !quote && (c === "*" || c === "?");
+          if (esc2) {
+            out += c;
+            esc2 = false;
+          } else if (quote) {
+            if (c === quote) {
+              quote = false;
+            } else if (quote == SQ) {
+              out += c;
+            } else {
+              if (c === BS) {
+                i2 += 1;
+                c = s.charAt(i2);
+                if (c === DQ || c === BS || c === DS) {
+                  out += c;
+                } else {
+                  out += BS + c;
+                }
+              } else if (c === DS) {
+                out += parseEnvVar();
+              } else {
+                out += c;
+              }
+            }
+          } else if (c === DQ || c === SQ) {
+            quote = c;
+          } else if (controlRE.test(c)) {
+            return { op: s };
+          } else if (hash.test(c)) {
+            commented = true;
+            var commentObj = { comment: string3.slice(match.index + i2 + 1) };
+            if (out.length) {
+              return [out, commentObj];
+            }
+            return [commentObj];
+          } else if (c === BS) {
+            esc2 = true;
+          } else if (c === DS) {
+            out += parseEnvVar();
+          } else {
+            out += c;
+          }
+        }
+        if (isGlob) {
+          return { op: "glob", pattern: out };
+        }
+        return out;
+      }).reduce(function(prev, arg) {
+        return typeof arg === "undefined" ? prev : prev.concat(arg);
+      }, []);
+    }
+    module.exports = function parse3(s, env, opts) {
+      var mapped = parseInternal(s, env, opts);
+      if (typeof env !== "function") {
+        return mapped;
+      }
+      return mapped.reduce(function(acc, s2) {
+        if (typeof s2 === "object") {
+          return acc.concat(s2);
+        }
+        var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+        if (xs.length === 1) {
+          return acc.concat(xs[0]);
+        }
+        return acc.concat(xs.filter(Boolean).map(function(x) {
+          if (startsWithToken.test(x)) {
+            return JSON.parse(x.split(TOKEN)[1]);
+          }
+          return x;
+        }));
+      }, []);
+    };
+  }
+});
+
+// node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/index.js
+var require_shell_quote = __commonJS({
+  "node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/index.js"(exports) {
+    "use strict";
+    exports.quote = require_quote();
+    exports.parse = require_parse();
+  }
+});
+
+// src/index.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { resolve } from "node:path";
+
+// src/logger.ts
+var LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var createLogger = (level) => {
+  const threshold = LEVEL_PRIORITY[level];
+  const noop = () => {
+  };
+  return {
+    error: threshold >= LEVEL_PRIORITY.error ? (...args) => console.error(...args) : noop,
+    warn: threshold >= LEVEL_PRIORITY.warn ? (...args) => console.error(...args) : noop,
+    info: threshold >= LEVEL_PRIORITY.info ? (...args) => console.log(...args) : noop,
+    debug: threshold >= LEVEL_PRIORITY.debug ? (...args) => console.log(...args) : noop
+  };
+};
+var instance;
+var initLogger = (level) => {
+  instance = createLogger(level);
+  return instance;
+};
+var logger = () => {
+  if (!instance) throw new Error("Logger not initialized \u2014 call initLogger() first");
+  return instance;
+};
+
+// src/sleep.ts
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+
+// src/agent.ts
+var import_shell_quote = __toESM(require_shell_quote(), 1);
+import { spawnSync as spawnSync2 } from "node:child_process";
+
+// src/subprocess.ts
+import { spawnSync } from "node:child_process";
+var run = (command, options) => {
+  const result = spawnSync(command, {
+    shell: true,
+    cwd: options?.cwd,
+    timeout: options?.timeout,
+    encoding: "utf-8"
+  });
+  if (result.error && "code" in result.error && result.error.code === "ETIMEDOUT") {
+    return {
+      exitCode: 1,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? ""
+    };
+  }
+  return {
+    exitCode: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+};
+
+// src/github.ts
+var isRecord = (value) => typeof value === "object" && value !== null;
+var resetToMain = () => {
+  const commands = ["git checkout main", "git clean -fd", "git pull"];
+  for (const cmd of commands) {
+    const result = run(cmd);
+    if (result.exitCode !== 0) {
+      throw new Error(`'${cmd}' failed (exit ${result.exitCode}): ${result.stderr}`);
+    }
+  }
+};
+var isPrOpen = (prLink) => {
+  const result = run(`gh pr view "${prLink}" --json state`);
+  if (result.exitCode !== 0) {
+    throw new Error(`gh pr view failed (exit ${result.exitCode}): ${result.stderr}`);
+  }
+  const data = JSON.parse(result.stdout);
+  if (!isRecord(data) || typeof data.state !== "string") {
+    throw new Error(`Unexpected gh pr view response: ${result.stdout}`);
+  }
+  return data.state === "OPEN";
+};
+var parsePrLink = (prLink) => {
+  const match = prLink.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+  if (!match) return null;
+  return { owner: match[1], repo: match[2], number: parseInt(match[3], 10) };
+};
+var hasMergeConflicts = (prLink) => {
+  const result = run(`gh pr view "${prLink}" --json mergeable --jq .mergeable`);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `gh pr view failed (exit ${result.exitCode}): ${result.stderr}`
+    );
+  }
+  return result.stdout.trim() === "CONFLICTING";
+};
+var fetchPrAuthor = (prLink) => {
+  const result = run(`gh pr view "${prLink}" --json author --jq .author.login`);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `gh pr view failed (exit ${result.exitCode}): ${result.stderr}`
+    );
+  }
+  const username = result.stdout.trim();
+  if (!username) {
+    throw new Error("Could not determine PR author");
+  }
+  return username;
+};
+var isReviewThread = (value) => {
+  if (!isRecord(value)) return false;
+  if (typeof value.isResolved !== "boolean") return false;
+  if (typeof value.path !== "string") return false;
+  if (!isRecord(value.comments) || !Array.isArray(value.comments.nodes))
+    return false;
+  const nodes = value.comments.nodes;
+  return nodes.every(
+    (c) => isRecord(c) && typeof c.databaseId === "number" && typeof c.body === "string" && typeof c.url === "string"
+  );
+};
+var isReviewThreadsResponse = (value) => {
+  if (!isRecord(value)) return false;
+  if (!isRecord(value.data)) return false;
+  if (!isRecord(value.data.repository)) return false;
+  if (!isRecord(value.data.repository.pullRequest)) return false;
+  const pr = value.data.repository.pullRequest;
+  if (!isRecord(pr.reviewThreads) || !Array.isArray(pr.reviewThreads.nodes))
+    return false;
+  const nodes = pr.reviewThreads.nodes;
+  return nodes.every(isReviewThread);
+};
+var fetchActionableThreads = ({
+  prLink,
+  agentUsername,
+  allowlist,
+  requireMention
+}) => {
+  const parsed = parsePrLink(prLink);
+  if (!parsed) {
+    throw new Error(`Invalid PR link: ${prLink}`);
+  }
+  const query = `query { repository(owner: "${parsed.owner}", name: "${parsed.repo}") { pullRequest(number: ${parsed.number}) { reviewThreads(first: 100) { nodes { isResolved path line comments(first: 100) { nodes { databaseId body url author { login } } } } } } } }`;
+  const result = run(`gh api graphql -f query='${query}'`);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `gh api graphql failed (exit ${result.exitCode}): ${result.stderr}`
+    );
+  }
+  const data = JSON.parse(result.stdout);
+  if (!isReviewThreadsResponse(data)) {
+    throw new Error(`Unexpected GraphQL response: ${result.stdout}`);
+  }
+  const threads = data.data.repository.pullRequest.reviewThreads.nodes;
+  const isUnresolved = (thread) => !thread.isResolved;
+  const stripNonAllowlisted = (thread) => {
+    if (allowlist.length === 0) return thread;
+    const filtered = thread.comments.nodes.filter((c) => {
+      const login = c.author?.login;
+      if (!login) return false;
+      if (login === agentUsername) return true;
+      return allowlist.includes(login);
+    });
+    return { ...thread, comments: { nodes: filtered } };
+  };
+  const hasReviewerAsLastCommenter = (thread) => {
+    const comments = thread.comments.nodes;
+    if (comments.length === 0) return false;
+    return comments[comments.length - 1].author?.login !== agentUsername;
+  };
+  const latestCommentMentionsBot = (thread) => {
+    if (!requireMention) return true;
+    const comments = thread.comments.nodes;
+    if (comments.length === 0) return false;
+    return comments[comments.length - 1].body.includes(`@${agentUsername}`);
+  };
+  const toActionableThread = (thread) => ({
+    path: thread.path,
+    line: thread.line ?? void 0,
+    comments: thread.comments.nodes.map((c) => ({
+      id: c.databaseId,
+      body: c.body,
+      url: c.url,
+      author: c.author?.login ?? "unknown"
+    }))
+  });
+  logger().debug("GitHub PR data response:\n" + JSON.stringify(threads, null, "	"));
+  logger().debug("Agent git username (derived from PR author): " + agentUsername);
+  return threads.filter(isUnresolved).map(stripNonAllowlisted).filter(hasReviewerAsLastCommenter).filter(latestCommentMentionsBot).map(toActionableThread);
+};
+
+// src/agent.ts
+var PROMPT_PLACEHOLDER = "{prompt}";
+var runAgent = (commandTemplate, prompt) => {
+  const tokens = (0, import_shell_quote.parse)(commandTemplate).filter((t) => typeof t === "string");
+  const quoted = `"${prompt.replace(/"/g, '\\"')}"`;
+  const args = tokens.map((t) => t.replace(PROMPT_PLACEHOLDER, quoted));
+  const result = spawnSync2(args[0], args.slice(1), { encoding: "utf-8" });
+  return {
+    exitCode: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+};
+var PR_URL_PATTERN = /https:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
+var extractPrLink = (stdout) => {
+  const matches = stdout.match(PR_URL_PATTERN);
+  return matches ? matches[matches.length - 1] : null;
+};
+var buildImplementPrompt = (requirementsPath, pretext = "") => {
+  const pretextBlock = pretext ? `${pretext}
+
+` : "";
+  return `${pretextBlock}Read the requirements JSON file at \`@${requirementsPath}\`.
+Find the first item where \`passes\` is \`false\`.
+Implement that item fully.
+Before creating the PR, update that item so \`passes\` becomes \`true\` in the requirements file on this branch.
+Create a GitHub PR with an extensive summary of what you tried and did in the PR description.
+When finished, return the URL for the PR. Don't return a preamble or anything else - only return the URL for the PR.`;
+};
+var formatThread = (thread, index) => {
+  const lastComment = thread.comments[thread.comments.length - 1];
+  const replyInfo = lastComment ? ` (reply to comment ID: ${lastComment.id})` : "";
+  const header = thread.line != null ? `### Thread ${index + 1}: \`${thread.path}\` (line ${thread.line})${replyInfo}` : `### Thread ${index + 1}: \`${thread.path}\`${replyInfo}`;
+  const comments = thread.comments.map((c, idx) => `${idx}. **${c.author}:** ${c.body}`).join("\n\n");
+  return `${header}
+
+${comments}`;
+};
+var buildReactionPrompt = (prLink, threads, pretext = "") => {
+  const parsed = parsePrLink(prLink);
+  const threadSections = threads.map(formatThread).join("\n\n---\n\n");
+  const repoSlug = parsed ? `${parsed.owner}/${parsed.repo}` : "{owner}/{repo}";
+  const prNumber = parsed ? parsed.number : "{pull_number}";
+  const pretextBlock = pretext ? `${pretext}
+
+` : "";
+  return `${pretextBlock}You have review comments to address on PR ${prLink}.
+
+## Actionable review threads
+
+${threadSections}
+
+---
+
+For each thread above:
+1. Determine whether the reviewer is **asking a question** or **requesting a code change**.
+2. If it's a question or request for information: reply with an explanation only \u2014 do NOT change any code.
+3. If it's an actionable request: make the necessary code changes, commit them, and push your updates to the PR branch.
+4. In both cases, reply **directly in each review thread** using the comment ID shown in the thread header. Run this exact command for each thread:
+   \`\`\`
+   gh api repos/${repoSlug}/pulls/${prNumber}/comments/{comment_id}/replies -f body="your reply"
+   \`\`\`
+   Replace \`{comment_id}\` with the ID from the thread header. Do NOT leave a general PR comment \u2014 you MUST reply to each thread individually using the command above.
+
+When you are done with all threads, return "DONE".`;
+};
+var MERGE_CONFLICT_PRETEXT = "IMPORTANT: The PR branch has merge conflicts with the base branch. Before addressing any review comments, resolve all merge conflicts first. Pull the latest main branch, merge it into the PR branch, resolve conflicts, and push.";
+var buildConflictResolutionPrompt = (prLink, pretext = "") => {
+  const pretextBlock = pretext ? `${pretext}
+
+` : "";
+  return `${pretextBlock}The PR branch for ${prLink} has merge conflicts with the base branch. Please resolve them:
+
+1. Pull the latest main branch and merge it into the PR branch.
+2. Resolve all merge conflicts.
+3. Commit the merge resolution and push to the PR branch.
+
+When you are done, return "DONE".`;
+};
+var executeConflictResolution = (commandTemplate, prLink, pretext = "") => {
+  const prompt = buildConflictResolutionPrompt(prLink, pretext);
+  logger().debug("Conflict resolution agent prompt:\n" + prompt);
+  return runAgent(commandTemplate, prompt);
+};
+var executeCommentReaction = (commandTemplate, prLink, threads, pretext = "") => {
+  const prompt = buildReactionPrompt(prLink, threads, pretext);
+  logger().debug("Reaction agent prompt:\n" + prompt);
+  return runAgent(commandTemplate, prompt);
+};
+
+// src/state.ts
+import { readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+var readCurrentPrLink = (statePath) => {
+  if (!existsSync(statePath)) {
+    return null;
+  }
+  const content = readFileSync(statePath, "utf-8").trim();
+  if (!content) {
+    return null;
+  }
+  const state = JSON.parse(content);
+  return state.currentPrLink ?? null;
+};
+var writeStateFile = (statePath, state) => {
+  const dir = dirname(statePath);
+  mkdirSync(dir, { recursive: true });
+  const tempPath = join(dir, `.state-${randomUUID()}.tmp`);
+  writeFileSync(tempPath, JSON.stringify(state), "utf-8");
+  renameSync(tempPath, statePath);
+};
+var writeCurrentPrLink = (statePath, prLink) => writeStateFile(statePath, { currentPrLink: prLink });
+var clearCurrentPrLink = (statePath) => writeStateFile(statePath, { currentPrLink: null });
+
+// src/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.js
+var NEVER = Object.freeze({
+  status: "aborted"
+});
+// @__NO_SIDE_EFFECTS__
+function $constructor(name, initializer2, params) {
+  function init(inst, def) {
+    if (!inst._zod) {
+      Object.defineProperty(inst, "_zod", {
+        value: {
+          def,
+          constr: _,
+          traits: /* @__PURE__ */ new Set()
+        },
+        enumerable: false
+      });
+    }
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
+    inst._zod.traits.add(name);
+    initializer2(inst, def);
+    const proto = _.prototype;
+    const keys = Object.keys(proto);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      if (!(k in inst)) {
+        inst[k] = proto[k].bind(inst);
+      }
+    }
+  }
+  const Parent = params?.Parent ?? Object;
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _(def) {
+    var _a2;
+    const inst = params?.Parent ? new Definition() : this;
+    init(inst, def);
+    (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name });
+  return _;
+}
+var $ZodAsyncError = class extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+};
+var globalConfig = {};
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/util.js
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  return values;
+}
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
+function defineLazy(object2, key, getter) {
+  let value = void 0;
+  Object.defineProperty(object2, key, {
+    get() {
+      if (value === EVALUATING) {
+        return void 0;
+      }
+      if (value === void 0) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object2, key, {
+        value: v
+        // configurable: true,
+      });
+    },
+    configurable: true
+  });
+}
+var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
+};
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+var allowsEval = cached(() => {
+  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+    return false;
+  }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent)
+    cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
+    return {};
+  if (typeof params === "string")
+    return { error: () => params };
+  if (params?.message !== void 0) {
+    if (params?.error !== void 0)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string")
+    return { ...params, error: () => params.error };
+  return params;
+}
+function optionalKeys(shape) {
+  return Object.keys(shape).filter((k) => {
+    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+  });
+}
+var NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-34028234663852886e22, 34028234663852886e22],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function aborted(x, startIndex = 0) {
+  if (x.aborted === true)
+    return true;
+  for (let i = startIndex; i < x.issues.length; i++) {
+    if (x.issues[i]?.continue !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a2;
+    (_a2 = iss).path ?? (_a2.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config2) {
+  const full = { ...iss, path: iss.path ?? [] };
+  if (!iss.message) {
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) {
+    delete full.input;
+  }
+  return full;
+}
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/errors.js
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+};
+var $ZodError = $constructor("$ZodError", initializer);
+var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/parse.js
+var _parse = (_Err) => (schema, value, _ctx, _params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  if (result.issues.length) {
+    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, _params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+var parse2 = /* @__PURE__ */ _parse($ZodRealError);
+var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
+var _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError();
+  }
+  return result.issues.length ? {
+    success: false,
+    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
+    success: false,
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/regexes.js
+var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+var string = (params) => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+var number = /^-?\d+(?:\.\d+)?$/;
+var boolean = /^(?:true|false)$/i;
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
+var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+  var _a2;
+  inst._zod ?? (inst._zod = {});
+  inst._zod.def = def;
+  (_a2 = inst._zod).onattach ?? (_a2.onattach = []);
+});
+var numericOriginMap = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+};
+var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst2) => {
+    const bag = inst2._zod.bag;
+    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    if (def.value > curr) {
+      if (def.inclusive)
+        bag.minimum = def.value;
+      else
+        bag.exclusiveMinimum = def.value;
+    }
+  });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
+var version = {
+  major: 4,
+  minor: 3,
+  patch: 6
+};
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/schemas.js
+var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+  var _a2;
+  inst ?? (inst = {});
+  inst._zod.def = def;
+  inst._zod.bag = inst._zod.bag || {};
+  inst._zod.version = version;
+  const checks = [...inst._zod.def.checks ?? []];
+  if (inst._zod.traits.has("$ZodCheck")) {
+    checks.unshift(inst);
+  }
+  for (const ch of checks) {
+    for (const fn of ch._zod.onattach) {
+      fn(inst);
+    }
+  }
+  if (checks.length === 0) {
+    (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
+    inst._zod.deferred?.push(() => {
+      inst._zod.run = inst._zod.parse;
+    });
+  } else {
+    const runChecks = (payload, checks2, ctx) => {
+      let isAborted = aborted(payload);
+      let asyncResult;
+      for (const ch of checks2) {
+        if (ch._zod.def.when) {
+          const shouldRun = ch._zod.def.when(payload);
+          if (!shouldRun)
+            continue;
+        } else if (isAborted) {
+          continue;
+        }
+        const currLen = payload.issues.length;
+        const _ = ch._zod.check(payload);
+        if (_ instanceof Promise && ctx?.async === false) {
+          throw new $ZodAsyncError();
+        }
+        if (asyncResult || _ instanceof Promise) {
+          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+            await _;
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              return;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          });
+        } else {
+          const nextLen = payload.issues.length;
+          if (nextLen === currLen)
+            continue;
+          if (!isAborted)
+            isAborted = aborted(payload, currLen);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.then(() => {
+          return payload;
+        });
+      }
+      return payload;
+    };
+    const handleCanaryResult = (canary, payload, ctx) => {
+      if (aborted(canary)) {
+        canary.aborted = true;
+        return canary;
+      }
+      const checkResult = runChecks(payload, checks, ctx);
+      if (checkResult instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
+      }
+      return inst._zod.parse(checkResult, ctx);
+    };
+    inst._zod.run = (payload, ctx) => {
+      if (ctx.skipChecks) {
+        return inst._zod.parse(payload, ctx);
+      }
+      if (ctx.direction === "backward") {
+        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+        if (canary instanceof Promise) {
+          return canary.then((canary2) => {
+            return handleCanaryResult(canary2, payload, ctx);
+          });
+        }
+        return handleCanaryResult(canary, payload, ctx);
+      }
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError();
+        return result.then((result2) => runChecks(result2, checks, ctx));
+      }
+      return runChecks(result, checks, ctx);
+    };
+  }
+  defineLazy(inst, "~standard", () => ({
+    validate: (value) => {
+      try {
+        const r = safeParse(inst, value);
+        return r.success ? { value: r.data } : { issues: r.error?.issues };
+      } catch (_) {
+        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  }));
+});
+var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
+  inst._zod.parse = (payload, _) => {
+    if (def.coerce)
+      try {
+        payload.value = String(payload.value);
+      } catch (_2) {
+      }
+    if (typeof payload.value === "string")
+      return payload;
+    payload.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = inst._zod.bag.pattern ?? number;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Number(payload.value);
+      } catch (_) {
+      }
+    const input = payload.value;
+    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
+      return payload;
+    }
+    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+    payload.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input,
+      inst,
+      ...received ? { received } : {}
+    });
+    return payload;
+  };
+});
+var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = boolean;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Boolean(payload.value);
+      } catch (_) {
+      }
+    const input = payload.value;
+    if (typeof input === "boolean")
+      return payload;
+    payload.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = Array(input.length);
+    const proms = [];
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const result = def.element._zod.run({
+        value: item,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+      } else {
+        handleArrayResult(result, payload, i);
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
+  if (result.issues.length) {
+    if (isOptionalOut && !(key in input)) {
+      return;
+    }
+    final.issues.push(...prefixIssues(key, result.issues));
+  }
+  if (result.value === void 0) {
+    if (key in input) {
+      final.value[key] = void 0;
+    }
+  } else {
+    final.value[key] = result.value;
+  }
+}
+function normalizeDef(def) {
+  const keys = Object.keys(def.shape);
+  for (const k of keys) {
+    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
+      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+    }
+  }
+  const okeys = optionalKeys(def.shape);
+  return {
+    ...def,
+    keys,
+    keySet: new Set(keys),
+    numKeys: keys.length,
+    optionalKeys: new Set(okeys)
+  };
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+  const unrecognized = [];
+  const keySet = def.keySet;
+  const _catchall = def.catchall._zod;
+  const t = _catchall.def.type;
+  const isOptionalOut = _catchall.optout === "optional";
+  for (const key in input) {
+    if (keySet.has(key))
+      continue;
+    if (t === "never") {
+      unrecognized.push(key);
+      continue;
+    }
+    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+    if (r instanceof Promise) {
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+    } else {
+      handlePropertyResult(r, payload, key, input, isOptionalOut);
+    }
+  }
+  if (unrecognized.length) {
+    payload.issues.push({
+      code: "unrecognized_keys",
+      keys: unrecognized,
+      input,
+      inst
+    });
+  }
+  if (!proms.length)
+    return payload;
+  return Promise.all(proms).then(() => {
+    return payload;
+  });
+}
+var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+  $ZodType.init(inst, def);
+  const desc = Object.getOwnPropertyDescriptor(def, "shape");
+  if (!desc?.get) {
+    const sh = def.shape;
+    Object.defineProperty(def, "shape", {
+      get: () => {
+        const newSh = { ...sh };
+        Object.defineProperty(def, "shape", {
+          value: newSh
+        });
+        return newSh;
+      }
+    });
+  }
+  const _normalized = cached(() => normalizeDef(def));
+  defineLazy(inst._zod, "propValues", () => {
+    const shape = def.shape;
+    const propValues = {};
+    for (const key in shape) {
+      const field = shape[key]._zod;
+      if (field.values) {
+        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+        for (const v of field.values)
+          propValues[key].add(v);
+      }
+    }
+    return propValues;
+  });
+  const isObject2 = isObject;
+  const catchall = def.catchall;
+  let value;
+  inst._zod.parse = (payload, ctx) => {
+    value ?? (value = _normalized.value);
+    const input = payload.value;
+    if (!isObject2(input)) {
+      payload.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = {};
+    const proms = [];
+    const shape = value.shape;
+    for (const key of value.keys) {
+      const el = shape[key];
+      const isOptionalOut = el._zod.optout === "optional";
+      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
+      } else {
+        handlePropertyResult(r, payload, key, input, isOptionalOut);
+      }
+    }
+    if (!catchall) {
+      return proms.length ? Promise.all(proms).then(() => payload) : payload;
+    }
+    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+  };
+});
+var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+  $ZodType.init(inst, def);
+  const values = getEnumValues(def.entries);
+  const valuesSet = new Set(values);
+  inst._zod.values = valuesSet;
+  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (valuesSet.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === void 0) {
+    return { issues: [], value: void 0 };
+  }
+  return result;
+}
+var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  inst._zod.optout = "optional";
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (def.innerType._zod.optin === "optional") {
+      const result = def.innerType._zod.run(payload, ctx);
+      if (result instanceof Promise)
+        return result.then((r) => handleOptionalResult(r, payload.value));
+      return handleOptionalResult(result, payload.value);
+    }
+    if (payload.value === void 0) {
+      return payload;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/registries.js
+var _a;
+var $ZodRegistry = class {
+  constructor() {
+    this._map = /* @__PURE__ */ new WeakMap();
+    this._idmap = /* @__PURE__ */ new Map();
+  }
+  add(schema, ..._meta) {
+    const meta2 = _meta[0];
+    this._map.set(schema, meta2);
+    if (meta2 && typeof meta2 === "object" && "id" in meta2) {
+      this._idmap.set(meta2.id, schema);
+    }
+    return this;
+  }
+  clear() {
+    this._map = /* @__PURE__ */ new WeakMap();
+    this._idmap = /* @__PURE__ */ new Map();
+    return this;
+  }
+  remove(schema) {
+    const meta2 = this._map.get(schema);
+    if (meta2 && typeof meta2 === "object" && "id" in meta2) {
+      this._idmap.delete(meta2.id);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+  get(schema) {
+    const p = schema._zod.parent;
+    if (p) {
+      const pm = { ...this.get(p) ?? {} };
+      delete pm.id;
+      const f = { ...pm, ...this._map.get(schema) };
+      return Object.keys(f).length ? f : void 0;
+    }
+    return this._map.get(schema);
+  }
+  has(schema) {
+    return this._map.has(schema);
+  }
+};
+function registry() {
+  return new $ZodRegistry();
+}
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+var globalRegistry = globalThis.__zod_globalRegistry;
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
+// @__NO_SIDE_EFFECTS__
+function _string(Class, params) {
+  return new Class({
+    type: "string",
+    ...normalizeParams(params)
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function _number(Class, params) {
+  return new Class({
+    type: "number",
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function _boolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    ...normalizeParams(params)
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function _gt(value, params) {
+  return new $ZodCheckGreaterThan({
+    check: "greater_than",
+    ...normalizeParams(params),
+    value,
+    inclusive: false
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function _positive(params) {
+  return /* @__PURE__ */ _gt(0, params);
+}
+
+// node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/mini/schemas.js
+var ZodMiniType = /* @__PURE__ */ $constructor("ZodMiniType", (inst, def) => {
+  if (!inst._zod)
+    throw new Error("Uninitialized schema in ZodMiniType.");
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.type = def.type;
+  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
+  inst.safeParse = (data, params) => safeParse(inst, data, params);
+  inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
+  inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
+  inst.check = (...checks) => {
+    return inst.clone({
+      ...def,
+      checks: [
+        ...def.checks ?? [],
+        ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+      ]
+    }, { parent: true });
+  };
+  inst.with = inst.check;
+  inst.clone = (_def, params) => clone(inst, _def, params);
+  inst.brand = () => inst;
+  inst.register = ((reg, meta2) => {
+    reg.add(inst, meta2);
+    return inst;
+  });
+  inst.apply = (fn) => fn(inst);
+});
+var ZodMiniString = /* @__PURE__ */ $constructor("ZodMiniString", (inst, def) => {
+  $ZodString.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function string2(params) {
+  return _string(ZodMiniString, params);
+}
+var ZodMiniNumber = /* @__PURE__ */ $constructor("ZodMiniNumber", (inst, def) => {
+  $ZodNumber.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function number2(params) {
+  return _number(ZodMiniNumber, params);
+}
+var ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+  $ZodBoolean.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function boolean2(params) {
+  return _boolean(ZodMiniBoolean, params);
+}
+var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function array(element, params) {
+  return new ZodMiniArray({
+    type: "array",
+    element,
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniObject = /* @__PURE__ */ $constructor("ZodMiniObject", (inst, def) => {
+  $ZodObject.init(inst, def);
+  ZodMiniType.init(inst, def);
+  defineLazy(inst, "shape", () => def.shape);
+});
+// @__NO_SIDE_EFFECTS__
+function object(shape, params) {
+  const def = {
+    type: "object",
+    shape: shape ?? {},
+    ...normalizeParams(params)
+  };
+  return new ZodMiniObject(def);
+}
+var ZodMiniEnum = /* @__PURE__ */ $constructor("ZodMiniEnum", (inst, def) => {
+  $ZodEnum.init(inst, def);
+  ZodMiniType.init(inst, def);
+  inst.options = Object.values(def.entries);
+});
+// @__NO_SIDE_EFFECTS__
+function _enum(values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  return new ZodMiniEnum({
+    type: "enum",
+    entries,
+    ...normalizeParams(params)
+  });
+}
+var ZodMiniOptional = /* @__PURE__ */ $constructor("ZodMiniOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function optional(innerType) {
+  return new ZodMiniOptional({
+    type: "optional",
+    innerType
+  });
+}
+
+// src/config.ts
+var MERGE_CONFLICT_RESOLUTION_VALUES = ["never", "withThreads", "always"];
+var configSchema = object({
+  statePath: optional(string2()),
+  logLevel: optional(_enum(["error", "warn", "info", "debug"])),
+  pollIntervalMinutes: optional(number2().check(_positive())),
+  pretext: optional(string2()),
+  allowlist: optional(array(string2())),
+  requireMention: optional(boolean2()),
+  mergeConflictResolution: optional(_enum(MERGE_CONFLICT_RESOLUTION_VALUES))
+});
+var DEFAULT_CONFIG_PATH = "./.remote-ralph/config.json";
+var DEFAULT_CONFIG = {
+  statePath: "./.remote-ralph/state.json",
+  logLevel: "info",
+  pollIntervalMinutes: 5,
+  pretext: "",
+  allowlist: [],
+  requireMention: false,
+  mergeConflictResolution: "withThreads"
+};
+var resolveConfig = (configPath) => {
+  if (!existsSync2(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(configPath, "utf-8"));
+  } catch {
+    console.error(`Error: config file at '${configPath}' is not valid JSON`);
+    process.exit(1);
+  }
+  if (typeof raw === "object" && raw !== null) {
+    const knownKeys = new Set(Object.keys(configSchema.shape));
+    for (const key of Object.keys(raw)) {
+      if (!knownKeys.has(key)) {
+        console.warn(`Warning: unrecognized config key '${key}' in '${configPath}'`);
+      }
+    }
+  }
+  const result = configSchema.safeParse(raw);
+  if (!result.success) {
+    console.error(`Error: invalid config file at '${configPath}': ${result.error.message}`);
+    process.exit(1);
+  }
+  return {
+    statePath: result.data.statePath ?? DEFAULT_CONFIG.statePath,
+    logLevel: result.data.logLevel ?? DEFAULT_CONFIG.logLevel,
+    pollIntervalMinutes: result.data.pollIntervalMinutes ?? DEFAULT_CONFIG.pollIntervalMinutes,
+    pretext: result.data.pretext ?? DEFAULT_CONFIG.pretext,
+    allowlist: result.data.allowlist ?? DEFAULT_CONFIG.allowlist,
+    requireMention: result.data.requireMention ?? DEFAULT_CONFIG.requireMention,
+    mergeConflictResolution: result.data.mergeConflictResolution ?? DEFAULT_CONFIG.mergeConflictResolution
+  };
+};
+
+// src/index.ts
+var LOG_LEVELS = ["error", "warn", "info", "debug"];
+var MAX_CONSECUTIVE_POLL_FAILURES = 3;
+var getArg = (args, paramName) => {
+  const index = args.indexOf(paramName);
+  if (index === -1 || index === args.length - 1) {
+    return void 0;
+  }
+  return args[index + 1];
+};
+var logHelpMessage = () => {
+  console.log(`
+remote-ralph - 24/7 autonomous implementation loop
+
+Usage:
+  remote-ralph --requirements-path <path> --command <template> [options]
+
+Required:
+  --requirements-path <path>   Path to requirements JSON file
+  --command <template>         Command template with ${PROMPT_PLACEHOLDER} placeholder
+
+Optional:
+  --config-path <path>   Path to config file (default: ./.remote-ralph/config.json)
+  --state-path <path>    Path to state file (default: ./.remote-ralph/state.json)
+  --log-level <level>    Log level: error, warn, info, debug (default: info)
+  -h, --help             Show this help message
+  `);
+};
+var parseArgs = (argv) => {
+  const args = argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    logHelpMessage();
+    process.exit(0);
+  }
+  const requirementsPath = getArg(args, "--requirements-path");
+  if (!requirementsPath) {
+    console.error("Error: --requirements-path is required");
+    process.exit(1);
+  }
+  const command = getArg(args, "--command");
+  if (!command) {
+    console.error("Error: --command is required");
+    process.exit(1);
+  }
+  if (command && !command.includes(PROMPT_PLACEHOLDER)) {
+    console.error(`Error: --command must contain ${PROMPT_PLACEHOLDER} placeholder`);
+    process.exit(1);
+  }
+  const configPath = getArg(args, "--config-path") ?? DEFAULT_CONFIG_PATH;
+  const config2 = resolveConfig(configPath);
+  const statePathArg = getArg(args, "--state-path");
+  const statePath = statePathArg ?? config2.statePath;
+  const logLevelRaw = getArg(args, "--log-level");
+  const logLevelArg = logLevelRaw?.toLowerCase();
+  const isLogLevel = (value) => LOG_LEVELS.some((l) => l === value);
+  const configLogLevel = config2.logLevel;
+  let logLevel = configLogLevel;
+  if (logLevelArg !== void 0) {
+    if (!isLogLevel(logLevelArg)) {
+      console.error(`Error: invalid --log-level '${logLevelArg}'. Must be one of: ${LOG_LEVELS.join(", ")}`);
+      process.exit(1);
+    }
+    logLevel = logLevelArg;
+  }
+  const pollIntervalMs = config2.pollIntervalMinutes * 60 * 1e3;
+  return { requirementsPath, statePath, logLevel, command, pollIntervalMs, config: config2 };
+};
+var validateGitRepo = (cwd = process.cwd()) => {
+  if (!existsSync3(resolve(cwd, ".git"))) {
+    console.error("Error: not a git repository (no .git in current directory)");
+    process.exit(1);
+  }
+};
+var validateRequirementsPath = (requirementsPath) => {
+  if (!existsSync3(requirementsPath)) {
+    console.error(`Error: requirements file not found at '${requirementsPath}'`);
+    process.exit(1);
+  }
+};
+var createPr = (config2) => {
+  logger().info("No current PR found, starting implementation...");
+  const prompt = buildImplementPrompt(config2.requirementsPath, config2.config.pretext);
+  const result = runAgent(config2.command, prompt);
+  logger().debug("Agent response: " + JSON.stringify(result, null, "	"));
+  const prLink = extractPrLink(result.stdout);
+  if (prLink) {
+    writeCurrentPrLink(config2.statePath, prLink);
+    logger().info("PR created:", prLink);
+    return prLink;
+  }
+  logger().error("Failed to extract PR link from agent output");
+  return null;
+};
+var reactToThreads = ({ threads, prLink, command, pretext }) => {
+  if (!threads.length) {
+    logger().debug("No actionable threads found");
+    return;
+  }
+  logger().info(`Found ${threads.length} actionable thread(s), invoking agent...`);
+  const result = executeCommentReaction(command, prLink, threads, pretext);
+  logger().debug("Agent response:\n" + JSON.stringify(result, null, "	"));
+  logger().info("Finished reacting to threads");
+};
+var main = async () => {
+  const config2 = parseArgs(process.argv);
+  validateGitRepo();
+  validateRequirementsPath(config2.requirementsPath);
+  initLogger(config2.logLevel);
+  logger().info("requirements-path:", config2.requirementsPath);
+  logger().info("state-path:", config2.statePath);
+  logger().info("log-level:", config2.logLevel);
+  logger().info("command:", config2.command);
+  logger().info("poll-interval-minutes:", config2.pollIntervalMs / 6e4);
+  while (true) {
+    const existingPrLink = readCurrentPrLink(config2.statePath);
+    if (!existingPrLink) {
+      resetToMain();
+    }
+    const prLink = existingPrLink ?? createPr(config2);
+    if (!prLink) {
+      logger().info("No PR link available, all items may be done");
+      return;
+    }
+    const agentUsername = fetchPrAuthor(prLink);
+    let consecutiveFailures = 0;
+    while (true) {
+      try {
+        if (!isPrOpen(prLink)) break;
+        const mergeConflictMode = config2.config.mergeConflictResolution;
+        let hasConflicts = false;
+        try {
+          hasConflicts = hasMergeConflicts(prLink);
+        } catch (e) {
+          logger().warn(`Failed to check merge conflicts: ${e instanceof Error ? e.message : e}`);
+        }
+        const threads = fetchActionableThreads({
+          prLink,
+          agentUsername,
+          allowlist: config2.config.allowlist ?? DEFAULT_CONFIG.allowlist,
+          requireMention: config2.config.requireMention ?? DEFAULT_CONFIG.requireMention
+        });
+        if (hasConflicts && mergeConflictMode === "always" && threads.length === 0) {
+          logger().info("Merge conflicts detected, invoking agent for conflict resolution...");
+          try {
+            const result = executeConflictResolution(config2.command, prLink, config2.config.pretext);
+            logger().debug("Conflict resolution agent response:\n" + JSON.stringify(result, null, "	"));
+            logger().info("Finished conflict resolution attempt");
+          } catch (e) {
+            logger().warn(`Conflict resolution failed: ${e instanceof Error ? e.message : e}`);
+          }
+        }
+        const reactionPretext = hasConflicts && mergeConflictMode !== "never" && threads.length > 0 ? config2.config.pretext ? `${config2.config.pretext}
+
+${MERGE_CONFLICT_PRETEXT}` : MERGE_CONFLICT_PRETEXT : config2.config.pretext;
+        reactToThreads({
+          threads,
+          prLink,
+          command: config2.command,
+          pretext: reactionPretext
+        });
+        consecutiveFailures = 0;
+      } catch (error) {
+        consecutiveFailures++;
+        logger().warn(`Failed to fetch PR data (${consecutiveFailures}/${MAX_CONSECUTIVE_POLL_FAILURES}): ${error instanceof Error ? error.message : error}`);
+        if (consecutiveFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
+          logger().error(`Exiting: ${MAX_CONSECUTIVE_POLL_FAILURES} consecutive poll failures`);
+          return;
+        }
+      }
+      await sleep(config2.pollIntervalMs);
+    }
+    logger().info("PR is no longer open (merged or closed)");
+    clearCurrentPrLink(config2.statePath);
+  }
+};
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+export {
+  MAX_CONSECUTIVE_POLL_FAILURES,
+  main,
+  parseArgs,
+  validateGitRepo,
+  validateRequirementsPath
+};