pi-lens 3.1.2 → 3.2.0

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

@@ -1,213 +0,0 @@
-/**
- * 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

@@ -1,127 +0,0 @@
-/**
- * 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));
-    });
-});

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

@@ -1,260 +0,0 @@
-/**
- * LSP Launch Utilities Test Suite
- *
- * Tests for launching LSP servers including:
- * - Direct binary execution
- * - Package manager execution (npx/bun)
- * - Node.js script execution
- * - Python module execution
- * - Process cleanup
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { spawn } from "child_process";
-import { launchLSP, launchViaPackageManager, launchViaNode, launchViaPython, stopLSP, } from "../launch.js";
-// Mock child_process
-vi.mock("child_process", () => ({
-    spawn: vi.fn(),
-}));
-const mockSpawn = vi.mocked(spawn);
-// Helper to create mock child process
-function createMockChildProcess(pid = 123) {
-    return {
-        pid,
-        stdin: { write: vi.fn() },
-        stdout: { on: vi.fn(), pipe: vi.fn() },
-        stderr: { on: vi.fn(), pipe: vi.fn() },
-        kill: vi.fn(),
-        on: vi.fn(),
-        connected: true,
-    };
-}
-describe("launchLSP", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should spawn process with correct parameters", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchLSP("typescript-language-server", ["--stdio"], { cwd: "/test" });
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd, args, options] = mockSpawn.mock.calls[0];
-        // Command should be provided (format depends on platform)
-        expect(cmd).toBeTruthy();
-        expect(options).toMatchObject({
-            cwd: "/test",
-            stdio: ["pipe", "pipe", "pipe"],
-            detached: false,
-            windowsHide: true,
-        });
-    });
-    it("should merge environment variables", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        const customEnv = { CUSTOM_VAR: "value" };
-        launchLSP("server", [], { env: customEnv });
-        const [, , options] = mockSpawn.mock.calls[0];
-        expect(options?.env).toMatchObject({
-            CUSTOM_VAR: "value",
-        });
-    });
-    it("should return LSPProcess with all streams", async () => {
-        const mockProcess = createMockChildProcess(456);
-        mockSpawn.mockReturnValue(mockProcess);
-        const result = launchLSP("server", [], {});
-        expect(result.pid).toBe(456);
-        expect(result.stdin).toBeDefined();
-        expect(result.stdout).toBeDefined();
-        expect(result.stderr).toBeDefined();
-    });
-    it("should throw if stdin is not available", async () => {
-        const mockProcess = { ...createMockChildProcess(), stdin: null };
-        mockSpawn.mockReturnValue(mockProcess);
-        expect(() => launchLSP("server", [], {})).toThrow("Failed to spawn LSP server");
-    });
-    it("should throw if stdout is not available", async () => {
-        const mockProcess = { ...createMockChildProcess(), stdout: null };
-        mockSpawn.mockReturnValue(mockProcess);
-        expect(() => launchLSP("server", [], {})).toThrow("Failed to spawn LSP server");
-    });
-    it("should throw if stderr is not available", async () => {
-        const mockProcess = { ...createMockChildProcess(), stderr: null };
-        mockSpawn.mockReturnValue(mockProcess);
-        expect(() => launchLSP("server", [], {})).toThrow("Failed to spawn LSP server");
-    });
-    it("should default to process.cwd() when cwd not provided", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchLSP("server", [], {});
-        const [, , options] = mockSpawn.mock.calls[0];
-        expect(options?.cwd).toBe(process.cwd());
-    });
-    it("should use shell mode on Windows for .cmd files", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        // Save original platform
-        const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
-        Object.defineProperty(process, "platform", { value: "win32" });
-        try {
-            launchLSP("server.cmd", ["--arg"], {});
-            const [, , options] = mockSpawn.mock.calls[0];
-            expect(options?.shell).toBe(true);
-        }
-        finally {
-            // Restore original platform
-            if (originalPlatform) {
-                Object.defineProperty(process, "platform", originalPlatform);
-            }
-        }
-    });
-});
-describe("launchViaPackageManager", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Clear BUN_INSTALL env var
-        delete process.env.BUN_INSTALL;
-    });
-    it("should spawn via package manager", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPackageManager("typescript-language-server", ["--stdio"], {});
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd] = mockSpawn.mock.calls[0];
-        // Command should contain npx or bun
-        expect(String(cmd)).toMatch(/npx|bun/);
-    });
-    it("should use bun when BUN_INSTALL is set", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        process.env.BUN_INSTALL = "/path/to/bun";
-        launchViaPackageManager("typescript-language-server", ["--stdio"], {});
-        const [cmd, args] = mockSpawn.mock.calls[0];
-        // On Windows with shell mode, args may be concatenated into cmd
-        const cmdStr = String(cmd);
-        const hasBun = cmdStr.includes("bun") || (args && args.some((a) => a && a.includes("bun")));
-        const hasX = cmdStr.includes(" x ") || (args && args.includes("x"));
-        expect(hasBun).toBe(true);
-        // Note: 'x' arg may be in command string on Windows
-    });
-    it("should pass through options", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPackageManager("server", ["--flag"], { cwd: "/test" });
-        const [, , options] = mockSpawn.mock.calls[0];
-        expect(options?.cwd).toBe("/test");
-    });
-});
-describe("launchViaNode", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should spawn node with script path", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaNode("/path/to/script.js", ["--arg"], { cwd: "/test" });
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd, args, options] = mockSpawn.mock.calls[0];
-        // On Windows, command is combined; on Unix, it's separate
-        expect(String(cmd)).toContain("node");
-        expect(options?.cwd).toBe("/test");
-    });
-});
-describe("launchViaPython", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should spawn Python module", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPython("pylsp", [], {});
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd] = mockSpawn.mock.calls[0];
-        expect(String(cmd)).toMatch(/python|py/);
-    });
-    it("should pass args to module", async () => {
-        const mockProcess = createMockChildProcess();
-        mockSpawn.mockReturnValue(mockProcess);
-        launchViaPython("pylsp", ["--verbose", "--log-file", "/tmp/log"], {});
-        expect(mockSpawn).toHaveBeenCalled();
-        const [cmd, args] = mockSpawn.mock.calls[0];
-        // Args should include the module and the passed args
-        expect(args).toContain("-m");
-        expect(args).toContain("pylsp");
-        expect(args).toContain("--verbose");
-    });
-});
-describe("stopLSP", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.useFakeTimers({ shouldAdvanceTime: true });
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it("should send SIGTERM first", async () => {
-        const mockKill = vi.fn();
-        const exitHandlers = [];
-        const mockProcess = {
-            ...createMockChildProcess(),
-            kill: mockKill,
-            on: vi.fn((event, handler) => {
-                if (event === "exit") {
-                    exitHandlers.push(handler);
-                    // Simulate immediate exit
-                    setTimeout(() => handler(), 10);
-                }
-            }),
-        };
-        const stopPromise = stopLSP({
-            process: mockProcess,
-            stdin: {},
-            stdout: {},
-            stderr: {},
-            pid: 123,
-        });
-        // Let the exit handler fire
-        await new Promise(r => setTimeout(r, 20));
-        expect(mockKill).toHaveBeenCalledWith("SIGTERM");
-    });
-    it.skip("should send SIGKILL if process doesn't exit in time", async () => {
-        // This test is flaky with fake timers - skipping for now
-        // The actual implementation works correctly in production
-    }, 15000);
-    it("should resolve immediately on exit", async () => {
-        const mockProcess = {
-            ...createMockChildProcess(),
-            on: vi.fn((event, handler) => {
-                if (event === "exit") {
-                    // Call handler immediately
-                    handler();
-                }
-            }),
-        };
-        await expect(stopLSP({
-            process: mockProcess,
-            stdin: {},
-            stdout: {},
-            stderr: {},
-            pid: 123,
-        })).resolves.toBeUndefined();
-    });
-    it("should resolve on error event", async () => {
-        const mockProcess = {
-            ...createMockChildProcess(),
-            on: vi.fn((event, handler) => {
-                if (event === "error") {
-                    setTimeout(handler, 10);
-                }
-            }),
-        };
-        const stopPromise = stopLSP({
-            process: mockProcess,
-            stdin: {},
-            stdout: {},
-            stderr: {},
-            pid: 123,
-        });
-        // Let the error handler fire
-        await new Promise(r => setTimeout(r, 20));
-        await expect(stopPromise).resolves.toBeUndefined();
-    });
-});