@xynogen/pix-search 0.1.1 → 0.2.2

package/README.md

@@ -1,12 +1,30 @@
 # pix-search
 
-Smarter `@` file search for [Pi Coding Agent](https://github.com/earendil-works/pi).
+`@` file picker overlay for [Pi Coding Agent](https://github.com/earendil-works/pi).
 
-Wraps the built-in autocomplete provider to improve file ranking when you type `@` in the prompt:
+Typing `@` at a token boundary (line start or after whitespace) opens a modal
+file picker with its own query input:
 
-- **Fuzzy scoring** — proper character-order matching with gap penalties and word-boundary bonuses (uses pi-tui's `fuzzyMatch`)
-- **Git recency** — recently modified files (from `git log`) rank higher
-- **Depth penalty** — shallower files win ties
+- **Files and folders** — pick a file to point the model at it, or a folder to
+  scope work to a whole directory. Folders appear with a trailing `/`.
+- **Live preview** — on wide terminals a side pane shows the selection: a file's
+  first lines with syntax highlighting, or a folder's immediate file list.
+- **File-type icons & colors** — results show Nerd Font file/folder icons and
+  type-colored names (respects `PRETTY_ICONS`).
+- **Spaces in the query** — the picker owns keyboard focus, so `@` then `my file`
+  filters on the full phrase with no `@"…"` quoting.
+- **Name-based** — matches file/folder *names and paths*, not file contents.
+- **Fuzzy scoring** — character-order matching with word-boundary bonuses.
+- **Git recency** — recently modified files (from `git log`) rank higher.
+- **Depth penalty** — shallower entries win ties.
+
+Picking a result inserts `<path>…</path>` into the prompt; the model receives
+that span verbatim, and `@xynogen/pix-display` renders it as an `@name` chip
+when installed. Keys: `↑`/`↓` move, `⏎` insert, `Esc` cancel (a cancelled
+pick inserts a literal `@`, so the keystroke is never swallowed).
+
+`@` mid-token (e.g. an email `user@host`) is left as a literal `@` — only a
+boundary `@` opens the picker.
 
 ## Install
 
@@ -14,4 +32,6 @@ Wraps the built-in autocomplete provider to improve file ranking when you type `
 pi install npm:@xynogen/pix-search
 ```
 
-Standalone — **not** bundled by `@xynogen/pix-core`.
+Standalone — **not** bundled by `@xynogen/pix-core`. It wraps whatever editor
+is already installed (via `getEditorComponent`/`setEditorComponent`), so it
+composes with `pix-display` in either load order.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@xynogen/pix-search",
-	"version": "0.1.1",
-	"description": "Pi extension — smarter @ file search with fuzzy + git recency ranking",
+	"version": "0.2.2",
+	"description": "Pi extension — @ file picker overlay with fuzzy + git recency ranking",
 	"type": "module",
 	"main": "src/index.ts",
 	"exports": {
@@ -48,6 +48,7 @@
 		"@earendil-works/pi-tui": "*"
 	},
 	"dependencies": {
-		"@vscode/ripgrep": "^1.18.0"
+		"@vscode/ripgrep": "^1.18.0",
+		"@xynogen/pix-pretty": "^1.21.0"
 	}
 }

package/src/editor.ts

@@ -0,0 +1,51 @@
+/** Add the @ picker to an editor without replacing its paste state or rendering. */
+import type { CustomEditor } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+
+/** Picked paths are marked as `<path>…</path>`; pix-display renders the span as a chip. */
+export function pathToken(path: string): string {
+	return `<path>${path}</path> `;
+}
+
+export type OpenPicker = () => Promise<string | null>;
+
+/** A mention starts at the beginning of a line or after whitespace. */
+export function atStartsMention(before: string): boolean {
+	return before === "" || /\s$/.test(before);
+}
+
+export function attachPicker(
+	editor: CustomEditor,
+	tui: TUI,
+	openPicker: OpenPicker,
+	onError: (message: string) => void,
+): void {
+	const handleInput = editor.handleInput.bind(editor);
+	let inPaste = false;
+	const runPicker = async () => {
+		try {
+			const path = await openPicker();
+			editor.insertTextAtCursor(path ? pathToken(path) : "@");
+		} catch (error) {
+			editor.insertTextAtCursor("@");
+			onError(`File picker failed: ${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	editor.handleInput = (data: string) => {
+		// Bracketed paste can arrive in separate chunks; a pasted @ is not a shortcut.
+		for (const marker of data.matchAll(/\x1b\[(200|201)~/g)) {
+			inPaste = marker[1] === "200";
+		}
+		if (!inPaste && data === "@") {
+			const cursor = editor.getCursor();
+			const line = editor.getLines()[cursor.line] ?? "";
+			if (atStartsMention(line.slice(0, cursor.col))) {
+				void runPicker();
+				return;
+			}
+		}
+		handleInput(data);
+	};
+}

package/src/extension.ts

@@ -1,19 +1,71 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createSearchProvider } from "./provider.ts";
+/**
+ * pix-search — adds input handling that opens a file-picker
+ * overlay when you type `@` at a token boundary. The picker owns its own query
+ * input, so spaces in the query work natively (no `@"…"` quoting). It lists
+ * both files and their containing folders (so you can @-mention a directory),
+ * ranked by fuzzy score + git recency, with a live preview of the selection.
+ */
+
+import { CustomEditor, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { attachPicker } from "./editor.ts";
+import { FilePicker } from "./picker.ts";
+import { withDirectories } from "./rank.ts";
 import { loadRecency, type RecencyMap } from "./recency.ts";
+import { rgFiles } from "./rg.ts";
 
 export default function (pi: ExtensionAPI): void {
 	pi.on("session_start", async (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
 		const cwd = ctx.cwd;
 
-		// Warm recency cache in background — non-blocking
+		// Warm the git-recency cache in the background; picker reads whatever is
+		// ready when it opens (empty until the first git log returns).
 		let recency: RecencyMap = new Map();
-		const recencyReady = loadRecency(cwd).then((map) => {
+		void loadRecency(cwd).then((map) => {
 			recency = map;
 		});
-		// Fire-and-forget; if git isn't available, recency stays empty
-		void recencyReady;
 
-		ctx.ui.addAutocompleteProvider((current) => createSearchProvider(current, cwd, () => recency));
+		// Open the picker overlay and resolve with the chosen path (or null).
+		const openPicker = () =>
+			ctx.ui.custom<string | null>(
+				(tui, theme, _kb, done) => {
+					// List files fresh each open so new/removed files are reflected.
+					const controller = new AbortController();
+					const picker = new FilePicker({
+						files: [],
+						recency,
+						theme: theme as never,
+						cwd,
+						done,
+						onChange: () => tui.requestRender(),
+					});
+					void rgFiles(cwd, controller.signal).then((files) =>
+						picker.setFiles(withDirectories(files)),
+					);
+					return {
+						render: (width: number) => picker.render(width),
+						handleInput: (data: string) => picker.handleInput(data),
+						invalidate: () => picker.invalidate(),
+						dispose: () => controller.abort(),
+					};
+				},
+				{ overlay: true, overlayOptions: { anchor: "center", width: "60%", maxHeight: "60%" } },
+			);
+
+		const previous = ctx.ui.getEditorComponent();
+		ctx.ui.setEditorComponent((tui, theme, kb) => {
+			const editor = previous?.(tui, theme, kb) ?? new CustomEditor(tui, theme, kb);
+			// ponytail: cursor access requires CustomEditor. Keep other editors intact;
+			// add a public cursor adapter if a non-CustomEditor integration is needed.
+			if (editor instanceof CustomEditor) {
+				attachPicker(editor, tui, openPicker, (message) => ctx.ui.notify(message, "error"));
+			} else {
+				ctx.ui.notify(
+					"pix-search: @ picker requires a CustomEditor; existing editor kept.",
+					"warning",
+				);
+			}
+			return editor;
+		});
 	});
 }

package/src/picker.ts

@@ -0,0 +1,245 @@
+/**
+ * File picker overlay — a self-contained modal with its own query input and
+ * result list. Unlike the inline `@` dropdown, this owns keyboard focus, so
+ * spaces in the query are native (no quoting hack) and the host editor's
+ * space-stops-autocomplete behavior is irrelevant.
+ *
+ * The component is a plain pi-tui `Component` (render + handleInput). It is
+ * pure w.r.t. file discovery: it receives the already-listed files and a
+ * recency map, ranks them with `rankFiles`, and reports the chosen path (or
+ * null on cancel) through the `done` callback.
+ */
+
+import { readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { hlBlock } from "@xynogen/pix-pretty/highlight";
+import { dirIcon, fileColor, fileIcon } from "@xynogen/pix-pretty/icons";
+import { lang } from "@xynogen/pix-pretty/lang";
+import { frameLines, joinColumns, modalWidth } from "@xynogen/pix-pretty/modal-frame";
+import type { ThemeLike } from "@xynogen/pix-pretty/types";
+import { rankFiles } from "./rank.ts";
+import type { RecencyMap } from "./recency.ts";
+
+const MAX_VISIBLE = 10;
+/** Show the preview pane only when the modal is at least this wide. */
+const PREVIEW_MIN_WIDTH = 72;
+/** How many lines of the selected file to preview. */
+const PREVIEW_LINES = 14;
+/** Cap the bytes we read for a preview — enough for PREVIEW_LINES of code. */
+const PREVIEW_MAX_BYTES = 8 * 1024;
+
+export interface FilePickerOptions {
+	files: string[];
+	recency: RecencyMap;
+	theme: ThemeLike;
+	/** Root for resolving relative result paths when reading previews. */
+	cwd: string;
+	/** Called with the chosen path, or null on cancel. */
+	done: (path: string | null) => void;
+	/** Ask the host to re-render (e.g. after an async syntax-highlight lands). */
+	onChange?: () => void;
+	/** Seed query (e.g. characters typed after @ before the picker opened). */
+	initialQuery?: string;
+}
+
+export class FilePicker {
+	private query: string;
+	private selected = 0;
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+
+	private files: string[];
+	/** Syntax-highlighted preview lines, keyed by file path. Filled async by
+	 *  hlBlock; a miss shows plain text until the highlight lands. */
+	private hlCache = new Map<string, string[]>();
+
+	constructor(private readonly opts: FilePickerOptions) {
+		this.query = opts.initialQuery ?? "";
+		this.files = opts.files;
+	}
+
+	/** Replace the candidate file list (e.g. once async `rg --files` returns). */
+	setFiles(files: string[]): void {
+		this.files = files;
+		this.invalidate();
+	}
+
+	private results() {
+		return rankFiles(this.files, this.query, this.opts.recency, 50);
+	}
+
+	/** Color a result label: dirs use accent/dim, files use their type hue when
+	 *  selected and dim otherwise (so the selection pops without noise). */
+	private styleName(path: string, label: string, isDir: boolean, isSel: boolean): string {
+		const theme = this.opts.theme;
+		if (isDir) return theme.fg(isSel ? "accent" : "dim", label);
+		return isSel ? fileColor(path, label, theme) : theme.fg("dim", label);
+	}
+
+	/** Preview lines for the selected result: a folder shows its immediate
+	 *  file/dir list (icon-prefixed); a file shows its first lines, syntax-
+	 *  highlighted once hlBlock resolves. Returns [] on any error (unreadable,
+	 *  binary, missing) so the pane just stays empty. */
+	private preview(path: string): string[] {
+		const theme = this.opts.theme;
+		if (path.endsWith("/")) {
+			const children = new Set<string>();
+			for (const f of this.files) {
+				if (!f.startsWith(path)) continue;
+				const rest = f.slice(path.length).split("/");
+				children.add(rest.length > 1 ? `${rest[0]}/` : (rest[0] ?? ""));
+			}
+			return [...children]
+				.filter(Boolean)
+				.sort((a, b) => a.localeCompare(b))
+				.slice(0, PREVIEW_LINES)
+				.map((child) => {
+					const isDir = child.endsWith("/");
+					const icon = isDir ? dirIcon(theme) : fileIcon(child, theme);
+					const name = isDir ? theme.fg("accent", child) : fileColor(child, child, theme);
+					return `${icon}${name}`;
+				});
+		}
+		const cached = this.hlCache.get(path);
+		if (cached) return cached;
+		try {
+			const abs = isAbsolute(path) ? path : join(this.opts.cwd, path);
+			const buf = readFileSync(abs).subarray(0, PREVIEW_MAX_BYTES).toString("utf8");
+			if (buf.includes("\u0000")) return []; // binary
+			const plain = buf.split("\n").slice(0, PREVIEW_LINES);
+			// Kick off async highlight; cache + re-render when it lands.
+			void hlBlock(plain.join("\n"), lang(path), theme).then((hl) => {
+				this.hlCache.set(path, hl);
+				this.invalidate();
+				this.opts.onChange?.();
+			});
+			return plain; // plain until the highlight resolves
+		} catch {
+			return [];
+		}
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape")) {
+			this.opts.done(null);
+			return;
+		}
+		if (matchesKey(data, "enter")) {
+			const hit = this.results()[this.selected];
+			this.opts.done(hit ? hit.path : null);
+			return;
+		}
+		if (matchesKey(data, "up")) {
+			this.selected = Math.max(0, this.selected - 1);
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, "down")) {
+			this.selected = Math.min(this.results().length - 1, this.selected + 1);
+			this.invalidate();
+			return;
+		}
+		if (matchesKey(data, "backspace")) {
+			this.query = this.query.slice(0, -1);
+			this.selected = 0;
+			this.invalidate();
+			return;
+		}
+		// Printable characters (including space) extend the query.
+		if (data.length === 1 && data.charCodeAt(0) >= 32) {
+			this.query += data;
+			this.selected = 0;
+			this.invalidate();
+		}
+	}
+
+	render(width: number): string[] {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+
+		const theme = this.opts.theme;
+		const inner = modalWidth(width) - 4; // frame chrome
+		const results = this.results();
+		if (this.selected >= results.length) this.selected = Math.max(0, results.length - 1);
+
+		// Scroll window around the selection.
+		const start = Math.max(
+			0,
+			Math.min(this.selected - MAX_VISIBLE + 1, results.length - MAX_VISIBLE),
+		);
+		const visible = results.slice(start, start + MAX_VISIBLE);
+
+		// Header: bold title + live result count, then the query line.
+		const count = theme.fg(
+			"muted",
+			`${results.length} ${results.length === 1 ? "match" : "matches"}`,
+		);
+		const title = `${theme.bold(theme.fg("accent", "  Find files & folders"))}  ${count}`;
+		const queryLine = `${theme.fg("accent", "❯")} ${
+			this.query ? theme.fg("text", this.query) : theme.fg("muted", "type to filter…")
+		}`;
+
+		// Two-pane layout when the modal is wide: results on the left, a preview
+		// of the selected entry on the right. Narrow terminals fall back to a
+		// single result column.
+		const showPreview = inner >= PREVIEW_MIN_WIDTH && results.length > 0;
+		const listW = showPreview ? Math.floor(inner * 0.45) : inner;
+		const gap = 2;
+		const previewW = inner - listW - gap;
+
+		const listRows: string[] = [];
+		if (results.length === 0) {
+			listRows.push(theme.fg("muted", "  no matching files"));
+		} else {
+			for (const [i, entry] of visible.entries()) {
+				const isSel = start + i === this.selected;
+				const isDir = entry.path.endsWith("/");
+				const marker = isSel ? theme.fg("accent", "›") : " ";
+				const icon = isDir ? dirIcon(theme) : fileIcon(entry.path, theme);
+				const name = this.styleName(entry.path, entry.label, isDir, isSel);
+				const dir = entry.path.slice(0, entry.path.length - entry.label.length);
+				const dirText = dir ? theme.fg("muted", dir) : "";
+				listRows.push(truncateToWidth(`${marker} ${icon}${name} ${dirText}`, listW));
+			}
+		}
+
+		const rows: string[] = [title, "", queryLine, ""];
+		if (showPreview) {
+			const sel = results[this.selected];
+			const previewRows = sel ? this.preview(sel.path) : [];
+			const head = sel
+				? theme.fg(
+						"muted",
+						truncateToWidth(sel.path.endsWith("/") ? `${sel.path} · contents` : sel.path, previewW),
+					)
+				: "";
+			const previewLines = [
+				head,
+				theme.fg("border", "─".repeat(previewW)),
+				...previewRows.map((l) => truncateToWidth(l, previewW)),
+			];
+			rows.push(
+				...joinColumns(listRows, previewLines, { leftWidth: listW, rightWidth: previewW, gap }),
+			);
+		} else {
+			rows.push(...listRows);
+		}
+
+		const hint = theme.fg("muted", "↑↓ move · ⏎ insert · esc cancel");
+		rows.push("", hint);
+
+		this.cachedLines = frameLines({
+			width: modalWidth(width),
+			lines: rows,
+			color: (s) => theme.fg("accent", s),
+			fg: (s) => theme.fg("text", s),
+		});
+		this.cachedWidth = width;
+		return this.cachedLines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}

package/src/rank.ts

@@ -0,0 +1,70 @@
+/**
+ * Pure file ranking — filename fuzzy score + git recency + depth penalty.
+ * No TUI, no I/O: takes a file list and returns the best matches, so the
+ * scoring is unit-testable independently of the picker UI.
+ */
+
+import { basename } from "node:path";
+import type { RecencyMap } from "./recency.ts";
+import { scoreFilename } from "./rg.ts";
+
+const W_FILENAME = 1.0;
+const W_RECENCY = 30;
+const W_DEPTH = -0.5; // penalty per path depth level
+
+export interface RankedFile {
+	/** Path relative to the search root, with a trailing "/" for directories. */
+	path: string;
+	/** basename (with trailing "/" for dirs) for compact display. */
+	label: string;
+	score: number;
+}
+
+function depthOf(path: string): number {
+	return path.split("/").length - 1;
+}
+
+/**
+ * Rank `files` against `query`. Empty query returns all files ordered by
+ * recency then depth (so the picker shows something useful before typing).
+ * Files with no filename match are dropped once the query is non-empty.
+ */
+export function rankFiles(
+	files: string[],
+	query: string,
+	recency: RecencyMap,
+	limit = 20,
+): RankedFile[] {
+	const q = query.trim();
+	const ranked: RankedFile[] = [];
+	for (const path of files) {
+		const fnScore = scoreFilename(path, q);
+		if (q && fnScore === 0) continue;
+		const isDir = path.endsWith("/");
+		const clean = isDir ? path.slice(0, -1) : path;
+		const score =
+			fnScore * W_FILENAME + (recency.get(path) ?? 0) * W_RECENCY + depthOf(path) * W_DEPTH;
+		ranked.push({ path, label: basename(clean) + (isDir ? "/" : ""), score });
+	}
+	ranked.sort((a, b) => b.score - a.score);
+	return ranked.slice(0, limit);
+}
+
+/**
+ * Expand a flat file list into files + the directories that contain them, so
+ * the picker can offer folders as selectable targets. Directories keep a
+ * trailing "/" (rankFiles already treats that as a dir label). Order is
+ * files-as-given with derived dirs appended; rankFiles re-sorts by score.
+ */
+export function withDirectories(files: string[]): string[] {
+	const dirs = new Set<string>();
+	for (const path of files) {
+		const parts = path.split("/");
+		for (let i = 1; i < parts.length; i++) {
+			dirs.add(`${parts.slice(0, i).join("/")}/`);
+		}
+	}
+	// Drop any dir that already appears verbatim in files (rare) to avoid dupes.
+	const seen = new Set(files);
+	return [...files, ...[...dirs].filter((d) => !seen.has(d))];
+}

package/src/rg.ts

@@ -1,9 +1,8 @@
 /**
  * Ripgrep-based file discovery.
- * - `rgFiles(query)` — filename matches via `rg --files` piped through fuzzy
- * - `rgContent(query)` — files containing query text via `rg -l`
+ * - `rgFiles()` — enumerate files via `rg --files`, scored by filename fuzzy
  *
- * Both respect .gitignore, hidden-file exclusions, and abort signals.
+ * Respects .gitignore, hidden-file exclusions, and abort signals.
  */
 
 import { spawn } from "node:child_process";
@@ -20,13 +19,6 @@ try {
 	/* bundled binary unavailable — fall back to PATH `rg` */
 }
 
-export interface RgEntry {
-	/** Relative path from basePath */
-	path: string;
-	/** Whether this matched by content (true) or filename (false) */
-	contentMatch: boolean;
-}
-
 const TIMEOUT_MS = 3_000;
 
 function spawnRg(args: string[], cwd: string, signal: AbortSignal): Promise<string[]> {
@@ -85,71 +77,6 @@ export async function rgFiles(cwd: string, signal: AbortSignal): Promise<string[
 	return spawnRg(["--files", "--hidden", "--glob", "!.git"], cwd, signal);
 }
 
-/**
- * Search file contents for `query`, return matching file paths.
- * Uses fixed-string search (no regex) for speed + safety.
- */
-export async function rgContent(
-	query: string,
-	cwd: string,
-	signal: AbortSignal,
-): Promise<string[]> {
-	if (!query || query.length < 2) return [];
-	return spawnRg(
-		[
-			"--files-with-matches",
-			"--fixed-strings",
-			"--ignore-case",
-			"--hidden",
-			"--glob",
-			"!.git",
-			"--max-count",
-			"1", // stop after first match per file
-			"--",
-			query,
-		],
-		cwd,
-		signal,
-	);
-}
-
-/**
- * Combined file search: filename fuzzy + content grep.
- * Returns deduplicated entries, filename matches first.
- */
-export async function rgSearch(
-	query: string,
-	cwd: string,
-	signal: AbortSignal,
-): Promise<RgEntry[]> {
-	// Run both in parallel
-	const [allFiles, contentFiles] = await Promise.all([
-		rgFiles(cwd, signal),
-		rgContent(query, cwd, signal),
-	]);
-
-	if (signal.aborted) return [];
-
-	const seen = new Set<string>();
-	const results: RgEntry[] = [];
-
-	// Filename matches (all files, will be fuzzy-scored by caller)
-	for (const path of allFiles) {
-		if (seen.has(path)) continue;
-		seen.add(path);
-		results.push({ path, contentMatch: false });
-	}
-
-	// Content-only matches (files not already in filename results)
-	for (const path of contentFiles) {
-		if (seen.has(path)) continue;
-		seen.add(path);
-		results.push({ path, contentMatch: true });
-	}
-
-	return results;
-}
-
 /**
  * Score a file path against a query for filename relevance.
  * Returns 0 for no match. Higher = better.

package/src/provider.ts

@@ -1,165 +0,0 @@
-/**
- * Autocomplete provider wrapper — intercepts @ suggestions and re-ranks
- * using rg file discovery, fuzzy scoring, and git recency.
- *
- * Non-@ completions (slash commands, path completions) pass through to the
- * built-in provider unchanged.
- */
-
-import { basename } from "node:path";
-import type {
-	AutocompleteItem,
-	AutocompleteProvider,
-	AutocompleteSuggestions,
-} from "@earendil-works/pi-tui";
-import type { RecencyMap } from "./recency.ts";
-import { rgContent, rgFiles, scoreFilename } from "./rg.ts";
-
-const MAX_SUGGESTIONS = 20;
-/** Minimum query length before we also search file contents */
-const CONTENT_SEARCH_MIN = 2;
-
-/** Weight factors for the combined score */
-const W_FILENAME = 1.0;
-const W_RECENCY = 30;
-const W_CONTENT = 25;
-const W_DEPTH = -0.5; // penalty per path depth level
-
-interface ScoredEntry {
-	path: string;
-	filenameScore: number;
-	recencyScore: number;
-	contentMatch: boolean;
-	depth: number;
-}
-
-function depthOf(path: string): number {
-	return path.split("/").length - 1;
-}
-
-function combinedScore(entry: ScoredEntry): number {
-	return (
-		entry.filenameScore * W_FILENAME +
-		entry.recencyScore * W_RECENCY +
-		(entry.contentMatch ? W_CONTENT : 0) +
-		entry.depth * W_DEPTH
-	);
-}
-
-function isAtPrefix(prefix: string): boolean {
-	return prefix.startsWith("@") || prefix.startsWith('@"');
-}
-
-function extractRawQuery(prefix: string): string {
-	let raw = prefix;
-	if (raw.startsWith('@"')) raw = raw.slice(2);
-	else if (raw.startsWith("@")) raw = raw.slice(1);
-	if (raw.endsWith('"')) raw = raw.slice(0, -1);
-	return raw;
-}
-
-function buildValue(path: string, isDir: boolean, quoted: boolean): string {
-	const displayPath = isDir ? `${path}/` : path;
-	const needsQuotes = quoted || path.includes(" ");
-	if (!needsQuotes) return `@${displayPath}`;
-	return `@"${displayPath}"`;
-}
-
-export function createSearchProvider(
-	inner: AutocompleteProvider,
-	cwd: string,
-	getRecency: () => RecencyMap,
-): AutocompleteProvider {
-	return {
-		triggerCharacters: inner.triggerCharacters,
-
-		async getSuggestions(
-			lines,
-			cursorLine,
-			cursorCol,
-			options,
-		): Promise<AutocompleteSuggestions | null> {
-			// Let inner figure out if this is an @ prefix
-			const result = await inner.getSuggestions(lines, cursorLine, cursorCol, options);
-
-			// Not an @ prefix, or inner returned nothing — pass through
-			if (!result || !isAtPrefix(result.prefix)) return result;
-
-			const query = extractRawQuery(result.prefix);
-			const isQuoted = result.prefix.includes('"');
-			const { signal } = options;
-
-			if (signal.aborted) return result;
-
-			// Run rg in parallel: file listing + content search
-			const [allFiles, contentFiles] = await Promise.all([
-				rgFiles(cwd, signal),
-				query.length >= CONTENT_SEARCH_MIN ? rgContent(query, cwd, signal) : Promise.resolve([]),
-			]);
-
-			if (signal.aborted) return result;
-
-			const contentSet = new Set(contentFiles);
-			const recency = getRecency();
-
-			// Score every file
-			const scored: ScoredEntry[] = [];
-			for (const path of allFiles) {
-				const fnScore = scoreFilename(path, query);
-				const isContent = contentSet.has(path);
-				// Skip if neither filename nor content match
-				if (fnScore === 0 && !isContent) continue;
-
-				scored.push({
-					path,
-					filenameScore: fnScore,
-					recencyScore: recency.get(path) ?? 0,
-					contentMatch: isContent,
-					depth: depthOf(path),
-				});
-			}
-
-			// Add content-only matches not in allFiles
-			for (const path of contentFiles) {
-				if (scored.some((e) => e.path === path)) continue;
-				scored.push({
-					path,
-					filenameScore: 0,
-					recencyScore: recency.get(path) ?? 0,
-					contentMatch: true,
-					depth: depthOf(path),
-				});
-			}
-
-			// Sort by combined score descending
-			scored.sort((a, b) => combinedScore(b) - combinedScore(a));
-
-			const items: AutocompleteItem[] = scored.slice(0, MAX_SUGGESTIONS).map((entry) => {
-				const isDir = entry.path.endsWith("/");
-				const cleanPath = isDir ? entry.path.slice(0, -1) : entry.path;
-				const label = basename(cleanPath) + (isDir ? "/" : "");
-				const desc =
-					entry.contentMatch && entry.filenameScore === 0
-						? `${entry.path} (content match)`
-						: entry.path;
-				return {
-					value: buildValue(cleanPath, isDir, isQuoted),
-					label,
-					description: desc,
-				};
-			});
-
-			if (items.length === 0) return result; // fall back to built-in
-
-			return { items, prefix: result.prefix };
-		},
-
-		applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-			return inner.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-		},
-
-		shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
-			return inner.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
-		},
-	};
-}