pi-lens 3.2.0 → 3.3.1

package/clients/lsp/__tests__/client.test.ts

@@ -29,15 +29,7 @@ vi.mock("vscode-jsonrpc/node.js", () => ({
 	StreamMessageWriter: vi.fn(),
 }));
 
-vi.mock("../../bus/events.js", () => ({
-	DiagnosticFound: {
-		publish: vi.fn(),
-		subscribe: vi.fn(() => vi.fn()), // Returns unsubscribe function
-	},
-}));
-
 import { createMessageConnection } from "vscode-jsonrpc/node.js";
-import { DiagnosticFound } from "../../bus/events.js";
 
 describe("createLSPClient", () => {
 	let mockProcess: LSPProcess;
@@ -236,42 +228,6 @@ describe("createLSPClient", () => {
 			);
 		});
 
-		it("should publish diagnostics to bus", async () => {
-			await createLSPClient({
-				serverId: "test-server",
-				process: mockProcess,
-				root: "/test",
-			});
-
-			// Get the registered handler
-			const handler = mockConnection.onNotification.mock.calls.find(
-				(call: any) => call[0] === "textDocument/publishDiagnostics",
-			)?.[1];
-
-			expect(handler).toBeDefined();
-
-			// Simulate receiving diagnostics
-			const mockDiagnostics: LSPDiagnostic[] = [
-				{
-					severity: 1,
-					message: "Type error",
-					range: {
-						start: { line: 0, character: 0 },
-						end: { line: 0, character: 5 },
-					},
-					code: "TS2345",
-				},
-			];
-
-			// Call handler directly (would be debounced in real scenario)
-			handler?.({ uri: "file:///test/file.ts", diagnostics: mockDiagnostics });
-
-			// Advance past debounce (150ms)
-			await vi.advanceTimersByTimeAsync(200);
-
-			expect(DiagnosticFound.publish).toHaveBeenCalled();
-		});
-
 		it.skip("should store diagnostics for retrieval", async () => {
 			const client = await createLSPClient({
 				serverId: "test-server",
@@ -320,8 +276,7 @@ describe("createLSPClient", () => {
 				root: "/test",
 			});
 
-			// waitForDiagnostics uses bus subscription + setTimeout for timeout
-			// With fake timers, we need to advance time to trigger the timeout
+			// waitForDiagnostics resolves via timeout when no notification arrives
 			const promise = client.waitForDiagnostics("/test/file.ts", 100);
 			await vi.advanceTimersByTimeAsync(150);
 			await promise;

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

@@ -0,0 +1,167 @@
+/**
+ * LSP Configuration Test Suite
+ *
+ * Tests for configuration including:
+ * - Config file loading
+ * - Custom server creation
+ * - Server registry management
+ * - Disabled server handling
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+// Mock fs/promises before any imports that use it
+const mockReadFile = vi.fn();
+const mockAccess = vi.fn();
+const mockStat = vi.fn();
+vi.mock("node:fs/promises", async () => {
+    return {
+        readFile: mockReadFile,
+        access: mockAccess,
+        stat: mockStat,
+    };
+});
+// Import after mocking - mocks are already defined above
+const { loadLSPConfig, createCustomServer, initLSPConfig, getAllServers, isServerDisabled, getServersForFileWithConfig, } = await import("../config.js");
+describe("loadLSPConfig", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it.skip("should load config from .pi-lens/lsp.json", async () => {
+        const config = {
+            servers: {
+                "my-server": {
+                    name: "My Custom Server",
+                    extensions: [".myext"],
+                    command: "my-lsp",
+                    args: ["--stdio"],
+                },
+            },
+        };
+        mockReadFile.mockResolvedValue(JSON.stringify(config));
+        const result = await loadLSPConfig("/project");
+        expect(result).toEqual(config);
+        expect(mockReadFile).toHaveBeenCalled();
+    });
+    it("should return empty config when file not found", async () => {
+        mockReadFile.mockRejectedValue(new Error("ENOENT"));
+        const result = await loadLSPConfig("/project");
+        expect(result).toEqual({});
+    });
+    it("should handle invalid JSON gracefully", async () => {
+        mockReadFile.mockResolvedValue("not valid json");
+        const result = await loadLSPConfig("/project");
+        expect(result).toEqual({});
+    });
+    it.skip("should try multiple config paths", async () => {
+        mockReadFile
+            .mockRejectedValueOnce(new Error("ENOENT"))
+            .mockRejectedValueOnce(new Error("ENOENT"))
+            .mockResolvedValueOnce(JSON.stringify({ servers: {} }));
+        const result = await loadLSPConfig("/project");
+        expect(mockReadFile).toHaveBeenCalledTimes(3);
+        expect(result).toEqual({ servers: {} });
+    });
+});
+describe("createCustomServer", () => {
+    it("should create server from config", () => {
+        const config = {
+            name: "Custom LSP",
+            extensions: [".custom"],
+            command: "custom-lsp",
+            args: ["--stdio", "--verbose"],
+            rootMarkers: [".customrc"],
+        };
+        const server = createCustomServer(config, "custom-server");
+        expect(server.id).toBe("custom-server");
+        expect(server.name).toBe("Custom LSP");
+        expect(server.extensions).toEqual([".custom"]);
+        expect(typeof server.spawn).toBe("function");
+        expect(typeof server.root).toBe("function");
+    });
+    it("should use process.cwd() as root when no markers specified", async () => {
+        const config = {
+            name: "Simple LSP",
+            extensions: [".simple"],
+            command: "simple-lsp",
+        };
+        const server = createCustomServer(config, "simple");
+        const root = await server.root("/any/path/file.simple");
+        expect(root).toBe(process.cwd());
+    });
+});
+describe("initLSPConfig", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Reset by calling init with empty config
+        mockReadFile.mockRejectedValue(new Error("ENOENT"));
+        return initLSPConfig("/test-reset");
+    });
+    it("should initialize with empty config", async () => {
+        mockReadFile.mockRejectedValue(new Error("ENOENT"));
+        await initLSPConfig("/project");
+        const servers = getAllServers();
+        // Should have built-in servers
+        expect(servers.some((s) => s.id === "typescript")).toBe(true);
+    });
+    it.skip("should register custom servers from config", async () => {
+        const config = {
+            servers: {
+                "custom-test-server": {
+                    name: "Custom Test Server",
+                    extensions: [".ctest"],
+                    command: "ctest-lsp",
+                },
+            },
+        };
+        mockReadFile.mockResolvedValue(JSON.stringify(config));
+        await initLSPConfig("/project");
+        const servers = getAllServers();
+        expect(servers.some((s) => s.id === "custom-test-server")).toBe(true);
+    });
+    it.skip("should handle disabled servers", async () => {
+        const config = {
+            disabledServers: ["python"],
+        };
+        mockReadFile.mockResolvedValue(JSON.stringify(config));
+        await initLSPConfig("/project");
+        expect(isServerDisabled("python")).toBe(true);
+        expect(isServerDisabled("typescript")).toBe(false);
+    });
+});
+describe("getAllServers", () => {
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        mockReadFile.mockRejectedValue(new Error("ENOENT"));
+        await initLSPConfig("/test");
+    });
+    it("should include built-in servers", () => {
+        const servers = getAllServers();
+        expect(servers.some((s) => s.id === "typescript")).toBe(true);
+        expect(servers.some((s) => s.id === "python")).toBe(true);
+        expect(servers.some((s) => s.id === "go")).toBe(true);
+        expect(servers.some((s) => s.id === "rust")).toBe(true);
+    });
+});
+describe("getServersForFileWithConfig", () => {
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        mockReadFile.mockRejectedValue(new Error("ENOENT"));
+        await initLSPConfig("/test");
+    });
+    it("should find TypeScript server for .ts files", () => {
+        const servers = getServersForFileWithConfig("/project/file.ts");
+        expect(servers.some((s) => s.id === "typescript")).toBe(true);
+    });
+    it("should find Python server for .py files", () => {
+        const servers = getServersForFileWithConfig("/project/file.py");
+        expect(servers.some((s) => s.id === "python")).toBe(true);
+    });
+    it("should return empty array for unknown file type", () => {
+        const servers = getServersForFileWithConfig("/project/file.unknown");
+        expect(servers).toEqual([]);
+    });
+    it("should be case insensitive for extensions", () => {
+        const servers1 = getServersForFileWithConfig("/project/file.TS");
+        const servers2 = getServersForFileWithConfig("/project/file.ts");
+        expect(servers1.map((s) => s.id)).toEqual(servers2.map((s) => s.id));
+    });
+});

package/clients/lsp/__tests__/error-recovery.test.js

@@ -0,0 +1,213 @@
+/**
+ * LSP Error Recovery Tests
+ *
+ * Tests for LSP failure scenarios and recovery mechanisms.
+ * Critical for stability in real-world usage.
+ */
+import { Effect } from "effect";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getLSPService, resetLSPService } from "../index.js";
+// Check if we should run real LSP tests
+const runRealLSPTests = process.env.RUN_REAL_LSP_TESTS === "true";
+describe("LSP Error Recovery", () => {
+    let service;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    describe("Spawn Failures", () => {
+        it("should handle LSP spawn failure gracefully", async () => {
+            // Simulate spawn failure by using invalid command
+            const result = await service.hasLSP("/test/invalid-file.xyz");
+            // Should return false without throwing
+            expect(result).toBe(false);
+        });
+        it("should handle missing LSP server binary", async () => {
+            // Test with a file type that has no installed LSP
+            const result = await service.hasLSP("/test/file.unknown");
+            expect(result).toBe(false);
+        });
+        it("should handle permission denied on spawn", async () => {
+            // This would require mocking at a lower level
+            // For now, just verify it doesn't crash
+            await expect(service.openFile("/test.ts", "content")).resolves.not.toThrow();
+        });
+    });
+    describe("Runtime Crashes", () => {
+        it("should handle LSP crash during operation", async () => {
+            // Open a file first
+            await service.openFile("/test.ts", "const x = 1;");
+            // Simulate crash by shutting down abruptly
+            await service.shutdown();
+            // Subsequent operations should handle gracefully
+            const diags = await service.getDiagnostics("/test.ts");
+            expect(diags).toEqual([]);
+        });
+        it("should handle multiple rapid shutdown calls", async () => {
+            // First shutdown
+            await expect(service.shutdown()).resolves.not.toThrow();
+            // Second shutdown should also not throw
+            await expect(service.shutdown()).resolves.not.toThrow();
+            // Third shutdown
+            await expect(service.shutdown()).resolves.not.toThrow();
+        });
+        it("should handle getDiagnostics on crashed server", async () => {
+            // Get diagnostics without opening (simulates crash state)
+            const diags = await service.getDiagnostics("/nonexistent/crashed.ts");
+            expect(diags).toEqual([]);
+        });
+    });
+    describe("Root Detection Edge Cases", () => {
+        it("should exclude .pi-lens from root detection", async () => {
+            // This was a real bug where .pi-lens/tools/package.json was found as root
+            // We verify the config excludes .pi-lens
+            const { getAllServers } = await import("../config.js");
+            const servers = getAllServers();
+            // Should return array (verification that config loads)
+            expect(Array.isArray(servers)).toBe(true);
+        });
+        it("should handle deeply nested file paths", async () => {
+            const deepPath = "/very/deep/nested/path/to/the/file.ts";
+            // Should not throw on deep paths
+            await expect(service.openFile(deepPath, "content")).resolves.not.toThrow();
+            await expect(service.getDiagnostics(deepPath)).resolves.not.toThrow();
+        });
+        it("should handle paths with special characters", async () => {
+            const specialPaths = [
+                "/path with spaces/file.ts",
+                "/path-with-dashes/file.ts",
+                "/path_with_underscores/file.ts",
+                "/path.with.dots/file.ts",
+            ];
+            for (const path of specialPaths) {
+                await expect(service.openFile(path, "content")).resolves.not.toThrow();
+            }
+        });
+    });
+    describe("Timeout Handling", () => {
+        it("should handle slow LSP operations", async () => {
+            // Create a mock slow operation
+            const slowPromise = new Promise((resolve) => {
+                setTimeout(() => resolve("done"), 5000);
+            });
+            // Should not hang indefinitely
+            const timeoutPromise = Promise.race([
+                slowPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 100)),
+            ]);
+            await expect(timeoutPromise).rejects.toThrow("Timeout");
+        });
+        it("should handle hanging getDiagnostics", async () => {
+            // Start diagnostics request
+            const diagPromise = service.getDiagnostics("/test.ts");
+            // Should complete (even if empty) within reasonable time
+            const result = await Promise.race([
+                diagPromise,
+                new Promise((resolve) => setTimeout(() => resolve("timeout"), 1000)),
+            ]);
+            // Either completes or times out gracefully
+            expect(result).toBeDefined();
+        });
+    });
+    describe("Multiple LSP Coordination", () => {
+        it("should handle multiple LSPs running simultaneously", async () => {
+            // This tests that multiple LSP servers don't interfere
+            const files = [
+                { path: "/test.ts", content: "const x: number = 1;" },
+                { path: "/test.py", content: "x = 1" },
+                { path: "/test.rs", content: "let x = 1;" },
+            ];
+            // Open multiple files
+            for (const file of files) {
+                await expect(service.openFile(file.path, file.content)).resolves.not.toThrow();
+            }
+            // Get diagnostics for all
+            for (const file of files) {
+                const diags = await service.getDiagnostics(file.path);
+                expect(Array.isArray(diags)).toBe(true);
+            }
+        });
+        it("should handle rapid file switching", async () => {
+            const files = ["/a.ts", "/b.ts", "/c.ts"];
+            // Rapidly switch between files
+            for (let i = 0; i < 10; i++) {
+                const file = files[i % files.length];
+                await service.openFile(file, `content ${i}`);
+                await service.getDiagnostics(file);
+            }
+            // Should not crash or hang
+            expect(true).toBe(true);
+        });
+    });
+    describe("Effect Integration Error Handling", () => {
+        it("should handle errors in Effect context", async () => {
+            const { lspEffect } = await import("../index.js");
+            // Try to get LSP for non-existent file type
+            const { hasLSP } = lspEffect(service);
+            const program = hasLSP("/test.unknownxyz");
+            // Should complete without throwing
+            const result = await Effect.runPromise(program);
+            expect(typeof result).toBe("boolean");
+        });
+        it("should recover from Effect failures", async () => {
+            const { lspEffect } = await import("../index.js");
+            // Shutdown then try operations
+            await service.shutdown();
+            const { shutdown } = lspEffect(service);
+            const program = shutdown();
+            // Should not throw even after shutdown
+            await expect(Effect.runPromise(program)).resolves.not.toThrow();
+        });
+    });
+});
+// Real server tests - these require actual LSP servers
+// These catch real-world issues like the ESLintServer spawn error
+describe.skipIf(!runRealLSPTests)("Real Server Error Recovery", () => {
+    let service;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    it("should handle real TypeScript LSP spawn", async () => {
+        const hasTsLsp = await service.hasLSP("/test.ts");
+        if (hasTsLsp) {
+            // If installed, should be able to open and diagnose
+            await service.openFile("/test.ts", "const x: string = 1;");
+            const diags = await service.getDiagnostics("/test.ts");
+            // Should get type error
+            expect(diags.length).toBeGreaterThan(0);
+            expect(diags[0].message).toContain("Type");
+        }
+    });
+    it("should handle real Python LSP spawn", async () => {
+        const hasPyLsp = await service.hasLSP("/test.py");
+        if (hasPyLsp) {
+            await service.openFile("/test.py", "x = 1\nprint(y)"); // y is undefined
+            const diags = await service.getDiagnostics("/test.py");
+            // Should have errors about undefined y
+            expect(diags.length).toBeGreaterThan(0);
+        }
+    });
+    it("should restart crashed LSP server", async () => {
+        const hasTsLsp = await service.hasLSP("/test.ts");
+        if (hasTsLsp) {
+            // Open file
+            await service.openFile("/test.ts", "const x = 1;");
+            // Get diagnostics (server should be running)
+            const _diags1 = await service.getDiagnostics("/test.ts");
+            // Shutdown (simulates crash)
+            await service.shutdown();
+            // Try to use again - should handle gracefully
+            const diags2 = await service.getDiagnostics("/test.ts");
+            expect(Array.isArray(diags2)).toBe(true);
+        }
+    });
+});

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

@@ -0,0 +1,127 @@
+/**
+ * LSP Integration Test Suite
+ *
+ * End-to-end tests for the LSP system including:
+ * - Full workflow: detect -> spawn -> open -> diagnose -> shutdown
+ * - Multiple server coordination
+ * - Error recovery scenarios
+ * - Real TypeScript server integration (optional)
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { getLSPService, resetLSPService } from "../index.js";
+import { Effect } from "effect";
+// Check if we should run real LSP tests
+const runRealLSPTests = process.env.RUN_REAL_LSP_TESTS === "true";
+describe("LSP Integration", () => {
+    let service;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    describe("Service Lifecycle", () => {
+        it("should handle complete lifecycle without errors", async () => {
+            // This is a basic smoke test
+            const hasLSP = await service.hasLSP("/test.ts");
+            // Result depends on whether TypeScript LSP is installed
+            // Just verify it doesn't throw
+            expect(typeof hasLSP).toBe("boolean");
+        });
+        it("should handle multiple shutdown calls gracefully", async () => {
+            // First shutdown
+            await expect(service.shutdown()).resolves.not.toThrow();
+            // Second shutdown should also not throw
+            await expect(service.shutdown()).resolves.not.toThrow();
+        });
+        it("should report status correctly", async () => {
+            const status = service.getStatus();
+            // Should return array (may be empty if no clients active)
+            expect(Array.isArray(status)).toBe(true);
+        });
+    });
+    describe("Effect Integration", () => {
+        it("should run hasLSP effect successfully", async () => {
+            const { hasLSP } = await import("../index.js").then((m) => m.lspEffect(service));
+            const program = hasLSP("/test.ts");
+            const result = await Effect.runPromise(program);
+            expect(typeof result).toBe("boolean");
+        });
+        it("should run shutdown effect successfully", async () => {
+            const { shutdown } = await import("../index.js").then((m) => m.lspEffect(service));
+            const program = shutdown();
+            const result = await Effect.runPromise(program);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle operations on non-existent files", async () => {
+            await expect(service.openFile("/nonexistent/file.ts", "content"))
+                .resolves.not.toThrow();
+        });
+        it("should handle getDiagnostics on non-existent files", async () => {
+            const diags = await service.getDiagnostics("/nonexistent/file.ts");
+            expect(diags).toEqual([]);
+        });
+        it("should handle updateFile on non-existent files", async () => {
+            await expect(service.updateFile("/nonexistent/file.ts", "new content"))
+                .resolves.not.toThrow();
+        });
+    });
+});
+// Real server tests - these require actual LSP servers to be installed
+// Run with: RUN_REAL_LSP_TESTS=true npm test
+describe.skipIf(!runRealLSPTests)("Real Server Tests", () => {
+    let service;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    it("should detect TypeScript LSP if available", async () => {
+        const hasLSP = await service.hasLSP(process.cwd() + "/test.ts");
+        if (hasLSP) {
+            console.log("✅ TypeScript LSP detected");
+        }
+        else {
+            console.log("⚠️ TypeScript LSP not available");
+        }
+    });
+});
+describe("Concurrent Operations", () => {
+    let service;
+    beforeEach(() => {
+        resetLSPService();
+        service = getLSPService();
+    });
+    afterEach(async () => {
+        await service.shutdown();
+        resetLSPService();
+    });
+    it("should handle concurrent hasLSP checks", async () => {
+        const checks = [
+            service.hasLSP("/file1.ts"),
+            service.hasLSP("/file2.ts"),
+            service.hasLSP("/file3.ts"),
+        ];
+        const results = await Promise.all(checks);
+        expect(results).toHaveLength(3);
+        results.forEach((r) => expect(typeof r).toBe("boolean"));
+    });
+    it("should handle concurrent diagnostics requests", async () => {
+        // These should not throw even if files don't exist
+        const requests = [
+            service.getDiagnostics("/file1.ts"),
+            service.getDiagnostics("/file2.ts"),
+            service.getDiagnostics("/file3.ts"),
+        ];
+        const results = await Promise.all(requests);
+        expect(results).toHaveLength(3);
+        results.forEach((r) => expect(Array.isArray(r)).toBe(true));
+    });
+});