@ff-labs/pi-fff 0.10.1 → 0.10.2-nightly.031005e

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ff-labs/pi-fff",
   "public": true,
-  "version": "0.10.1",
+  "version": "0.10.2-nightly.031005e",
   "description": "pi extension: FFF-powered fuzzy file and content search",
   "type": "module",
   "license": "MIT",
@@ -40,8 +40,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ff-labs/fff-bun": "*",
-    "@ff-labs/fff-node": "*"
+    "@ff-labs/fff-bun": "0.10.2-nightly.031005e",
+    "@ff-labs/fff-node": "0.10.2-nightly.031005e"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",

package/src/aux-finders.ts

@@ -14,13 +14,15 @@ interface AuxPicker {
 }
 
 export interface AuxOpts {
-  frecencyDbPath?: string;
-  historyDbPath?: string;
   enableFsRootScanning: boolean;
 }
 
 export class AuxFinderPool {
   private entries: AuxPicker[] = [];
+  // In-flight creations keyed by root. Concurrent acquire() calls for the same
+  // (or a covering) root share one finder/scan instead of each starting a full
+  // duplicate traversal — issue #746. Mirrors the main finder's finderPromise.
+  private pending = new Map<string, Promise<AuxPicker>>();
   constructor(private opts: AuxOpts) {}
 
   destroy(): void {
@@ -29,6 +31,7 @@ export class AuxFinderPool {
     }
 
     this.entries = [];
+    this.pending.clear();
   }
 
   private sweepIdle(now = Date.now()): void {
@@ -60,31 +63,53 @@ export class AuxFinderPool {
       return { finder: covering.finder, root: covering.root };
     }
 
+    // Coalesce concurrent creations for the same root so we scan once. A slow
+    // full-home scan started by one call is awaited by the others instead of
+    // each spawning its own traversal (#746).
+    const inflight = this.pending.get(maybeRoot);
+    if (inflight) {
+      const e = await inflight;
+      e.lastUsed = Date.now();
+      return { finder: e.finder, root: e.root };
+    }
+
+    const creation = this.create(maybeRoot).finally(() => {
+      this.pending.delete(maybeRoot);
+    });
+    this.pending.set(maybeRoot, creation);
+    const entry = await creation;
+    return { finder: entry.finder, root: entry.root };
+  }
+
+  private async create(root: string): Promise<AuxPicker> {
     if (this.entries.length >= MAX_AUX) {
       let oldest = this.entries[0];
-      for (const e of this.entries)
-        if (e.lastUsed < oldest.lastUsed) oldest = e;
+      for (const e of this.entries) if (e.lastUsed < oldest.lastUsed) oldest = e;
       if (!oldest.finder.isDestroyed) oldest.finder.destroy();
       this.entries = this.entries.filter((e) => e !== oldest);
     }
 
     const { FileFinder } = await loadSdk();
+    // LMDB env can only be opened once per process; the main finder already
+    // owns the frecency/history DBs. Aux finders are transient and run without
+    // persistent scoring — see issue #700.
     const result = FileFinder.create({
-      basePath: maybeRoot,
-      frecencyDbPath: this.opts.frecencyDbPath,
-      historyDbPath: this.opts.historyDbPath,
+      basePath: root,
       aiMode: true,
       enableHomeDirScanning: true,
       enableFsRootScanning: this.opts.enableFsRootScanning,
     });
     if (!result.ok)
-      throw new Error(
-        `Failed to create aux file finder for ${maybeRoot}: ${result.error}`,
-      );
+      throw new Error(`Failed to create aux file finder for ${root}: ${result.error}`);
 
     await result.value.waitForScan(SCAN_TIMEOUT_MS);
-    this.entries.push({ root: maybeRoot, finder: result.value, lastUsed: Date.now() });
-    return { finder: result.value, root: maybeRoot };
+    const entry: AuxPicker = {
+      root,
+      finder: result.value,
+      lastUsed: Date.now(),
+    };
+    this.entries.push(entry);
+    return entry;
   }
 
   size(): number {
@@ -97,9 +122,7 @@ export class AuxFinderPool {
 // remainder usable as a fuzzy path constraint relative to that root. Glob and
 // nonexistent segments both go into the suffix: we walk up to the nearest
 // existing ancestor so partially-wrong paths still resolve to a search root.
-export function resolveAuxRoot(
-  absPath: string,
-): { root: string; suffix: string } | null {
+export function resolveAuxRoot(absPath: string): { root: string; suffix: string } | null {
   const trimmed = path.normalize(absPath.trim()).replace(/\/+$/, "") || "/";
   if (!path.isAbsolute(trimmed)) return null;
   if (trimmed === path.sep) return { root: path.sep, suffix: "" };
@@ -159,7 +182,6 @@ export function routePathConstraint(
   return resolveAuxRoot(candidate);
 }
 
-
 export function rootCovers(root: string, target: string): boolean {
   if (root === target) return true;
   const prefix = root.endsWith(path.sep) ? root : root + path.sep;

package/src/index.ts

@@ -36,6 +36,9 @@ const DEFAULT_FIND_LIMIT = 30;
 const GREP_MAX_LINE_LENGTH = 500;
 const MENTION_MAX_RESULTS = 20;
 
+// If we exceed 10 seconds for indexed grep - something is definitely off
+const GREP_TIME_BUDGET_MS = 10_000;
+
 type FffMode = "tools-and-ui" | "tools-only" | "override";
 
 const VALID_MODES: FffMode[] = ["tools-and-ui", "tools-only", "override"];
@@ -261,9 +264,7 @@ function createFffMentionProvider(
 
       const query = prefix.startsWith('@"') ? prefix.slice(2) : prefix.slice(1);
       const items = await getItems(query, options.signal);
-      return options.signal.aborted || items.length === 0
-        ? null
-        : { items, prefix };
+      return options.signal.aborted || items.length === 0 ? null : { items, prefix };
     },
     applyCompletion(_lines, cursorLine, cursorCol, item, prefix) {
       const currentLine = _lines[cursorLine] || "";
@@ -272,11 +273,7 @@ function createFffMentionProvider(
       const newLine = before + item.value + after;
       const newCursorCol = cursorCol - prefix.length + item.value.length;
       return {
-        lines: [
-          ..._lines.slice(0, cursorLine),
-          newLine,
-          ..._lines.slice(cursorLine + 1),
-        ],
+        lines: [..._lines.slice(0, cursorLine), newLine, ..._lines.slice(cursorLine + 1)],
         cursorLine,
         cursorCol: newCursorCol,
       };
@@ -344,8 +341,6 @@ export default function fffExtension(pi: ExtensionAPI) {
   }
 
   let auxPool = new AuxFinderPool({
-    frecencyDbPath,
-    historyDbPath,
     enableFsRootScanning,
   });
 
@@ -409,9 +404,7 @@ export default function fffExtension(pi: ExtensionAPI) {
     const aux = await auxPool.acquire(route.root);
     // A broader covering picker may have been reused; rebase the suffix so the
     // constraint stays relative to the picker's actual root.
-    const rebase = nodePath
-      .relative(aux.root, route.root)
-      .replaceAll(nodePath.sep, "/");
+    const rebase = nodePath.relative(aux.root, route.root).replaceAll(nodePath.sep, "/");
     const suffix = [rebase, route.suffix].filter(Boolean).join("/");
     const query = buildQuery(suffix || undefined, pattern, exclude, aux.root);
     return { finder: aux.finder, query, root: aux.root };
@@ -428,22 +421,20 @@ export default function fffExtension(pi: ExtensionAPI) {
     const result = f.mixedSearch(query, { pageSize: MENTION_MAX_RESULTS });
     if (!result.ok) return [];
 
-    return result.value.items
-      .slice(0, MENTION_MAX_RESULTS)
-      .map((mixed: MixedItem) => {
-        if (mixed.type === "directory") {
-          return {
-            value: buildAtCompletionValue(mixed.item.relativePath),
-            label: mixed.item.dirName,
-            description: mixed.item.relativePath,
-          };
-        }
+    return result.value.items.slice(0, MENTION_MAX_RESULTS).map((mixed: MixedItem) => {
+      if (mixed.type === "directory") {
         return {
           value: buildAtCompletionValue(mixed.item.relativePath),
-          label: mixed.item.fileName,
+          label: mixed.item.dirName,
           description: mixed.item.relativePath,
         };
-      });
+      }
+      return {
+        value: buildAtCompletionValue(mixed.item.relativePath),
+        label: mixed.item.fileName,
+        description: mixed.item.relativePath,
+      };
+    });
   }
 
   function registerAutocompleteProvider(ctx: {
@@ -479,21 +470,11 @@ export default function fffExtension(pi: ExtensionAPI) {
           return current.getSuggestions(lines, cursorLine, cursorCol, options);
         },
         applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-          return current.applyCompletion(
-            lines,
-            cursorLine,
-            cursorCol,
-            item,
-            prefix,
-          );
+          return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
         },
         shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
           return (
-            current.shouldTriggerFileCompletion?.(
-              lines,
-              cursorLine,
-              cursorCol,
-            ) ?? true
+            current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true
           );
         },
       };
@@ -508,14 +489,12 @@ export default function fffExtension(pi: ExtensionAPI) {
   });
 
   pi.registerFlag("fff-frecency-db", {
-    description:
-      "Path to the frecency database (overrides FFF_FRECENCY_DB env)",
+    description: "Path to the frecency database (overrides FFF_FRECENCY_DB env)",
     type: "string",
   });
 
   pi.registerFlag("fff-history-db", {
-    description:
-      "Path to the query history database (overrides FFF_HISTORY_DB env)",
+    description: "Path to the query history database (overrides FFF_HISTORY_DB env)",
     type: "string",
   });
 
@@ -575,20 +554,15 @@ export default function fffExtension(pi: ExtensionAPI) {
     context: any,
     maxLines = 15,
   ) => {
-    const text =
-      (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-    const output =
-      result.content?.find((c) => c.type === "text")?.text?.trim() ?? "";
+    const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+    const output = result.content?.find((c) => c.type === "text")?.text?.trim() ?? "";
     if (!output) {
       text.setText(theme.fg("muted", "No output"));
       return text;
     }
 
     const lines = output.split("\n");
-    const displayLines = lines.slice(
-      0,
-      options.expanded ? lines.length : maxLines,
-    );
+    const displayLines = lines.slice(0, options.expanded ? lines.length : maxLines);
     let content = `\n${displayLines.map((line: string) => theme.fg("toolOutput", line)).join("\n")}`;
     if (lines.length > displayLines.length) {
       content += theme.fg(
@@ -643,10 +617,10 @@ export default function fffExtension(pi: ExtensionAPI) {
     description: `Grep file contents. Smart-case, auto-detects regex vs literal, git-aware. Results are ranked by frecency (most-accessed files first); matches within a file stay in source order. Default limit ${DEFAULT_GREP_LIMIT}.`,
     promptSnippet: "Grep contents",
     promptGuidelines: [
-      "Prefer bare identifiers as patterns. Literal queries are most efficient.",
-      "Use path for include ('src/', '*.ts') and exclude for noise ('test/,*.min.js').",
-      "caseSensitive: true when you need exact case (smart-case otherwise).",
-      "After 1-2 greps, read the top match instead of more greps.",
+      `${toolNames.grep}: prefer bare identifiers as patterns. Literal queries are most efficient.`,
+      `${toolNames.grep}: use path for include ('src/', '*.ts') and exclude for noise ('test/,*.min.js').`,
+      `${toolNames.grep}: caseSensitive: true when you need exact case (smart-case otherwise).`,
+      `${toolNames.grep}: after 1-2 greps, read the top match instead of more greps.`,
     ],
     parameters: grepSchema,
 
@@ -654,11 +628,7 @@ export default function fffExtension(pi: ExtensionAPI) {
       if (signal?.aborted) throw new Error("Operation aborted");
 
       const pattern = params.pattern;
-      const aux = await resolveFinderForPath(
-        params.path,
-        pattern,
-        params.exclude,
-      );
+      const aux = await resolveFinderForPath(params.path, pattern, params.exclude);
 
       const picker = aux ? aux.finder : await ensureFinder(activeCwd);
       const effectiveLimit = Math.max(1, params.limit ?? DEFAULT_GREP_LIMIT);
@@ -669,8 +639,7 @@ export default function fffExtension(pi: ExtensionAPI) {
       // Auto-detect: regex if the pattern has regex metacharacters AND parses
       // as a valid regex, otherwise plain literal. The fuzzy fallback below
       // only kicks in for plain mode — regex queries are intentional.
-      const hasRegexSyntax =
-        pattern !== pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const hasRegexSyntax = pattern !== pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
       let mode: GrepMode = hasRegexSyntax ? "regex" : "plain";
       if (mode === "regex") {
@@ -715,6 +684,7 @@ export default function fffExtension(pi: ExtensionAPI) {
         beforeContext: params.context ?? 0,
         afterContext: params.context ?? 0,
         classifyDefinitions: true,
+        timeBudgetMs: GREP_TIME_BUDGET_MS,
       });
 
       if (!grepResult.ok) throw new Error(grepResult.error);
@@ -722,9 +692,23 @@ export default function fffExtension(pi: ExtensionAPI) {
       let result = grepResult.value;
       let fuzzyNotice: string | null = null;
 
-      // automatic fuzzy fallback allows to broad the queries and find different cases
-      if (result.items.length === 0 && !params.cursor && mode !== "regex") {
-        const fuzzy = picker.grep(pattern, {
+      // if we hit the timeout do not run the fuzzy fallback
+      // cause it will only consumer more time
+      if (
+        result.items.length === 0 &&
+        !result.nextCursor &&
+        !params.cursor &&
+        mode !== "regex"
+      ) {
+        // When the caller pinned a specific file (path has an extension), the
+        // fuzzy fallback broadens across the whole picker — the file may just
+        // be misnamed. For directory constraints (or no path), we keep the
+        // constrained query so the fallback does not leak matches from
+        // excluded / out-of-scope directories.
+        const lastSeg = params.path?.split(/[\\/]/).pop() ?? "";
+        const pathTargetsFile = /\.[a-zA-Z][a-zA-Z0-9]{0,9}$/.test(lastSeg);
+        const fuzzyQuery = pathTargetsFile ? pattern : query;
+        const fuzzy = picker.grep(fuzzyQuery, {
           mode: "fuzzy",
           smartCase,
           maxMatchesPerFile: Math.min(effectiveLimit, 50),
@@ -732,6 +716,7 @@ export default function fffExtension(pi: ExtensionAPI) {
           beforeContext: 0,
           afterContext: 0,
           classifyDefinitions: true,
+          timeBudgetMs: GREP_TIME_BUDGET_MS,
         });
 
         if (fuzzy.ok && fuzzy.value.items.length > 0) {
@@ -743,14 +728,10 @@ export default function fffExtension(pi: ExtensionAPI) {
       let output = formatGrepOutput(result);
       const notices: string[] = [];
       if (result.regexFallbackError) {
-        notices.push(
-          `Invalid regex: ${result.regexFallbackError}, used literal match`,
-        );
+        notices.push(`Invalid regex: ${result.regexFallbackError}, used literal match`);
       }
       if (result.nextCursor) {
-        notices.push(
-          `Continue with cursor="${storeCursor(result.nextCursor)}"`,
-        );
+        notices.push(`Continue with cursor="${storeCursor(result.nextCursor)}"`);
       }
 
       if (notices.length > 0) output += `\n\n[${notices.join(". ")}]`;
@@ -766,8 +747,7 @@ export default function fffExtension(pi: ExtensionAPI) {
     },
 
     renderCall(args, theme, context) {
-      const text =
-        (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
       const pattern = args?.pattern ?? "";
       const path = args?.path ?? ".";
       let content =
@@ -822,12 +802,12 @@ export default function fffExtension(pi: ExtensionAPI) {
     description: `Fuzzy path search and glob search. Matches against the whole repo-relative path, not just the filename. Frecency-ranked, git-aware. Multi-word = narrower (AND). Default limit ${DEFAULT_FIND_LIMIT}.`,
     promptSnippet: "Find files by path or glob",
     promptGuidelines: [
-      "Matches the WHOLE path, not just the filename — `profile` hits `chrome/browser/profiles/x.cc` too.",
-      "Keep queries to 1-2 terms; extra words narrow.",
-      "Use for paths, not content. Use grep for content.",
-      "For exact path matches use a glob in `path` — e.g. path: '**/profile.h' for exact filename, or path: 'src/**/profile.h' scoped to a subtree. Bare patterns are fuzzy.",
-      "To list everything inside a directory, pass path: 'dir/**' with an empty or wildcard pattern instead of using pattern alone.",
-      "Use exclude: 'test/,*.min.js' to cut noise in large repos.",
+      `${toolNames.find}: matches the WHOLE path, not just the filename — \`profile\` hits \`chrome/browser/profiles/x.cc\` too.`,
+      `${toolNames.find}: keep queries to 1-2 terms; extra words narrow.`,
+      `${toolNames.find}: use for paths, not content. Use ${toolNames.grep} for content.`,
+      `${toolNames.find}: for exact path matches use a glob in \`path\` — e.g. path: '**/profile.h' for exact filename, or path: 'src/**/profile.h' scoped to a subtree. Bare patterns are fuzzy.`,
+      `${toolNames.find}: to list everything inside a directory, pass path: 'dir/**' with an empty or wildcard pattern instead of using pattern alone.`,
+      `${toolNames.find}: use exclude: 'test/,*.min.js' to cut noise in large repos.`,
     ],
     parameters: findSchema,
 
@@ -839,16 +819,11 @@ export default function fffExtension(pi: ExtensionAPI) {
       const aux = resumed
         ? resumed.auxRoot
           ? {
-              finder: (await auxPool.acquire(resumed.auxRoot, { exact: true }))
-                .finder,
+              finder: (await auxPool.acquire(resumed.auxRoot, { exact: true })).finder,
               root: resumed.auxRoot,
             }
           : null
-        : await resolveFinderForPath(
-            params.path,
-            params.pattern,
-            params.exclude,
-          );
+        : await resolveFinderForPath(params.path, params.pattern, params.exclude);
 
       const picker = aux ? aux.finder : await ensureFinder(activeCwd);
       const effectiveLimit = resumed
@@ -880,8 +855,7 @@ export default function fffExtension(pi: ExtensionAPI) {
       // shown so far there's another page to fetch.
       const shownSoFar = pageIndex * effectiveLimit + result.items.length;
       const hasMore =
-        result.items.length >= effectiveLimit &&
-        result.totalMatched > shownSoFar;
+        result.items.length >= effectiveLimit && result.totalMatched > shownSoFar;
 
       const notices: string[] = [];
       if (formatted.weak && formatted.shownCount > 0)
@@ -916,8 +890,7 @@ export default function fffExtension(pi: ExtensionAPI) {
     },
 
     renderCall(args, theme, context) {
-      const text =
-        (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
       const pattern = args?.pattern ?? "";
       const path = args?.path ?? ".";
       let content =
@@ -950,9 +923,7 @@ export default function fffExtension(pi: ExtensionAPI) {
       constraints: Type.Optional(
         Type.String({ description: "File filter, e.g. '*.{ts,tsx} !test/'" }),
       ),
-      context: Type.Optional(
-        Type.Number({ description: "Context lines before+after" }),
-      ),
+      context: Type.Optional(Type.Number({ description: "Context lines before+after" })),
       limit: Type.Optional(
         Type.Number({
           description: `Max matches (default ${DEFAULT_GREP_LIMIT})`,
@@ -968,9 +939,9 @@ export default function fffExtension(pi: ExtensionAPI) {
         "Search file contents for ANY of multiple literal patterns (OR, SIMD Aho-Corasick). Faster than regex alternation.",
       promptSnippet: "Multi-pattern OR content search",
       promptGuidelines: [
-        "Use when searching for several identifiers at once.",
-        "Include all naming-convention variants (snake/camel/Pascal).",
-        "Patterns are literal. Use constraints for file filters.",
+        `${toolNames.multiGrep}: use when searching for several identifiers at once.`,
+        `${toolNames.multiGrep}: include all naming-convention variants (snake/camel/Pascal).`,
+        `${toolNames.multiGrep}: patterns are literal. Use constraints for file filters.`,
       ],
       parameters: multiGrepSchema,
 
@@ -1018,8 +989,7 @@ export default function fffExtension(pi: ExtensionAPI) {
       },
 
       renderCall(args, theme, context) {
-        const text =
-          (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+        const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
         const patterns = args?.patterns ?? [];
         const constraints = args?.constraints;
         let content =
@@ -1041,8 +1011,7 @@ export default function fffExtension(pi: ExtensionAPI) {
   // --- commands ---
 
   pi.registerCommand("fff-mode", {
-    description:
-      "Show or set FFF mode: /fff-mode [tools-and-ui | tools-only | override]",
+    description: "Show or set FFF mode: /fff-mode [tools-and-ui | tools-only | override]",
     handler: async (args, ctx) => {
       const arg = (args || "").trim();
 
@@ -1056,10 +1025,7 @@ export default function fffExtension(pi: ExtensionAPI) {
 
       // Validate and set mode
       if (!VALID_MODES.includes(arg as FffMode)) {
-        ctx.ui.notify(
-          `Usage: /fff-mode [${VALID_MODES.join(" | ")}]`,
-          "warning",
-        );
+        ctx.ui.notify(`Usage: /fff-mode [${VALID_MODES.join(" | ")}]`, "warning");
         return;
       }
 

package/src/query.ts

@@ -10,11 +10,7 @@ export function normalizePathConstraint(
   if (path.isAbsolute(trimmed)) {
     const relative = path.relative(cwd, trimmed).replaceAll(path.sep, "/");
     if (relative === "") return null;
-    if (
-      relative.startsWith("../") ||
-      relative === ".." ||
-      path.isAbsolute(relative)
-    ) {
+    if (relative.startsWith("../") || relative === ".." || path.isAbsolute(relative)) {
       throw new Error(
         `Path constraint must be relative to the workspace: ${pathConstraint}`,
       );