pi-supernova 0.0.1

package/runtime.js

@@ -0,0 +1,243 @@
+
+import { packageFinalReturn } from "./bottleneck.js";
+import { parallel as runParallel, pipeline as runPipeline } from "./parallel.js";
+import { performance } from "node:perf_hooks";
+import { isString, isFunction, isObject } from "./decode.js";
+
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+
+const compiledCache = new Map();
+const COMPILED_CACHE_MAX = 256;
+
+function wrapBody(code) {
+  const trimmed = String(code || "").trim();
+  if (!trimmed) throw new Error("code must be a non-empty string");
+
+  if (/^(async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed)) {
+    return `const __fn = (${trimmed});\nreturn await __fn();`;
+  }
+  if (/^async\s+function\b/.test(trimmed) || /^function\b/.test(trimmed)) {
+    return `const __fn = (${trimmed});\nreturn await __fn();`;
+  }
+  return trimmed;
+}
+
+export async function runGuestProgram(options) {
+  const { code, nova, config, signal, onTimeout } = options;
+  const maxCode = config.maxCodeChars ?? 48000;
+  if (code.length > maxCode) {
+    return {
+      ok: false,
+      error: `code exceeds ${maxCode} characters`,
+      logs: [],
+      wallMs: 0,
+    };
+  }
+
+  const logs = [];
+  const started = performance.now();
+  const timeoutMs = config.timeoutMs ?? 60000;
+
+  const scopedConsole = {
+    log: (...args) => pushLog(logs, args, config),
+    warn: (...args) => pushLog(logs, args, config),
+    error: (...args) => pushLog(logs, args, config),
+    info: (...args) => pushLog(logs, args, config),
+  };
+
+  let body;
+  try {
+    body = wrapBody(code);
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      logs,
+      wallMs: Math.round(performance.now() - started),
+    };
+  }
+
+  let compiled = compiledCache.get(body);
+  if (!compiled) {
+    compiled = new AsyncFunction(
+      "nova",
+      "tools",
+      "console",
+      "parallel",
+      "pipeline",
+      "read",
+      "write",
+      "edit",
+      "patch",
+      "surface",
+      "snap",
+      "bash",
+      "exec",
+      "speculate",
+      body,
+    );
+    if (compiledCache.size >= COMPILED_CACHE_MAX) {
+      const first = compiledCache.keys().next().value;
+      if (first !== undefined) compiledCache.delete(first);
+    }
+    compiledCache.set(body, compiled);
+  }
+
+  const abortError = new Error("supernova timed out or aborted");
+  const timeoutPromise = sleepReject(timeoutMs, abortError, signal, () => {
+    try {
+      onTimeout?.();
+    } catch {
+    }
+  });
+
+  const unwrapValue = (res) => {
+    if (res && isObject(res) && "value" in res) {
+      if (res.details?.isSnap && isString(res.value)) {
+        try {
+          return JSON.parse(res.value);
+        } catch {
+          return res.value;
+        }
+      }
+      if (res.details?.batch && Array.isArray(res.details?.items)) {
+        return res.details.items;
+      }
+      return res.value;
+    }
+    return res;
+  };
+
+  const guestRead = async (p, off, lim) => {
+    if (Array.isArray(p)) {
+      return await Promise.all(p.map((item) => guestRead(item, off, lim)));
+    }
+    const res = await nova.call("read", { path: p, offset: off, limit: lim });
+    return unwrapValue(res);
+  };
+  const guestWrite = async (p, c) => unwrapValue(await nova.call("write", { path: p, content: c }));
+  const guestEdit = async (p, oldOrDiff, newText) => {
+    const res = await nova.call("edit", { path: p, oldText: oldOrDiff, newText });
+    return unwrapValue(res);
+  };
+  const guestPatch = async (p, d) => unwrapValue(await nova.call("apply_patch", { path: p, patch: d }));
+  const guestSurface = async (p) => {
+    const res = await (isFunction(nova.surface) ? nova.surface(p) : nova.call("surface", { path: p }));
+    return unwrapValue(res);
+  };
+  const guestSnap = async (q, p) => {
+    const res = await (isFunction(nova.snap) ? nova.snap(q, p) : nova.call("snap", { query: q, path: p }));
+    return unwrapValue(res);
+  };
+  const guestBash = async (cmd, opts) => {
+    const res = await nova.call("bash", { command: cmd, ...opts });
+    if (res?.ok === false) {
+      const detail = isString(res?.details) ? res.details : "";
+      throw new Error(res?.value || detail || `command failed: ${cmd}`);
+    }
+    return unwrapValue(res);
+  };
+  const quoteShellArg = (value) => `'${String(value).replaceAll("'", "'\\''")}'`;
+  const guestExec = async (cmd, args, opts) => {
+    const argv = [cmd, ...(Array.isArray(args) ? args : [])].map(quoteShellArg).join(" ");
+    return guestBash(argv, opts);
+  };
+  const guestSpeculate = async (fn) => (isFunction(nova.speculate) ? nova.speculate(fn) : fn());
+
+  let settled = false;
+  const runPromise = Promise.resolve(
+    compiled(
+      nova,
+      nova,
+      scopedConsole,
+      runParallel,
+      runPipeline,
+      guestRead,
+      guestWrite,
+      guestEdit,
+      guestPatch,
+      guestSurface,
+      guestSnap,
+      guestBash,
+      guestExec,
+      guestSpeculate,
+    ),
+  );
+  runPromise.catch((err) => {
+    if (!settled) return;
+    pushLog(logs, [`[late guest error] ${err instanceof Error ? err.message : String(err)}`], config);
+  });
+  timeoutPromise.catch(() => {
+  });
+
+  try {
+    const resultValue = await Promise.race([runPromise, timeoutPromise]);
+    settled = true;
+    const packaged = packageFinalReturn(resultValue, logs, config);
+    return {
+      ok: true,
+      result: packaged.returnValue,
+      resultText: packaged.returnText,
+      returnTruncated: packaged.returnTruncated,
+      logs: packaged.logs,
+      logTruncated: packaged.logTruncated,
+      wallMs: Math.round(performance.now() - started),
+    };
+  } catch (err) {
+    settled = true;
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      logs,
+      wallMs: Math.round(performance.now() - started),
+    };
+  } finally {
+    settled = true;
+    timeoutPromise.clear();
+  }
+}
+
+function pushLog(logs, args, config) {
+  const maxLines = config.maxLogLines ?? 100;
+  if (logs.length >= maxLines) return;
+  const line = args
+    .map((a) => {
+      if (isString(a)) return a;
+      try {
+        return JSON.stringify(a);
+      } catch {
+        return String(a);
+      }
+    })
+    .join(" ");
+  logs.push(line);
+}
+
+function sleepReject(ms, error, signal, onFire) {
+  let timer;
+  let onAbort;
+  const fire = (reject) => {
+    try {
+      onFire?.();
+    } catch {
+    }
+    reject(error);
+  };
+  const promise = new Promise((_, reject) => {
+    timer = setTimeout(() => fire(reject), ms);
+    if (timer.unref) timer.unref();
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer);
+        fire(reject);
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+  promise.clear = () => {
+    clearTimeout(timer);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+  };
+  return promise;
+}

package/snap.js

@@ -0,0 +1,225 @@
+
+import * as path from "node:path";
+import { isString } from "./decode.js";
+import { extractStructuralSurface } from "./surface.js";
+
+const STOP_WORDS = new Set([
+  "the", "a", "an", "and", "or", "in", "on", "at", "to", "for", "of", "with",
+  "by", "from", "is", "it", "this", "that", "where", "how", "what", "which",
+  "file", "code", "function", "class", "method", "find", "get", "look",
+]);
+
+export function tokenizeQuery(query) {
+  if (!isString(query) || !query.trim()) {
+    return { tokens: [], wantsTest: false, wantsType: false, wantsDoc: false };
+  }
+
+  const raw = query
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .split(/[^a-zA-Z0-9_]+/);
+
+  const tokens = raw.filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+  const queryLower = query.toLowerCase();
+
+  return {
+    tokens: [...new Set(tokens)],
+    wantsTest: queryLower.includes("test") || queryLower.includes("spec"),
+    wantsType: queryLower.includes("type") || queryLower.includes("interface") || queryLower.includes("schema"),
+    wantsDoc: queryLower.includes("doc") || queryLower.includes("readme"),
+  };
+}
+
+export function scorePathTopology(filePath, tokens, { wantsTest, wantsDoc, wantsType }) {
+  const norm = filePath.replace(/\\/g, "/").toLowerCase();
+  const basename = path.basename(norm);
+  const ext = path.extname(norm);
+
+  const isTest = norm.includes("test") || norm.includes("spec") || norm.includes("__tests__");
+  if (isTest && !wantsTest) return -50;
+  if (!isTest && wantsTest) return -20;
+
+  if (norm.includes("node_modules/") || norm.includes("dist/") || norm.includes("target/")) {
+    return -100;
+  }
+
+  let score = 0;
+  const pathParts = norm.split(/[^a-zA-Z0-9]+/);
+
+  for (const token of tokens) {
+    if (basename === token || basename.startsWith(token + ".")) score += 60;
+    else if (basename.includes(token)) score += 30;
+    else if (pathParts.includes(token)) score += 15;
+    else if (norm.includes(token)) score += 5;
+  }
+
+  if ([".ts", ".js", ".mjs", ".rs", ".py", ".go"].includes(ext) && !wantsDoc) {
+    score += 5;
+  }
+  if (wantsType && [".ts", ".d.ts", ".rs", ".go"].includes(ext)) {
+    score += 10;
+  }
+
+  return score;
+}
+
+function scoreContentDefinitions(content, tokens) {
+  const lines = content.split("\n");
+  let score = 0;
+  let bestLine = 1;
+  let bestLineScore = 0;
+
+  const defRegex = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)/;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith("//") || line.startsWith("#") || line.startsWith("*")) continue;
+
+    let lineScore = 0;
+    const isDef = defRegex.test(line);
+
+    for (const token of tokens) {
+      if (line.toLowerCase().includes(token)) {
+        lineScore += isDef ? 40 : 5;
+      }
+    }
+
+    if (lineScore > bestLineScore) {
+      bestLineScore = lineScore;
+      bestLine = i + 1;
+    }
+    score += lineScore;
+  }
+
+  return { totalScore: score, bestLine, bestLineScore };
+}
+
+export async function executeSnap({ query, searchDir, vfs, runCommand }) {
+  const { tokens, wantsTest, wantsType, wantsDoc } = tokenizeQuery(query);
+  if (tokens.length === 0) {
+    throw new Error("snap requires at least one searchable concept keyword");
+  }
+
+  const dir = searchDir || process.cwd();
+  let fileList = [];
+  try {
+    const res = await runCommand(["rg", "--files", dir], { timeoutMs: 15_000 });
+    fileList = res.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
+  } catch {
+    fileList = [];
+  }
+
+  if (fileList.length === 0) {
+    throw new Error(`no files found to search in ${dir}`);
+  }
+
+  const scoredPaths = [];
+  for (const f of fileList) {
+    const score = scorePathTopology(f, tokens, { wantsTest, wantsDoc, wantsType });
+    if (score > 0) scoredPaths.push({ path: f, score });
+  }
+
+  scoredPaths.sort((a, b) => b.score - a.score);
+
+  let candidates = scoredPaths.filter((p) => p.score >= 25).slice(0, 10).map((p) => p.path);
+
+  if (candidates.length < 5) {
+    try {
+      const grepArgs = ["-l", "--max-count=1"];
+      if (!wantsTest) {
+        grepArgs.push("-g", "!test/**", "-g", "!tests/**", "-g", "!*.test.*", "-g", "!*.spec.*");
+      }
+      const salient = tokens.filter((t) => t.length > 2).slice(0, 4);
+      for (const t of salient) grepArgs.push("-e", t);
+      const res = await runCommand(["rg", ...grepArgs, dir], { timeoutMs: 15_000 });
+      const grepHits = res.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
+      const seen = new Set(candidates);
+      for (const h of grepHits) {
+        if (!seen.has(h)) {
+          seen.add(h);
+          candidates.push(h);
+          if (candidates.length >= 15) break;
+        }
+      }
+    } catch {
+      if (candidates.length === 0) candidates = fileList.slice(0, 5);
+    }
+  }
+
+  const candidateScores = [];
+
+  for (const filePath of candidates) {
+    let content = "";
+    try {
+      content = await vfs.read(filePath);
+    } catch {
+      continue;
+    }
+
+    const { totalScore, bestLine, bestLineScore } = scoreContentDefinitions(content, tokens);
+    const ext = path.extname(filePath);
+    const surface = extractStructuralSurface(content, ext);
+
+    let surfaceBonus = 0;
+    let signature = "";
+    let anchorLine = bestLine;
+
+    for (const item of surface.items) {
+      const nameLower = item.name.toLowerCase();
+      for (const token of tokens) {
+        if (nameLower.includes(token)) {
+          surfaceBonus += item.isExport ? 80 : 50;
+          if (!signature) {
+            signature = item.signature;
+            anchorLine = item.line;
+          }
+        }
+      }
+    }
+
+    const isTestFile = filePath.toLowerCase().includes("test") || filePath.toLowerCase().includes("spec");
+    const testAdjustment = isTestFile && !wantsTest ? -200 : (isTestFile && wantsTest ? 100 : 0);
+    const finalScore = totalScore + surfaceBonus + (bestLineScore * 2) + testAdjustment;
+    candidateScores.push({
+      path: filePath,
+      score: finalScore,
+      anchorLine,
+      signature,
+      content,
+    });
+  }
+
+  candidateScores.sort((a, b) => b.score - a.score);
+
+  if (candidateScores.length === 0 || candidateScores[0].score <= 0) {
+    const fallbackPath = candidates[0] || fileList[0];
+    return {
+      path: fallbackPath,
+      line: 1,
+      signature: "",
+      confidence: 0.3,
+      context: [],
+    };
+  }
+
+  const best = candidateScores[0];
+  const lines = best.content.split("\n");
+  const startLine = Math.max(1, best.anchorLine - 3);
+  const endLine = Math.min(lines.length, best.anchorLine + 8);
+
+  const contextLines = [];
+  for (let l = startLine; l <= endLine; l++) {
+    const marker = l === best.anchorLine ? "►" : " ";
+    contextLines.push(`${marker} ${String(l).padStart(4)} │ ${lines[l - 1]}`);
+  }
+
+  const confidence = Math.min(0.98, Math.max(0.65, best.score / 150));
+
+  return {
+    path: best.path,
+    line: best.anchorLine,
+    signature: best.signature,
+    confidence: Number(confidence.toFixed(2)),
+    context: contextLines,
+  };
+}

package/surface.js

@@ -0,0 +1,127 @@
+
+import { isString } from "./decode.js";
+
+function scanPython(lines) {
+  const items = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = /^([ \t]*)(def|class|async def)\s+([a-zA-Z0-9_]+)(\(.*?\))?:?/.exec(line);
+    if (!match) continue;
+    items.push({
+      kind: match[2].includes("def") ? "function" : "class",
+      name: match[3],
+      signature: match[0].trim(),
+      line: i + 1,
+      depth: Math.floor(match[1].length / 4),
+    });
+  }
+  return items;
+}
+
+function scanRust(lines) {
+  const items = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const match = /^(pub\s+)?(async\s+)?(fn|struct|enum|trait|impl|type|const)\s+([a-zA-Z0-9_]+)(<.*?>)?(\(.*?\))?/.exec(line);
+    if (!match) continue;
+    items.push({
+      kind: match[3],
+      name: match[4],
+      signature: line.replace(/\{.*$/, "").trim(),
+      line: i + 1,
+    });
+  }
+  return items;
+}
+
+function scanGo(lines) {
+  const items = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const funcMatch = /^func\s+(\(.*?\)\s+)?([a-zA-Z0-9_]+)(\(.*?\))/.exec(line);
+    if (funcMatch) {
+      items.push({
+        kind: "function",
+        name: funcMatch[2],
+        signature: line.replace(/\{.*$/, "").trim(),
+        line: i + 1,
+      });
+      continue;
+    }
+    const typeMatch = /^type\s+([a-zA-Z0-9_]+)\s+(struct|interface)/.exec(line);
+    if (typeMatch) {
+      items.push({
+        kind: typeMatch[2],
+        name: typeMatch[1],
+        signature: line.replace(/\{.*$/, "").trim(),
+        line: i + 1,
+      });
+    }
+  }
+  return items;
+}
+
+function scanJavaScript(lines) {
+  const items = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) continue;
+
+    const expMatch = /^export\s+(?:default\s+)?(?:async\s+)?(function\*?|class|const|let|var|type|interface|enum)\s+([a-zA-Z0-9_$]+)/.exec(line);
+    if (expMatch) {
+      items.push({
+        kind: expMatch[1],
+        name: expMatch[2],
+        isExport: true,
+        signature: line.replace(/\{.*$/, "").trim(),
+        line: i + 1,
+      });
+      continue;
+    }
+
+    const declMatch = /^(?:async\s+)?(function\*?|class)\s+([a-zA-Z0-9_$]+)/.exec(line);
+    if (declMatch) {
+      items.push({
+        kind: declMatch[1],
+        name: declMatch[2],
+        isExport: false,
+        signature: line.replace(/\{.*$/, "").trim(),
+        line: i + 1,
+      });
+      continue;
+    }
+
+    const tsMatch = /^(interface|type)\s+([a-zA-Z0-9_$]+)/.exec(line);
+    if (tsMatch) {
+      items.push({
+        kind: tsMatch[1],
+        name: tsMatch[2],
+        isExport: false,
+        signature: line.replace(/\{.*$/, "").trim(),
+        line: i + 1,
+      });
+    }
+  }
+  return items;
+}
+
+const SCANNERS = {
+  py: scanPython,
+  rs: scanRust,
+  go: scanGo,
+  js: scanJavaScript,
+  ts: scanJavaScript,
+  jsx: scanJavaScript,
+  tsx: scanJavaScript,
+  mjs: scanJavaScript,
+  cjs: scanJavaScript,
+};
+
+export function extractStructuralSurface(code, extension = "js") {
+  if (!isString(code) || !code.trim()) return { items: [], lineCount: 0 };
+  const lines = code.split("\n");
+  const ext = extension.replace(/^\./, "").toLowerCase();
+  const scanner = SCANNERS[ext] || SCANNERS.js;
+  const items = scanner(lines);
+  return { items, lineCount: lines.length };
+}