pi-lens 2.2.9 → 3.0.0

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

@@ -0,0 +1,209 @@
+/**
+ * LSP Configuration Test Suite
+ * 
+ * Tests for configuration including:
+ * - Config file loading
+ * - Custom server creation
+ * - Server registry management
+ * - Disabled server handling
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// Mock fs/promises before importing the module under test
+vi.mock("fs/promises", async () => {
+	return {
+		readFile: vi.fn(),
+		access: vi.fn(),
+		stat: vi.fn(),
+	};
+});
+
+// Import after mocking
+const { loadLSPConfig, createCustomServer, initLSPConfig, getAllServers, isServerDisabled, getServersForFileWithConfig } = await import("../config.js");
+
+const mockReadFile = vi.mocked(fs.readFile);
+
+describe("loadLSPConfig", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("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("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("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("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__/error-recovery.test.ts

@@ -0,0 +1,279 @@
+/**
+ * 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, type LSPService, 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: LSPService;
+
+	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: LSPService;
+
+	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);
+		}
+	});
+});