pi-lens 3.1.2 → 3.2.0

package/clients/biome-client.test.js

@@ -1,144 +0,0 @@
-import * as fs from "node:fs";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { BiomeClient } from "./biome-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("BiomeClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new BiomeClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-biome-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isSupportedFile", () => {
-        it("should support JS/TS files", () => {
-            expect(client.isSupportedFile("test.js")).toBe(true);
-            expect(client.isSupportedFile("test.jsx")).toBe(true);
-            expect(client.isSupportedFile("test.ts")).toBe(true);
-            expect(client.isSupportedFile("test.tsx")).toBe(true);
-            expect(client.isSupportedFile("test.mjs")).toBe(true);
-            expect(client.isSupportedFile("test.cjs")).toBe(true);
-        });
-        it("should support CSS and JSON", () => {
-            expect(client.isSupportedFile("style.css")).toBe(true);
-            expect(client.isSupportedFile("config.json")).toBe(true);
-        });
-        it("should not support unsupported files", () => {
-            expect(client.isSupportedFile("test.py")).toBe(false);
-            expect(client.isSupportedFile("test.md")).toBe(false);
-            expect(client.isSupportedFile("test.txt")).toBe(false);
-        });
-    });
-    describe("isAvailable", () => {
-        it("should check biome availability", () => {
-            const available = client.isAvailable();
-            // Just verify it doesn't throw - actual availability depends on environment
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("checkFile", () => {
-        it("should return empty array for non-existent files", () => {
-            if (!client.isAvailable())
-                return;
-            const result = client.checkFile("/nonexistent/file.ts");
-            expect(result).toEqual([]);
-        });
-        it("should return array of diagnostics for TS files", {
-            timeout: 15000,
-        }, () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-const x: number = "string";
-`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.checkFile(filePath);
-            // Should return an array (may or may not have issues)
-            expect(Array.isArray(result)).toBe(true);
-        });
-    });
-    describe("formatDiagnostics", () => {
-        it("should format diagnostics for display", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Unexpected var",
-                    rule: "noVar",
-                    category: "lint",
-                    fixable: true,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags, "test.ts");
-            expect(formatted).toContain("Biome");
-            expect(formatted).toContain("1 issue");
-            expect(formatted).toContain("noVar");
-        });
-        it("should show fixable count", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Error 1",
-                    rule: "rule1",
-                    category: "lint",
-                    fixable: true,
-                },
-                {
-                    line: 2,
-                    column: 0,
-                    endLine: 2,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Warning 1",
-                    rule: "rule2",
-                    category: "lint",
-                    fixable: false,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags, "test.ts");
-            expect(formatted).toContain("1 fixable");
-        });
-        it("should truncate long diagnostic lists", () => {
-            const diags = Array.from({ length: 20 }, (_, i) => ({
-                line: i + 1,
-                column: 0,
-                endLine: i + 1,
-                endColumn: 10,
-                severity: "warning",
-                message: `Warning ${i}`,
-                rule: `rule${i}`,
-                category: "lint",
-                fixable: false,
-            }));
-            const formatted = client.formatDiagnostics(diags, "test.ts");
-            expect(formatted).toContain("...");
-            expect(formatted).toContain("5 more");
-        });
-    });
-    describe("formatFile", () => {
-        it("should format a file", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `const x={a:1,b:2}`;
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            const result = client.formatFile(filePath);
-            expect(result.success).toBe(true);
-            // Check if file was formatted (should have spaces)
-            const formatted = fs.readFileSync(filePath, "utf-8");
-            expect(formatted).toContain(": "); // Should have spaces after colons
-        });
-    });
-});

package/clients/cache-manager.test.js

@@ -1,197 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { CacheManager, } from "./cache-manager.js";
-describe("CacheManager", () => {
-    let manager;
-    let testDir;
-    beforeEach(() => {
-        manager = new CacheManager();
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-cache-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    describe("scanner cache", () => {
-        it("should return null for missing cache", () => {
-            const result = manager.readCache("knip", testDir);
-            expect(result).toBeNull();
-        });
-        it("should write and read cache", () => {
-            const data = { files: ["a.ts", "b.ts"], unused: ["x"] };
-            manager.writeCache("knip", data, testDir, { scanDurationMs: 1500 });
-            const result = manager.readCache("knip", testDir);
-            expect(result).not.toBeNull();
-            expect(result?.data).toEqual(data);
-            expect(result?.meta.scanDurationMs).toBe(1500);
-            expect(result?.meta.timestamp).toBeDefined();
-        });
-        it("should return null for stale cache", () => {
-            const data = { files: [] };
-            manager.writeCache("jscpd", data, testDir);
-            // Manually set old timestamp
-            const metaPath = path.join(testDir, ".pi-lens", "cache", "jscpd.meta.json");
-            const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
-            meta.timestamp = new Date(Date.now() - 60 * 60 * 1000).toISOString(); // 1 hour ago
-            fs.writeFileSync(metaPath, JSON.stringify(meta));
-            const result = manager.readCache("jscpd", testDir, 30 * 60 * 1000);
-            expect(result).toBeNull();
-        });
-        it("should respect custom maxAge", () => {
-            const data = { files: [] };
-            manager.writeCache("madge", data, testDir);
-            // Cache is 45 min old
-            const metaPath = path.join(testDir, ".pi-lens", "cache", "madge.meta.json");
-            const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
-            meta.timestamp = new Date(Date.now() - 45 * 60 * 1000).toISOString();
-            fs.writeFileSync(metaPath, JSON.stringify(meta));
-            // Default 30 min → stale
-            expect(manager.readCache("madge", testDir)).toBeNull();
-            // Custom 60 min → fresh
-            const result = manager.readCache("madge", testDir, 60 * 60 * 1000);
-            expect(result).not.toBeNull();
-        });
-        it("should check cache freshness", () => {
-            expect(manager.isCacheFresh("knip", testDir)).toBe(false);
-            manager.writeCache("knip", {}, testDir);
-            expect(manager.isCacheFresh("knip", testDir)).toBe(true);
-        });
-        it("should clear cache", () => {
-            manager.writeCache("jscpd", { clones: [] }, testDir);
-            expect(manager.isCacheFresh("jscpd", testDir)).toBe(true);
-            manager.clearCache("jscpd", testDir);
-            expect(manager.isCacheFresh("jscpd", testDir)).toBe(false);
-        });
-    });
-    // Helper to get test file path (absolute)
-    const testFile = (name) => path.join(testDir, name);
-    describe("turn state", () => {
-        it("should return default state when no file exists", () => {
-            const state = manager.readTurnState(testDir);
-            expect(state.files).toEqual({});
-            expect(state.turnCycles).toBe(0);
-            expect(state.maxCycles).toBe(3);
-        });
-        it("should write and read turn state", () => {
-            const state = {
-                files: {
-                    "src/a.ts": {
-                        modifiedRanges: [{ start: 1, end: 10 }],
-                        importsChanged: true,
-                        lastEdit: new Date().toISOString(),
-                    },
-                },
-                turnCycles: 1,
-                maxCycles: 3,
-                lastUpdated: "",
-            };
-            manager.writeTurnState(state, testDir);
-            const read = manager.readTurnState(testDir);
-            expect(read.turnCycles).toBe(1);
-            expect(read.files["src/a.ts"].modifiedRanges).toHaveLength(1);
-        });
-        it("should add modified ranges and merge overlapping", () => {
-            manager.addModifiedRange(testFile("src/a.ts"), { start: 1, end: 10 }, false, testDir);
-            manager.addModifiedRange(testFile("src/a.ts"), { start: 8, end: 20 }, true, testDir);
-            const state = manager.readTurnState(testDir);
-            const key = "src/a.ts";
-            const ranges = state.files[key]?.modifiedRanges;
-            expect(ranges).toHaveLength(1); // Merged into one
-            expect(ranges?.[0]).toEqual({ start: 1, end: 20 });
-            expect(state.files[key].importsChanged).toBe(true);
-        });
-        it("should track imports_changed flag", () => {
-            // First edit without import change
-            manager.addModifiedRange(testFile("src/a.ts"), { start: 1, end: 5 }, false, testDir);
-            // Second edit with import change
-            manager.addModifiedRange(testFile("src/a.ts"), { start: 10, end: 15 }, true, testDir);
-            const state = manager.readTurnState(testDir);
-            expect(state.files["src/a.ts"].importsChanged).toBe(true);
-        });
-        it("should increment turn cycle", () => {
-            manager.incrementTurnCycle(testDir);
-            manager.incrementTurnCycle(testDir);
-            const state = manager.readTurnState(testDir);
-            expect(state.turnCycles).toBe(2);
-        });
-        it("should detect max cycles exceeded", () => {
-            expect(manager.isMaxCyclesExceeded(testDir)).toBe(false);
-            manager.incrementTurnCycle(testDir);
-            manager.incrementTurnCycle(testDir);
-            manager.incrementTurnCycle(testDir);
-            expect(manager.isMaxCyclesExceeded(testDir)).toBe(true);
-        });
-        it("should clear turn state", () => {
-            manager.addModifiedRange(testFile("src/a.ts"), { start: 1, end: 10 }, true, testDir);
-            manager.incrementTurnCycle(testDir);
-            manager.clearTurnState(testDir);
-            const state = manager.readTurnState(testDir);
-            expect(Object.keys(state.files)).toHaveLength(0);
-            expect(state.turnCycles).toBe(0);
-        });
-    });
-    describe("file queries", () => {
-        beforeEach(() => {
-            // Clear any previous state from other tests
-            manager.clearTurnState(testDir);
-            // Now add our test files
-            manager.addModifiedRange(testFile("a.ts"), { start: 1, end: 10 }, false, testDir);
-            manager.addModifiedRange(testFile("b.ts"), { start: 5, end: 20 }, true, testDir);
-            manager.addModifiedRange(testFile("c.ts"), { start: 1, end: 5 }, true, testDir);
-        });
-        it("should get all files for jscpd", () => {
-            const files = manager.getFilesForJscpd(testDir);
-            expect(files).toHaveLength(3);
-        });
-        it("should get only files with import changes for madge", () => {
-            // Verify state was recorded correctly
-            const state = manager.readTurnState(testDir);
-            const fileKeys = Object.keys(state.files);
-            // Only b.ts and c.ts have importsChanged: true
-            const madgeFiles = manager.getFilesForMadge(testDir);
-            const filesWithImportsTrue = fileKeys.filter((k) => state.files[k].importsChanged);
-            expect(madgeFiles).toHaveLength(filesWithImportsTrue.length);
-        });
-    });
-    describe("range utilities", () => {
-        it("should merge non-overlapping ranges", () => {
-            const ranges = [
-                { start: 1, end: 5 },
-                { start: 10, end: 15 },
-                { start: 20, end: 25 },
-            ];
-            expect(manager.mergeRanges(ranges)).toHaveLength(3);
-        });
-        it("should merge overlapping ranges", () => {
-            const ranges = [
-                { start: 1, end: 10 },
-                { start: 5, end: 15 },
-            ];
-            const merged = manager.mergeRanges(ranges);
-            expect(merged).toHaveLength(1);
-            expect(merged[0]).toEqual({ start: 1, end: 15 });
-        });
-        it("should merge adjacent ranges", () => {
-            const ranges = [
-                { start: 1, end: 10 },
-                { start: 11, end: 20 },
-            ];
-            const merged = manager.mergeRanges(ranges);
-            expect(merged).toHaveLength(1);
-            expect(merged[0]).toEqual({ start: 1, end: 20 });
-        });
-        it("should detect line in modified range", () => {
-            const ranges = [
-                { start: 10, end: 20 },
-                { start: 30, end: 40 },
-            ];
-            expect(manager.isLineInModifiedRange(5, ranges)).toBe(false);
-            expect(manager.isLineInModifiedRange(10, ranges)).toBe(true);
-            expect(manager.isLineInModifiedRange(15, ranges)).toBe(true);
-            expect(manager.isLineInModifiedRange(20, ranges)).toBe(true);
-            expect(manager.isLineInModifiedRange(25, ranges)).toBe(false);
-            expect(manager.isLineInModifiedRange(35, ranges)).toBe(true);
-        });
-    });
-});

package/clients/complexity-client.test.js

@@ -1,234 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { ComplexityClient } from "./complexity-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("ComplexityClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new ComplexityClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-complexity-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isSupportedFile", () => {
-        it("should support TypeScript files", () => {
-            expect(client.isSupportedFile("test.ts")).toBe(true);
-            expect(client.isSupportedFile("test.tsx")).toBe(true);
-        });
-        it("should support JavaScript files", () => {
-            expect(client.isSupportedFile("test.js")).toBe(true);
-            expect(client.isSupportedFile("test.jsx")).toBe(true);
-            expect(client.isSupportedFile("test.mjs")).toBe(true);
-            expect(client.isSupportedFile("test.cjs")).toBe(true);
-        });
-        it("should not support non-TS/JS files", () => {
-            expect(client.isSupportedFile("test.py")).toBe(false);
-            expect(client.isSupportedFile("test.json")).toBe(false);
-            expect(client.isSupportedFile("test.md")).toBe(false);
-        });
-    });
-    describe("analyzeFile", () => {
-        it("should return null for non-existent files", () => {
-            const result = client.analyzeFile("/nonexistent/file.ts");
-            expect(result).toBeNull();
-        });
-        it("should analyze a simple function", () => {
-            try {
-                const content = `
-function greet(name: string): string {
-  return "Hello, " + name;
-}
-`;
-                const filePath = createTempFile(tmpDir, "simple.ts", content);
-                const result = client.analyzeFile(filePath);
-                expect(result).not.toBeNull();
-                expect(result?.functionCount).toBe(1);
-                expect(result?.cyclomaticComplexity).toBe(1);
-                expect(result?.cognitiveComplexity).toBe(0);
-                expect(result?.maxNestingDepth).toBeGreaterThanOrEqual(1);
-            }
-            finally {
-            }
-        });
-        it("should detect if statements in cyclomatic complexity", () => {
-            try {
-                const content = `
-function check(x: number): string {
-  if (x > 0) {
-    return "positive";
-  } else if (x < 0) {
-    return "negative";
-  } else {
-    return "zero";
-  }
-}
-`;
-                const filePath = createTempFile(tmpDir, "if-test.ts", content);
-                const result = client.analyzeFile(filePath);
-                expect(result).not.toBeNull();
-                // 1 base + 1 if + 1 else-if = 3
-                expect(result?.cyclomaticComplexity).toBeGreaterThanOrEqual(3);
-            }
-            finally {
-            }
-        });
-        it("should calculate maintainability index", () => {
-            try {
-                const content = `
-function simple(): number {
-  return 42;
-}
-`;
-                const filePath = createTempFile(tmpDir, "mi-test.ts", content);
-                const result = client.analyzeFile(filePath);
-                expect(result).not.toBeNull();
-                expect(result?.maintainabilityIndex).toBeGreaterThan(0);
-                expect(result?.maintainabilityIndex).toBeLessThanOrEqual(100);
-            }
-            finally {
-            }
-        });
-        it("should detect deep nesting", () => {
-            try {
-                const content = `
-function deepNest(arr: number[][][][]): number {
-  for (let i = 0; i < arr.length; i++) {
-    for (let j = 0; j < arr[i].length; j++) {
-      for (let k = 0; k < arr[i][j].length; k++) {
-        for (let l = 0; l < arr[i][j][k].length; l++) {
-          if (arr[i][j][k][l] > 0) {
-            return arr[i][j][k][l];
-          }
-        }
-      }
-    }
-  }
-  return 0;
-}
-`;
-                const filePath = createTempFile(tmpDir, "nesting-test.ts", content);
-                const result = client.analyzeFile(filePath);
-                expect(result).not.toBeNull();
-                expect(result?.maxNestingDepth).toBeGreaterThanOrEqual(5);
-            }
-            finally {
-            }
-        });
-        it("should count cognitive complexity with nesting penalty", () => {
-            try {
-                const content = `
-function nested(x: number, y: number): number {
-  if (x > 0) {
-    if (y > 0) {
-      if (x > y) {
-        return 1;
-      }
-    }
-  }
-  return 0;
-}
-`;
-                const filePath = createTempFile(tmpDir, "cognitive-test.ts", content);
-                const result = client.analyzeFile(filePath);
-                expect(result).not.toBeNull();
-                // Cognitive: 1 (if) + 2 (nested if) + 3 (deeply nested if) = 6
-                expect(result?.cognitiveComplexity).toBeGreaterThanOrEqual(6);
-            }
-            finally {
-            }
-        });
-        it("should calculate halstead volume", () => {
-            try {
-                const content = `
-function add(a: number, b: number): number {
-  return a + b;
-}
-`;
-                const filePath = createTempFile(tmpDir, "halstead-test.ts", content);
-                const result = client.analyzeFile(filePath);
-                expect(result).not.toBeNull();
-                expect(result?.halsteadVolume).toBeGreaterThan(0);
-            }
-            finally {
-            }
-        });
-        it("should measure function length", () => {
-            try {
-                const shortContent = `function short() { return 1; }`;
-                const longContent = `
-function long(): number {
-  const a = 1;
-  const b = 2;
-  const c = 3;
-  const d = 4;
-  const e = 5;
-  const f = 6;
-  const g = 7;
-  const h = 8;
-  const i = 9;
-  const j = 10;
-  return a + b + c + d + e + f + g + h + i + j;
-}
-`;
-                const shortPath = createTempFile(tmpDir, "short.ts", shortContent);
-                const longPath = createTempFile(tmpDir, "long.ts", longContent);
-                const shortResult = client.analyzeFile(shortPath);
-                const longResult = client.analyzeFile(longPath);
-                expect(shortResult?.maxFunctionLength ?? 0).toBeLessThan(longResult?.maxFunctionLength ?? 0);
-            }
-            finally {
-            }
-        });
-    });
-    describe("formatMetrics", () => {
-        it("should format metrics for display", () => {
-            const metrics = {
-                filePath: "test.ts",
-                maxNestingDepth: 4,
-                avgFunctionLength: 15,
-                maxFunctionLength: 30,
-                functionCount: 3,
-                cyclomaticComplexity: 4,
-                maxCyclomaticComplexity: 8,
-                cognitiveComplexity: 12,
-                halsteadVolume: 200,
-                maintainabilityIndex: 75,
-                linesOfCode: 100,
-                commentLines: 10,
-                codeEntropy: 0.5,
-                maxParamsInFunction: 3,
-                aiCommentPatterns: 1,
-                singleUseFunctions: 0,
-                tryCatchCount: 1,
-            };
-            const formatted = client.formatMetrics(metrics);
-            expect(formatted).toContain("test.ts");
-            expect(formatted).toContain("75/100");
-        });
-        it("should warn about low maintainability", () => {
-            const metrics = {
-                filePath: "bad.ts",
-                maxNestingDepth: 8,
-                avgFunctionLength: 60,
-                maxFunctionLength: 100,
-                functionCount: 5,
-                cyclomaticComplexity: 15,
-                maxCyclomaticComplexity: 25,
-                cognitiveComplexity: 50,
-                halsteadVolume: 800,
-                maintainabilityIndex: 25,
-                linesOfCode: 500,
-                commentLines: 10,
-                codeEntropy: 0.5,
-                maxParamsInFunction: 4,
-                aiCommentPatterns: 2,
-                singleUseFunctions: 1,
-                tryCatchCount: 2,
-            };
-            const formatted = client.formatMetrics(metrics);
-            expect(formatted).toContain("✗"); // Low MI indicator
-        });
-    });
-});

package/clients/dependency-checker.test.js

@@ -1,60 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { DependencyChecker } from "./dependency-checker.js";
-import { setupTestEnvironment } from "./test-utils.js";
-describe("DependencyChecker", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new DependencyChecker();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-dep-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isAvailable", () => {
-        it("should check madge availability", () => {
-            const available = client.isAvailable();
-            expect(typeof available).toBe("boolean");
-        });
-    });
-    describe("checkFile", () => {
-        it("should return no circular deps for non-existent files", () => {
-            const result = client.checkFile("/nonexistent/file.ts");
-            expect(result.hasCircular).toBe(false);
-            expect(result.circular).toEqual([]);
-        });
-        it("should return correct structure when not available", () => {
-            const mockChecker = new DependencyChecker();
-            if (mockChecker.isAvailable())
-                return; // Skip if available
-            const result = mockChecker.checkFile("/some/file.ts");
-            expect(result).toHaveProperty("hasCircular");
-            expect(result).toHaveProperty("circular");
-            expect(result).toHaveProperty("checked");
-        });
-    });
-    describe("scanProject", () => {
-        it("should return correct structure", () => {
-            const mockChecker = new DependencyChecker();
-            // When not available, should still return expected structure
-            const result = mockChecker.scanProject(tmpDir);
-            expect(result).toHaveProperty("circular");
-            expect(result).toHaveProperty("count");
-            expect(Array.isArray(result.circular)).toBe(true);
-        });
-    });
-    describe("formatWarning", () => {
-        it("should format circular dependency warning", () => {
-            const circularDeps = ["b.ts", "c.ts", "a.ts"];
-            const formatted = client.formatWarning("a.ts", circularDeps);
-            expect(formatted).toContain("cycle");
-            expect(formatted).toContain("a.ts");
-        });
-        it("should show the circular path", () => {
-            const circularDeps = ["b.ts", "a.ts"];
-            const formatted = client.formatWarning("a.ts", circularDeps);
-            expect(formatted).toContain("b.ts");
-        });
-    });
-});