pi-supernova 0.6.0 → 0.7.0

package/src/context/ledger.js

@@ -39,19 +39,23 @@ function newHistory() {
 // Experimental candidate collection, not proof of provider-visible retention:
 // AgentMessage metadata and later context transformations can hide these strings.
 // Keep this optimization opt-in until exact outgoing citation targets are validated.
-function collectRetained(value, retained, depth = 0) {
-  if (isString(value)) {
-    // Every line, not only substantive ones. A run may span a blank or short line,
-    // so isRetained must be exact per line or the run truncates there. An oversized
-    // line is never stored: it cannot sit inside a six-line run, and this is what
-    // keeps base64 image payloads out of the retention set.
-    if (value.length > MAX_OBSERVED_LINE && !value.includes("\n")) return;
+function retainString(value, retained) {
+  // Every line, not only substantive ones. A run may span a blank or short line,
+  // so isRetained must be exact per line or the run truncates there. An oversized
+  // line is never stored: it cannot sit inside a six-line run, and this is what
+  // keeps base64 image payloads out of the retention set.
+  if (value.length > MAX_OBSERVED_LINE && !value.includes("\n")) return;
 
-    for (const line of value.split("\n")) {
-      if (retained.size >= MAX_STORED_LINES) return;
+  for (const line of value.split("\n")) {
+    if (retained.size >= MAX_STORED_LINES) return;
 
-      if (line.length <= MAX_OBSERVED_LINE) retained.add(line);
-    }
+    if (line.length <= MAX_OBSERVED_LINE) retained.add(line);
+  }
+}
+
+function collectRetained(value, retained, depth = 0) {
+  if (isString(value)) {
+    retainString(value, retained);
 
     return;
   }
@@ -174,7 +178,7 @@ export class SeenLedger {
     return count;
   }
 
-  longestRun(lines, hashes, index, call) {
+  bestCandidateRun(lines, hashes, index, call) {
     const candidates = this.occurrences.get(hashes[index]);
 
     if (!candidates) return null;
@@ -186,12 +190,23 @@ export class SeenLedger {
       if (length >= MIN_RUN && (!best || length > best.length)) best = { ...candidate, length };
     }
 
-    if (!best) return null;
+    return best;
+  }
+
+  substantiveCount(lines, index, length) {
     let count = 0;
 
-    for (let i = index; i < index + best.length; i++) if (collapsible(lines[i])) count++;
+    for (let i = index; i < index + length; i++) if (collapsible(lines[i])) count++;
 
-    return count >= MIN_SUBSTANTIVE ? best : null;
+    return count;
+  }
+
+  longestRun(lines, hashes, index, call) {
+    const best = this.bestCandidateRun(lines, hashes, index, call);
+
+    if (!best) return null;
+
+    return this.substantiveCount(lines, index, best.length) >= MIN_SUBSTANTIVE ? best : null;
   }
 
   citation(lines, index, run) {
@@ -245,19 +260,14 @@ export class SeenLedger {
     return sent;
   }
 
-  remember(call, lines) {
-    if (this.window === 0 || call <= this.history.latestCall - this.window || lines.length > MAX_STORED_LINES) return;
-
-    if (this.results.has(call)) this.forget(call);
-
+  evictForCapacity(incoming) {
     for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
-      if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
+      if (this.storedLines + incoming <= MAX_STORED_LINES) break;
       this.forget(old);
     }
+  }
 
-    const hashes = Uint32Array.from(lines, hashLine);
-    const origins = lines.map(line => this.origins.get(line));
-
+  indexCollapsible(lines, hashes, call) {
     for (let i = 0; i < lines.length; i++) {
       if (!collapsible(lines[i])) continue;
       let list = this.occurrences.get(hashes[i]);
@@ -265,7 +275,16 @@ export class SeenLedger {
       if (!list) this.occurrences.set(hashes[i], (list = []));
       list.push({ call, index: i });
     }
+  }
+
+  remember(call, lines) {
+    if (this.window === 0 || call <= this.history.latestCall - this.window || lines.length > MAX_STORED_LINES) return;
 
+    if (this.results.has(call)) this.forget(call);
+    this.evictForCapacity(lines.length);
+    const hashes = Uint32Array.from(lines, hashLine);
+    const origins = lines.map(line => this.origins.get(line));
+    this.indexCollapsible(lines, hashes, call);
     this.results.set(call, { hashes, lines, origins });
     this.history.storedLines += lines.length;
   }

package/src/context/outline.js

@@ -97,16 +97,7 @@ function focusedText(raw, lower, stems, relPath, opts) {
  * @param entry index entry (text + cached lines/surface)
  * @param about question or symbol; empty ⇒ pure skeleton (every body folded)
  */
-export function outlineFile(entry, relPath, about, options = {}) {
-  const opts = { ...OUTLINE_DEFAULTS, ...options };
-  const { raw, lower } = WorkspaceIndex.linesOf(entry);
-  const lineCount = raw.length;
-  const spans = WorkspaceIndex.spansOf(entry).map((s) => ({ ...s, signature: raw[s.start - 1].trim() }));
-  const stems = [...new Set(tokenizeQuery(about || "").tokens.map(stem))];
-
-  if (spans.length === 0) return about ? focusedText(raw, lower, stems, relPath, opts) : null;
-  const expanded = chooseExpanded(spans, lower, stems, raw, opts);
-
+function outlineHeader(spans, raw, opts) {
   const parts = [];
   const headerEnd = Math.min(spans[0].start - 1, opts.headerLines);
 
@@ -118,16 +109,30 @@ export function outlineFile(entry, relPath, about, options = {}) {
     if (spans[0].start - 1 > opts.headerLines) parts.push("      … " + (spans[0].start - 1 - opts.headerLines) + " more header lines");
   }
 
+  return parts;
+}
+
+function clipOutline(text, title, maxChars) {
+  if (text.length <= maxChars) return text;
+  const end = text.lastIndexOf("\n", Math.max(0, maxChars - 160));
+
+  return (end > title.length ? text.slice(0, end) : text.slice(0, maxChars)) + "\n      … outline truncated; use read(path, line, count) for later declarations";
+}
+
+export function outlineFile(entry, relPath, about, options = {}) {
+  const opts = { ...OUTLINE_DEFAULTS, ...options };
+  const { raw, lower } = WorkspaceIndex.linesOf(entry);
+  const lineCount = raw.length;
+  const spans = WorkspaceIndex.spansOf(entry).map((s) => ({ ...s, signature: raw[s.start - 1].trim() }));
+  const stems = [...new Set(tokenizeQuery(about || "").tokens.map(stem))];
+
+  if (spans.length === 0) return about ? focusedText(raw, lower, stems, relPath, opts) : null;
+  const expanded = chooseExpanded(spans, lower, stems, raw, opts);
+  const parts = outlineHeader(spans, raw, opts);
+
   for (let i = 0; i < spans.length; i++) parts.push(expanded.has(i) ? expandedBlock(spans[i], raw, opts) : foldedLine(spans[i]));
   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");
-
-  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 };
+  return { text: clipOutline(title + "\n" + parts.join("\n"), title, opts.maxChars), expanded: expanded.size, declarations: spans.length };
 }

package/src/context/repo-index.js

@@ -101,35 +101,41 @@ 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;
-    }
+function lineIndent(raw, i) {
+  return raw[i].length - raw[i].trimStart().length;
+}
 
-    return Math.min(end, lineCount);
+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 raw[start - 1] ?? "") {
+  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++) {
-    for (const ch of raw[i]) {
-      if (ch === "{") depth++;
-      else if (ch === "}") depth--;
-    }
+    depth += braceDelta(raw[i]);
 
     if (depth <= 0) return i + 1;
   }
@@ -137,6 +143,89 @@ function declarationEnd(raw, lower, start, lineCount, ext) {
   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;
+
+  while (offset < buffer.length) {
+    const read = fs.readSync(fd, buffer, offset, buffer.length - offset, offset);
+
+    if (read <= 0) break;
+    offset += read;
+  }
+
+  return offset;
+}
+
+function parseRgFiles(res, root) {
+  let error;
+
+  if (res.exitCode !== 0 && res.exitCode !== 1) error = res.stderr.trim() || "rg exited with status " + res.exitCode;
+  const truncated = res.outputTruncated === true;
+  const output = truncated && !res.stdout.endsWith("\n") ? res.stdout.slice(0, res.stdout.lastIndexOf("\n") + 1) : res.stdout;
+
+  return { files: output.split("\n").flatMap(f => f ? [path.resolve(root, f)] : []).sort(), error, truncated, missing: false };
+}
+
+function addPorcelainRow(rows, i, set) {
+  const row = rows[i];
+
+  if (row.length <= 3) return i;
+  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 + 1];
+
+    if (target) set.add(target);
+
+    return i + 1;
+  }
+
+  return i;
+}
+
+function ingestPorcelain(stdout, set) {
+  const rows = stdout.split("\0");
+
+  for (let i = 0; i < rows.length; i++) i = addPorcelainRow(rows, i, set);
+}
+
+function grepPendingHuge(pending, rel, regex, out) {
+  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;
+  }
+}
+
+function grepEntryRows(e, filePath, root, regex, nameRegex, out) {
+  const lineAnchored = /\^|\$/.test(regex.source.replace(/\\[\^$]|\[[^\]]*\]/g, ""));
+
+  if (!lineAnchored && !regex.test(e.text)) return;
+  const { raw, defNames } = WorkspaceIndex.linesOf(e);
+  const rel = relativeSlash(root, filePath);
+
+  for (let i = 0; i < raw.length; i++) {
+    if (regex.test(raw[i])) out.push({ rel, line: i + 1, text: raw[i], def: defNames[i] !== "" && nameRegex.test(defNames[i]) });
+  }
+}
+
 export class WorkspaceIndex {
   constructor(runCommand) {
     this.runCommand = runCommand;
@@ -164,6 +253,8 @@ export class WorkspaceIndex {
     this.lastTouched = relPath;
   }
 
+  getEntryBytes() { return this.entryBytes; }
+
   watch(root) {
     if (this.watchers.has(root)) return this.watchers.get(root);
     let ok = false;
@@ -211,24 +302,7 @@ export class WorkspaceIndex {
     try {
       const res = await this.runCommand(["git", "status", "--porcelain", "-z", "--untracked-files=all"], { cwd: root, timeoutMs: 5_000 });
 
-      if (res.exitCode === 0) {
-        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);
-          }
-        }
-      }
+      if (res.exitCode === 0) ingestPorcelain(res.stdout, set);
     } catch {}
 
     this.gitModified.set(root, set);
@@ -248,142 +322,95 @@ export class WorkspaceIndex {
     }
   }
 
-  /** Absolute, sorted file list for a root; gitignore-aware via rg; cached for LIST_TTL_MS. */
-  async files(root, includeHidden = false, signal) {
-    const key = root + "\0" + (includeHidden ? "h" : "");
-    const cached = this.lists.get(key);
-    const ttl = this.watch(root) ? WATCHED_TTL_MS : LIST_TTL_MS;
-
-    if (cached && Date.now() - cached.at < ttl) return cached.files;
+  async listFilesWithRg(root, includeHidden, signal) {
     const args = ["rg", "--files"];
 
     if (includeHidden) args.push("--hidden");
     args.push("-g", "!.git/**", "-g", "!**/.git/**", "--", root);
-    let files = [];
-    let error;
-    let truncated = false;
-    let missing = false;
 
     try {
-      const res = await this.runCommand(args, { cwd: root, timeoutMs: 15_000, signal });
-
-      if (res.exitCode !== 0 && res.exitCode !== 1) error = res.stderr.trim() || "rg exited with status " + res.exitCode;
-      truncated = res.outputTruncated === true;
-      const output = truncated && !res.stdout.endsWith("\n") ? res.stdout.slice(0, res.stdout.lastIndexOf("\n") + 1) : res.stdout;
-      files = output.split("\n").filter(Boolean).map(f => path.resolve(root, f)).sort();
+      return parseRgFiles(await this.runCommand(args, { cwd: root, timeoutMs: 15_000, signal }), root);
     } catch (err) {
       signal?.throwIfAborted();
-      error = err.message;
-      missing = !fs.existsSync(root);
-    }
-
-    this.lists.set(key, { files, at: Date.now(), error, truncated, missing });
 
-    return files;
+      return { files: [], error: err.message, truncated: false, missing: !fs.existsSync(root) };
+    }
   }
 
-  /** Cached {text, lower, ext, surface?} for a file, re-read when mtime/size changed. Null for unreadable, binary, or huge files. */
-  entry(filePath) {
-    if (!isTextCandidate(filePath)) return null;
-    let stat;
-
-    try {
-      stat = fs.statSync(filePath);
-    } catch {
-      const previous = this.entries.get(filePath);
-
-      if (previous) this.entryBytes -= previous.weight ?? 0;
-      this.entries.delete(filePath);
+  /** Absolute, sorted file list for a root; gitignore-aware via rg; cached for LIST_TTL_MS. */
+  async files(root, includeHidden = false, signal) {
+    const key = root + "\0" + (includeHidden ? "h" : "");
+    const cached = this.lists.get(key);
+    const ttl = this.watch(root) ? WATCHED_TTL_MS : LIST_TTL_MS;
 
-      return null;
-    }
+    if (cached && Date.now() - cached.at < ttl) return cached.files;
+    const listed = await this.listFilesWithRg(root, includeHidden, signal);
+    this.lists.set(key, { ...listed, at: Date.now() });
 
-    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
-      const previous = this.entries.get(filePath);
+    return listed.files;
+  }
 
-      if (previous) this.entryBytes -= previous.weight ?? 0;
-      this.entries.delete(filePath);
+  dropCached(filePath) {
+    const previous = this.entries.get(filePath);
 
-      return null;
-    }
-    const cached = this.entries.get(filePath);
+    if (previous) this.entryBytes -= previous.weight ?? 0;
+    this.entries.delete(filePath);
+  }
 
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-      this.entries.delete(filePath);
-      this.entries.set(filePath, cached);
+  rejectEntry(filePath) {
+    this.dropCached(filePath);
 
-      return cached;
-    }
-    let text;
-    let actual = stat;
+    return null;
+  }
 
+  statOrNull(filePath) {
     try {
-      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK ?? 0));
+      return fs.statSync(filePath);
+    } catch {
+      return null;
+    }
+  }
 
-      try {
-        actual = fs.fstatSync(fd);
-        if (!actual.isFile() || actual.size > MAX_FILE_BYTES) {
-          const previous = this.entries.get(filePath);
+  cachedHit(filePath, stat) {
+    const cached = this.entries.get(filePath);
 
-          if (previous) this.entryBytes -= previous.weight ?? 0;
-          this.entries.delete(filePath);
+    if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) return null;
+    this.entries.delete(filePath);
+    this.entries.set(filePath, cached);
 
-          return null;
-        }
-        const buffer = Buffer.alloc(MAX_FILE_BYTES + 1);
-        let offset = 0;
+    return cached;
+  }
 
-        while (offset < buffer.length) {
-          const read = fs.readSync(fd, buffer, offset, buffer.length - offset, offset);
+  readFdText(filePath, fd) {
+    let actual = fs.fstatSync(fd);
 
-          if (read <= 0) break;
-          offset += read;
-        }
+    if (!actual.isFile() || actual.size > MAX_FILE_BYTES) return this.rejectEntry(filePath);
+    // One reusable scratch read per index: allocating 512 KiB per file lets
+    // thousands of dead buffers pile up as RSS before a major GC notices.
+    this.scratchRead ??= Buffer.alloc(MAX_FILE_BYTES + 1);
+    const offset = readFdBuffer(fd, this.scratchRead);
 
-        if (offset > MAX_FILE_BYTES) {
-          const previous = this.entries.get(filePath);
+    if (offset > MAX_FILE_BYTES) return this.rejectEntry(filePath);
+    actual = fs.fstatSync(fd);
 
-          if (previous) this.entryBytes -= previous.weight ?? 0;
-          this.entries.delete(filePath);
+    if (!actual.isFile() || actual.size !== offset) return this.rejectEntry(filePath);
 
-          return null;
-        }
-        actual = fs.fstatSync(fd);
-        if (!actual.isFile() || actual.size !== offset) {
-          const previous = this.entries.get(filePath);
+    return { text: this.scratchRead.subarray(0, offset).toString("utf8"), actual };
+  }
 
-          if (previous) this.entryBytes -= previous.weight ?? 0;
-          this.entries.delete(filePath);
+  readIndexedText(filePath) {
+    try {
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK ?? 0));
 
-          return null;
-        }
-        text = buffer.subarray(0, offset).toString("utf8");
+      try {
+        return this.readFdText(filePath, fd);
       } finally { fs.closeSync(fd); }
     } catch {
-      const previous = this.entries.get(filePath);
-
-      if (previous) this.entryBytes -= previous.weight ?? 0;
-      this.entries.delete(filePath);
-
-      return null;
+      return this.rejectEntry(filePath);
     }
+  }
 
-    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 (previous) this.entryBytes -= previous.weight ?? 0;
-    this.entries.delete(filePath);
-    this.entries.set(filePath, created);
-    this.entryBytes += created.weight;
-
+  evictOverflow() {
     while (this.entryBytes > MAX_ENTRY_CACHE_BYTES && this.entries.size > 1) {
       const oldest = this.entries.keys().next().value;
       const evicted = this.entries.get(oldest);
@@ -391,10 +418,38 @@ export class WorkspaceIndex {
       this.entries.delete(oldest);
       this.entryBytes -= evicted?.weight ?? 0;
     }
+  }
+
+  storeCreated(filePath, loaded) {
+    const created = { text: loaded.text, lower: loaded.text.toLowerCase(), mtimeMs: loaded.actual.mtimeMs, size: loaded.actual.size, weight: Math.max(1, loaded.actual.size) * 2, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+    this.dropCached(filePath);
+    this.entries.set(filePath, created);
+    this.entryBytes += created.weight;
+    this.evictOverflow();
 
     return created;
   }
 
+  /** Cached {text, lower, ext, surface?} for a file, re-read when mtime/size changed. Null for unreadable, binary, or huge files. */
+  entry(filePath) {
+    if (!isTextCandidate(filePath)) return null;
+    const stat = this.statOrNull(filePath);
+
+    if (!stat) return this.rejectEntry(filePath);
+
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return this.rejectEntry(filePath);
+    const cached = this.cachedHit(filePath, stat);
+
+    if (cached) return cached;
+    const loaded = this.readIndexedText(filePath);
+
+    if (!loaded) return null;
+
+    if (loaded.text.includes("\0")) return this.rejectEntry(filePath);
+
+    return this.storeCreated(filePath, loaded);
+  }
+
   static fromText(filePath, text) {
     return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
   }
@@ -470,46 +525,27 @@ export class WorkspaceIndex {
     return hits;
   }
 
+  resolveGrepEntry(filePath, overlayText, root, regex, out) {
+    const pending = overlayText(filePath);
+
+    if (pending === undefined) return this.entry(filePath);
+
+    if (Buffer.byteLength(pending, "utf8") <= MAX_FILE_BYTES) return WorkspaceIndex.fromText(filePath, pending);
+    grepPendingHuge(pending, relativeSlash(root, filePath), regex, out);
+
+    return null;
+  }
+
   /** Structured grep rows {rel, line, text, def}; def marks lines whose declared name itself matches. */
   grepRows(files, regex, root, overlayText = () => undefined) {
     const out = [];
     const nameRegex = new RegExp(regex.source, "i");
 
     for (const filePath of files) {
-      const pending = overlayText(filePath);
-      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;
-      }
+      const e = this.resolveGrepEntry(filePath, overlayText, root, regex, out);
 
       if (!e) continue;
-      const lineAnchored = /\^|\$/.test(regex.source.replace(/\\[\^$]|\[[^\]]*\]/g, ""));
-
-      if (!lineAnchored && !regex.test(e.text)) continue;
-      const { raw, defNames } = WorkspaceIndex.linesOf(e);
-      const rel = relativeSlash(root, filePath);
-
-      for (let i = 0; i < raw.length; i++) {
-        if (regex.test(raw[i])) out.push({ rel, line: i + 1, text: raw[i], def: defNames[i] !== "" && nameRegex.test(defNames[i]) });
-      }
+      grepEntryRows(e, filePath, root, regex, nameRegex, out);
     }
 
     return out;