pi-supernova 0.0.15 → 0.1.0

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));

package/host-bridge.js

@@ -1,7 +1,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { packageHostResult } from "./bottleneck.js";
+import { packageHostResult, hostResultFailed } from "./bottleneck.js";
 import { isString, isNumber, isFunction, isObject } from "./decode.js";
 import { isMutatingTool, runParallelWave } from "./parallel.js";
 import { unknownToolMessage } from "./catalog.js";
@@ -79,7 +79,7 @@ function applyReplacements(target, content, requestedEdits) {
     if (index < 0) {
       throw new Error(`edit target not found in ${target}: oldText must match the file byte-for-byte (read() it first; check whitespace and quotes)`);
     }
-    if (content.indexOf(replacement.oldText, index + replacement.oldText.length) >= 0) {
+    if (content.indexOf(replacement.oldText, index + 1) >= 0) {
       throw new Error(`edit target is not unique in ${target}: include more surrounding lines in oldText, or pass edits:[{oldText,newText},…]`);
     }
     return { ...replacement, index, end: index + replacement.oldText.length };
@@ -113,15 +113,16 @@ async function formatLsEntry(dirPath, entry) {
 
 function createNativeAdapters(getCwd, vfs, config, index, ledger) {
   async function readAdapter(params, signal) {
+      signal?.throwIfAborted();
       const cwd = getCwd();
       const targetParam = params?.path ?? params?.target;
 
       if (Array.isArray(targetParam)) {
         const results = await Promise.all(
-          targetParam.map((p) => readAdapter({ path: p, offset: params?.offset, limit: params?.limit }, signal)),
+          targetParam.map((p) => readAdapter({ ...params, path: p }, signal)),
         );
         const items = results.map((r) => r.content[0].text);
-        return textResult(items.join("\n---\n"), { count: results.length, batch: true, items });
+        return textResult("", { count: results.length, batch: true, items });
       }
 
       if (looksLikePath(targetParam)) {
@@ -281,7 +282,8 @@ function createNativeAdapters(getCwd, vfs, config, index, ledger) {
       const cwd = getCwd();
       const target = await resolveWorkspacePath(cwd, params?.path, "write", false);
       if (signal?.aborted) throw new Error("aborted");
-      const content = String(params?.content ?? "");
+      if (!isString(params?.content)) throw new Error("write requires string content");
+      const content = params.content;
       let prevText = "";
       try {
         prevText = await vfs.read(target);
@@ -308,7 +310,6 @@ function createNativeAdapters(getCwd, vfs, config, index, ledger) {
         matches.length === 1
           ? buildEditDiff(target, content, matches[0].oldText, matches[0].newText)
           : buildMultiEditDiff(target, content, matches);
-      const tag = speculative ? " (speculative)" : "";
       const summary = await editSummary(cwd, target, content, updated, diff);
       return textResult(summary, { path: target, speculative, diff });
     },
@@ -367,7 +368,7 @@ function createNativeAdapters(getCwd, vfs, config, index, ledger) {
       const options = {};
       if (Number.isInteger(params?.k) && params.k > 0) options.k = params.k;
       if (Number.isInteger(params?.maxChars) && params.maxChars > 0) options.maxChars = params.maxChars;
-      const res = await selectEvidence({ query: params.query, root: cwd, searchDir, index, overlayText: (p) => vfs.getOverlay(p), options });
+      const res = await selectEvidence({ query: params.query, root: cwd, searchDir, index, overlayText: (p) => vfs.getOverlay(p), pendingPaths: vfs.getOverlayPaths(), options });
       for (const span of res.spans) ledger.recordOrigin(span.path, span.lines[0], span.text.split("\n"));
       return textResult(JSON.stringify(res), { route: res.route, count: res.spans.length });
     },
@@ -408,7 +409,7 @@ function createNativeAdapters(getCwd, vfs, config, index, ledger) {
       if (res.exitCode !== 0) text += sourceForReferences(cwd, text);
       return {
         content: [{ type: "text", text }],
-        details: { exitCode: res.exitCode, outputTruncated: res.outputTruncated, transactionBarrier },
+        details: { exitCode: res.exitCode, signal: res.signal, outputTruncated: res.outputTruncated, transactionBarrier },
         isError: res.exitCode !== 0,
       };
     },
@@ -474,19 +475,24 @@ function createNativeAdapters(getCwd, vfs, config, index, ledger) {
   };
 }
 
-export function createHostBridge({ pi, config, getCwd }) {
-  const index = new WorkspaceIndex((argv, opts) => runCommand(argv, opts));
-  const ledger = new SeenLedger({ window: config.seenWindow ?? 40 });
+export function createHostBridge({ pi, config, getCwd, registry, ledger: runLedger }) {
+  const index = registry?.index ?? new WorkspaceIndex((argv, opts) => runCommand(argv, opts));
+  const ledger = runLedger ?? new SeenLedger({ window: config.seenWindow ?? 40 });
   const vfs = new CausalVfs(() => index.invalidate());
-  const executors = new Map();
+  const executors = registry?.executors ?? new Map();
+  const definitions = registry?.definitions ?? new Map();
+  const sharedRegistry = registry ?? { executors, definitions, index, callSeq: 0 };
+  let closed = false;
   const natives = createNativeAdapters(getCwd, vfs, config, index, ledger);
   let callCount = 0;
   let activeCtx = null;
+  let hostSession = null;
+  let boundSessionId;
   let activeSignal = undefined;
   let trace = [];
   let callListener = null;
 
-  if (pi && isFunction(pi.registerTool)) {
+  if (!registry && pi && isFunction(pi.registerTool)) {
     const original = pi.registerTool.bind(pi);
     const excluded = new Set(config.excludeTools || []);
     pi.registerTool = (tool) => {
@@ -498,6 +504,7 @@ export function createHostBridge({ pi, config, getCwd }) {
         !excluded.has(tool.name)
       ) {
         executors.set(tool.name, tool.execute.bind(tool));
+        definitions.set(tool.name, tool);
       }
       return original(tool);
     };
@@ -505,10 +512,52 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   function bindCallContext(ctx, signal) {
     activeCtx = ctx || null;
+    const sessionId = ctx?.sessionManager?.getSessionId?.();
+    boundSessionId = sessionId;
+    const registry = pi?.pi?.AgentRegistry?.global?.();
+    hostSession = sessionId && registry?.list
+      ? registry.list().map(ref => ref.session).find(session => !session?.isDisposed && session?.sessionManager?.getSessionId?.() === sessionId) ?? null
+      : null;
     activeSignal = signal;
+    vfs.signal = signal;
+  }
+
+  function hostTool(name) {
+    if (!hostSession) return undefined;
+    const metadata = definitions.get(name);
+    // Keep Supernova's transactional adapters for ordinary built-ins. Respect overrides.
+    if (Object.hasOwn(natives, name) && metadata?.sourceInfo?.source === "builtin") return undefined;
+    return hostSession.getToolForEvalBridge?.(name);
+  }
+
+  function isCallable(name) {
+    if (name === "supernova" || (config.excludeTools ?? []).includes(name)) return false;
+    if (hostSession) {
+      if (hostSession.isDisposed || hostSession.sessionManager.getSessionId() !== boundSessionId) return false;
+      if (!hostSession.getEvalBridgeToolNames().includes(name) && definitions.has(name)) return false;
+      return !!hostTool(name) || (Object.hasOwn(natives, name) && (!definitions.has(name) || definitions.get(name).sourceInfo?.source === "builtin"));
+    }
+    if (definitions.has(name) && isFunction(pi?.getActiveTools) && !pi.getActiveTools().includes(name)) return false;
+    return executors.has(name) || Object.hasOwn(natives, name);
+  }
+
+  function refreshTools() {
+    const tools = pi?.getAllTools?.() ?? [];
+    for (const tool of tools) {
+      if (!isString(tool?.name)) continue;
+      definitions.set(tool.name, { ...definitions.get(tool.name), ...tool });
+      if (!hostSession && isFunction(tool.execute)) executors.set(tool.name, tool.execute.bind(tool));
+    }
+    return [...definitions.values()].filter(tool => isCallable(tool.name));
+  }
+
+  function externalNames() {
+    return [...definitions.keys()].filter(name => !!hostTool(name) || executors.has(name));
   }
 
   function resetCallBudget() {
+    closed = false;
+    vfs.closed = false;
     callCount = 0;
     trace = [];
     // Files may change between programs (editor, git); never serve a stale run.
@@ -556,6 +605,7 @@ export function createHostBridge({ pi, config, getCwd }) {
   }
 
   function checkCallBudget(name) {
+    if (closed) throw new Error("program is already complete");
     const maxCalls = config.maxBridgeCalls ?? 256;
     callCount += 1;
     if (callCount > maxCalls) {
@@ -598,23 +648,35 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   async function invokeRaw(name, args) {
     checkCallBudget(name);
+    const callId = ++sharedRegistry.callSeq;
     assertCallableTarget(name);
+    if (!isCallable(name)) throw new Error(unknownToolMessage(name, [...definitions.keys(), ...Object.keys(natives)].filter(isCallable)));
 
     const record = { name, args: args || {}, time: Date.now() };
     trace.push(record);
     notifyCall(record);
 
     try {
-      const exec = executors.get(name);
+      const delegated = hostTool(name);
+      const exec = delegated ? delegated.execute.bind(delegated) : hostSession ? undefined : executors.get(name);
       if (exec) {
         const fallbackDiff = await writeFallbackDiff(name, args);
-        if (isMutatingTool(name, config)) await vfs.prepareExternalMutation(name);
-        const res = await exec(`supernova:${name}:${callCount}`, args || {}, activeSignal, undefined, activeCtx);
-        completeRecord(record, res, fallbackDiff);
-        return res;
+        const mutating = isMutatingTool(name, config, args, definitions.get(name));
+        if (mutating) await vfs.prepareExternalMutation(name);
+        if (activeSignal?.aborted || closed) throw new Error("aborted");
+        if (!isCallable(name)) throw new Error("tool is no longer enabled in this session: " + name);
+        try {
+          const res = await exec(`supernova:${name}:${callId}`, args || {}, activeSignal, undefined, delegated
+            ? { ...activeCtx, settings: hostSession.settings, toolNames: hostSession.getEvalBridgeToolNames(), autoApprove: false }
+            : activeCtx);
+          completeRecord(record, res, fallbackDiff);
+          return res;
+        } finally {
+          if (mutating) { vfs.invalidateCache(); index.invalidate(); clearPathCache(); }
+        }
       }
 
-      const native = natives[name];
+      const native = Object.hasOwn(natives, name) ? natives[name] : undefined;
       if (native) {
         const res = await native(args || {}, activeSignal);
         completeRecord(record, res);
@@ -633,7 +695,7 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   function finishRecord(record, res) {
     record.ms = Date.now() - record.time;
-    record.ok = res?.isError !== true && res?.details?.ok !== false;
+    record.ok = !hostResultFailed(res);
     const exitCode = isObject(res?.details) ? res.details.exitCode : undefined;
     if (Number.isInteger(exitCode) && exitCode !== 0) record.exitCode = exitCode;
   }
@@ -645,14 +707,16 @@ export function createHostBridge({ pi, config, getCwd }) {
   }
 
   async function callMany(calls) {
-    const list = Array.isArray(calls) ? calls : [];
+    if (!Array.isArray(calls)) throw new TypeError("nova.callMany requires an array");
+    const list = calls;
+    if (list.some(item => !isString(item?.name) || !item.name)) throw new TypeError("nova.callMany entries require a tool name");
     const thunks = list.map((item) => {
       const n = item?.name;
       const a = item?.args;
       return () => call(n, a);
     });
     const names = list.map((item) => item?.name).filter((n) => isString(n));
-    const wave = await runParallelWave(thunks, { names }, { mode: "auto", config });
+    const wave = await runParallelWave(thunks, { names, calls: list, definitions: names.map(name => definitions.get(name)) }, { mode: "auto", config });
     // Return a results array that also carries .mode/.reason, and is directly
     // iterable so `for (const r of await nova.callMany([...]))` works.
     const results = Array.isArray(wave.results) ? wave.results.slice() : [];
@@ -666,7 +730,16 @@ export function createHostBridge({ pi, config, getCwd }) {
 
   return {
     executors,
+    definitions,
     natives,
+    refreshTools,
+    isCallable,
+    externalNames,
+    supportsBatchRead: () => !hostTool("read") && !executors.has("read"),
+    fork(options) {
+      return createHostBridge({ pi, config, getCwd: options.getCwd, registry: sharedRegistry, ledger: ledger.fork() });
+    },
+    close() { closed = true; vfs.closed = true; },
     bindCallContext,
     resetCallBudget,
     getTrace,