@pepps233/mendr 0.1.0

package/dist/chunk-EGSZLVR6.js

@@ -0,0 +1,1051 @@
+// src/exec.ts
+import { createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+import { execa } from "execa";
+var CommandFailedError = class extends Error {
+  constructor(command, args, result) {
+    super(formatCommandFailure(command, args, result));
+    this.command = command;
+    this.args = args;
+    this.result = result;
+    this.name = "CommandFailedError";
+  }
+  command;
+  args;
+  result;
+};
+var defaultExec = async (command, args, options = {}) => {
+  const logStreams = await createLogStreams(options);
+  const subprocess = execa(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    input: options.input,
+    stdin: options.input === void 0 ? "ignore" : "pipe",
+    timeout: options.timeoutMs,
+    reject: false
+  });
+  teeStream(subprocess.stdout, logStreams.stdout);
+  teeStream(subprocess.stderr, logStreams.stderr);
+  try {
+    const result = await subprocess;
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode ?? (result.timedOut ? 124 : 0),
+      timedOut: result.timedOut
+    };
+  } finally {
+    await closeLogStreams(logStreams);
+  }
+};
+async function execOk(exec, command, args, options) {
+  const result = await exec(command, args, options);
+  if (result.exitCode !== 0) {
+    throw new CommandFailedError(command, args, result);
+  }
+  return result;
+}
+function formatCommandFailure(command, args, result) {
+  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.exitCode}`;
+  const formattedCommand = [command, ...args.map(formatCommandArg)].join(" ");
+  if (result.timedOut) {
+    return `${formattedCommand} timed out: ${detail}`;
+  }
+  return `${formattedCommand} failed: ${detail}`;
+}
+function formatCommandArg(arg) {
+  const normalized = arg.replace(/\s+/g, " ");
+  return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
+}
+async function createLogStreams(options) {
+  await Promise.all(
+    [options.stdoutFile, options.stderrFile].filter((path) => path !== void 0).map((path) => mkdir(dirname(path), { recursive: true }))
+  );
+  return {
+    stdout: options.stdoutFile ? createWriteStream(options.stdoutFile, { flags: "w" }) : void 0,
+    stderr: options.stderrFile ? createWriteStream(options.stderrFile, { flags: "w" }) : void 0
+  };
+}
+function teeStream(source, destination) {
+  if (!source || !destination) {
+    return;
+  }
+  source.on("data", (chunk) => {
+    destination.write(chunk);
+  });
+}
+async function closeLogStreams(streams) {
+  await Promise.all([closeLogStream(streams.stdout), closeLogStream(streams.stderr)]);
+}
+async function closeLogStream(stream) {
+  if (!stream) {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    stream.once("error", reject);
+    stream.end(() => {
+      stream.off("error", reject);
+      resolve();
+    });
+  });
+}
+
+// src/agents/driver.ts
+import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/agents/types.ts
+var AgentParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentParseError";
+  }
+};
+function extractJsonValue(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    throw new AgentParseError("Agent output was empty.");
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  for (const match of trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+    const candidate2 = match[1]?.trim();
+    if (!candidate2) {
+      continue;
+    }
+    try {
+      return JSON.parse(candidate2);
+    } catch {
+    }
+  }
+  const candidate = findFirstJsonCandidate(trimmed);
+  if (candidate) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      throw new AgentParseError("Agent output contained malformed JSON.");
+    }
+  }
+  throw new AgentParseError("Agent output did not contain JSON.");
+}
+function parseIssueArrayFromText(text) {
+  const value = extractJsonValue(text);
+  if (!Array.isArray(value)) {
+    throw new AgentParseError("Agent JSON payload must be an issue array.");
+  }
+  return value.map(parseIssue);
+}
+function parseFixIssueResultArrayFromText(text) {
+  const value = extractJsonValue(text);
+  if (!Array.isArray(value)) {
+    throw new AgentParseError("Agent JSON payload must be a fix result array.");
+  }
+  return value.map(parseFixIssueResult);
+}
+function issueFingerprint(issue) {
+  return [
+    normalizeFingerprintPart(issue.title),
+    normalizeFingerprintPart(issue.file),
+    String(issue.line),
+    normalizeFingerprintPart(issue.description)
+  ].join("|");
+}
+function dedupeIssues(issues) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const issue of issues) {
+    const fingerprint = issueFingerprint(issue);
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    deduped.push(issue);
+  }
+  return deduped;
+}
+function parseIssue(value) {
+  if (!isRecord(value)) {
+    throw new AgentParseError("Agent issue must be an object.");
+  }
+  const { title, file, line, severity, description } = value;
+  if (typeof title !== "string" || typeof file !== "string" || typeof line !== "number" || !Number.isInteger(line) || typeof severity !== "string" || typeof description !== "string") {
+    throw new AgentParseError("Agent issue has an invalid schema.");
+  }
+  return {
+    title,
+    file,
+    line,
+    severity,
+    description
+  };
+}
+function parseFixIssueResult(value) {
+  if (!isRecord(value)) {
+    throw new AgentParseError("Agent fix result must be an object.");
+  }
+  const { title, fingerprint, status, summary } = value;
+  const sha = readOptionalString(value, "sha") ?? readOptionalString(value, "commitSha");
+  const commitMessage = readOptionalString(value, "commitMessage");
+  if (typeof title !== "string" || typeof fingerprint !== "string" || status !== "fixed" && status !== "failed" || typeof summary !== "string") {
+    throw new AgentParseError("Agent fix result has an invalid schema.");
+  }
+  return {
+    title,
+    fingerprint,
+    status,
+    sha,
+    commitMessage,
+    summary
+  };
+}
+function readOptionalString(value, key) {
+  const raw = value[key];
+  return typeof raw === "string" && raw.trim().length > 0 ? raw : void 0;
+}
+function normalizeFingerprintPart(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function findFirstJsonCandidate(text) {
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char !== "[" && char !== "{") {
+      continue;
+    }
+    const end = findJsonEnd(text, index, char === "[" ? "]" : "}");
+    if (end !== void 0) {
+      return text.slice(index, end + 1);
+    }
+  }
+  return void 0;
+}
+function findJsonEnd(text, start, expectedClose) {
+  const stack = [expectedClose];
+  let inString = false;
+  let escaped = false;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "[") {
+      stack.push("]");
+      continue;
+    }
+    if (char === "{") {
+      stack.push("}");
+      continue;
+    }
+    if (char === "]" || char === "}") {
+      if (stack.at(-1) !== char) {
+        return void 0;
+      }
+      stack.pop();
+      if (stack.length === 0) {
+        return index;
+      }
+    }
+  }
+  return void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/agents/prompts.ts
+var issueSchema = '[{"title":"specific standalone title","file":"path","line":1,"severity":"low|medium|high|critical","description":"two concise sentences describing the finding"}]';
+var fixSchema = '[{"title":"issue title","fingerprint":"issue fingerprint","status":"fixed","commitMessage":"<type>(<scope>): <short imperative summary>\\n\\n- <why this change was needed>\\n- <why this approach or impact matters>","summary":"exactly two sentences"},{"title":"issue title","fingerprint":"issue fingerprint","status":"failed","summary":"exactly two sentences explaining the failure"}]';
+function buildReviewSystemPrompt() {
+  return [
+    "You are the REVIEW agent in the pull request review loop.",
+    "Report only issues that are strictly inside the provided PR diff scope.",
+    "Respond only with JSON matching the requested issue schema."
+  ].join("\n");
+}
+function buildFixSystemPrompt() {
+  return [
+    "You are the FIX agent in the pull request review loop.",
+    "Fix only the supplied issue and stay inside the changed PR scope.",
+    "Do not create commits or push changes.",
+    "Respond only with JSON matching the requested fix-result schema."
+  ].join("\n");
+}
+function buildReviewPrompt(ctx) {
+  return [
+    "You are a code review agent for a GitHub pull request.",
+    "Review only changes in the provided PR diff.",
+    "Do not report issues outside the changed scope.",
+    "Look for security issues, correctness issues, maintainability issues, and unnecessary redundancies.",
+    "Return an empty JSON array when there are no changed-scope issues.",
+    "Use issue titles that are specific enough to stand alone in the final summary.",
+    "Use exactly two concise sentences for each issue description.",
+    "respond ONLY with JSON matching this schema:",
+    issueSchema,
+    "",
+    `Review PR ${ctx.pr}.`,
+    "",
+    "PR review.md:",
+    ctx.reviewMarkdown,
+    "",
+    "Current report.md:",
+    ctx.reportMarkdown,
+    "",
+    "PR diff:",
+    ctx.diff
+  ].join("\n");
+}
+function buildFixPrompt(issues, ctx) {
+  const issuePayload = issues.map((issue) => ({
+    ...issue,
+    fingerprint: issueFingerprint(issue)
+  }));
+  return [
+    "You are a code fixer agent for a GitHub pull request.",
+    "Fix only the single issue listed below and stay inside the changed PR scope.",
+    "Use one fresh session to fix this issue.",
+    "Do not create commits, push changes, or include commit SHAs in the result.",
+    "For fixed issues, write the exact commitMessage mendr should use after your process exits.",
+    "The commitMessage must describe what the commit changed, not restate the reviewed issue.",
+    "Commit messages must use exactly this format:",
+    "<type>(<scope>): <short imperative summary>",
+    "",
+    "- <why this change was needed>",
+    "- <why this approach or impact matters>",
+    "",
+    "Commit-message summaries must be imperative and must not end with a period.",
+    "Do not include co-author lines, AI references, provider references, or non-imperative summaries.",
+    "mendr will stage, commit with your commitMessage, record, and push successful fixes after your process exits.",
+    "After fixing, respond ONLY with JSON matching this schema:",
+    fixSchema,
+    "",
+    "The result must include the issue title and fingerprint shown in the issue payload.",
+    "For fixed issues, summarize the concrete code changes you made, not the issue title.",
+    "For failed issues, set status to failed and explain why in two sentences.",
+    "",
+    `Fix PR ${ctx.pr}.`,
+    "",
+    "Issue payload:",
+    JSON.stringify(issuePayload, null, 2),
+    "",
+    "PR review.md:",
+    ctx.reviewMarkdown,
+    "",
+    "Current report.md:",
+    ctx.reportMarkdown,
+    "",
+    "PR diff:",
+    ctx.diff
+  ].join("\n");
+}
+
+// src/agents/claude.ts
+function parseClaudeIssues(output) {
+  const envelope = extractJsonValue(output);
+  if (isClaudeResultEnvelope(envelope)) {
+    return parseIssueArrayFromText(envelope.result);
+  }
+  if (Array.isArray(envelope)) {
+    return parseIssueArrayFromText(JSON.stringify(envelope));
+  }
+  throw new AgentParseError("Claude output did not include a result payload.");
+}
+function parseClaudeFixResults(output) {
+  const envelope = extractJsonValue(output);
+  if (isClaudeResultEnvelope(envelope)) {
+    return parseFixIssueResultArrayFromText(envelope.result);
+  }
+  if (Array.isArray(envelope)) {
+    return parseFixIssueResultArrayFromText(JSON.stringify(envelope));
+  }
+  throw new AgentParseError("Claude output did not include a result payload.");
+}
+function buildClaudeReviewInvocation(ctx) {
+  const prompt = buildReviewPrompt(ctx);
+  return {
+    command: "claude",
+    args: [
+      "-p",
+      prompt,
+      "--output-format",
+      "json",
+      "--model",
+      ctx.model,
+      "--effort",
+      ctx.effort,
+      "--permission-mode",
+      "acceptEdits",
+      "--add-dir",
+      ctx.repo,
+      "--append-system-prompt",
+      buildReviewSystemPrompt()
+    ]
+  };
+}
+function buildClaudeFixInvocation(issues, ctx) {
+  const prompt = buildFixPrompt(issues, ctx);
+  return {
+    command: "claude",
+    args: [
+      "-p",
+      prompt,
+      "--output-format",
+      "json",
+      "--model",
+      ctx.model,
+      "--effort",
+      ctx.effort,
+      "--permission-mode",
+      "acceptEdits",
+      "--add-dir",
+      ctx.repo,
+      "--append-system-prompt",
+      buildFixSystemPrompt()
+    ]
+  };
+}
+function isClaudeResultEnvelope(value) {
+  return typeof value === "object" && value !== null && "result" in value && typeof value.result === "string";
+}
+
+// src/agents/codex.ts
+function parseCodexIssues(output) {
+  return parseIssueArrayFromText(output);
+}
+function parseCodexFixResults(output) {
+  return parseFixIssueResultArrayFromText(output);
+}
+function buildCodexReviewInvocation(ctx, options) {
+  const prompt = buildReviewPrompt(ctx);
+  return {
+    command: "codex",
+    args: [
+      "exec",
+      prompt,
+      "-m",
+      ctx.model,
+      "-c",
+      `model_reasoning_effort=${JSON.stringify(ctx.effort)}`,
+      "--sandbox",
+      "workspace-write",
+      "--json",
+      "-C",
+      ctx.repo,
+      "--output-last-message",
+      options.outputFile
+    ]
+  };
+}
+function buildCodexFixInvocation(issues, ctx, options) {
+  const prompt = buildFixPrompt(issues, ctx);
+  return {
+    command: "codex",
+    args: [
+      "exec",
+      prompt,
+      "-m",
+      ctx.model,
+      "-c",
+      `model_reasoning_effort=${JSON.stringify(ctx.effort)}`,
+      "--sandbox",
+      "workspace-write",
+      "--json",
+      "-C",
+      ctx.repo,
+      "--output-last-message",
+      options.outputFile
+    ]
+  };
+}
+
+// src/agents/driver.ts
+var codexEfforts = ["low", "medium", "high", "xhigh"];
+var claudeEfforts = ["low", "medium", "high", "xhigh", "max"];
+var defaultAgentTimeoutMs = 10 * 60 * 1e3;
+function defaultModelForAgent(agent) {
+  if (agent === "codex") {
+    return process.env.MENDR_CODEX_MODEL ?? "gpt-5.5";
+  }
+  return process.env.MENDR_CLAUDE_MODEL ?? "claude-opus-4-8";
+}
+function defaultEffortForAgent(agent) {
+  const effort = agent === "codex" ? process.env.MENDR_CODEX_EFFORT : process.env.MENDR_CLAUDE_EFFORT;
+  if (effort) {
+    if (isEffortForAgent(agent, effort)) {
+      return effort;
+    }
+    throw new Error(
+      `Invalid ${agent} effort "${effort}". Expected one of: ${allowedEffortsForAgent(agent).join(", ")}.`
+    );
+  }
+  return agent === "codex" ? "xhigh" : "high";
+}
+function allowedEffortsForAgent(agent) {
+  return agent === "codex" ? codexEfforts : claudeEfforts;
+}
+function isEffortForAgent(agent, effort) {
+  return allowedEffortsForAgent(agent).includes(effort);
+}
+function agentTimeoutMs(env = process.env) {
+  const rawTimeout = env.MENDR_AGENT_TIMEOUT_MS;
+  if (rawTimeout === void 0) {
+    return defaultAgentTimeoutMs;
+  }
+  const timeout = Number(rawTimeout);
+  if (!Number.isInteger(timeout) || timeout < 0) {
+    throw new Error("Invalid MENDR_AGENT_TIMEOUT_MS. Expected a non-negative integer.");
+  }
+  return timeout === 0 ? void 0 : timeout;
+}
+function createAgentDriver(options) {
+  if (options.agent === "codex") {
+    return new CodexAgentDriver(options.exec, options.outputDir);
+  }
+  return new ClaudeAgentDriver(options.exec, options.outputDir);
+}
+var ClaudeAgentDriver = class {
+  constructor(exec, outputDir) {
+    this.exec = exec;
+    this.outputDir = outputDir;
+  }
+  exec;
+  outputDir;
+  outputIndex = 0;
+  async review(ctx) {
+    const label = this.nextLabel("claude", "review");
+    const invocation = buildClaudeReviewInvocation(ctx);
+    const result = await runAgentInvocation(this.exec, invocation, {
+      cwd: ctx.repo,
+      outputDir: this.outputDir,
+      label
+    });
+    return parseClaudeIssues(result.stdout);
+  }
+  async fix(issues, ctx) {
+    const label = this.nextLabel("claude", "fix");
+    const invocation = buildClaudeFixInvocation(issues, ctx);
+    const result = await runAgentInvocation(this.exec, invocation, {
+      cwd: ctx.repo,
+      outputDir: this.outputDir,
+      label
+    });
+    return parseClaudeFixResults(result.stdout);
+  }
+  nextLabel(agent, kind) {
+    this.outputIndex += 1;
+    return `${agent}-${kind}-${this.outputIndex}`;
+  }
+};
+var CodexAgentDriver = class {
+  constructor(exec, outputDir) {
+    this.exec = exec;
+    this.outputDir = outputDir;
+  }
+  exec;
+  outputDir;
+  outputIndex = 0;
+  async review(ctx) {
+    const label = this.nextLabel("codex", "review");
+    const outputFile = await this.outputFile(label);
+    const invocation = buildCodexReviewInvocation(ctx, { outputFile });
+    const result = await runAgentInvocation(this.exec, invocation, {
+      cwd: ctx.repo,
+      outputDir: this.outputDir,
+      label
+    });
+    const finalMessage = await readFile(outputFile, "utf8");
+    await writeAgentIo(this.outputDir, label, result, {
+      "final-message.md": finalMessage
+    });
+    return parseCodexIssues(finalMessage);
+  }
+  async fix(issues, ctx) {
+    const label = this.nextLabel("codex", "fix");
+    const outputFile = await this.outputFile(label);
+    const invocation = buildCodexFixInvocation(issues, ctx, { outputFile });
+    const result = await runAgentInvocation(this.exec, invocation, {
+      cwd: ctx.repo,
+      outputDir: this.outputDir,
+      label
+    });
+    const finalMessage = await readFile(outputFile, "utf8");
+    await writeAgentIo(this.outputDir, label, result, {
+      "final-message.md": finalMessage
+    });
+    return parseCodexFixResults(finalMessage);
+  }
+  nextLabel(agent, kind) {
+    this.outputIndex += 1;
+    return `${agent}-${kind}-${this.outputIndex}`;
+  }
+  async outputFile(label) {
+    await mkdir2(this.outputDir, { recursive: true });
+    return join(this.outputDir, `${label}.final-message.md`);
+  }
+};
+async function runAgentInvocation(exec, invocation, options) {
+  const stdoutFile = join(options.outputDir, `${options.label}.stdout.log`);
+  const stderrFile = join(options.outputDir, `${options.label}.stderr.log`);
+  const result = await exec(invocation.command, invocation.args, {
+    cwd: options.cwd,
+    timeoutMs: agentTimeoutMs(),
+    stdoutFile,
+    stderrFile
+  });
+  await writeAgentIo(options.outputDir, options.label, result);
+  if (result.exitCode !== 0) {
+    throw new CommandFailedError(invocation.command, invocation.args, result);
+  }
+  return result;
+}
+async function writeAgentIo(outputDir, label, result, extraFiles = {}) {
+  await mkdir2(outputDir, { recursive: true });
+  await Promise.all([
+    writeFile(join(outputDir, `${label}.stdout.log`), result.stdout, "utf8"),
+    writeFile(join(outputDir, `${label}.stderr.log`), result.stderr, "utf8"),
+    ...Object.entries(extraFiles).map(
+      ([suffix, content]) => writeFile(join(outputDir, `${label}.${suffix}`), content, "utf8")
+    )
+  ]);
+}
+
+// src/git.ts
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+async function getRepoRoot(exec, cwd) {
+  const result = await execOk(exec, "git", ["rev-parse", "--show-toplevel"], { cwd });
+  return result.stdout.trim();
+}
+async function getHeadCommitSha(exec, repo) {
+  const result = await execOk(exec, "git", ["rev-parse", "HEAD"], { cwd: repo });
+  return result.stdout.trim();
+}
+async function fetchPullRequestHeadRef(exec, repo, pr, ref) {
+  await execOk(exec, "git", ["fetch", "origin", `+refs/pull/${pr}/head:${ref}`], {
+    cwd: repo
+  });
+}
+async function createDetachedWorktree(exec, repo, worktreePath, ref) {
+  await execOk(exec, "git", ["worktree", "add", "--detach", worktreePath, ref], {
+    cwd: repo
+  });
+}
+async function removeWorktree(exec, repo, worktreePath) {
+  await execOk(exec, "git", ["worktree", "remove", "--force", worktreePath], {
+    cwd: repo
+  });
+}
+async function getPorcelainStatus(exec, repo) {
+  const result = await execOk(exec, "git", ["status", "--porcelain"], { cwd: repo });
+  return result.stdout.trim();
+}
+async function fetchRemoteBranch(exec, repo, remote, branch) {
+  const remoteRef = `refs/remotes/${remote}/${branch}`;
+  await execOk(exec, "git", ["fetch", remote, `+refs/heads/${branch}:${remoteRef}`], {
+    cwd: repo
+  });
+  return remoteRef;
+}
+async function ensureMergeableWithRef(exec, repo, baseRef) {
+  try {
+    await execOk(exec, "git", ["merge-tree", "--write-tree", "--quiet", baseRef, "HEAD"], {
+      cwd: repo
+    });
+  } catch (error) {
+    if (!isModernMergeTreeUnsupported(error)) {
+      throw error;
+    }
+    await ensureMergeableWithTemporaryWorktree(exec, repo, baseRef);
+  }
+}
+async function ensureMergeableWithTemporaryWorktree(exec, repo, baseRef) {
+  const worktreePath = await mkdtemp(join2(tmpdir(), "mendr-merge-check-"));
+  let mergeError;
+  let worktreeCreated = false;
+  try {
+    await createDetachedWorktree(exec, repo, worktreePath, "HEAD");
+    worktreeCreated = true;
+    await execOk(exec, "git", ["merge", "--no-commit", "--no-ff", baseRef], {
+      cwd: worktreePath
+    });
+  } catch (error) {
+    mergeError = error;
+  } finally {
+    try {
+      if (worktreeCreated) {
+        await removeWorktree(exec, repo, worktreePath);
+      } else {
+        await rm(worktreePath, { recursive: true, force: true });
+      }
+    } catch (cleanupError) {
+      if (mergeError === void 0) {
+        throw cleanupError;
+      }
+    }
+  }
+  if (mergeError !== void 0) {
+    throw mergeError;
+  }
+}
+function isModernMergeTreeUnsupported(error) {
+  if (!(error instanceof CommandFailedError)) {
+    return false;
+  }
+  if (error.command !== "git" || error.args[0] !== "merge-tree") {
+    return false;
+  }
+  const output = `${error.result.stderr}
+${error.result.stdout}`.toLowerCase();
+  return output.includes("not a git command") || output.includes("usage: git merge-tree") || output.includes("unknown option") || output.includes("unrecognized option") || output.includes("unknown switch");
+}
+async function stageAll(exec, repo) {
+  await execOk(exec, "git", ["add", "-A"], { cwd: repo });
+}
+async function commitStaged(exec, repo, message) {
+  await execOk(exec, "git", ["commit", "-F", "-"], {
+    cwd: repo,
+    input: `${message.trim()}
+`
+  });
+  return getHeadCommitSha(exec, repo);
+}
+async function resetWorktreeToCommit(exec, repo, sha) {
+  await execOk(exec, "git", ["reset", "--hard", sha], { cwd: repo });
+  await execOk(exec, "git", ["clean", "-fdx"], { cwd: repo });
+}
+async function pushHeadToBranch(exec, repo, remote, branch) {
+  await execOk(exec, "git", ["push", remote, `HEAD:${branch}`], { cwd: repo });
+}
+
+// src/github.ts
+async function fetchPullRequestReadinessRefs(exec, repo, pr) {
+  const result = await execOk(
+    exec,
+    "gh",
+    ["pr", "view", pr, "--json", "baseRefName,headRefOid"],
+    { cwd: repo }
+  );
+  const parsed = JSON.parse(result.stdout);
+  const baseBranch = typeof parsed.baseRefName === "string" ? parsed.baseRefName.trim() : "";
+  const headSha = typeof parsed.headRefOid === "string" ? parsed.headRefOid.trim() : "";
+  if (baseBranch.length === 0) {
+    throw new Error("Could not resolve the pull request base branch from GitHub.");
+  }
+  if (headSha.length === 0) {
+    throw new Error("Could not resolve the pull request head SHA from GitHub.");
+  }
+  return {
+    baseBranch,
+    headSha
+  };
+}
+async function fetchPullRequestDetails(exec, repo, pr) {
+  const result = await execOk(
+    exec,
+    "gh",
+    ["pr", "view", pr, "--json", "title,body,comments"],
+    { cwd: repo }
+  );
+  const parsed = JSON.parse(result.stdout);
+  return {
+    title: typeof parsed.title === "string" ? parsed.title : "",
+    body: typeof parsed.body === "string" ? parsed.body : "",
+    comments: Array.isArray(parsed.comments) ? parsed.comments : []
+  };
+}
+async function fetchPullRequestDiff(exec, repo, pr) {
+  const result = await execOk(exec, "gh", ["pr", "diff", pr], { cwd: repo });
+  return result.stdout;
+}
+async function fetchPullRequestHeadBranch(exec, repo, pr) {
+  const result = await execOk(
+    exec,
+    "gh",
+    [
+      "pr",
+      "view",
+      pr,
+      "--json",
+      "headRefName,headRepository,headRepositoryOwner,isCrossRepository"
+    ],
+    {
+      cwd: repo
+    }
+  );
+  const parsed = JSON.parse(result.stdout);
+  const branch = typeof parsed.headRefName === "string" ? parsed.headRefName.trim() : "";
+  if (branch.length === 0) {
+    throw new Error("Could not resolve the pull request head branch from GitHub.");
+  }
+  const branchPushRemote = resolveBranchPushRemote(parsed);
+  return {
+    branch,
+    branchPushRemote
+  };
+}
+async function validatePullRequest(exec, repo, pr) {
+  await execOk(exec, "gh", ["pr", "view", pr, "--json", "number,url"], { cwd: repo });
+}
+async function waitForPullRequestChecks(exec, repo, pr) {
+  await execOk(
+    exec,
+    "gh",
+    ["pr", "checks", pr, "--watch", "--fail-fast", "--interval", "10"],
+    {
+      cwd: repo,
+      timeoutMs: 30 * 60 * 1e3
+    }
+  );
+}
+async function postPullRequestComment(exec, repo, pr, bodyFile) {
+  await execOk(exec, "gh", ["pr", "comment", pr, "--body-file", bodyFile], { cwd: repo });
+}
+function renderReviewMarkdown(pr, details) {
+  const comments = details.comments.length ? details.comments.map(renderComment).join("\n\n") : "No comments.";
+  return [
+    `# PR ${pr}: ${details.title || "(untitled)"}`,
+    "",
+    "## Body",
+    details.body.trim() || "No body.",
+    "",
+    "## Comments",
+    comments,
+    ""
+  ].join("\n");
+}
+function renderComment(comment) {
+  const author = comment.author?.login ?? "unknown";
+  const body = comment.body?.trim() || "(empty comment)";
+  return `- @${author}: ${body}`;
+}
+function resolveBranchPushRemote(input) {
+  const headRepository = readRepositoryInfo(input.headRepository, input.headRepositoryOwner);
+  const baseRepository = readRepositoryInfo(input.baseRepository);
+  const isCrossRepository = typeof input.isCrossRepository === "boolean" ? input.isCrossRepository : void 0;
+  if (!headRepository) {
+    throw new Error("Could not resolve the pull request head repository from GitHub.");
+  }
+  if (isCrossRepository === false) {
+    return "origin";
+  }
+  if (isCrossRepository === void 0 && headRepository.nameWithOwner && baseRepository?.nameWithOwner && headRepository.nameWithOwner === baseRepository.nameWithOwner) {
+    return "origin";
+  }
+  const remote = headRepository.sshUrl ?? normalizedGitUrl(headRepository.url);
+  if (remote) {
+    return remote;
+  }
+  if (headRepository.nameWithOwner) {
+    return `https://github.com/${headRepository.nameWithOwner}.git`;
+  }
+  throw new Error("Could not resolve the pull request head repository push remote from GitHub.");
+}
+function readRepositoryInfo(value, ownerFallback) {
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  const nameWithOwner = readString(value, "nameWithOwner") ?? readNameWithOwner(
+    readOwnerLogin(value.owner) ?? readOwnerLogin(ownerFallback),
+    readString(value, "name")
+  );
+  const url = readString(value, "url");
+  const sshUrl = readString(value, "sshUrl") ?? readString(value, "sshURL");
+  if (!nameWithOwner && !url && !sshUrl) {
+    return void 0;
+  }
+  return {
+    ...nameWithOwner ? { nameWithOwner } : {},
+    ...url ? { url } : {},
+    ...sshUrl ? { sshUrl } : {}
+  };
+}
+function readNameWithOwner(owner, name) {
+  if (!owner || !name) {
+    return void 0;
+  }
+  return `${owner}/${name}`;
+}
+function readOwnerLogin(value) {
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  return readString(value, "login");
+}
+function normalizedGitUrl(url) {
+  if (!url) {
+    return void 0;
+  }
+  if (!/^https?:\/\//i.test(url)) {
+    return url;
+  }
+  return url.endsWith(".git") ? url : `${url}.git`;
+}
+function readString(value, key) {
+  const raw = value[key];
+  return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/paths.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+var homeEnvVar = "MENDR_HOME";
+function defaultMendrHome(env = process.env) {
+  return env[homeEnvVar] ?? join3(homedir(), ".mendr");
+}
+function reviewsDir(mendrHome) {
+  return join3(mendrHome, "reviews");
+}
+function reviewDir(mendrHome, id) {
+  return join3(reviewsDir(mendrHome), id);
+}
+function worktreesDir(mendrHome) {
+  return join3(mendrHome, "worktrees");
+}
+function sessionWorktreePath(mendrHome, id, pr) {
+  return join3(worktreesDir(mendrHome), `session-${id}-pr-${pr}`);
+}
+
+// src/state.ts
+import { appendFile, mkdir as mkdir3, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+var terminalReviewPhases = /* @__PURE__ */ new Set(["complete", "stopped", "failed"]);
+function isTerminalReviewState(state) {
+  return state.done || terminalReviewPhases.has(state.phase);
+}
+async function writeMeta(home, id, meta) {
+  await ensureMendrHome(home);
+  await writeJson(home, id, "meta.json", meta);
+}
+async function readMeta(home, id) {
+  const meta = await readJson(home, id, "meta.json");
+  return {
+    ...meta,
+    maxRounds: meta.maxRounds ?? 3
+  };
+}
+async function writeState(home, id, state) {
+  await ensureMendrHome(home);
+  await writeJson(home, id, "state.json", state);
+}
+async function readState(home, id) {
+  return readJson(home, id, "state.json");
+}
+async function appendEvent(home, id, event) {
+  const dir = reviewDir(home, id);
+  const line = JSON.stringify({
+    ...event,
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await mkdir3(dir, { recursive: true });
+  await appendFile(join4(dir, "events.log"), `${line}
+`, "utf8");
+}
+async function appendIssueRecord(home, id, issue) {
+  await appendJsonl(home, id, "issues.jsonl", issue);
+}
+async function appendFixAttempt(home, id, attempt) {
+  await appendJsonl(home, id, "fixes.jsonl", attempt);
+}
+async function ensureMendrHome(home) {
+  await mkdir3(reviewsDir(home), { recursive: true });
+}
+async function closeReviewSession(home, id) {
+  await rm2(reviewDir(home, id), { recursive: true, force: true });
+}
+async function readEvents(home, id) {
+  let raw;
+  try {
+    raw = await readFile2(join4(reviewDir(home, id), "events.log"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  return raw.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+async function writeJson(home, id, fileName, value) {
+  const dir = reviewDir(home, id);
+  await mkdir3(dir, { recursive: true });
+  await writeFile2(join4(dir, fileName), `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function appendJsonl(home, id, fileName, value) {
+  const dir = reviewDir(home, id);
+  await mkdir3(dir, { recursive: true });
+  await appendFile(join4(dir, fileName), `${JSON.stringify(value)}
+`, "utf8");
+}
+async function readJson(home, id, fileName) {
+  return JSON.parse(await readFile2(join4(reviewDir(home, id), fileName), "utf8"));
+}
+
+export {
+  issueFingerprint,
+  dedupeIssues,
+  defaultExec,
+  execOk,
+  defaultModelForAgent,
+  defaultEffortForAgent,
+  allowedEffortsForAgent,
+  isEffortForAgent,
+  createAgentDriver,
+  getRepoRoot,
+  getHeadCommitSha,
+  fetchPullRequestHeadRef,
+  createDetachedWorktree,
+  removeWorktree,
+  getPorcelainStatus,
+  fetchRemoteBranch,
+  ensureMergeableWithRef,
+  stageAll,
+  commitStaged,
+  resetWorktreeToCommit,
+  pushHeadToBranch,
+  fetchPullRequestReadinessRefs,
+  fetchPullRequestDetails,
+  fetchPullRequestDiff,
+  fetchPullRequestHeadBranch,
+  validatePullRequest,
+  waitForPullRequestChecks,
+  postPullRequestComment,
+  renderReviewMarkdown,
+  defaultMendrHome,
+  reviewsDir,
+  reviewDir,
+  worktreesDir,
+  sessionWorktreePath,
+  isTerminalReviewState,
+  writeMeta,
+  readMeta,
+  writeState,
+  readState,
+  appendEvent,
+  appendIssueRecord,
+  appendFixAttempt,
+  ensureMendrHome,
+  closeReviewSession,
+  readEvents
+};