@pepps233/mendr 0.1.0 → 0.2.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-753PEKBT.js}

@@ -153,19 +153,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.");
@@ -431,9 +418,10 @@ function buildCodexReviewInvocation(ctx, options) {
   const prompt = buildReviewPrompt(ctx);
   return {
     command: "codex",
+    input: prompt,
     args: [
       "exec",
-      prompt,
+      "-",
       "-m",
       ctx.model,
       "-c",
@@ -452,9 +440,10 @@ function buildCodexFixInvocation(issues, ctx, options) {
   const prompt = buildFixPrompt(issues, ctx);
   return {
     command: "codex",
+    input: prompt,
     args: [
       "exec",
-      prompt,
+      "-",
       "-m",
       ctx.model,
       "-c",
@@ -600,6 +589,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 +994,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-753PEKBT.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-753PEKBT.js";
 
 // src/orchestrator.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -266,6 +265,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);
@@ -317,13 +317,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 +338,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 +442,219 @@ 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;
+}
+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 +665,7 @@ async function runFixRound(input) {
       ...input,
       ctx: {
         ...input.ctx,
+        diff: attempt.diff,
         reportMarkdown: report
       },
       attempt,
@@ -610,129 +826,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) {
+  const sanitized = removeCoAuthorLines(normalized).trim();
+  if (!sanitized) {
     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(".")) {
-    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,6 +1,6 @@
 {
   "name": "@pepps233/mendr",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Autonomous pull request review agent CLI.",
   "type": "module",
   "bin": {