pi-lens 3.6.7 → 3.7.0

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

@@ -88,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",
@@ -366,7 +375,9 @@ async function installNpmTool(
 			proc.on("error", (err) => reject(err));
 		});
 	} catch (err) {
-		console.error(`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`);
+		console.error(
+			`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`,
+		);
 		debugLog("Full error:", err);
 		return undefined;
 	}
@@ -400,7 +411,9 @@ async function installPipTool(
 			proc.on("error", (err) => reject(err));
 		});
 	} catch (err) {
-		console.error(`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`);
+		console.error(
+			`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`,
+		);
 		debugLog("Full error:", err);
 		return undefined;
 	}
@@ -439,7 +452,9 @@ export async function installTool(toolId: string): Promise<boolean> {
 				return false;
 		}
 	} catch (err) {
-		console.error(`[auto-install] Failed to install ${tool.name}: ${(err as Error).message}`);
+		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>;
 }
 

package/clients/lsp/interactive-install.ts

@@ -14,45 +14,173 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
+/**
+ * Install strategy:
+ * - "npm":    npm install -g <packageName>  (managed by pi-lens, goes into .pi-lens/tools)
+ * - "shell":  run installCommand verbatim in a shell  (gem, dotnet, brew, etc.)
+ * - "manual": can't auto-install — show installCommand and tell the user to run it
+ */
+type InstallStrategy = "npm" | "shell" | "manual";
+
+interface LanguageConfig {
+	toolId: string;
+	toolName: string;
+	/** Shown to user and used as the shell command for "shell" strategy */
+	installCommand: string;
+	/** npm package name — required for "npm" strategy */
+	packageName?: string;
+	installStrategy: InstallStrategy;
+}
+
 // Languages that support interactive auto-install prompt
-const COMMON_LANGUAGES: Record<
-	string,
-	{
-		toolId: string;
-		toolName: string;
-		installCommand: string;
-		packageName: string;
-	}
-> = {
+const COMMON_LANGUAGES: Record<string, LanguageConfig> = {
+	// --- Originally supported ---
 	go: {
 		toolId: "gopls",
 		toolName: "Go Language Server (gopls)",
 		installCommand: "go install golang.org/x/tools/gopls@latest",
-		packageName: "golang.org/x/tools/gopls",
+		installStrategy: "shell",
 	},
 	rust: {
 		toolId: "rust-analyzer",
 		toolName: "Rust Language Server (rust-analyzer)",
 		installCommand: "rustup component add rust-analyzer",
-		packageName: "rust-analyzer",
+		installStrategy: "shell",
 	},
 	yaml: {
 		toolId: "yaml-language-server",
 		toolName: "YAML Language Server",
 		installCommand: "npm install -g yaml-language-server",
 		packageName: "yaml-language-server",
+		installStrategy: "npm",
 	},
 	json: {
 		toolId: "vscode-json-language-server",
 		toolName: "JSON Language Server",
 		installCommand: "npm install -g vscode-langservers-extracted",
 		packageName: "vscode-langservers-extracted",
+		installStrategy: "npm",
 	},
 	bash: {
 		toolId: "bash-language-server",
 		toolName: "Bash Language Server",
 		installCommand: "npm install -g bash-language-server",
 		packageName: "bash-language-server",
+		installStrategy: "npm",
+	},
+	// --- Tier-4: previously silent on ENOENT ---
+	ruby: {
+		toolId: "ruby-lsp",
+		toolName: "Ruby LSP",
+		installCommand: "gem install ruby-lsp",
+		installStrategy: "shell",
+	},
+	php: {
+		toolId: "intelephense",
+		toolName: "PHP Language Server (Intelephense)",
+		installCommand: "npm install -g intelephense",
+		packageName: "intelephense",
+		installStrategy: "npm",
+	},
+	csharp: {
+		toolId: "csharp-ls",
+		toolName: "C# Language Server (csharp-ls)",
+		installCommand: "dotnet tool install -g csharp-ls",
+		installStrategy: "shell",
+	},
+	fsharp: {
+		toolId: "fsautocomplete",
+		toolName: "F# Language Server (FSAutocomplete)",
+		installCommand: "dotnet tool install -g fsautocomplete",
+		installStrategy: "shell",
+	},
+	java: {
+		toolId: "jdtls",
+		toolName: "Java Language Server (Eclipse JDT LS)",
+		installCommand:
+			"brew install jdtls  # or: https://github.com/eclipse-jdtls/eclipse.jdt.ls",
+		installStrategy: "manual",
+	},
+	kotlin: {
+		toolId: "kotlin-language-server",
+		toolName: "Kotlin Language Server",
+		installCommand:
+			"brew install kotlin-language-server  # or: https://github.com/fwcd/kotlin-language-server",
+		installStrategy: "manual",
+	},
+	swift: {
+		toolId: "sourcekit-lsp",
+		toolName: "Swift Language Server (SourceKit-LSP)",
+		installCommand:
+			"xcode-select --install  # bundled with Xcode / Swift toolchain",
+		installStrategy: "manual",
+	},
+	dart: {
+		toolId: "dart",
+		toolName: "Dart Language Server",
+		installCommand: "# Install Dart SDK: https://dart.dev/get-dart",
+		installStrategy: "manual",
+	},
+	lua: {
+		toolId: "lua-language-server",
+		toolName: "Lua Language Server",
+		installCommand: "brew install lua-language-server",
+		installStrategy: "shell",
+	},
+	cpp: {
+		toolId: "clangd",
+		toolName: "C/C++ Language Server (clangd)",
+		installCommand: "brew install llvm  # or: apt install clangd",
+		installStrategy: "manual",
+	},
+	zig: {
+		toolId: "zls",
+		toolName: "Zig Language Server (ZLS)",
+		installCommand: "brew install zls",
+		installStrategy: "shell",
+	},
+	haskell: {
+		toolId: "haskell-language-server-wrapper",
+		toolName: "Haskell Language Server",
+		installCommand: "ghcup install hls",
+		installStrategy: "shell",
+	},
+	elixir: {
+		toolId: "elixir-ls",
+		toolName: "Elixir Language Server (ElixirLS)",
+		installCommand:
+			"# Download from: https://github.com/elixir-lsp/elixir-ls/releases",
+		installStrategy: "manual",
+	},
+	gleam: {
+		toolId: "gleam",
+		toolName: "Gleam Language Server",
+		installCommand: "brew install gleam",
+		installStrategy: "shell",
+	},
+	ocaml: {
+		toolId: "ocamllsp",
+		toolName: "OCaml Language Server (ocamllsp)",
+		installCommand: "opam install ocaml-lsp-server",
+		installStrategy: "shell",
+	},
+	clojure: {
+		toolId: "clojure-lsp",
+		toolName: "Clojure Language Server",
+		installCommand: "brew install clojure-lsp/brew/clojure-lsp",
+		installStrategy: "shell",
+	},
+	terraform: {
+		toolId: "terraform-ls",
+		toolName: "Terraform Language Server",
+		installCommand: "brew install hashicorp/tap/terraform-ls",
+		installStrategy: "shell",
+	},
+	nix: {
+		toolId: "nixd",
+		toolName: "Nix Language Server (nixd)",
+		installCommand: "nix profile install nixpkgs#nixd",
+		installStrategy: "shell",
 	},
 };
 
@@ -160,19 +288,32 @@ function isAutoInstallEnabled(): boolean {
 }
 
 /**
- * Attempt to install a tool
+ * Attempt to install a tool using the configured strategy.
+ *
+ * - "npm":    npm install -g <packageName>
+ * - "shell":  run installCommand verbatim via shell (gem, dotnet, brew, etc.)
+ * - "manual": can't auto-install — print the command and return false
  */
-async function installTool(
-	toolId: string,
-	packageName: string,
-): Promise<boolean> {
+async function installTool(config: LanguageConfig): Promise<boolean> {
+	const { toolId, toolName, installCommand, packageName, installStrategy } =
+		config;
+
+	if (installStrategy === "manual") {
+		console.error(
+			`[pi-lens] ${toolName} must be installed manually:\n   ${installCommand}`,
+		);
+		return false;
+	}
+
 	console.error(`[pi-lens] Installing ${toolId}...`);
 
+	const [cmd, ...args] =
+		installStrategy === "npm" && packageName
+			? ["npm", "install", "-g", packageName]
+			: ["sh", "-c", installCommand];
+
 	return new Promise((resolve) => {
-		const proc = spawn("npm", ["install", "-g", packageName], {
-			stdio: "inherit",
-			shell: true,
-		});
+		const proc = spawn(cmd, args, { stdio: "inherit", shell: false });
 
 		proc.on("close", (code) => {
 			if (code === 0) {
@@ -242,19 +383,24 @@ export async function promptForInstall(
 			`[pi-lens] Auto-install enabled, installing ${config.toolName}...`,
 		);
 		await saveChoice(cwd, config.toolId, "auto");
-		return await installTool(config.toolId, config.packageName);
+		return await installTool(config);
 	}
 
 	// Show interactive prompt
 	console.error(`\n⚠️  ${config.toolName} not found`);
 	console.error(`   Install: ${config.installCommand}`);
+	// For manual-only tools, skip the Y/n prompt — user must install themselves
+	if (config.installStrategy === "manual") {
+		await saveChoice(cwd, config.toolId, "no");
+		return false;
+	}
 	console.error(`\n   Install now? [Y/n] (auto-accepts in 30s)`);
 
 	const answer = await promptUser(30000);
 	await saveChoice(cwd, config.toolId, answer);
 
 	if (answer === "yes") {
-		return await installTool(config.toolId, config.packageName);
+		return await installTool(config);
 	}
 
 	console.error(`[pi-lens] Skipped ${config.toolName} installation`);
@@ -268,6 +414,15 @@ export function getInstallCommand(language: string): string | undefined {
 	return COMMON_LANGUAGES[language]?.installCommand;
 }
 
+/**
+ * Get install strategy for a language (exposed for testing)
+ */
+export function getInstallStrategy(
+	language: string,
+): InstallStrategy | undefined {
+	return COMMON_LANGUAGES[language]?.installStrategy;
+}
+
 /**
  * Check if a language supports interactive install
  */