@pepps233/mendr 0.1.0 → 0.3.0

package/README.md

@@ -38,6 +38,7 @@ mendr ls
 mendr view <id>
 mendr stop <id>
 mendr kill <id>
+mendr version
 ```
 
 ![mendr](https://raw.githubusercontent.com/Pepps233/mendr/main/assets/mendr.gif)
@@ -50,6 +51,8 @@ mendr kill <id>
 Codex accepts `low`, `medium`, `high`, or `xhigh`.
 Claude Code accepts `low`, `medium`, `high`, `xhigh`, or `max`.
 Set `MENDR_CODEX_MODEL`, `MENDR_CODEX_EFFORT`, `MENDR_CLAUDE_MODEL`, or `MENDR_CLAUDE_EFFORT` to change unattended defaults.
+Run `mendr version` to check the installed package version against the latest npm release.
+When an interactive npm-installed `mendr` is behind the latest release, the first command for that installed/latest version pair prompts before continuing so you can upgrade with yes or no.
 
 ## Example
 

package/dist/{chunk-EGSZLVR6.js → chunk-3EH6IS7Z.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),
@@ -153,19 +162,6 @@ function issueFingerprint(issue) {
     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.");
@@ -201,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;
@@ -268,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.",
@@ -283,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.",
@@ -362,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)) {
@@ -372,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: [
@@ -412,7 +466,7 @@ function buildClaudeFixInvocation(issues, ctx) {
       "--add-dir",
       ctx.repo,
       "--append-system-prompt",
-      buildFixSystemPrompt()
+      systemPrompt
     ]
   };
 }
@@ -424,37 +478,31 @@ 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",
-    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
-    ]
-  };
+  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,
     args: [
       "exec",
-      prompt,
+      "-",
       "-m",
       ctx.model,
       "-c",
@@ -523,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);
@@ -556,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);
@@ -600,6 +673,7 @@ async function runAgentInvocation(exec, invocation, options) {
   const stderrFile = join(options.outputDir, `${options.label}.stderr.log`);
   const result = await exec(invocation.command, invocation.args, {
     cwd: options.cwd,
+    input: invocation.input,
     timeoutMs: agentTimeoutMs(),
     stdoutFile,
     stderrFile
@@ -1004,7 +1078,6 @@ async function readJson(home, id, fileName) {
 
 export {
   issueFingerprint,
-  dedupeIssues,
   defaultExec,
   execOk,
   defaultModelForAgent,

package/dist/cli.d.ts

@@ -41,6 +41,9 @@ type CliParseResult = {
 } | {
     ok: true;
     command: "ls";
+} | {
+    ok: true;
+    command: "version";
 } | {
     ok: true;
     command: "view" | "kill" | "stop";

package/dist/cli.js

@@ -26,17 +26,298 @@ import {
   worktreesDir,
   writeMeta,
   writeState
-} from "./chunk-EGSZLVR6.js";
+} from "./chunk-3EH6IS7Z.js";
 
 // src/cli.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { realpathSync } from "fs";
-import { mkdir, readdir } from "fs/promises";
+import { mkdir as mkdir2, readdir } from "fs/promises";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 import { Box, Text, render, useApp, useInput, useStdin } from "ink";
 import Spinner from "ink-spinner";
 import React, { useEffect, useState } from "react";
+
+// src/version.ts
+import { spawn } from "child_process";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { createRequire } from "module";
+import { join } from "path";
+import { createInterface } from "readline/promises";
+var require2 = createRequire(import.meta.url);
+var manifest = require2("../package.json");
+var promptStateFile = "version-check.json";
+var mendrPackageName = manifest.name;
+var mendrVersion = manifest.version;
+async function getMendrVersionStatus(options = {}) {
+  const packageName = options.packageName ?? mendrPackageName;
+  const currentVersion = options.currentVersion ?? mendrVersion;
+  try {
+    const latestVersion = await (options.fetchLatestVersion ?? fetchLatestPackageVersion)(
+      packageName
+    );
+    return {
+      packageName,
+      currentVersion,
+      latestVersion,
+      isOutdated: compareNpmVersions(currentVersion, latestVersion) < 0
+    };
+  } catch (error) {
+    return {
+      packageName,
+      currentVersion,
+      isOutdated: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatMendrVersionStatus(status) {
+  const lines = [`Installed: ${status.packageName}@${status.currentVersion}`];
+  if (status.latestVersion) {
+    lines.push(`Latest: ${status.latestVersion}`);
+    lines.push(status.isOutdated ? "Status: update available" : "Status: up to date");
+    return lines.join("\n");
+  }
+  lines.push("Latest: unavailable");
+  if (status.error) {
+    lines.push(`Status: unable to check npm registry (${status.error})`);
+  }
+  return lines.join("\n");
+}
+async function maybePromptForMendrUpgrade(options = {}) {
+  const env = options.env ?? process.env;
+  if (isUpdateCheckDisabled(env)) {
+    return;
+  }
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stderr;
+  if (!isInteractive(input, output)) {
+    return;
+  }
+  const packageName = options.packageName ?? mendrPackageName;
+  const currentVersion = options.currentVersion ?? mendrVersion;
+  const status = await getMendrVersionStatus({
+    packageName,
+    currentVersion,
+    fetchLatestVersion: options.fetchLatestVersion
+  });
+  if (!status.latestVersion || !status.isOutdated) {
+    return;
+  }
+  const mendrHome = options.mendrHome ?? defaultMendrHome(env);
+  const existingState = await readPromptState(mendrHome);
+  if (existingState?.currentVersion === currentVersion && existingState.latestVersion === status.latestVersion) {
+    return;
+  }
+  const askForUpgrade = options.askForUpgrade ?? ((context) => askYesNoUpgrade({
+    ...context,
+    input,
+    output
+  }));
+  const shouldUpgrade = await askForUpgrade({
+    packageName,
+    currentVersion,
+    latestVersion: status.latestVersion
+  });
+  if (!shouldUpgrade) {
+    await writePromptState(mendrHome, {
+      currentVersion,
+      latestVersion: status.latestVersion,
+      response: "declined",
+      promptedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+    });
+    return;
+  }
+  try {
+    await (options.installLatestPackage ?? installLatestPackage)(packageName);
+    await writePromptState(mendrHome, {
+      currentVersion,
+      latestVersion: status.latestVersion,
+      response: "accepted",
+      promptedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+    });
+  } catch (error) {
+    output.write(
+      `Upgrade failed: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    output.write(`Continuing with ${packageName}@${currentVersion}.
+`);
+  }
+}
+async function fetchLatestPackageVersion(packageName, options = {}) {
+  const fetchFn = options.fetch ?? fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 2e3);
+  try {
+    const response = await fetchFn(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      {
+        headers: {
+          accept: "application/vnd.npm.install-v1+json, application/json"
+        },
+        signal: controller.signal
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`npm registry returned HTTP ${response.status}`);
+    }
+    const metadata = await response.json();
+    const latest = metadata["dist-tags"]?.latest;
+    if (typeof latest !== "string" || latest.length === 0) {
+      throw new Error("npm registry response did not include dist-tags.latest");
+    }
+    return latest;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function installLatestPackage(packageName) {
+  const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+  await new Promise((resolve, reject) => {
+    const child = spawn(npmCommand, ["install", "-g", `${packageName}@latest`], {
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(
+        new Error(
+          signal ? `npm install -g ${packageName}@latest stopped with ${signal}` : `npm install -g ${packageName}@latest exited with code ${code ?? 1}`
+        )
+      );
+    });
+  });
+}
+function compareNpmVersions(left, right) {
+  const leftParts = parseSemver(left);
+  const rightParts = parseSemver(right);
+  if (!leftParts || !rightParts) {
+    return left.localeCompare(right);
+  }
+  const length = Math.max(leftParts.main.length, rightParts.main.length);
+  for (let index = 0; index < length; index += 1) {
+    const diff = (leftParts.main[index] ?? 0) - (rightParts.main[index] ?? 0);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return comparePrerelease(leftParts.prerelease, rightParts.prerelease);
+}
+async function askYesNoUpgrade(input) {
+  const prompt = `${input.packageName} ${input.latestVersion} is available (installed ${input.currentVersion}). Upgrade now? [y/n] `;
+  const readline = createInterface({
+    input: input.input,
+    output: input.output,
+    terminal: true
+  });
+  try {
+    for (; ; ) {
+      const answer = (await readline.question(prompt)).trim().toLowerCase();
+      if (answer === "y" || answer === "yes") {
+        return true;
+      }
+      if (answer === "n" || answer === "no") {
+        return false;
+      }
+      input.output.write("Please answer yes or no.\n");
+    }
+  } finally {
+    readline.close();
+  }
+}
+async function readPromptState(mendrHome) {
+  try {
+    const raw = await readFile(promptStatePath(mendrHome), "utf8");
+    const state = JSON.parse(raw);
+    if (typeof state.currentVersion !== "string" || typeof state.latestVersion !== "string" || state.response !== "accepted" && state.response !== "declined" || typeof state.promptedAt !== "string") {
+      return void 0;
+    }
+    return state;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    return void 0;
+  }
+}
+async function writePromptState(mendrHome, state) {
+  await mkdir(mendrHome, { recursive: true });
+  await writeFile(promptStatePath(mendrHome), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+function promptStatePath(mendrHome) {
+  return join(mendrHome, promptStateFile);
+}
+function isUpdateCheckDisabled(env) {
+  return env.CI === "true" || env.MENDR_SKIP_UPDATE_CHECK === "1";
+}
+function isInteractive(input, output) {
+  return input.isTTY === true && output.isTTY === true;
+}
+function parseSemver(version) {
+  const withoutBuildMetadata = version.replace(/^v/, "").split("+", 1)[0];
+  const [mainVersion, prereleaseVersion = ""] = withoutBuildMetadata.split("-", 2);
+  const main2 = mainVersion.split(".").map((part) => {
+    if (!/^\d+$/.test(part)) {
+      return Number.NaN;
+    }
+    return Number(part);
+  });
+  if (main2.length === 0 || main2.some((part) => !Number.isSafeInteger(part))) {
+    return void 0;
+  }
+  return {
+    main: main2,
+    prerelease: prereleaseVersion.length > 0 ? prereleaseVersion.split(".") : []
+  };
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 && right.length === 0) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return 1;
+  }
+  if (right.length === 0) {
+    return -1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === void 0) {
+      return -1;
+    }
+    if (rightPart === void 0) {
+      return 1;
+    }
+    const comparison = comparePrereleasePart(leftPart, rightPart);
+    if (comparison !== 0) {
+      return comparison;
+    }
+  }
+  return 0;
+}
+function comparePrereleasePart(left, right) {
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+  if (leftNumeric && rightNumeric) {
+    return Number(left) - Number(right);
+  }
+  if (leftNumeric) {
+    return -1;
+  }
+  if (rightNumeric) {
+    return 1;
+  }
+  return left.localeCompare(right);
+}
+
+// src/cli.ts
 var agents = /* @__PURE__ */ new Set(["claude", "codex"]);
 function parseCliArgs(argv) {
   const args = argv.slice(2);
@@ -46,6 +327,12 @@ function parseCliArgs(argv) {
       command: "ls"
     };
   }
+  if (args[0] === "version" || args[0] === "--version" || args[0] === "-V") {
+    return {
+      ok: true,
+      command: "version"
+    };
+  }
   if (args[0] === "view" || args[0] === "kill" || args[0] === "stop") {
     const reviewId = args[1];
     if (!reviewId) {
@@ -134,7 +421,7 @@ async function startReview(options) {
   };
   let worktreeCreated = false;
   try {
-    await mkdir(worktreesDir(mendrHome), { recursive: true });
+    await mkdir2(worktreesDir(mendrHome), { recursive: true });
     await fetchPullRequestHeadRef(exec, repo, options.pr, worktreeRef);
     await createDetachedWorktree(exec, repo, worktreePath, worktreeRef);
     worktreeCreated = true;
@@ -477,7 +764,7 @@ async function assertBinary(exec, command, args, cwd) {
 }
 function defaultSpawnDaemon(args) {
   const daemonPath = fileURLToPath(new URL("./daemon.js", import.meta.url));
-  const child = spawn(
+  const child = spawn2(
     process.execPath,
     [daemonPath, "--home", args.mendrHome, "--id", args.reviewId],
     {
@@ -496,7 +783,7 @@ async function createReviewId(mendrHome) {
   for (; ; ) {
     const id = String(candidate);
     try {
-      await mkdir(reviewDir(mendrHome, id));
+      await mkdir2(reviewDir(mendrHome, id));
       return id;
     } catch (error) {
       if (error.code === "EEXIST") {
@@ -633,7 +920,7 @@ function parsePositiveInteger(value) {
 }
 async function main(argv) {
   const program = new Command();
-  program.name("mendr").description("Run an autonomous agentic review loop on a GitHub pull request.").argument("[agent]", "agent CLI to use: claude or codex").argument("[pr]", "pull request number or GitHub pull request URL").option("-r, --rounds <n>", "maximum review and fix iterations", "3").option("-m, --model <model>", "agent model override").option("-e, --effort <effort>", "agent effort override").action(
+  program.name("mendr").version(mendrVersion).description("Run an autonomous agentic review loop on a GitHub pull request.").argument("[agent]", "agent CLI to use: claude or codex").argument("[pr]", "pull request number or GitHub pull request URL").option("-r, --rounds <n>", "maximum review and fix iterations", "3").option("-m, --model <model>", "agent model override").option("-e, --effort <effort>", "agent effort override").action(
     async (agent, prArg, options) => {
       if (!agent && !prArg) {
         program.help();
@@ -673,6 +960,9 @@ async function main(argv) {
   program.command("ls").description("List review sessions.").action(async () => {
     console.log(await renderReviewList());
   });
+  program.command("version").description("Check the installed mendr version.").action(async () => {
+    console.log(formatMendrVersionStatus(await getMendrVersionStatus()));
+  });
   program.command("view").description("Watch a live review status view.").argument("<id>", "review id").action(async (reviewId) => {
     await startLiveReviewView({ reviewId });
   });
@@ -684,6 +974,9 @@ async function main(argv) {
     await closeReview({ reviewId });
     console.log(`Killed ${reviewId}`);
   });
+  program.hook("preAction", async () => {
+    await maybePromptForMendrUpgrade();
+  });
   await program.parseAsync(argv);
 }
 function isCliEntrypoint(invokedPath, modulePath = fileURLToPath(import.meta.url)) {

package/dist/daemon.js

@@ -5,7 +5,6 @@ import {
   appendIssueRecord,
   commitStaged,
   createAgentDriver,
-  dedupeIssues,
   defaultEffortForAgent,
   defaultExec,
   defaultMendrHome,
@@ -29,7 +28,7 @@ import {
   stageAll,
   waitForPullRequestChecks,
   writeState
-} from "./chunk-EGSZLVR6.js";
+} from "./chunk-3EH6IS7Z.js";
 
 // src/orchestrator.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -40,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";
@@ -66,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}`;
@@ -105,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) {
@@ -266,6 +299,7 @@ var PullRequestHeadChangedError = class extends Error {
 };
 var PR_HEAD_PROPAGATION_TIMEOUT_MS = 3e4;
 var PR_HEAD_PROPAGATION_POLL_MS = 2e3;
+var MAX_REVIEW_DIFF_LINES = 4e3;
 async function runOrchestrator(options) {
   const exec = options.exec ?? defaultExec;
   const dir = reviewDir(options.mendrHome, options.reviewId);
@@ -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",
@@ -317,13 +374,14 @@ async function runOrchestrator(options) {
         reviewMarkdown,
         reportMarkdown: report
       });
-      let issues = [];
+      let reviewedIssues = [];
       try {
-        issues = dedupeIssues(await agentDriver.review(ctx));
+        reviewedIssues = await reviewDiffChunks(agentDriver, ctx);
       } catch (error) {
         await fail(options, state, "Review failed", error);
         return;
       }
+      const issues = reviewedIssues.map((entry) => entry.issue);
       await persistIssueRecords(options, round, issues);
       state = await updateStatus(options, state, {
         issuesFound: state.issuesFound + issues.length
@@ -337,8 +395,9 @@ async function runOrchestrator(options) {
         break;
       }
       openIssues = issues;
-      const issueAttempts = issues.map((issue, index) => ({
-        issue,
+      const issueAttempts = reviewedIssues.map((entry, index) => ({
+        issue: entry.issue,
+        diff: entry.diff,
         round,
         issueIndex: index + 1
       }));
@@ -440,6 +499,375 @@ async function runOrchestrator(options) {
     await fail(options, state, "Orchestrator failed", error);
   }
 }
+async function reviewDiffChunks(agentDriver, ctx) {
+  const reviewedIssues = [];
+  for (const diff of splitDiffForReview(ctx.diff)) {
+    const issues = await agentDriver.review({
+      ...ctx,
+      diff
+    });
+    for (const issue of issues) {
+      reviewedIssues.push({
+        issue,
+        diff
+      });
+    }
+  }
+  return dedupeReviewedIssues(reviewedIssues);
+}
+function dedupeReviewedIssues(reviewedIssues) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of reviewedIssues) {
+    const fingerprint = issueFingerprint(entry.issue);
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    deduped.push(entry);
+  }
+  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) {
+    return [normalized];
+  }
+  const chunks = [];
+  let currentChunk = [];
+  for (const fileBlock of splitDiffFileBlocks(normalized.split("\n"))) {
+    const boundedBlocks = fileBlock.length > maxLines ? splitOversizedFileBlock(fileBlock, maxLines) : [fileBlock];
+    for (const block of boundedBlocks) {
+      for (const boundedBlock of splitRawLines(block, maxLines)) {
+        if (currentChunk.length > 0 && currentChunk.length + boundedBlock.length > maxLines) {
+          chunks.push(currentChunk);
+          currentChunk = [];
+        }
+        currentChunk.push(...boundedBlock);
+      }
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks.map((chunk) => chunk.join("\n"));
+}
+function splitDiffFileBlocks(lines) {
+  const blocks = [];
+  let currentBlock = [];
+  for (const line of lines) {
+    if (line.startsWith("diff --git ") && currentBlock.length > 0) {
+      blocks.push(currentBlock);
+      currentBlock = [];
+    }
+    currentBlock.push(line);
+  }
+  if (currentBlock.length > 0) {
+    blocks.push(currentBlock);
+  }
+  return blocks;
+}
+function splitOversizedFileBlock(block, maxLines) {
+  const firstHunkIndex = block.findIndex((line) => line.startsWith("@@"));
+  if (firstHunkIndex === -1) {
+    return splitRawLines(block, maxLines);
+  }
+  const header = block.slice(0, firstHunkIndex);
+  const hunks = splitHunks(block.slice(firstHunkIndex));
+  const chunks = [];
+  let currentChunk = [...header];
+  for (const hunk of hunks) {
+    if (header.length + hunk.length > maxLines) {
+      if (currentChunk.length > header.length) {
+        chunks.push(currentChunk);
+        currentChunk = [...header];
+      }
+      chunks.push(...splitOversizedHunk(header, hunk, maxLines));
+      continue;
+    }
+    if (currentChunk.length + hunk.length > maxLines) {
+      chunks.push(currentChunk);
+      currentChunk = [...header];
+    }
+    currentChunk.push(...hunk);
+  }
+  if (currentChunk.length > header.length) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+function splitHunks(lines) {
+  const hunks = [];
+  let currentHunk = [];
+  for (const line of lines) {
+    if (line.startsWith("@@") && currentHunk.length > 0) {
+      hunks.push(currentHunk);
+      currentHunk = [];
+    }
+    currentHunk.push(line);
+  }
+  if (currentHunk.length > 0) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+function splitOversizedHunk(header, hunk, maxLines) {
+  const parsedHeader = parseHunkHeader(hunk[0]);
+  if (!parsedHeader) {
+    const hunkHeader = hunk[0]?.startsWith("@@") ? [hunk[0]] : [];
+    const body2 = hunkHeader.length > 0 ? hunk.slice(1) : hunk;
+    const prefix = [...header, ...hunkHeader];
+    const bodyCapacity2 = maxLines - prefix.length;
+    if (bodyCapacity2 <= 0) {
+      return splitRawLines([...prefix, ...body2], maxLines);
+    }
+    if (body2.length === 0) {
+      return [prefix];
+    }
+    const chunks2 = [];
+    for (let index = 0; index < body2.length; index += bodyCapacity2) {
+      chunks2.push([...prefix, ...body2.slice(index, index + bodyCapacity2)]);
+    }
+    return chunks2;
+  }
+  const body = hunk.slice(1);
+  const bodyCapacity = maxLines - header.length - 1;
+  if (bodyCapacity <= 0) {
+    return splitRawLines([...header, hunk[0], ...body], maxLines);
+  }
+  if (body.length === 0) {
+    return [[...header, hunk[0]]];
+  }
+  const chunks = [];
+  let oldCursor = parsedHeader.oldStart;
+  let newCursor = parsedHeader.newStart;
+  let oldAnchor = initialHunkAnchor(parsedHeader.oldStart, parsedHeader.oldCount);
+  let newAnchor = initialHunkAnchor(parsedHeader.newStart, parsedHeader.newCount);
+  for (let index = 0; index < body.length; index += bodyCapacity) {
+    const bodySlice = body.slice(index, index + bodyCapacity);
+    const oldCount = countHunkLines(bodySlice, "old");
+    const newCount = countHunkLines(bodySlice, "new");
+    const hunkHeader = formatHunkHeader(parsedHeader, {
+      oldStart: hunkRangeStart(oldCursor, oldAnchor, oldCount),
+      oldCount,
+      newStart: hunkRangeStart(newCursor, newAnchor, newCount),
+      newCount
+    });
+    chunks.push([...header, hunkHeader, ...bodySlice]);
+    if (oldCount > 0) {
+      oldAnchor = oldCursor + oldCount - 1;
+      oldCursor += oldCount;
+    }
+    if (newCount > 0) {
+      newAnchor = newCursor + newCount - 1;
+      newCursor += newCount;
+    }
+  }
+  return chunks;
+}
+function parseHunkHeader(line) {
+  const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(
+    line ?? ""
+  );
+  if (!match) {
+    return void 0;
+  }
+  return {
+    oldStart: Number(match[1]),
+    oldCount: match[2] === void 0 ? 1 : Number(match[2]),
+    newStart: Number(match[3]),
+    newCount: match[4] === void 0 ? 1 : Number(match[4]),
+    section: match[5]
+  };
+}
+function formatHunkHeader(parsedHeader, range) {
+  return [
+    `@@ -${range.oldStart},${range.oldCount}`,
+    `+${range.newStart},${range.newCount}`,
+    `@@${parsedHeader.section}`
+  ].join(" ");
+}
+function initialHunkAnchor(start, count) {
+  return count === 0 ? start : Math.max(0, start - 1);
+}
+function hunkRangeStart(cursor, anchor, count) {
+  return count === 0 ? anchor : cursor;
+}
+function countHunkLines(lines, side) {
+  return lines.filter((line) => {
+    const prefix = line[0];
+    if (prefix === " ") {
+      return true;
+    }
+    return side === "old" ? prefix === "-" : prefix === "+";
+  }).length;
+}
+function splitRawLines(lines, maxLines) {
+  const chunks = [];
+  for (let index = 0; index < lines.length; index += maxLines) {
+    chunks.push(lines.slice(index, index + maxLines));
+  }
+  return chunks;
+}
+function lineCount(text) {
+  return text.length === 0 ? 0 : text.split("\n").length;
+}
 async function runFixRound(input) {
   let report = input.report;
   let fixedCount = 0;
@@ -450,6 +878,7 @@ async function runFixRound(input) {
       ...input,
       ctx: {
         ...input.ctx,
+        diff: attempt.diff,
         reportMarkdown: report
       },
       attempt,
@@ -610,129 +1039,23 @@ function validateCommitMessage(message) {
       reason: "commit messages must not contain NUL bytes"
     };
   }
-  const forbiddenReason = forbiddenCommitMessageReason(normalized);
-  if (forbiddenReason) {
-    return {
-      valid: false,
-      reason: forbiddenReason
-    };
-  }
-  const lines = normalized.split("\n");
-  if (lines.length !== 4) {
-    return {
-      valid: false,
-      reason: "commit messages must contain a subject, a blank line, and exactly two bullet lines"
-    };
-  }
-  if (lines[1] !== "") {
-    return {
-      valid: false,
-      reason: "commit messages must separate the subject from the body with a blank line"
-    };
-  }
-  const subject = parseCommitSubject(lines[0]);
-  if (!subject) {
-    return {
-      valid: false,
-      reason: "commit message subjects must match <type>(<scope>): <short imperative summary>"
-    };
-  }
-  if (subject.summary.endsWith(".")) {
+  const sanitized = removeCoAuthorLines(normalized).trim();
+  if (!sanitized) {
     return {
       valid: false,
-      reason: "commit message summaries must not end with a period"
-    };
-  }
-  if (looksNonImperative(subject.summary)) {
-    return {
-      valid: false,
-      reason: "commit message summaries must be imperative"
-    };
-  }
-  if (!lines[2].startsWith("- ") || lines[2].trim() === "-") {
-    return {
-      valid: false,
-      reason: "commit message bodies must use a non-empty first bullet"
-    };
-  }
-  if (!lines[3].startsWith("- ") || lines[3].trim() === "-") {
-    return {
-      valid: false,
-      reason: "commit message bodies must use a non-empty second bullet"
+      reason: "the fixer did not provide a commit message after unsupported trailers were removed"
     };
   }
   return {
     valid: true,
-    message: normalized
+    message: sanitized
   };
 }
 function invalidCommitMessageSummary(reason) {
   return `The fixer reported this issue as fixed, but its commit message is invalid: ${reason}. Manual follow-up is required before Mendr can safely record and push the fix.`;
 }
-function forbiddenCommitMessageReason(message) {
-  const lines = message.split("\n");
-  if (lines.some((line) => /^co-authored-by\s*:/i.test(line.trim()))) {
-    return "commit messages must not include co-author lines";
-  }
-  if (/\b(?:ai|a\.i\.|openai|chatgpt|claude|anthropic|codex|providers?)\b/i.test(message)) {
-    return "commit messages must not include AI or provider references";
-  }
-  return void 0;
-}
-function parseCommitSubject(line) {
-  const match = /^([a-z][a-z0-9-]*)\(([a-z0-9._/-]+)\): ([A-Za-z][^\n]*)$/.exec(line);
-  if (!match) {
-    return void 0;
-  }
-  const [, type, scope, summary] = match;
-  if (!summary.trim()) {
-    return void 0;
-  }
-  return {
-    type,
-    scope,
-    summary
-  };
-}
-function looksNonImperative(summary) {
-  const firstWord = summary.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
-  return [
-    "added",
-    "adding",
-    "adds",
-    "changed",
-    "changing",
-    "changes",
-    "created",
-    "creating",
-    "creates",
-    "fixed",
-    "fixing",
-    "fixes",
-    "handled",
-    "handling",
-    "handles",
-    "made",
-    "makes",
-    "prevented",
-    "preventing",
-    "prevents",
-    "recorded",
-    "recording",
-    "records",
-    "rejected",
-    "rejecting",
-    "rejects",
-    "updated",
-    "updating",
-    "updates",
-    "used",
-    "using",
-    "uses",
-    "validated",
-    "validating",
-    "validates"
-  ].includes(firstWord);
+function removeCoAuthorLines(message) {
+  return message.split("\n").filter((line) => !/^co-authored-by\s*:/i.test(line.trim())).join("\n");
 }
 async function pushWithRetry(exec, repo, remote, branch) {
   try {

package/package.json

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