pi-supernova 0.8.2 → 0.9.1

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

@@ -0,0 +1,80 @@
+import * as path from 'node:path';
+import {isString} from '../shared/decode.js';
+import {isTestPath} from '../fs/workspace.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", "are", "does", "do",
+]);
+
+const SOURCE_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs", ".py", ".go"]);
+
+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. */
+export function stem(token) {
+  if (token.length < 5) return token;
+
+  return token.replace(/(ations?|ings?|ed|es|e|s|ly|ers?)$/, (m) => (token.length - m.length >= 4 ? "" : m));
+}
+
+export function tokenizeQuery(query) {
+  if (!isString(query) || !query.trim()) return { tokens: [], wantsTest: false, wantsType: false, wantsDoc: false };
+  const words = query.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-zA-Z0-9_]+/);
+
+  return {
+    tokens: [...new Set(words.filter(word => word.length > 1 && !STOP_WORDS.has(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)),
+  };
+}
+
+function tokenPathScore(base, words, normalized, tokens) {
+  let score = 0;
+
+  for (const token of tokens) {
+    // 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;
+  }
+
+  return score;
+}
+
+function topologyPenalty(normalized, flags) {
+  const parts = normalized.split("/");
+
+  if (parts.some(part => BUILD_DIRS.has(part))) return -100;
+  const test = isTestPath(normalized);
+
+  if (test && !flags.wantsTest) return -50;
+  if (!test && flags.wantsTest) return -20;
+}
+
+export function scorePathTopology(filePath, tokens, flags) {
+  const normalized = filePath.replaceAll("\\", "/").toLowerCase();
+  const penalty = topologyPenalty(normalized, flags);
+
+  if (penalty !== undefined) return penalty;
+  const ext = path.extname(normalized);
+  let score = SOURCE_EXT.has(ext) && !flags.wantsDoc ? 5 : 0;
+
+  if (flags.wantsType && TYPED_EXT.has(ext)) score += 10;
+
+  return score + tokenPathScore(path.basename(normalized), normalized.split(/[^a-zA-Z0-9]+/), normalized, tokens);
+}
+export { SOURCE_EXT, MAX_NEEDLE_CHARS };

package/src/context/repo-index.js

@@ -1,6 +1,9 @@
+export {globToRegExp} from '../fs/glob.js';
+export {declaredName} from './source-entry.js';
+import {fromText,linesOf,spansOf,surfaceOf} from './source-entry.js';
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { extractStructuralSurface } from "./surface.js";
+
 import { isFunction } from "../shared/decode.js";
 import { Frecency } from "./fuzzy.js";
 import { relativeSlash } from "../fs/workspace.js";
@@ -29,126 +32,10 @@ const BINARY_EXT = new Set([
   ".jar", ".so", ".dylib", ".dll", ".exe", ".bin", ".o", ".a", ".node", ".lock", ".sqlite", ".sqlite3", ".db",
 ]);
 
-const REGEX_SPECIAL = /[.+^${}()|\\]/g;
-
-const IDENT_TOKEN = /[A-Za-z_$][\w$]*/g;
-
-const EMPTY = Object.freeze([]);
-
-const DEF_PATTERN = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(?:(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)|([A-Z][A-Z0-9_$]*)\s*(?::[^=\n]+)?=)/;
-
-/** Declared identifier on a line (function/class/UPPER_CASE constant/…), or ""; the same rule snap and grep use. */
-export function declaredName(line) {
-  const match = DEF_PATTERN.exec(String(line).trim());
-
-  return match?.[2] ?? match?.[3] ?? "";
-}
-
 function isTextCandidate(filePath) {
   return !BINARY_EXT.has(path.extname(filePath).toLowerCase());
 }
 
-/** Translate one glob token at index i → [regexSource, nextIndex]. */
-function globToken(glob, i) {
-  const ch = glob[i];
-
-  if (ch === "*" && glob[i + 1] === "*") {
-    const slashAfter = glob[i + 2] === "/";
-
-    return [slashAfter ? "(?:.*/)?" : ".*", i + (slashAfter ? 3 : 2)];
-  }
-
-  if (ch === "*") return ["[^/]*", i + 1];
-
-  if (ch === "?") return ["[^/]", i + 1];
-
-  if (ch === "{" || ch === "[") return globGroup(glob, i, ch);
-
-  return [ch.replace(REGEX_SPECIAL, "\\$&"), i + 1];
-}
-
-/** {a,b} alternation or [..] class starting at i. */
-function globGroup(glob, i, open) {
-  const close = open === "{" ? "}" : "]";
-  const end = glob.indexOf(close, i);
-
-  if (end < 0) throw new SyntaxError("unclosed " + open + " in glob");
-  const inner = glob.slice(i + 1, end);
-  const source = open === "{"
-    ? "(?:" + inner.split(",").map(globBody).join("|") + ")"
-    : "[" + (inner.startsWith("!") ? "^" + inner.slice(1) : inner) + "]";
-
-  return [source, end + 1];
-}
-
-function globBody(glob) {
-  let source = "";
-  let i = 0;
-
-  while (i < glob.length) {
-    const [piece, next] = globToken(glob, i);
-    source += piece;
-    i = next;
-  }
-
-  return source;
-}
-
-/** gitignore-style glob (rg -g) → RegExp over a "/"-separated relative path. No slash ⇒ basename match anywhere. */
-export function globToRegExp(glob) {
-  const body = globBody(glob);
-
-  return new RegExp(glob.includes("/") ? "^" + body + "$" : "(?:^|/)" + body + "$");
-}
-
-function lineIndent(raw, i) {
-  return raw[i].length - raw[i].trimStart().length;
-}
-
-function pythonDeclarationEnd(raw, lower, start, lineCount) {
-  const base = lineIndent(raw, start - 1);
-  let end = start;
-
-  for (let i = start; i < lineCount; i++) {
-    if (lower[i] === "") { end = i + 1; continue; }
-    if (lineIndent(raw, i) <= base) break;
-    end = i + 1;
-  }
-
-  return Math.min(end, lineCount);
-}
-
-function braceDelta(text) {
-  let depth = 0;
-
-  for (const ch of text) {
-    if (ch === "{") depth++;
-    else if (ch === "}") depth--;
-  }
-
-  return depth;
-}
-
-function braceDeclarationEnd(raw, start, lineCount) {
-  let depth = braceDelta(raw[start - 1] ?? "");
-
-  if (depth <= 0) return start;
-
-  for (let i = start; i < raw.length; i++) {
-    depth += braceDelta(raw[i]);
-
-    if (depth <= 0) return i + 1;
-  }
-
-  return lineCount;
-}
-
-function declarationEnd(raw, lower, start, lineCount, ext) {
-  if (ext === ".py") return pythonDeclarationEnd(raw, lower, start, lineCount);
-
-  return braceDeclarationEnd(raw, start, lineCount);
-}
-
 function readFdBuffer(fd, buffer) {
   let offset = 0;
 
@@ -226,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;
@@ -450,59 +350,18 @@ export class WorkspaceIndex {
     return this.storeCreated(filePath, loaded);
   }
 
-  static fromText(filePath, text) {
-    return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
-  }
+  static fromText(filePath, text) { return fromText(filePath, text); }
 
   /** Per-line raw text, lowercase text, declared identifier (or ""), and identifier tokens, computed once per entry. */
-  static linesOf(entry) {
-    if (entry.lines) return entry.lines;
-    const raw = entry.text.split("\n");
-    const lower = [];
-    const defNames = [];
-    const idents = [];
-
-    for (let i = 0; i < raw.length; i++) {
-      const trimmed = raw[i].trim();
-      lower[i] = trimmed.toLowerCase();
-      const declared = DEF_PATTERN.exec(trimmed);
-      defNames[i] = (declared?.[2] ?? declared?.[3] ?? "").toLowerCase();
-      idents[i] = trimmed.match(IDENT_TOKEN) || EMPTY;
-    }
-
-    entry.lines = { raw, lower, defNames, idents };
-
-    return entry.lines;
-  }
+  static linesOf(entry) { return linesOf(entry); }
 
   /**
    * Declaration spans [start, end] (1-based, inclusive). Nested bodies stay inside the parent
    * (brace-matched for JS-like, indent for Python). The file's leading header is not a span.
    */
-  static spansOf(entry) {
-    if (entry.spans) return entry.spans;
-    const { items, lineCount } = WorkspaceIndex.surfaceOf(entry);
-    const { lower, raw } = WorkspaceIndex.linesOf(entry);
-    const spans = [];
-
-    for (let i = 0; i < items.length; i++) {
-      const start = items[i].line;
-      let end = declarationEnd(raw, lower, start, lineCount, entry.ext);
-
-      while (end > start && lower[end - 1] === "") end--;
-      spans.push({ start, end, name: items[i].name, kind: items[i].kind, isExport: items[i].isExport === true });
-    }
-
-    entry.spans = spans;
-
-    return spans;
-  }
+  static spansOf(entry) { return spansOf(entry); }
 
-  static surfaceOf(entry) {
-    if (!entry.surface) entry.surface = extractStructuralSurface(entry.text, entry.ext);
-
-    return entry.surface;
-  }
+  static surfaceOf(entry) { return surfaceOf(entry); }
 
   /** True when the list is small enough to scan in-process instead of spawning rg. */
   canScan(files) {
@@ -512,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/search-files.js

@@ -0,0 +1,19 @@
+import * as path from 'node:path';
+import {WorkspaceIndex} from './repo-index.js';
+
+function pendingInScope(root, pendingPaths) {
+  return pendingPaths.filter(file => {
+    const relative = path.relative(root, file);
+
+    return relative === "" || (relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative));
+  });
+}
+
+function overlaySearchEntry(index, filePath, overlayText) {
+  const pending = overlayText(filePath);
+
+  return pending === undefined
+    ? index.entry(filePath)
+    : Buffer.byteLength(pending, "utf8") <= 512 * 1024 ? WorkspaceIndex.fromText(filePath, pending) : null;
+}
+export { pendingInScope, overlaySearchEntry };

package/src/context/search.js

@@ -1,3 +1,5 @@
+import {textResult} from '../shared/result.js';
+import {pendingInScope,overlaySearchEntry} from './search-files.js';
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isString } from "../shared/decode.js";
@@ -5,14 +7,6 @@ import { WorkspaceIndex, globToRegExp } from "./repo-index.js";
 import { rankPaths, smartCase, fuzzyMatch } from "./fuzzy.js";
 import { runCommand, relativeSlash } from "../fs/workspace.js";
 
-// Search served from the in-process index: fuzzy path find (fff port), smart-case grep with
-// definition-first rows and fuzzy fallback, glob listing. rg is spawned only for trees too
-// large to scan in-process.
-
-function textResult(text, details) {
-  return { content: [{ type: "text", text: String(text ?? "") }], details: details || {} };
-}
-
 async function candidateFileList(index, root, includeHidden = false, signal) {
   const stat = await fs.stat(root).catch(() => null);
 
@@ -21,14 +15,6 @@ async function candidateFileList(index, root, includeHidden = false, signal) {
   return index.files(root, includeHidden, signal);
 }
 
-function pendingInScope(root, pendingPaths) {
-  return pendingPaths.filter(file => {
-    const relative = path.relative(root, file);
-
-    return relative === "" || (relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative));
-  });
-}
-
 function parseMatchRecord(line, truncated, isLast) {
   if (!line) return { skip: true };
 
@@ -248,14 +234,6 @@ function grepRegex(pattern, params) {
   }
 }
 
-function overlaySearchEntry(index, filePath, overlayText) {
-  const pending = overlayText(filePath);
-
-  return pending === undefined
-    ? index.entry(filePath)
-    : Buffer.byteLength(pending, "utf8") <= 512 * 1024 ? WorkspaceIndex.fromText(filePath, pending) : null;
-}
-
 function fuzzyLineRow(pattern, rawLine, defName, rel, line, maxTypos, caseSensitive) {
   const m = fuzzyMatch(pattern, rawLine, { maxTypos, caseSensitive });