pi-lens 3.1.2 → 3.2.0

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

@@ -1,259 +0,0 @@
-/**
- * LSP Server Definitions Test Suite
- *
- * Tests for server definitions including:
- * - Root detection with various project markers
- * - Server matching by extension
- * - Custom server creation
- * - Server registry operations
- */
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { LSP_SERVERS, TypeScriptServer, PythonServer, GoServer, RustServer, getServerForExtension, getServerById, getServersForFile, createRootDetector, } from "../server.js";
-import * as fs from "fs/promises";
-// Mock fs/promises - need to mock the module before it's imported
-vi.mock("fs/promises", async () => {
-    const actual = await vi.importActual("fs/promises");
-    return {
-        ...actual,
-        stat: vi.fn(),
-        access: vi.fn(),
-    };
-});
-describe("createRootDetector", () => {
-    const mockStat = vi.mocked(fs.stat);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should return undefined when no markers exist", async () => {
-        // Mock all stat calls to throw (file not found)
-        mockStat.mockRejectedValue(new Error("ENOENT"));
-        const detector = createRootDetector(["package.json"]);
-        const root = await detector("/project/src/components/Button.tsx");
-        expect(root).toBeUndefined();
-    });
-    it("should return undefined for empty marker list", async () => {
-        const detector = createRootDetector([]);
-        const root = await detector("/project/file.ts");
-        expect(root).toBeUndefined();
-    });
-    it("should stop at filesystem root", async () => {
-        mockStat.mockRejectedValue(new Error("ENOENT"));
-        const detector = createRootDetector(["package.json"]);
-        const root = await detector("C:/file.ts");
-        // Should reach root and return undefined
-        expect(root).toBeUndefined();
-    });
-    it("should respect exclude patterns", async () => {
-        // First call finds node_modules (excluded)
-        mockStat.mockImplementation(async (filepath) => {
-            if (filepath.includes("node_modules")) {
-                return { isDirectory: () => true };
-            }
-            throw new Error("ENOENT");
-        });
-        const detector = createRootDetector(["package.json"], ["node_modules"]);
-        const root = await detector("/project/node_modules/lib/index.js");
-        expect(root).toBeUndefined();
-    });
-});
-describe("TypeScriptServer", () => {
-    const mockStat = vi.mocked(fs.stat);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should have correct ID and name", () => {
-        expect(TypeScriptServer.id).toBe("typescript");
-        expect(TypeScriptServer.name).toBe("TypeScript Language Server");
-    });
-    it("should match TypeScript extensions", () => {
-        expect(TypeScriptServer.extensions).toContain(".ts");
-        expect(TypeScriptServer.extensions).toContain(".tsx");
-        expect(TypeScriptServer.extensions).toContain(".js");
-        expect(TypeScriptServer.extensions).toContain(".jsx");
-        expect(TypeScriptServer.extensions).toContain(".mts");
-        expect(TypeScriptServer.extensions).toContain(".cts");
-    });
-    it("should return undefined when no project markers found", async () => {
-        mockStat.mockRejectedValue(new Error("ENOENT"));
-        const root = await TypeScriptServer.root("/project/src/index.ts");
-        expect(root).toBeUndefined();
-    });
-    it("should have spawn function", () => {
-        expect(typeof TypeScriptServer.spawn).toBe("function");
-    });
-});
-describe("PythonServer", () => {
-    const mockStat = vi.mocked(fs.stat);
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should have correct ID and name", () => {
-        expect(PythonServer.id).toBe("python");
-        expect(PythonServer.name).toBe("Pyright Language Server");
-    });
-    it("should match Python extensions", () => {
-        expect(PythonServer.extensions).toContain(".py");
-        expect(PythonServer.extensions).toContain(".pyi");
-    });
-    it("should return undefined when no project markers found", async () => {
-        mockStat.mockRejectedValue(new Error("ENOENT"));
-        const root = await PythonServer.root("/project/src/main.py");
-        expect(root).toBeUndefined();
-    });
-    it("should have spawn function", () => {
-        expect(typeof PythonServer.spawn).toBe("function");
-    });
-});
-describe("GoServer", () => {
-    it("should have correct ID and name", () => {
-        expect(GoServer.id).toBe("go");
-        expect(GoServer.name).toBe("gopls");
-    });
-    it("should match .go extension", () => {
-        expect(GoServer.extensions).toContain(".go");
-    });
-    it("should have root detection function", () => {
-        expect(typeof GoServer.root).toBe("function");
-    });
-    it("should have spawn function", () => {
-        expect(typeof GoServer.spawn).toBe("function");
-    });
-});
-describe("RustServer", () => {
-    it("should have correct ID and name", () => {
-        expect(RustServer.id).toBe("rust");
-        expect(RustServer.name).toBe("rust-analyzer");
-    });
-    it("should match .rs extension", () => {
-        expect(RustServer.extensions).toContain(".rs");
-    });
-    it("should have root detection function", () => {
-        expect(typeof RustServer.root).toBe("function");
-    });
-    it("should have spawn function", () => {
-        expect(typeof RustServer.spawn).toBe("function");
-    });
-});
-describe("getServerForExtension", () => {
-    it("should return TypeScript server for .ts files", () => {
-        const server = getServerForExtension(".ts");
-        expect(server?.id).toBe("typescript");
-    });
-    it("should return Python server for .py files", () => {
-        const server = getServerForExtension(".py");
-        expect(server?.id).toBe("python");
-    });
-    it("should return Go server for .go files", () => {
-        const server = getServerForExtension(".go");
-        expect(server?.id).toBe("go");
-    });
-    it("should return Rust server for .rs files", () => {
-        const server = getServerForExtension(".rs");
-        expect(server?.id).toBe("rust");
-    });
-    it("should return undefined for unknown extensions", () => {
-        const server = getServerForExtension(".unknown");
-        expect(server).toBeUndefined();
-    });
-});
-describe("getServerById", () => {
-    it("should return server by ID", () => {
-        const server = getServerById("typescript");
-        expect(server?.name).toBe("TypeScript Language Server");
-    });
-    it("should return Python server by ID", () => {
-        const server = getServerById("python");
-        expect(server?.name).toBe("Pyright Language Server");
-    });
-    it("should return Go server by ID", () => {
-        const server = getServerById("go");
-        expect(server?.name).toBe("gopls");
-    });
-    it("should return Rust server by ID", () => {
-        const server = getServerById("rust");
-        expect(server?.name).toBe("rust-analyzer");
-    });
-    it("should return undefined for unknown ID", () => {
-        const server = getServerById("unknown");
-        expect(server).toBeUndefined();
-    });
-});
-describe("getServersForFile", () => {
-    it("should find servers for TypeScript file", () => {
-        const servers = getServersForFile("/project/src/index.ts");
-        expect(servers.some((s) => s.id === "typescript")).toBe(true);
-    });
-    it("should find servers for Python file", () => {
-        const servers = getServersForFile("/project/src/main.py");
-        expect(servers.some((s) => s.id === "python")).toBe(true);
-    });
-    it("should find servers for Go file", () => {
-        const servers = getServersForFile("/project/cmd/app/main.go");
-        expect(servers.some((s) => s.id === "go")).toBe(true);
-    });
-    it("should find servers for Rust file", () => {
-        const servers = getServersForFile("/project/src/main.rs");
-        expect(servers.some((s) => s.id === "rust")).toBe(true);
-    });
-    it("should return empty array for unknown file type", () => {
-        const servers = getServersForFile("/project/file.unknown");
-        expect(servers).toEqual([]);
-    });
-    it("should be case insensitive for extensions", () => {
-        const servers1 = getServersForFile("/project/file.TS");
-        const servers2 = getServersForFile("/project/file.ts");
-        expect(servers1.map((s) => s.id)).toEqual(servers2.map((s) => s.id));
-    });
-});
-describe("LSP_SERVERS registry", () => {
-    it("should contain all expected servers", () => {
-        const serverIds = LSP_SERVERS.map((s) => s.id);
-        expect(serverIds).toContain("typescript");
-        expect(serverIds).toContain("python");
-        expect(serverIds).toContain("go");
-        expect(serverIds).toContain("rust");
-        expect(serverIds).toContain("ruby");
-        expect(serverIds).toContain("php");
-        expect(serverIds).toContain("java");
-        expect(serverIds).toContain("cpp");
-        expect(serverIds).toContain("bash");
-        expect(serverIds).toContain("yaml");
-        expect(serverIds).toContain("json");
-        expect(serverIds).toContain("docker");
-        expect(serverIds).toContain("vue");
-        expect(serverIds).toContain("svelte");
-    });
-    it("should have unique server IDs", () => {
-        const ids = LSP_SERVERS.map((s) => s.id);
-        const uniqueIds = new Set(ids);
-        expect(uniqueIds.size).toBe(ids.length);
-    });
-    it("should have non-empty extensions for each server", () => {
-        for (const server of LSP_SERVERS) {
-            expect(server.extensions.length).toBeGreaterThan(0);
-        }
-    });
-    it("should have valid extensions for each server", () => {
-        for (const server of LSP_SERVERS) {
-            // All extensions should start with . or be special names like "Dockerfile"
-            const validExtensions = server.extensions.every((ext) => ext.startsWith(".") || ext === "Dockerfile");
-            expect(validExtensions).toBe(true);
-        }
-    });
-    it("should have spawn function for each server", () => {
-        for (const server of LSP_SERVERS) {
-            expect(typeof server.spawn).toBe("function");
-        }
-    });
-    it("should have root detection function for each server", () => {
-        for (const server of LSP_SERVERS) {
-            expect(typeof server.root).toBe("function");
-        }
-    });
-    it("should have name for each server", () => {
-        for (const server of LSP_SERVERS) {
-            expect(server.name).toBeTruthy();
-            expect(typeof server.name).toBe("string");
-        }
-    });
-});

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

@@ -1,417 +0,0 @@
-/**
- * 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 { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { Effect } from "effect";
-import { LSPService, lspEffect, getLSPService, 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 { getServersForFileWithConfig as mockGetServersForFile } from "../config.js";
-import { createLSPClient as mockCreateLSPClient } from "../client.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),
-        waitForDiagnostics: vi.fn().mockResolvedValue(undefined),
-        shutdown: vi.fn().mockResolvedValue(undefined),
-    };
-}