pi-lens 3.8.21 → 3.8.23

package/clients/lsp/index.ts

@@ -19,6 +19,7 @@ import type { LSPServerInfo } from "./server.js";
 import { normalizeMapKey, uriToPath } from "../path-utils.js";
 import { detectFileKind } from "../file-kinds.js";
 import { detectProjectLanguageProfile } from "../language-profile.js";
+import { logLatency } from "../latency-logger.js";
 
 // --- Types ---
 
@@ -53,6 +54,9 @@ export interface SpawnedServer {
 export class LSPService {
 	private state: LSPState;
 	private languagePolicyCache = new Map<string, { allowInstall: boolean; expiresAt: number }>();
+	private workspaceProbeLogged = new Set<string>();
+	private warmStartLogged = new Set<string>();
+	private emitConsoleLspErrors = process.env.PI_LENS_CONSOLE_LSP === "1";
 
 	constructor() {
 		this.state = {
@@ -73,61 +77,113 @@ export class LSPService {
 
 		// Try each matching server
 		for (const server of servers) {
-			const root = await server.root(filePath);
-			if (!root) continue;
-			const allowInstall = this.shouldAllowInstall(filePath, root);
-
-			const normalizedRoot = normalizeMapKey(root);
-			const key = `${server.id}:${normalizedRoot}`;
-
-			// Check cache first (fast path)
-			const existing = this.state.clients.get(key);
-			if (existing) {
-				if (!existing.isAlive()) {
-					try {
-						await existing.shutdown();
-					} catch {
-						/* ignore dead client shutdown errors */
-					}
-					this.state.clients.delete(key);
-					this.state.broken.delete(key);
-				} else {
-				return { client: existing, info: server };
-				}
+			const spawned = await this.ensureClientForServer(filePath, server);
+			if (spawned) {
+				logLatency({
+					type: "phase",
+					phase: "lsp_client_selected",
+					filePath,
+					durationMs: 0,
+					metadata: {
+						serverId: server.id,
+						candidateCount: servers.length,
+					},
+				});
+				return spawned;
 			}
+		}
 
-			// Check if broken
-			const brokenUntil = this.state.broken.get(key);
-			if (typeof brokenUntil === "number" && brokenUntil > Date.now()) {
-				continue;
-			}
-			if (typeof brokenUntil === "number" && brokenUntil <= Date.now()) {
-				this.state.broken.delete(key);
-			}
+		logLatency({
+			type: "phase",
+			phase: "lsp_client_unavailable",
+			filePath,
+			durationMs: 0,
+			metadata: {
+				candidateCount: servers.length,
+				servers: servers.map((server) => server.id),
+			},
+		});
 
-			// Check if there's already an in-flight spawn for this key
-			const inFlight = this.state.inFlight.get(key);
-			if (inFlight) {
-				// Wait for the existing spawn to complete
-				const result = await inFlight;
-				if (result) return result;
-				continue; // This server failed, try next
-			}
+		return undefined;
+	}
 
-			// Create the spawn promise and store it
-			const spawnPromise = this.spawnClient(server, root, key, filePath, allowInstall);
-			this.state.inFlight.set(key, spawnPromise);
+	/**
+	 * Get or create ALL LSP clients that can serve a file.
+	 * Used for diagnostics aggregation across complementary servers.
+	 */
+	async getClientsForFile(filePath: string): Promise<SpawnedServer[]> {
+		const servers = getServersForFileWithConfig(filePath);
+		if (servers.length === 0) return [];
 
-			try {
-				const result = await spawnPromise;
-				if (result) return result;
-			} finally {
-				// Clean up in-flight tracking
-				this.state.inFlight.delete(key);
+		const spawned = await Promise.all(
+			servers.map((server) => this.ensureClientForServer(filePath, server)),
+		);
+		return spawned.filter((entry): entry is SpawnedServer => Boolean(entry));
+	}
+
+	private async ensureClientForServer(
+		filePath: string,
+		server: LSPServerInfo,
+	): Promise<SpawnedServer | undefined> {
+		const root = await server.root(filePath);
+		if (!root) return undefined;
+		const allowInstall = this.shouldAllowInstall(filePath, root);
+
+		const normalizedRoot = normalizeMapKey(root);
+		const key = `${server.id}:${normalizedRoot}`;
+
+		const existing = this.state.clients.get(key);
+		if (existing) {
+			if (!existing.isAlive()) {
+				try {
+					await existing.shutdown();
+				} catch {
+					/* ignore dead client shutdown errors */
+				}
+				this.state.clients.delete(key);
+				this.state.broken.delete(key);
+			} else {
+				if (!this.warmStartLogged.has(key)) {
+					logSessionStart(
+						`lsp warm-start ${server.id}: reused root=${root} file=${filePath}`,
+					);
+					this.warmStartLogged.add(key);
+				}
+				return { client: existing, info: server };
 			}
 		}
 
-		return undefined;
+		const brokenUntil = this.state.broken.get(key);
+		if (typeof brokenUntil === "number" && brokenUntil > Date.now()) {
+			logLatency({
+				type: "phase",
+				phase: "lsp_client_skipped_broken",
+				filePath,
+				durationMs: 0,
+				metadata: {
+					serverId: server.id,
+					retryInMs: Math.max(0, brokenUntil - Date.now()),
+				},
+			});
+			return undefined;
+		}
+		if (typeof brokenUntil === "number" && brokenUntil <= Date.now()) {
+			this.state.broken.delete(key);
+		}
+
+		const inFlight = this.state.inFlight.get(key);
+		if (inFlight) {
+			return inFlight;
+		}
+
+		const spawnPromise = this.spawnClient(server, root, key, filePath, allowInstall);
+		this.state.inFlight.set(key, spawnPromise);
+
+		try {
+			return await spawnPromise;
+		} finally {
+			this.state.inFlight.delete(key);
+		}
 	}
 
 	private shouldAllowInstall(filePath: string, root: string): boolean {
@@ -192,31 +248,47 @@ export class LSPService {
 				root,
 				initialization: spawned.initialization,
 			});
+			const wsDiag =
+				typeof client.getWorkspaceDiagnosticsSupport === "function"
+					? client.getWorkspaceDiagnosticsSupport()
+					: {
+						advertised: false,
+						mode: "push-only" as const,
+						diagnosticProviderKind: "unavailable",
+					};
 
 			this.state.clients.set(key, client);
 			logSessionStart(
 				`lsp spawn ${server.id}: success source=${spawned.source ?? server.installPolicy ?? "unknown"} (${Date.now() - startedAt}ms)`,
 			);
+			if (!this.workspaceProbeLogged.has(key)) {
+				logSessionStart(
+					`lsp workspace-diag probe ${server.id}: advertised=${wsDiag.advertised} mode=${wsDiag.mode} provider=${wsDiag.diagnosticProviderKind}`,
+				);
+				this.workspaceProbeLogged.add(key);
+			}
 			return { client, info: server };
 		} catch (err) {
 			logSessionStart(
 				`lsp spawn ${server.id}: failed (${Date.now() - startedAt}ms) error=${err instanceof Error ? err.message : String(err)}`,
 			);
 			const errorMsg = err instanceof Error ? err.message : String(err);
-			if (errorMsg.includes("Timeout")) {
-				console.error(
-					`[lsp] ${server.id} timed out during initialization (${errorMsg}). The server may be downloading or the project is large. Skipping.`,
-				);
-			} else if (errorMsg.includes("stream was destroyed")) {
-				console.error(
-					`[lsp] ${server.id} stream was destroyed. The server binary may be missing or crashed immediately. Try reinstalling: npm install -g ${server.id}-language-server`,
-				);
-			} else if (errorMsg.includes("exited immediately")) {
-				console.error(
-					`[lsp] ${server.id} ${errorMsg}. Try reinstalling: npm install -g ${server.id}-language-server`,
-				);
-			} else {
-				console.error(`[lsp] Failed to spawn ${server.id}:`, err);
+			if (this.emitConsoleLspErrors) {
+				if (errorMsg.includes("Timeout")) {
+					console.error(
+						`[lsp] ${server.id} timed out during initialization (${errorMsg}). The server may be downloading or the project is large. Skipping.`,
+					);
+				} else if (errorMsg.includes("stream was destroyed")) {
+					console.error(
+						`[lsp] ${server.id} stream was destroyed. The server binary may be missing or crashed immediately. Try reinstalling: npm install -g ${server.id}-language-server`,
+					);
+				} else if (errorMsg.includes("exited immediately")) {
+					console.error(
+						`[lsp] ${server.id} ${errorMsg}. Try reinstalling: npm install -g ${server.id}-language-server`,
+					);
+				} else {
+					console.error(`[lsp] Failed to spawn ${server.id}:`, err);
+				}
 			}
 			this.state.broken.set(key, Date.now() + BROKEN_RETRY_COOLDOWN_MS);
 			return undefined;
@@ -244,17 +316,155 @@ export class LSPService {
 		await spawned.client.notify.change(filePath, content);
 	}
 
+	/**
+	 * Touch a file like OpenCode's LSP flow: ensure document is open/synced,
+	 * and optionally wait briefly for diagnostics warm-up.
+	 */
+	async touchFile(
+		filePath: string,
+		content: string,
+		waitForDiagnostics = false,
+		source = "unknown",
+		useAllClients = false,
+	): Promise<void> {
+		const startedAt = Date.now();
+		const normalizedPath = normalizeMapKey(filePath);
+		const spawned = useAllClients
+			? await this.getClientsForFile(filePath)
+			: await this.getClientForFile(filePath).then((entry) =>
+					entry ? [entry] : [],
+				);
+		if (spawned.length === 0) {
+			logLatency({
+				type: "phase",
+				phase: "lsp_touch_file",
+				filePath: normalizedPath,
+				durationMs: Date.now() - startedAt,
+			metadata: {
+				serverCountReady: 0,
+				clientScope: useAllClients ? "all" : "primary",
+				failureKind: "no_clients",
+			},
+			});
+			return;
+		}
+
+		const languageId = getLanguageId(filePath) ?? "plaintext";
+		await Promise.all(
+			spawned.map((entry) => entry.client.notify.open(filePath, content, languageId)),
+		);
+
+		if (waitForDiagnostics) {
+			await Promise.all(
+				spawned.map((entry) =>
+					entry.client.waitForDiagnostics(filePath, 1200).catch(() => undefined),
+				),
+			);
+		}
+
+		logLatency({
+			type: "phase",
+			phase: "lsp_touch_file",
+			filePath: normalizedPath,
+			durationMs: Date.now() - startedAt,
+			metadata: {
+				serverCountReady: spawned.length,
+				clientScope: useAllClients ? "all" : "primary",
+				waitForDiagnostics,
+				source,
+				failureKind: "success",
+			},
+		});
+	}
+
 	/**
 	 * Get diagnostics for a file
 	 */
 	async getDiagnostics(
 		filePath: string,
 	): Promise<import("./client.js").LSPDiagnostic[]> {
-		const spawned = await this.getClientForFile(filePath);
-		if (!spawned) return [];
+		const startedAt = Date.now();
+		const normalizedPath = normalizeMapKey(filePath);
+		const spawned = await this.getClientsForFile(filePath);
+		if (spawned.length === 0) {
+			logLatency({
+				type: "phase",
+				phase: "lsp_diagnostics_aggregate",
+				filePath: normalizedPath,
+				durationMs: Date.now() - startedAt,
+				metadata: {
+					serverCountAttempted: 0,
+					serverCountReady: 0,
+					mergedCount: 0,
+					dedupDroppedCount: 0,
+					failureKind: "no_clients",
+					health: "no_clients",
+					servers: [],
+				},
+			});
+			return [];
+		}
+
+		const perServer = await Promise.all(
+			spawned.map(async (entry) => {
+				const waitStart = Date.now();
+				await entry.client.waitForDiagnostics(filePath, 3000);
+				const diagnostics = entry.client.getDiagnostics(filePath);
+				return {
+					serverId: entry.info.id,
+					waitMs: Date.now() - waitStart,
+					diagnosticCount: diagnostics.length,
+					diagnostics,
+				};
+			}),
+		);
+
+		const merged: import("./client.js").LSPDiagnostic[] = [];
+		const seen = new Set<string>();
+		for (const entry of perServer) {
+			for (const diagnostic of entry.diagnostics) {
+				const key = [
+					diagnostic.range.start.line,
+					diagnostic.range.start.character,
+					diagnostic.message,
+				].join(":");
+				if (seen.has(key)) continue;
+				seen.add(key);
+				merged.push(diagnostic);
+			}
+		}
+
+		const rawCount = perServer.reduce(
+			(sum, entry) => sum + entry.diagnosticCount,
+			0,
+		);
+		const serversWithDiagnostics = perServer.filter(
+			(entry) => entry.diagnosticCount > 0,
+		).length;
+		const failureKind = merged.length === 0 ? "empty_result" : "success";
+
+		logLatency({
+			type: "phase",
+			phase: "lsp_diagnostics_aggregate",
+			filePath: normalizedPath,
+			durationMs: Date.now() - startedAt,
+			metadata: {
+				serverCountAttempted: getServersForFileWithConfig(filePath).length,
+				serverCountReady: perServer.length,
+				serverCountWithDiagnostics: serversWithDiagnostics,
+				mergedCount: merged.length,
+				dedupDroppedCount: rawCount - merged.length,
+				failureKind,
+				health: failureKind === "success" ? "ok" : "empty_result",
+				servers: perServer.map((entry) => ({
+					id: entry.serverId,
+					waitMs: entry.waitMs,
+					diagnosticCount: entry.diagnosticCount,
+				})),
+			},
+		});
 
-		await spawned.client.waitForDiagnostics(filePath, 3000);
-		return spawned.client.getDiagnostics(filePath);
+		return merged;
 	}
 
 	/**
@@ -294,6 +504,15 @@ export class LSPService {
 		return spawned.client.hover(filePath, line, character);
 	}
 
+	/**
+	 * Navigation: signature help at cursor position
+	 */
+	async signatureHelp(filePath: string, line: number, character: number) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return null;
+		return spawned.client.signatureHelp(filePath, line, character);
+	}
+
 	/**
 	 * Navigation: symbols in document
 	 */
@@ -306,13 +525,98 @@ export class LSPService {
 	/**
 	 * Navigation: workspace-wide symbol search
 	 */
-	async workspaceSymbol(query: string) {
+	async workspaceSymbol(query: string, filePath?: string) {
+		if (filePath) {
+			const spawned = await this.getClientForFile(filePath);
+			if (!spawned) return [];
+			return spawned.client.workspaceSymbol(query);
+		}
+
 		// Use the first active client for workspace-level queries
 		const clients = Array.from(this.state.clients.values());
 		if (clients.length === 0) return [];
 		return clients[0].workspaceSymbol(query);
 	}
 
+	/**
+	 * Capability snapshot for LSP operations.
+	 * If filePath is provided, probes that server; otherwise uses first active client.
+	 */
+	async getOperationSupport(filePath?: string): Promise<
+		import("./client.js").LSPOperationSupport | null
+	> {
+		if (filePath) {
+			const spawned = await this.getClientForFile(filePath);
+			if (!spawned) return null;
+			const getter = spawned.client.getOperationSupport;
+			if (typeof getter !== "function") return null;
+			return getter();
+		}
+
+		const first = this.state.clients.values().next().value;
+		if (!first) return null;
+		const getter = first.getOperationSupport;
+		if (typeof getter !== "function") return null;
+		return getter();
+	}
+
+	/**
+	 * Capability snapshot for workspace diagnostics support.
+	 * If filePath is provided, probes that server; otherwise uses first active client.
+	 */
+	async getWorkspaceDiagnosticsSupport(filePath?: string): Promise<
+		import("./client.js").LSPWorkspaceDiagnosticsSupport | null
+	> {
+		if (filePath) {
+			const spawned = await this.getClientForFile(filePath);
+			if (!spawned) return null;
+			const getter = spawned.client.getWorkspaceDiagnosticsSupport;
+			if (typeof getter !== "function") return null;
+			return getter();
+		}
+
+		const first = this.state.clients.values().next().value;
+		if (!first) return null;
+		const getter = first.getWorkspaceDiagnosticsSupport;
+		if (typeof getter !== "function") return null;
+		return getter();
+	}
+
+	/**
+	 * Navigation: available code actions at position/range
+	 */
+	async codeAction(
+		filePath: string,
+		line: number,
+		character: number,
+		endLine: number,
+		endCharacter: number,
+	) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.codeAction(
+			filePath,
+			line,
+			character,
+			endLine,
+			endCharacter,
+		);
+	}
+
+	/**
+	 * Navigation: rename symbol at position
+	 */
+	async rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+	) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return null;
+		return spawned.client.rename(filePath, line, character, newName);
+	}
+
 	/**
 	 * Navigation: go to implementation
 	 */
@@ -374,16 +678,8 @@ export class LSPService {
 	 * Check if LSP is available for a file
 	 */
 	async hasLSP(filePath: string): Promise<boolean> {
-		const servers = getServersForFileWithConfig(filePath);
-		if (servers.length === 0) return false;
-
-		// Check if any server can provide a root
-		for (const server of servers) {
-			const root = await server.root(filePath);
-			if (root) return true;
-		}
-
-		return false;
+		const spawned = await this.getClientForFile(filePath);
+		return Boolean(spawned);
 	}
 
 	/**
@@ -402,6 +698,8 @@ export class LSPService {
 		}
 		this.state.clients.clear();
 		this.state.broken.clear();
+		this.workspaceProbeLogged.clear();
+		this.warmStartLogged.clear();
 	}
 
 	/**

package/clients/lsp/launch.ts

@@ -26,6 +26,38 @@ export interface LSPProcess {
 
 const isWindows = process.platform === "win32";
 
+function buildAugmentedPath(basePath?: string): string {
+	if (!isWindows) return basePath ?? "";
+
+	const userProfile = process.env.USERPROFILE;
+	const candidates: string[] = [];
+	if (userProfile) {
+		candidates.push(path.join(userProfile, ".cargo", "bin"));
+		candidates.push(path.join(userProfile, "go", "bin"));
+	}
+	candidates.push(path.join("C:\\", "Ruby34-x64", "bin"));
+	candidates.push(path.join("C:\\", "Ruby33-x64", "bin"));
+
+	const existing = new Set<string>();
+	for (const entry of (basePath ?? "").split(path.delimiter)) {
+		if (!entry) continue;
+		existing.add(path.normalize(entry).toLowerCase());
+	}
+
+	const toAppend: string[] = [];
+	for (const candidate of candidates) {
+		if (!candidate || !fs.existsSync(candidate)) continue;
+		const normalized = path.normalize(candidate).toLowerCase();
+		if (existing.has(normalized)) continue;
+		toAppend.push(candidate);
+		existing.add(normalized);
+	}
+
+	if (toAppend.length === 0) return basePath ?? "";
+	if (!basePath) return toAppend.join(path.delimiter);
+	return `${basePath}${path.delimiter}${toAppend.join(path.delimiter)}`;
+}
+
 /**
  * Find binary in npm global directory
  * Works around PATH caching issue after npm install -g
@@ -169,7 +201,11 @@ export async function launchLSP(
 	options: SpawnOptions = {},
 ): Promise<LSPProcess> {
 	const cwd = String(options.cwd ?? process.cwd());
-	const env = { ...process.env, ...options.env };
+	const mergedEnv = { ...process.env, ...options.env };
+	const env: NodeJS.ProcessEnv = {
+		...mergedEnv,
+		PATH: buildAugmentedPath(mergedEnv.PATH),
+	};
 
 	// Resolve command path
 	// - If already absolute, use as-is
@@ -332,7 +368,11 @@ export async function launchViaPackageManager(
 		const shellCommand = `npx --no ${packageName}${argsStr ? ` ${argsStr}` : ""}`;
 
 		const cwd = String(options.cwd ?? process.cwd());
-		const env = { ...process.env, ...options.env };
+		const mergedEnv = { ...process.env, ...options.env };
+		const env: NodeJS.ProcessEnv = {
+			...mergedEnv,
+			PATH: buildAugmentedPath(mergedEnv.PATH),
+		};
 
 		const proc = nodeSpawn(shellCommand, [], {
 			cwd,