pi-lens 3.2.0 → 3.3.1

package/clients/cache-manager.test.js

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

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

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