pi-supernova 0.4.0 → 0.6.0

package/src/bridge/native-tools.js

@@ -54,7 +54,11 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   };
 
   function settingsFor(ctx) {
-    return host.SettingsManager?.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted?.() === true });
+    try {
+      return host.SettingsManager?.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted?.() === true });
+    } catch {
+      return undefined;
+    }
   }
 
   async function readOne(args, signal, ctx, bridge, id) {
@@ -67,7 +71,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
     signal?.throwIfAborted();
     const image = /\.(png|jpe?g|gif|webp|bmp)$/i.test(target);
 
-    if (stat?.isFile() && (args.about === undefined || image)) {
+    if (stat?.isFile() && args.about === undefined && args.query === undefined && args.resolve === undefined && args.outline === undefined && args.evidence === undefined && args.json === undefined && args.complete === undefined) {
       // Pi retains image handling, full text, line windows, truncation metadata,
       // and actionable continuation offsets. Do not summarize or dedupe these.
       return factories.read(ctx.cwd, { autoResizeImages: image ? settingsFor(ctx)?.getImageAutoResize() : undefined }).execute(id, { ...args, path: target }, signal, undefined, ctx);
@@ -77,7 +81,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   }
 
   async function execute(name, id, args, signal, onUpdate, context) {
-    const ctx = { ...context, cwd: context?.cwd || cwd };
+    const ctx = { ...context, cwd: isString(context?.cwd) && context.cwd ? context.cwd : cwd };
     const bridge = base.fork({ getCwd: () => ctx.cwd });
     bridge.bindCallContext(ctx, signal);
     signal?.throwIfAborted();
@@ -166,11 +170,17 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
     };
 
     if (name === "read") {
-      tool.description += " Also reads directories or finds source from a symbol/question passed as path. Use about to focus a file or directory on a question. An array of paths returns all readable files and labels individual errors.";
+      tool.description += " Also reads directories or finds source from a symbol/question passed as path. Use about to focus a file or directory on a question (at most 16 keywords). An array of up to 64 paths returns all readable files and labels individual errors. Images return as attachments up to 20 MiB each; at most 16 image attachments are returned.";
       tool.parameters = { ...definition.parameters, properties: {
         ...definition.parameters.properties,
         path: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, maxItems: 64 }], description: "File, directory, source question, or up to 64 paths to read" },
-        about: { type: "string", description: "Focus on this question or symbol; source selection reports uncertainty instead of guessing" },
+        about: { type: "string", description: "Focus on this question or symbol (at most 16 keywords); source selection reports uncertainty instead of guessing" },
+        query: { type: "string", description: "Source question; optional path scopes the search" },
+        outline: { type: "boolean" },
+        evidence: { type: "boolean" },
+        resolve: { type: "boolean" },
+        complete: { type: "boolean" },
+        json: { anyOf: [{ type: "boolean" }, { type: "string" }, { type: "array", items: { type: "string" }, maxItems: 64 }] },
       } };
       tool.promptGuidelines = [...(definition.promptGuidelines || []), "read can find source from a symbol or question; check its selection status before choosing a file. Plain file reads preserve full text within the stated limits."];
     }
@@ -179,7 +189,7 @@ export function registerNativeTools(pi, host, config = loadConfig()) {
   }
 
   pi.on("session_start", (_event, ctx) => {
-    cwd = ctx?.cwd || cwd;
+    cwd = isString(ctx?.cwd) && ctx.cwd ? ctx.cwd : cwd;
     base.invalidateFiles();
   });
   pi.registerCommand("supernova", {

package/src/context/evidence.js

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { WorkspaceIndex } from "./repo-index.js";
 import { tokenizeQuery, scorePathTopology, stem } from "./snap.js";
@@ -143,7 +144,7 @@ function lexicalSim(a, b) {
 
 function activateEntities(profile, graph) {
   const eta = new Map();
-  const anchors = profile.subjects.length ? profile.subjects : profile.keywords;
+  const anchors = profile.subjects.length ? profile.subjects : profile.stems;
 
   for (const anchor of anchors) {
     let best = null;
@@ -388,12 +389,12 @@ function candidateFiles(files, profile, index, limit, overlayText) {
 
   scored.sort((a, b) => b.s - a.s);
   const chosen = new Set();
-  const anchors = (profile.subjects.length ? profile.subjects : profile.keywords).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
+  const anchors = (profile.subjects.length ? profile.subjects : profile.stems).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
 
   const pendingHits = files.filter(file => {
     const pending = overlayText(file);
 
-    return pending !== undefined && anchors.some(anchor => pending.toLowerCase().includes(anchor));
+    return pending !== undefined && Buffer.byteLength(pending, "utf8") <= 512 * 1024 && anchors.some(anchor => pending.toLowerCase().includes(anchor));
   });
 
   const hits = anchors.length ? [...new Set([...pendingHits, ...index.filesContaining(files, anchors, true)])] : [];
@@ -511,7 +512,12 @@ export async function selectEvidence({ query, root, searchDir, index, overlayTex
     return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
   });
 
-  const files = [...new Set([...await index.files(searchRoot), ...staged])];
+  const rootStat = await fs.stat(searchRoot).catch(error => {
+    if (error?.code === "ENOENT" || error?.code === "ENOTDIR") return null;
+    throw error;
+  });
+  const diskFiles = rootStat?.isFile() ? [searchRoot] : rootStat ? await index.files(searchRoot) : [];
+  const files = [...new Set([...diskFiles, ...staged])];
 
   if (files.length === 0) throw new Error(`no files found to search in ${searchDir || root}`);
 
@@ -520,7 +526,9 @@ export async function selectEvidence({ query, root, searchDir, index, overlayTex
 
   for (const f of chosenFiles) {
     const pending = overlayText(f);
-    const entry = pending === undefined ? index.entry(f) : WorkspaceIndex.fromText(f, pending);
+    const entry = pending === undefined
+      ? index.entry(f)
+      : Buffer.byteLength(pending, "utf8") <= 512 * 1024 ? WorkspaceIndex.fromText(f, pending) : null;
 
     if (!entry) continue;
     spans.push(...spansOf(entry, f, opts.maxSpanLines));

package/src/context/fuzzy.js

@@ -15,6 +15,7 @@ const AI_DECAY = Math.LN2 / 3;            // per day
 const AI_MAX_HISTORY_DAYS = 7;
 
 const MAX_TIMESTAMPS_PER_FILE = 128;
+const MAX_FRECENCY_FILES = 10000;
 
 const AI_MODIFICATION_THRESHOLDS = [[16, 30], [8, 300], [4, 900], [2, 3600], [1, 14400]]; // [boost, seconds]
 
@@ -26,7 +27,10 @@ export class Frecency {
   record(filePath, at = Date.now() / 1000) {
     let list = this.access.get(filePath);
 
-    if (!list) this.access.set(filePath, (list = []));
+    if (!list) {
+      if (this.access.size >= MAX_FRECENCY_FILES) this.access.delete(this.access.keys().next().value);
+      this.access.set(filePath, (list = []));
+    }
     list.push(at);
 
     if (list.length > MAX_TIMESTAMPS_PER_FILE) list.splice(0, list.length - MAX_TIMESTAMPS_PER_FILE);
@@ -124,20 +128,35 @@ export function fuzzyMatch(needle, hay, { maxTypos = 0, caseSensitive = false }
 
   if (direct) return { ...direct, typos: 0, exact: hay.toLowerCase() === needle.toLowerCase() };
 
-  if (maxTypos <= 0 || needle.length < 3) return null;
-  let best = null;
+  if (maxTypos <= 0 || needle.length < 3 || needle.length > 128) return null;
+  const memo = new Map();
 
-  for (let i = 0; i < needle.length; i++) {
-    const shorter = needle.slice(0, i) + needle.slice(i + 1);
-    const m = fuzzyMatch(shorter, hay, { maxTypos: maxTypos - 1, caseSensitive });
+  const visit = (part, typosLeft) => {
+    const key = part + "\0" + typosLeft;
 
-    if (!m) continue;
-    const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
+    if (memo.has(key)) return memo.get(key);
+    let best = matchOnce(part, hay, caseSensitive);
 
-    if (!best || scored.score > best.score) best = scored;
-  }
+    if (best) best = { ...best, typos: 0, exact: hay.toLowerCase() === part.toLowerCase() };
+
+    if (typosLeft > 0) {
+      for (let i = 0; i < part.length; i++) {
+        const shorter = part.slice(0, i) + part.slice(i + 1);
+        const m = visit(shorter, typosLeft - 1);
+
+        if (!m) continue;
+        const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
+
+        if (!best || scored.score > best.score) best = scored;
+      }
+    }
+
+    memo.set(key, best);
 
-  return best;
+    return best;
+  };
+
+  return visit(needle, maxTypos);
 }
 
 export function smartCase(query) {
@@ -164,7 +183,7 @@ function distancePenalty(currentDir, candidateDir) {
 export function rankPaths(query, paths, ctx = {}) {
   const parts = query.trim().split(/\s+/).filter((p) => p.length >= 2);
 
-  if (parts.length === 0) return [];
+  if (parts.length === 0 || parts.length > 16) return [];
   const caseSensitive = smartCase(query);
   const maxTypos = ctx.maxTypos ?? (parts[0].length >= 6 ? 2 : parts[0].length >= 4 ? 1 : 0);
   const currentDir = ctx.currentFile ? ctx.currentFile.slice(0, ctx.currentFile.lastIndexOf("/") + 1) : "";
@@ -212,7 +231,9 @@ function filenameBonus(base, rel, filenameStart, first, needle) {
 
 /** fff: frecency boost base·f/100 and +15% for git-modified files. */
 function contextBoost(base, rel, ctx) {
-  const frecency = ctx.frecency ? ctx.frecency.score(rel, ctx.mtimeOf?.(rel)) : 0;
+  let frecency = 0;
+
+  try { frecency = ctx.frecency ? ctx.frecency.score(rel, ctx.mtimeOf?.(rel)) : 0; } catch {}
   const gitBoost = ctx.modified?.has(rel) ? Math.floor((base * 15) / 100) : 0;
 
   return Math.floor((base * frecency) / 100) + gitBoost;

package/src/context/outline.js

@@ -28,6 +28,7 @@ function relevance(span, lower, stems) {
 }
 
 function chooseExpanded(spans, lower, stems, raw, opts) {
+  if (stems.length === 0) return new Set();
   const scored = spans.map((s, i) => ({ i, r: relevance(s, lower, stems), chars: raw.slice(s.start - 1, s.end).join("\n").length }));
   scored.sort((a, b) => b.r - a.r || a.i - b.i);
   const expanded = new Set();
@@ -118,7 +119,15 @@ export function outlineFile(entry, relPath, about, options = {}) {
   }
 
   for (let i = 0; i < spans.length; i++) parts.push(expanded.has(i) ? expandedBlock(spans[i], raw, opts) : foldedLine(spans[i]));
-  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (about ? " for \"" + about + "\"" : "") + " · read(path, line, count) for a folded body";
+  const label = about ? String(about).replace(/\s+/g, " ").slice(0, 120) : "";
+  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (label ? " for \"" + label + "\"" : "") + " · read(path, line, count) for a folded body";
+  let text = title + "\n" + parts.join("\n");
 
-  return { text: title + "\n" + parts.join("\n"), expanded: expanded.size, declarations: spans.length };
+  if (text.length > opts.maxChars) {
+    const end = text.lastIndexOf("\n", Math.max(0, opts.maxChars - 160));
+
+    text = (end > title.length ? text.slice(0, end) : text.slice(0, opts.maxChars)) + "\n      … outline truncated; use read(path, line, count) for later declarations";
+  }
+
+  return { text, expanded: expanded.size, declarations: spans.length };
 }

package/src/context/repo-index.js

@@ -21,6 +21,7 @@ const WATCH_DEBOUNCE_MS = 150;
 const MAX_INDEXED_FILES = 4000;
 
 const MAX_FILE_BYTES = 512 * 1024;
+const MAX_ENTRY_CACHE_BYTES = 64 * 1024 * 1024;
 
 const BINARY_EXT = new Set([
   ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tgz", ".tar", ".bz2", ".xz", ".7z",
@@ -34,11 +35,13 @@ 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_$]+)/;
+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/const/…), or ""; the same rule snap and grep use. */
+/** Declared identifier on a line (function/class/UPPER_CASE constant/…), or ""; the same rule snap and grep use. */
 export function declaredName(line) {
-  return DEF_PATTERN.exec(String(line).trim())?.[2] ?? "";
+  const match = DEF_PATTERN.exec(String(line).trim());
+
+  return match?.[2] ?? match?.[3] ?? "";
 }
 
 function isTextCandidate(filePath) {
@@ -71,7 +74,9 @@ function globGroup(glob, i, open) {
 
   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 + "]";
+  const source = open === "{"
+    ? "(?:" + inner.split(",").map(globBody).join("|") + ")"
+    : "[" + (inner.startsWith("!") ? "^" + inner.slice(1) : inner) + "]";
 
   return [source, end + 1];
 }
@@ -96,11 +101,48 @@ export function globToRegExp(glob) {
   return new RegExp(glob.includes("/") ? "^" + body + "$" : "(?:^|/)" + body + "$");
 }
 
+function declarationEnd(raw, lower, start, lineCount, ext) {
+  if (ext === ".py") {
+    const indentOf = (i) => raw[i].length - raw[i].trimStart().length;
+    const base = indentOf(start - 1);
+    let end = start;
+
+    for (let i = start; i < lineCount; i++) {
+      if (lower[i] === "") { end = i + 1; continue; }
+      if (indentOf(i) <= base) break;
+      end = i + 1;
+    }
+
+    return Math.min(end, lineCount);
+  }
+
+  let depth = 0;
+
+  for (const ch of raw[start - 1] ?? "") {
+    if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+  }
+
+  if (depth <= 0) return start;
+
+  for (let i = start; i < raw.length; i++) {
+    for (const ch of raw[i]) {
+      if (ch === "{") depth++;
+      else if (ch === "}") depth--;
+    }
+
+    if (depth <= 0) return i + 1;
+  }
+
+  return lineCount;
+}
+
 export class WorkspaceIndex {
   constructor(runCommand) {
     this.runCommand = runCommand;
     this.lists = new Map();
     this.entries = new Map();
+    this.entryBytes = 0;
     this.watchers = new Map();
     this.frecency = new Frecency();
     this.gitModified = new Map(); // root → Set(relative "/"-joined paths)
@@ -109,6 +151,11 @@ export class WorkspaceIndex {
 
   invalidate() {
     this.lists.clear();
+    this.gitModified.clear();
+
+    for (const entry of this.entries.values()) this.entryBytes -= entry.weight ?? 0;
+    this.entries.clear();
+    this.entryBytes = 0;
   }
 
   /** fff frecency: every read/edit is an access; the newest one is the "current file" for distance penalties. */
@@ -130,12 +177,17 @@ export class WorkspaceIndex {
           timer = null;
           this.lists.clear();
           this.gitModified.delete(root);
+          this.entries.clear();
+          this.entryBytes = 0;
         }, WATCH_DEBOUNCE_MS);
+        timer.unref?.();
       });
 
       watcher.on("error", () => {
         this.watchers.set(root, false);
         this.lists.clear();
+        this.entries.clear();
+        this.entryBytes = 0;
       });
 
       if (isFunction(watcher.unref)) watcher.unref();
@@ -160,8 +212,21 @@ export class WorkspaceIndex {
       const res = await this.runCommand(["git", "status", "--porcelain", "-z", "--untracked-files=all"], { cwd: root, timeoutMs: 5_000 });
 
       if (res.exitCode === 0) {
-        for (const row of res.stdout.split("\0")) {
-          if (row.length > 3) set.add(row.slice(3));
+        const rows = res.stdout.split("\0");
+
+        for (let i = 0; i < rows.length; i++) {
+          const row = rows[i];
+
+          if (row.length <= 3) continue;
+          const status = row.slice(0, 2);
+          const file = row.slice(3);
+
+          if (file) set.add(file);
+          if ((status.includes("R") || status.includes("C")) && i + 1 < rows.length) {
+            const target = rows[++i];
+
+            if (target) set.add(target);
+          }
         }
       }
     } catch {}
@@ -193,7 +258,7 @@ export class WorkspaceIndex {
     const args = ["rg", "--files"];
 
     if (includeHidden) args.push("--hidden");
-    args.push("-g", "!.git/**", "-g", "!**/.git/**", root);
+    args.push("-g", "!.git/**", "-g", "!**/.git/**", "--", root);
     let files = [];
     let error;
     let truncated = false;
@@ -225,26 +290,107 @@ export class WorkspaceIndex {
     try {
       stat = fs.statSync(filePath);
     } catch {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
       this.entries.delete(filePath);
 
       return null;
     }
 
-    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return null;
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
+      this.entries.delete(filePath);
+
+      return null;
+    }
     const cached = this.entries.get(filePath);
 
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached;
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+      this.entries.delete(filePath);
+      this.entries.set(filePath, cached);
+
+      return cached;
+    }
     let text;
+    let actual = stat;
 
     try {
-      text = fs.readFileSync(filePath, "utf8");
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK ?? 0));
+
+      try {
+        actual = fs.fstatSync(fd);
+        if (!actual.isFile() || actual.size > MAX_FILE_BYTES) {
+          const previous = this.entries.get(filePath);
+
+          if (previous) this.entryBytes -= previous.weight ?? 0;
+          this.entries.delete(filePath);
+
+          return null;
+        }
+        const buffer = Buffer.alloc(MAX_FILE_BYTES + 1);
+        let offset = 0;
+
+        while (offset < buffer.length) {
+          const read = fs.readSync(fd, buffer, offset, buffer.length - offset, offset);
+
+          if (read <= 0) break;
+          offset += read;
+        }
+
+        if (offset > MAX_FILE_BYTES) {
+          const previous = this.entries.get(filePath);
+
+          if (previous) this.entryBytes -= previous.weight ?? 0;
+          this.entries.delete(filePath);
+
+          return null;
+        }
+        actual = fs.fstatSync(fd);
+        if (!actual.isFile() || actual.size !== offset) {
+          const previous = this.entries.get(filePath);
+
+          if (previous) this.entryBytes -= previous.weight ?? 0;
+          this.entries.delete(filePath);
+
+          return null;
+        }
+        text = buffer.subarray(0, offset).toString("utf8");
+      } finally { fs.closeSync(fd); }
     } catch {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
+      this.entries.delete(filePath);
+
+      return null;
+    }
+
+    if (text.includes("\0")) {
+      const previous = this.entries.get(filePath);
+
+      if (previous) this.entryBytes -= previous.weight ?? 0;
+      this.entries.delete(filePath);
+
       return null;
     }
+    const created = { text, lower: text.toLowerCase(), mtimeMs: actual.mtimeMs, size: actual.size, weight: Math.max(1, actual.size) * 2, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+    const previous = this.entries.get(filePath);
 
-    if (text.includes("\0")) return null;
-    const created = { text, lower: text.toLowerCase(), mtimeMs: stat.mtimeMs, size: stat.size, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+    if (previous) this.entryBytes -= previous.weight ?? 0;
+    this.entries.delete(filePath);
     this.entries.set(filePath, created);
+    this.entryBytes += created.weight;
+
+    while (this.entryBytes > MAX_ENTRY_CACHE_BYTES && this.entries.size > 1) {
+      const oldest = this.entries.keys().next().value;
+      const evicted = this.entries.get(oldest);
+
+      this.entries.delete(oldest);
+      this.entryBytes -= evicted?.weight ?? 0;
+    }
 
     return created;
   }
@@ -264,7 +410,8 @@ export class WorkspaceIndex {
     for (let i = 0; i < raw.length; i++) {
       const trimmed = raw[i].trim();
       lower[i] = trimmed.toLowerCase();
-      defNames[i] = DEF_PATTERN.exec(trimmed)?.[2].toLowerCase() ?? "";
+      const declared = DEF_PATTERN.exec(trimmed);
+      defNames[i] = (declared?.[2] ?? declared?.[3] ?? "").toLowerCase();
       idents[i] = trimmed.match(IDENT_TOKEN) || EMPTY;
     }
 
@@ -274,18 +421,18 @@ export class WorkspaceIndex {
   }
 
   /**
-   * Declaration spans [start, end] (1-based, inclusive) in file order, trailing blank lines trimmed.
-   * A span runs to the line before the next declaration; the file's leading header is not a span.
+   * 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 } = WorkspaceIndex.linesOf(entry);
+    const { lower, raw } = WorkspaceIndex.linesOf(entry);
     const spans = [];
 
     for (let i = 0; i < items.length; i++) {
       const start = items[i].line;
-      let end = Math.min(i + 1 < items.length ? items[i + 1].line - 1 : lineCount, lineCount);
+      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 });
@@ -330,9 +477,33 @@ export class WorkspaceIndex {
 
     for (const filePath of files) {
       const pending = overlayText(filePath);
-      const e = pending === undefined ? this.entry(filePath) : WorkspaceIndex.fromText(filePath, pending);
+      let e = null;
+
+      if (pending === undefined) e = this.entry(filePath);
+      else if (Buffer.byteLength(pending, "utf8") <= MAX_FILE_BYTES) e = WorkspaceIndex.fromText(filePath, pending);
+      else {
+        const rel = relativeSlash(root, filePath);
+        let start = 0;
+        let line = 0;
+
+        while (start <= pending.length) {
+          const end = pending.indexOf("\n", start);
+          const stop = end === -1 ? pending.length : end;
+          const text = pending.slice(start, stop).replace(/\r$/, "");
+
+          line++;
+          if (regex.test(text)) out.push({ rel, line, text, def: false });
+          if (end === -1) break;
+          start = end + 1;
+        }
+
+        continue;
+      }
+
+      if (!e) continue;
+      const lineAnchored = /\^|\$/.test(regex.source.replace(/\\[\^$]|\[[^\]]*\]/g, ""));
 
-      if (!e || !regex.test(e.text)) continue;
+      if (!lineAnchored && !regex.test(e.text)) continue;
       const { raw, defNames } = WorkspaceIndex.linesOf(e);
       const rel = relativeSlash(root, filePath);