pi-lens 3.1.2 → 3.2.0

package/clients/services/__tests__/effect-integration.test.js

@@ -1,86 +0,0 @@
-/**
- * Effect Integration Tests
- *
- * Tests for Effect-TS concurrent runner execution.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { clearRunnerRegistry, listRunners, registerRunner, } from "../../dispatch/dispatcher.js";
-import { dispatchLintWithEffect, dispatchWithEffect, } from "../effect-integration.js";
-describe("Effect Integration", () => {
-    beforeEach(async () => {
-        clearRunnerRegistry();
-        // Register a simple test runner
-        const testRunner = {
-            id: "test-runner",
-            appliesTo: ["jsts"],
-            priority: 10,
-            enabledByDefault: true,
-            async run(ctx) {
-                return {
-                    status: "succeeded",
-                    diagnostics: [{
-                            id: "test:1",
-                            message: "Test diagnostic",
-                            filePath: ctx.filePath,
-                            severity: "info",
-                            semantic: "silent",
-                            tool: "test-runner",
-                        }],
-                    semantic: "none",
-                };
-            },
-        };
-        registerRunner(testRunner);
-    });
-    it("should have runners registered", () => {
-        const runners = listRunners();
-        expect(runners.length).toBeGreaterThan(0);
-        expect(runners.some(r => r.id === "test-runner")).toBe(true);
-    });
-    it("should run effect integration with real runners", async () => {
-        const ctx = {
-            filePath: "test.ts",
-            cwd: "/test",
-            kind: "jsts",
-            pi: {
-                getFlag: vi.fn(() => false),
-            },
-            autofix: true,
-            deltaMode: false,
-            baselines: new Map(),
-            hasTool: vi.fn(() => Promise.resolve(false)),
-            log: vi.fn(),
-        };
-        // Get actual runners for jsts
-        const { getRunnersForKind } = await import("../../dispatch/dispatcher.js");
-        const runners = getRunnersForKind("jsts");
-        const group = {
-            runnerIds: runners.slice(0, 2).map(r => r.id), // Use first 2 runners
-            mode: "all",
-        };
-        const result = await dispatchWithEffect(ctx, [group]);
-        // Just verify it doesn't crash and returns valid result
-        expect(result).toBeDefined();
-        expect(typeof result.durationMs).toBe("number");
-    });
-    it("should handle --lens-effect flag path", async () => {
-        const mockPi = {
-            getFlag: vi.fn((flag) => flag === "lens-effect"),
-            readFile: vi.fn(),
-            writeFile: vi.fn(),
-            editFile: vi.fn(),
-            bash: vi.fn(),
-            ui: {
-                notify: vi.fn(),
-                progress: vi.fn(),
-                prompt: vi.fn(),
-            },
-            llm: {
-                stream: vi.fn(),
-                createMessage: vi.fn(),
-            },
-        };
-        const output = await dispatchLintWithEffect("test.ts", "/test", mockPi);
-        expect(typeof output).toBe("string");
-    });
-});

package/clients/test-runner-client.test.js

@@ -1,192 +0,0 @@
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { TestRunnerClient } from "./test-runner-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("TestRunnerClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TestRunnerClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-test-runner-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("detectRunner", () => {
-        it("should detect vitest from config file", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            const result = client.detectRunner(tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.runner).toBe("vitest");
-        });
-        it("should detect jest from config file", () => {
-            createTempFile(tmpDir, "jest.config.js", "module.exports = {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            const result = client.detectRunner(tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.runner).toBe("jest");
-        });
-        it("should detect pytest from config file", () => {
-            createTempFile(tmpDir, "pytest.ini", "[tool:pytest]");
-            createTempFile(tmpDir, "src/app.py", "x = 1");
-            const result = client.detectRunner(tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.runner).toBe("pytest");
-        });
-        it("should detect runner from node_modules", () => {
-            // Create a node_modules/vitest to simulate installed package
-            createTempFile(tmpDir, "node_modules/vitest/package.json", "{}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            const result = client.detectRunner(tmpDir);
-            // Should detect vitest from node_modules
-            expect(result).not.toBeNull();
-        });
-        it("should prefer vitest over jest when both exist", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "jest.config.js", "module.exports = {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            const result = client.detectRunner(tmpDir);
-            expect(result?.runner).toBe("vitest");
-        });
-    });
-    describe("findTestFile", () => {
-        it("should find test file with .test.ts suffix", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            createTempFile(tmpDir, "src/app.test.ts", "describe('app', () => {});");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.testFile).toContain("app.test.ts");
-            expect(result?.runner).toBe("vitest");
-        });
-        it("should find test file with .spec.ts suffix", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            createTempFile(tmpDir, "src/app.spec.ts", "describe('app', () => {});");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.testFile).toContain("app.spec.ts");
-        });
-        it("should find test file in __tests__ directory", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            createTempFile(tmpDir, "src/__tests__/app.test.ts", "describe('app', () => {});");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.testFile).toContain("__tests__");
-        });
-        it("should find test file in top-level tests/ directory", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            createTempFile(tmpDir, "tests/app.test.ts", "describe('app', () => {});");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.testFile).toContain(path.join("tests", "app.test.ts"));
-        });
-        it("should find pytest test file with test_ prefix", () => {
-            createTempFile(tmpDir, "pytest.ini", "[tool:pytest]");
-            createTempFile(tmpDir, "src/app.py", "x = 1");
-            createTempFile(tmpDir, "tests/test_app.py", "def test_app(): pass");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.py"), tmpDir);
-            expect(result).not.toBeNull();
-            expect(result?.testFile).toContain("test_app.py");
-            expect(result?.runner).toBe("pytest");
-        });
-        it("should return null when no test file found", () => {
-            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
-            expect(result).toBeNull();
-        });
-        it("should find test file even without config (if runner installed)", () => {
-            // Simulate vitest installed in node_modules
-            createTempFile(tmpDir, "node_modules/vitest/package.json", "{}");
-            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
-            createTempFile(tmpDir, "src/app.test.ts", "describe('app', () => {});");
-            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
-            // Should find the test file since vitest is "installed"
-            expect(result).not.toBeNull();
-        });
-    });
-    describe("formatResult", () => {
-        it("should format passing tests", () => {
-            const result = {
-                file: "/test/app.test.ts",
-                sourceFile: "/test/app.ts",
-                runner: "vitest",
-                passed: 5,
-                failed: 0,
-                skipped: 0,
-                failures: [],
-                duration: 420,
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("✓");
-            expect(formatted).toContain("5/5 passed");
-            expect(formatted).toContain("0.42s");
-        });
-        it("should format failing tests", () => {
-            const result = {
-                file: "/test/app.test.ts",
-                sourceFile: "/test/app.ts",
-                runner: "vitest",
-                passed: 3,
-                failed: 2,
-                skipped: 0,
-                failures: [
-                    {
-                        name: "should add",
-                        message: "expected 4, got 3",
-                        location: "app.test.ts:10",
-                    },
-                    {
-                        name: "should subtract",
-                        message: "expected 1, got 2",
-                        location: "app.test.ts:20",
-                    },
-                ],
-                duration: 420,
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("✗");
-            expect(formatted).toContain("2/5 failed");
-            expect(formatted).toContain("should add");
-            expect(formatted).toContain("should subtract");
-        });
-        it("should format runner errors", () => {
-            const result = {
-                file: "/test/app.test.ts",
-                sourceFile: "/test/app.ts",
-                runner: "vitest",
-                passed: 0,
-                failed: 0,
-                skipped: 0,
-                failures: [],
-                duration: 0,
-                error: "Test file not found",
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("⚠");
-            expect(formatted).toContain("Could not run tests");
-        });
-        it("should return empty string for no tests", () => {
-            const result = {
-                file: "/test/app.test.ts",
-                sourceFile: "/test/app.ts",
-                runner: "vitest",
-                passed: 0,
-                failed: 0,
-                skipped: 0,
-                failures: [],
-                duration: 0,
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toBe("");
-        });
-    });
-});

package/clients/todo-scanner.test.js

@@ -1,301 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-import { TodoScanner } from "./todo-scanner.js";
-describe("TodoScanner", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TodoScanner();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-todo-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("scanFile", () => {
-        it("should return empty array for non-existent files", () => {
-            const result = client.scanFile("/nonexistent/file.ts");
-            expect(result).toEqual([]);
-        });
-        it("should find TODO comments", () => {
-            const content = `
-// TODO: implement this function
-function foo() {}
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("TODO");
-            expect(result[0].message).toContain("implement this function");
-        });
-        it("should find FIXME comments", () => {
-            const content = `
-// FIXME: this is broken
-function foo() {}
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("FIXME");
-        });
-        it("should find HACK comments", () => {
-            const content = `
-// HACK: temporary workaround
-const x = 1;
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("HACK");
-        });
-        it("should find BUG comments", () => {
-            const content = `
-// BUG: this causes a crash
-const x = 1;
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("BUG");
-        });
-        it("should find NOTE comments", () => {
-            const content = `
-// NOTE: important design decision
-const x = 1;
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("NOTE");
-        });
-        it("should find TODO in block comments", () => {
-            const content = `
-/*
- * TODO: refactor this later
- */
-const x = 1;
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("TODO");
-        });
-        it("should find TODO in JSDoc comments", () => {
-            const content = `
-/**
- * TODO: add proper documentation
- */
-function foo() {}
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("TODO");
-        });
-        it("should find TODO in Python comments", () => {
-            const content = `
-# TODO: implement this
-def foo():
-    pass
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(1);
-            expect(result[0].type).toBe("TODO");
-        });
-        it("should skip TODO in strings", () => {
-            const content = `
-const message = "TODO: buy milk";
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(0);
-        });
-        it("should report correct line numbers", () => {
-            const content = `
-const x = 1;
-const y = 2;
-// TODO: fix this
-const z = 3;
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result[0].line).toBe(4);
-        });
-        it("should find multiple annotations in one file", () => {
-            const content = `
-// TODO: first
-// FIXME: second
-// HACK: third
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.scanFile(filePath);
-            expect(result.length).toBe(3);
-        });
-    });
-    describe("scanDirectory", () => {
-        it("should scan all files in directory", () => {
-            createTempFile(tmpDir, "file1.ts", "// TODO: task 1");
-            createTempFile(tmpDir, "file2.ts", "// FIXME: bug 1");
-            createTempFile(tmpDir, "file3.py", "# HACK: workaround");
-            const result = client.scanDirectory(tmpDir);
-            expect(result.items.length).toBe(3);
-        });
-        it("should skip node_modules", () => {
-            createTempFile(tmpDir, "src/file.ts", "// TODO: task 1");
-            createTempFile(tmpDir, "node_modules/lib/file.ts", "// TODO: should be skipped");
-            const result = client.scanDirectory(tmpDir);
-            expect(result.items.length).toBe(1);
-            expect(result.items[0].file).not.toContain("node_modules");
-        });
-        it("should group items by type", () => {
-            createTempFile(tmpDir, "file1.ts", "// TODO: task 1");
-            createTempFile(tmpDir, "file2.ts", "// TODO: task 2");
-            createTempFile(tmpDir, "file3.ts", "// FIXME: bug 1");
-            const result = client.scanDirectory(tmpDir);
-            expect(result.byType.get("TODO")?.length).toBe(2);
-            expect(result.byType.get("FIXME")?.length).toBe(1);
-        });
-        it("should group items by file", () => {
-            createTempFile(tmpDir, "file1.ts", "// TODO: task 1\n// FIXME: bug 1");
-            createTempFile(tmpDir, "file2.ts", "// TODO: task 2");
-            const result = client.scanDirectory(tmpDir);
-            const file1Items = [...result.byFile.entries()].find(([k]) => k.includes("file1.ts"));
-            expect(file1Items?.[1].length).toBe(2);
-        });
-    });
-    describe("formatResult", () => {
-        it("should return empty string for no results", () => {
-            const result = { items: [], byType: new Map(), byFile: new Map() };
-            expect(client.formatResult(result)).toBe("");
-        });
-        it("should format results with counts", () => {
-            const result = {
-                items: [
-                    {
-                        type: "TODO",
-                        message: "task 1",
-                        file: "test.ts",
-                        line: 1,
-                        column: 0,
-                    },
-                    {
-                        type: "FIXME",
-                        message: "bug 1",
-                        file: "test.ts",
-                        line: 2,
-                        column: 0,
-                    },
-                ],
-                byType: new Map([
-                    [
-                        "TODO",
-                        [
-                            {
-                                type: "TODO",
-                                message: "task 1",
-                                file: "test.ts",
-                                line: 1,
-                                column: 0,
-                            },
-                        ],
-                    ],
-                ]),
-                byFile: new Map([
-                    [
-                        "test.ts",
-                        [
-                            {
-                                type: "TODO",
-                                message: "task 1",
-                                file: "test.ts",
-                                line: 1,
-                                column: 0,
-                            },
-                        ],
-                    ],
-                ]),
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("2 annotation(s)");
-            expect(formatted).toContain("TODO");
-            expect(formatted).toContain("FIXME");
-        });
-        it("should prioritize FIXME/HACK before TODO", () => {
-            const result = {
-                items: [
-                    {
-                        type: "FIXME",
-                        message: "bug",
-                        file: "test.ts",
-                        line: 2,
-                        column: 0,
-                    },
-                    {
-                        type: "TODO",
-                        message: "task",
-                        file: "test.ts",
-                        line: 1,
-                        column: 0,
-                    },
-                ],
-                byType: new Map(),
-                byFile: new Map(),
-            };
-            const formatted = client.formatResult(result);
-            // Check that FIXME line comes before TODO line in the sorted output
-            const fixmeLineIndex = formatted.indexOf("🔴");
-            const todoLineIndex = formatted.indexOf("📝");
-            expect(fixmeLineIndex).toBeLessThan(todoLineIndex);
-        });
-        it("should show correct icons", () => {
-            const result = {
-                items: [
-                    {
-                        type: "FIXME",
-                        message: "bug",
-                        file: "test.ts",
-                        line: 1,
-                        column: 0,
-                    },
-                    {
-                        type: "HACK",
-                        message: "hack",
-                        file: "test.ts",
-                        line: 2,
-                        column: 0,
-                    },
-                    {
-                        type: "BUG",
-                        message: "bug",
-                        file: "test.ts",
-                        line: 3,
-                        column: 0,
-                    },
-                    {
-                        type: "TODO",
-                        message: "todo",
-                        file: "test.ts",
-                        line: 4,
-                        column: 0,
-                    },
-                    {
-                        type: "NOTE",
-                        message: "note",
-                        file: "test.ts",
-                        line: 5,
-                        column: 0,
-                    },
-                ],
-                byType: new Map(),
-                byFile: new Map(),
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("🔴"); // FIXME
-            expect(formatted).toContain("🟠"); // HACK
-            expect(formatted).toContain("🐛"); // BUG
-            expect(formatted).toContain("📝"); // TODO
-            expect(formatted).toContain("ℹ️"); // NOTE
-        });
-    });
-});

package/clients/type-coverage-client.test.js

@@ -1,105 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { setupTestEnvironment } from "./test-utils.js";
-import { TypeCoverageClient } from "./type-coverage-client.js";
-describe("TypeCoverageClient", () => {
-    let client;
-    let _tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new TypeCoverageClient();
-        ({ tmpDir: _tmpDir, cleanup } = setupTestEnvironment("pi-lens-typecoverage-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isAvailable", () => {
-        it("should check type-coverage availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("formatResult", () => {
-        it("should return empty string when not successful", () => {
-            const result = {
-                success: false,
-                percentage: 0,
-                typed: 0,
-                total: 0,
-                untypedLocations: [],
-            };
-            expect(client.formatResult(result)).toBe("");
-        });
-        it("should show coverage percentage", () => {
-            const result = {
-                success: true,
-                percentage: 95,
-                typed: 95,
-                total: 100,
-                untypedLocations: [],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("95.0%");
-            expect(formatted).toContain("95/100");
-        });
-        it("should show warning for low coverage", () => {
-            const result = {
-                success: true,
-                percentage: 80,
-                typed: 80,
-                total: 100,
-                untypedLocations: [],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("⚠");
-        });
-        it("should show checkmark for high coverage", () => {
-            const result = {
-                success: true,
-                percentage: 100,
-                typed: 100,
-                total: 100,
-                untypedLocations: [],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("✓");
-        });
-        it("should show untyped locations", () => {
-            const result = {
-                success: true,
-                percentage: 90,
-                typed: 90,
-                total: 100,
-                untypedLocations: [
-                    { file: "test.ts", line: 10, column: 5, name: "x" },
-                    { file: "test.ts", line: 20, column: 8, name: "y" },
-                ],
-            };
-            const formatted = client.formatResult(result);
-            expect(formatted).toContain("test.ts:10");
-            expect(formatted).toContain("test.ts:20");
-            expect(formatted).toContain("x");
-            expect(formatted).toContain("y");
-        });
-        it("should truncate long untyped location lists", () => {
-            const locations = Array.from({ length: 20 }, (_, i) => ({
-                file: `file${i}.ts`,
-                line: i + 1,
-                column: 0,
-                name: `var${i}`,
-            }));
-            const result = {
-                success: true,
-                percentage: 80,
-                typed: 80,
-                total: 100,
-                untypedLocations: locations,
-            };
-            const formatted = client.formatResult(result, 10);
-            expect(formatted).toContain("...");
-            expect(formatted).toContain("10 more");
-        });
-    });
-});