pi-lens 3.2.0 → 3.3.1

package/clients/lsp/__tests__/service.test.js

@@ -0,0 +1,435 @@
+/**
+ * LSP Service Test Suite
+ *
+ * Tests for the LSP Service layer including:
+ * - Client lifecycle management
+ * - Effect-TS integration
+ * - File operations (open/update/getDiagnostics)
+ * - Server availability checking
+ * - Cleanup and shutdown
+ */
+import { Effect } from "effect";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { getLSPService, LSPService, lspEffect, resetLSPService, } from "../index.js";
+// Mock the dependencies
+vi.mock("../server.js", async () => {
+    const actual = await vi.importActual("../server.js");
+    return {
+        ...actual,
+        getServersForFileWithConfig: vi.fn(),
+    };
+});
+vi.mock("../config.js", () => ({
+    initLSPConfig: vi.fn(),
+    getServersForFileWithConfig: vi.fn(),
+}));
+vi.mock("../language.js", () => ({
+    getLanguageId: vi.fn(() => "typescript"),
+}));
+vi.mock("../launch.js", () => ({
+    launchLSP: vi.fn(),
+}));
+vi.mock("../client.js", () => ({
+    createLSPClient: vi.fn(),
+}));
+import { createLSPClient as mockCreateLSPClient } from "../client.js";
+import { getServersForFileWithConfig as mockGetServersForFile } from "../config.js";
+describe("LSPService", () => {
+    let service;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    describe("constructor", () => {
+        it("should initialize with empty state", () => {
+            const status = service.getStatus();
+            expect(status).toEqual([]);
+        });
+        it("should create fresh LSPState", () => {
+            // Verify service was created with initial state
+            expect(service).toBeDefined();
+            expect(service).toBeInstanceOf(LSPService);
+        });
+    });
+    describe("hasLSP", () => {
+        it("should return false when no servers match file extension", async () => {
+            vi.mocked(mockGetServersForFile).mockReturnValue([]);
+            const result = await service.hasLSP("/test/file.unknown");
+            expect(result).toBe(false);
+        });
+        it("should return true when server matches and provides root", async () => {
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn(),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            const result = await service.hasLSP("/project/test.ts");
+            expect(result).toBe(true);
+        });
+        it("should return false when server cannot determine root", async () => {
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue(undefined),
+                spawn: vi.fn(),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            const result = await service.hasLSP("/project/test.ts");
+            expect(result).toBe(false);
+        });
+        it("should check all matching servers until root is found", async () => {
+            const server1 = {
+                id: "server1",
+                name: "Server 1",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue(undefined),
+                spawn: vi.fn(),
+            };
+            const server2 = {
+                id: "server2",
+                name: "Server 2",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn(),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([server1, server2]);
+            const result = await service.hasLSP("/project/test.ts");
+            expect(result).toBe(true);
+            expect(server1.root).toHaveBeenCalled();
+            expect(server2.root).toHaveBeenCalled();
+        });
+    });
+    describe("getClientForFile", () => {
+        it("should return undefined when no servers match", async () => {
+            vi.mocked(mockGetServersForFile).mockReturnValue([]);
+            const result = await service.getClientForFile("/test/file.unknown");
+            expect(result).toBeUndefined();
+        });
+        it("should cache and reuse existing client", async () => {
+            const mockClient = createMockClient();
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({
+                    process: { pid: 123 },
+                }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            // First call creates client
+            const result1 = await service.getClientForFile("/project/test.ts");
+            expect(result1).toBeDefined();
+            expect(mockCreateLSPClient).toHaveBeenCalledTimes(1);
+            // Second call returns cached client
+            const result2 = await service.getClientForFile("/project/other.ts");
+            expect(result2?.client).toBe(result1?.client);
+            expect(mockCreateLSPClient).toHaveBeenCalledTimes(1); // Not called again
+        });
+        it("should handle server spawn failure", async () => {
+            const mockSpawn = vi.fn().mockRejectedValue(new Error("Spawn failed"));
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: mockSpawn,
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            const result = await service.getClientForFile("/project/test.ts");
+            expect(result).toBeUndefined();
+        });
+        it("should try next server when first fails", async () => {
+            const mockClient = createMockClient();
+            const failingServer = {
+                id: "server1",
+                name: "Failing Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockRejectedValue(new Error("Spawn failed")),
+            };
+            const workingServer = {
+                id: "server2",
+                name: "Working Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({
+                    process: { pid: 456 },
+                }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([
+                failingServer,
+                workingServer,
+            ]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            const result = await service.getClientForFile("/project/test.ts");
+            expect(result).toBeDefined();
+            expect(result?.info.id).toBe("server2");
+        });
+    });
+    describe("openFile", () => {
+        it("should send didOpen notification with correct parameters", async () => {
+            const mockClient = createMockClient();
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({
+                    process: { pid: 123 },
+                }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            await service.openFile("/project/test.ts", "const x = 1;");
+            expect(mockClient.notify.open).toHaveBeenCalledWith("/project/test.ts", "const x = 1;", "typescript");
+        });
+        it("should do nothing when no LSP available", async () => {
+            vi.mocked(mockGetServersForFile).mockReturnValue([]);
+            // Should not throw
+            await expect(service.openFile("/test.unknown", "content")).resolves.not.toThrow();
+        });
+    });
+    describe("updateFile", () => {
+        it("should send didChange notification", async () => {
+            const mockClient = createMockClient();
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({
+                    process: { pid: 123 },
+                }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            await service.updateFile("/project/test.ts", "const x = 2;");
+            expect(mockClient.notify.change).toHaveBeenCalledWith("/project/test.ts", "const x = 2;");
+        });
+    });
+    describe("getDiagnostics", () => {
+        it("should return diagnostics from client", async () => {
+            const mockDiagnostics = [
+                {
+                    severity: 1,
+                    message: "Type error",
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 5 },
+                    },
+                },
+            ];
+            const mockClient = createMockClient(mockDiagnostics);
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({
+                    process: { pid: 123 },
+                }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            const result = await service.getDiagnostics("/project/test.ts");
+            expect(result).toEqual(mockDiagnostics);
+            expect(mockClient.waitForDiagnostics).toHaveBeenCalled();
+        });
+        it("should return empty array when no LSP available", async () => {
+            vi.mocked(mockGetServersForFile).mockReturnValue([]);
+            const result = await service.getDiagnostics("/test.unknown");
+            expect(result).toEqual([]);
+        });
+    });
+    describe("shutdown", () => {
+        it("should shutdown all clients", async () => {
+            const mockClient1 = createMockClient();
+            const mockClient2 = createMockClient();
+            // Add clients to service
+            const mockServer1 = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project1"),
+                spawn: vi.fn().mockResolvedValue({ process: { pid: 1 } }),
+            };
+            const mockServer2 = {
+                id: "python",
+                name: "Python Server",
+                extensions: [".py"],
+                root: vi.fn().mockResolvedValue("/project2"),
+                spawn: vi.fn().mockResolvedValue({ process: { pid: 2 } }),
+            };
+            vi.mocked(mockGetServersForFile)
+                .mockReturnValueOnce([mockServer1])
+                .mockReturnValueOnce([mockServer2]);
+            vi.mocked(mockCreateLSPClient)
+                .mockResolvedValueOnce(mockClient1)
+                .mockResolvedValueOnce(mockClient2);
+            // Create clients
+            await service.getClientForFile("/project1/test.ts");
+            await service.getClientForFile("/project2/test.py");
+            await service.shutdown();
+            expect(mockClient1.shutdown).toHaveBeenCalled();
+            expect(mockClient2.shutdown).toHaveBeenCalled();
+        });
+        it("should handle shutdown errors gracefully", async () => {
+            const mockClient = createMockClient();
+            mockClient.shutdown.mockRejectedValue(new Error("Shutdown failed"));
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({ process: { pid: 123 } }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            await service.getClientForFile("/project/test.ts");
+            // Should not throw even when client shutdown fails
+            await expect(service.shutdown()).resolves.not.toThrow();
+        });
+    });
+    describe("getStatus", () => {
+        it("should return status of all active clients", async () => {
+            const mockClient = createMockClient();
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({ process: { pid: 123 } }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            await service.getClientForFile("/project/test.ts");
+            const status = service.getStatus();
+            expect(status).toHaveLength(1);
+            expect(status[0]).toEqual({
+                serverId: "typescript",
+                root: "/project",
+                connected: true,
+            });
+        });
+    });
+});
+describe("lspEffect", () => {
+    let service;
+    let effect;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+        effect = lspEffect(service);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    describe("openFile Effect", () => {
+        it("should wrap openFile in Effect", async () => {
+            const mockClient = createMockClient();
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({ process: { pid: 123 } }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            const program = effect.openFile("/project/test.ts", "content");
+            const result = await Effect.runPromise(program);
+            expect(result).toBeUndefined();
+            expect(mockClient.notify.open).toHaveBeenCalled();
+        });
+        it("should handle errors in Effect", async () => {
+            vi.mocked(mockGetServersForFile).mockReturnValue([]);
+            const program = effect.openFile("/test.unknown", "content");
+            // Should complete successfully (no-op for unknown files)
+            await expect(Effect.runPromise(program)).resolves.not.toThrow();
+        });
+    });
+    describe("getDiagnostics Effect", () => {
+        it("should wrap getDiagnostics in Effect", async () => {
+            const mockDiagnostics = [
+                {
+                    severity: 1,
+                    message: "Error",
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 1 },
+                    },
+                },
+            ];
+            const mockClient = createMockClient(mockDiagnostics);
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn().mockResolvedValue({ process: { pid: 123 } }),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            vi.mocked(mockCreateLSPClient).mockResolvedValue(mockClient);
+            const program = effect.getDiagnostics("/project/test.ts");
+            const result = await Effect.runPromise(program);
+            expect(result).toEqual(mockDiagnostics);
+        });
+    });
+    describe("hasLSP Effect", () => {
+        it("should wrap hasLSP in Effect", async () => {
+            const mockServer = {
+                id: "typescript",
+                name: "TypeScript Server",
+                extensions: [".ts"],
+                root: vi.fn().mockResolvedValue("/project"),
+                spawn: vi.fn(),
+            };
+            vi.mocked(mockGetServersForFile).mockReturnValue([mockServer]);
+            const program = effect.hasLSP("/project/test.ts");
+            const result = await Effect.runPromise(program);
+            expect(result).toBe(true);
+        });
+    });
+    describe("shutdown Effect", () => {
+        it("should wrap shutdown in Effect", async () => {
+            const program = effect.shutdown();
+            const result = await Effect.runPromise(program);
+            expect(result).toBeUndefined();
+        });
+    });
+});
+// Helper function to create mock client
+function createMockClient(diagnostics = []) {
+    return {
+        serverId: "test-server",
+        root: "/test",
+        connection: {},
+        notify: {
+            open: vi.fn().mockResolvedValue(undefined),
+            change: vi.fn().mockResolvedValue(undefined),
+        },
+        getDiagnostics: vi.fn().mockReturnValue(diagnostics),
+        getAllDiagnostics: vi.fn().mockReturnValue(new Map()),
+        waitForDiagnostics: vi.fn().mockResolvedValue(undefined),
+        definition: vi.fn().mockResolvedValue([]),
+        references: vi.fn().mockResolvedValue([]),
+        hover: vi.fn().mockResolvedValue(null),
+        documentSymbol: vi.fn().mockResolvedValue([]),
+        workspaceSymbol: vi.fn().mockResolvedValue([]),
+        implementation: vi.fn().mockResolvedValue([]),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+    };
+}

package/clients/lsp/client.js

@@ -7,12 +7,12 @@
  * - 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 { DiagnosticFound } from "../bus/events.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 // --- Constants ---
-const DIAGNOSTICS_DEBOUNCE_MS = 150;
+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) {
@@ -22,6 +22,11 @@ export async function createLSPClient(options) {
     // 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);
@@ -33,28 +38,8 @@ export async function createLSPClient(options) {
         const timer = setTimeout(() => {
             diagnostics.set(filePath, newDiags);
             pendingDiagnostics.delete(filePath);
-            // Publish to bus
-            // Defensive: filter out malformed diagnostics that may lack range
-            const validDiags = newDiags.filter((d) => d.range?.start?.line !== undefined);
-            DiagnosticFound.publish({
-                runnerId: serverId,
-                filePath,
-                diagnostics: validDiags.map((d) => ({
-                    id: `${serverId}:${d.code ?? "unknown"}:${d.range.start.line}`,
-                    message: d.message,
-                    filePath,
-                    line: d.range.start.line + 1,
-                    column: d.range.start.character + 1,
-                    severity: severityFromNumber(d.severity),
-                    semantic: d.severity === 1
-                        ? "blocking"
-                        : d.severity === 2
-                            ? "warning"
-                            : "silent",
-                    tool: serverId,
-                })),
-                durationMs: 0,
-            });
+            // Signal any active waitForDiagnostics calls for this file.
+            diagnosticEmitter.emit("diagnostics", filePath);
         }, DIAGNOSTICS_DEBOUNCE_MS);
         pendingDiagnostics.set(filePath, timer);
     });
@@ -88,10 +73,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,
@@ -171,29 +153,33 @@ export async function createLSPClient(options) {
         },
         async waitForDiagnostics(filePath, timeoutMs = 10000) {
             const normalizedPath = normalizeMapKey(filePath);
+            // Fast path: diagnostics already available
             if (diagnostics.has(normalizedPath))
                 return;
-            // Use bus subscription like OpenCode - more reliable than polling
             return new Promise((resolve) => {
                 let debounceTimer;
-                // Subscribe to diagnostic events from this server
-                const unsub = DiagnosticFound.subscribe((event) => {
-                    if (event.properties.filePath === normalizedPath &&
-                        event.properties.runnerId === serverId) {
-                        // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
-                        if (debounceTimer)
-                            clearTimeout(debounceTimer);
-                        debounceTimer = setTimeout(() => {
-                            unsub();
-                            clearTimeout(timeout);
-                            resolve();
-                        }, DIAGNOSTICS_DEBOUNCE_MS);
-                    }
-                });
+                // 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);
-                    unsub();
+                    diagnosticEmitter.off("diagnostics", onDiagnostics);
                     resolve();
                 }, timeoutMs);
             });
@@ -283,6 +269,8 @@ export async function createLSPClient(options) {
                 clearTimeout(timer);
             }
             pendingDiagnostics.clear();
+            // Remove all diagnostic listeners (cancels any in-flight waitForDiagnostics)
+            diagnosticEmitter.removeAllListeners();
             // Graceful shutdown
             try {
                 await connection.sendRequest("shutdown");