fix: file @ autocomplete performance using fd

- Replace slow synchronous directory walking with fd for fuzzy file search
- Auto-download fd to ~/.pi/agent/tools/ if not found in PATH
- Performance improved from ~900ms to ~10ms per keystroke on large repos
- Remove minimatch dependency from tui package
- Graceful degradation if fd unavailable (empty results)

Fixes #69

packages/coding-agent/src/tools-manager.ts

@@ -0,0 +1,188 @@
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+import { chmodSync, createWriteStream, existsSync, mkdirSync, renameSync, rmSync } from "fs";
+import { arch, homedir, platform } from "os";
+import { join } from "path";
+import { Readable } from "stream";
+import { finished } from "stream/promises";
+
+const TOOLS_DIR = join(homedir(), ".pi", "agent", "tools");
+
+interface ToolConfig {
+	name: string;
+	repo: string; // GitHub repo (e.g., "sharkdp/fd")
+	binaryName: string; // Name of the binary inside the archive
+	getAssetName: (version: string, plat: string, architecture: string) => string | null;
+}
+
+const TOOLS: Record<string, ToolConfig> = {
+	fd: {
+		name: "fd",
+		repo: "sharkdp/fd",
+		binaryName: "fd",
+		getAssetName: (version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `fd-v${version}-${archStr}-apple-darwin.tar.gz`;
+			} else if (plat === "linux") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `fd-v${version}-${archStr}-unknown-linux-gnu.tar.gz`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `fd-v${version}-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+};
+
+// Check if a command exists in PATH by trying to run it
+function commandExists(cmd: string): boolean {
+	try {
+		spawnSync(cmd, ["--version"], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+// Get the path to a tool (system-wide or in our tools dir)
+export function getToolPath(tool: "fd"): string | null {
+	const config = TOOLS[tool];
+	if (!config) return null;
+
+	// Check our tools directory first
+	const localPath = join(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+	if (existsSync(localPath)) {
+		return localPath;
+	}
+
+	// Check system PATH - if found, just return the command name (it's in PATH)
+	if (commandExists(config.binaryName)) {
+		return config.binaryName;
+	}
+
+	return null;
+}
+
+// Fetch latest release version from GitHub
+async function getLatestVersion(repo: string): Promise<string> {
+	const response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+		headers: { "User-Agent": "pi-coding-agent" },
+	});
+
+	if (!response.ok) {
+		throw new Error(`GitHub API error: ${response.status}`);
+	}
+
+	const data = await response.json();
+	return data.tag_name.replace(/^v/, "");
+}
+
+// Download a file from URL
+async function downloadFile(url: string, dest: string): Promise<void> {
+	const response = await fetch(url);
+
+	if (!response.ok) {
+		throw new Error(`Failed to download: ${response.status}`);
+	}
+
+	if (!response.body) {
+		throw new Error("No response body");
+	}
+
+	const fileStream = createWriteStream(dest);
+	await finished(Readable.fromWeb(response.body as any).pipe(fileStream));
+}
+
+// Download and install a tool
+async function downloadTool(tool: "fd"): Promise<string> {
+	const config = TOOLS[tool];
+	if (!config) throw new Error(`Unknown tool: ${tool}`);
+
+	const plat = platform();
+	const architecture = arch();
+
+	// Get latest version
+	const version = await getLatestVersion(config.repo);
+
+	// Get asset name for this platform
+	const assetName = config.getAssetName(version, plat, architecture);
+	if (!assetName) {
+		throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+	}
+
+	// Create tools directory
+	mkdirSync(TOOLS_DIR, { recursive: true });
+
+	const downloadUrl = `https://github.com/${config.repo}/releases/download/v${version}/${assetName}`;
+	const archivePath = join(TOOLS_DIR, assetName);
+	const binaryExt = plat === "win32" ? ".exe" : "";
+	const binaryPath = join(TOOLS_DIR, config.binaryName + binaryExt);
+
+	// Download
+	await downloadFile(downloadUrl, archivePath);
+
+	// Extract
+	const extractDir = join(TOOLS_DIR, "extract_tmp");
+	mkdirSync(extractDir, { recursive: true });
+
+	try {
+		if (assetName.endsWith(".tar.gz")) {
+			spawnSync("tar", ["xzf", archivePath, "-C", extractDir], { stdio: "pipe" });
+		} else if (assetName.endsWith(".zip")) {
+			spawnSync("unzip", ["-o", archivePath, "-d", extractDir], { stdio: "pipe" });
+		}
+
+		// Find the binary in extracted files
+		const extractedDir = join(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ""));
+		const extractedBinary = join(extractedDir, config.binaryName + binaryExt);
+
+		if (existsSync(extractedBinary)) {
+			renameSync(extractedBinary, binaryPath);
+		} else {
+			throw new Error(`Binary not found in archive: ${extractedBinary}`);
+		}
+
+		// Make executable (Unix only)
+		if (plat !== "win32") {
+			chmodSync(binaryPath, 0o755);
+		}
+	} finally {
+		// Cleanup
+		rmSync(archivePath, { force: true });
+		rmSync(extractDir, { recursive: true, force: true });
+	}
+
+	return binaryPath;
+}
+
+// Ensure a tool is available, downloading if necessary
+// Returns the path to the tool, or null if unavailable
+export async function ensureTool(tool: "fd", silent: boolean = false): Promise<string | null> {
+	const existingPath = getToolPath(tool);
+	if (existingPath) {
+		return existingPath;
+	}
+
+	const config = TOOLS[tool];
+	if (!config) return null;
+
+	// Tool not found - download it
+	if (!silent) {
+		console.log(chalk.dim(`${config.name} not found. Downloading...`));
+	}
+
+	try {
+		const path = await downloadTool(tool);
+		if (!silent) {
+			console.log(chalk.dim(`${config.name} installed to ${path}`));
+		}
+		return path;
+	} catch (e) {
+		if (!silent) {
+			console.log(chalk.yellow(`Failed to download ${config.name}: ${e instanceof Error ? e.message : e}`));
+		}
+		return null;
+	}
+}