pi-supernova 0.5.0 → 0.7.0

package/src/adapters/refs.js

@@ -0,0 +1,41 @@
+import { relativeSlash } from "../fs/workspace.js";
+
+export function outlineOptions(params, references, config) {
+  const options = { references };
+
+  if (Number.isInteger(params?.maxChars) && params.maxChars > 0) options.maxChars = Math.min(params.maxChars, config.maxCallResultChars ?? 65536);
+
+  return options;
+}
+
+/** Outline lines carry their own line numbers ("  330 text"); provenance follows them. */
+export function recordOutlineOrigins(ledger, rel, outlineText) {
+  for (const line of outlineText.split("\n")) {
+    const m = /^\s*(\d+) (.*)$/.exec(line);
+
+    if (m && !/ … \d+ lines$/.test(line)) ledger.recordOrigin(rel, Number(m[1]), [line]);
+  }
+}
+
+/** Where else a name appears (declaration line excluded), for outlines and edit results. */
+export function createReferenceFinder(index, vfs) {
+  return async function referenceFinder(cwd, targetPath) {
+    let files;
+
+    try { files = [...new Set([...await index.files(cwd), ...vfs.getOverlayPaths()])]; }
+    catch { return () => []; }
+
+    if (!index.canScan(files)) return () => [];
+
+    return (name, excludeLine) => {
+      if (!name || name.length < 3) return [];
+      const escaped = name.replace(/[$]/g, (c) => "\\" + c);
+      const regex = new RegExp("\\b" + escaped + "\\b");
+
+      return index
+        .grepRows(files, regex, cwd, file => vfs.getOverlay(file))
+        .filter((r) => !(r.line === excludeLine && r.rel === relativeSlash(cwd, targetPath)))
+        .map((r) => r.rel + ":" + r.line);
+    };
+  };
+}

package/src/adapters/write.js

@@ -0,0 +1,96 @@
+import * as path from "node:path";
+import { isString } from "../shared/decode.js";
+import { buildWriteDiff } from "../fs/diff.js";
+import { quickCheck } from "../fs/check.js";
+import { resolveWorkspacePath, relativeSlash } from "../fs/workspace.js";
+import {
+  textResult, contentLineInfo, boundedWriteDiff,
+  WRITE_DIFF_MAX_READ_BYTES, WRITE_APPEND_MAX_READ_BYTES, QUICK_CHECK_MAX_CHARS,
+  writeSnapshot,
+} from "../fs/text-ops.js";
+
+const READ_ARTIFACT_MARK = /\[read truncated;|…\[[^\]\n]*truncated[^\]\n]*\]…/u;
+
+function assertWriteAppendFlag(append) {
+  if (append !== undefined && append !== true && append !== false) throw new Error("write append must be a boolean");
+}
+
+function assertWriteArtifactsFlag(allowReadArtifacts) {
+  if (allowReadArtifacts !== undefined && allowReadArtifacts !== true && allowReadArtifacts !== false) throw new Error("write allowReadArtifacts must be a boolean");
+}
+
+function writeDiffFor(target, prevText, content, removedLines) {
+  if (removedLines === undefined && content.length <= WRITE_DIFF_MAX_READ_BYTES) {
+    return buildWriteDiff(target, prevText, content);
+  }
+
+  return boundedWriteDiff(target, content, removedLines ?? contentLineInfo(prevText).count);
+}
+
+function writeCheckWarning(content, target) {
+  if (content.length > QUICK_CHECK_MAX_CHARS) return "";
+  const check = quickCheck(content, path.extname(target));
+
+  return check && !check.ok ? "\ncheck: " + check.message : "";
+}
+
+function writeOutcome(rel, target, content, speculative, prevText, removedLines) {
+  const diff = writeDiffFor(target, prevText, content, removedLines);
+  const tag = speculative ? " (speculative)" : "";
+
+  return textResult(`wrote ${rel}${tag}${writeCheckWarning(content, target)}`, { path: target, speculative, diff });
+}
+
+export function createWrite(ctx) {
+  const { getCwd, vfs, index } = ctx;
+
+  function assertWriteParams(params) {
+    if (!isString(params?.content)) throw new Error("write requires string content");
+    assertWriteAppendFlag(params.append);
+    assertWriteArtifactsFlag(params.allowReadArtifacts);
+    const content = String(params.content);
+
+    if (params.allowReadArtifacts !== true && READ_ARTIFACT_MARK.test(content)) {
+      throw new Error("refusing to write truncated read output; use edit() or reconstruct complete source windows. Set allowReadArtifacts:true only to intentionally write literal truncation-marker text");
+    }
+
+    return content;
+  }
+
+  async function applyAppend(target, content, snap) {
+    let { previous: prevText, overlay, existingBytes } = snap;
+
+    if (existingBytes > WRITE_APPEND_MAX_READ_BYTES) throw new Error("append input exceeds " + WRITE_APPEND_MAX_READ_BYTES + " bytes; stream it with bash redirection instead");
+
+    if (existingBytes !== undefined && existingBytes > WRITE_DIFF_MAX_READ_BYTES) {
+      try { prevText = overlay !== undefined ? overlay : await vfs.read(target, { maxBytes: WRITE_APPEND_MAX_READ_BYTES, preserveRead: true }); }
+      catch (error) { if (error.code !== "ENOENT") throw error; }
+    }
+
+    return { content: prevText + content, prevText, removedLines: undefined };
+  }
+
+  async function write(params, signal) {
+      const cwd = getCwd();
+      const target = await resolveWorkspacePath(cwd, params?.path, "write", false);
+
+      if (signal?.aborted) throw new Error("aborted");
+      let content = assertWriteParams(params);
+      const snap = await writeSnapshot(vfs, target, signal);
+      let { previous: prevText, removedLines } = snap;
+
+      if (params.append === true) {
+        const appended = await applyAppend(target, content, snap);
+        content = appended.content;
+        prevText = appended.prevText;
+        removedLines = appended.removedLines;
+      }
+
+      const { speculative } = await vfs.write(target, content);
+      index.touch(relativeSlash(cwd, target));
+
+      return writeOutcome(relativeSlash(cwd, target), target, content, speculative, prevText, removedLines);
+  }
+
+  return { write };
+}

package/src/bridge/catalog.js

@@ -1,257 +1,67 @@
+import { isString } from "../shared/decode.js";
 
-import { isString, isObject } from "../shared/decode.js";
-
-const NATIVE_TOOL_DEFINITIONS = [
-  {
-    name: "read",
-    description: "Read files, images or directories. JSON selectors project full documents within output budgets. Source questions locate and open source directly; resolve returns structured source/status without guessing.",
-    parameters: { type: "object", properties: {
-      path: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }], description: "Workspace-relative file or directory, source question, or array of paths" },
-      target: { anyOf: [{ type: "string" }, { type: "array" }], description: "File path/query or array of paths" },
-      offset: { type: "number", description: "One-based starting line" },
-      limit: { type: "number", description: "Maximum lines to return" },
-      about: { type: "string", description: "Question or symbol: expand file bodies, or locate and open source inside a directory" },
-      query: { type: "string", description: "Source question; optional path scopes the search directory" },
-      resolve: { type: "boolean", description: "Return structured source/status for a direct resolve-to-edit handoff" },
-      complete: { type: "boolean", description: "Fail unless the entire requested file fits without clipping" },
-      json: { anyOf: [{ type: "boolean" }, { type: "string" }, { type: "array", items: { type: "string" } }], description: "Parse the complete JSON input (up to 16 MiB), then select .field, .items[0:3], or quoted keys. A selector array returns an array of values; true selects the root. Oversized selections fail, never clip." },
-    } },
-  },
-  {
-    name: "write", description: "Write UTF-8 content to a workspace file.",
-    parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" }, allowReadArtifacts: { type: "boolean", description: "Explicit opt-in for intentionally writing literal truncation-marker text" } }, required: ["path", "content"] },
-  },
-  {
-    name: "edit", description: "Apply unique text replacements to a workspace file; returns the post-edit lines, a structural check, and references to changed declarations.",
-    parameters: { type: "object", properties: {
-      path: { type: "string" }, oldText: { type: "string" }, newText: { type: "string" }, edits: { type: "array", description: "[{oldText, newText}] for several replacements in one call" },
-    }, required: ["path"] },
-  },
-  {
-    name: "apply_patch", description: "Apply a unified diff to one workspace file.",
-    parameters: { type: "object", properties: { path: { type: "string" }, patch: { type: "string" } }, required: ["patch"] },
-  },
-  {
-    name: "snap", description: "Select source with found, ambiguous, not_found, or incomplete status. The read command uses the same engine.",
-    parameters: { type: "object", properties: {
-      query: { type: "string", description: "Source concept to resolve" },
-      path: { type: "string", description: "Optional workspace search root; explicitly targeting a hidden directory includes its hidden files, but Git metadata is always excluded" },
-    }, required: ["query"] },
-  },
-  {
-    name: "evidence", description: "Top-K source spans (with path and line provenance) that answer a concept question; read these instead of whole files.",
-    parameters: { type: "object", properties: {
-      query: { type: "string", description: "Concept, symbol, or question" },
-      path: { type: "string", description: "Optional search root" },
-      k: { type: "number", description: "Main spans to return (default 5)" },
-      maxChars: { type: "number", description: "Total text budget (default 6000)" },
-    }, required: ["query"] },
-  },
-  {
-    name: "surface", description: "Extract a structural outline from a workspace source file.",
-    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
-  },
-  {
-    name: "bash", description: "Run a shell command inside the workspace and capture bounded output.",
-    parameters: { type: "object", properties: { command: { type: "string" }, cwd: { type: "string" }, timeoutMs: { type: "number" } }, required: ["command"] },
-  },
-  {
-    name: "grep", description: "Search file contents. Smart-case regex; definition lines first (marked *); fuzzy fallback when nothing matches literally.",
-    parameters: { type: "object", properties: {
-      pattern: { type: "string" }, path: { type: "string" }, glob: { type: "string" }, caseSensitive: { type: "boolean" }, limit: { type: "number" },
-    }, required: ["pattern"] },
-  },
-  {
-    name: "glob", description: "Find files: a glob pattern, or free text for typo-tolerant, frecency-ranked path search.",
-    parameters: { type: "object", properties: { pattern: { type: "string" } }, required: ["pattern"] },
-  },
-  {
-    name: "find", description: "List workspace files, optionally constrained by path and pattern.",
-    parameters: { type: "object", properties: { path: { type: "string" }, pattern: { type: "string" }, glob: { type: "string" } } },
-  },
-  {
-    name: "ls", description: "List direct entries in a workspace directory.",
-    parameters: { type: "object", properties: { path: { type: "string" } } },
-  },
-];
-
-export function mergeNativeToolDefinitions(tools, capturedNames = []) {
-  const nativeByName = new Map(NATIVE_TOOL_DEFINITIONS.map((tool) => [tool.name, tool]));
-  const captured = new Set(capturedNames);
-  const seen = new Set();
-  const merged = [];
-
-  for (const tool of tools || []) {
-    const fallback = nativeByName.get(tool?.name);
-    merged.push(fallback && !captured.has(tool.name)
-      ? { ...tool, ...fallback, sourceInfo: { path: "<native:" + tool.name + ">" } }
-      : tool);
-
-    if (tool?.name) seen.add(tool.name);
-  }
-
-  for (const fallback of NATIVE_TOOL_DEFINITIONS) {
-    if (!seen.has(fallback.name)) {
-      merged.push({ ...fallback, sourceInfo: { path: "<native:" + fallback.name + ">" } });
-    }
-  }
-
-  return merged;
-}
-
-function sourcePathOf(tool) {
-  if (tool.sourceInfo && isString(tool.sourceInfo.path)) return tool.sourceInfo.path;
-
-  if (isString(tool.extensionPath)) return tool.extensionPath;
-
-  if (isString(tool.sourcePath)) return tool.sourcePath;
-
-  return undefined;
-}
-
-function normalizeTool(tool) {
-  if (!tool || !isObject(tool)) return null;
-  const name = isString(tool.name) ? tool.name : "";
-
-  if (!name) return null;
-  const description = isString(tool.description) ? tool.description : "";
-
-  return {
-    name,
-    nameLower: name.toLowerCase(),
-    description,
-    descLower: description.toLowerCase(),
-    parameters: tool.parameters,
-    schemaError: tool.schemaError,
-    sourcePath: sourcePathOf(tool),
-  };
-}
-
-export function buildCatalog(tools, excludeNames = []) {
-  const exclude = new Set(excludeNames);
-  const rows = [];
-
-  for (const tool of tools || []) {
-    const row = normalizeTool(tool);
-
-    if (!row || exclude.has(row.name)) continue;
-    rows.push(row);
-  }
+/** Optimal string alignment distance: insert/delete/substitute/adjacent-transpose cost 1. */
+function osaCell(a, b, rows, i, j) {
+  const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+  let best = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
 
-  rows.sort((a, b) => a.name.localeCompare(b.name));
+  if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) best = Math.min(best, rows[i - 2][j - 2] + 1);
 
-  return rows;
+  return best;
 }
 
-function tokenize(query) {
-  return String(query || "")
-    .toLowerCase()
-    .split(/[^a-z0-9_]+/g)
-    .filter((t) => t.length > 1);
-}
+function editDistance(a, b) {
+  const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array.from({ length: b.length }, () => 0)]);
 
-function scoreRow(row, tokens) {
-  if (tokens.length === 0) return 1;
-  const name = row.nameLower || row.name.toLowerCase();
-  const desc = row.descLower || row.description.toLowerCase();
-  let score = 0;
+  for (let j = 1; j <= b.length; j++) rows[0][j] = j;
 
-  for (const token of tokens) {
-    if (name === token) score += 10;
-    else if (name.includes(token)) score += 5;
-    else if (desc.includes(token)) score += 2;
+  for (let i = 1; i < rows.length; i++) {
+    for (let j = 1; j <= b.length; j++) rows[i][j] = osaCell(a, b, rows, i, j);
   }
 
-  return score;
+  return rows[a.length][b.length];
 }
 
-export function searchCatalog(catalog, query, limit = 12) {
-  const tokens = tokenize(query);
-  const scored = [];
+function scoreName(needle, candidate, maxDistance) {
+  const lower = candidate.toLowerCase();
 
-  for (const row of catalog) {
-    const score = scoreRow(row, tokens);
+  if (lower === needle) return null;
+  const distance = lower.includes(needle) || needle.includes(lower) ? 1 : editDistance(needle, lower);
 
-    if (score <= 0 && tokens.length > 0) continue;
-    scored.push({ name: row.name, description: row.description.slice(0, 160), score });
-  }
+  if (distance > maxDistance) return null;
 
-  scored.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
-
-  return scored.slice(0, Math.max(1, limit)).map(({ score: _s, ...hit }) => hit);
+  return { candidate, distance };
 }
 
-/** Optimal string alignment distance: insert/delete/substitute/adjacent-transpose cost 1. */
-function editDistance(a, b) {
-  const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array.from({ length: b.length }, () => 0)]);
-
-  for (let j = 1; j <= b.length; j++) rows[0][j] = j;
-
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      let best = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
-
-      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) best = Math.min(best, rows[i - 2][j - 2] + 1);
-      rows[i][j] = best;
-    }
-  }
-
-  return rows[a.length][b.length];
+function bySuggestionRank(needle, a, b) {
+  return (
+    a.distance - b.distance ||
+    Math.abs(a.candidate.length - needle.length) - Math.abs(b.candidate.length - needle.length) ||
+    a.candidate.localeCompare(b.candidate)
+  );
 }
 
-/** Closest tool names for a mistyped name: substring hits first, then a length-scaled edit distance. */
 function suggestNames(name, candidates, limit = 3) {
-  const needle = String(name || "").toLowerCase();
+  const needle = String(name || "").toLowerCase().slice(0, 128);
 
   if (!needle) return [];
   const maxDistance = Math.max(1, Math.floor(needle.length / 3));
   const scored = [];
 
   for (const candidate of candidates) {
-    const lower = candidate.toLowerCase();
-
-    if (lower === needle) continue;
-    const distance = lower.includes(needle) || needle.includes(lower) ? 1 : editDistance(needle, lower);
+    const hit = scoreName(needle, candidate, maxDistance);
 
-    if (distance <= maxDistance) scored.push({ candidate, distance });
+    if (hit) scored.push(hit);
   }
 
-  scored.sort(
-    (a, b) =>
-      a.distance - b.distance ||
-      Math.abs(a.candidate.length - needle.length) - Math.abs(b.candidate.length - needle.length) ||
-      a.candidate.localeCompare(b.candidate),
-  );
+  scored.sort((a, b) => bySuggestionRank(needle, a, b));
 
   return scored.slice(0, limit).map((s) => s.candidate);
 }
 
 export function unknownToolMessage(name, candidates) {
-  const close = suggestNames(name, candidates);
+  const close = suggestNames(name, candidates.filter(isString));
   const hint = close.length ? ` Did you mean ${close.map((c) => JSON.stringify(c)).join(", ")}?` : "";
 
   return `unknown tool "${name}".${hint} Check the command name and configured tool exclusions.`;
 }
-
-export function describeTool(catalog, name) {
-  const row = catalog.find((t) => t.name === name);
-
-  if (!row) {
-    return { ok: false, error: unknownToolMessage(name, catalog.map((t) => t.name)) };
-  }
-
-  if (!isObject(row.parameters)) return { ok: false, name, error: "tool schema unavailable: " + (row.schemaError ?? name) };
-
-  if (!row._described) {
-    row._described = {
-      ok: true,
-      name: row.name,
-      description: row.description,
-      parameters: row.parameters,
-      sourcePath: row.sourcePath,
-    };
-  }
-
-  return row._described;
-}