pi-lens 3.1.2 → 3.2.0

package/clients/lsp/client.js

@@ -150,8 +150,10 @@ export async function createLSPClient(options) {
             },
             async change(filePath, content) {
                 const uri = pathToFileURL(filePath).href;
-                const version = (documentVersions.get(filePath) ?? 0) + 1;
-                documentVersions.set(filePath, version);
+                // Normalize path for Windows case-insensitive lookup
+                const normalizedPath = normalizeMapKey(filePath);
+                const version = (documentVersions.get(normalizedPath) ?? 0) + 1;
+                documentVersions.set(normalizedPath, version);
                 await connection.sendNotification("textDocument/didChange", {
                     textDocument: { uri, version },
                     contentChanges: [{ text: content }],
@@ -163,6 +165,10 @@ export async function createLSPClient(options) {
             const normalizedPath = normalizeMapKey(filePath);
             return diagnostics.get(normalizedPath) ?? [];
         },
+        getAllDiagnostics() {
+            // Return copy of all tracked diagnostics (for cascade checking)
+            return new Map(diagnostics);
+        },
         async waitForDiagnostics(filePath, timeoutMs = 10000) {
             const normalizedPath = normalizeMapKey(filePath);
             if (diagnostics.has(normalizedPath))
@@ -192,6 +198,85 @@ export async function createLSPClient(options) {
                 }, timeoutMs);
             });
         },
+        async definition(filePath, line, character) {
+            const uri = pathToFileURL(filePath).href;
+            try {
+                const result = await connection.sendRequest("textDocument/definition", {
+                    textDocument: { uri },
+                    position: { line, character },
+                });
+                if (!result)
+                    return [];
+                return Array.isArray(result) ? result : [result];
+            }
+            catch {
+                return [];
+            }
+        },
+        async references(filePath, line, character, includeDeclaration = true) {
+            const uri = pathToFileURL(filePath).href;
+            try {
+                const result = await connection.sendRequest("textDocument/references", {
+                    textDocument: { uri },
+                    position: { line, character },
+                    context: { includeDeclaration },
+                });
+                return Array.isArray(result) ? result : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        async hover(filePath, line, character) {
+            const uri = pathToFileURL(filePath).href;
+            try {
+                return (await connection.sendRequest("textDocument/hover", {
+                    textDocument: { uri },
+                    position: { line, character },
+                }));
+            }
+            catch {
+                return null;
+            }
+        },
+        async documentSymbol(filePath) {
+            const uri = pathToFileURL(filePath).href;
+            try {
+                const result = await connection.sendRequest("textDocument/documentSymbol", {
+                    textDocument: { uri },
+                });
+                return Array.isArray(result) ? result : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        async workspaceSymbol(query) {
+            try {
+                const result = await connection.sendRequest("workspace/symbol", {
+                    query,
+                });
+                return Array.isArray(result) ? result : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        async implementation(filePath, line, character) {
+            const uri = pathToFileURL(filePath).href;
+            try {
+                const result = await connection.sendRequest("textDocument/implementation", {
+                    textDocument: { uri },
+                    position: { line, character },
+                });
+                if (!result)
+                    return [];
+                return Array.isArray(result) ? result : [result];
+            }
+            catch {
+                return [];
+            }
+        },
         async shutdown() {
             // Clear pending timers
             for (const timer of pendingDiagnostics.values()) {

package/clients/lsp/client.ts

@@ -32,6 +32,32 @@ export interface LSPDiagnostic {
 	source?: string;
 }
 
+export interface LSPLocation {
+	uri: string;
+	range: {
+		start: { line: number; character: number };
+		end: { line: number; character: number };
+	};
+}
+
+export interface LSPHover {
+	contents:
+		| string
+		| { kind: string; value: string }
+		| Array<string | { language: string; value: string }>;
+	range?: LSPLocation["range"];
+}
+
+export interface LSPSymbol {
+	name: string;
+	kind: number;
+	location?: LSPLocation;
+	range?: LSPLocation["range"];
+	selectionRange?: LSPLocation["range"];
+	detail?: string;
+	children?: LSPSymbol[];
+}
+
 export interface LSPClientInfo {
 	serverId: string;
 	root: string;
@@ -42,6 +68,37 @@ export interface LSPClientInfo {
 	};
 	getDiagnostics(filePath: string): LSPDiagnostic[];
 	waitForDiagnostics(filePath: string, timeoutMs?: number): Promise<void>;
+	/** Get all tracked diagnostics (for cascade checking) */
+	getAllDiagnostics(): Map<string, LSPDiagnostic[]>;
+	/** Go to definition — returns Location[] */
+	definition(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<LSPLocation[]>;
+	/** Find all references */
+	references(
+		filePath: string,
+		line: number,
+		character: number,
+		includeDeclaration?: boolean,
+	): Promise<LSPLocation[]>;
+	/** Hover info at position */
+	hover(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<LSPHover | null>;
+	/** Symbols in a document */
+	documentSymbol(filePath: string): Promise<LSPSymbol[]>;
+	/** Workspace-wide symbol search */
+	workspaceSymbol(query: string): Promise<LSPSymbol[]>;
+	/** Go to implementation */
+	implementation(
+		filePath: string,
+		line: number,
+		character: number,
+	): Promise<LSPLocation[]>;
 	shutdown(): Promise<void>;
 }
 
@@ -150,10 +207,7 @@ export async function createLSPClient(options: {
 					workDoneProgress: true,
 				},
 				workspace: {
-					workspaceFolders: {
-						supported: true,
-						changeNotifications: true,
-					},
+					workspaceFolders: true, // Simple boolean for broader compatibility
 					configuration: true,
 					didChangeWatchedFiles: {
 						dynamicRegistration: true,
@@ -222,8 +276,10 @@ export async function createLSPClient(options: {
 
 			async change(filePath, content) {
 				const uri = pathToFileURL(filePath).href;
-				const version = (documentVersions.get(filePath) ?? 0) + 1;
-				documentVersions.set(filePath, version);
+				// Normalize path for Windows case-insensitive lookup
+				const normalizedPath = normalizeMapKey(filePath);
+				const version = (documentVersions.get(normalizedPath) ?? 0) + 1;
+				documentVersions.set(normalizedPath, version);
 
 				await connection.sendNotification("textDocument/didChange", {
 					textDocument: { uri, version },
@@ -238,6 +294,11 @@ export async function createLSPClient(options: {
 			return diagnostics.get(normalizedPath) ?? [];
 		},
 
+		getAllDiagnostics() {
+			// Return copy of all tracked diagnostics (for cascade checking)
+			return new Map(diagnostics);
+		},
+
 		async waitForDiagnostics(filePath, timeoutMs = 10000) {
 			const normalizedPath = normalizeMapKey(filePath);
 			if (diagnostics.has(normalizedPath)) return;
@@ -270,6 +331,89 @@ export async function createLSPClient(options: {
 			});
 		},
 
+		async definition(filePath, line, character) {
+			const uri = pathToFileURL(filePath).href;
+			try {
+				const result = await connection.sendRequest("textDocument/definition", {
+					textDocument: { uri },
+					position: { line, character },
+				});
+				if (!result) return [];
+				return Array.isArray(result) ? result : [result];
+			} catch {
+				return [];
+			}
+		},
+
+		async references(filePath, line, character, includeDeclaration = true) {
+			const uri = pathToFileURL(filePath).href;
+			try {
+				const result = await connection.sendRequest("textDocument/references", {
+					textDocument: { uri },
+					position: { line, character },
+					context: { includeDeclaration },
+				});
+				return Array.isArray(result) ? result : [];
+			} catch {
+				return [];
+			}
+		},
+
+		async hover(filePath, line, character) {
+			const uri = pathToFileURL(filePath).href;
+			try {
+				return (await connection.sendRequest("textDocument/hover", {
+					textDocument: { uri },
+					position: { line, character },
+				})) as LSPHover | null;
+			} catch {
+				return null;
+			}
+		},
+
+		async documentSymbol(filePath) {
+			const uri = pathToFileURL(filePath).href;
+			try {
+				const result = await connection.sendRequest(
+					"textDocument/documentSymbol",
+					{
+						textDocument: { uri },
+					},
+				);
+				return Array.isArray(result) ? result : [];
+			} catch {
+				return [];
+			}
+		},
+
+		async workspaceSymbol(query) {
+			try {
+				const result = await connection.sendRequest("workspace/symbol", {
+					query,
+				});
+				return Array.isArray(result) ? result : [];
+			} catch {
+				return [];
+			}
+		},
+
+		async implementation(filePath, line, character) {
+			const uri = pathToFileURL(filePath).href;
+			try {
+				const result = await connection.sendRequest(
+					"textDocument/implementation",
+					{
+						textDocument: { uri },
+						position: { line, character },
+					},
+				);
+				if (!result) return [];
+				return Array.isArray(result) ? result : [result];
+			} catch {
+				return [];
+			}
+		},
+
 		async shutdown() {
 			// Clear pending timers
 			for (const timer of pendingDiagnostics.values()) {

package/clients/lsp/config.js

@@ -18,18 +18,14 @@
  *   }
  * }
  */
-import fs from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-import { LSP_SERVERS, createRootDetector } from "./server.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { launchLSP } from "./launch.js";
+import { createRootDetector, LSP_SERVERS, } from "./server.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // --- Config Loading ---
-const CONFIG_PATHS = [
-    ".pi-lens/lsp.json",
-    ".pi-lens.json",
-    "pi-lsp.json",
-];
+const CONFIG_PATHS = [".pi-lens/lsp.json", ".pi-lens.json", "pi-lsp.json"];
 /**
  * Load LSP configuration from file
  */
@@ -61,7 +57,7 @@ export function createCustomServer(config, id) {
             ? createRootDetector(config.rootMarkers)
             : async () => process.cwd(),
         async spawn(root) {
-            const proc = launchLSP(config.command, config.args ?? ["--stdio"], {
+            const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
                 cwd: root,
                 env: config.env ? { ...process.env, ...config.env } : process.env,
             });
@@ -99,7 +95,7 @@ export async function initLSPConfig(cwd) {
  */
 export function getAllServers() {
     const all = [...LSP_SERVERS, ...customServers];
-    return all.filter(s => !disabledServerIds.has(s.id));
+    return all.filter((s) => !disabledServerIds.has(s.id));
 }
 /**
  * Check if a server is disabled
@@ -107,6 +103,7 @@ export function getAllServers() {
 export function isServerDisabled(serverId) {
     return disabledServerIds.has(serverId);
 }
+// --- Override getServersForFile to include custom servers
 export function getServersForFileWithConfig(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return getAllServers().filter((server) => server.extensions.includes(ext));

package/clients/lsp/config.ts

@@ -1,10 +1,10 @@
 /**
  * LSP Configuration for pi-lens
- * 
+ *
  * Allows users to define custom LSP servers via configuration.
- * 
+ *
  * Config file: .pi-lens/lsp.json
- * 
+ *
  * Example:
  * {
  *   "servers": {
@@ -19,11 +19,15 @@
  * }
  */
 
-import fs from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-import { LSP_SERVERS, type LSPServerInfo, createRootDetector } from "./server.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { launchLSP } from "./launch.js";
+import {
+	createRootDetector,
+	LSP_SERVERS,
+	type LSPServerInfo,
+} from "./server.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -45,11 +49,7 @@ export interface LSPConfig {
 
 // --- Config Loading ---
 
-const CONFIG_PATHS = [
-	".pi-lens/lsp.json",
-	".pi-lens.json",
-	"pi-lsp.json",
-];
+const CONFIG_PATHS = [".pi-lens/lsp.json", ".pi-lens.json", "pi-lsp.json"];
 
 /**
  * Load LSP configuration from file
@@ -74,16 +74,19 @@ export async function loadLSPConfig(cwd: string): Promise<LSPConfig> {
 /**
  * Create LSPServerInfo from user configuration
  */
-export function createCustomServer(config: CustomServerConfig, id: string): LSPServerInfo {
+export function createCustomServer(
+	config: CustomServerConfig,
+	id: string,
+): LSPServerInfo {
 	return {
 		id,
 		name: config.name,
 		extensions: config.extensions,
-		root: config.rootMarkers 
+		root: config.rootMarkers
 			? createRootDetector(config.rootMarkers)
 			: async () => process.cwd(),
 		async spawn(root) {
-			const proc = launchLSP(config.command, config.args ?? ["--stdio"], {
+			const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
 				cwd: root,
 				env: config.env ? { ...process.env, ...config.env } : process.env,
 			});
@@ -102,18 +105,20 @@ let disabledServerIds: Set<string> = new Set();
  */
 export async function initLSPConfig(cwd: string): Promise<void> {
 	const config = await loadLSPConfig(cwd);
-	
+
 	// Clear previous custom servers
 	customServers = [];
 	disabledServerIds = new Set(config.disabledServers ?? []);
-	
+
 	// Register custom servers from config
 	if (config.servers) {
 		for (const [id, serverConfig] of Object.entries(config.servers)) {
 			try {
 				const server = createCustomServer(serverConfig, id);
 				customServers.push(server);
-				console.error(`[lsp-config] Registered custom server: ${id} (${serverConfig.name})`);
+				console.error(
+					`[lsp-config] Registered custom server: ${id} (${serverConfig.name})`,
+				);
 			} catch (err) {
 				console.error(`[lsp-config] Failed to register server ${id}:`, err);
 			}
@@ -126,7 +131,7 @@ export async function initLSPConfig(cwd: string): Promise<void> {
  */
 export function getAllServers(): LSPServerInfo[] {
 	const all = [...LSP_SERVERS, ...customServers];
-	return all.filter(s => !disabledServerIds.has(s.id));
+	return all.filter((s) => !disabledServerIds.has(s.id));
 }
 
 /**
@@ -138,8 +143,6 @@ export function isServerDisabled(serverId: string): boolean {
 
 // --- Override getServersForFile to include custom servers
 
-import { getServersForFile as getBuiltinServersForFile } from "./server.js";
-
 export function getServersForFileWithConfig(filePath: string): LSPServerInfo[] {
 	const ext = path.extname(filePath).toLowerCase();
 	return getAllServers().filter((server) => server.extensions.includes(ext));

package/clients/lsp/index.js

@@ -136,6 +136,75 @@ export class LSPService {
         await spawned.client.waitForDiagnostics(filePath, 3000);
         return spawned.client.getDiagnostics(filePath);
     }
+    /**
+     * Navigation: go to definition
+     */
+    async definition(filePath, line, character) {
+        const spawned = await this.getClientForFile(filePath);
+        if (!spawned)
+            return [];
+        return spawned.client.definition(filePath, line, character);
+    }
+    /**
+     * Navigation: find all references
+     */
+    async references(filePath, line, character, includeDeclaration = true) {
+        const spawned = await this.getClientForFile(filePath);
+        if (!spawned)
+            return [];
+        return spawned.client.references(filePath, line, character, includeDeclaration);
+    }
+    /**
+     * Navigation: hover info
+     */
+    async hover(filePath, line, character) {
+        const spawned = await this.getClientForFile(filePath);
+        if (!spawned)
+            return null;
+        return spawned.client.hover(filePath, line, character);
+    }
+    /**
+     * Navigation: symbols in document
+     */
+    async documentSymbol(filePath) {
+        const spawned = await this.getClientForFile(filePath);
+        if (!spawned)
+            return [];
+        return spawned.client.documentSymbol(filePath);
+    }
+    /**
+     * Navigation: workspace-wide symbol search
+     */
+    async 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);
+    }
+    /**
+     * Navigation: go to implementation
+     */
+    async implementation(filePath, line, character) {
+        const spawned = await this.getClientForFile(filePath);
+        if (!spawned)
+            return [];
+        return spawned.client.implementation(filePath, line, character);
+    }
+    /**
+     * Get all diagnostics across all tracked files (for cascade checking)
+     */
+    async getAllDiagnostics() {
+        const all = new Map();
+        for (const [_key, client] of this.state.clients) {
+            const clientDiags = client.getAllDiagnostics();
+            for (const [filePath, diags] of clientDiags) {
+                const existing = all.get(filePath) ?? [];
+                all.set(filePath, [...existing, ...diags]);
+            }
+        }
+        return all;
+    }
     /**
      * Check if LSP is available for a file
      */

package/clients/lsp/index.ts

@@ -177,6 +177,88 @@ export class LSPService {
 		return spawned.client.getDiagnostics(filePath);
 	}
 
+	/**
+	 * Navigation: go to definition
+	 */
+	async definition(filePath: string, line: number, character: number) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.definition(filePath, line, character);
+	}
+
+	/**
+	 * Navigation: find all references
+	 */
+	async references(
+		filePath: string,
+		line: number,
+		character: number,
+		includeDeclaration = true,
+	) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.references(
+			filePath,
+			line,
+			character,
+			includeDeclaration,
+		);
+	}
+
+	/**
+	 * Navigation: hover info
+	 */
+	async hover(filePath: string, line: number, character: number) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return null;
+		return spawned.client.hover(filePath, line, character);
+	}
+
+	/**
+	 * Navigation: symbols in document
+	 */
+	async documentSymbol(filePath: string) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.documentSymbol(filePath);
+	}
+
+	/**
+	 * Navigation: workspace-wide symbol search
+	 */
+	async workspaceSymbol(query: string) {
+		// 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);
+	}
+
+	/**
+	 * Navigation: go to implementation
+	 */
+	async implementation(filePath: string, line: number, character: number) {
+		const spawned = await this.getClientForFile(filePath);
+		if (!spawned) return [];
+		return spawned.client.implementation(filePath, line, character);
+	}
+
+	/**
+	 * Get all diagnostics across all tracked files (for cascade checking)
+	 */
+	async getAllDiagnostics(): Promise<
+		Map<string, import("./client.js").LSPDiagnostic[]>
+	> {
+		const all = new Map<string, import("./client.js").LSPDiagnostic[]>();
+		for (const [_key, client] of this.state.clients) {
+			const clientDiags = client.getAllDiagnostics();
+			for (const [filePath, diags] of clientDiags) {
+				const existing = all.get(filePath) ?? [];
+				all.set(filePath, [...existing, ...diags]);
+			}
+		}
+		return all;
+	}
+
 	/**
 	 * Check if LSP is available for a file
 	 */

package/clients/lsp/interactive-install.js

@@ -9,9 +9,9 @@
  * - User choice caching per project
  * - Only prompts for "common" languages (Go, Rust, YAML, JSON, Bash)
  */
-import * as fs from "fs/promises";
-import * as path from "path";
-import { spawn } from "child_process";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 // Languages that support interactive auto-install prompt
 const COMMON_LANGUAGES = {
     go: {
@@ -33,7 +33,7 @@ const COMMON_LANGUAGES = {
         packageName: "yaml-language-server",
     },
     json: {
-        toolId: "vscode-json-languageserver",
+        toolId: "vscode-json-language-server",
         toolName: "JSON Language Server",
         installCommand: "npm install -g vscode-langservers-extracted",
         packageName: "vscode-langservers-extracted",
@@ -123,8 +123,8 @@ function promptUser(timeoutMs) {
  */
 function isAutoInstallEnabled() {
     // Check environment variable or process arguments
-    return process.env.PI_LENS_AUTO_INSTALL === "1" ||
-        process.argv.includes("--auto-install");
+    return (process.env.PI_LENS_AUTO_INSTALL === "1" ||
+        process.argv.includes("--auto-install"));
 }
 /**
  * Attempt to install a tool
@@ -173,9 +173,20 @@ export async function promptForInstall(language, cwd) {
         const thirtyDays = 30 * 24 * 60 * 60 * 1000;
         if (Date.now() - cached.timestamp < thirtyDays) {
             if (cached.choice === "yes" || cached.choice === "auto") {
-                return true;
+                // Verify binary actually exists before trusting cache
+                try {
+                    const { execSync } = await import("node:child_process");
+                    execSync(`which ${config.toolId}`, { stdio: "ignore" });
+                    return true; // Binary exists, cache is valid
+                }
+                catch {
+                    // Binary not found, invalidate cache and continue to install
+                    console.error(`[pi-lens] Cached ${config.toolId} not found, re-installing...`);
+                }
+            }
+            else {
+                return false; // User previously declined
             }
-            return false;
         }
     }
     // Check auto-install flag