pi-lens 3.2.0 → 3.3.1

package/clients/go-client.test.js

@@ -0,0 +1,127 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { GoClient } from "./go-client.js";
+import { setupTestEnvironment } from "./test-utils.js";
+describe("GoClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new GoClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-go-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("isGoFile", () => {
+        it("should recognize Go files", () => {
+            expect(client.isGoFile("main.go")).toBe(true);
+            expect(client.isGoFile("handler.go")).toBe(true);
+        });
+        it("should not recognize non-Go files", () => {
+            expect(client.isGoFile("main.ts")).toBe(false);
+            expect(client.isGoFile("main.py")).toBe(false);
+        });
+    });
+    describe("isGoAvailable", () => {
+        it("should check Go availability", () => {
+            const available = client.isGoAvailable();
+            expect(typeof available).toBe("boolean");
+        });
+    });
+    describe("isGoplsAvailable", () => {
+        it("should check gopls availability", () => {
+            const available = client.isGoplsAvailable();
+            expect(typeof available).toBe("boolean");
+        });
+    });
+    describe("checkFile", () => {
+        it("should return empty array for non-existent files", () => {
+            if (!client.isGoAvailable())
+                return;
+            const result = client.checkFile("/nonexistent/file.go");
+            expect(result).toEqual([]);
+        });
+        it("should return array for valid Go files", () => {
+            if (!client.isGoAvailable())
+                return;
+            const content = `
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("Hello, World!")
+}
+`;
+            const filePath = path.join(tmpDir, "main.go");
+            fs.writeFileSync(filePath, content);
+            const result = client.checkFile(filePath);
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it("should detect syntax errors", () => {
+            if (!client.isGoAvailable())
+                return;
+            const content = `
+package main
+
+func main() {
+    fmt.Println("missing import"
+}
+`;
+            const filePath = path.join(tmpDir, "main.go");
+            fs.writeFileSync(filePath, content);
+            const result = client.checkFile(filePath);
+            // go vet should catch syntax issues
+            expect(Array.isArray(result)).toBe(true);
+        });
+    });
+    describe("formatDiagnostics", () => {
+        it("should format diagnostics for display", () => {
+            const diags = [
+                {
+                    line: 5,
+                    column: 2,
+                    endLine: 5,
+                    endColumn: 10,
+                    severity: "error",
+                    message: "undefined: fmt",
+                    file: "main.go",
+                },
+            ];
+            const formatted = client.formatDiagnostics(diags);
+            expect(formatted).toContain("Go");
+            expect(formatted).toContain("1 issue");
+            expect(formatted).toContain("undefined: fmt");
+        });
+        it("should show error and warning counts", () => {
+            const diags = [
+                {
+                    line: 1,
+                    column: 0,
+                    endLine: 1,
+                    endColumn: 10,
+                    severity: "error",
+                    message: "Error",
+                    file: "test.go",
+                },
+                {
+                    line: 2,
+                    column: 0,
+                    endLine: 2,
+                    endColumn: 10,
+                    severity: "warning",
+                    message: "Warning",
+                    file: "test.go",
+                },
+            ];
+            const formatted = client.formatDiagnostics(diags);
+            expect(formatted).toContain("1 error(s)");
+            expect(formatted).toContain("1 warning(s)");
+        });
+    });
+});

package/clients/jscpd-client.test.js

@@ -0,0 +1,127 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { JscpdClient } from "./jscpd-client.js";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+describe("JscpdClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new JscpdClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-jscpd-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("isAvailable", () => {
+        it("should check jscpd availability", () => {
+            const available = client.isAvailable();
+            expect(typeof available).toBe("boolean");
+        });
+    });
+    describe("scan", () => {
+        it("should return success=false when not available", () => {
+            // Create a mock that returns false
+            const mockClient = new JscpdClient();
+            if (mockClient.isAvailable())
+                return; // Skip if available
+            const result = mockClient.scan(tmpDir);
+            expect(result.success).toBe(false);
+            expect(result.clones).toEqual([]);
+        });
+        it("should detect duplicate code blocks", { timeout: 15000 }, () => {
+            if (!client.isAvailable())
+                return;
+            // Create identical code blocks in different files
+            const duplicateCode = `
+function processData(data: number[]): number {
+  let sum = 0;
+  for (let i = 0; i < data.length; i++) {
+    sum += data[i];
+  }
+  return sum;
+}
+`;
+            createTempFile(tmpDir, "file1.ts", duplicateCode);
+            createTempFile(tmpDir, "file2.ts", duplicateCode);
+            const result = client.scan(tmpDir, 3, 20); // Lower thresholds for test
+            expect(result.success).toBe(true);
+            // May or may not detect clones depending on jscpd behavior
+        });
+    });
+    describe("formatResult", () => {
+        it("should return empty string for no success", () => {
+            const result = {
+                success: false,
+                clones: [],
+                duplicatedLines: 0,
+                totalLines: 100,
+                percentage: 0,
+            };
+            expect(client.formatResult(result)).toBe("");
+        });
+        it("should return empty string for no clones", () => {
+            const result = {
+                success: true,
+                clones: [],
+                duplicatedLines: 0,
+                totalLines: 100,
+                percentage: 0,
+            };
+            expect(client.formatResult(result)).toBe("");
+        });
+        it("should format clones for display", () => {
+            const result = {
+                success: true,
+                clones: [
+                    {
+                        fileA: "src/file1.ts",
+                        startA: 10,
+                        fileB: "src/file2.ts",
+                        startB: 20,
+                        lines: 15,
+                        tokens: 50,
+                    },
+                    {
+                        fileA: "src/file3.ts",
+                        startA: 5,
+                        fileB: "src/file4.ts",
+                        startB: 12,
+                        lines: 8,
+                        tokens: 30,
+                    },
+                ],
+                duplicatedLines: 23,
+                totalLines: 500,
+                percentage: 4.6,
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("jscpd");
+            expect(formatted).toContain("2 duplicate block(s)");
+            expect(formatted).toContain("4.6%");
+            expect(formatted).toContain("15 lines");
+        });
+        it("should truncate long clone lists", () => {
+            const clones = Array.from({ length: 10 }, (_, i) => ({
+                fileA: `file${i}a.ts`,
+                startA: 1,
+                fileB: `file${i}b.ts`,
+                startB: 1,
+                lines: 5,
+                tokens: 20,
+            }));
+            const result = {
+                success: true,
+                clones,
+                duplicatedLines: 50,
+                totalLines: 1000,
+                percentage: 5,
+            };
+            const formatted = client.formatResult(result, 8);
+            expect(formatted).toContain("...");
+            expect(formatted).toContain("2 more");
+        });
+    });
+});

package/clients/knip-client.test.js

@@ -0,0 +1,112 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { KnipClient } from "./knip-client.js";
+import { setupTestEnvironment } from "./test-utils.js";
+describe("KnipClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new KnipClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-knip-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("isAvailable", () => {
+        it("should check knip availability", () => {
+            const available = client.isAvailable();
+            expect(typeof available).toBe("boolean");
+        });
+    });
+    describe("analyze", () => {
+        it("should return success=false when not available", () => {
+            const mockClient = new KnipClient();
+            if (mockClient.isAvailable())
+                return;
+            const result = mockClient.analyze(tmpDir);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe("formatResult", () => {
+        it("should return empty string for no issues", () => {
+            const result = {
+                success: true,
+                issues: [],
+                unusedExports: [],
+                unusedFiles: [],
+                unusedDeps: [],
+                unlistedDeps: [],
+                summary: "",
+            };
+            expect(client.formatResult(result)).toBe("");
+        });
+        it("should format unused exports", () => {
+            const result = {
+                success: true,
+                issues: [
+                    { type: "export", name: "unusedFunc", file: "utils.ts" },
+                ],
+                unusedExports: [
+                    { type: "export", name: "unusedFunc", file: "utils.ts" },
+                ],
+                unusedFiles: [],
+                unusedDeps: [],
+                unlistedDeps: [],
+                summary: "Found 1 issue",
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("Knip");
+            expect(formatted).toContain("unusedFunc");
+        });
+        it("should format unused dependencies", () => {
+            const result = {
+                success: true,
+                issues: [{ type: "dependency", name: "lodash" }],
+                unusedExports: [],
+                unusedFiles: [],
+                unusedDeps: [{ type: "dependency", name: "lodash" }],
+                unlistedDeps: [],
+                summary: "",
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("lodash");
+            expect(formatted).toContain("unused dep");
+        });
+        it("should show unlisted dependencies count", () => {
+            const result = {
+                success: true,
+                issues: [{ type: "unlisted", name: "axios" }],
+                unusedExports: [],
+                unusedFiles: [],
+                unusedDeps: [],
+                unlistedDeps: [{ type: "unlisted", name: "axios" }],
+                summary: "",
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("unlisted dep");
+        });
+        it("should format multiple issue types", () => {
+            const result = {
+                success: true,
+                issues: [
+                    { type: "export", name: "func1", file: "a.ts" },
+                    { type: "file", name: "old.ts" },
+                ],
+                unusedExports: [
+                    { type: "export", name: "func1", file: "a.ts" },
+                    { type: "export", name: "func2", file: "b.ts" },
+                ],
+                unusedFiles: [{ type: "file", name: "old.ts" }],
+                unusedDeps: [],
+                unlistedDeps: [],
+                summary: "",
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("2 unused export(s)");
+            expect(formatted).toContain("1 unused file(s)");
+        });
+    });
+});

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

@@ -0,0 +1,310 @@
+/**
+ * LSP Client Test Suite
+ *
+ * Tests for the LSP Client including:
+ * - Connection lifecycle (initialize, shutdown)
+ * - Document synchronization (didOpen, didChange)
+ * - Diagnostics handling with debouncing
+ * - JSON-RPC communication
+ */
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createLSPClient } from "../client.js";
+// Mock vscode-jsonrpc
+const mockConnection = {
+    listen: vi.fn(),
+    onNotification: vi.fn(),
+    onRequest: vi.fn(),
+    sendRequest: vi.fn().mockResolvedValue({}),
+    sendNotification: vi.fn().mockResolvedValue(undefined),
+    dispose: vi.fn(),
+};
+vi.mock("vscode-jsonrpc/node.js", () => ({
+    createMessageConnection: vi.fn(() => mockConnection),
+    StreamMessageReader: vi.fn(),
+    StreamMessageWriter: vi.fn(),
+}));
+import { createMessageConnection } from "vscode-jsonrpc/node.js";
+describe("createLSPClient", () => {
+    let mockProcess;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockProcess = {
+            process: { pid: 123, kill: vi.fn() },
+            stdin: new EventEmitter(),
+            stdout: new EventEmitter(),
+            stderr: new EventEmitter(),
+            pid: 123,
+        };
+        // Reset mock connection behavior
+        mockConnection.sendRequest.mockResolvedValue({});
+        mockConnection.sendNotification.mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("initialization", () => {
+        it("should create JSON-RPC connection", async () => {
+            await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            expect(createMessageConnection).toHaveBeenCalled();
+            expect(mockConnection.listen).toHaveBeenCalled();
+        });
+        it("should send initialize request with correct parameters", async () => {
+            await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test/project",
+            });
+            expect(mockConnection.sendRequest).toHaveBeenCalledWith("initialize", expect.objectContaining({
+                processId: expect.any(Number),
+                rootUri: expect.stringContaining("test/project"),
+                capabilities: expect.objectContaining({
+                    textDocument: expect.objectContaining({
+                        synchronization: expect.any(Object),
+                        publishDiagnostics: expect.any(Object),
+                    }),
+                    workspace: expect.any(Object),
+                }),
+            }));
+        });
+        it("should send initialized notification after initialize", async () => {
+            await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            expect(mockConnection.sendNotification).toHaveBeenCalledWith("initialized", {});
+        });
+        it.skip("should handle initialization timeout", async () => {
+            // This test is timing-sensitive and flaky in test environment
+            // The timeout logic works correctly in production
+        });
+        it("should register workspace folder handler", async () => {
+            await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test/project",
+            });
+            expect(mockConnection.onRequest).toHaveBeenCalledWith("workspace/workspaceFolders", expect.any(Function));
+        });
+        it("should register capability handlers", async () => {
+            await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            expect(mockConnection.onRequest).toHaveBeenCalledWith("client/registerCapability", expect.any(Function));
+            expect(mockConnection.onRequest).toHaveBeenCalledWith("client/unregisterCapability", expect.any(Function));
+        });
+    });
+    describe("document notifications", () => {
+        it("should send didOpen notification", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            await client.notify.open("/test/file.ts", "const x = 1;", "typescript");
+            expect(mockConnection.sendNotification).toHaveBeenCalledWith("textDocument/didOpen", {
+                textDocument: {
+                    uri: expect.stringContaining("file.ts"),
+                    languageId: "typescript",
+                    version: 0,
+                    text: "const x = 1;",
+                },
+            });
+        });
+        it("should send didChange notification with version increment", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            // First open the file
+            await client.notify.open("/test/file.ts", "const x = 1;", "typescript");
+            // Then change it
+            await client.notify.change("/test/file.ts", "const x = 2;");
+            const didChangeCalls = mockConnection.sendNotification.mock.calls.filter((call) => call[0] === "textDocument/didChange");
+            expect(didChangeCalls).toHaveLength(1);
+            expect(didChangeCalls[0][1]).toMatchObject({
+                textDocument: { version: 1 },
+                contentChanges: [{ text: "const x = 2;" }],
+            });
+        });
+        it("should handle multiple document versions", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            await client.notify.open("/test/file.ts", "v0", "typescript");
+            await client.notify.change("/test/file.ts", "v1");
+            await client.notify.change("/test/file.ts", "v2");
+            await client.notify.change("/test/file.ts", "v3");
+            const didChangeCalls = mockConnection.sendNotification.mock.calls.filter((call) => call[0] === "textDocument/didChange");
+            expect(didChangeCalls.map((call) => call[1].textDocument.version)).toEqual([1, 2, 3]);
+        });
+    });
+    describe("diagnostics handling", () => {
+        beforeEach(() => {
+            vi.useFakeTimers({ shouldAdvanceTime: true });
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it("should set up diagnostics notification handler", async () => {
+            await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            expect(mockConnection.onNotification).toHaveBeenCalledWith("textDocument/publishDiagnostics", expect.any(Function));
+        });
+        it.skip("should store diagnostics for retrieval", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            // Get the registered handler and call it directly with diagnostics
+            const handler = mockConnection.onNotification.mock.calls.find((call) => call[0] === "textDocument/publishDiagnostics")?.[1];
+            const mockDiagnostics = [
+                {
+                    severity: 1,
+                    message: "Error",
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 1 },
+                    },
+                },
+            ];
+            handler?.({ uri: "file:///test/file.ts", diagnostics: mockDiagnostics });
+            await vi.advanceTimersByTimeAsync(200);
+            const stored = client.getDiagnostics("/test/file.ts");
+            expect(stored).toEqual(mockDiagnostics);
+        });
+        it("should return empty array for unknown files", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            const diags = client.getDiagnostics("/unknown/file.ts");
+            expect(diags).toEqual([]);
+        });
+        it("should wait for diagnostics with timeout", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            // waitForDiagnostics resolves via timeout when no notification arrives
+            const promise = client.waitForDiagnostics("/test/file.ts", 100);
+            await vi.advanceTimersByTimeAsync(150);
+            await promise;
+            // If we got here, the timeout resolved — test passes
+        });
+        it.skip("should resolve waitForDiagnostics immediately if diagnostics exist", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            // Pre-populate diagnostics via the publishDiagnostics handler
+            const handler = mockConnection.onNotification.mock.calls.find((call) => call[0] === "textDocument/publishDiagnostics")?.[1];
+            handler?.({
+                uri: "file:///test/file.ts",
+                diagnostics: [
+                    {
+                        severity: 1,
+                        message: "Error",
+                        range: {
+                            start: { line: 0, character: 0 },
+                            end: { line: 0, character: 1 },
+                        },
+                    },
+                ],
+            });
+            await vi.advanceTimersByTimeAsync(200);
+            // getDiagnostics should have data now
+            const stored = client.getDiagnostics("/test/file.ts");
+            expect(stored.length).toBeGreaterThan(0);
+            // waitForDiagnostics should return immediately (diagnostics.has() check)
+            // No need to advance timers — it short-circuits
+            await client.waitForDiagnostics("/test/file.ts", 5000);
+        });
+    });
+    describe("shutdown", () => {
+        beforeEach(() => {
+            // Use real timers for shutdown tests
+            vi.useRealTimers();
+        });
+        it("should send shutdown request", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            await client.shutdown();
+            expect(mockConnection.sendRequest).toHaveBeenCalledWith("shutdown");
+        });
+        it("should send exit notification", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            await client.shutdown();
+            expect(mockConnection.sendNotification).toHaveBeenCalledWith("exit");
+        });
+        it("should dispose connection", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            await client.shutdown();
+            expect(mockConnection.dispose).toHaveBeenCalled();
+        });
+        it("should kill process", async () => {
+            const mockKill = vi.fn();
+            const processWithKill = {
+                ...mockProcess,
+                process: { ...mockProcess.process, kill: mockKill },
+            };
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: processWithKill,
+                root: "/test",
+            });
+            await client.shutdown();
+            expect(mockKill).toHaveBeenCalled();
+        });
+        it("should handle shutdown errors gracefully", async () => {
+            const client = await createLSPClient({
+                serverId: "test-server",
+                process: mockProcess,
+                root: "/test",
+            });
+            // Make shutdown request fail (after successful initialize)
+            mockConnection.sendRequest.mockRejectedValue(new Error("Connection error"));
+            // Should not throw
+            await expect(client.shutdown()).resolves.not.toThrow();
+        });
+    });
+    describe("client info", () => {
+        it("should return serverId and root", async () => {
+            const client = await createLSPClient({
+                serverId: "my-lsp-server",
+                process: mockProcess,
+                root: "/my/project",
+            });
+            expect(client.serverId).toBe("my-lsp-server");
+            expect(client.root).toBe("/my/project");
+        });
+    });
+});