pi-lens 3.8.21 → 3.8.23

package/clients/lsp/client.ts

@@ -49,6 +49,53 @@ export interface LSPHover {
 	range?: LSPLocation["range"];
 }
 
+export interface LSPSignatureHelp {
+	signatures: Array<{
+		label: string;
+		documentation?: string | { kind: string; value: string };
+		parameters?: Array<{
+			label: string | [number, number];
+			documentation?: string | { kind: string; value: string };
+		}>;
+	}>;
+	activeSignature?: number;
+	activeParameter?: number;
+}
+
+export interface LSPCodeAction {
+	title: string;
+	kind?: string;
+	diagnostics?: LSPDiagnostic[];
+	edit?: unknown;
+	command?: unknown;
+	data?: unknown;
+}
+
+export interface LSPWorkspaceEdit {
+	changes?: Record<string, unknown[]>;
+	documentChanges?: unknown[];
+	changeAnnotations?: Record<string, unknown>;
+}
+
+export interface LSPWorkspaceDiagnosticsSupport {
+	advertised: boolean;
+	mode: "pull" | "push-only";
+	diagnosticProviderKind: string;
+}
+
+export interface LSPOperationSupport {
+	definition: boolean;
+	references: boolean;
+	hover: boolean;
+	signatureHelp: boolean;
+	documentSymbol: boolean;
+	workspaceSymbol: boolean;
+	codeAction: boolean;
+	rename: boolean;
+	implementation: boolean;
+	callHierarchy: boolean;
+}
+
 export interface LSPSymbol {
 	name: string;
 	kind: number;
@@ -93,6 +140,10 @@ export interface LSPClientInfo {
 	waitForDiagnostics(filePath: string, timeoutMs?: number): Promise<void>;
 	/** Get all tracked diagnostics (for cascade checking) */
 	getAllDiagnostics(): Map<string, LSPDiagnostic[]>;
+	/** Capability snapshot for workspace diagnostics support */
+	getWorkspaceDiagnosticsSupport(): LSPWorkspaceDiagnosticsSupport;
+	/** Capability snapshot for navigation/edit operations */
+	getOperationSupport(): LSPOperationSupport;
 	/** Go to definition — returns Location[] */
 	definition(
 		filePath: string,
@@ -112,10 +163,31 @@ export interface LSPClientInfo {
 		line: number,
 		character: number,
 	): Promise<LSPHover | null>;
+	/** Signature help at position */
+	signatureHelp(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<LSPSignatureHelp | null>;
 	/** Symbols in a document */
 	documentSymbol(filePath: string): Promise<LSPSymbol[]>;
 	/** Workspace-wide symbol search */
 	workspaceSymbol(query: string): Promise<LSPSymbol[]>;
+	/** Available code actions at a range */
+	codeAction(
+		filePath: string,
+		line: number,
+		character: number,
+		endLine: number,
+		endCharacter: number,
+	): Promise<LSPCodeAction[]>;
+	/** Rename symbol at position */
+	rename(
+		filePath: string,
+		line: number,
+		character: number,
+		newName: string,
+	): Promise<LSPWorkspaceEdit | null>;
 	/** Go to implementation */
 	implementation(
 		filePath: string,
@@ -141,8 +213,66 @@ export interface LSPClientInfo {
 
 // --- Constants ---
 
-const DIAGNOSTICS_DEBOUNCE_MS = 150; // ms — waits for follow-up semantic diagnostics
-const INITIALIZE_TIMEOUT_MS = 15_000; // 15s — npx downloads are handled by ensureTool, not here
+const DIAGNOSTICS_DEBOUNCE_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_DIAGNOSTICS_DEBOUNCE_MS",
+	150,
+); // ms — waits for follow-up semantic diagnostics
+const INITIALIZE_TIMEOUT_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_INIT_TIMEOUT_MS",
+	15_000,
+); // 15s — npx downloads are handled by ensureTool, not here
+const DIAGNOSTICS_WAIT_TIMEOUT_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_DIAGNOSTICS_WAIT_MS",
+	10_000,
+);
+const PULL_DIAGNOSTICS_RETRY_BUDGET_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_PULL_RETRY_BUDGET_MS",
+	1200,
+);
+const PULL_DIAGNOSTICS_RETRY_INTERVAL_MS = positiveIntFromEnv(
+	"PI_LENS_LSP_PULL_RETRY_INTERVAL_MS",
+	250,
+);
+
+const LSP_CRASH_CODES = new Set([
+	"ERR_STREAM_DESTROYED",
+	"ERR_STREAM_WRITE_AFTER_END",
+	"EPIPE",
+	"ECONNRESET",
+]);
+
+let crashGuardInstalled = false;
+
+function isIgnorableLspRuntimeCrash(err: unknown): boolean {
+	if (!(err instanceof Error)) return false;
+	const code = (err as { code?: string }).code;
+	if (code && LSP_CRASH_CODES.has(code)) return true;
+	const msg = err.message.toLowerCase();
+	const stack = (err.stack ?? "").toLowerCase();
+	return (
+		msg.includes("stream") ||
+		msg.includes("write after end") ||
+		stack.includes("vscode-jsonrpc/lib/node/ril.js")
+	);
+}
+
+function installCrashGuard(): void {
+	if (crashGuardInstalled) return;
+	crashGuardInstalled = true;
+
+	process.on("uncaughtException", (err) => {
+		if (isIgnorableLspRuntimeCrash(err)) {
+			return;
+		}
+		throw err;
+	});
+
+	process.on("unhandledRejection", (reason) => {
+		if (isIgnorableLspRuntimeCrash(reason)) {
+			return;
+		}
+	});
+}
 
 // --- Client Factory ---
 
@@ -152,6 +282,8 @@ export async function createLSPClient(options: {
 	root: string;
 	initialization?: Record<string, unknown>;
 }): Promise<LSPClientInfo> {
+	installCrashGuard();
+
 	const { serverId, process: lspProcess, root, initialization } = options;
 
 	// Attach persistent 'error' listeners to all three stdio streams.
@@ -174,6 +306,7 @@ export async function createLSPClient(options: {
 		(label: string) => (err: Error & { code?: string }) => {
 			if (
 				err.code === "ERR_STREAM_DESTROYED" ||
+				err.code === "ERR_STREAM_WRITE_AFTER_END" ||
 				err.code === "EPIPE" ||
 				err.code === "ECONNRESET"
 			)
@@ -215,21 +348,22 @@ export async function createLSPClient(options: {
 		"textDocument/publishDiagnostics",
 		(params: { uri: string; diagnostics?: LSPDiagnostic[] }) => {
 			const filePath = uriToPath(params.uri);
+			const normalizedPath = normalizeMapKey(filePath);
 			const newDiags: LSPDiagnostic[] = params.diagnostics || [];
 
 			// Debounce: clear existing timer and set new one
-			const existingTimer = pendingDiagnostics.get(filePath);
+			const existingTimer = pendingDiagnostics.get(normalizedPath);
 			if (existingTimer) clearTimeout(existingTimer);
 
 			const timer = setTimeout(() => {
-				diagnostics.set(filePath, newDiags);
-				pendingDiagnostics.delete(filePath);
+				diagnostics.set(normalizedPath, newDiags);
+				pendingDiagnostics.delete(normalizedPath);
 
 				// Signal any active waitForDiagnostics calls for this file.
-				diagnosticEmitter.emit("diagnostics", filePath);
+				diagnosticEmitter.emit("diagnostics", normalizedPath);
 			}, DIAGNOSTICS_DEBOUNCE_MS);
 
-			pendingDiagnostics.set(filePath, timer);
+			pendingDiagnostics.set(normalizedPath, timer);
 		},
 	);
 
@@ -255,25 +389,39 @@ export async function createLSPClient(options: {
 	let isConnected = true;
 	let lastError: Error | undefined;
 	let isDestroyed = false;
+	let connectionDisposed = false;
+
+	function disposeConnection(): void {
+		if (connectionDisposed) return;
+		connectionDisposed = true;
+		try {
+			connection.dispose();
+		} catch {
+			// ignore
+		}
+	}
 
 	// Handle connection errors and close events
 	connection.onError((error) => {
 		lastError = error instanceof Error ? error : new Error(String(error));
 		isConnected = false;
 		isDestroyed = true;
+		disposeConnection();
 		console.error(`[lsp] ${serverId} connection error:`, lastError.message);
 	});
 
 	connection.onClose(() => {
 		isConnected = false;
 		isDestroyed = true;
+		disposeConnection();
 	});
 
 	// Also handle process exit to catch crashes immediately
 	lspProcess.process.on("exit", (code) => {
+		isConnected = false;
+		isDestroyed = true;
+		disposeConnection();
 		if (code !== 0 && code !== null) {
-			isConnected = false;
-			isDestroyed = true;
 			console.error(`[lsp] ${serverId} process exited with code ${code}`);
 		}
 	});
@@ -327,6 +475,9 @@ export async function createLSPClient(options: {
 		);
 	}
 
+	const workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
+	const operationSupport = detectOperationSupport(initResult);
+
 	// Send initialized notification
 	await safeSendNotification(connection, "initialized", {});
 
@@ -437,9 +588,41 @@ export async function createLSPClient(options: {
 			return new Map(diagnostics);
 		},
 
-		async waitForDiagnostics(filePath, timeoutMs = 10000) {
+		getWorkspaceDiagnosticsSupport() {
+			return workspaceDiagnosticsSupport;
+		},
+
+		getOperationSupport() {
+			return operationSupport;
+		},
+
+		async waitForDiagnostics(filePath, timeoutMs = DIAGNOSTICS_WAIT_TIMEOUT_MS) {
 			const normalizedPath = normalizeMapKey(filePath);
 
+			if (workspaceDiagnosticsSupport.mode === "pull") {
+				const firstPullCount = await requestPullDiagnostics(filePath);
+				if (firstPullCount > 0) return;
+
+				const retryBudgetMs = Math.min(
+					timeoutMs,
+					PULL_DIAGNOSTICS_RETRY_BUDGET_MS,
+				);
+				const startedAt = Date.now();
+				let latestCount = firstPullCount;
+
+				while (
+					latestCount === 0 &&
+					Date.now() - startedAt < retryBudgetMs
+				) {
+					await new Promise((resolve) =>
+						setTimeout(resolve, PULL_DIAGNOSTICS_RETRY_INTERVAL_MS),
+					);
+					latestCount = await requestPullDiagnostics(filePath);
+				}
+
+				if (latestCount > 0) return;
+			}
+
 			// Fast path: diagnostics already available
 			if (diagnostics.has(normalizedPath)) return;
 
@@ -517,6 +700,20 @@ export async function createLSPClient(options: {
 			return result ?? null;
 		},
 
+		async signatureHelp(filePath, line, character) {
+			if (!isProcessAlive()) return null;
+			const uri = pathToFileURL(filePath).href;
+			const result = await safeSendRequest<LSPSignatureHelp>(
+				connection,
+				"textDocument/signatureHelp",
+				{
+					textDocument: { uri },
+					position: { line, character },
+				},
+			);
+			return result ?? null;
+		},
+
 		async documentSymbol(filePath) {
 			if (!isProcessAlive()) return [];
 			const uri = pathToFileURL(filePath).href;
@@ -542,6 +739,51 @@ export async function createLSPClient(options: {
 			return result ?? [];
 		},
 
+		async codeAction(
+			filePath,
+			line,
+			character,
+			endLine,
+			endCharacter,
+		) {
+			if (!isProcessAlive()) return [];
+			const uri = pathToFileURL(filePath).href;
+			const result = await safeSendRequest<unknown[]>(
+				connection,
+				"textDocument/codeAction",
+				{
+					textDocument: { uri },
+					range: {
+						start: { line, character },
+						end: { line: endLine, character: endCharacter },
+					},
+					context: {
+						diagnostics: diagnostics.get(normalizeMapKey(filePath)) ?? [],
+					},
+				},
+			);
+			if (!result || !Array.isArray(result)) return [];
+			return result.filter(
+				(item): item is LSPCodeAction =>
+					typeof item === "object" && item !== null && "title" in item,
+			);
+		},
+
+		async rename(filePath, line, character, newName) {
+			if (!isProcessAlive()) return null;
+			const uri = pathToFileURL(filePath).href;
+			const result = await safeSendRequest<LSPWorkspaceEdit>(
+				connection,
+				"textDocument/rename",
+				{
+					textDocument: { uri },
+					position: { line, character },
+					newName,
+				},
+			);
+			return result ?? null;
+		},
+
 		async implementation(filePath, line, character) {
 			if (!isProcessAlive()) return [];
 			const uri = pathToFileURL(filePath).href;
@@ -598,6 +840,7 @@ export async function createLSPClient(options: {
 
 		async shutdown() {
 			isConnected = false;
+			isDestroyed = true;
 			// Clear pending timers
 			for (const timer of pendingDiagnostics.values()) {
 				clearTimeout(timer);
@@ -620,11 +863,47 @@ export async function createLSPClient(options: {
 				/* ignore */
 			}
 
-			connection.end();
-			connection.dispose();
+			disposeConnection();
 			lspProcess.process.kill();
 		},
 	};
+
+	async function requestPullDiagnostics(filePath: string): Promise<number> {
+		if (!isProcessAlive()) return 0;
+		const uri = pathToFileURL(filePath).href;
+		try {
+			const report = await safeSendRequest<{
+				kind?: string;
+				items?: LSPDiagnostic[];
+				relatedDocuments?: Record<string, { items?: LSPDiagnostic[] }>;
+			}>(connection, "textDocument/diagnostic", {
+				textDocument: { uri },
+			});
+
+			if (!report) return 0;
+
+			const normalizedPath = normalizeMapKey(filePath);
+			const primaryItems = report.items ?? [];
+			diagnostics.set(normalizedPath, primaryItems);
+			let totalCount = primaryItems.length;
+
+			if (report.relatedDocuments) {
+				for (const [relatedUri, related] of Object.entries(
+					report.relatedDocuments,
+				)) {
+					const relatedPath = uriToPath(relatedUri);
+					const relatedItems = related?.items ?? [];
+					diagnostics.set(normalizeMapKey(relatedPath), relatedItems);
+					totalCount += relatedItems.length;
+				}
+			}
+
+			diagnosticEmitter.emit("diagnostics", normalizedPath);
+			return totalCount;
+		} catch {
+			return 0;
+		}
+	}
 }
 
 // Helper to safely send notifications - catches stream destruction
@@ -681,6 +960,7 @@ function isStreamError(err: unknown): boolean {
 		msg.includes("disposed") ||
 		msg.includes("cancelled") ||
 		(err as { code?: string }).code === "ERR_STREAM_DESTROYED" ||
+		(err as { code?: string }).code === "ERR_STREAM_WRITE_AFTER_END" ||
 		(err as { code?: string }).code === "EPIPE"
 	);
 }
@@ -722,3 +1002,77 @@ async function withTimeout<T>(
 		),
 	]);
 }
+
+function positiveIntFromEnv(name: string, fallback: number): number {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return parsed;
+}
+
+function detectWorkspaceDiagnosticsSupport(
+	initResult: unknown,
+): LSPWorkspaceDiagnosticsSupport {
+	const capabilities =
+		typeof initResult === "object" && initResult !== null
+			? (initResult as { capabilities?: Record<string, unknown> }).capabilities
+			: undefined;
+	const diagnosticProvider = capabilities?.diagnosticProvider;
+	if (!diagnosticProvider) {
+		return {
+			advertised: false,
+			mode: "push-only",
+			diagnosticProviderKind: "none",
+		};
+	}
+
+	if (typeof diagnosticProvider === "boolean") {
+		return {
+			advertised: diagnosticProvider,
+			mode: diagnosticProvider ? "pull" : "push-only",
+			diagnosticProviderKind: "boolean",
+		};
+	}
+
+	if (typeof diagnosticProvider === "object") {
+		return {
+			advertised: true,
+			mode: "pull",
+			diagnosticProviderKind: "object",
+		};
+	}
+
+	return {
+		advertised: false,
+		mode: "push-only",
+		diagnosticProviderKind: typeof diagnosticProvider,
+	};
+}
+
+function detectOperationSupport(initResult: unknown): LSPOperationSupport {
+	const capabilities =
+		typeof initResult === "object" && initResult !== null
+			? (initResult as { capabilities?: Record<string, unknown> }).capabilities
+			: undefined;
+
+	const hasProvider = (key: string): boolean => {
+		const value = capabilities?.[key];
+		if (value === undefined || value === null) return false;
+		if (typeof value === "boolean") return value;
+		return true;
+	};
+
+	return {
+		definition: hasProvider("definitionProvider"),
+		references: hasProvider("referencesProvider"),
+		hover: hasProvider("hoverProvider"),
+		signatureHelp: hasProvider("signatureHelpProvider"),
+		documentSymbol: hasProvider("documentSymbolProvider"),
+		workspaceSymbol: hasProvider("workspaceSymbolProvider"),
+		codeAction: hasProvider("codeActionProvider"),
+		rename: hasProvider("renameProvider"),
+		implementation: hasProvider("implementationProvider"),
+		callHierarchy: hasProvider("callHierarchyProvider"),
+	};
+}