@pepps233/mendr 0.2.0 → 0.4.0

package/dist/{chunk-753PEKBT.js → chunk-GKT5VC55.js}

@@ -145,6 +145,15 @@ function parseFixIssueResultArrayFromText(text) {
   }
   return value.map(parseFixIssueResult);
 }
+function parseExistingCommentReviewResultArrayFromText(text) {
+  const value = extractJsonValue(text);
+  if (!Array.isArray(value)) {
+    throw new AgentParseError(
+      "Agent JSON payload must be an existing-comment review result array."
+    );
+  }
+  return value.map(parseExistingCommentReviewResult);
+}
 function issueFingerprint(issue) {
   return [
     normalizeFingerprintPart(issue.title),
@@ -188,6 +197,29 @@ function parseFixIssueResult(value) {
     summary
   };
 }
+function parseExistingCommentReviewResult(value) {
+  if (!isRecord(value)) {
+    throw new AgentParseError("Agent existing-comment review result must be an object.");
+  }
+  const { status, summary } = value;
+  if (status !== "needs_fix" && status !== "already_addressed" && status !== "does_not_exist") {
+    throw new AgentParseError("Agent existing-comment review result has an invalid status.");
+  }
+  if (typeof summary !== "string") {
+    throw new AgentParseError("Agent existing-comment review result has an invalid summary.");
+  }
+  if (status !== "needs_fix") {
+    return {
+      status,
+      summary
+    };
+  }
+  return {
+    status,
+    summary,
+    issue: parseIssue(value)
+  };
+}
 function readOptionalString(value, key) {
   const raw = value[key];
   return typeof raw === "string" && raw.trim().length > 0 ? raw : void 0;
@@ -255,6 +287,15 @@ function isRecord(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"}]';
+var existingCommentReviewSchema = '[{"status":"needs_fix","title":"specific standalone title","file":"path","line":1,"severity":"low|medium|high|critical","description":"two concise sentences describing the finding","summary":"two concise sentences for final reporting"},{"status":"already_addressed","summary":"two concise sentences for final reporting"},{"status":"does_not_exist","summary":"two concise sentences for final reporting"}]';
+function buildExistingCommentReviewSystemPrompt() {
+  return [
+    "You are the EXISTING COMMENT REVIEW agent in the pull request review loop.",
+    "Read existing PR comments only from the provided review.md.",
+    "Classify only concrete unresolved code correction requests.",
+    "Respond only with JSON matching the requested existing-comment review schema."
+  ].join("\n");
+}
 function buildReviewSystemPrompt() {
   return [
     "You are the REVIEW agent in the pull request review loop.",
@@ -270,6 +311,33 @@ function buildFixSystemPrompt() {
     "Respond only with JSON matching the requested fix-result schema."
   ].join("\n");
 }
+function buildExistingCommentReviewPrompt(ctx) {
+  return [
+    "You are reviewing existing GitHub pull request comments before normal review rounds begin.",
+    "Read only the provided PR review.md as the source for existing comments.",
+    "Ignore comments that do not describe a concrete bug, issue, or requested code correction.",
+    "If a newer comment clearly says an earlier issue was handled, return already_addressed.",
+    "If no newer resolution comment exists, inspect the current code in the repository and the PR diff.",
+    "If the code already handles the issue, return already_addressed.",
+    "If the alleged issue is not reproducible or not true in the codebase, return does_not_exist.",
+    "Otherwise return needs_fix with issue fields matching the standard issue schema.",
+    "Use exactly two concise sentences for every summary and needs_fix description.",
+    "Return an empty JSON array when no existing comments need follow-up.",
+    "respond ONLY with JSON matching this schema:",
+    existingCommentReviewSchema,
+    "",
+    `Review existing comments for PR ${ctx.pr}.`,
+    "",
+    "PR review.md:",
+    ctx.reviewMarkdown,
+    "",
+    "Current report.md:",
+    ctx.reportMarkdown,
+    "",
+    "PR diff:",
+    ctx.diff
+  ].join("\n");
+}
 function buildReviewPrompt(ctx) {
   return [
     "You are a code review agent for a GitHub pull request.",
@@ -349,6 +417,16 @@ function parseClaudeIssues(output) {
   }
   throw new AgentParseError("Claude output did not include a result payload.");
 }
+function parseClaudeExistingCommentReviewResults(output) {
+  const envelope = extractJsonValue(output);
+  if (isClaudeResultEnvelope(envelope)) {
+    return parseExistingCommentReviewResultArrayFromText(envelope.result);
+  }
+  if (Array.isArray(envelope)) {
+    return parseExistingCommentReviewResultArrayFromText(JSON.stringify(envelope));
+  }
+  throw new AgentParseError("Claude output did not include a result payload.");
+}
 function parseClaudeFixResults(output) {
   const envelope = extractJsonValue(output);
   if (isClaudeResultEnvelope(envelope)) {
@@ -359,30 +437,19 @@ function parseClaudeFixResults(output) {
   }
   throw new AgentParseError("Claude output did not include a result payload.");
 }
+function buildClaudeExistingCommentReviewInvocation(ctx) {
+  const prompt = buildExistingCommentReviewPrompt(ctx);
+  return buildClaudeInvocation(ctx, prompt, buildExistingCommentReviewSystemPrompt());
+}
 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()
-    ]
-  };
+  return buildClaudeInvocation(ctx, prompt, buildReviewSystemPrompt());
 }
 function buildClaudeFixInvocation(issues, ctx) {
   const prompt = buildFixPrompt(issues, ctx);
+  return buildClaudeInvocation(ctx, prompt, buildFixSystemPrompt());
+}
+function buildClaudeInvocation(ctx, prompt, systemPrompt) {
   return {
     command: "claude",
     args: [
@@ -399,7 +466,7 @@ function buildClaudeFixInvocation(issues, ctx) {
       "--add-dir",
       ctx.repo,
       "--append-system-prompt",
-      buildFixSystemPrompt()
+      systemPrompt
     ]
   };
 }
@@ -411,33 +478,25 @@ function isClaudeResultEnvelope(value) {
 function parseCodexIssues(output) {
   return parseIssueArrayFromText(output);
 }
+function parseCodexExistingCommentReviewResults(output) {
+  return parseExistingCommentReviewResultArrayFromText(output);
+}
 function parseCodexFixResults(output) {
   return parseFixIssueResultArrayFromText(output);
 }
+function buildCodexExistingCommentReviewInvocation(ctx, options) {
+  const prompt = buildExistingCommentReviewPrompt(ctx);
+  return buildCodexInvocation(ctx, options, prompt);
+}
 function buildCodexReviewInvocation(ctx, options) {
   const prompt = buildReviewPrompt(ctx);
-  return {
-    command: "codex",
-    input: prompt,
-    args: [
-      "exec",
-      "-",
-      "-m",
-      ctx.model,
-      "-c",
-      `model_reasoning_effort=${JSON.stringify(ctx.effort)}`,
-      "--sandbox",
-      "workspace-write",
-      "--json",
-      "-C",
-      ctx.repo,
-      "--output-last-message",
-      options.outputFile
-    ]
-  };
+  return buildCodexInvocation(ctx, options, prompt);
 }
 function buildCodexFixInvocation(issues, ctx, options) {
   const prompt = buildFixPrompt(issues, ctx);
+  return buildCodexInvocation(ctx, options, prompt);
+}
+function buildCodexInvocation(ctx, options, prompt) {
   return {
     command: "codex",
     input: prompt,
@@ -512,6 +571,16 @@ var ClaudeAgentDriver = class {
   exec;
   outputDir;
   outputIndex = 0;
+  async reviewExistingComments(ctx) {
+    const label = this.nextLabel("claude", "comment-review");
+    const invocation = buildClaudeExistingCommentReviewInvocation(ctx);
+    const result = await runAgentInvocation(this.exec, invocation, {
+      cwd: ctx.repo,
+      outputDir: this.outputDir,
+      label
+    });
+    return parseClaudeExistingCommentReviewResults(result.stdout);
+  }
   async review(ctx) {
     const label = this.nextLabel("claude", "review");
     const invocation = buildClaudeReviewInvocation(ctx);
@@ -545,6 +614,21 @@ var CodexAgentDriver = class {
   exec;
   outputDir;
   outputIndex = 0;
+  async reviewExistingComments(ctx) {
+    const label = this.nextLabel("codex", "comment-review");
+    const outputFile = await this.outputFile(label);
+    const invocation = buildCodexExistingCommentReviewInvocation(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 parseCodexExistingCommentReviewResults(finalMessage);
+  }
   async review(ctx) {
     const label = this.nextLabel("codex", "review");
     const outputFile = await this.outputFile(label);
@@ -750,10 +834,13 @@ async function fetchPullRequestDetails(exec, repo, pr) {
     { cwd: repo }
   );
   const parsed = JSON.parse(result.stdout);
+  const comments = normalizeIssueComments(parsed.comments);
+  const reviewBodies = await fetchPullRequestReviewBodies(exec, repo, pr);
+  const reviewComments = await fetchPullRequestReviewComments(exec, repo, pr);
   return {
     title: typeof parsed.title === "string" ? parsed.title : "",
     body: typeof parsed.body === "string" ? parsed.body : "",
-    comments: Array.isArray(parsed.comments) ? parsed.comments : []
+    comments: sortCommentsByCreatedAt([...comments, ...reviewBodies, ...reviewComments])
   };
 }
 async function fetchPullRequestDiff(exec, repo, pr) {
@@ -819,7 +906,114 @@ function renderReviewMarkdown(pr, details) {
 function renderComment(comment) {
   const author = comment.author?.login ?? "unknown";
   const body = comment.body?.trim() || "(empty comment)";
-  return `- @${author}: ${body}`;
+  const context = renderCommentContext(comment);
+  return `- @${author}${context}: ${body}`;
+}
+async function fetchPullRequestReviewBodies(exec, repo, pr) {
+  const result = await execOk(
+    exec,
+    "gh",
+    ["api", "--paginate", "--slurp", `repos/{owner}/{repo}/pulls/${pr}/reviews`],
+    { cwd: repo }
+  );
+  return readGhApiArray(result.stdout).map(normalizeReviewBody).filter((comment) => comment !== void 0);
+}
+async function fetchPullRequestReviewComments(exec, repo, pr) {
+  const result = await execOk(
+    exec,
+    "gh",
+    ["api", "--paginate", "--slurp", `repos/{owner}/{repo}/pulls/${pr}/comments`],
+    { cwd: repo }
+  );
+  return readGhApiArray(result.stdout).filter(isRecord2).map(normalizeReviewComment);
+}
+function normalizeIssueComments(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(isRecord2).map((comment) => ({
+    author: readAuthor(comment.author),
+    body: readString(comment, "body"),
+    createdAt: readString(comment, "createdAt") ?? readString(comment, "created_at"),
+    kind: "comment",
+    url: readString(comment, "url") ?? readString(comment, "html_url")
+  }));
+}
+function normalizeReviewBody(value) {
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  const body = readString(value, "body");
+  const url = readString(value, "html_url") ?? readString(value, "url");
+  if (!body && !url) {
+    return void 0;
+  }
+  return {
+    author: readAuthor(value.user) ?? readAuthor(value.author),
+    body,
+    createdAt: readString(value, "submitted_at") ?? readString(value, "submittedAt"),
+    kind: "review",
+    state: readString(value, "state"),
+    url
+  };
+}
+function normalizeReviewComment(value) {
+  return {
+    author: readAuthor(value.user) ?? readAuthor(value.author),
+    body: readString(value, "body"),
+    createdAt: readString(value, "created_at") ?? readString(value, "createdAt"),
+    kind: "review_comment",
+    line: readNumber(value, "line") ?? readNumber(value, "original_line"),
+    path: readString(value, "path"),
+    url: readString(value, "html_url") ?? readString(value, "url")
+  };
+}
+function readGhApiArray(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  if (parsed.every(Array.isArray)) {
+    return parsed.flat();
+  }
+  return parsed;
+}
+function sortCommentsByCreatedAt(comments) {
+  return comments.map((comment, index) => ({ comment, index })).sort((left, right) => {
+    const leftTime = readCommentTime(left.comment);
+    const rightTime = readCommentTime(right.comment);
+    if (leftTime === rightTime) {
+      return left.index - right.index;
+    }
+    return leftTime - rightTime;
+  }).map(({ comment }) => comment);
+}
+function readCommentTime(comment) {
+  const time = comment.createdAt ? Date.parse(comment.createdAt) : Number.NaN;
+  return Number.isFinite(time) ? time : Number.MAX_SAFE_INTEGER;
+}
+function renderCommentContext(comment) {
+  const parts = [];
+  if (comment.kind === "review") {
+    parts.push(comment.state ? `review ${comment.state.toLowerCase()}` : "review");
+  } else if (comment.kind === "review_comment") {
+    parts.push(renderReviewCommentLocation(comment));
+  } else {
+    parts.push("comment");
+  }
+  if (comment.url) {
+    parts.push(comment.url);
+  }
+  return ` (${parts.join(", ")})`;
+}
+function renderReviewCommentLocation(comment) {
+  if (comment.path && comment.line !== void 0) {
+    return `inline comment on ${comment.path}:${comment.line}`;
+  }
+  if (comment.path) {
+    return `inline comment on ${comment.path}`;
+  }
+  return "inline comment";
 }
 function resolveBranchPushRemote(input) {
   const headRepository = readRepositoryInfo(input.headRepository, input.headRepositoryOwner);
@@ -874,6 +1068,13 @@ function readOwnerLogin(value) {
   }
   return readString(value, "login");
 }
+function readAuthor(value) {
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  const login = readString(value, "login");
+  return login ? { login } : void 0;
+}
 function normalizedGitUrl(url) {
   if (!url) {
     return void 0;
@@ -887,6 +1088,10 @@ function readString(value, key) {
   const raw = value[key];
   return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
 }
+function readNumber(value, key) {
+  const raw = value[key];
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/cli.js

@@ -26,7 +26,7 @@ import {
   worktreesDir,
   writeMeta,
   writeState
-} from "./chunk-753PEKBT.js";
+} from "./chunk-GKT5VC55.js";
 
 // src/cli.ts
 import { spawn as spawn2 } from "child_process";

package/dist/daemon.js

@@ -28,7 +28,7 @@ import {
   stageAll,
   waitForPullRequestChecks,
   writeState
-} from "./chunk-753PEKBT.js";
+} from "./chunk-GKT5VC55.js";
 
 // src/orchestrator.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -39,6 +39,7 @@ import { setTimeout as delay } from "timers/promises";
 import { Buffer } from "buffer";
 var REPORT_HEADING = "## Summary by Mendr";
 var LEGACY_REPORT_HEADING = "## Summary";
+var EXISTING_COMMENT_FOLLOW_UP_HEADING = "### Existing Comment Follow-up";
 var RESOLVED_ISSUES_HEADING = "### Resolved Issues";
 var UNRESOLVED_ISSUES_HEADING = "### Unresolved Issues";
 var ROUND_CAP_HEADING = "### Round Cap";
@@ -65,6 +66,16 @@ ${legacyShaLine}`)) {
 function appendIssueResult(report, entry) {
   return appendResolvedIssue(report, entry);
 }
+function appendExistingCommentFollowUp(report, entry) {
+  let normalized = ensureSummary(report);
+  const lines = existingCommentFollowUpLines(entry);
+  const block = lines.join("\n");
+  if (normalized.includes(block)) {
+    return normalized === report ? report : normalized;
+  }
+  normalized = ensureSection(normalized, EXISTING_COMMENT_FOLLOW_UP_HEADING);
+  return appendBlock(normalized, lines);
+}
 function appendUnresolvedIssue(report, entry) {
   let normalized = ensureSummary(report);
   const issueLine = `#### ${entry.issue.title}`;
@@ -104,6 +115,29 @@ function appendRoundCapNote(report, note) {
   normalized = ensureSection(normalized, ROUND_CAP_HEADING);
   return appendBlock(normalized, [capLine, ...openIssueLines]);
 }
+function existingCommentFollowUpLines(entry) {
+  if (entry.status === "fixed") {
+    return [
+      `#### ${entry.issue.title}`,
+      issueFingerprintLine(entry.issue),
+      "**Status:** Fixed",
+      `**Commit:** ${entry.sha}`,
+      entry.summary
+    ];
+  }
+  if (entry.status === "fixer_failed") {
+    return [
+      `#### ${entry.issue.title}`,
+      issueFingerprintLine(entry.issue),
+      "**Status:** Fixer failed",
+      entry.summary
+    ];
+  }
+  if (entry.status === "already_addressed") {
+    return ["#### Already addressed", "**Status:** Already addressed", entry.summary];
+  }
+  return ["#### Issue does not exist", "**Status:** Issue does not exist", entry.summary];
+}
 function ensureSummary(report) {
   const trimmed = report.trim();
   if (trimmed.length === 0) {
@@ -297,6 +331,29 @@ async function runOrchestrator(options) {
     let report = await readReport(reportPath);
     let openIssues = [];
     const attemptedIssueFingerprints = /* @__PURE__ */ new Set();
+    const commentPrepassOutcome = await runExistingCommentPrepass({
+      options,
+      exec,
+      agentDriver,
+      repo: sessionRepo,
+      pr: meta.pr,
+      model,
+      effort,
+      reviewPath,
+      report,
+      reportPath,
+      branch: meta.branch,
+      branchPushRemote: normalizeBranchPushRemote(meta.branchPushRemote),
+      state,
+      setState: (nextState) => {
+        state = nextState;
+      }
+    });
+    report = commentPrepassOutcome.report;
+    state = commentPrepassOutcome.state;
+    for (const issue of commentPrepassOutcome.attemptedIssues) {
+      attemptedIssueFingerprints.add(issueFingerprint(issue));
+    }
     for (let round = 1; round <= meta.maxRounds; round += 1) {
       state = await updateStatus(options, state, {
         phase: "reviewing",
@@ -471,6 +528,162 @@ function dedupeReviewedIssues(reviewedIssues) {
   }
   return deduped;
 }
+async function runExistingCommentPrepass(input) {
+  if (!input.agentDriver.reviewExistingComments) {
+    return {
+      report: input.report,
+      state: input.state,
+      attemptedIssues: []
+    };
+  }
+  let state = await updateStatus(input.options, input.state, {
+    phase: "reviewing",
+    currentStatus: "Reviewing existing comments"
+  });
+  input.setState(state);
+  await appendEvent(input.options.mendrHome, input.options.reviewId, {
+    status: "Reviewing existing comments",
+    detail: "existing comment follow-up"
+  });
+  const diff = await fetchPullRequestDiff(input.exec, input.repo, input.pr);
+  const reviewMarkdown = await readFile(input.reviewPath, "utf8");
+  const ctx = buildContext({
+    repo: input.repo,
+    pr: input.pr,
+    model: input.model,
+    effort: input.effort,
+    diff,
+    reviewMarkdown,
+    reportMarkdown: input.report
+  });
+  let results = [];
+  try {
+    results = await input.agentDriver.reviewExistingComments(ctx);
+  } catch (error) {
+    await fail(input.options, state, "Existing comment review failed", error);
+  }
+  let report = input.report;
+  const attempts = [];
+  for (const result of results) {
+    if (result.status === "needs_fix" && result.issue) {
+      const attempt = {
+        issue: result.issue,
+        diff,
+        round: 0,
+        issueIndex: attempts.length + 1
+      };
+      attempts.push({ result, attempt });
+      await appendIssueRecord(input.options.mendrHome, input.options.reviewId, {
+        sessionId: input.options.reviewId,
+        round: 0,
+        issueIndex: attempt.issueIndex,
+        fingerprint: issueFingerprint(result.issue),
+        title: result.issue.title,
+        file: result.issue.file,
+        line: result.issue.line,
+        severity: result.issue.severity,
+        description: result.issue.description
+      });
+      continue;
+    }
+    if (result.status === "already_addressed" || result.status === "does_not_exist") {
+      report = appendExistingCommentFollowUp(report, {
+        status: result.status,
+        summary: result.summary
+      });
+    }
+  }
+  if (results.length > 0) {
+    await writeFile(input.reportPath, report, "utf8");
+  }
+  if (attempts.length === 0) {
+    return {
+      report,
+      state,
+      attemptedIssues: []
+    };
+  }
+  state = await updateStatus(input.options, state, {
+    phase: "fixing",
+    currentStatus: "Resolving existing comments",
+    issuesFound: state.issuesFound + attempts.length
+  });
+  input.setState(state);
+  await appendEvent(input.options.mendrHome, input.options.reviewId, {
+    status: "Resolving existing comments",
+    detail: `existing comment follow-up with ${attempts.length} issue${attempts.length === 1 ? "" : "s"}`
+  });
+  let fixedCount = 0;
+  let lastSuccessfulSha = await getHeadCommitSha(input.exec, input.repo);
+  for (const { result, attempt } of attempts) {
+    const outcome = await runSingleIssueFix({
+      options: input.options,
+      exec: input.exec,
+      agentDriver: input.agentDriver,
+      ctx: {
+        ...ctx,
+        diff: attempt.diff,
+        reportMarkdown: report
+      },
+      attempt,
+      lastSuccessfulSha,
+      state
+    });
+    if (outcome.status === "fixed" && outcome.sha) {
+      report = appendExistingCommentFollowUp(report, {
+        status: "fixed",
+        issue: attempt.issue,
+        sha: outcome.sha,
+        summary: outcome.summary
+      });
+    } else {
+      report = appendExistingCommentFollowUp(report, {
+        status: "fixer_failed",
+        issue: attempt.issue,
+        summary: outcome.summary
+      });
+    }
+    await appendFixAttempt(input.options.mendrHome, input.options.reviewId, {
+      sessionId: input.options.reviewId,
+      round: 0,
+      issueIndex: attempt.issueIndex,
+      fingerprint: issueFingerprint(attempt.issue),
+      title: attempt.issue.title,
+      status: outcome.status,
+      summary: outcome.summary,
+      ...outcome.sha ? { commitSha: outcome.sha } : {}
+    });
+    await writeFile(input.reportPath, report, "utf8");
+    if (outcome.status === "fixed" && outcome.sha) {
+      fixedCount += 1;
+      lastSuccessfulSha = outcome.sha;
+      state = await updateStatus(input.options, state, {
+        issuesFixed: state.issuesFixed + 1
+      });
+      input.setState(state);
+    } else {
+      await appendEvent(input.options.mendrHome, input.options.reviewId, {
+        status: "Fix failed",
+        detail: `${attempt.issue.title}: ${result.summary} ${outcome.summary}`
+      });
+    }
+  }
+  if (fixedCount > 0) {
+    try {
+      await pushWithRetry(input.exec, input.repo, input.branchPushRemote, input.branch);
+    } catch (error) {
+      const message = errorToMessage(error);
+      const failedReport = appendFailureNote(report, `push failed: ${message}`);
+      await writeFile(input.reportPath, failedReport, "utf8");
+      await fail(input.options, state, "Push failed", error);
+    }
+  }
+  return {
+    report,
+    state,
+    attemptedIssues: attempts.map(({ attempt }) => attempt.issue)
+  };
+}
 function splitDiffForReview(diff, maxLines = MAX_REVIEW_DIFF_LINES) {
   const normalized = diff.replace(/\r\n?/g, "\n");
   if (lineCount(normalized) <= maxLines) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@pepps233/mendr",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Autonomous pull request review agent CLI.",
   "type": "module",
   "bin": {
-    "mendr": "./dist/cli.js"
+    "mendr": "dist/cli.js"
   },
   "files": [
     "dist"