pi-supernova 0.6.0 → 0.7.0

package/src/adapters/edit.js

@@ -0,0 +1,249 @@
+import * as path from "node:path";
+import { isString, isNumber } from "../shared/decode.js";
+import { buildEditDiff, buildMultiEditDiff, buildPatchDiff, MAX_DIFF_MATCHES } from "../fs/diff.js";
+import { declaredName, WorkspaceIndex } from "../context/repo-index.js";
+import { quickCheck } from "../fs/check.js";
+import { applyPatchToText } from "../fs/patch.js";
+import { resolveWorkspacePath, relativeSlash } from "../fs/workspace.js";
+import { referencesForNames } from "../context/search.js";
+import {
+  textResult, sourceLines, lineTextRange, applyReplacements, applyViewReplace,
+  shiftDiffLines, contentLineInfo, boundedEditDiff, QUICK_CHECK_MAX_CHARS,
+} from "../fs/text-ops.js";
+
+export function createEdit(ctx) {
+  const { getCwd, vfs, index, ledger } = ctx;
+  function lineAt(updated, newLines, n) {
+    if (newLines) return newLines[n - 1] ?? "";
+    const { start, end } = lineTextRange(updated, n);
+
+    return updated.slice(start, end).replace(/\r?\n$/, "");
+  }
+
+  function spanEditRange(span, lineCount) {
+    if (!span || !Number.isInteger(span.start) || !Number.isInteger(span.end) || span.start < 1 || span.end < span.start) return null;
+    const end = Math.min(lineCount, span.end);
+
+    return span.start <= end ? [{ start: span.start, end }] : [];
+  }
+
+  function mergeEditRange(ranges, line, lineCount) {
+    const start = Math.max(1, line - 2), end = Math.min(lineCount, line + 2);
+
+    if (ranges.length && start <= ranges.at(-1).end + 1) ranges.at(-1).end = Math.max(ranges.at(-1).end, end);
+    else ranges.push({ start, end });
+  }
+
+  function collectEditRanges(span, diff, lineCount) {
+    const explicit = spanEditRange(span, lineCount);
+
+    if (explicit) return explicit;
+    const ranges = [];
+    const positions = diff.lines.filter(row => row.type !== "context")
+      .map(row => Math.min(lineCount, row.newLineNum ?? row.lineNum)).sort((a, b) => a - b);
+
+    for (const line of positions) mergeEditRange(ranges, line, lineCount);
+
+    return ranges;
+  }
+
+  function formatEditBlocks(rel, updated, newLines, ranges) {
+    const perRange = Math.max(1, Math.floor(40 / Math.max(1, ranges.length)));
+    const blocks = [];
+
+    for (const { start, end } of ranges) {
+      const last = Math.min(end, start + perRange - 1);
+      const lines = Array.from({ length: Math.max(0, last - start + 1) }, (_, i) => lineAt(updated, newLines, start + i));
+      ledger.recordOrigin(rel, start, lines);
+      blocks.push("edited " + rel + ":" + start + "-" + last + "\n" + lines.map((line, i) => String(start + i).padStart(5) + " " + line).join("\n"));
+
+      if (last < end) blocks.push("[continue with read({path:" + JSON.stringify(rel) + ",offset:" + (last + 1) + ",limit:" + (end - last) + "})]");
+    }
+
+    return blocks.join("\n");
+  }
+
+  async function editSummary(cwd, target, original, updated, diff, signal, span) {
+    const rel = relativeSlash(cwd, target);
+    const newLines = updated.length <= 512 * 1024 ? updated.split("\n") : null;
+    const lineCount = newLines ? newLines.length : contentLineInfo(updated).count;
+    let out = formatEditBlocks(rel, updated, newLines, collectEditRanges(span, diff, lineCount));
+
+    if (diff?.omittedMatches) out += `\n…${diff.omittedMatches} more matches (receipt shows the first ${MAX_DIFF_MATCHES})`;
+    const check = updated.length <= QUICK_CHECK_MAX_CHARS ? quickCheck(updated, path.extname(target)) : null;
+
+    if (check && !check.ok) out += `\ncheck: ${check.message}`;
+    const refs = await changedDeclarationRefs(cwd, target, original, updated, diff, signal);
+
+    if (refs) out += `\n${refs}`;
+
+    return out;
+  }
+
+  function lineText(text, lines, number) {
+    if (lines) return lines[number - 1] ?? "";
+    const { start, end } = lineTextRange(text, number);
+
+    return text.slice(start, end).replace(/\r?\n$/, "");
+  }
+
+  function nameAtDiffLine(l, original, updated, oldLines, newLines, canMapOwners, target, spans) {
+    const number = l.type === "remove" ? l.lineNum : l.newLineNum ?? l.lineNum;
+    const source = l.type === "remove" ? original : updated;
+    const cached = l.type === "remove" ? oldLines : newLines;
+    const name = declaredName(lineText(source, cached, number));
+
+    if (name) return name;
+    if (!canMapOwners) return;
+    if (!spans.has(l.type)) spans.set(l.type, WorkspaceIndex.spansOf(WorkspaceIndex.fromText(target, source)));
+
+    return spans.get(l.type).find(span => span.start <= number && number <= span.end)?.name;
+  }
+
+  function collectChangedNames(target, original, updated, diff) {
+    const canMapOwners = original.length <= 512 * 1024 && updated.length <= 512 * 1024;
+    const oldLines = canMapOwners ? original.split("\n") : null;
+    const newLines = canMapOwners ? updated.split("\n") : null;
+    const names = new Set();
+    const spans = new Map();
+
+    for (const l of diff.lines) {
+      if (l.type === "context") continue;
+      const name = nameAtDiffLine(l, original, updated, oldLines, newLines, canMapOwners, target, spans);
+
+      if (name) names.add(name);
+      if (names.size >= 3) break;
+    }
+
+    return names;
+  }
+
+  function formatNameRefs(references, incomplete) {
+    const parts = [];
+
+    for (const [name, refs] of references) {
+      if (refs.length) parts.push(name + " also referenced in " + refs.slice(0, 6).join(", ") + (refs.length > 6 ? " (more matches)" : ""));
+    }
+
+    if (incomplete) parts.push("references incomplete: search budget reached");
+
+    return parts.join("\n");
+  }
+
+  async function changedDeclarationRefs(cwd, target, original, updated, diff, signal) {
+    const names = collectChangedNames(target, original, updated, diff);
+
+    if (names.size === 0) return "";
+
+    try {
+      const { references, incomplete } = await referencesForNames({ root: cwd, names: [...names].slice(0, 3),
+        excludePath: target, overlayText: file => vfs.getOverlay(file), pendingPaths: vfs.getOverlayPaths(), signal });
+
+      return formatNameRefs(references, incomplete);
+    } catch (error) {
+      signal?.throwIfAborted();
+
+      return "references unavailable: " + error.message;
+    }
+  }
+
+  async function commitEdit(cwd, target, original, updated, diff, signal, span) {
+    const { speculative } = await vfs.write(target, updated);
+    index.touch(relativeSlash(cwd, target));
+    const summary = await editSummary(cwd, target, original, updated, diff, signal, span);
+
+    return textResult(summary, { path: target, speculative, diff });
+  }
+
+  async function applyViewEdit(cwd, target, content, params, signal) {
+    const viewText = String(params.viewText);
+    const nextText = String(params.newText);
+    const windowNext = isString(params.oldText)
+      ? applyReplacements(target, viewText, [{ oldText: String(params.oldText), newText: nextText }]).updated
+      : nextText;
+    const { updated } = applyViewReplace(target, content, params.viewStart, params.viewEnd, viewText, windowNext);
+    const diffFrom = isString(params.oldText) ? String(params.oldText) : viewText;
+    const diff = shiftDiffLines(buildEditDiff(target, viewText, diffFrom, isString(params.oldText) ? nextText : windowNext), params.viewStart - 1);
+    const spanEnd = params.viewStart + Math.max(sourceLines(windowNext).length, 1) - 1;
+
+    return commitEdit(cwd, target, content, updated, diff, signal, { start: params.viewStart, end: spanEnd });
+  }
+
+  function diffForMatches(target, content, updated, matches) {
+    if (content.length > 512 * 1024 || updated.length > 512 * 1024) return boundedEditDiff(target, content, matches);
+    if (matches.length === 1) return buildEditDiff(target, content, matches[0].oldText, matches[0].newText);
+
+    return buildMultiEditDiff(target, content, matches);
+  }
+
+  async function edit(params, signal) {
+      const cwd = getCwd();
+      const target = await resolveWorkspacePath(cwd, params?.path, "edit", false);
+
+      if (signal?.aborted) throw new Error("aborted");
+      const content = await vfs.read(target, { maxBytes: 64 * 1024 * 1024 });
+
+      if (isNumber(params?.viewStart) && isNumber(params?.viewEnd) && isString(params?.viewText) && isString(params?.newText)) {
+        return applyViewEdit(cwd, target, content, params, signal);
+      }
+
+      const requestedEdits = Array.isArray(params?.edits) ? params.edits : [{ oldText: params?.oldText, newText: params?.newText }];
+      const { updated, matches } = applyReplacements(target, content, requestedEdits);
+
+      return commitEdit(cwd, target, content, updated, diffForMatches(target, content, updated, matches), signal);
+  }
+
+  function patchInputPath(params) {
+    let inputPath = params?.path;
+
+    if (!inputPath && isString(params?.patch)) {
+      for (const match of params.patch.matchAll(/^(?:---|\+\+\+)\s+([^\t\n]+)/gm)) {
+        const candidate = match[1].trim().replace(/^[ab]\//, "");
+
+        if (candidate !== "/dev/null") return candidate;
+      }
+    }
+
+    return inputPath;
+  }
+
+  async function readPatchOriginal(target) {
+    try {
+      return await vfs.read(target, { maxBytes: 64 * 1024 * 1024, preserveRead: true });
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+
+      return "";
+    }
+  }
+
+  async function apply_patch(params, signal) {
+      const cwd = getCwd();
+      const target = await resolveWorkspacePath(cwd, patchInputPath(params), "apply_patch", false);
+
+      if (!isString(params?.patch) || !params.patch.trim()) {
+        throw new Error("apply_patch requires patch");
+      }
+
+      if (signal?.aborted) throw new Error("aborted");
+      const original = await readPatchOriginal(target);
+      if (original.length > 2 * 1024 * 1024) throw new Error("apply_patch input exceeds 2 MiB; use edit() for targeted replacements");
+      const { resultText, hunkCount, relocations } = applyPatchToText(original, params.patch);
+      const { speculative } = await vfs.write(target, resultText);
+      const diff = buildPatchDiff(target, params.patch, relocations);
+      index.touch(relativeSlash(cwd, target));
+      let summary = await editSummary(cwd, target, original, resultText, diff, signal);
+
+      if (relocations.length) summary += "\nrelocated " + relocations.map(entry => "#" + entry.hunk + " " + (entry.offset > 0 ? "+" : "") + entry.offset + " lines").join(", ");
+
+      return textResult(summary, {
+        path: target,
+        hunks: hunkCount,
+        speculative,
+        diff,
+        relocated: relocations,
+      });
+  }
+
+  return { edit, apply_patch, editSummary };
+}

package/src/adapters/errors.js

@@ -0,0 +1,31 @@
+export const IMAGE_MAX_BYTES = 20 * 1024 * 1024;
+export const LARGE_FILE_BYTES = 512 * 1024;
+
+/** Raw path-only reads above these must use json/about/offset/complete. */
+export const RAW_JSON_CHARS = 4096;
+
+export const RAW_SOURCE_CHARS = 8192;
+
+export const RAW_SOURCE_LINES = 160;
+
+/** Routing responses above this fall back to the bound error instead of dumping. */
+export const ROUTING_MAX_CHARS = 4096;
+export const ABOUT_TOKEN_MAX = 16;
+export const IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+};
+
+export function imageTooLarge(rel, size) {
+  return new Error("image " + rel + " is " + size + " bytes (" + (size / 1024 / 1024).toFixed(1) + " MiB); the image read limit is " + IMAGE_MAX_BYTES + " bytes (20 MiB); resize or select fewer/smaller images");
+}
+
+export function missingFile(targetPath) {
+  const error = new Error("no such file: " + targetPath + " (locate it with read using a directory path or source question)");
+  error.code = "ENOENT";
+  return error;
+}

package/src/adapters/index.js

@@ -0,0 +1,31 @@
+import { createNativeScheduler } from "../runtime/parallel.js";
+import { createRead } from "./read.js";
+import { createWrite } from "./write.js";
+import { createEdit } from "./edit.js";
+import { createBash } from "./bash.js";
+import { createList } from "./list.js";
+
+export function createNativeAdapters(getCwd, vfs, config, index, ledger, hooks) {
+  const ctx = { getCwd, vfs, config, index, ledger, hooks, reads: createNativeScheduler() };
+  const read = createRead(ctx);
+  ctx.readDirectory = read.readDirectory;
+  const write = createWrite(ctx);
+  const edit = createEdit(ctx);
+  const bash = createBash(ctx);
+  const list = createList(ctx);
+  hooks.summarizeEdit = edit.editSummary;
+  return {
+    read: read.read,
+    write: write.write,
+    edit: edit.edit,
+    apply_patch: edit.apply_patch,
+    snap: read.snap,
+    evidence: read.evidence,
+    surface: read.surface,
+    bash: bash.bash,
+    grep: list.grep,
+    glob: list.glob,
+    find: list.find,
+    ls: list.ls,
+  };
+}

package/src/adapters/list.js

@@ -0,0 +1,102 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { resolveWorkspacePath, runCommand } from "../fs/workspace.js";
+import { fuzzyFind, grepIndexed, listIndexed, listWithTools, rgGrepArgs } from "../context/search.js";
+import { textResult, formatDirectoryEntry } from "../fs/text-ops.js";
+
+function rawListPattern(op, params) {
+  if (op === "glob") return String(params?.pattern || "");
+
+  return params?.pattern || params?.glob;
+}
+
+function globPatternOf(op, params) {
+  const pattern = rawListPattern(op, params);
+
+  if (op === "glob" && !pattern) throw new Error("glob requires pattern");
+
+  return pattern ? String(pattern) : null;
+}
+
+async function resolveListDir(op, params, cwd) {
+  if (op === "find" && params?.path) return resolveWorkspacePath(cwd, params.path, op, true);
+
+  return cwd;
+}
+
+function fileListing(dirPath, size) {
+  const entry = formatDirectoryEntry(path.basename(dirPath), "file", size);
+
+  return textResult(entry, { path: dirPath, directory: false, count: 1, entries: [entry] });
+}
+
+export function createList(ctx) {
+  const { getCwd, vfs, index } = ctx;
+
+  async function listFromCache(searchDir, cwd, globPattern, pending) {
+    const fuzzy = await fuzzyFind(index, searchDir, cwd, globPattern, 20, pending);
+
+    if (fuzzy !== null) return textResult(fuzzy, { via: "fuzzy" });
+    const indexed = await listIndexed(index, searchDir, cwd, globPattern, pending);
+
+    if (indexed !== null) return textResult(indexed, { via: "index" });
+
+    return null;
+  }
+
+  async function listFiles(params, signal, op, cwd) {
+    if (signal?.aborted) throw new Error("aborted");
+    const searchDir = await resolveListDir(op, params, cwd);
+    const globPattern = globPatternOf(op, params);
+    const pending = vfs.getOverlayPaths();
+    const cached = await listFromCache(searchDir, cwd, globPattern, pending);
+
+    if (cached !== null) return cached;
+
+    return listWithTools(searchDir, globPattern, cwd, signal, pending);
+  }
+
+  async function grepWithRg(pattern, params, searchPath, cwd, signal) {
+      const res = await runCommand(["rg", ...rgGrepArgs(pattern, params, searchPath)], { cwd, timeoutMs: 30_000, signal });
+
+      if (res.exitCode !== 0 && res.exitCode !== 1) {
+        throw new Error(res.stderr.trim() || `rg exited ${res.exitCode}`);
+      }
+
+      return textResult(res.stdout, { exitCode: res.exitCode });
+  }
+
+  async function grep(params, signal) {
+      const cwd = getCwd();
+      const pattern = String(params?.pattern || "");
+
+      if (!pattern) throw new Error("grep requires pattern");
+      const searchPath = params?.path ? await resolveWorkspacePath(cwd, params.path, "grep", true) : cwd;
+      const indexed = await grepIndexed(index, pattern, params, searchPath, cwd, file => vfs.getOverlay(file), vfs.getOverlayPaths());
+
+      if (indexed !== null) return textResult(indexed, { exitCode: indexed ? 0 : 1, via: "index" });
+      // Large tree: real rg keeps its own output format.
+      return grepWithRg(pattern, params, searchPath, cwd, signal);
+  }
+
+  async function glob(params, signal) {
+    return listFiles(params, signal, "glob", getCwd());
+  }
+  async function find(params, signal) {
+    return listFiles(params, signal, "find", getCwd());
+  }
+  async function ls(params, signal) {
+      const cwd = getCwd();
+      const dirPath = params?.path ? await resolveWorkspacePath(cwd, params.path, "ls", true) : cwd;
+      const pending = vfs.getOverlay(dirPath);
+
+      if (pending !== undefined) return fileListing(dirPath, Buffer.byteLength(pending, "utf8"));
+      const stat = await fs.stat(dirPath).catch(() => null);
+
+      if (stat?.isFile()) return fileListing(dirPath, stat.size);
+
+      return ctx.readDirectory(dirPath, signal);
+  }
+
+  return { grep, glob, find, ls };
+}