pi-lens 3.1.2 → 3.2.0

package/clients/file-kinds.test.js

@@ -1,169 +0,0 @@
-/**
- * Tests for file-kinds.ts
- * Centralized file type detection
- */
-import { describe, expect, it } from "vitest";
-import { detectFileKind, getExtensionsForKind, getFileKindLabel, getLanguageId, isCodeKind, isConfigKind, isFileKind, isScannableFile, } from "./file-kinds.js";
-describe("detectFileKind", () => {
-    it("should detect JavaScript/TypeScript files", () => {
-        expect(detectFileKind("src/app.ts")).toBe("jsts");
-        expect(detectFileKind("src/app.tsx")).toBe("jsts");
-        expect(detectFileKind("src/app.js")).toBe("jsts");
-        expect(detectFileKind("src/app.jsx")).toBe("jsts");
-        expect(detectFileKind("src/app.mjs")).toBe("jsts");
-        expect(detectFileKind("src/app.cjs")).toBe("jsts");
-    });
-    it("should detect Python files", () => {
-        expect(detectFileKind("app.py")).toBe("python");
-        expect(detectFileKind("tests/test_app.py")).toBe("python");
-    });
-    it("should detect Go files", () => {
-        expect(detectFileKind("main.go")).toBe("go");
-        expect(detectFileKind("pkg/utils.go")).toBe("go");
-    });
-    it("should detect Rust files", () => {
-        expect(detectFileKind("main.rs")).toBe("rust");
-        expect(detectFileKind("lib/app.rs")).toBe("rust");
-    });
-    it("should detect C++ files", () => {
-        expect(detectFileKind("main.cpp")).toBe("cxx");
-        expect(detectFileKind("header.hpp")).toBe("cxx");
-        expect(detectFileKind("file.cc")).toBe("cxx");
-        expect(detectFileKind("file.hxx")).toBe("cxx");
-    });
-    it("should detect CMake files", () => {
-        expect(detectFileKind("CMakeLists.txt")).toBe("cmake");
-        expect(detectFileKind("build.cmake")).toBe("cmake");
-    });
-    it("should detect Shell files", () => {
-        expect(detectFileKind("script.sh")).toBe("shell");
-        expect(detectFileKind("script.bash")).toBe("shell");
-        expect(detectFileKind("Makefile")).toBe("shell");
-    });
-    it("should detect JSON files", () => {
-        expect(detectFileKind("config.json")).toBe("json");
-        expect(detectFileKind("package.json")).toBe("json");
-    });
-    it("should detect Markdown files", () => {
-        expect(detectFileKind("README.md")).toBe("markdown");
-        expect(detectFileKind("docs/guide.mdx")).toBe("markdown");
-    });
-    it("should detect CSS files", () => {
-        expect(detectFileKind("style.css")).toBe("css");
-        expect(detectFileKind("style.scss")).toBe("css");
-        expect(detectFileKind("style.less")).toBe("css");
-    });
-    it("should detect YAML files", () => {
-        expect(detectFileKind("config.yaml")).toBe("yaml");
-        expect(detectFileKind("config.yml")).toBe("yaml");
-    });
-    it("should return undefined for unknown extensions", () => {
-        expect(detectFileKind("file.xyz")).toBeUndefined();
-        expect(detectFileKind("file")).toBeUndefined();
-    });
-    it("should handle case-insensitive extensions", () => {
-        expect(detectFileKind("file.TS")).toBe("jsts");
-        expect(detectFileKind("file.PY")).toBe("python");
-    });
-    it("should handle paths with special characters", () => {
-        expect(detectFileKind("/path/to/file.ts")).toBe("jsts");
-        expect(detectFileKind("C:\\path\\to\\file.py")).toBe("python");
-    });
-});
-describe("isFileKind", () => {
-    it("should check single file kind", () => {
-        expect(isFileKind("app.ts", "jsts")).toBe(true);
-        expect(isFileKind("app.py", "jsts")).toBe(false);
-    });
-    it("should check multiple file kinds", () => {
-        expect(isFileKind("app.ts", ["jsts", "python"])).toBe(true);
-        expect(isFileKind("app.py", ["jsts", "python"])).toBe(true);
-        expect(isFileKind("app.go", ["jsts", "python"])).toBe(false);
-    });
-    it("should return false for undefined file kind", () => {
-        expect(isFileKind("file.xyz", "jsts")).toBe(false);
-        expect(isFileKind("file.xyz", ["jsts", "python"])).toBe(false);
-    });
-});
-describe("isCodeKind", () => {
-    it("should identify code file kinds", () => {
-        expect(isCodeKind("jsts")).toBe(true);
-        expect(isCodeKind("python")).toBe(true);
-        expect(isCodeKind("go")).toBe(true);
-        expect(isCodeKind("rust")).toBe(true);
-        expect(isCodeKind("cxx")).toBe(true);
-        expect(isCodeKind("shell")).toBe(true);
-    });
-    it("should reject non-code file kinds", () => {
-        expect(isCodeKind("json")).toBe(false);
-        expect(isCodeKind("markdown")).toBe(false);
-        expect(isCodeKind("css")).toBe(false);
-    });
-});
-describe("isConfigKind", () => {
-    it("should identify config file kinds", () => {
-        expect(isConfigKind("json")).toBe(true);
-        expect(isConfigKind("yaml")).toBe(true);
-        expect(isConfigKind("markdown")).toBe(true);
-        expect(isConfigKind("css")).toBe(true);
-    });
-    it("should reject non-config file kinds", () => {
-        expect(isConfigKind("jsts")).toBe(false);
-        expect(isConfigKind("python")).toBe(false);
-        expect(isConfigKind("go")).toBe(false);
-    });
-});
-describe("isScannableFile", () => {
-    it("should return true for code files", () => {
-        expect(isScannableFile("app.ts")).toBe(true);
-        expect(isScannableFile("app.py")).toBe(true);
-    });
-    it("should return true for config files", () => {
-        expect(isScannableFile("config.json")).toBe(true);
-        expect(isScannableFile("README.md")).toBe(true);
-    });
-    it("should return false for test files", () => {
-        expect(isScannableFile("app.test.ts")).toBe(false);
-        expect(isScannableFile("app.spec.ts")).toBe(false);
-        expect(isScannableFile("test-app.ts")).toBe(false);
-    });
-    it("should return false for unknown extensions", () => {
-        expect(isScannableFile("file.xyz")).toBe(false);
-    });
-});
-describe("getLanguageId", () => {
-    it("should return correct language IDs", () => {
-        expect(getLanguageId("jsts")).toBe("typescript");
-        expect(getLanguageId("python")).toBe("python");
-        expect(getLanguageId("go")).toBe("go");
-        expect(getLanguageId("rust")).toBe("rust");
-        expect(getLanguageId("cxx")).toBe("cpp");
-        expect(getLanguageId("json")).toBe("json");
-    });
-    it("should return plaintext for unknown kinds", () => {
-        expect(getLanguageId("unknown")).toBe("plaintext");
-    });
-});
-describe("getExtensionsForKind", () => {
-    it("should return extensions for jsts", () => {
-        const exts = getExtensionsForKind("jsts");
-        expect(exts).toContain(".ts");
-        expect(exts).toContain(".tsx");
-        expect(exts).toContain(".js");
-        expect(exts).toContain(".jsx");
-    });
-    it("should return extensions for python", () => {
-        const exts = getExtensionsForKind("python");
-        expect(exts).toEqual([".py"]);
-    });
-});
-describe("getFileKindLabel", () => {
-    it("should return human-readable labels", () => {
-        expect(getFileKindLabel("jsts")).toBe("JavaScript/TypeScript");
-        expect(getFileKindLabel("python")).toBe("Python");
-        expect(getFileKindLabel("cxx")).toBe("C/C++");
-    });
-    it("should return kind as fallback", () => {
-        expect(getFileKindLabel("unknown")).toBe("unknown");
-    });
-});

package/clients/go-client.test.js

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

package/clients/jscpd-client.test.js

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

package/clients/knip-client.test.js

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