pi-supernova 0.5.0 → 0.7.0

package/src/fs/patch.js

@@ -9,6 +9,36 @@ function parseHunkHeader(line) {
     newStart: Number(match[3]), newLength: match[4] === undefined ? 1 : Number(match[4]), lines: [], noNewline: [] };
 }
 
+function applyNoNewlineMarker(current) {
+  if (!current.lines.length) throw new Error("newline marker requires a preceding hunk line");
+  current.noNewline.push(current.lines.length - 1);
+}
+
+function pushHunkLine(current, line, oldCount, newCount) {
+  if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
+    throw new Error("apply_patch accepts one file at a time");
+  }
+
+  current.lines.push(line);
+
+  return {
+    oldCount: line[0] !== "+" ? oldCount + 1 : oldCount,
+    newCount: line[0] !== "-" ? newCount + 1 : newCount,
+  };
+}
+
+function consumeHunkLine(current, line, oldCount, newCount) {
+  if (line.startsWith("\")) {
+    applyNoNewlineMarker(current);
+
+    return { oldCount, newCount };
+  }
+
+  if (!/^[+ -]/.test(line)) return { oldCount, newCount };
+
+  return pushHunkLine(current, line, oldCount, newCount);
+}
+
 export function parsePatchHunks(patchText) {
   const hunks = [];
   let current;
@@ -23,19 +53,8 @@ export function parsePatchHunks(patchText) {
       hunks.push(current);
       oldCount = 0;
       newCount = 0;
-    } else if (current && line.startsWith("\")) {
-      if (!current.lines.length) throw new Error("newline marker requires a preceding hunk line");
-      current.noNewline.push(current.lines.length - 1);
-    } else if (current && /^[+ -]/.test(line)) {
-      if (oldCount === current.oldLength && newCount === current.newLength && /^--- |^\+\+\+ /.test(line)) {
-        throw new Error("apply_patch accepts one file at a time");
-      }
-
-      current.lines.push(line);
-
-      if (line[0] !== "+") oldCount++;
-
-      if (line[0] !== "-") newCount++;
+    } else if (current) {
+      ({ oldCount, newCount } = consumeHunkLine(current, line, oldCount, newCount));
     }
   }
 
@@ -59,21 +78,73 @@ function splitFile(text) {
   });
 }
 
-function findHunkMatch(fileLines, expectedOld, nominal) {
+function findHunkMatch(fileLines, expectedOld, nominal, hunk, oldStart) {
   const matchAt = index => index >= 0 && index + expectedOld.length <= fileLines.length
     && expectedOld.every((line, i) => fileLines[index + i].text === line);
 
-  if (matchAt(nominal)) return nominal;
+  if (matchAt(nominal)) return { index: nominal, relocated: 0 };
+
+  if (!expectedOld.length) return { index: -1, relocated: 0 };
+
+  const maxDrift = Math.min(Math.max(fileLines.length, 100), 200);
+  const hits = [];
+
+  for (let delta = 1; delta <= maxDrift; delta++) {
+    if (matchAt(nominal + delta)) hits.push(nominal + delta);
+
+    if (matchAt(nominal - delta)) hits.push(nominal - delta);
+  }
+
+  if (hits.length > 1) throw new Error("patch hunk " + hunk + " near line " + oldStart + " matches " + hits.length + " locations; add context lines to disambiguate");
+
+  if (hits.length === 1) return { index: hits[0], relocated: hits[0] - nominal };
+
+  return { index: -1, relocated: 0 };
+}
+
+function hunkLineText(line) {
+  return line.slice(1).replace(/\r$/, "");
+}
 
-  if (!expectedOld.length) return -1;
+function applyHunkLines(hunk, fileLines, matchIndex, ending) {
+  const replacement = [];
+  let oldIndex = matchIndex;
 
-  for (let delta = 1; delta <= Math.max(fileLines.length, 100); delta++) {
-    if (matchAt(nominal + delta)) return nominal + delta;
+  for (let i = 0; i < hunk.lines.length; i++) {
+    const line = hunk.lines[i];
 
-    if (matchAt(nominal - delta)) return nominal - delta;
+    if (line[0] === "+") {
+      replacement.push({ text: hunkLineText(line), ending: hunk.noNewline.includes(i) ? "" : ending });
+    } else {
+      const original = fileLines[oldIndex++];
+
+      if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
+
+      if (line[0] === " ") replacement.push(original);
+    }
   }
 
-  return -1;
+  return replacement;
+}
+
+function applyOneHunk(hunk, h, fileLines, offsetShift, relocationShift, ending) {
+  const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(hunkLineText);
+  const newCount = hunk.lines.filter(line => line[0] !== "-").length;
+
+  if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
+  // The new coordinate also handles BSD diff's -1,0 header at file start.
+  const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
+  const match = findHunkMatch(fileLines, expectedOld, nominal, h + 1, hunk.oldStart);
+
+  if (match.index < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
+  const replacement = applyHunkLines(hunk, fileLines, match.index, ending);
+  fileLines.splice(match.index, expectedOld.length, ...replacement);
+
+  return {
+    relocationShift: relocationShift + match.relocated,
+    offsetShift: offsetShift + match.relocated + replacement.length - expectedOld.length,
+    relocated: match.relocated,
+  };
 }
 
 export function applyPatchToText(originalText, patchText) {
@@ -81,42 +152,17 @@ export function applyPatchToText(originalText, patchText) {
   const hunks = parsePatchHunks(patchText);
   const fileLines = splitFile(originalText);
   const ending = fileLines.find(line => line.ending)?.ending ?? "\n";
+  const relocations = [];
   let offsetShift = 0;
   let relocationShift = 0;
 
   for (let h = 0; h < hunks.length; h++) {
-    const hunk = hunks[h];
-    const textOf = line => line.slice(1).replace(/\r$/, "");
-    const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(textOf);
-    const newCount = hunk.lines.filter(line => line[0] !== "-").length;
-
-    if (expectedOld.length !== hunk.oldLength || newCount !== hunk.newLength) throw new Error("patch hunk " + (h + 1) + " length does not match its header");
-    // The new coordinate also handles BSD diff's -1,0 header at file start.
-    const nominal = hunk.oldLength === 0 ? hunk.newStart - 1 + relocationShift : hunk.oldStart - 1 + offsetShift;
-    const matchIndex = findHunkMatch(fileLines, expectedOld, nominal);
-
-    if (matchIndex < 0) throw new Error("patch hunk " + (h + 1) + " rejected at line " + hunk.oldStart + ": context did not match");
-    const replacement = [];
-    let oldIndex = matchIndex;
-
-    for (let i = 0; i < hunk.lines.length; i++) {
-      const line = hunk.lines[i];
-
-      if (line[0] === "+") {
-        replacement.push({ text: textOf(line), ending: hunk.noNewline.includes(i) ? "" : line.endsWith("\r") ? "\r\n" : ending });
-      } else {
-        const original = fileLines[oldIndex++];
-
-        if (hunk.noNewline.includes(i) && original.ending) throw new Error("patch newline marker does not match the file");
-
-        if (line[0] === " ") replacement.push(original);
-      }
-    }
+    const applied = applyOneHunk(hunks[h], h, fileLines, offsetShift, relocationShift, ending);
+    offsetShift = applied.offsetShift;
+    relocationShift = applied.relocationShift;
 
-    fileLines.splice(matchIndex, expectedOld.length, ...replacement);
-    relocationShift += matchIndex - nominal;
-    offsetShift += matchIndex - nominal + replacement.length - expectedOld.length;
+    if (applied.relocated !== 0) relocations.push({ hunk: h + 1, offset: applied.relocated });
   }
 
-  return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length };
+  return { resultText: fileLines.map(line => line.text + line.ending).join(""), hunkCount: hunks.length, relocations };
 }

package/src/fs/source-window.js

@@ -0,0 +1,82 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { relativeSlash } from "./workspace.js";
+
+export const SOURCE_REF = /((?:\/|[A-Za-z]:[\\/])?(?:[\w.@-]+[\\/])*[\w.@-]+\.(?:m?[jt]sx?|c[jt]s|py|rs|go|java|kt|rb|php|c|cc|cpp|h|hpp|cs|swift|json|ya?ml|toml))(?::|\()(\d+)/g;
+
+function prefix(p) {
+  return p.endsWith(path.sep) ? p : p + path.sep;
+}
+
+async function readBoundedFile(real, rootPrefix, signal) {
+  const handle = await fs.open(real, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK ?? 0));
+
+  try {
+    const stat = await handle.stat();
+
+    if (!real.startsWith(rootPrefix) || !stat.isFile() || stat.size > 1024 * 1024) return null;
+    const buffer = Buffer.alloc(Math.min(stat.size, 1024 * 1024));
+    let offset = 0;
+
+    while (offset < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
+
+      if (bytesRead <= 0) break;
+      offset += bytesRead;
+      signal?.throwIfAborted();
+    }
+
+    return buffer.subarray(0, offset).toString("utf8");
+  } finally { await handle.close(); }
+}
+
+function windowRows(text, lineNo, ledger, rel) {
+  const raw = text.split("\n");
+
+  if (lineNo < 1 || lineNo > raw.length) return null;
+  const start = Math.max(1, lineNo - 2);
+  const rows = [];
+
+  for (let l = start; l <= Math.min(raw.length, lineNo + 2); l++) rows.push((l === lineNo ? "►" : " ") + String(l).padStart(4) + " " + raw[l - 1]);
+  ledger.recordOrigin(rel, start, rows);
+
+  return rel + ":" + lineNo + "\n" + rows.join("\n");
+}
+
+/** Fresh bounded source window for a diagnostic; no index warmup or stale cached bodies. */
+export async function sourceWindow(cwd, commandCwd, file, lineNo, signal, ledger) {
+  const candidate = path.resolve(commandCwd, file);
+
+  try {
+    const root = await fs.realpath(cwd);
+    const cwdPrefix = prefix(path.resolve(cwd));
+    const rootPrefix = prefix(root);
+
+    if (!candidate.startsWith(cwdPrefix) && !candidate.startsWith(rootPrefix)) return null;
+    const real = await fs.realpath(candidate);
+    const text = await readBoundedFile(real, rootPrefix, signal);
+
+    if (text === null) return null;
+
+    return windowRows(text, lineNo, ledger, relativeSlash(root, real));
+  } catch { return null; }
+}
+
+/** A failing command names path:line; the model wants those lines next. Attach them (≤4 sites). */
+export async function sourceForReferences(cwd, commandCwd, output, signal, ledger) {
+  const seen = new Set();
+  const blocks = [];
+
+  for (const m of output.matchAll(SOURCE_REF)) {
+    const key = m[1] + ":" + m[2];
+
+    if (seen.has(key)) continue;
+    if (seen.size >= 4) break;
+    seen.add(key);
+    const block = await sourceWindow(cwd, commandCwd, m[1], Number(m[2]), signal, ledger);
+
+    if (block) blocks.push(block);
+  }
+
+  return blocks.length ? "\n--- source\n" + blocks.join("\n") : "";
+}