pi-supernova 0.10.1 → 0.11.0

package/src/fs/patch.js

@@ -78,8 +78,8 @@ function splitFile(text) {
   });
 }
 
-function findHunkMatch(fileLines, expectedOld, nominal, hunk, oldStart) {
-  const matchAt = index => index >= 0 && index + expectedOld.length <= fileLines.length
+function findHunkMatch(fileLines, expectedOld, nominal, hunk, oldStart, floor) {
+  const matchAt = index => index >= floor && index + expectedOld.length <= fileLines.length
     && expectedOld.every((line, i) => fileLines[index + i].text === line);
 
   if (matchAt(nominal)) return { index: nominal, relocated: 0 };
@@ -102,8 +102,11 @@ function findHunkMatch(fileLines, expectedOld, nominal, hunk, oldStart) {
   return { index: -1, relocated: 0 };
 }
 
-function hunkLineText(line) {
-  return line.slice(1).replace(/\r$/, "");
+function hunkLineText(hunk, i) {
+  const text = hunk.lines[i].slice(1);
+
+  // Without an original newline, a trailing CR is payload, not a CRLF ending.
+  return hunk.noNewline.includes(i) ? text : text.replace(/\r$/, "");
 }
 
 function applyHunkLines(hunk, fileLines, matchIndex, ending) {
@@ -114,7 +117,7 @@ function applyHunkLines(hunk, fileLines, matchIndex, ending) {
     const line = hunk.lines[i];
 
     if (line[0] === "+") {
-      replacement.push({ text: hunkLineText(line), ending: hunk.noNewline.includes(i) ? "" : ending });
+      replacement.push({ text: hunkLineText(hunk, i), ending: hunk.noNewline.includes(i) ? "" : ending });
     } else {
       const original = fileLines[oldIndex++];
 
@@ -127,23 +130,33 @@ function applyHunkLines(hunk, fileLines, matchIndex, ending) {
   return replacement;
 }
 
-function applyOneHunk(hunk, h, fileLines, offsetShift, relocationShift, ending) {
-  const expectedOld = hunk.lines.filter(line => line[0] !== "+").map(hunkLineText);
+function applyOneHunk(hunk, h, fileLines, offsetShift, relocationShift, ending, floor) {
+  const expectedOld = hunk.lines.flatMap((line, i) => line[0] !== "+" ? [hunkLineText(hunk, i)] : []);
   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);
+  const match = findHunkMatch(fileLines, expectedOld, nominal, h + 1, hunk.oldStart, floor);
 
   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);
+  const tailEnd = fileLines.length;
+  const length = tailEnd + replacement.length - expectedOld.length;
+
+  // Valid hunks can exceed the engine's argument-count limit. Move the tail
+  // in place rather than passing every replacement line as a splice argument.
+  if (length > tailEnd) fileLines.length = length;
+  fileLines.copyWithin(match.index + replacement.length, match.index + expectedOld.length, tailEnd);
+  fileLines.length = length;
+
+  for (let i = 0; i < replacement.length; i++) fileLines[match.index + i] = replacement[i];
 
   return {
     relocationShift: relocationShift + match.relocated,
     offsetShift: offsetShift + match.relocated + replacement.length - expectedOld.length,
     relocated: match.relocated,
+    floor: match.index + replacement.length,
   };
 }
 
@@ -155,11 +168,14 @@ export function applyPatchToText(originalText, patchText) {
   const relocations = [];
   let offsetShift = 0;
   let relocationShift = 0;
+  // Later hunks cannot reinterpret already-published output as original input.
+  let floor = 0;
 
   for (let h = 0; h < hunks.length; h++) {
-    const applied = applyOneHunk(hunks[h], h, fileLines, offsetShift, relocationShift, ending);
+    const applied = applyOneHunk(hunks[h], h, fileLines, offsetShift, relocationShift, ending, floor);
     offsetShift = applied.offsetShift;
     relocationShift = applied.relocationShift;
+    floor = applied.floor;
 
     if (applied.relocated !== 0) relocations.push({ hunk: h + 1, offset: applied.relocated });
   }

package/src/fs/process-tree.js

@@ -54,6 +54,24 @@ function signalGroups(job, signal) {
   }
 }
 
+function waitForRetirement(job) {
+  if (job.processClosed) return delay(10);
+
+  // A child normally closes its pipes just after exit. Wake on that event rather
+  // than charging every successful command a polling interval. Keep a fallback
+  // for stuck pipes; group disappearance is still checked by the caller.
+  return new Promise(resolve => {
+    const done = () => {
+      clearTimeout(timer);
+      job.child.off("close", done);
+      resolve();
+    };
+
+    const timer = setTimeout(done, 10);
+    job.child.once("close", done);
+  });
+}
+
 // Both foreground and background commands own their POSIX groups until they
 // disappear, not merely until the leader exits or inherited output pipes close.
 // Callers update processExited/processClosed from the real child events and may
@@ -85,7 +103,7 @@ export async function retireProcessTree(job) {
     if (Date.now() >= deadline) throw new Error("owned process group or output pipes did not close" + (job.signalError ? ": " + job.signalError : ""));
 
     if (process.platform !== "win32") signalGroups(job, "SIGKILL");
-    await delay(10);
+    await waitForRetirement(job);
   }
 
   if (discoveryError) throw new Error("descendant discovery failed: " + discoveryError.message);

package/src/fs/read-window.js

@@ -16,15 +16,18 @@ function advanceLines(bytes, start, remaining) {
   return { offset: start, remaining };
 }
 
-async function scanWindow(file, stat, startLine, lineCount, maxBytes, signal) {
-  const scan = { parts: [], collected: 0, startByte: undefined, endByte: undefined };
-  let skip = startLine - 1, take = lineCount ?? Infinity, position = 0;
-
-  for await (const chunk of fileChunks(file, signal, stat.size)) {
+async function scanWindow(file, startLine, lineCount, maxBytes, signal) {
+  const scan = { parts: [], collected: 0, startByte: undefined, endByte: undefined, readBytes: 0, eof: false };
+  // Empty windows need an emptiness probe, not a seek to the requested line.
+  let skip = lineCount === 0 ? 0 : startLine - 1, take = lineCount ?? Infinity;
+
+  // Regular virtual files can report zero, undersized or oversized stat lengths.
+  // Only the read stream establishes EOF and whether a selected window is whole.
+  for await (const chunk of fileChunks(file, signal, Infinity, lineCount === 0 ? 1 : undefined)) {
     const head = advanceLines(chunk, 0, skip);
     skip = head.remaining;
-    const start = position;
-    position += chunk.length;
+    const start = scan.readBytes;
+    scan.readBytes += chunk.length;
 
     if (skip) continue;
     scan.startByte ??= start + head.offset;
@@ -39,9 +42,11 @@ async function scanWindow(file, stat, startLine, lineCount, maxBytes, signal) {
       scan.collected += end - head.offset;
     }
 
-    if (take === 0 || scan.collected > maxBytes) break;
+    if (scan.collected > maxBytes || take === 0 && tail.offset < chunk.length) return scan;
   }
 
+  scan.eof = true;
+
   return scan;
 }
 
@@ -59,7 +64,7 @@ async function openReadFile(target) {
 
 export function createWindowReader(vfs) {
   return async function readWindow(target, startLine, lineCount, maxBytes, signal) {
-    const overlay = vfs.getOverlay(target);
+    const overlay = await vfs.getOverlay(target);
 
     if (overlay !== undefined) {
       const window = overlayWindow(overlay,startLine,lineCount);
@@ -70,22 +75,33 @@ export function createWindowReader(vfs) {
 
     const file = await openReadFile(target);
 
+    let stat, result, wholeBytes;
+
     try {
-      const stat = await file.stat();
+      stat = await file.stat();
 
       if (!stat.isFile()) throw new Error("read requires a regular file: " + target);
 
-      if (lineCount === 0) return { text: "", satisfied: true, whole: stat.size === 0 };
-      const scan = await scanWindow(file, stat, startLine, lineCount, maxBytes, signal);
+      const scan = await scanWindow(file, startLine, lineCount, maxBytes, signal);
+
+      if (scan.startByte === undefined) {
+        result = { text: "", satisfied: true, whole: scan.eof && scan.readBytes === 0 };
+      } else {
+        if (scan.collected > maxBytes) return { text: "", satisfied: false, whole: false };
+        const bytes = Buffer.concat(scan.parts, scan.collected);
+        const end = scan.startByte + scan.collected;
+        const eof = scan.eof;
+        const text = eof ? decodeUtf8Strict(bytes, target) : decodeUtf8Window(bytes, target);
+        const whole = startLine === 1 && scan.startByte === 0 && eof;
+        // The digest-reuse contract requires bytes agreeing with observed size.
+        wholeBytes = whole && bytes.length === stat.size ? bytes : undefined;
+        result = { text, satisfied: end >= scan.endByte || eof, whole };
+      }
+    } finally { await file.close(); }
 
-      if (scan.startByte === undefined) return { text: "", satisfied: true, whole: stat.size === 0 };
-      const bytes = Buffer.concat(scan.parts, scan.collected);
-      const end = scan.startByte + scan.collected;
-      const eof = end >= stat.size;
-      const text = eof ? decodeUtf8Strict(bytes, target) : decodeUtf8Window(bytes);
-      await vfs.recordExpected(target, stat);
+    // An open read handle can prevent Windows from restoring a rollback backup.
+    await vfs.recordExpected(target, stat, wholeBytes);
 
-      return { text, satisfied: end >= scan.endByte || eof, whole: startLine === 1 && scan.startByte === 0 && eof };
-    } finally { await file.close(); }
+    return result;
   };
 }

package/src/fs/source-window.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { relativeSlash } from "./workspace.js";
+import { sameFileVersion, readLimitedBytes } from "./file-io.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;
 
@@ -15,18 +16,11 @@ async function readBoundedFile(real, rootPrefix, signal) {
     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;
+    const buffer = await readLimitedBytes(handle, stat, 1024 * 1024, "diagnostic input", signal);
 
-    while (offset < buffer.length) {
-      const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
+    if (!sameFileVersion(stat, await handle.stat())) return null;
 
-      if (bytesRead <= 0) break;
-      offset += bytesRead;
-      signal?.throwIfAborted();
-    }
-
-    return buffer.subarray(0, offset).toString("utf8");
+    return buffer.toString("utf8");
   } finally { await handle.close(); }
 }
 
@@ -71,6 +65,7 @@ export async function sourceForReferences(cwd, commandCwd, output, signal, ledge
     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);

package/src/fs/text-ops.js

@@ -1,9 +1,15 @@
 import { fileChunks } from "./file-io.js";
+
 export {MAX_DIRECTORY_ENTRIES,formatDirectoryEntry,formatLsEntry} from './directory.js';
+
 export {textResult,resultDiff} from '../shared/result.js';
+
 import {sliceLinesRaw,lineNumberAt,formatNumberedLine,numberedPreview,lineStartIndex,lineEndIndex,lineTextRange,contentLineInfo} from './lines.js';
+
 export * from './lines.js';
+
 export {jsonStringLength,maxJsonStringPrefix} from './json-size.js';
+
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { homedir } from "node:os";
@@ -27,13 +33,13 @@ export function normalizeReadWindow(params) {
   const limit = readLineParam(params.limit, "limit");
 
   if (offset !== undefined) normalized.offset = Math.max(1, offset);
+
   if (limit !== undefined) normalized.limit = Math.max(0, limit);
 
   return normalized;
 }
 
 export function resolveReadPath(cwd, target) {
-  if (!isString(target) || !target.trim()) throw new Error("read requires path");
   const input = assertFilesystemPath(target, "read");
 
   return path.resolve(cwd, input === "~" ? homedir() : input.startsWith("~/") ? path.join(homedir(), input.slice(2)) : input);
@@ -42,8 +48,9 @@ export function resolveReadPath(cwd, target) {
 export async function probeExistingPath(cwd, targetParam, vfs) {
   const targetPath = resolveReadPath(cwd, targetParam);
 
-  if (vfs.getOverlay(targetPath) !== undefined) {
-    const overlay = vfs.getOverlay(targetPath);
+  const overlay = await vfs.getOverlay(targetPath);
+
+  if (overlay !== undefined) {
 
     return { path: targetPath, directory: false, size: Buffer.byteLength(overlay, "utf8"), overlay };
   }
@@ -55,7 +62,7 @@ export async function probeExistingPath(cwd, targetParam, vfs) {
   } catch (err) {
     if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") throw err;
 
-    if (vfs.getOverlayPaths().some(file => file.startsWith(targetPath + path.sep))) return { path: targetPath, directory: true };
+    if ((await vfs.getOverlayPaths(targetPath)).some(file => file.startsWith(targetPath + path.sep))) return { path: targetPath, directory: true };
 
     return null;
   }
@@ -74,7 +81,7 @@ function duplicateEditError(target, content, index, second) {
   return new Error("edit target is not unique in " + target + ": lines " + a + " and " + b + "; include more surrounding lines in oldText, or pass edits:[{oldText,newText},…]\n" + formatNumberedLine(a, lineAt(content, a)) + "\n" + formatNumberedLine(b, lineAt(content, b)));
 }
 
-/** Exact bytes at the closest guess: a byte-for-byte miss is usually indentation drift. */
+/** Show nearby exact bytes without guessing why the multi-line match failed. */
 function nearMissPreview(content, oldText) {
   const first = String(oldText).split("\n").find(line => line.trim().length > 0);
 
@@ -87,12 +94,13 @@ function nearMissPreview(content, oldText) {
   const from = lineStartIndex(content, start);
   const shown = content.slice(from, lineEndIndex(content, from, Math.min(5, line - start + 3))).replace(/\r?\n$/, "");
 
-  return "first oldText line matches line " + line + " only after trimming; exact bytes there:\n"
+  return "oldText anchor near line " + line + "; exact bytes there:\n"
     + shown.split("\n").map((text, index) => formatNumberedLine(start + index, text)).join("\n");
 }
+
 function matchReplacement(target, content, replacement) {
   if (!isString(replacement?.oldText) || replacement.oldText.length === 0) {
-    throw new Error("edit requires non-empty oldText");
+    throw new Error("edit requires non-empty oldText; to insert, include adjacent existing text in oldText and repeat it in newText");
   }
 
   if (!isString(replacement?.newText)) throw new Error("edit requires newText");
@@ -103,6 +111,7 @@ function matchReplacement(target, content, replacement) {
   if (index < 0) {
     throw new Error("edit target not found in " + target + ": oldText must match the file byte-for-byte\n" + (nearMissPreview(content, oldText) ?? numberedPreview(content)));
   }
+
   const second = content.indexOf(oldText, index + 1);
 
   if (second >= 0) throw duplicateEditError(target, content, index, second);
@@ -110,31 +119,38 @@ function matchReplacement(target, content, replacement) {
   return { ...replacement, oldText, newText, index, end: index + oldText.length };
 }
 
-function assertNoOverlap(target, matches) {
+function assertNoOverlap(target, content, matches) {
   for (let i = 1; i < matches.length; i++) {
-    if (matches[i].index < matches[i - 1].end) throw new Error(`edit targets overlap in ${target}`);
+    if (matches[i].index < matches[i - 1].end) throw new Error(`edit targets overlap in ${target}: edits ${matches[i - 1].editNumber} and ${matches[i].editNumber} overlap at line ${lineNumberAt(content, matches[i].index)}; combine overlapping replacements or apply them sequentially against updated text`);
   }
 }
 
 export function applyReplacements(target, content, requestedEdits) {
   if (requestedEdits.length === 0) throw new Error("edit requires at least one replacement");
+
   const matches = requestedEdits.map((replacement, index) => {
-    try { return matchReplacement(target, content, replacement); }
+    try { return { ...matchReplacement(target, content, replacement), editNumber: index + 1 }; }
     catch (error) {
       // Name the failing entry: a multi-edit miss is otherwise a guessing game.
       throw requestedEdits.length === 1 ? error : new Error("edit " + (index + 1) + " of " + requestedEdits.length + ": " + error.message);
     }
   });
+
   matches.sort((a, b) => a.index - b.index);
-  assertNoOverlap(target, matches);
-  let updated = content;
+  assertNoOverlap(target, content, matches);
+  const parts = [];
+  let from = 0;
 
-  for (let i = matches.length - 1; i >= 0; i--) {
-    const match = matches[i];
-    updated = updated.slice(0, match.index) + match.newText + updated.slice(match.end);
+  // All coordinates refer to the original. Assemble once instead of copying
+  // the growing document for every replacement; inserted text is never rematched.
+  for (const match of matches) {
+    parts.push(content.slice(from, match.index), match.newText);
+    from = match.end;
   }
 
-  return { updated, matches };
+  parts.push(content.slice(from));
+
+  return { updated: parts.join(""), matches };
 }
 
 export function shiftDiffLines(diff, delta) {
@@ -162,6 +178,7 @@ function withLineEnding(insert, ending) {
 
 function viewInsertText(content, startIndex, endIndex, newText) {
   const hasSuffix = endIndex < content.length;
+
   // A view replaces whole source lines. Preserve the separator before following
   // lines, but let an explicit trailing newline change a no-trailing-newline EOF.
   if (hasSuffix) return content.slice(0, startIndex) + withLineEnding(newText, suffixSeparator(content, endIndex)) + content.slice(endIndex);
@@ -193,7 +210,9 @@ export function applyViewReplace(target, content, start, end, oldText, newText)
 }
 
 export const WRITE_DIFF_MAX_READ_BYTES = 512 * 1024;
+
 export const WRITE_APPEND_MAX_READ_BYTES = 64 * 1024 * 1024;
+
 export const QUICK_CHECK_MAX_CHARS = 2 * 1024 * 1024;
 
 async function snapshotLargeFile(vfs, target, overlay, signal) {
@@ -230,14 +249,14 @@ async function existingStat(target) {
 /** Prior body (or line count) for a write receipt / CAS, without always materializing huge files. */
 export async function writeSnapshot(vfs, target, signal) {
   const stat = await existingStat(target);
-  const overlay = vfs.getOverlay(target);
+  const overlay = await vfs.getOverlay(target);
   const existingBytes = overlay !== undefined ? Buffer.byteLength(overlay, "utf8") : stat?.size;
 
   if (existingBytes !== undefined && existingBytes > WRITE_DIFF_MAX_READ_BYTES) {
-    return { previous: "", removedLines: await snapshotLargeFile(vfs, target, overlay, signal), overlay, existingBytes };
+    return { previous: "", removedLines: await snapshotLargeFile(vfs, target, overlay, signal) };
   }
 
-  return { previous: await snapshotSmallFile(vfs, target, overlay), removedLines: undefined, overlay, existingBytes };
+  return { previous: await snapshotSmallFile(vfs, target, overlay), removedLines: undefined };
 }
 
 export async function countContentLines(target, signal) {
@@ -280,6 +299,7 @@ export function boundedEditDiff(target, original, matches) {
     const nextStart = start + shift;
 
     for (let i = 0; i < oldInfo.preview.length; i++) lines.push({ type: "remove", lineNum: start + i, newLineNum: nextStart + i, text: oldInfo.preview[i] });
+
     for (let i = 0; i < newInfo.preview.length; i++) lines.push({ type: "add", lineNum: nextStart + i, newLineNum: nextStart + i, text: newInfo.preview[i] });
 
     shift += newInfo.newlines - oldInfo.newlines;