pi-lens 3.6.6 → 3.7.0

package/clients/dispatch/runners/similarity.ts

@@ -9,6 +9,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as ts from "typescript";
 import { EXCLUDED_DIRS } from "../../file-utils.js";
+import { NativeRustCoreClient } from "../../native-rust-client.js";
 import {
 	buildProjectIndex,
 	findSimilarFunctions,
@@ -23,12 +24,18 @@ import type {
 	RunnerResult,
 } from "../types.js";
 
+// Singleton Rust client — initialised once, reused across runner invocations.
+const rustClient = new NativeRustCoreClient();
+
+/** Feature flag: set to false to force the pure-TypeScript path. */
+const USE_RUST = true;
+
 // ============================================================================
 // Configuration
 // ============================================================================
 
 const CONFIG = {
-	SIMILARITY_THRESHOLD: 0.75, // 75% minimum similarity
+	SIMILARITY_THRESHOLD: 0.9, // 90% minimum similarity — below this false positives dominate
 	MIN_TRANSITIONS: 20, // Skip functions with <20 AST transitions
 	MAX_SUGGESTIONS: 3, // Max 3 suggestions per file
 	USAGE_THRESHOLD: 2, // Only suggest utilities with 2+ uses (placeholder)
@@ -64,6 +71,24 @@ const similarityRunner: RunnerDefinition = {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
+		// ── Rust fast-path ─────────────────────────────────────────────────────
+		// Try Rust for file scanning + similarity detection. If the Rust binary
+		// is available, use it. On any failure, fall through to the pure-TS path.
+		if (USE_RUST && rustClient.isAvailable()) {
+			try {
+				const rustResult = await runWithRust(
+					filePath,
+					projectRoot,
+					CONFIG.SIMILARITY_THRESHOLD,
+					CONFIG.MAX_SUGGESTIONS,
+				);
+				if (rustResult !== null) return rustResult;
+			} catch {
+				// Fall through to TypeScript implementation.
+			}
+		}
+		// ── TypeScript fallback ─────────────────────────────────────────────────
+
 		const index = await loadOrBuildIndex(projectRoot);
 		if (!index || index.entries.size === 0) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -261,6 +286,80 @@ function buildSuggestionMessage(
 	return `Function '${func.name}' has ${similarityPct}% similarity to existing utility '${name}()' in ${location}. Consider reusing the existing utility.`;
 }
 
+// ============================================================================
+// Rust fast-path
+// ============================================================================
+
+/**
+ * Run similarity detection via the Rust binary.
+ *
+ * Flow:
+ * 1. Scan project files with Rust (respects .gitignore, much faster than glob).
+ * 2. Build the Rust index (persisted to .pi-lens/rust-index.json).
+ * 3. Query similarity for the current file.
+ * 4. Convert matches to Diagnostics.
+ *
+ * Returns `null` if the Rust path cannot produce results (no matches is still
+ * a valid result — returned as an empty-diagnostic RunnerResult).
+ */
+async function runWithRust(
+	filePath: string,
+	projectRoot: string,
+	threshold: number,
+	maxSuggestions: number,
+): Promise<RunnerResult | null> {
+	// 1. Scan project files.
+	const scanned = await rustClient.scanProject(projectRoot, [".ts", ".tsx"]);
+	if (scanned.length === 0) return null;
+
+	const relativeFiles = scanned.map((e) =>
+		path.relative(projectRoot, e.path).replace(/\\/g, "/"),
+	);
+
+	// 2. Build index (saves to .pi-lens/rust-index.json).
+	await rustClient.buildIndex(projectRoot, relativeFiles);
+
+	// 3. Find similarities for the current file.
+	const matches = await rustClient.findSimilarities(
+		projectRoot,
+		filePath,
+		threshold,
+	);
+
+	if (matches.length === 0) {
+		return { status: "succeeded", diagnostics: [], semantic: "none" };
+	}
+
+	// 4. Convert to Diagnostics.
+	const diagnostics: Diagnostic[] = matches
+		.slice(0, maxSuggestions)
+		.map((m) => {
+			const similarityPct = Math.round(m.similarity * 100);
+			// source_id format: "path/to/file.ts::funcName@line"
+			const [srcFile, srcFunc] = m.source_id.split("::");
+			const [targetFile, targetFunc] = m.target_id.split("::");
+			const funcName = srcFunc?.split("@")[0] ?? "?";
+			const targetName = targetFunc?.split("@")[0] ?? "?";
+			void srcFile; // file is implicit (it's the current file)
+			return {
+				id: `similarity-rust-${m.source_id}-${m.target_id}`,
+				tool: "similarity",
+				filePath,
+				line: 1, // Rust gives us the function source_id; line resolution is TODO
+				column: 1,
+				message: `Function '${funcName}' has ${similarityPct}% similarity to '${targetName}()' in ${targetFile}. Consider reusing the existing utility.`,
+				severity: "warning" as const,
+				semantic: "warning" as const,
+			};
+		});
+
+	return {
+		status: "succeeded",
+		diagnostics,
+		semantic: diagnostics.length > 0 ? "warning" : "none",
+	};
+}
+
 // ============================================================================
 // Index Management
 // ============================================================================

package/clients/dispatch/runners/type-safety.ts

@@ -51,7 +51,11 @@ const typeSafetyRunner: RunnerDefinition = {
 		return {
 			status: hasErrors ? "failed" : "succeeded",
 			diagnostics,
-			semantic: hasErrors ? "blocking" : "warning",
+			semantic: hasErrors
+				? "blocking"
+				: diagnostics.length > 0
+					? "warning"
+					: "none",
 		};
 	},
 };

package/clients/formatters.ts

@@ -17,10 +17,16 @@ import { safeSpawn } from "./safe-spawn.js";
 
 export interface FormatterInfo {
 	name: string;
-	command: string[]; // Command with $FILE placeholder
+	command: string[]; // Command with $FILE placeholder — used as fallback
 	extensions: string[];
 	/** Detect if this formatter should be used for a project */
 	detect(cwd: string): Promise<boolean>;
+	/**
+	 * Optionally resolve the full command at runtime (venv, vendor/bin, bundle exec).
+	 * Return null to fall back to the static `command` field.
+	 * filePath is already resolved to an absolute path.
+	 */
+	resolveCommand?(filePath: string, cwd: string): Promise<string[] | null>;
 }
 
 export interface FormatterResult {
@@ -82,11 +88,107 @@ async function which(command: string): Promise<string | null> {
 	return result.stdout?.trim().split("\n")[0] ?? null;
 }
 
+// --- Venv / Local Binary Helpers ---
+
+/**
+ * Walk up from cwd looking for a binary in .venv or venv.
+ * Returns the absolute path if found, null otherwise.
+ */
+async function findInVenv(binary: string, cwd: string): Promise<string | null> {
+	const isWin = process.platform === "win32";
+	const candidates = isWin
+		? [
+				`.venv/Scripts/${binary}.exe`,
+				`venv/Scripts/${binary}.exe`,
+				`.venv/Scripts/${binary}`,
+				`venv/Scripts/${binary}`,
+			]
+		: [`.venv/bin/${binary}`, `venv/bin/${binary}`];
+
+	let dir = cwd;
+	const root = path.parse(dir).root;
+	while (dir !== root) {
+		for (const candidate of candidates) {
+			const full = path.join(dir, candidate);
+			if (await fileExists(full)) return full;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+
+/**
+ * Check vendor/bin for PHP Composer-managed tools.
+ * Walks up from cwd to find vendor/bin/<binary>.
+ */
+async function findInVendorBin(
+	binary: string,
+	cwd: string,
+): Promise<string | null> {
+	const isWin = process.platform === "win32";
+	const name = isWin ? `${binary}.bat` : binary;
+	let dir = cwd;
+	const root = path.parse(dir).root;
+	while (dir !== root) {
+		const full = path.join(dir, "vendor", "bin", name);
+		if (await fileExists(full)) return full;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+
+/**
+ * Check node_modules/.bin for locally installed Node tools.
+ * Walks up from cwd to find node_modules/.bin/<binary>.
+ */
+async function findInNodeModules(
+	binary: string,
+	cwd: string,
+): Promise<string | null> {
+	const isWin = process.platform === "win32";
+	let dir = cwd;
+	const root = path.parse(dir).root;
+	while (dir !== root) {
+		const candidates = isWin
+			? [
+					path.join(dir, "node_modules", ".bin", `${binary}.cmd`),
+					path.join(dir, "node_modules", ".bin", binary),
+				]
+			: [path.join(dir, "node_modules", ".bin", binary)];
+		for (const full of candidates) {
+			if (await fileExists(full)) return full;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+
+/**
+ * Returns true if `bundle exec <gem>` should be used:
+ * bundle binary is available AND Gemfile.lock exists in the tree.
+ */
+async function canUseBundleExec(cwd: string): Promise<boolean> {
+	if ((await which("bundle")) === null) return false;
+	const lockfiles = await findUp(["Gemfile.lock"], cwd);
+	return lockfiles.length > 0;
+}
+
 // --- Formatter Definitions ---
 
 export const biomeFormatter: FormatterInfo = {
 	name: "biome",
 	command: ["npx", "@biomejs/biome", "format", "--write", "$FILE"],
+	async resolveCommand(filePath, cwd) {
+		const local = await findInNodeModules("biome", cwd);
+		if (local) return [local, "format", "--write", filePath];
+		return null;
+	},
 	extensions: [
 		".js",
 		".jsx",
@@ -111,10 +213,10 @@ export const biomeFormatter: FormatterInfo = {
 		const found = await findUp(configs, cwd);
 		if (found.length > 0) return true;
 
-		// Check if biome is in package.json devDependencies
-		const pkgPath = path.join(cwd, "package.json");
-		if (await fileExists(pkgPath)) {
-			const pkg = (await readJson(pkgPath)) as {
+		// Check if biome is in the nearest package.json devDependencies
+		const pkgPaths = await findUp(["package.json"], cwd);
+		if (pkgPaths.length > 0) {
+			const pkg = (await readJson(pkgPaths[0])) as {
 				devDependencies?: Record<string, string>;
 			};
 			if (pkg.devDependencies?.["@biomejs/biome"]) return true;
@@ -127,6 +229,11 @@ export const biomeFormatter: FormatterInfo = {
 export const prettierFormatter: FormatterInfo = {
 	name: "prettier",
 	command: ["npx", "prettier", "--write", "$FILE"],
+	async resolveCommand(filePath, cwd) {
+		const local = await findInNodeModules("prettier", cwd);
+		if (local) return [local, "--write", filePath];
+		return null;
+	},
 	extensions: [
 		".js",
 		".jsx",
@@ -168,10 +275,10 @@ export const prettierFormatter: FormatterInfo = {
 		const found = await findUp(configs, cwd);
 		if (found.length > 0) return true;
 
-		// Check package.json
-		const pkgPath = path.join(cwd, "package.json");
-		if (await fileExists(pkgPath)) {
-			const pkg = (await readJson(pkgPath)) as {
+		// Check the nearest package.json for prettier
+		const pkgPaths = await findUp(["package.json"], cwd);
+		if (pkgPaths.length > 0) {
+			const pkg = (await readJson(pkgPaths[0])) as {
 				devDependencies?: Record<string, string>;
 				dependencies?: Record<string, string>;
 				prettier?: unknown;
@@ -191,6 +298,11 @@ export const ruffFormatter: FormatterInfo = {
 	name: "ruff",
 	command: ["ruff", "format", "$FILE"],
 	extensions: [".py", ".pyi"],
+	async resolveCommand(filePath, cwd) {
+		const venv = await findInVenv("ruff", cwd);
+		if (venv) return [venv, "format", filePath];
+		return null;
+	},
 	async detect(cwd: string) {
 		// Check for ruff config
 		const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"];
@@ -226,6 +338,11 @@ export const blackFormatter: FormatterInfo = {
 	name: "black",
 	command: ["black", "$FILE"],
 	extensions: [".py", ".pyi"],
+	async resolveCommand(filePath, cwd) {
+		const venv = await findInVenv("black", cwd);
+		if (venv) return [venv, filePath];
+		return null;
+	},
 	async detect(cwd: string) {
 		// Check for black config in pyproject.toml
 		const configs = ["pyproject.toml"];
@@ -351,6 +468,11 @@ export const rubocopFormatter: FormatterInfo = {
 	name: "rubocop",
 	command: ["rubocop", "-a", "--no-color", "$FILE"],
 	extensions: [".rb", ".rake", ".gemspec", ".ru"],
+	async resolveCommand(filePath, cwd) {
+		if (await canUseBundleExec(cwd))
+			return ["bundle", "exec", "rubocop", "-a", "--no-color", filePath];
+		return null;
+	},
 	async detect(cwd: string) {
 		// Only run if project has explicit RuboCop config
 		const configs = [".rubocop.yml", ".rubocop.yaml"];
@@ -370,6 +492,11 @@ export const standardrbFormatter: FormatterInfo = {
 	name: "standardrb",
 	command: ["standardrb", "--fix", "$FILE"],
 	extensions: [".rb", ".rake"],
+	async resolveCommand(filePath, cwd) {
+		if (await canUseBundleExec(cwd))
+			return ["bundle", "exec", "standardrb", "--fix", filePath];
+		return null;
+	},
 	async detect(cwd: string) {
 		// standardrb is only used if explicitly in Gemfile (no config file — it is the config)
 		const gemfile = path.join(cwd, "Gemfile");
@@ -403,6 +530,80 @@ export const terraformFormatter: FormatterInfo = {
 	},
 };
 
+export const phpCsFixerFormatter: FormatterInfo = {
+	name: "php-cs-fixer",
+	command: ["php-cs-fixer", "fix", "$FILE"],
+	extensions: [".php"],
+	async resolveCommand(filePath, cwd) {
+		const vendor = await findInVendorBin("php-cs-fixer", cwd);
+		if (vendor) return [vendor, "fix", filePath];
+		return null;
+	},
+	async detect(cwd: string) {
+		const vendorBin = await findInVendorBin("php-cs-fixer", cwd);
+		const globalBin = await which("php-cs-fixer");
+		if (!vendorBin && !globalBin) return false;
+		// Only run if project has explicit config
+		const configs = [".php-cs-fixer.php", ".php-cs-fixer.dist.php"];
+		const found = await findUp(configs, cwd);
+		return found.length > 0;
+	},
+};
+
+export const csharpierFormatter: FormatterInfo = {
+	name: "csharpier",
+	command: ["dotnet", "csharpier", "$FILE"],
+	extensions: [".cs"],
+	async detect(_cwd: string) {
+		// Check dotnet is available AND csharpier tool is installed
+		if ((await which("dotnet")) === null) return false;
+		const result = safeSpawn("dotnet", ["csharpier", "--version"], {
+			timeout: 5000,
+		});
+		return !result.error && result.status === 0;
+	},
+};
+
+export const fantomasFormatter: FormatterInfo = {
+	name: "fantomas",
+	command: ["fantomas", "$FILE"],
+	extensions: [".fs", ".fsi", ".fsx"],
+	async detect(_cwd: string) {
+		return (await which("fantomas")) !== null;
+	},
+};
+
+export const swiftformatFormatter: FormatterInfo = {
+	name: "swiftformat",
+	command: ["swiftformat", "$FILE"],
+	extensions: [".swift"],
+	async detect(_cwd: string) {
+		return (await which("swiftformat")) !== null;
+	},
+};
+
+export const styluaFormatter: FormatterInfo = {
+	name: "stylua",
+	command: ["stylua", "$FILE"],
+	extensions: [".lua"],
+	async detect(cwd: string) {
+		if ((await which("stylua")) === null) return false;
+		// Prefer explicit config but also run if binary is present in a Lua project
+		const configs = ["stylua.toml", ".stylua.toml"];
+		const found = await findUp(configs, cwd);
+		return found.length > 0;
+	},
+};
+
+export const ormoluFormatter: FormatterInfo = {
+	name: "ormolu",
+	command: ["ormolu", "--mode", "inplace", "$FILE"],
+	extensions: [".hs", ".lhs"],
+	async detect(_cwd: string) {
+		return (await which("ormolu")) !== null;
+	},
+};
+
 // --- Registry ---
 
 const ALL_FORMATTERS: FormatterInfo[] = [
@@ -421,6 +622,12 @@ const ALL_FORMATTERS: FormatterInfo[] = [
 	clangFormatFormatter,
 	ktlintFormatter,
 	terraformFormatter,
+	phpCsFixerFormatter,
+	csharpierFormatter,
+	fantomasFormatter,
+	swiftformatFormatter,
+	styluaFormatter,
+	ormoluFormatter,
 	rubocopFormatter,
 	standardrbFormatter,
 	gleamFormatter,
@@ -514,19 +721,13 @@ export async function formatFile(
 		const cwd = path.dirname(absolutePath);
 		const contentBefore = await fs.readFile(absolutePath, "utf-8");
 
-		// Replace $FILE placeholder
-		let cmd = formatter.command.map((c) => c.replace("$FILE", absolutePath));
-
-		// OPTIMIZATION: Use local biome binary instead of npx if available
-		if (formatter.name === "biome" && cmd[0] === "npx") {
-			const localBiome = path.join(cwd, "node_modules", ".bin", "biome");
-			const localBiomeWin = path.join(cwd, "node_modules", ".bin", "biome.cmd");
-			if (await fileExists(localBiome)) {
-				cmd = [localBiome, ...cmd.slice(2)]; // Replace "npx" "@biomejs/biome" with local path
-			} else if (await fileExists(localBiomeWin)) {
-				cmd = [localBiomeWin, ...cmd.slice(2)];
-			}
-		}
+		// Resolve command: prefer local (venv/vendor/node_modules) over global
+		const resolved = formatter.resolveCommand
+			? await formatter.resolveCommand(absolutePath, cwd)
+			: null;
+		const cmd =
+			resolved ??
+			formatter.command.map((c) => c.replace("$FILE", absolutePath));
 
 		// Run formatter
 		const result = safeSpawn(cmd[0], cmd.slice(1), { timeout: 15000, cwd });

package/clients/installer/index.ts

@@ -39,6 +39,19 @@ import path from "node:path";
 // Global installation directory for pi-lens tools
 const TOOLS_DIR = path.join(process.cwd(), ".pi-lens", "tools");
 
+// Debug flag - set via PI_LENS_DEBUG=1 or --debug
+const DEBUG =
+	process.env.PI_LENS_DEBUG === "1" || process.argv.includes("--debug");
+
+/**
+ * Log debug messages only when DEBUG is enabled
+ */
+function debugLog(...args: unknown[]): void {
+	if (DEBUG) {
+		console.error("[auto-install:debug]", ...args);
+	}
+}
+
 // --- Tool Definitions ---
 
 interface ToolDefinition {
@@ -75,6 +88,15 @@ const TOOLS: ToolDefinition[] = [
 		binaryName: "pyright",
 	},
 	// Linting/formatting tools
+	{
+		id: "prettier",
+		name: "Prettier",
+		checkCommand: "prettier",
+		checkArgs: ["--version"],
+		installStrategy: "npm",
+		packageName: "prettier",
+		binaryName: "prettier",
+	},
 	{
 		id: "ruff",
 		name: "Ruff",
@@ -237,22 +259,18 @@ async function verifyToolBinary(binPath: string): Promise<boolean> {
 
 		proc.on("exit", (code) => {
 			if (code === 0) {
-				console.error(
-					`[auto-install] Verified: ${binPath} (version: ${stdout.trim()})`,
-				);
+				debugLog(`Verified: ${binPath} (version: ${stdout.trim()})`);
 				resolve(true);
 			} else {
-				console.error(
-					`[auto-install] Verification failed for ${binPath}: exit code ${code}, stderr: ${stderr}`,
-				);
+				console.error(`[auto-install] Verification failed for ${binPath}`);
+				debugLog("Exit code:", code, "stderr:", stderr);
 				resolve(false);
 			}
 		});
 
 		proc.on("error", (err) => {
-			console.error(
-				`[auto-install] Verification failed for ${binPath}: ${err.message}`,
-			);
+			console.error(`[auto-install] Verification failed for ${binPath}`);
+			debugLog("Error:", err.message);
 			resolve(false);
 		});
 	});
@@ -322,11 +340,11 @@ async function installNpmTool(
 					}
 
 					// NEW: Verify the binary actually works before returning
-					console.error(`[auto-install] Verifying ${binaryName}...`);
+					debugLog(`Verifying ${binaryName}...`);
 					const isValid = await verifyToolBinary(binPath);
 					if (!isValid) {
 						console.error(
-							`[auto-install] ${packageName} installed but verification failed. The binary may be corrupted.`,
+							`[auto-install] ${packageName} installed but verification failed (binary may be corrupted)`,
 						);
 						// Clean up the broken installation
 						try {
@@ -358,9 +376,9 @@ async function installNpmTool(
 		});
 	} catch (err) {
 		console.error(
-			`[auto-install] Failed to install npm tool ${packageName}:`,
-			err,
+			`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`,
 		);
+		debugLog("Full error:", err);
 		return undefined;
 	}
 }
@@ -394,9 +412,9 @@ async function installPipTool(
 		});
 	} catch (err) {
 		console.error(
-			`[auto-install] Failed to install pip tool ${packageName}:`,
-			err,
+			`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`,
 		);
+		debugLog("Full error:", err);
 		return undefined;
 	}
 }
@@ -434,7 +452,10 @@ export async function installTool(toolId: string): Promise<boolean> {
 				return false;
 		}
 	} catch (err) {
-		console.error(`[auto-install] Failed to install ${tool.name}:`, err);
+		console.error(
+			`[auto-install] Failed to install ${tool.name}: ${(err as Error).message}`,
+		);
+		debugLog("Full error:", err);
 		return false;
 	}
 }

package/clients/latency-logger.ts

@@ -13,7 +13,10 @@ try {
 
 export interface LatencyEntry {
 	type: "runner" | "tool_result" | "phase";
+	/** ISO timestamp when this entry was written (= finish time for runners) */
 	ts?: string;
+	/** ISO timestamp when the runner/phase started — diff with ts = durationMs */
+	startedAt?: string;
 	toolName?: string;
 	filePath: string;
 	fullPath?: string;
@@ -25,6 +28,12 @@ export interface LatencyEntry {
 	status?: string;
 	diagnosticCount?: number;
 	semantic?: string;
+	/** For dispatch_complete: actual wall-clock time (groups run in parallel) */
+	wallClockMs?: number;
+	/** For dispatch_complete: sum of all individual runner durationMs */
+	sumMs?: number;
+	/** wallClockMs - sumMs ≥ 0 means parallelism saved this many ms */
+	parallelGainMs?: number;
 	metadata?: Record<string, unknown>;
 }