pi-supernova 0.0.15 → 0.2.0

package/decode.js

@@ -4,3 +4,64 @@ export const isString = (v) => toStr.call(v) === "[object String]";
 export const isObject = (v) => toStr.call(v) === "[object Object]";
 export const isFunction = (v) => toStr.call(v) === "[object Function]" || v instanceof Function;
 export const isNumber = (v) => toStr.call(v) === "[object Number]" && Number.isFinite(v);
+
+const MAX_DEPTH = 64;
+const MAX_TYPED_ARRAY = 4096;
+
+function plainFromBinary(value) {
+  const bytes = value.byteLength;
+  if (value instanceof ArrayBuffer) value = new Uint8Array(value);
+  else if (value instanceof DataView) value = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  if (value.length > MAX_TYPED_ARRAY) return "[" + value.constructor.name + " " + bytes + " bytes]";
+  return value instanceof BigInt64Array || value instanceof BigUint64Array
+    ? Array.from(value, x => x.toString() + "n")
+    : Array.from(value);
+}
+
+function plainFromMap(value, seen, depth) {
+  const allStringKeys = [...value.keys()].every(isString);
+  if (!allStringKeys) return [...value].map(([k, v]) => [toPlain(k, seen, depth + 1), toPlain(v, seen, depth + 1)]);
+  const out = Object.create(null);
+  for (const [k, v] of value) out[k] = toPlain(v, seen, depth + 1);
+  return out;
+}
+
+function plainFromCollection(value, seen, depth) {
+  if (Array.isArray(value)) return value.map((x) => toPlain(x, seen, depth + 1));
+  if (value instanceof Set) return [...value].map((x) => toPlain(x, seen, depth + 1));
+  if (value instanceof Map) return plainFromMap(value, seen, depth);
+  const out = Object.create(null);
+  for (const k of Object.keys(value)) out[k] = toPlain(value[k], seen, depth + 1);
+  return out;
+}
+
+/** Convert any guest value to structured-clone-safe, JSON-shaped data. */
+export function toPlain(value, seen = new Set(), depth = 0) {
+  if (value === null || value === undefined) return value;
+  const tag = toStr.call(value);
+  if (tag === "[object String]" || tag === "[object Number]" || tag === "[object Boolean]") return value.valueOf();
+  if (tag === "[object BigInt]") return value.toString() + "n";
+  if (isFunction(value)) return "[Function" + (value.name ? " " + value.name : "") + "]";
+  if (tag === "[object Symbol]") return value.toString();
+  if (depth > MAX_DEPTH) return "[Depth]";
+  if (seen.has(value)) return "[Circular]";
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+  if (value instanceof RegExp) return value.toString();
+  if (value instanceof Error) {
+    const out = { name: value.name, message: value.message };
+    if (value.cause !== undefined) out.cause = toPlain(value.cause, seen, depth + 1);
+    return out;
+  }
+  if (value instanceof Promise) return "[Promise]";
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return plainFromBinary(value);
+  if (isFunction(value.toJSON)) return toPlain(value.toJSON(), seen, depth + 1);
+  seen.add(value);
+  try {
+    return plainFromCollection(value, seen, depth);
+  } finally {
+    seen.delete(value);
+  }
+}
+
+// ---- RPC to the host thread ----
+

package/evidence.js

@@ -309,7 +309,7 @@ function normalize(scores) {
 
 // ---- candidate files (boundary + topology + entity hits) ----
 
-function candidateFiles(files, profile, index, limit) {
+function candidateFiles(files, profile, index, limit, overlayText) {
   const scored = [];
   for (const f of files) {
     const s = scorePathTopology(f, profile.keywords, profile.flags);
@@ -318,7 +318,11 @@ function candidateFiles(files, profile, index, limit) {
   scored.sort((a, b) => b.s - a.s);
   const chosen = new Set(scored.slice(0, limit).map(({ f }) => f));
   const anchors = (profile.subjects.length ? profile.subjects : profile.keywords).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
-  const hits = anchors.length ? index.filesContaining(files, anchors, true) : [];
+  const pendingHits = files.filter(file => {
+    const pending = overlayText(file);
+    return pending !== undefined && anchors.some(anchor => pending.toLowerCase().includes(anchor));
+  });
+  const hits = anchors.length ? [...new Set([...pendingHits, ...index.filesContaining(files, anchors, true)])] : [];
   for (const f of hits) {
     if (chosen.size >= limit) break;
     if (profile.flags.wantsTest || scorePathTopology(f, profile.keywords, profile.flags) > -50) chosen.add(f);
@@ -385,14 +389,19 @@ function render(spans, picks, fused, opts, root) {
  * R(q): top-K provenance-bearing source spans for a concept query, selected without any model call.
  * @returns {{ route: string, spans: Array<{path, lines, name, kind, why, text}> }}
  */
-export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, options = {} }) {
+export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, pendingPaths = [], options = {} }) {
   const opts = { ...EVIDENCE_DEFAULTS, ...options };
   const profile = profileQuery(query);
   if (profile.keywords.length === 0) throw new Error("evidence requires at least one searchable concept keyword");
-  const files = await index.files(searchDir || root);
+  const searchRoot = path.resolve(searchDir || root);
+  const staged = pendingPaths.filter(file => {
+    const relative = path.relative(searchRoot, file);
+    return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+  });
+  const files = [...new Set([...await index.files(searchRoot), ...staged])];
   if (files.length === 0) throw new Error(`no files found to search in ${searchDir || root}`);
 
-  const { files: chosenFiles, fileScores } = candidateFiles(files, profile, index, opts.maxCandidateFiles);
+  const { files: chosenFiles, fileScores } = candidateFiles(files, profile, index, opts.maxCandidateFiles, overlayText);
   const spans = [];
   for (const f of chosenFiles) {
     const pending = overlayText(f);

package/format.js

@@ -1,4 +1,4 @@
-import { isString } from "./decode.js";
+import { isString, isObject } from "./decode.js";
 
 export function truncateChars(text, maxChars, label = "value") {
   const normalized = isString(text) ? text : String(text ?? "");
@@ -12,22 +12,21 @@ export function truncateChars(text, maxChars, label = "value") {
       originalChars: normalized.length,
     };
   }
-  const head = headEnd(normalized, Math.floor(limit * 0.7));
-  let tail = Math.max(0, limit - head);
+  let head = headEnd(normalized, Math.floor(limit * 0.7));
+  let tail = 0;
   let marker = "";
-  let previousTail = -1;
-  while (tail !== previousTail) {
-    previousTail = tail;
+  for (;;) {
     const omitted = normalized.length - head - tail;
-    marker = `\n…[${label} truncated ${omitted} chars]…\n`;
-    tail = Math.max(0, limit - head - marker.length);
+    marker = "\n…[" + label + " truncated " + omitted + " chars]…\n";
+    if (marker.length > limit) return { text: normalized.slice(0, headEnd(normalized, limit)), truncated: true, originalChars: normalized.length };
+    const budget = limit - marker.length;
+    const nextHead = headEnd(normalized, Math.min(head, budget));
+    const nextTail = normalized.length - tailStartIndex(normalized, Math.max(0, budget - nextHead));
+    if (nextHead === head && nextTail === tail) break;
+    head = nextHead;
+    tail = nextTail;
   }
-  const tailStart = tailStartIndex(normalized, tail);
-  return {
-    text: normalized.slice(0, head) + marker + normalized.slice(tailStart),
-    truncated: true,
-    originalChars: normalized.length,
-  };
+  return { text: normalized.slice(0, head) + marker + normalized.slice(normalized.length - tail), truncated: true, originalChars: normalized.length };
 }
 
 // Lone surrogates in a tool result make the message invalid UTF-8 at the API
@@ -53,7 +52,7 @@ function formatKey(key) {
 
 function formatPrimitive(value) {
   if (value === undefined) return "undefined";
-  if (typeof value === "number" && !Number.isFinite(value)) return String(value);
+  if (Number.isNaN(value) || value === Infinity || value === -Infinity) return String(value);
   return JSON.stringify(value) ?? String(value);
 }
 
@@ -65,7 +64,7 @@ function formatFlatList(value) {
 }
 
 function formatFlat(value) {
-  if (value === null || typeof value !== "object") return formatPrimitive(value);
+  if ((!isObject(value) && !Array.isArray(value))) return formatPrimitive(value);
   if (Array.isArray(value)) return formatFlatList(value);
   let out = "";
   for (const key of Object.keys(value)) {
@@ -83,7 +82,7 @@ function formatFlat(value) {
  */
 export function formatValue(value, indent = "", width = FORMAT_WIDTH) {
   const flat = formatFlat(value);
-  if (value === null || typeof value !== "object" || flat.length + indent.length <= width) return flat;
+  if ((!isObject(value) && !Array.isArray(value)) || flat.length + indent.length <= width) return flat;
   const pad = indent + " ";
   if (Array.isArray(value)) {
     if (value.length === 0) return "[]";

package/guest-worker.js

@@ -1,95 +1,15 @@
 import { parentPort } from "node:worker_threads";
 import { parallel as runParallel, pipeline as runPipeline } from "./parallel.js";
-import { isString, isFunction, isObject } from "./decode.js";
+import { isString, isObject, toPlain } from "./decode.js";
+import { truncateChars } from "./format.js";
 
 // Guest programs run here, off the host thread. The host can terminate() this
 // worker mid-loop, so a runaway "while (true) {}" or process.exit() in guest
 // code cannot take the harness down with it.
 
 const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
-const compiledCache = new Map();
-const COMPILED_CACHE_MAX = 256;
-const PARAMS = [
-  "nova", "console", "parallel", "pipeline",
-  "read", "write", "edit", "patch", "surface", "snap", "evidence", "bash", "exec", "speculate",
-];
-// V8 and JSC both place the body on the line after the synthesized header.
+const PARAMS = ["nova", "console", "parallel", "pipeline", "read", "write", "edit", "patch", "surface", "snap", "evidence", "bash", "exec", "speculate"];
 const BODY_LINE_OFFSET = 2;
-
-function skipLeadingComments(src) {
-  let i = 0;
-  for (;;) {
-    while (/\s/.test(src[i])) i++;
-    if (src.startsWith("//", i)) {
-      const nl = src.indexOf("\n", i);
-      if (nl < 0) return src.length;
-      i = nl + 1;
-    } else if (src.startsWith("/*", i)) {
-      const end = src.indexOf("*/", i + 2);
-      if (end < 0) return src.length;
-      i = end + 2;
-    } else {
-      return i;
-    }
-  }
-}
-
-function skipString(src, j, quote) {
-  for (j++; j < src.length && src[j] !== quote; j++) if (src[j] === "\\") j++;
-  return j;
-}
-
-function skipBalancedParens(src, i) {
-  let depth = 0;
-  for (let j = i; j < src.length; j++) {
-    const ch = src[j];
-    if (ch === "(") {
-      depth++;
-      continue;
-    }
-    if (ch === ")") {
-      depth--;
-      if (depth === 0) return j + 1;
-      continue;
-    }
-    if ("\"'\u0060".includes(ch)) j = skipString(src, j, ch);
-  }
-  return -1;
-}
-
-/** True when src (after comments) is a single arrow or function expression. */
-function isFunctionExpression(src) {
-  let i = skipLeadingComments(src);
-  const rest = src.slice(i);
-  if (/^(async\s+)?function\b/.test(rest)) return true;
-  const asyncMatch = /^async\s+/.exec(rest);
-  if (asyncMatch) i += asyncMatch[0].length;
-  if (/^[A-Za-z_$][\w$]*\s*=>/.test(src.slice(i))) return true;
-  if (src[i] !== "(") return false;
-  const after = skipBalancedParens(src, i);
-  if (after < 0) return false;
-  return /^\s*=>/.test(src.slice(after));
-}
-
-function wrapBody(code) {
-  const trimmed = String(code).trim();
-  if (!trimmed) throw new Error("code must be a non-empty string");
-  if (isFunctionExpression(trimmed)) return "const __fn = (" + trimmed + ");\nreturn await __fn();";
-  return trimmed;
-}
-
-function compile(code) {
-  const body = wrapBody(code);
-  let compiled = compiledCache.get(body);
-  if (compiled) return compiled;
-  compiled = new AsyncFunction(...PARAMS, body);
-  if (compiledCache.size >= COMPILED_CACHE_MAX) {
-    compiledCache.delete(compiledCache.keys().next().value);
-  }
-  compiledCache.set(body, compiled);
-  return compiled;
-}
-
 /** Best-effort guest line:col from an error stack (V8 "<anonymous>:L:C", JSC "eval code").*/
 function guestLocation(err) {
   const stack = String(err?.stack);
@@ -100,64 +20,8 @@ function guestLocation(err) {
   return { line, col: Number(m[2]) };
 }
 
-const MAX_DEPTH = 64;
-const MAX_TYPED_ARRAY = 4096;
-
-function plainFromBinary(value) {
-  const bytes = value.byteLength;
-  if (value instanceof ArrayBuffer) value = new Uint8Array(value);
-  if (value.length > MAX_TYPED_ARRAY) return "[" + value.constructor.name + " " + bytes + " bytes]";
-  return Array.from(value, (x) => (typeof x === "bigint" ? x.toString() + "n" : x));
-}
-
-function plainFromMap(value, seen, depth) {
-  const allStringKeys = [...value.keys()].every((k) => typeof k === "string");
-  if (!allStringKeys) return [...value].map(([k, v]) => [toPlain(k, seen, depth + 1), toPlain(v, seen, depth + 1)]);
-  const out = {};
-  for (const [k, v] of value) out[k] = toPlain(v, seen, depth + 1);
-  return out;
-}
-
-function plainFromCollection(value, seen, depth) {
-  if (Array.isArray(value)) return value.map((x) => toPlain(x, seen, depth + 1));
-  if (value instanceof Set) return [...value].map((x) => toPlain(x, seen, depth + 1));
-  if (value instanceof Map) return plainFromMap(value, seen, depth);
-  const out = {};
-  for (const k of Object.keys(value)) out[k] = toPlain(value[k], seen, depth + 1);
-  return out;
-}
-
-/** Convert any guest value to structured-clone-safe, JSON-shaped data. */
-function toPlain(value, seen = new Set(), depth = 0) {
-  if (value === null || value === undefined) return value;
-  const t = typeof value;
-  if (t === "string" || t === "number" || t === "boolean") return value;
-  if (t === "bigint") return value.toString() + "n";
-  if (t === "function") return "[Function" + (value.name ? " " + value.name : "") + "]";
-  if (t === "symbol") return value.toString();
-  if (depth > MAX_DEPTH) return "[Depth]";
-  if (seen.has(value)) return "[Circular]";
-  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-  if (value instanceof RegExp) return value.toString();
-  if (value instanceof Error) {
-    const out = { name: value.name, message: value.message };
-    if (value.cause !== undefined) out.cause = toPlain(value.cause, seen, depth + 1);
-    return out;
-  }
-  if (value instanceof Promise) return "[Promise]";
-  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return plainFromBinary(value);
-  if (isFunction(value.toJSON)) return toPlain(value.toJSON(), seen, depth + 1);
-  seen.add(value);
-  try {
-    return plainFromCollection(value, seen, depth);
-  } finally {
-    seen.delete(value);
-  }
-}
-
-// ---- RPC to the host thread ----
-
 let activeRunId = 0;
+let runActive = false;
 let rpcSeq = 0;
 const pendingRpc = new Map();
 
@@ -165,12 +29,13 @@ function post(msg) {
   parentPort.postMessage(msg);
 }
 
-function rpc(method, args) {
+function callRpc(runId, method, args) {
+  if (!runActive || runId !== activeRunId) return Promise.reject(new Error("program is already complete"));
   return new Promise((resolve, reject) => {
     const id = ++rpcSeq;
     pendingRpc.set(id, { resolve, reject });
     try {
-      post({ op: "rpc", id, runId: activeRunId, method, args });
+      post({ op: "rpc", id, runId, method, args });
     } catch (err) {
       pendingRpc.delete(id);
       reject(new Error("nova." + method + " arguments are not transferable: " + err?.message));
@@ -179,6 +44,7 @@ function rpc(method, args) {
 }
 
 function unwrapValue(res) {
+  if (res?.ok === false) throw new Error(String(res.value ?? res.error ?? "host tool failed"));
   if ("value" in Object(res)) return res.value;
   return res;
 }
@@ -201,7 +67,8 @@ function leanEnvelope(res) {
   return res;
 }
 
-function buildGuestApi(available) {
+function buildGuestApi(available, batchRead, runId) {
+  const rpc = (method, args) => callRpc(runId, method, args);
   const availableSet = new Set(available);
   const nova = {
     search: (query, limit) => rpc("search", [query, limit]),
@@ -238,7 +105,9 @@ function buildGuestApi(available) {
   const readArgs = (p, a, b) => (isObject(a) && !Array.isArray(a) ? { path: p, ...a } : { path: p, offset: a, limit: b });
   const read = async (p, a, b) => {
     if (Array.isArray(p)) {
+      if (!batchRead) return Promise.all(p.map(item => read(item, a, b)));
       const res = await nova.call("read", readArgs(p, a, b));
+      unwrapValue(res);
       if (Array.isArray(res?.items)) return res.items;
       // Captured host executor without batch support: fan out.
       return Promise.all(p.map((item) => read(item, a, b)));
@@ -277,8 +146,13 @@ function buildGuestApi(available) {
 
 function makeConsole(runId, limits) {
   let count = 0;
+  let truncated = false;
+  const markTruncated = () => {
+    if (!truncated) post({ op: "logTruncated", runId });
+    truncated = true;
+  };
   const emit = (...args) => {
-    if (count >= limits.maxLogLines) return;
+    if (count >= limits.maxLogLines) { markTruncated(); return; }
     count++;
     const line = args
       .map((a) => {
@@ -290,30 +164,34 @@ function makeConsole(runId, limits) {
         }
       })
       .join(" ");
-    post({ op: "log", runId, line: line.length > limits.maxLogLineChars ? line.slice(0, limits.maxLogLineChars) + "…" : line });
+    const clipped = truncateChars(line, limits.maxLogLineChars, "log");
+    if (clipped.truncated) markTruncated();
+    post({ op: "log", runId, line: clipped.text, truncated: clipped.truncated });
   };
   return { log: emit, warn: emit, error: emit, info: emit, debug: emit };
 }
 
 function postFailure(runId, err, location) {
+  runActive = false;
   const message = err instanceof Error ? err.message : String(err);
   post({ op: "error", runId, message, location });
 }
 
 async function handleRun(msg) {
-  const { runId, code, limits, available } = msg;
+  const { runId, prepared, limits, available, batchRead = true } = msg;
   activeRunId = runId;
+  runActive = true;
   let compiled;
   try {
-    compiled = compile(code);
+    compiled = { fn: new AsyncFunction(...PARAMS, prepared.body), hasReturn: prepared.hasReturn };
   } catch (err) {
     postFailure(runId, err);
     return;
   }
-  const api = buildGuestApi(available);
+  const api = buildGuestApi(available, batchRead, runId);
   const scopedConsole = makeConsole(runId, limits);
   try {
-    const value = await compiled(
+    const value = await compiled.fn(
       api.nova, scopedConsole, runParallel, runPipeline,
       api.read, api.write, api.edit, api.patch, api.surface, api.snap, api.evidence, api.bash, api.exec, api.speculate,
     );
@@ -324,7 +202,8 @@ async function handleRun(msg) {
     } catch (err) {
       plain = "[unserializable: " + (err?.message || err) + "]";
     }
-    post({ op: "done", runId, value: plain, undefinedReturn: value === undefined, hasReturn: /\breturn\b/.test(code) });
+    runActive = false;
+    post({ op: "done", runId, value: plain, undefinedReturn: value === undefined && !compiled.hasReturn, hasReturn: compiled.hasReturn });
   } catch (err) {
     if (runId !== activeRunId) return;
     postFailure(runId, err, guestLocation(err));