pi-lens 3.2.0 → 3.3.1

package/clients/todo-scanner.test.js

@@ -0,0 +1,301 @@
+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

@@ -0,0 +1,105 @@
+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");
+        });
+    });
+});

package/clients/typescript-client.codefix.test.js

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+import { TypeScriptClient } from "./typescript-client.js";
+describe("TypeScriptClient - Code Fixes", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new TypeScriptClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-codefix-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("getCodeFixes", () => {
+        it("should provide fix for missing property on object literal", () => {
+            // Real-world case: Missing required property in object literal
+            const content = `
+interface Config {
+  name: string;
+  port: number;
+  debug: boolean;
+}
+
+const config: Config = {
+  name: "my-app",
+  port: 3000
+  // Missing 'debug' property - TS2345
+};
+`;
+            const filePath = createTempFile(tmpDir, "missing-property.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            const missingPropError = diags.find((d) => d.code === 2345 || d.message.includes("missing"));
+            if (missingPropError) {
+                const line = missingPropError.range.start.line;
+                const char = missingPropError.range.start.character;
+                const fixes = client.getCodeFixes(filePath, line, char, [
+                    missingPropError.code,
+                ]);
+                // TypeScript should suggest adding the missing property
+                expect(fixes.length).toBeGreaterThan(0);
+                const hasAddPropertyFix = fixes.some((f) => f.description.toLowerCase().includes("add") ||
+                    f.description.toLowerCase().includes("property") ||
+                    f.description.toLowerCase().includes("declare"));
+                expect(hasAddPropertyFix).toBe(true);
+            }
+        });
+        it("should provide fix for missing await in async function", () => {
+            // Real-world case: Forgetting await on a Promise-returning function
+            const content = `
+async function fetchUser(id: string): Promise<{ name: string }> {
+  return { name: "John" };
+}
+
+async function getUserName(id: string): Promise<string> {
+  const user = fetchUser(id); // Missing await
+  return user.name; // Type 'Promise<{ name: string; }>' has no property 'name'
+}
+`;
+            const filePath = createTempFile(tmpDir, "missing-await.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            // TS2739: Type 'Promise<{ name: string; }>' is missing 'name'
+            const propertyError = diags.find((d) => d.code === 2739 || d.message.includes("is missing"));
+            if (propertyError) {
+                const fixes = client.getAllCodeFixes(filePath);
+                // If there's an error, check if we have fixes for it
+                const lineFixes = fixes.get(propertyError.range.start.line);
+                if (lineFixes) {
+                    expect(lineFixes.length).toBeGreaterThan(0);
+                }
+            }
+            // Test passes if we get here - not all TS versions provide fixes for this
+            expect(true).toBe(true);
+        });
+        it("should provide fix for incorrect type assignment", () => {
+            // Real-world case: String instead of number
+            const content = `
+function calculateTotal(price: number, tax: number): number {
+  return price + tax;
+}
+
+const result = calculateTotal("100", 10); // TS2345: Argument of type 'string' is not assignable to parameter of type 'number'
+`;
+            const filePath = createTempFile(tmpDir, "type-mismatch.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            const typeError = diags.find((d) => d.code === 2345);
+            if (typeError) {
+                const line = typeError.range.start.line;
+                const char = typeError.range.start.character;
+                const fixes = client.getCodeFixes(filePath, line, char, [2345]);
+                // TypeScript often suggests fixes for type mismatches
+                expect(fixes).toBeDefined();
+            }
+        });
+        it("should collect all fixes via getAllCodeFixes", () => {
+            // Multiple errors in one file
+            const content = `
+interface Person {
+  name: string;
+  age: number;
+}
+
+const person: Person = {
+  name: "Alice"
+  // Missing age
+};
+
+function greet(p: Person): string {
+  return "Hello " + p.name;
+}
+
+greet({ name: "Bob" }); // Missing age in argument
+`;
+            const filePath = createTempFile(tmpDir, "multiple-errors.ts", content);
+            client.addFile(filePath, content);
+            const allFixes = client.getAllCodeFixes(filePath);
+            // Should have fixes mapped by line number
+            expect(allFixes).toBeInstanceOf(Map);
+            // Each fix entry should have a description and changes
+            for (const [line, fixes] of allFixes.entries()) {
+                expect(typeof line).toBe("number");
+                expect(fixes.length).toBeGreaterThan(0);
+                for (const fix of fixes) {
+                    expect(fix.description).toBeTruthy();
+                    expect(fix.changes).toBeDefined();
+                }
+            }
+        });
+    });
+    describe("Integration with diagnostic messages", () => {
+        it("should include fix suggestions in getAllCodeFixes output", () => {
+            const content = `
+class User {
+  constructor(public name: string) {}
+}
+
+const user = new User(); // TS2554: Expected 1 arguments, but got 0
+`;
+            const filePath = createTempFile(tmpDir, "constructor-args.ts", content);
+            client.addFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            const argError = diags.find((d) => d.code === 2554);
+            if (argError) {
+                const fixes = client.getAllCodeFixes(filePath);
+                const lineFixes = fixes.get(argError.range.start.line);
+                if (lineFixes && lineFixes.length > 0) {
+                    // The runner would append this to the message
+                    const suggestion = lineFixes[0].description;
+                    expect(suggestion).toBeTruthy();
+                }
+            }
+        });
+    });
+});

package/clients/typescript-client.test.js

@@ -0,0 +1,105 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+import { TypeScriptClient } from "./typescript-client.js";
+describe("TypeScriptClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new TypeScriptClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ts-test-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("isTypeScriptFile", () => {
+        it("should recognize TypeScript files", () => {
+            expect(client.isTypeScriptFile("test.ts")).toBe(true);
+            expect(client.isTypeScriptFile("test.tsx")).toBe(true);
+        });
+        it("should also recognize JavaScript files (for type checking)", () => {
+            expect(client.isTypeScriptFile("test.js")).toBe(true);
+            expect(client.isTypeScriptFile("test.jsx")).toBe(true);
+        });
+        it("should not recognize non-JS/TS files", () => {
+            expect(client.isTypeScriptFile("test.py")).toBe(false);
+            expect(client.isTypeScriptFile("test.md")).toBe(false);
+        });
+    });
+    describe("updateFile and getDiagnostics", () => {
+        it("should detect type errors", () => {
+            const content = `
+const x: number = "string"; // Type error
+`;
+            const filePath = createTempFile(tmpDir, "test.ts", content);
+            client.updateFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            expect(diags.length).toBeGreaterThan(0);
+            expect(diags.some((d) => d.message.includes("string"))).toBe(true);
+        });
+        it("should not report errors for valid code", () => {
+            const content = `
+const x: number = 42;
+const y: string = "hello";
+`;
+            const filePath = createTempFile(tmpDir, "test.ts", content);
+            client.updateFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            // May have warnings but no errors for valid code
+            const errors = diags.filter((d) => d.severity === 1); // Error severity
+            expect(errors.length).toBe(0);
+        });
+        it("should detect undefined variables", () => {
+            const content = `
+function test() {
+  return undefinedVariable;
+}
+`;
+            const filePath = createTempFile(tmpDir, "test.ts", content);
+            client.updateFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            expect(diags.some((d) => d.message.includes("undefined"))).toBe(true);
+        });
+        it("should detect missing function arguments", () => {
+            const content = `
+function add(a: number, b: number): number {
+  return a + b;
+}
+const result = add(1);
+`;
+            const filePath = createTempFile(tmpDir, "test.ts", content);
+            client.updateFile(filePath, content);
+            const diags = client.getDiagnostics(filePath);
+            expect(diags.some((d) => d.message.includes("Expected"))).toBe(true);
+        });
+    });
+    describe("diagnostic severity", () => {
+        it("should have correct severity levels", () => {
+            const diags = [
+                {
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: { line: 0, character: 10 },
+                    },
+                    severity: 1, // Error
+                    message: "Error message",
+                },
+                {
+                    range: {
+                        start: { line: 1, character: 0 },
+                        end: { line: 1, character: 10 },
+                    },
+                    severity: 2, // Warning
+                    message: "Warning message",
+                },
+            ];
+            // Test that diagnostics have expected structure
+            expect(diags[0].severity).toBe(1); // Error
+            expect(diags[1].severity).toBe(2); // Warning
+            expect(diags[0].message).toContain("Error");
+        });
+    });
+});