pi-supernova 0.0.4 → 0.0.6

package/runtime.js

@@ -59,23 +59,32 @@ export async function runGuestProgram(options) {
 
   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,
-    );
+    try {
+      compiled = new AsyncFunction(
+        "nova",
+        "tools",
+        "console",
+        "parallel",
+        "pipeline",
+        "read",
+        "write",
+        "edit",
+        "patch",
+        "surface",
+        "snap",
+        "bash",
+        "exec",
+        "speculate",
+        body,
+      );
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+        logs,
+        wallMs: Math.round(performance.now() - started),
+      };
+    }
     if (compiledCache.size >= COMPILED_CACHE_MAX) {
       const first = compiledCache.keys().next().value;
       if (first !== undefined) compiledCache.delete(first);
@@ -108,6 +117,16 @@ export async function runGuestProgram(options) {
     return res;
   };
 
+  const unwrapJsonValue = (res) => {
+    const value = unwrapValue(res);
+    if (!isString(value)) return value;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  };
+
   const guestRead = async (p, off, lim) => {
     if (Array.isArray(p)) {
       return await Promise.all(p.map((item) => guestRead(item, off, lim)));
@@ -123,11 +142,11 @@ export async function runGuestProgram(options) {
   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);
+    return unwrapJsonValue(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);
+    return unwrapJsonValue(res);
   };
   const guestBash = async (cmd, opts) => {
     const res = await nova.call("bash", { command: cmd, ...opts });

package/snap.js

@@ -94,21 +94,46 @@ function scoreContentDefinitions(content, tokens) {
   return { totalScore: score, bestLine, bestLineScore };
 }
 
-export async function executeSnap({ query, searchDir, vfs, runCommand }) {
+function relativeHasSegment(relativePath, segmentName) {
+  return relativePath.split(path.sep).includes(segmentName);
+}
+
+function relativeHasHiddenSegment(relativePath) {
+  return relativePath.split(path.sep).some((segment) => segment.startsWith(".") && segment.length > 1);
+}
+
+export async function executeSnap({ query, searchDir, includeHidden = false, vfs, runCommand, pendingPaths = [] }) {
   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();
+  if (path.resolve(dir).split(path.sep).includes(".git")) {
+    throw new Error("snap cannot search Git metadata");
+  }
   let fileList = [];
   try {
-    const res = await runCommand(["rg", "--files", dir], { timeoutMs: 15_000 });
+    const rgArgs = ["rg", "--files"];
+    if (includeHidden) rgArgs.push("--hidden");
+    rgArgs.push("-g", "!.git/**", "-g", "!**/.git/**", dir);
+    const res = await runCommand(rgArgs, { timeoutMs: 15_000 });
     fileList = res.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
   } catch {
     fileList = [];
   }
 
+  const seenPaths = new Set(fileList.map((filePath) => path.resolve(filePath)));
+  for (const pendingPath of pendingPaths) {
+    const absolutePath = path.resolve(pendingPath);
+    const relativePath = path.relative(path.resolve(dir), absolutePath);
+    const escapesDir = relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath);
+    const hiddenRelativePath = relativeHasHiddenSegment(relativePath);
+    if (escapesDir || relativeHasSegment(relativePath, ".git") || (!includeHidden && hiddenRelativePath) || seenPaths.has(absolutePath)) continue;
+    seenPaths.add(absolutePath);
+    fileList.push(absolutePath);
+  }
+
   if (fileList.length === 0) {
     throw new Error(`no files found to search in ${dir}`);
   }
@@ -125,7 +150,8 @@ export async function executeSnap({ query, searchDir, vfs, runCommand }) {
 
   if (candidates.length < 5) {
     try {
-      const grepArgs = ["-l", "--max-count=1"];
+      const grepArgs = ["-l", "--max-count=1", "-g", "!.git/**", "-g", "!**/.git/**"];
+      if (includeHidden) grepArgs.push("--hidden");
       if (!wantsTest) {
         grepArgs.push("-g", "!test/**", "-g", "!tests/**", "-g", "!*.test.*", "-g", "!*.spec.*");
       }