@codraoss/core 0.9.4

package/dist/chunk-XD6CGYHO.js

@@ -0,0 +1,893 @@
+import {
+  generatorFindingCap
+} from "./chunk-MMVQPGK3.js";
+import {
+  renderDiffSnippet
+} from "./chunk-V3RF6GQW.js";
+import {
+  MAX_LOGGED_JSON_CHARS,
+  MIN_DISCRIMINATING_EVIDENCE_CHARS,
+  NON_ANSWER_MAX_RESPONSE_CHARS,
+  NON_ANSWER_MIN_DIFF_LINES,
+  SEVERITY_ORDER
+} from "./chunk-FGXA7JNR.js";
+import {
+  buildPresenceIndex,
+  checkAbsenceClaim,
+  isVersionClaimRefutedByPin,
+  looksLikeExternalVersionClaim,
+  refuteUndecidableClaim
+} from "./chunk-U3VKVDZ7.js";
+import {
+  buildAnchorHash,
+  buildFindingFingerprint,
+  buildFindingFingerprintV2,
+  foldEvidenceText,
+  normalizeFindingTitle
+} from "./chunk-NSTV4TRP.js";
+import {
+  logger
+} from "./chunk-WSK45HW4.js";
+import {
+  findPositionForLine,
+  getValidPositions
+} from "./chunk-OIQRTDYR.js";
+
+// src/model-output/index.ts
+import {
+  parsedReviewCommentSchema,
+  toClaimType,
+  CLAIM_TYPE_CATEGORY
+} from "@codraoss/schema";
+import { z as z3 } from "zod";
+
+// src/model-output/json.ts
+import { fileReviewModelOutputSchema } from "@codraoss/schema";
+import { jsonrepair } from "jsonrepair";
+import "zod";
+function truncateJsonForLog(value) {
+  if (value.length <= MAX_LOGGED_JSON_CHARS) return value;
+  return `${value.slice(0, MAX_LOGGED_JSON_CHARS)}... [truncated ${value.length - MAX_LOGGED_JSON_CHARS} chars]`;
+}
+function hasReviewKeys(input) {
+  return /"(files|findings|overall_explanation|overall_correctness|overall_confidence_score|summary)"\s*:/.test(input);
+}
+function scanBalanced(raw, startIdx, open, close) {
+  let stack = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = startIdx; i < raw.length; i++) {
+    const char = raw[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === open) stack++;
+    else if (char === close) {
+      stack--;
+      if (stack === 0) return raw.slice(startIdx, i + 1);
+    }
+  }
+  return null;
+}
+function extractJson(raw, anchorKey = "findings") {
+  const jsonBlocks = Array.from(raw.matchAll(/```json([\s\S]*?)```/gi));
+  if (jsonBlocks.length > 0) {
+    return jsonBlocks[jsonBlocks.length - 1][1].trim();
+  }
+  const genericBlocks = Array.from(raw.matchAll(/```(?:[\w+-]+)?([\s\S]*?)```/gi));
+  if (genericBlocks.length > 0) {
+    const candidates = genericBlocks.filter((b) => b[1].includes("{") && b[1].includes("}") && hasReviewKeys(b[1]));
+    if (candidates.length > 0) {
+      const content = candidates[candidates.length - 1][1].trim();
+      const start = content.indexOf("{");
+      const end = content.lastIndexOf("}");
+      if (start !== -1 && end !== -1 && end > start) {
+        return content.slice(start, end + 1);
+      }
+      return content;
+    }
+  }
+  const arrayStart = raw.indexOf("[");
+  if (arrayStart !== -1 && raw.slice(0, arrayStart).trim() === "") {
+    const matched = scanBalanced(raw, arrayStart, "[", "]");
+    if (matched && hasReviewKeys(matched)) return matched;
+  }
+  const anchorIdx = anchorKey === "files" ? raw.indexOf('"files"') : -1;
+  const findingsIdx = anchorIdx !== -1 ? anchorIdx : raw.indexOf('"findings"');
+  const summaryIdx = raw.indexOf('"summary"');
+  const targetIdx = findingsIdx !== -1 ? findingsIdx : summaryIdx !== -1 ? summaryIdx : -1;
+  let firstBrace = -1;
+  if (targetIdx !== -1) {
+    firstBrace = raw.lastIndexOf("{", targetIdx);
+  }
+  if (firstBrace === -1) {
+    const allBraces = Array.from(raw.matchAll(/\{/g));
+    let bestIdx = -1;
+    let bestScore = -1;
+    for (const match of allBraces) {
+      const idx = match.index;
+      const excerpt = raw.slice(idx, idx + 200);
+      let score = 0;
+      if (excerpt.includes('"files"')) score += 100;
+      if (excerpt.includes('"findings"')) score += 100;
+      if (excerpt.includes('"summary"')) score += 50;
+      if (excerpt.includes('"overall_explanation"')) score += 50;
+      if (excerpt.includes('" : ') || excerpt.includes('":')) score += 10;
+      if (excerpt.includes('"[')) score += 5;
+      if (excerpt.includes(": number;") || excerpt.includes(": string;")) score -= 80;
+      if (excerpt.includes("export ") || excerpt.includes("function ")) score -= 80;
+      if (excerpt.includes("interface ") || excerpt.includes("type ")) score -= 80;
+      if (excerpt.includes(" + ")) score -= 20;
+      if (score > bestScore) {
+        bestScore = score;
+        bestIdx = idx;
+      }
+    }
+    if (bestIdx !== -1 && bestScore > 0) {
+      firstBrace = bestIdx;
+    }
+  }
+  if (firstBrace === -1) {
+    const start = raw.indexOf("{");
+    if (start !== -1) {
+      const excerpt = raw.slice(start, start + 50);
+      if (excerpt.includes('"') && excerpt.includes(":")) {
+        firstBrace = start;
+      }
+    }
+  }
+  if (firstBrace !== -1) {
+    let stack = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = firstBrace; i < raw.length; i++) {
+      const char = raw[i];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (char === "\\") {
+        escape = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (!inString) {
+        if (char === "{") stack++;
+        else if (char === "}") {
+          stack--;
+          if (stack === 0) {
+            return raw.slice(firstBrace, i + 1);
+          }
+        }
+      }
+    }
+    const partial = raw.slice(firstBrace).trim();
+    let closing = "";
+    if (inString) closing += '"';
+    closing += "}".repeat(Math.max(1, stack));
+    return `${partial}${closing}`;
+  }
+  return raw.trim();
+}
+function preprocessJson(json) {
+  let result = "";
+  let inString = false;
+  let escape = false;
+  for (let i = 0; i < json.length; i++) {
+    const char = json[i];
+    if (escape) {
+      result += char;
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      result += char;
+      escape = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      result += char;
+      continue;
+    }
+    if (inString) {
+      if (char === "\n") {
+        result += "\\n";
+      } else if (char === "\r") {
+        result += "\\r";
+      } else {
+        result += char;
+      }
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function stripNulls(value) {
+  if (Array.isArray(value)) return value.map(stripNulls);
+  if (value === null || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === null) continue;
+    out[key] = stripNulls(entry);
+  }
+  return out;
+}
+function isPlaceholderString(value) {
+  return typeof value === "string" && /^<[^>]+>$/.test(value.trim());
+}
+function coerceReviewNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && !isPlaceholderString(value)) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function normalizeFinding(finding) {
+  if (!finding || typeof finding !== "object") return null;
+  const f = finding;
+  if (isPlaceholderString(f.title) || isPlaceholderString(f.body) || isPlaceholderString(f.evidence)) return null;
+  const location = f.code_location && typeof f.code_location === "object" ? f.code_location : {};
+  const line = coerceReviewNumber(location.line);
+  const start = coerceReviewNumber(location.line_range && typeof location.line_range === "object" ? location.line_range.start : void 0);
+  const end = coerceReviewNumber(location.line_range && typeof location.line_range === "object" ? location.line_range.end : void 0);
+  const priority = coerceReviewNumber(f.priority);
+  const codeLocation = {
+    absolute_file_path: location.absolute_file_path || f.path || ""
+  };
+  if (line !== void 0) {
+    codeLocation.line = Math.trunc(line);
+  }
+  if (start !== void 0 || end !== void 0) {
+    codeLocation.line_range = {
+      start: Math.trunc(start ?? end),
+      end: Math.trunc(end ?? start)
+    };
+  }
+  return {
+    ...f,
+    title: (f.title ? String(f.title) : "").trim().slice(0, 100).replace(/[\uD800-\uDBFF]$/, "") || "Code finding",
+    priority: priority === void 0 ? void 0 : Math.max(0, Math.min(4, Math.trunc(priority))),
+    code_location: codeLocation,
+    confidence_score: typeof f.confidence_score === "number" ? Math.max(0, Math.min(1, f.confidence_score > 1 ? f.confidence_score / 10 : f.confidence_score)) : void 0
+  };
+}
+function parseRawPayload(raw) {
+  let extracted;
+  try {
+    extracted = extractJson(raw);
+    if (!hasReviewKeys(extracted)) {
+      throw new Error("Model response did not contain review JSON keys.");
+    }
+  } catch (e) {
+    logger.error("Failed to extract JSON from model response", {
+      rawLength: raw.length,
+      rawPrefix: raw.slice(0, 500),
+      error: e instanceof Error ? e.message : String(e)
+    });
+    throw new Error("Could not find JSON root in model response.", { cause: e });
+  }
+  let preprocessed;
+  try {
+    preprocessed = preprocessJson(extracted);
+  } catch (e) {
+    logger.warn("JSON preprocessing partially failed, continuing...", { extracted, error: e });
+    preprocessed = extracted;
+  }
+  let repaired = preprocessed;
+  try {
+    repaired = jsonrepair(preprocessed);
+  } catch (e) {
+    logger.warn("jsonrepair failed to fix model output, using preprocessed text", { preprocessed: truncateJsonForLog(preprocessed), error: e });
+  }
+  let parsedJson;
+  try {
+    parsedJson = stripNulls(JSON.parse(repaired));
+  } catch (e) {
+    logger.error("Critical JSON parse error after extraction and repair", { repaired: truncateJsonForLog(repaired), error: e });
+    throw new Error(`Invalid JSON format: ${e instanceof Error ? e.message : "Unknown error"}`, { cause: e });
+  }
+  try {
+    const findReviewObject = (arr) => {
+      const best = arr.find((i) => i && typeof i === "object" && Array.isArray(i.findings) && typeof i.summary === "string");
+      if (best) return best;
+      const good = arr.find((i) => i && typeof i === "object" && Array.isArray(i.findings));
+      if (good) return good;
+      return arr.find(
+        (i) => i && typeof i === "object" && ("findings" in i || "overall_explanation" in i || "summary" in i || "overall_correctness" in i)
+      );
+    };
+    let data = Array.isArray(parsedJson) ? findReviewObject(parsedJson) || parsedJson[0] || {} : parsedJson;
+    if (data && typeof data === "object") {
+      const obj = data;
+      if (!obj.findings) obj.findings = [];
+      if (!obj.overall_explanation) obj.overall_explanation = "No explanation provided.";
+      if (!obj.overall_correctness) obj.overall_correctness = "Uncertain";
+      if (typeof obj.overall_confidence_score === "number") {
+        if (obj.overall_confidence_score > 1) {
+          obj.overall_confidence_score = Math.min(obj.overall_confidence_score / 10, 1);
+        } else if (obj.overall_confidence_score < 0) {
+          obj.overall_confidence_score = 0;
+        }
+      } else {
+        obj.overall_confidence_score = 0.5;
+      }
+      if (Array.isArray(obj.findings)) {
+        obj.findings = obj.findings.flatMap((finding) => {
+          const normalized = normalizeFinding(finding);
+          return normalized ? [normalized] : [];
+        });
+      }
+      data = obj;
+    }
+    return fileReviewModelOutputSchema.parse(data);
+  } catch (e) {
+    logger.error("Model response failed schema validation", { parsedJson, error: e });
+    throw new Error(`Response schema mismatch: ${e instanceof Error ? e.message : "Check logs"}`, { cause: e });
+  }
+}
+
+// src/model-output/evidence.ts
+function buildEvidenceIndex(file) {
+  const byContent = /* @__PURE__ */ new Map();
+  const lines = [];
+  for (const hunk of file.hunks) {
+    const postable = hunk.lines.filter((line) => line.kind !== "del" && line.newLineNumber !== void 0);
+    if (postable.length === 0) continue;
+    hunk.lines.forEach((line, lineIndex) => {
+      const normalized = foldEvidenceText(line.content);
+      if (!normalized) return;
+      let anchor = line;
+      if (line.kind === "del" || line.newLineNumber === void 0) {
+        anchor = hunk.lines.slice(lineIndex + 1).find((l) => l.kind !== "del" && l.newLineNumber !== void 0) ?? hunk.lines.slice(0, lineIndex).reverse().find((l) => l.kind !== "del" && l.newLineNumber !== void 0) ?? postable[0];
+      }
+      lines.push({ normalized, line: anchor });
+      const existing = byContent.get(normalized);
+      if (existing) existing.push(anchor);
+      else byContent.set(normalized, [anchor]);
+    });
+  }
+  return { byContent, lines };
+}
+function foldFirstEvidenceLine(evidence) {
+  if (typeof evidence !== "string") return null;
+  return evidence.split("\n").map(foldEvidenceText).find((l) => l.length > 0) ?? null;
+}
+function buildBinAmbiguityIndex(files) {
+  const filesPerLine = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const hunk of file.hunks) {
+      for (const line of hunk.lines) {
+        const normalized = foldEvidenceText(line.content);
+        if (normalized.length < MIN_DISCRIMINATING_EVIDENCE_CHARS) continue;
+        const paths = filesPerLine.get(normalized);
+        if (paths) paths.add(file.path);
+        else filesPerLine.set(normalized, /* @__PURE__ */ new Set([file.path]));
+      }
+    }
+  }
+  const index = /* @__PURE__ */ new Map();
+  for (const [normalized, paths] of filesPerLine) {
+    if (paths.size > 1) index.set(normalized, paths.size);
+  }
+  return index;
+}
+function resolveEvidence(evidence, index, reportedLine) {
+  if (typeof evidence !== "string") return { status: "absent" };
+  const firstLine = foldFirstEvidenceLine(evidence);
+  if (!firstLine) return { status: "absent" };
+  if (firstLine.length < MIN_DISCRIMINATING_EVIDENCE_CHARS) return { status: "weak" };
+  const nearest = (candidates) => {
+    if (reportedLine === void 0) return candidates[0];
+    return candidates.reduce(
+      (best, candidate) => Math.abs((candidate.newLineNumber ?? 0) - reportedLine) < Math.abs((best.newLineNumber ?? 0) - reportedLine) ? candidate : best
+    );
+  };
+  const exact = index.byContent.get(firstLine);
+  if (exact && exact.length > 0) return { status: "matched", line: nearest(exact) };
+  const contained = index.lines.flatMap(({ normalized, line }) => normalized.length >= MIN_DISCRIMINATING_EVIDENCE_CHARS && (normalized.includes(firstLine) || firstLine.includes(normalized)) ? [line] : []);
+  if (contained.length > 0) return { status: "matched", line: nearest(contained) };
+  return { status: "unmatched" };
+}
+
+// src/model-output/dedupe.ts
+var SEVERITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3, nit: 4 };
+var NUL = String.fromCharCode(0);
+function dedupeFindings(comments) {
+  const best = /* @__PURE__ */ new Map();
+  for (const comment of comments) {
+    const key = comment.source === "rule" ? `rule${NUL}${comment.ruleId ?? ""}${NUL}${comment.path}${NUL}${comment.anchorHash ?? ""}` : normalizeFindingTitle(comment.title);
+    if (!key) {
+      best.set(`__unique__${best.size}`, comment);
+      continue;
+    }
+    const existing = best.get(key);
+    if (!existing) {
+      best.set(key, comment);
+      continue;
+    }
+    const rank = SEVERITY_RANK[comment.severity] ?? 4;
+    const existingRank = SEVERITY_RANK[existing.severity] ?? 4;
+    const isBetter = rank < existingRank || rank === existingRank && (comment.confidenceScore ?? 0) > (existing.confidenceScore ?? 0);
+    if (isBetter) best.set(key, comment);
+  }
+  return Array.from(best.values());
+}
+
+// src/model-output/non-answer.ts
+function isNonAnswerReview(input) {
+  if (input.findingCount > 0) return false;
+  if (input.file.lineCount < (input.minDiffLines ?? NON_ANSWER_MIN_DIFF_LINES)) return false;
+  return input.rawText.trim().length < NON_ANSWER_MAX_RESPONSE_CHARS;
+}
+
+// src/model-output/json-batch.ts
+import { batchReviewModelOutputSchema } from "@codraoss/schema";
+import { jsonrepair as jsonrepair2 } from "jsonrepair";
+import "zod";
+function readEntryPath(entry) {
+  for (const key of ["absolute_file_path", "path", "file", "file_path", "filename"]) {
+    const value = entry[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function normalizeConfidence(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  if (value > 1) return Math.min(value / 10, 1);
+  if (value < 0) return 0;
+  return value;
+}
+function normalizeBatchFileEntry(entry, fallbackPath) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+  const e = entry;
+  const path = readEntryPath(e) ?? fallbackPath;
+  if (!path) return null;
+  if (!Array.isArray(e.findings)) return null;
+  return {
+    absolute_file_path: path,
+    findings: e.findings.flatMap((finding) => {
+      const normalized = normalizeFinding(finding);
+      return normalized ? [normalized] : [];
+    }),
+    overall_correctness: typeof e.overall_correctness === "string" && e.overall_correctness ? e.overall_correctness : void 0,
+    overall_explanation: typeof e.overall_explanation === "string" && e.overall_explanation ? e.overall_explanation : void 0,
+    overall_confidence_score: normalizeConfidence(e.overall_confidence_score)
+  };
+}
+function collectBatchEntries(parsedJson) {
+  const root = parsedJson && typeof parsedJson === "object" ? parsedJson : null;
+  const files = root?.files ?? (Array.isArray(parsedJson) ? parsedJson : void 0);
+  if (Array.isArray(files)) {
+    return files.flatMap((entry) => {
+      const normalized = normalizeBatchFileEntry(entry);
+      return normalized ? [normalized] : [];
+    });
+  }
+  if (files && typeof files === "object") {
+    return Object.entries(files).flatMap(([path, entry]) => {
+      const normalized = normalizeBatchFileEntry(entry, path);
+      return normalized ? [normalized] : [];
+    });
+  }
+  return null;
+}
+function parseRawBatchPayload(raw) {
+  let extracted;
+  try {
+    extracted = extractJson(raw, "files");
+    if (!hasReviewKeys(extracted)) {
+      throw new Error("Model response did not contain review JSON keys.");
+    }
+  } catch (e) {
+    logger.error("Failed to extract JSON from batched model response", {
+      rawLength: raw.length,
+      rawPrefix: raw.slice(0, 500),
+      error: e instanceof Error ? e.message : String(e)
+    });
+    throw new Error("Could not find JSON root in batched model response.", { cause: e });
+  }
+  let preprocessed;
+  try {
+    preprocessed = preprocessJson(extracted);
+  } catch (e) {
+    logger.warn("JSON preprocessing partially failed, continuing...", { extracted, error: e });
+    preprocessed = extracted;
+  }
+  let repaired = preprocessed;
+  try {
+    repaired = jsonrepair2(preprocessed);
+  } catch (e) {
+    logger.warn("jsonrepair failed to fix batched model output, using preprocessed text", { preprocessed: truncateJsonForLog(preprocessed), error: e });
+  }
+  let parsedJson;
+  try {
+    parsedJson = stripNulls(JSON.parse(repaired));
+  } catch (e) {
+    logger.error("Critical JSON parse error after extraction and repair", { repaired: truncateJsonForLog(repaired), error: e });
+    throw new Error(`Invalid JSON format: ${e instanceof Error ? e.message : "Unknown error"}`, { cause: e });
+  }
+  const entries = collectBatchEntries(parsedJson);
+  const root = parsedJson && typeof parsedJson === "object" && !Array.isArray(parsedJson) ? parsedJson : {};
+  if (!entries?.length) {
+    if (Array.isArray(root.findings)) return { shape: "flat", data: parseRawPayload(raw) };
+    logger.error("Batched model response contained no recognisable file entries", {
+      parsedJson: truncateJsonForLog(JSON.stringify(parsedJson ?? null))
+    });
+    throw new Error("Batched response contained no recognisable file entries.");
+  }
+  try {
+    return {
+      shape: "nested",
+      data: batchReviewModelOutputSchema.parse({
+        files: entries,
+        overall_confidence_score: normalizeConfidence(root.overall_confidence_score) ?? 0.5
+      })
+    };
+  } catch (e) {
+    logger.error("Batched model response failed schema validation", { parsedJson, error: e });
+    throw new Error(`Batched response schema mismatch: ${e instanceof Error ? e.message : "Check logs"}`, { cause: e });
+  }
+}
+
+// src/model-output/batch.ts
+var basename = (path) => path.split("/").pop() ?? path;
+function resolveEntryPath(reported, candidates, claimed) {
+  const unclaimed = (matches) => matches.find((f) => !claimed.has(f.path)) ?? null;
+  const exact = candidates.filter((f) => samePath(f.path, reported));
+  const renamed = candidates.filter((f) => f.previousPath && samePath(f.previousPath, reported));
+  if (exact.length > 0 || renamed.length > 0) return unclaimed(exact) ?? unclaimed(renamed);
+  const stripped = reported.trim().replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/^\//, "");
+  const suffixed = candidates.filter((f) => f.path.endsWith(`/${stripped}`));
+  if (suffixed.length === 1) return unclaimed(suffixed);
+  const named = candidates.filter((f) => basename(f.path) === basename(stripped));
+  return named.length === 1 ? unclaimed(named) : null;
+}
+function groundEntry(file, entry, deniedClaimTypes, ambiguity, confidenceScore, stats) {
+  for (const finding of entry.findings) {
+    const claimed = finding.code_location?.absolute_file_path?.trim();
+    if (claimed && !samePath(claimed, file.path)) stats.pathMismatchFindings += 1;
+  }
+  return groundParsedFindings(
+    { ...entry, findings: entry.findings, overall_confidence_score: confidenceScore },
+    file,
+    { deniedClaimTypes, ambiguity: { index: ambiguity.index, filePath: file.path, stats: ambiguity.stats } }
+  );
+}
+function trimOverCap(reviews, cap, stats) {
+  for (const [path, review] of reviews) {
+    if (review.comments.length <= cap) continue;
+    const ranked = review.comments.toSorted((a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity));
+    const dropped = ranked.slice(cap);
+    stats.overCap += dropped.length;
+    const header = "### Additional Comments (Off-diff)";
+    const bullets = dropped.map((c) => `- **[over-cap] ${c.title}:** ${c.body}`).join("\n");
+    reviews.set(path, {
+      ...review,
+      comments: ranked.slice(0, cap),
+      fileSummary: review.fileSummary.includes(header) ? `${review.fileSummary}
+${bullets}` : `${review.fileSummary}
+
+${header}
+${bullets}`
+    });
+  }
+}
+function parseBatchReviewResponse(raw, files, options) {
+  const stats = {
+    unroutableEntries: 0,
+    pathMismatchFindings: 0,
+    ambiguousAcrossBin: 0,
+    flatFallback: 0,
+    overCap: 0,
+    entriesReturned: 0
+  };
+  const payload = parseRawBatchPayload(raw);
+  const reviews = /* @__PURE__ */ new Map();
+  const ambiguity = { index: buildBinAmbiguityIndex(files), stats: { ambiguousAcrossBin: 0 } };
+  const claimed = /* @__PURE__ */ new Set();
+  const ground = (file, entry, confidence) => reviews.set(file.path, groundEntry(file, entry, options?.deniedClaimTypes, ambiguity, confidence, stats));
+  if (payload.shape === "flat") {
+    stats.flatFallback = 1;
+    stats.entriesReturned = 1;
+    const byFile = /* @__PURE__ */ new Map();
+    for (const finding of payload.data.findings) {
+      const reported = finding.code_location.absolute_file_path?.trim();
+      const target = !reported && files.length === 1 ? files[0] : resolveEntryPath(reported ?? "", files, claimed);
+      if (!target) {
+        stats.unroutableEntries += 1;
+        continue;
+      }
+      const bucket = byFile.get(target.path);
+      if (bucket) bucket.findings.push(finding);
+      else byFile.set(target.path, { file: target, findings: [finding] });
+    }
+    for (const { file, findings } of byFile.values()) {
+      ground(file, {
+        findings,
+        overall_correctness: payload.data.overall_correctness,
+        overall_explanation: payload.data.overall_explanation
+      }, payload.data.overall_confidence_score);
+    }
+  } else {
+    stats.entriesReturned = payload.data.files.length;
+    for (const entry of payload.data.files) {
+      const file = resolveEntryPath(entry.absolute_file_path, files, claimed);
+      if (!file) {
+        stats.unroutableEntries += 1;
+        logger.warn("Batched review returned an entry for an unknown path", { reported: entry.absolute_file_path });
+        continue;
+      }
+      claimed.add(file.path);
+      ground(file, entry, entry.overall_confidence_score ?? payload.data.overall_confidence_score);
+    }
+  }
+  stats.ambiguousAcrossBin = ambiguity.stats.ambiguousAcrossBin;
+  if (options?.maxCommentsPerFile) trimOverCap(reviews, generatorFindingCap(options.maxCommentsPerFile), stats);
+  return { reviews, missing: files.flatMap((f) => reviews.has(f.path) ? [] : [f.path]), stats };
+}
+
+// src/model-output/index.ts
+function samePath(a, b) {
+  const strip = (p) => p.trim().replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/^\//, "");
+  return strip(a) === strip(b);
+}
+function withSuggestion(body, codeSuggestion) {
+  if (!codeSuggestion) return body;
+  const cleanSuggestion = codeSuggestion.replace(/```suggestion\n?|```/g, "").trim();
+  const cleanBody = body.split("```suggestion")[0].trim();
+  return `${cleanBody}
+
+\`\`\`suggestion
+${cleanSuggestion}
+\`\`\``;
+}
+var CLAIM_TYPE_REPAIRS = [
+  { pattern: /dependenc(?:y|ies)\s+array|exhaustive[- ]deps/i, claimType: "react_hook_missing_deps" },
+  { pattern: /redos|catastrophic backtrack|exponential backtrack/i, claimType: "redos_regex" }
+];
+function repairClaimType(claimType, title, body, onRepair) {
+  if (claimType !== "other") return claimType;
+  const text = `${title}
+${body}`;
+  if (looksLikeExternalVersionClaim(title, body)) {
+    onRepair();
+    return "external_version_claim";
+  }
+  for (const { pattern, claimType: repaired } of CLAIM_TYPE_REPAIRS) {
+    if (pattern.test(text)) {
+      onRepair();
+      return repaired;
+    }
+  }
+  return claimType;
+}
+function formatWithheld(w) {
+  return w.tag ? `- **[${w.tag}] ${w.title}:** ${w.body}` : `- **${w.title}:** ${w.body}`;
+}
+function groundFindingInEvidence(finding, evidenceIndex, evidenceStats, ambiguity) {
+  const reportedLine = finding.code_location.line || finding.code_location.line_range?.start;
+  evidenceStats.total += 1;
+  const evidence = resolveEvidence(finding.evidence, evidenceIndex, reportedLine);
+  if (evidence.status === "matched") evidenceStats.matched += 1;
+  else if (evidence.status === "unmatched") evidenceStats.unmatched += 1;
+  else if (evidence.status === "weak") evidenceStats.weak += 1;
+  else if (evidence.status === "absent") evidenceStats.absent += 1;
+  if (evidence.status !== "matched") {
+    return { withheld: { title: finding.title, body: finding.body, tag: `unverified:${evidence.status}` } };
+  }
+  if (ambiguity) {
+    const firstLine = foldFirstEvidenceLine(finding.evidence);
+    const claimedPath = finding.code_location.absolute_file_path?.trim();
+    const ambiguousAcrossBin = firstLine ? (ambiguity.index.get(firstLine) ?? 0) > 1 : false;
+    if (ambiguousAcrossBin && claimedPath && !samePath(claimedPath, ambiguity.filePath)) {
+      ambiguity.stats.ambiguousAcrossBin += 1;
+      return {
+        withheld: {
+          title: finding.title,
+          body: finding.body,
+          tag: "unverified:ambiguous-across-bin"
+        }
+      };
+    }
+  }
+  return { diffLine: evidence.line };
+}
+function anchorToDiffPosition(file, diffLine, validPositions, finding) {
+  const line = diffLine.newLineNumber;
+  const position = findPositionForLine(file, line);
+  if (position === void 0 || !validPositions.has(position)) {
+    return { withheld: { title: finding.title, body: finding.body } };
+  }
+  return { line, position };
+}
+function validateFindingShape(finding) {
+  const priorityMap = {
+    0: "P0",
+    1: "P1",
+    2: "P2",
+    3: "P3",
+    4: "nit"
+  };
+  const severity = finding.priority !== void 0 ? priorityMap[finding.priority] || "P3" : "P3";
+  const cleanText = (text) => {
+    let current = text.trim();
+    let prev = "";
+    while (current !== prev) {
+      prev = current;
+      current = current.replace(/^(?:[^\w\s]+|(?:QUALITY|SECURITY|BUG|PERFORMANCE|CORRECTNESS|P[0-3]|NIT)\b)+/giu, "").replace(/\n\s*/g, " ").trim();
+    }
+    return current;
+  };
+  const title = cleanText(finding.title);
+  let body = cleanText(finding.body);
+  const bodyPrefix = cleanText(body.split("\n")[0]);
+  if (bodyPrefix.toLowerCase().startsWith(title.toLowerCase()) || title.toLowerCase().startsWith(bodyPrefix.toLowerCase())) {
+    body = cleanText(body.slice(body.split("\n")[0].length));
+  }
+  return { severity, title, body };
+}
+function applyClaimGate(finding, title, body, anchorContent, deniedClaimTypes, claimTypeCounts, deniedClaimCounts) {
+  const claimType = repairClaimType(toClaimType(finding.claim_type), title, body, () => {
+    claimTypeCounts.__repaired = (claimTypeCounts.__repaired ?? 0) + 1;
+  });
+  claimTypeCounts[claimType] = (claimTypeCounts[claimType] ?? 0) + 1;
+  if (deniedClaimTypes.has(claimType)) {
+    deniedClaimCounts[claimType] = (deniedClaimCounts[claimType] ?? 0) + 1;
+    return { withheld: { title, body, tag: `claim-denied:${claimType}` } };
+  }
+  if (isVersionClaimRefutedByPin({ title, body, anchorContent })) {
+    deniedClaimCounts.version_claim_on_pinned_sha = (deniedClaimCounts.version_claim_on_pinned_sha ?? 0) + 1;
+    return { withheld: { title, body, tag: "refuted:pinned-sha" } };
+  }
+  const undecidable = refuteUndecidableClaim({ title, body });
+  if (undecidable) {
+    const key = `undecidable_${undecidable.replace("-", "_")}`;
+    deniedClaimCounts[key] = (deniedClaimCounts[key] ?? 0) + 1;
+    return { withheld: { title, body, tag: `refuted:${undecidable}` } };
+  }
+  return { claimType };
+}
+function buildParsedComment(params) {
+  const { file, line, position, severity, title, body, claimType, anchorContent, finding, presenceIndex, absenceCheckStats } = params;
+  const absence = checkAbsenceClaim({ title, body, anchorLine: line, index: presenceIndex });
+  if (absence.status === "refuted") {
+    absenceCheckStats.absenceShaped += 1;
+    absenceCheckStats.identifierExtracted += 1;
+    absenceCheckStats.refuted += 1;
+  } else if (absence.reason !== "not_absence_shaped") {
+    absenceCheckStats.absenceShaped += 1;
+    if (absence.reason !== "no_identifier" && absence.reason !== "ambiguous_identifier") {
+      absenceCheckStats.identifierExtracted += 1;
+    }
+  }
+  const confidenceScore = typeof finding.confidence_score === "number" ? finding.confidence_score : 0;
+  const codeSuggestion = typeof finding.code_suggestion === "string" && finding.code_suggestion.trim() ? finding.code_suggestion : void 0;
+  return parsedReviewCommentSchema.parse({
+    path: file.path,
+    line,
+    position,
+    severity,
+    category: CLAIM_TYPE_CATEGORY[claimType],
+    claimType,
+    contextSnippet: renderDiffSnippet(file, line) || void 0,
+    title,
+    body: withSuggestion(body, codeSuggestion),
+    codeSuggestion,
+    confidenceScore,
+    evidence: typeof finding.evidence === "string" && finding.evidence.trim() ? finding.evidence.trim() : void 0,
+    fingerprint: buildFindingFingerprint(file.path, title),
+    anchorHash: anchorContent ? buildAnchorHash(anchorContent) : void 0,
+    fingerprintV2: buildFindingFingerprintV2(
+      file.path,
+      claimType,
+      anchorContent ? buildAnchorHash(anchorContent) : void 0
+    ) ?? void 0
+  });
+}
+function groundParsedFindings(parsed, file, options) {
+  const validPositions = getValidPositions(file);
+  const evidenceIndex = buildEvidenceIndex(file);
+  const evidenceStats = { total: 0, matched: 0, unmatched: 0, weak: 0, absent: 0 };
+  const claimTypeCounts = {};
+  const deniedClaimCounts = {};
+  const deniedClaimTypes = new Set(options?.deniedClaimTypes ?? []);
+  const presenceIndex = buildPresenceIndex(file);
+  const absenceCheckStats = { absenceShaped: 0, identifierExtracted: 0, refuted: 0 };
+  const orphanedComments = [];
+  const comments = (parsed.findings || []).map((finding) => {
+    const grounded = groundFindingInEvidence(finding, evidenceIndex, evidenceStats, options?.ambiguity);
+    if ("withheld" in grounded) {
+      orphanedComments.push(formatWithheld(grounded.withheld));
+      return null;
+    }
+    const anchored = anchorToDiffPosition(file, grounded.diffLine, validPositions, finding);
+    if ("withheld" in anchored) {
+      orphanedComments.push(formatWithheld(anchored.withheld));
+      return null;
+    }
+    const { severity, title, body } = validateFindingShape(finding);
+    const anchorContent = grounded.diffLine.content ?? file.hunks.flatMap((h) => h.lines).find((l) => l.newLineNumber === anchored.line)?.content ?? "";
+    const gated = applyClaimGate(finding, title, body, anchorContent, deniedClaimTypes, claimTypeCounts, deniedClaimCounts);
+    if ("withheld" in gated) {
+      orphanedComments.push(formatWithheld(gated.withheld));
+      return null;
+    }
+    try {
+      return buildParsedComment({
+        file,
+        line: anchored.line,
+        position: anchored.position,
+        severity,
+        title,
+        body,
+        claimType: gated.claimType,
+        anchorContent,
+        finding,
+        presenceIndex,
+        absenceCheckStats
+      });
+    } catch (error) {
+      if (!(error instanceof z3.ZodError)) throw error;
+      orphanedComments.push(formatWithheld({
+        title: finding.title,
+        body: finding.body,
+        tag: "unverified:unassemblable"
+      }));
+      logger.warn("Dropped a finding that could not be assembled", {
+        path: file.path,
+        title: finding.title,
+        error: error.message
+      });
+      return null;
+    }
+  }).filter((comment) => Boolean(comment));
+  const verdict = parsed.overall_correctness.toLowerCase().includes("patch is correct") ? "approve" : "comment";
+  let fileSummary = parsed.overall_explanation;
+  if (orphanedComments.length > 0) {
+    fileSummary += `
+
+### Additional Comments (Off-diff)
+${orphanedComments.join("\n")}`;
+  }
+  return {
+    comments,
+    verdict: comments.length > 0 ? "comment" : verdict,
+    fileSummary,
+    overallCorrectness: parsed.overall_correctness,
+    confidenceScore: parsed.overall_confidence_score,
+    evidenceStats,
+    claimTypeCounts,
+    deniedClaimCounts,
+    absenceCheckStats
+  };
+}
+function parseFileReviewResponse(raw, file, options) {
+  return groundParsedFindings(parseRawPayload(raw), file, options);
+}
+
+export {
+  dedupeFindings,
+  isNonAnswerReview,
+  parseRawBatchPayload,
+  parseBatchReviewResponse,
+  samePath,
+  groundParsedFindings,
+  parseFileReviewResponse
+};
+//# sourceMappingURL=chunk-XD6CGYHO.js.map