@xynogen/pix-search 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 xynogen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# pix-search
+
+Smarter `@` file search 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:
+
+- **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
+
+## Install
+
+```bash
+pi install npm:@xynogen/pix-search
+```
+
+Standalone — **not** bundled by `@xynogen/pix-core`.

package/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "@xynogen/pix-search",
+	"version": "0.1.1",
+	"description": "Pi extension — smarter @ file search with fuzzy + git recency ranking",
+	"type": "module",
+	"main": "src/index.ts",
+	"exports": {
+		".": "./src/index.ts",
+		"./extension": "./src/extension.ts"
+	},
+	"scripts": {
+		"test": "bun test"
+	},
+	"files": [
+		"src",
+		"!src/**/*.test.*",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"src/extension.ts"
+		]
+	},
+	"keywords": [
+		"pi",
+		"pi-package",
+		"pi-extension",
+		"search",
+		"autocomplete"
+	],
+	"author": "xynogen",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/xynogen/pix-mono.git",
+		"directory": "packages/pix-search"
+	},
+	"homepage": "https://github.com/xynogen/pix-mono/tree/main/packages/pix-search#readme",
+	"bugs": {
+		"url": "https://github.com/xynogen/pix-mono/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	},
+	"dependencies": {
+		"@vscode/ripgrep": "^1.18.0"
+	}
+}

package/src/extension.ts

@@ -0,0 +1,19 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createSearchProvider } from "./provider.ts";
+import { loadRecency, type RecencyMap } from "./recency.ts";
+
+export default function (pi: ExtensionAPI): void {
+	pi.on("session_start", async (_event, ctx) => {
+		const cwd = ctx.cwd;
+
+		// Warm recency cache in background — non-blocking
+		let recency: RecencyMap = new Map();
+		const recencyReady = 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));
+	});
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./extension.ts";

package/src/provider.ts

@@ -0,0 +1,165 @@
+/**
+ * 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;
+		},
+	};
+}

package/src/recency.ts

@@ -0,0 +1,59 @@
+/**
+ * Git recency cache — maps relative file paths to a recency score (0–1).
+ * Uses `git log --name-only` to find recently touched files.
+ * Cached per session, refreshed on demand.
+ */
+
+import { execFile } from "node:child_process";
+
+const MAX_COMMITS = 200;
+const DECAY = 0.97; // exponential decay per commit position
+
+export type RecencyMap = Map<string, number>;
+
+export function buildRecencyScores(gitOutput: string): RecencyMap {
+	const scores: RecencyMap = new Map();
+	// git log --name-only output: commit header, blank, files, blank, repeat
+	const files = gitOutput
+		.split("\n")
+		.map((l) => l.trim())
+		.filter((l) => l.length > 0 && !l.startsWith("commit "));
+
+	let position = 0;
+	for (const file of files) {
+		if (scores.has(file)) continue; // first occurrence = most recent
+		scores.set(file, DECAY ** position);
+		position++;
+	}
+	return scores;
+}
+
+export async function loadRecency(cwd: string, signal?: AbortSignal): Promise<RecencyMap> {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve(new Map());
+			return;
+		}
+
+		const child = execFile(
+			"git",
+			["log", "--name-only", "--pretty=format:", `-n${MAX_COMMITS}`, "--diff-filter=ACMR"],
+			{ cwd, maxBuffer: 2 * 1024 * 1024, signal },
+			(err, stdout) => {
+				if (err || !stdout) {
+					resolve(new Map());
+					return;
+				}
+				resolve(buildRecencyScores(stdout));
+			},
+		);
+
+		signal?.addEventListener(
+			"abort",
+			() => {
+				child.kill("SIGKILL");
+			},
+			{ once: true },
+		);
+	});
+}

package/src/rg.ts

@@ -0,0 +1,189 @@
+/**
+ * Ripgrep-based file discovery.
+ * - `rgFiles(query)` — filename matches via `rg --files` piped through fuzzy
+ * - `rgContent(query)` — files containing query text via `rg -l`
+ *
+ * Both respect .gitignore, hidden-file exclusions, and abort signals.
+ */
+
+import { spawn } from "node:child_process";
+import { basename } from "node:path";
+
+// Bundled ripgrep: @vscode/ripgrep pulls a prebuilt rg per-platform on install
+// and exposes its absolute path, so users no longer need rg on PATH. Fall back
+// to a bare "rg" (PATH lookup) if the postinstall binary download was skipped
+// (e.g. npm_config_ignore_scripts).
+let RG_BIN = "rg";
+try {
+	RG_BIN = (require("@vscode/ripgrep") as { rgPath: string }).rgPath;
+} catch {
+	/* 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[]> {
+	return new Promise((resolve) => {
+		if (signal.aborted) {
+			resolve([]);
+			return;
+		}
+
+		const child = spawn(RG_BIN, args, {
+			cwd,
+			stdio: ["ignore", "pipe", "ignore"],
+			// ponytail: no env filtering — inherits .gitignore respect from rg defaults
+		});
+
+		let stdout = "";
+		let resolved = false;
+		const timer = setTimeout(() => {
+			if (!resolved) child.kill("SIGKILL");
+		}, TIMEOUT_MS);
+
+		const finish = (lines: string[]) => {
+			if (resolved) return;
+			resolved = true;
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			resolve(lines);
+		};
+
+		const onAbort = () => {
+			if (child.exitCode === null) child.kill("SIGKILL");
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+
+		child.stdout.setEncoding("utf-8");
+		child.stdout.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+		child.on("error", () => finish([]));
+		child.on("close", () => {
+			const lines = stdout
+				.trim()
+				.split("\n")
+				.filter(Boolean)
+				.map((l) => l.replace(/\\/g, "/"));
+			finish(lines);
+		});
+	});
+}
+
+/**
+ * List all files via `rg --files`, return raw paths.
+ * Fast — just enumerates, rg does .gitignore filtering.
+ */
+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.
+ */
+export function scoreFilename(filePath: string, query: string): number {
+	if (!query) return 1;
+
+	const fileName = basename(filePath);
+	const lowerFile = fileName.toLowerCase();
+	const lowerPath = filePath.toLowerCase();
+	const lowerQuery = query.toLowerCase();
+
+	// Exact filename
+	if (lowerFile === lowerQuery) return 100;
+	// Filename starts with query
+	if (lowerFile.startsWith(lowerQuery)) return 80;
+	// Filename contains query
+	if (lowerFile.includes(lowerQuery)) return 60;
+	// Full path contains query
+	if (lowerPath.includes(lowerQuery)) return 30;
+
+	// Fuzzy: all query chars appear in order in filename
+	let qi = 0;
+	for (let i = 0; i < lowerFile.length && qi < lowerQuery.length; i++) {
+		if (lowerFile[i] === lowerQuery[qi]) qi++;
+	}
+	if (qi === lowerQuery.length) return 20;
+
+	// Fuzzy on full path
+	qi = 0;
+	for (let i = 0; i < lowerPath.length && qi < lowerQuery.length; i++) {
+		if (lowerPath[i] === lowerQuery[qi]) qi++;
+	}
+	if (qi === lowerQuery.length) return 10;
+
+	return 0;
+}