pi-lens 3.6.2 → 3.6.4

package/clients/lsp/client.js

@@ -1,350 +0,0 @@
-/**
- * LSP Client for pi-lens
- *
- * Handles JSON-RPC communication with language servers:
- * - Initialize/shutdown lifecycle
- * - Document synchronization (didOpen, didChange)
- * - Diagnostics with debouncing
- * - Request/response handling
- */
-import { EventEmitter } from "node:events";
-import { pathToFileURL } from "node:url";
-import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/node.js";
-import { normalizeMapKey, uriToPath } from "./path-utils.js";
-// --- Constants ---
-const DIAGNOSTICS_DEBOUNCE_MS = 150; // ms — waits for follow-up semantic diagnostics
-const INITIALIZE_TIMEOUT_MS = 120000; // 2 minutes (was 45s) - allows time for npx to download packages
-// --- Client Factory ---
-export async function createLSPClient(options) {
-    const { serverId, process: lspProcess, root, initialization } = options;
-    // Create JSON-RPC connection
-    const connection = createMessageConnection(new StreamMessageReader(lspProcess.stdout), new StreamMessageWriter(lspProcess.stdin));
-    // Track diagnostics per file
-    const diagnostics = new Map();
-    const pendingDiagnostics = new Map();
-    // Local event emitter — signals waitForDiagnostics when new diagnostics arrive.
-    // Scoped to this client instance; replaces global bus pub/sub.
-    // setMaxListeners guards against Node.js warning for concurrent waitForDiagnostics calls.
-    const diagnosticEmitter = new EventEmitter();
-    diagnosticEmitter.setMaxListeners(50);
-    // Handle incoming diagnostics with debouncing
-    connection.onNotification("textDocument/publishDiagnostics", (params) => {
-        const filePath = uriToPath(params.uri);
-        const newDiags = params.diagnostics || [];
-        // Debounce: clear existing timer and set new one
-        const existingTimer = pendingDiagnostics.get(filePath);
-        if (existingTimer)
-            clearTimeout(existingTimer);
-        const timer = setTimeout(() => {
-            diagnostics.set(filePath, newDiags);
-            pendingDiagnostics.delete(filePath);
-            // Signal any active waitForDiagnostics calls for this file.
-            diagnosticEmitter.emit("diagnostics", filePath);
-        }, DIAGNOSTICS_DEBOUNCE_MS);
-        pendingDiagnostics.set(filePath, timer);
-    });
-    // Handle server requests
-    connection.onRequest("workspace/workspaceFolders", () => [
-        {
-            name: "workspace",
-            uri: pathToFileURL(root).href,
-        },
-    ]);
-    connection.onRequest("client/registerCapability", async () => { });
-    connection.onRequest("client/unregisterCapability", async () => { });
-    connection.onRequest("workspace/configuration", async () => [
-        initialization ?? {},
-    ]);
-    connection.onRequest("window/workDoneProgress/create", async () => { });
-    // Start listening
-    connection.listen();
-    // Send initialize request
-    await withTimeout(connection.sendRequest("initialize", {
-        processId: process.pid,
-        rootUri: pathToFileURL(root).href,
-        workspaceFolders: [
-            {
-                name: "workspace",
-                uri: pathToFileURL(root).href,
-            },
-        ],
-        capabilities: {
-            window: {
-                workDoneProgress: true,
-            },
-            workspace: {
-                workspaceFolders: true, // Simple boolean for broader compatibility
-                configuration: true,
-                didChangeWatchedFiles: {
-                    dynamicRegistration: true,
-                },
-            },
-            textDocument: {
-                synchronization: {
-                    didOpen: true,
-                    didChange: true,
-                },
-                publishDiagnostics: {
-                    versionSupport: true,
-                },
-            },
-        },
-        initializationOptions: initialization,
-    }), INITIALIZE_TIMEOUT_MS);
-    // Send initialized notification
-    await connection.sendNotification("initialized", {});
-    // Send configuration if provided (helps pyright and other servers)
-    if (initialization) {
-        await connection.sendNotification("workspace/didChangeConfiguration", {
-            settings: initialization,
-        });
-    }
-    // Track open documents with version numbers
-    const documentVersions = new Map();
-    return {
-        serverId,
-        root,
-        connection,
-        notify: {
-            async open(filePath, content, languageId) {
-                const uri = pathToFileURL(filePath).href;
-                // Normalize path for Windows case-insensitive lookup
-                const normalizedPath = normalizeMapKey(filePath);
-                documentVersions.set(normalizedPath, 0);
-                diagnostics.delete(normalizedPath); // Clear stale diagnostics
-                // Send workspace notification first (like opencode does)
-                await connection.sendNotification("workspace/didChangeWatchedFiles", {
-                    changes: [
-                        {
-                            uri,
-                            type: 1, // Created
-                        },
-                    ],
-                });
-                await connection.sendNotification("textDocument/didOpen", {
-                    textDocument: {
-                        uri,
-                        languageId,
-                        version: 0,
-                        text: content,
-                    },
-                });
-            },
-            async change(filePath, content) {
-                const uri = pathToFileURL(filePath).href;
-                // 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 }],
-                });
-            },
-        },
-        getDiagnostics(filePath) {
-            // Normalize path for Windows case-insensitive lookup
-            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);
-            // Fast path: diagnostics already available
-            if (diagnostics.has(normalizedPath))
-                return;
-            return new Promise((resolve) => {
-                let debounceTimer;
-                // Listen on the local emitter for this client's diagnostic notifications.
-                // No runnerId filter needed — this emitter is scoped to this client instance.
-                const onDiagnostics = (fp) => {
-                    if (normalizeMapKey(fp) !== normalizedPath)
-                        return;
-                    // Debounce: reset on each event to catch follow-up semantic diagnostics
-                    // (LSP often sends syntax diagnostics first, semantic ones shortly after).
-                    if (debounceTimer)
-                        clearTimeout(debounceTimer);
-                    debounceTimer = setTimeout(() => {
-                        diagnosticEmitter.off("diagnostics", onDiagnostics);
-                        clearTimeout(timeout);
-                        resolve();
-                    }, DIAGNOSTICS_DEBOUNCE_MS);
-                };
-                diagnosticEmitter.on("diagnostics", onDiagnostics);
-                // Timeout fallback: resolve even if no diagnostics arrive
-                // (some files have no errors, or the server may be slow)
-                const timeout = setTimeout(() => {
-                    if (debounceTimer)
-                        clearTimeout(debounceTimer);
-                    diagnosticEmitter.off("diagnostics", onDiagnostics);
-                    resolve();
-                }, 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 [];
-            }
-        },
-        // --- Call Hierarchy Methods ---
-        async prepareCallHierarchy(filePath, line, character) {
-            const uri = pathToFileURL(filePath).href;
-            try {
-                const result = await connection.sendRequest("textDocument/prepareCallHierarchy", {
-                    textDocument: { uri },
-                    position: { line, character },
-                });
-                if (!result)
-                    return [];
-                return Array.isArray(result) ? result : [result];
-            }
-            catch {
-                return [];
-            }
-        },
-        async incomingCalls(item) {
-            try {
-                const result = await connection.sendRequest("callHierarchy/incomingCalls", {
-                    item,
-                });
-                if (!result)
-                    return [];
-                return Array.isArray(result) ? result : [];
-            }
-            catch {
-                return [];
-            }
-        },
-        async outgoingCalls(item) {
-            try {
-                const result = await connection.sendRequest("callHierarchy/outgoingCalls", {
-                    item,
-                });
-                if (!result)
-                    return [];
-                return Array.isArray(result) ? result : [];
-            }
-            catch {
-                return [];
-            }
-        },
-        async shutdown() {
-            // Clear pending timers
-            for (const timer of pendingDiagnostics.values()) {
-                clearTimeout(timer);
-            }
-            pendingDiagnostics.clear();
-            // Remove all diagnostic listeners (cancels any in-flight waitForDiagnostics)
-            diagnosticEmitter.removeAllListeners();
-            // Graceful shutdown
-            try {
-                await connection.sendRequest("shutdown");
-                await connection.sendNotification("exit");
-            }
-            catch {
-                /* ignore */
-            }
-            connection.dispose();
-            lspProcess.process.kill();
-        },
-    };
-}
-// --- Utilities ---
-// Using shared path utilities from path-utils.ts
-function severityFromNumber(sev) {
-    switch (sev) {
-        case 1:
-            return "error";
-        case 2:
-            return "warning";
-        case 3:
-            return "info";
-        case 4:
-            return "hint";
-        default:
-            return "error";
-    }
-}
-async function withTimeout(promise, timeoutMs) {
-    return Promise.race([
-        promise,
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs)),
-    ]);
-}

package/clients/lsp/config.js

@@ -1,112 +0,0 @@
-/**
- * LSP Configuration for pi-lens
- *
- * Allows users to define custom LSP servers via configuration.
- *
- * Config file: .pi-lens/lsp.json
- *
- * Example:
- * {
- *   "servers": {
- *     "my-server": {
- *       "name": "My Custom LSP",
- *       "extensions": [".myext"],
- *       "command": "my-lsp-server",
- *       "args": ["--stdio"],
- *       "rootMarkers": ["package.json"]
- *     }
- *   }
- * }
- */
-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"];
-/**
- * Load LSP configuration from file
- */
-export async function loadLSPConfig(cwd) {
-    for (const configPath of CONFIG_PATHS) {
-        const fullPath = path.join(cwd, configPath);
-        try {
-            const content = await fs.readFile(fullPath, "utf-8");
-            const config = JSON.parse(content);
-            console.error(`[lsp-config] Loaded config from ${configPath}`);
-            return config;
-        }
-        catch {
-            // File doesn't exist or is invalid, try next
-        }
-    }
-    return {};
-}
-// --- Custom Server Factory ---
-/**
- * Create LSPServerInfo from user configuration
- */
-export function createCustomServer(config, id) {
-    return {
-        id,
-        name: config.name,
-        extensions: config.extensions,
-        root: config.rootMarkers
-            ? createRootDetector(config.rootMarkers)
-            : async () => process.cwd(),
-        async spawn(root) {
-            const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
-                cwd: root,
-                env: config.env ? { ...process.env, ...config.env } : process.env,
-            });
-            return { process: proc };
-        },
-    };
-}
-// --- Registry Management ---
-let customServers = [];
-let disabledServerIds = new Set();
-/**
- * Initialize LSP configuration (call at session start)
- */
-export async function initLSPConfig(cwd) {
-    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})`);
-            }
-            catch (err) {
-                console.error(`[lsp-config] Failed to register server ${id}:`, err);
-            }
-        }
-    }
-}
-/**
- * Get all available servers (built-in + custom, minus disabled)
- */
-export function getAllServers() {
-    const all = [...LSP_SERVERS, ...customServers];
-    return all.filter((s) => !disabledServerIds.has(s.id));
-}
-/**
- * Check if a server is disabled
- */
-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));
-}
-// Re-export with config support
-export { getAllServers as getServersForFile };