pi-supernova 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-supernova",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "CodeMode for Pi and OMP: read, edit, write and bash, with transactional files, source views and shared-input program batches.",
   "type": "module",
   "author": "AdityaVG13",

package/src/context/fuzzy.js

@@ -40,10 +40,13 @@ export class Frecency {
   score(filePath, mtimeSec, now = Date.now() / 1000) {
     let total = 0;
     const cutoff = now - AI_MAX_HISTORY_DAYS * 86400;
+    const stamps = this.access.get(filePath);
 
-    for (const t of this.access.get(filePath) || []) {
-      if (t < cutoff) continue;
-      total += Math.exp(-AI_DECAY * ((now - t) / 86400));
+    if (stamps) {
+      for (const t of stamps) {
+        if (t < cutoff) continue;
+        total += Math.exp(-AI_DECAY * ((now - t) / 86400));
+      }
     }
 
     if (mtimeSec) {
@@ -74,33 +77,42 @@ function isBoundary(hay, i) {
 }
 
 /**
- * Greedy forward match with backward tightening (fzf v1). Returns null or
- * { score, start, end }. Score: +16 boundary, +8 consecutive, +4 case match, −1 per gap char.
+ * Greedy forward scan. Returns the match end or the needle index that failed
+ * (failAt), which the typo retry uses to prune deletions provably unable to
+ * match (see matchWithTypos).
  */
-function matchOnce(needle, hay, caseSensitive) {
-  const hayCmp = caseSensitive ? hay : hay.toLowerCase();
-  const nCmp = caseSensitive ? needle : needle.toLowerCase();
+function scanForward(nCmp, hayCmp) {
   let hi = 0;
-  let firstAt = -1;
 
   for (let ni = 0; ni < nCmp.length; ni++) {
     hi = hayCmp.indexOf(nCmp[ni], hi);
 
-    if (hi < 0) return null;
-
-    if (firstAt < 0) firstAt = hi;
+    if (hi < 0) return { failAt: ni };
     hi++;
   }
 
-  const end = hi;
+  return { end: hi, failAt: -1 };
+}
+
+/**
+ * Greedy forward match with backward tightening (fzf v1). Returns null or
+ * { score, start, end }. Score: +16 boundary, +8 consecutive, +4 case match, −1 per gap char.
+ * Lowered strings arrive precomputed: the needle once per query, the haystack
+ * once per path — never re-lowered per part or per typo variant.
+ */
+function matchOnce(part, pCmp, hay, hayCmp) {
+  const scan = scanForward(pCmp, hayCmp);
+
+  if (scan.failAt >= 0) return null;
+  const end = scan.end;
   // Tighten: walk backwards from end to find the latest possible start.
   let start = end;
 
-  for (let ni = nCmp.length - 1; ni >= 0; ni--) {
-    start = hayCmp.lastIndexOf(nCmp[ni], start - 1);
+  for (let ni = pCmp.length - 1; ni >= 0; ni--) {
+    start = hayCmp.lastIndexOf(pCmp[ni], start - 1);
   }
 
-  return { score: scoreAlignment(needle, nCmp, hay, hayCmp, start), start, end };
+  return { score: scoreAlignment(part, pCmp, hay, hayCmp, start), start, end };
 }
 
 /** +16 boundary, +8 consecutive, +4 exact-case, −1 per skipped haystack char. */
@@ -122,9 +134,14 @@ function scoreAlignment(needle, nCmp, hay, hayCmp, start) {
   return score;
 }
 
-function considerShorter(part, typosLeft, visit, best) {
-  for (let i = 0; i < part.length; i++) {
-    const m = visit(part.slice(0, i) + part.slice(i + 1), typosLeft - 1);
+function considerShorter(sub, subCmp, subLower, typosLeft, visit, best, maxDel) {
+  for (let i = 0; i <= maxDel; i++) {
+    const m = visit(
+      sub.slice(0, i) + sub.slice(i + 1),
+      subCmp.slice(0, i) + subCmp.slice(i + 1),
+      subLower.slice(0, i) + subLower.slice(i + 1),
+      typosLeft - 1,
+    );
 
     if (!m) continue;
     const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
@@ -135,46 +152,95 @@ function considerShorter(part, typosLeft, visit, best) {
   return best;
 }
 
-function matchWithTypos(needle, hay, maxTypos, caseSensitive) {
+// Failure pruning (exact, not heuristic): a deletion strictly after the
+// fail index preserves the failing prefix, so that child fails too — and
+// every deeper success deletes an early char first, which the unpruned
+// order reaches with the same typo count via memo. On success all
+// deletions are still explored (a shorter variant can outscore the -12).
+// This turns full-miss retries from O(len^typos) attempts into O(len×typos).
+function matchWithTypos(part, pCmp, partLower, hay, hayCmp, hayLowerOrNull, maxTypos) {
   const memo = new Map();
+  let hayLower = hayLowerOrNull;
 
-  const visit = (part, typosLeft) => {
-    const key = part + "\0" + typosLeft;
+  const visit = (sub, subCmp, subLower, typosLeft) => {
+    const key = sub + "\0" + typosLeft;
 
     if (memo.has(key)) return memo.get(key);
-    let best = matchOnce(part, hay, caseSensitive);
+    const scan = scanForward(subCmp, hayCmp);
+    let best = null;
+    let maxDel = sub.length - 1;
+
+    if (scan.failAt < 0) {
+      let start = scan.end;
+
+      for (let ni = subCmp.length - 1; ni >= 0; ni--) {
+        start = hayCmp.lastIndexOf(subCmp[ni], start - 1);
+      }
 
-    if (best) best = { ...best, typos: 0, exact: hay.toLowerCase() === part.toLowerCase() };
+      if (hayLower === null) hayLower = hay.toLowerCase();
+      best = {
+        score: scoreAlignment(sub, subCmp, hay, hayCmp, start),
+        start,
+        end: scan.end,
+        typos: 0,
+        exact: hayLower === subLower,
+      };
+    } else {
+      maxDel = scan.failAt;
+    }
 
-    if (typosLeft > 0) best = considerShorter(part, typosLeft, visit, best);
+    if (typosLeft > 0) best = considerShorter(sub, subCmp, subLower, typosLeft, visit, best, maxDel);
     memo.set(key, best);
 
     return best;
   };
 
-  return visit(needle, maxTypos);
+  return visit(part, pCmp, partLower, maxTypos);
+}
+
+function matchPart(part, pCmp, partLower, hay, hayCmp, hayLowerOrNull, maxTypos) {
+  const direct = matchOnce(part, pCmp, hay, hayCmp);
+
+  if (direct) {
+    const hayLower = hayLowerOrNull === null ? hay.toLowerCase() : hayLowerOrNull;
+
+    return { ...direct, typos: 0, exact: hayLower === partLower };
+  }
+
+  if (maxTypos <= 0 || part.length < 3 || part.length > 128) return null;
+
+  return matchWithTypos(part, pCmp, partLower, hay, hayCmp, hayLowerOrNull, maxTypos);
 }
 
 /** Best match allowing up to maxTypos skipped needle characters. */
 export function fuzzyMatch(needle, hay, { maxTypos = 0, caseSensitive = false } = {}) {
-  const direct = matchOnce(needle, hay, caseSensitive);
-
-  if (direct) return { ...direct, typos: 0, exact: hay.toLowerCase() === needle.toLowerCase() };
+  if (caseSensitive) return matchPart(needle, needle, needle.toLowerCase(), hay, hay, null, maxTypos);
 
-  if (maxTypos <= 0 || needle.length < 3 || needle.length > 128) return null;
+  const needleLower = needle.toLowerCase();
+  const hayLower = hay.toLowerCase();
 
-  return matchWithTypos(needle, hay, maxTypos, caseSensitive);
+  return matchPart(needle, needleLower, needleLower, hay, hayLower, hayLower, maxTypos);
 }
 
 export function smartCase(query) {
   return /[A-Z]/.test(query);
 }
 
+function splitDirSegs(dir) {
+  return dir.split("/").filter(Boolean);
+}
+
 /** fff distance penalty: directory hops from the current file's directory, floor −20. */
-function distancePenalty(currentDir, candidateDir) {
-  if (!currentDir) return 0;
-  const a = currentDir.split("/").filter(Boolean);
-  const b = candidateDir.split("/").filter(Boolean);
+function distancePenalty(currentSegs, candidateDir, dirCache) {
+  if (!currentSegs) return 0;
+  let b = dirCache.get(candidateDir);
+
+  if (!b) {
+    b = splitDirSegs(candidateDir);
+    dirCache.set(candidateDir, b);
+  }
+
+  const a = currentSegs;
   let common = 0;
 
   while (common < a.length && common < b.length && a[common] === b[common]) common++;
@@ -191,13 +257,14 @@ function partTypos(parts, ctx) {
   return ctx.maxTypos ?? (parts[0].length >= 6 ? 2 : parts[0].length >= 4 ? 1 : 0);
 }
 
-function scoredPath(rel, parts, maxTypos, caseSensitive, ctx, currentDir) {
-  const matched = matchParts(parts, rel, maxTypos, caseSensitive);
+function scoredPath(rel, parts, partLower, maxTypos, caseSensitive, ctx, currentSegs, dirCache) {
+  const hayCmp = caseSensitive ? rel : rel.toLowerCase();
+  const matched = matchParts(parts, partLower, rel, hayCmp, caseSensitive ? null : hayCmp, maxTypos, caseSensitive);
 
   if (!matched) return null;
   const { base, first, exact } = matched;
   const filenameStart = rel.lastIndexOf("/") + 1;
-  const boosts = filenameBonus(base, rel, filenameStart, first, parts[0]) + contextBoost(base, rel, ctx) + distancePenalty(currentDir, rel.slice(0, filenameStart));
+  const boosts = filenameBonus(base, rel, filenameStart, first, partLower[0]) + contextBoost(base, rel, ctx) + distancePenalty(currentSegs, rel.slice(0, filenameStart), dirCache);
 
   return { path: rel, score: base + boosts, exact, typos: first.typos };
 }
@@ -208,11 +275,17 @@ export function rankPaths(query, paths, ctx = {}) {
   if (parts.length === 0 || parts.length > 16) return [];
   const caseSensitive = smartCase(query);
   const maxTypos = partTypos(parts, ctx);
+  // Per-query hoists: lowered parts once (not once per path per part), the
+  // current directory split once (not once per candidate), plus a
+  // per-call cache for candidate directory segments (paths share dirs).
+  const partLower = parts.map((p) => p.toLowerCase());
   const currentDir = ctx.currentFile ? ctx.currentFile.slice(0, ctx.currentFile.lastIndexOf("/") + 1) : "";
+  const currentSegs = currentDir ? splitDirSegs(currentDir) : null;
+  const dirCache = new Map();
   const out = [];
 
   for (const rel of paths) {
-    const scored = scoredPath(rel, parts, maxTypos, caseSensitive, ctx, currentDir);
+    const scored = scoredPath(rel, parts, partLower, maxTypos, caseSensitive, ctx, currentSegs, dirCache);
 
     if (scored) out.push(scored);
   }
@@ -223,13 +296,13 @@ export function rankPaths(query, paths, ctx = {}) {
 }
 
 /** Every query part must match; later parts get at most one typo (fff narrows per part). Score is the average. */
-function matchParts(parts, rel, maxTypos, caseSensitive) {
+function matchParts(parts, partLower, rel, hayCmp, hayLowerOrNull, maxTypos, caseSensitive) {
   let sum = 0;
   let first = null;
   let exact = true;
 
   for (let pi = 0; pi < parts.length; pi++) {
-    const m = fuzzyMatch(parts[pi], rel, { maxTypos: pi === 0 ? maxTypos : Math.min(maxTypos, 1), caseSensitive });
+    const m = matchPart(parts[pi], caseSensitive ? parts[pi] : partLower[pi], partLower[pi], rel, hayCmp, hayLowerOrNull, pi === 0 ? maxTypos : Math.min(maxTypos, 1));
 
     if (!m) return null;
     first ??= m;
@@ -241,10 +314,10 @@ function matchParts(parts, rel, maxTypos, caseSensitive) {
 }
 
 /** fff: exact filename +40% of base, any filename match +20%. */
-function filenameBonus(base, rel, filenameStart, first, needle) {
+function filenameBonus(base, rel, filenameStart, first, needleLower) {
   if (first.start < filenameStart) return 0;
 
-  return rel.slice(filenameStart).toLowerCase() === needle.toLowerCase() ? Math.floor((base * 2) / 5) : Math.floor(base / 5);
+  return rel.slice(filenameStart).toLowerCase() === needleLower ? Math.floor((base * 2) / 5) : Math.floor(base / 5);
 }
 
 /** fff: frecency boost base·f/100 and +15% for git-modified files. */

package/src/context/query.js

@@ -12,6 +12,14 @@ const SOURCE_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs",
 
 const TYPED_EXT = new Set([".ts", ".tsx", ".rs", ".go"]);
 
+const BUILD_DIRS = new Set(["node_modules", "dist", "target"]);
+
+const TEST_WORDS = new Set(["test", "tests", "testing", "spec", "specs"]);
+
+const TYPE_WORDS = new Set(["type", "types", "interface", "interfaces", "schema", "schemas"]);
+
+const DOC_WORDS = new Set(["doc", "docs", "documentation", "readme"]);
+
 const MAX_NEEDLE_CHARS = 128;
 
 /** Light suffix stripping so "terminated" ⊇ "terminat" matches "terminate"; deterministic, no dictionary. */
@@ -27,9 +35,9 @@ export function tokenizeQuery(query) {
 
   return {
     tokens: [...new Set(words.filter(word => word.length > 1 && !STOP_WORDS.has(word)))],
-    wantsTest: words.some(word => ["test", "tests", "testing", "spec", "specs"].includes(word)),
-    wantsType: words.some(word => ["type", "types", "interface", "interfaces", "schema", "schemas"].includes(word)),
-    wantsDoc: words.some(word => ["doc", "docs", "documentation", "readme"].includes(word)),
+    wantsTest: words.some(word => TEST_WORDS.has(word)),
+    wantsType: words.some(word => TYPE_WORDS.has(word)),
+    wantsDoc: words.some(word => DOC_WORDS.has(word)),
   };
 }
 
@@ -37,7 +45,8 @@ function tokenPathScore(base, words, normalized, tokens) {
   let score = 0;
 
   for (const token of tokens) {
-    if (base === token || base.startsWith(token + ".")) score += 60;
+    // base === token + "." without the concat alloc: same verdict, no garbage.
+    if (base === token || (base.length > token.length && base[token.length] === "." && base.startsWith(token))) score += 60;
     else if (base.includes(token)) score += 30;
     else if (words.includes(token)) score += 15;
     else if (normalized.includes(token)) score += 5;
@@ -49,7 +58,7 @@ function tokenPathScore(base, words, normalized, tokens) {
 function topologyPenalty(normalized, flags) {
   const parts = normalized.split("/");
 
-  if (parts.some(part => ["node_modules", "dist", "target"].includes(part))) return -100;
+  if (parts.some(part => BUILD_DIRS.has(part))) return -100;
   const test = isTestPath(normalized);
 
   if (test && !flags.wantsTest) return -50;

package/src/context/repo-index.js

@@ -113,6 +113,19 @@ function grepEntryRows(e, filePath, root, regex, nameRegex, out) {
   }
 }
 
+// One alternation scan per file instead of one full scan per needle — same
+// verdict as needles.some(includes). Needles are escaped: they arrive as
+// literals that may carry regex syntax.
+function anyOfProbe(needles) {
+  return new RegExp(needles.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"));
+}
+
+function fileMatchesNeedles(entry, needles, anyOf, probe) {
+  if (probe) return probe.test(entry.lower);
+
+  return anyOf ? needles.some((n) => entry.lower.includes(n)) : needles.every((n) => entry.lower.includes(n));
+}
+
 export class WorkspaceIndex {
   constructor(runCommand) {
     this.runCommand = runCommand;
@@ -358,14 +371,12 @@ export class WorkspaceIndex {
   /** Files whose lowercase text contains any (or every) needle; needles are lowercase. */
   filesContaining(files, needles, anyOf) {
     const hits = [];
+    const probe = anyOf && needles.length > 1 ? anyOfProbe(needles) : null;
 
     for (const filePath of files) {
       const e = this.entry(filePath);
 
-      if (!e) continue;
-      const found = anyOf ? needles.some((n) => e.lower.includes(n)) : needles.every((n) => e.lower.includes(n));
-
-      if (found) hits.push(filePath);
+      if (e && fileMatchesNeedles(e, needles, anyOf, probe)) hits.push(filePath);
     }
 
     return hits;

package/src/context/snap-search.js

@@ -15,17 +15,15 @@ function inScope(filePath, dir, includeHidden) {
   return !parts.includes(".git") && (includeHidden || !parts.some(part => part.startsWith(".") && part.length > 1));
 }
 
-function makeCandidate(filePath, dir, query, tokens, flags) {
+function makeCandidate(filePath, dir, query, tokens, flags, needles = tokens.map(token => stem(token).slice(0, MAX_NEEDLE_CHARS))) {
   const relative = path.relative(dir, filePath);
   const lower = relative.toLowerCase();
   const base = path.basename(lower);
 
   const extension = path.extname(base);
   const stemBase = extension ? base.slice(0, -extension.length) : base;
-  const exactPath = lower === query.toLowerCase() || base === query.toLowerCase()
-    || stemBase === query.toLowerCase();
-
-  const needles = tokens.map(token => stem(token).slice(0, MAX_NEEDLE_CHARS));
+  const queryLower = query.toLowerCase();
+  const exactPath = lower === queryLower || base === queryLower || stemBase === queryLower;
 
   return { path: filePath, pathScore: scorePathTopology(relative, tokens, flags), exactPath,
     pathCoverage: tokens.filter((token, index) => lower.includes(needles[index] ?? token)).length,
@@ -120,7 +118,7 @@ function parseRgRecord(line, truncated, isLast) {
   }
 }
 
-function absorbRgHit(candidates, record, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles) {
+function absorbRgHit(candidates, record, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles, candidateNeedles) {
   if (record.type !== "match" && record.type !== "context") return;
   const data = record.data;
 
@@ -131,21 +129,21 @@ function absorbRgHit(candidates, record, dir, includeHidden, overlayText, candid
   let candidate = candidates.get(filePath);
 
   if (!candidate) {
-    candidate = makeCandidate(filePath, candidateRoot, query, tokens, flags);
+    candidate = makeCandidate(filePath, candidateRoot, query, tokens, flags, candidateNeedles);
     candidates.set(filePath, candidate);
   }
 
   inspectLine(candidate, data.line_number, data.lines.text, query, tokens, needles, record.type === "match");
 }
 
-function overlayCandidates(candidates, pendingPaths, overlayText, candidateRoot, query, tokens, flags, needles, signal) {
+function overlayCandidates(candidates, pendingPaths, overlayText, candidateRoot, query, tokens, flags, needles, candidateNeedles, signal) {
   let overlayTruncated = false;
 
   for (const filePath of pendingPaths) {
     const pending = overlayText(filePath);
 
     if (pending === undefined) continue;
-    const candidate = makeCandidate(filePath, candidateRoot, query, tokens, flags);
+    const candidate = makeCandidate(filePath, candidateRoot, query, tokens, flags, candidateNeedles);
     overlayTruncated = inspectOverlay(candidate, pending, needles, query, tokens, signal) || overlayTruncated;
 
     if (candidate.matched.size) candidates.set(filePath, candidate);
@@ -176,7 +174,7 @@ async function runContentSearch({ dir, includeHidden, searchNeedles, run, overla
   return response;
 }
 
-function absorbRgRecords(candidates, response, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles, signal) {
+function absorbRgRecords(candidates, response, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles, candidateNeedles, signal) {
   const records = response.stdout.split("\n");
 
   for (let i = 0; i < records.length; i++) {
@@ -185,17 +183,20 @@ function absorbRgRecords(candidates, response, dir, includeHidden, overlayText,
 
     if (record === undefined) break;
     if (!record) continue;
-    absorbRgHit(candidates, record, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles);
+    absorbRgHit(candidates, record, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles, candidateNeedles);
   }
 }
 
 async function contentCandidates({ dir, includeHidden, query, tokens, flags, pendingPaths, run, overlayText, signal, exact, diskFiles, focusFile }) {
   const needles = exact ? [query.toLowerCase().slice(0, MAX_NEEDLE_CHARS)] : tokens.map(token => stem(token).slice(0, MAX_NEEDLE_CHARS));
+  // Coverage needles are always token-derived (even in exact mode, where the
+  // search needles collapse to the query): computed once, not once per file.
+  const candidateNeedles = exact ? tokens.map(token => stem(token).slice(0, MAX_NEEDLE_CHARS)) : needles;
   const candidateRoot = focusFile ? path.dirname(focusFile) : dir;
   const candidates = new Map();
   const response = await runContentSearch({ dir, includeHidden, searchNeedles: [...new Set(needles)], run, overlayText, signal, diskFiles, focusFile });
-  absorbRgRecords(candidates, response, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles, signal);
-  const overlayTruncated = overlayCandidates(candidates, pendingPaths, overlayText, candidateRoot, query, tokens, flags, needles, signal);
+  absorbRgRecords(candidates, response, dir, includeHidden, overlayText, candidateRoot, query, tokens, flags, needles, candidateNeedles, signal);
+  const overlayTruncated = overlayCandidates(candidates, pendingPaths, overlayText, candidateRoot, query, tokens, flags, needles, candidateNeedles, signal);
 
   return { candidates, truncated: response.outputTruncated === true || overlayTruncated };
 }