pi-supernova 0.0.11 → 0.0.15

package/render.js

@@ -12,124 +12,11 @@
 
 import { stripVTControlCharacters } from "node:util";
 import { isString, isObject, isFunction } from "./decode.js";
-import {
-	measureWidth,
-	hardTruncate,
-	clampLine,
-	wrapPlainToWidth,
-	fitPath,
-} from "./render-measure.js";
+import { measureWidth, hardTruncate, clampLine, fitPath } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
 import { formatValue } from "./format.js";
 
-export { measureWidth, hardTruncate, clampLine, wrapPlainToWidth, fitPath };
-
-function fitOutputLines(text, width) {
-	const w = Math.max(1, width | 0);
-	const out = [];
-	for (const line of String(text ?? "")
-		.replace(/\t/g, "   ")
-		.split("\n")) {
-		if (measureWidth(line) <= w) {
-			out.push(line);
-			continue;
-		}
-		// Wrap on plain text so long paths continue on the next line instead of
-		// dying as `packages/pi-supern…`. ANSI is dropped on wrap (crash-safety).
-		const plain = stripVTControlCharacters(line);
-		for (const chunk of wrapPlainToWidth(plain, w)) {
-			out.push(clampLine(chunk, w));
-		}
-	}
-	return out.length > 0 ? out : [""];
-}
-
-/** Compact bounded text; the host supplies the card background and borders. */
-export class SafeText {
-	constructor(text = "") {
-		this.text = text;
-	}
-	setText(text) {
-		this.text = text;
-	}
-	invalidate() {}
-	render(width = 80) {
-		const raw = String(this.text ?? "");
-		return raw.trim() ? fitOutputLines(raw, Math.max(1, width | 0)) : [];
-	}
-}
-
-// Keep names some tests / older call sites may import.
-export const visibleWidth = measureWidth;
-export const truncateToWidth = hardTruncate;
-
-export function extractOperationsFromCode(code) {
-	const trimmed = String(code || "").trim();
-	if (!trimmed) return [];
-
-	const ops = [];
-	const seen = new Set();
-
-	const addOp = (tool, target) => {
-		const key = `${tool}:${target}`;
-		if (!seen.has(key)) {
-			seen.add(key);
-			ops.push({ tool, target });
-		}
-	};
-
-	const callRegex = /nova\.call\s*\(\s*["'`]([a-zA-Z0-9_-]+)["'`](?:\s*,\s*(\{[\s\S]*?\}))?/g;
-	let match;
-	while ((match = callRegex.exec(trimmed)) !== null) {
-		const tool = match[1];
-		let target = "";
-		if (match[2]) {
-			const pathMatch = /path\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			const cmdMatch = /command\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			const patMatch = /pattern\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			if (pathMatch) target = pathMatch[1];
-			else if (cmdMatch) target = cmdMatch[1].length > 30 ? cmdMatch[1].slice(0, 27) + "…" : cmdMatch[1];
-			else if (patMatch) target = patMatch[1];
-		}
-		addOp(tool, target);
-	}
-
-	const callManyRegex = /nova\.callMany\s*\(\s*\[([\s\S]*?)\]\s*\)/g;
-	while ((match = callManyRegex.exec(trimmed)) !== null) {
-		const inner = match[1];
-		const subCalls = inner.matchAll(/name\s*:\s*["'`]([a-zA-Z0-9_-]+)["'`]/g);
-		for (const sub of subCalls) addOp(sub[1], "");
-	}
-
-	const namedCalls = [
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?read\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "read", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?write\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "write", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?edit\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "edit", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?patch\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "patch", wrap: (p) => p },
-		{
-			regex: /(?:^|[^\w$.])(?:nova\.)?bash\s*\(\s*["'`]([^"'`]+)["'`]/gm,
-			tool: "bash",
-			wrap: (c) => (c.length > 32 ? c.slice(0, 29) + "…" : c),
-		},
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?exec\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "exec", wrap: (c) => c },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?search\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "search", wrap: (q) => `"${q}"` },
-		{ regex: /(?:^|[^\w$.])nova\.describe\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "describe", wrap: (name) => name },
-		{ regex: /(?:^|[^\w$.])nova\.has\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "has", wrap: (name) => name },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?surface\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "surface", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?snap\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "snap", wrap: (q) => `"${q}"` },
-	];
-	for (const item of namedCalls) {
-		while ((match = item.regex.exec(trimmed)) !== null) {
-			addOp(item.tool, item.wrap(match[1]));
-		}
-	}
-
-	if (/nova\.speculate\s*\(/.test(trimmed)) {
-		addOp("speculate", "(branch foam)");
-	}
-
-	return ops;
-}
+export { measureWidth, hardTruncate, clampLine };
 
 function formatDiffRows(diff, theme, maxShown = 6) {
 	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return [];
@@ -217,7 +104,7 @@ export function normalizeCallRenderArgs(a, b, c) {
 /**
  * Dual-host renderResult args:
  *   Pi:  (result, {expanded,isPartial}, theme, context)
- *   OMP: (result, {expanded,isPartial}, theme, args)  — 4th is args, not context
+ *   OMP: (result, {expanded,isPartial}, theme, args)  (4th is args, not context)
  *
  * Call shapes share the first three positions, so host is inferred from the
  * fourth argument's context-versus-args shape.
@@ -237,7 +124,7 @@ function detectResultHost(options, ctxOrArgs) {
 	return "pi";
 }
 
-export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
+function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
 	if (isTheme(themeOrCtx)) {
 		const opts = isObject(options) ? options : {};
 		const context = contextFrom(opts, ctxOrArgs);
@@ -333,20 +220,21 @@ function operationsFromTrace(trace) {
 		.filter(Boolean);
 }
 
+// The call slot is always empty: the result card owns the whole lifecycle in both hosts.
+const EMPTY_CALL = { render: () => [], invalidate() {} };
+
 export function renderSupernovaCall(a, b, c) {
 	const { context, options } = normalizeCallRenderArgs(a, b, c);
-	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
-	if (options) options.lastComponent = comp;
-	else if (context) context.lastComponent = comp;
-	comp.setText("");
-	return comp;
+	if (options) options.lastComponent = EMPTY_CALL;
+	else if (context) context.lastComponent = EMPTY_CALL;
+	return EMPTY_CALL;
 }
 
 const TOOL_COL = 7;
 const DURATION_COL = 6;
 const PREVIEW_LINES = 24;
 
-export function formatDuration(ms) {
+function formatDuration(ms) {
 	if (!Number.isFinite(ms) || ms < 0) return "";
 	if (ms < 1000) return `${Math.round(ms)}ms`;
 	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
@@ -418,11 +306,8 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 	return prefix.trimEnd();
 }
 
-function operationsFor(payload, context, args) {
-	const trace = payload?.trace || context?.state?.trace || [];
-	const traced = operationsFromTrace(trace);
-	if (traced.length > 0) return traced;
-	return extractOperationsFromCode(args?.code).map((op) => displayOperation(op.tool, op.target)).filter(Boolean);
+function operationsFor(payload, context) {
+	return operationsFromTrace(payload?.trace || context?.state?.trace || []);
 }
 
 function resultLines(value, maxLines) {
@@ -475,33 +360,34 @@ class UnifiedResultCard {
 	set(theme, model) {
 		this.theme = theme;
 		this.model = model;
-		this.frame = undefined;
+		this.cache = undefined;
 	}
 	invalidate() {
-		this.frame = undefined;
+		this.cache = undefined;
 	}
 	render(width = 80) {
 		const { theme, model } = this;
 		if (!theme || !model) return [];
-		if (!this.frame) {
-			this.frame = novaFramedBlock(theme, (frameWidth) => {
-				const contentWidth = Math.max(1, frameWidth - 4);
-				const view = buildBodyLines(theme, contentWidth, model);
-				return {
-					header: novaStatusLine(theme, {
-						icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
-						title: "nova",
-						description: describeCard(model, view.opCount),
-					}),
-					sections: view.lines.length > 0 ? [{ lines: view.lines }] : [],
+		if (this.cache?.width === width) return this.cache.lines;
+		const view = buildBodyLines(theme, Math.max(1, width - 4), model);
+		const header = novaStatusLine(theme, {
+			icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
+			title: "nova",
+			description: describeCard(model, view.opCount),
+		});
+		// A program with no host calls has nothing to frame: one status line, no empty box.
+		const lines = view.lines.length === 0
+			? [clampLine(header, width)]
+			: novaFramedBlock(theme, () => ({
+					header,
+					sections: [{ lines: view.lines }],
 					state: model.isError ? "error" : model.isPartial ? "pending" : "success",
 					// borderMuted is invisible on OMP's card background; dim matches the duration column.
 					borderColor: model.isError ? "error" : "dim",
-					width: frameWidth,
-				};
-			});
-		}
-		return this.frame.render(width);
+					width,
+				})).render(width);
+		this.cache = { width, lines };
+		return lines;
 	}
 }
 

package/repo-index.js

@@ -1,13 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { extractStructuralSurface } from "./surface.js";
+import { Frecency } from "./fuzzy.js";
+import { relativeSlash } from "./workspace.js";
 
 // In-process workspace index: the gitignore-aware file list comes from one
 // \`rg --files\` spawn and is then reused; file text, lowercase text, and the
 // structural surface are cached per path and validated by mtime. snap/grep/glob
 // read from here instead of spawning, so a warm call is sub-millisecond.
 
+// With a working fs.watch the list only refreshes on change; the TTL is the fallback when watching fails.
 const LIST_TTL_MS = 10_000;
+const WATCHED_TTL_MS = 5 * 60_000;
+const WATCH_DEBOUNCE_MS = 150;
 const MAX_INDEXED_FILES = 4000;
 const MAX_FILE_BYTES = 512 * 1024;
 const BINARY_EXT = new Set([
@@ -20,7 +25,12 @@ 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_$]+)/;
 
-export function isTextCandidate(filePath) {
+/** Declared identifier on a line (function/class/const/…), or ""; the same rule snap and grep use. */
+export function declaredName(line) {
+  return DEF_PATTERN.exec(String(line).trim())?.[2] ?? "";
+}
+
+function isTextCandidate(filePath) {
   return !BINARY_EXT.has(path.extname(filePath).toLowerCase());
 }
 
@@ -69,17 +79,81 @@ export class WorkspaceIndex {
     this.runCommand = runCommand;
     this.lists = new Map();
     this.entries = new Map();
+    this.watchers = new Map();
+    this.frecency = new Frecency();
+    this.gitModified = new Map(); // root → Set(relative "/"-joined paths)
+    this.lastTouched = null;
   }
 
   invalidate() {
     this.lists.clear();
   }
 
+  /** fff frecency: every read/edit is an access; the newest one is the "current file" for distance penalties. */
+  touch(relPath) {
+    this.frecency.record(relPath);
+    this.lastTouched = relPath;
+  }
+
+  watch(root) {
+    if (this.watchers.has(root)) return this.watchers.get(root);
+    let ok = false;
+    try {
+      let timer = null;
+      const watcher = fs.watch(root, { recursive: true }, () => {
+        if (timer) return;
+        timer = setTimeout(() => {
+          timer = null;
+          this.lists.clear();
+          this.gitModified.delete(root);
+        }, WATCH_DEBOUNCE_MS);
+      });
+      watcher.on("error", () => {
+        this.watchers.set(root, false);
+        this.lists.clear();
+      });
+      if (typeof watcher.unref === "function") watcher.unref();
+      ok = true;
+    } catch {
+      ok = false;
+    }
+    this.watchers.set(root, ok);
+    return ok;
+  }
+
+  /** Paths git reports as modified/added/untracked (fff's git-status boost); one spawn per list refresh. */
+  async modifiedFiles(root) {
+    const cached = this.gitModified.get(root);
+    if (cached) return cached;
+    const set = new Set();
+    try {
+      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));
+        }
+      }
+    } catch {}
+    this.gitModified.set(root, set);
+    return set;
+  }
+
+  mtimeSeconds(filePath) {
+    const e = this.entries.get(filePath);
+    if (e) return e.mtimeMs / 1000;
+    try {
+      return fs.statSync(filePath).mtimeMs / 1000;
+    } catch {
+      return 0;
+    }
+  }
+
   /** Absolute, sorted file list for a root; gitignore-aware via rg; cached for LIST_TTL_MS. */
   async files(root, includeHidden = false) {
     const key = root + "\0" + (includeHidden ? "h" : "");
     const cached = this.lists.get(key);
-    if (cached && Date.now() - cached.at < LIST_TTL_MS) return cached.files;
+    const ttl = this.watch(root) ? WATCHED_TTL_MS : LIST_TTL_MS;
+    if (cached && Date.now() - cached.at < ttl) return cached.files;
     const args = ["rg", "--files"];
     if (includeHidden) args.push("--hidden");
     args.push("-g", "!.git/**", "-g", "!**/.git/**", root);
@@ -114,16 +188,16 @@ export class WorkspaceIndex {
       return null;
     }
     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 };
+    const created = { text, lower: text.toLowerCase(), mtimeMs: stat.mtimeMs, size: stat.size, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
     this.entries.set(filePath, created);
     return created;
   }
 
   static fromText(filePath, text) {
-    return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined };
+    return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
   }
 
-  /** Per-line raw text, lowercase text, declared identifier (or ""), and identifier tokens — computed once per entry. */
+  /** 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");
@@ -140,6 +214,25 @@ export class WorkspaceIndex {
     return entry.lines;
   }
 
+  /**
+   * 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.
+   */
+  static spansOf(entry) {
+    if (entry.spans) return entry.spans;
+    const { items, lineCount } = WorkspaceIndex.surfaceOf(entry);
+    const { lower } = 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);
+      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 surfaceOf(entry) {
     if (!entry.surface) entry.surface = extractStructuralSurface(entry.text, entry.ext);
     return entry.surface;
@@ -162,16 +255,17 @@ export class WorkspaceIndex {
     return hits;
   }
 
-  /** rg-style "path:line:text" rows over the indexed files, paths relative to root. */
-  grep(files, regex, root) {
+  /** Structured grep rows {rel, line, text, def}; def marks lines whose declared name itself matches. */
+  grepRows(files, regex, root) {
     const out = [];
+    const nameRegex = new RegExp(regex.source, "i");
     for (const filePath of files) {
       const e = this.entry(filePath);
       if (!e || !regex.test(e.text)) continue;
-      const lines = e.text.split("\n");
-      const rel = path.relative(root, filePath) || filePath;
-      for (let i = 0; i < lines.length; i++) {
-        if (regex.test(lines[i])) out.push(rel + ":" + (i + 1) + ":" + lines[i]);
+      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]) });
       }
     }
     return out;

package/runtime.js

@@ -94,15 +94,6 @@ export function warmGuestWorker(config) {
   return handle.ready;
 }
 
-/** Terminate every guest worker (tests, shutdown). */
-export async function shutdownGuestWorkers() {
-  if (!idleWorker) return;
-  const handle = idleWorker;
-  idleWorker = null;
-  handle.dead = true;
-  await handle.worker.terminate();
-}
-
 const RPC_METHODS = {
   call: (nova, args) => {
     if (!isFunction(nova?.call)) throw new Error("nova.call unavailable");
@@ -122,17 +113,9 @@ const RPC_METHODS = {
     if (!isFunction(nova?.describe)) throw new Error("nova.describe unavailable");
     return nova.describe(args[0]);
   },
-  surface: (nova, args) => {
-    if (isFunction(nova?.surface)) return nova.surface(args[0]);
-    return nova.call("surface", { path: args[0] });
-  },
-  snap: (nova, args) => {
-    if (isFunction(nova?.snap)) return nova.snap(args[0], args[1]);
-    return nova.call("snap", { query: args[0], path: args[1] });
-  },
-  speculateBegin: (nova) => (isFunction(nova?.speculateBegin) ? nova.speculateBegin() : undefined),
-  speculateCommit: (nova) => (isFunction(nova?.speculateCommit) ? nova.speculateCommit() : undefined),
-  speculateRollback: (nova) => (isFunction(nova?.speculateRollback) ? nova.speculateRollback() : undefined),
+  speculateBegin: (nova) => nova?.speculateBegin?.(),
+  speculateCommit: (nova) => nova?.speculateCommit?.(),
+  speculateRollback: (nova) => nova?.speculateRollback?.(),
 };
 
 async function dispatchRpc(nova, method, args) {

package/search.js

@@ -0,0 +1,141 @@
+import * as path from "node:path";
+import { WorkspaceIndex, globToRegExp } from "./repo-index.js";
+import { rankPaths, smartCase, fuzzyMatch } from "./fuzzy.js";
+import { runCommand, relativeSlash } from "./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 || {} };
+}
+
+export function rgGrepArgs(pattern, params, searchPath) {
+  const args = ["--line-number", "--no-heading", "--color", "never"];
+  if (params?.caseSensitive !== true) args.push("--ignore-case");
+  if (params?.glob) args.push("--glob", String(params.glob));
+  args.push("--", pattern, searchPath);
+  return args;
+}
+
+/** rg --files, then find(1) when rg is unavailable; both accept an optional glob/name pattern. */
+export async function listWithTools(searchDir, pattern, cwd, signal) {
+  const args = ["--files"];
+  if (pattern) args.push("-g", pattern);
+  const res = await runCommand(["rg", ...args, searchDir], { cwd, timeoutMs: 30_000, signal }).catch(() => null);
+  if (res && (res.exitCode === 0 || res.exitCode === 1)) return textResult(res.stdout, { via: "rg" });
+  const findArgs = [searchDir];
+  if (pattern) findArgs.push("-name", pattern);
+  const findRes = await runCommand(["find", ...findArgs], { cwd, timeoutMs: 30_000, signal });
+  return textResult(findRes.stdout, { via: "find" });
+}
+
+const GLOB_CHARS = /[*?[\]{}]/;
+
+/**
+ * fffind: a pattern without glob characters is a fuzzy, typo-tolerant, frecency-ranked path query.
+ * Returns "path" rows (best first) or null when the pattern is a real glob.
+ */
+export async function fuzzyFind(index, root, cwd, pattern, limit = 20) {
+  if (!pattern || GLOB_CHARS.test(pattern)) return null;
+  const files = await index.files(root);
+  if (!index.canScan(files)) return null;
+  const rel = files.map((f) => relativeSlash(cwd, f));
+  const absolute = new Map(rel.map((r, i) => [r, files[i]]));
+  // mtime is only consulted for paths that matched; never stat the whole tree.
+  const mtimeOf = (r) => index.mtimeSeconds(absolute.get(r));
+  const ranked = rankPaths(pattern, rel, { frecency: index.frecency, mtimeOf, modified: await index.modifiedFiles(cwd), currentFile: index.lastTouched });
+  // fff weak-match detector: when nothing matches exactly and the best is mostly typos, say so instead of flooding.
+  const rows = ranked.slice(0, limit);
+  if (rows.length === 0) return "";
+  return rows.map((r) => r.path).join("\n") + "\n";
+}
+
+/** fff-style grep: smart-case, definition lines first, fuzzy fallback when the literal has no hits. */
+export async function grepIndexed(index, pattern, params, searchPath, cwd) {
+  const compiled = grepRegex(pattern, params);
+  if (!compiled) return null;
+  const { regex, caseSensitive } = compiled;
+  let files = await index.files(searchPath);
+  if (!index.canScan(files)) return null;
+  if (params?.glob) {
+    const matcher = globToRegExp(String(params.glob));
+    files = files.filter((f) => matcher.test(relativeSlash(cwd, f)));
+  }
+  const rows = index.grepRows(files, regex, cwd);
+  const fallback = rows.length === 0 && /^[\w$.-]{4,}$/.test(pattern) ? fuzzyGrepRows(index, files, pattern, cwd, caseSensitive) : rows;
+  return formatGrepRows(fallback, grepLimit(params));
+}
+
+function grepLimit(params) {
+  return Number.isInteger(params?.limit) && params.limit > 0 ? params.limit : 200;
+}
+
+function grepRegex(pattern, params) {
+  const caseSensitive = params?.caseSensitive === true || (params?.caseSensitive !== false && smartCase(pattern));
+  try {
+    return { regex: new RegExp(pattern, caseSensitive ? "" : "i"), caseSensitive };
+  } catch {
+    return null;
+  }
+}
+
+/** Zero literal hits: retry each line fuzzily (1 typo, 2 for long names) within a tight span, so IsOffTheRecord finds is_off_the_record. */
+function fuzzyGrepRows(index, files, pattern, cwd, caseSensitive) {
+  const maxTypos = pattern.length >= 8 ? 2 : 1;
+  const rows = [];
+  for (const filePath of files) {
+    const e = index.entry(filePath);
+    if (!e) continue;
+    const { raw, defNames } = WorkspaceIndex.linesOf(e);
+    const rel = relativeSlash(cwd, filePath);
+    for (let i = 0; i < raw.length && rows.length <= 400; i++) {
+      const m = fuzzyMatch(pattern, raw[i], { maxTypos, caseSensitive });
+      if (!m || m.end - m.start > pattern.length + 2) continue;
+      rows.push({ rel, line: i + 1, text: raw[i], def: defNames[i] !== "" && fuzzyMatch(pattern, defNames[i], { maxTypos }) !== null });
+    }
+  }
+  return rows;
+}
+
+/** fff definition-first hinting: files that declare the name come first, declarations first within a file; one header per file. */
+function formatGrepRows(rows, limit) {
+  if (rows.length === 0) return "";
+  const groups = new Map();
+  for (const r of rows) {
+    if (!groups.has(r.rel)) groups.set(r.rel, []);
+    groups.get(r.rel).push(r);
+  }
+  const files = [...groups.values()].sort((a, b) => Number(b.some((r) => r.def)) - Number(a.some((r) => r.def)));
+  let out = "";
+  let shown = 0;
+  for (const group of files) {
+    if (shown >= limit) break;
+    out += group[0].rel + "\n";
+    group.sort((a, b) => Number(b.def) - Number(a.def) || a.line - b.line);
+    for (const r of group) {
+      if (shown++ >= limit) break;
+      out += "  " + r.line + (r.def ? "*" : ":") + " " + r.text.trim() + "\n";
+    }
+  }
+  if (rows.length > limit) out += "… " + (rows.length - limit) + " more matches (pass limit or narrow the pattern)\n";
+  return out;
+}
+
+/** rg --files [-g pattern] served from the index; null when the tree is too large. */
+export async function listIndexed(index, root, cwd, pattern) {
+  const files = await index.files(root);
+  if (!index.canScan(files)) return null;
+  const rel = files.map((f) => path.relative(cwd, f).split(path.sep).join("/"));
+  if (!pattern) return rel.length ? rel.join("\n") + "\n" : "";
+  let matcher;
+  try {
+    matcher = globToRegExp(pattern);
+  } catch {
+    return null;
+  }
+  const hits = rel.filter((f) => matcher.test(f));
+  return hits.length ? hits.join("\n") + "\n" : "";
+}
+

package/snap.js

@@ -2,6 +2,7 @@
 import * as path from "node:path";
 import { isString } from "./decode.js";
 import { WorkspaceIndex } from "./repo-index.js";
+import { isTestPath } from "./workspace.js";
 
 const STOP_WORDS = new Set([
   "the", "a", "an", "and", "or", "in", "on", "at", "to", "for", "of", "with",
@@ -137,12 +138,6 @@ function mergeGrepHits(candidates, grepHits) {
   return candidates;
 }
 
-function isTestPath(filePath) {
-  const segments = filePath.split(path.sep);
-  const base = segments[segments.length - 1];
-  return segments.includes("test") || segments.includes("tests") || base.includes(".test.") || base.includes(".spec.");
-}
-
 function expandCandidatesWithGrep(candidates, fileList, tokens, flags, index) {
   if (candidates.length >= 5) return candidates;
   const salient = tokens.filter((t) => t.length > 2).slice(0, 4);

package/surface.js

@@ -68,25 +68,34 @@ const JS_DECL_PATTERNS = [
 ];
 // Module-level tables/constants (column 0 only): without them the previous declaration's span swallows them.
 const JS_TOP_LEVEL_BINDING = /^(const|let|var)\s+([a-zA-Z0-9_$]+)\s*=/;
+// Indented methods (object-literal adapters, class members) that open a block on the same line.
+const JS_METHOD = /^(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?\*?([a-zA-Z_$][\w$]*)\s*\([^()]*\)\s*\{$/;
+const JS_ARROW_PROPERTY = /^([a-zA-Z_$][\w$]*)\s*[:=]\s*(?:async\s+)?(?:\([^()]*\)|[a-zA-Z_$][\w$]*)\s*=>\s*\{$/;
+const NOT_METHOD_NAMES = new Set(["if", "for", "while", "switch", "catch", "function", "return", "else", "do", "try", "with", "await", "typeof", "new", "constructor"]);
+
+function methodItem(line, lineNumber, depth) {
+  const match = JS_METHOD.exec(line) || JS_ARROW_PROPERTY.exec(line);
+  if (!match || NOT_METHOD_NAMES.has(match[1])) return null;
+  return { kind: "method", name: match[1], isExport: false, signature: line.replace(/\s*\{$/, ""), line: lineNumber, depth };
+}
+
+function declarationItem(line, rawLine, lineNumber) {
+  const patterns = /^\S/.test(rawLine) ? [...JS_DECL_PATTERNS, [JS_TOP_LEVEL_BINDING, false]] : JS_DECL_PATTERNS;
+  for (const [pattern, isExport] of patterns) {
+    const match = pattern.exec(line);
+    if (match) return { kind: match[1], name: match[2], isExport, signature: line.replace(/\{.*$/, "").trim(), line: lineNumber, depth: 0 };
+  }
+  return null;
+}
 
 function scanJavaScript(lines) {
   const items = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     if (!line || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) continue;
-    const patterns = /^\S/.test(lines[i]) ? [...JS_DECL_PATTERNS, [JS_TOP_LEVEL_BINDING, false]] : JS_DECL_PATTERNS;
-    for (const [pattern, isExport] of patterns) {
-      const match = pattern.exec(line);
-      if (!match) continue;
-      items.push({
-        kind: match[1],
-        name: match[2],
-        isExport,
-        signature: line.replace(/\{.*$/, "").trim(),
-        line: i + 1,
-      });
-      break;
-    }
+    const indent = lines[i].length - lines[i].trimStart().length;
+    const item = declarationItem(line, lines[i], i + 1) || (indent > 0 && indent <= 8 ? methodItem(line, i + 1, 1) : null);
+    if (item) items.push(item);
   }
   return items;
 }