pi-lens 3.1.2 → 3.2.0

package/clients/metrics-client.test.js

@@ -1,141 +0,0 @@
-import * as fs from "node:fs";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { MetricsClient } from "./metrics-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("MetricsClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new MetricsClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-metrics-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("calculateEntropy", () => {
-        it("should return 0 for empty string", () => {
-            expect(client.calculateEntropy("")).toBe(0);
-        });
-        it("should return 0 for single repeated character", () => {
-            expect(client.calculateEntropy("aaaaaa")).toBe(0);
-        });
-        it("should return 1 for two equally likely characters", () => {
-            expect(client.calculateEntropy("ababab")).toBe(1);
-        });
-        it("should return higher entropy for more diverse content", () => {
-            const lowEntropy = "aaaaaaaaaaaaaaaaaaaaaaaaaa";
-            const highEntropy = "abcdefghijklmnopqrstuvwxyz";
-            expect(client.calculateEntropy(highEntropy)).toBeGreaterThan(client.calculateEntropy(lowEntropy));
-        });
-        it("should match expected Shannon entropy for known input", () => {
-            // "aabb" has p(a)=0.5, p(b)=0.5, entropy = -2*(0.5*log2(0.5)) = 1
-            expect(client.calculateEntropy("aabb")).toBeCloseTo(1, 5);
-        });
-    });
-    describe("recordBaseline", () => {
-        it("should record baseline for existing file", () => {
-            const content = "const x = 1;\nconst y = 2;";
-            const filePath = createTempFile(tmpDir, "test.ts", content);
-            client.recordBaseline(filePath);
-            const metrics = client.getFileMetrics(filePath);
-            expect(metrics).not.toBeNull();
-            expect(metrics?.totalLines).toBeGreaterThanOrEqual(2);
-        });
-        it("should not record baseline for non-existent file", () => {
-            client.recordBaseline("/nonexistent/file.ts");
-            // Should not throw, just silently skip
-        });
-        it("should not overwrite existing baseline", () => {
-            const content1 = "const x = 1;\n";
-            const content2 = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
-            const filePath = createTempFile(tmpDir, "test.ts", content1);
-            client.recordBaseline(filePath);
-            // Modify file
-            fs.writeFileSync(filePath, content2);
-            // Record again - should not update baseline
-            client.recordBaseline(filePath);
-            const metrics = client.getFileMetrics(filePath);
-            expect(metrics?.entropyStart).toBe(client.calculateEntropy(content1));
-        });
-    });
-    describe("recordWrite", () => {
-        it("should track agent-written lines", () => {
-            const original = "const x = 1;\n";
-            const filePath = createTempFile(tmpDir, "test.ts", original);
-            client.recordBaseline(filePath);
-            const modified = "const x = 1;\nconst y = 2;\nconst z = 3;\n";
-            fs.writeFileSync(filePath, modified);
-            client.recordWrite(filePath, modified);
-            const aiRatio = client.getAICodeRatio();
-            expect(aiRatio.agentLines).toBeGreaterThan(0);
-        });
-        it("should calculate AI code ratio", () => {
-            const file1 = createTempFile(tmpDir, "file1.ts", "original content line 1\noriginal content line 2\n");
-            const file2 = createTempFile(tmpDir, "file2.ts", "original\n");
-            client.recordBaseline(file1);
-            client.recordBaseline(file2);
-            // Simulate agent writing new content
-            const newContent1 = "original content line 1\noriginal content line 2\nagent line 3\nagent line 4\n";
-            fs.writeFileSync(file1, newContent1);
-            client.recordWrite(file1, newContent1);
-            const aiRatio = client.getAICodeRatio();
-            expect(aiRatio.fileCount).toBe(2);
-            expect(aiRatio.ratio).toBeGreaterThanOrEqual(0);
-            expect(aiRatio.ratio).toBeLessThanOrEqual(1);
-        });
-    });
-    describe("getEntropyDeltas", () => {
-        it("should track entropy changes", () => {
-            const simple = "const x = 1;\n";
-            const filePath = createTempFile(tmpDir, "test.ts", simple);
-            client.recordBaseline(filePath);
-            // Make file more complex
-            const complex = `
-function complex(a: number, b: number, c: number): number {
-  if (a > 0) {
-    if (b > 0) {
-      if (c > 0) {
-        return a + b + c;
-      }
-    }
-  }
-  return 0;
-}
-`;
-            fs.writeFileSync(filePath, complex);
-            client.recordWrite(filePath, complex);
-            const deltas = client.getEntropyDeltas();
-            expect(deltas.length).toBe(1);
-            expect(deltas[0].delta).not.toBe(0);
-        });
-    });
-    describe("formatSessionSummary", () => {
-        it("should return empty string when no files touched", () => {
-            expect(client.formatSessionSummary()).toBe("");
-        });
-        it("should format AI code ratio when files are modified", () => {
-            const filePath = createTempFile(tmpDir, "test.ts", "original\n");
-            client.recordBaseline(filePath);
-            const modified = "original\nnew line 1\nnew line 2\n";
-            fs.writeFileSync(filePath, modified);
-            client.recordWrite(filePath, modified);
-            const summary = client.formatSessionSummary();
-            expect(summary).toContain("AI Code");
-            expect(summary).toContain("file(s)");
-        });
-    });
-    describe("reset", () => {
-        it("should clear all tracked data", () => {
-            const filePath = createTempFile(tmpDir, "test.ts", "content\n");
-            client.recordBaseline(filePath);
-            client.reset();
-            const aiRatio = client.getAICodeRatio();
-            expect(aiRatio.fileCount).toBe(0);
-            expect(client.formatSessionSummary()).toBe("");
-        });
-    });
-});

package/clients/ruff-client.test.js

@@ -1,132 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { RuffClient } from "./ruff-client.js";
-import { createTempFile, setupTestEnvironment } from "./test-utils.js";
-describe("RuffClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new RuffClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-ruff-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isPythonFile", () => {
-        it("should recognize Python files", () => {
-            expect(client.isPythonFile("test.py")).toBe(true);
-            expect(client.isPythonFile("module.py")).toBe(true);
-        });
-        it("should not recognize non-Python files", () => {
-            expect(client.isPythonFile("test.ts")).toBe(false);
-            expect(client.isPythonFile("test.js")).toBe(false);
-            expect(client.isPythonFile("test.txt")).toBe(false);
-        });
-    });
-    describe("isAvailable", () => {
-        it("should check ruff availability", () => {
-            const available = client.isAvailable();
-            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.py");
-            expect(result).toEqual([]);
-        });
-        it("should detect lint issues in Python code", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-import os
-import sys
-
-x = 1
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFile(filePath);
-            // Should detect unused imports
-            expect(result.some((d) => d.rule === "F401" || d.message.includes("unused"))).toBe(true);
-        });
-        it("should return array of diagnostics", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `
-def foo():
-    x = undefined_variable
-    return x
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFile(filePath);
-            // Should return an array
-            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: "Undefined name 'x'",
-                    rule: "F821",
-                    file: "test.py",
-                    fixable: false,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("Ruff");
-            expect(formatted).toContain("F821");
-            expect(formatted).toContain("Undefined name");
-        });
-        it("should show fixable count", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Unused import",
-                    rule: "F401",
-                    file: "test.py",
-                    fixable: true,
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("fixable");
-        });
-    });
-    describe("checkFormatting", () => {
-        it("should detect formatting issues", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `x=1
-y=2
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFormatting(filePath);
-            // Should suggest formatting (missing spaces around =)
-            expect(typeof result).toBe("string");
-        });
-        it("should return empty string for well-formatted code", () => {
-            if (!client.isAvailable())
-                return;
-            const content = `x = 1
-y = 2
-`;
-            const filePath = createTempFile(tmpDir, "test.py", content);
-            const result = client.checkFormatting(filePath);
-            // Well-formatted code should return empty or minimal output
-            expect(result).toBe("");
-        });
-    });
-});

package/clients/rust-client.test.js

@@ -1,108 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { RustClient } from "./rust-client.js";
-import { setupTestEnvironment } from "./test-utils.js";
-describe("RustClient", () => {
-    let client;
-    let tmpDir;
-    let cleanup;
-    beforeEach(() => {
-        client = new RustClient();
-        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-rust-test-"));
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    afterEach(() => {
-        cleanup();
-    });
-    describe("isRustFile", () => {
-        it("should recognize Rust files", () => {
-            expect(client.isRustFile("main.rs")).toBe(true);
-            expect(client.isRustFile("lib.rs")).toBe(true);
-        });
-        it("should not recognize non-Rust files", () => {
-            expect(client.isRustFile("main.ts")).toBe(false);
-            expect(client.isRustFile("main.py")).toBe(false);
-        });
-    });
-    describe("isAvailable", () => {
-        it("should check cargo availability", () => {
-            const available = client.isAvailable();
-            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.rs", tmpDir);
-            expect(result).toEqual([]);
-        });
-        it("should return array for valid Rust files", () => {
-            if (!client.isAvailable())
-                return;
-            // Need a Cargo.toml for cargo to work
-            fs.writeFileSync(path.join(tmpDir, "Cargo.toml"), `
-[package]
-name = "test"
-version = "0.1.0"
-edition = "2021"
-`);
-            fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
-            fs.writeFileSync(path.join(tmpDir, "src", "main.rs"), `
-fn main() {
-    println!("Hello, world!");
-}
-`);
-            const result = client.checkFile(path.join(tmpDir, "src", "main.rs"), tmpDir);
-            expect(Array.isArray(result)).toBe(true);
-        });
-    });
-    describe("formatDiagnostics", () => {
-        it("should format diagnostics for display", () => {
-            const diags = [
-                {
-                    line: 3,
-                    column: 0,
-                    endLine: 3,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "cannot find value `x` in this scope",
-                    code: "E0425",
-                    file: "main.rs",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("Rust");
-            expect(formatted).toContain("1 issue");
-            expect(formatted).toContain("E0425");
-        });
-        it("should show error and warning counts", () => {
-            const diags = [
-                {
-                    line: 1,
-                    column: 0,
-                    endLine: 1,
-                    endColumn: 10,
-                    severity: "error",
-                    message: "Error",
-                    file: "test.rs",
-                },
-                {
-                    line: 2,
-                    column: 0,
-                    endLine: 2,
-                    endColumn: 10,
-                    severity: "warning",
-                    message: "Warning",
-                    file: "test.rs",
-                },
-            ];
-            const formatted = client.formatDiagnostics(diags);
-            expect(formatted).toContain("1 error(s)");
-            expect(formatted).toContain("1 warning(s)");
-        });
-    });
-});

package/clients/sanitize.test.js

@@ -1,177 +0,0 @@
-/**
- * Tests for sanitize.ts
- * Tool output sanitization
- */
-import { describe, expect, it } from "vitest";
-import { extractErrorMessage, normalizeWhitespace, sanitizeBiomeOutput, sanitizeLine, sanitizeOutput, sanitizeRuffOutput, sanitizeToolOutput, stripAnsi, truncateMessage, } from "./sanitize.js";
-describe("stripAnsi", () => {
-    it("should remove ANSI color codes", () => {
-        expect(stripAnsi("\x1b[31mError\x1b[0m")).toBe("Error");
-        expect(stripAnsi("\x1b[1;32mSuccess\x1b[0m")).toBe("Success");
-    });
-    it("should remove extended ANSI codes", () => {
-        expect(stripAnsi("\x1b[1;2;3mText\x1b[0m")).toBe("Text");
-    });
-    it("should return original string if no ANSI codes", () => {
-        expect(stripAnsi("Plain text")).toBe("Plain text");
-    });
-});
-describe("normalizeWhitespace", () => {
-    it("should collapse multiple spaces", () => {
-        expect(normalizeWhitespace("Hello    World")).toBe("Hello World");
-    });
-    it("should trim lines", () => {
-        expect(normalizeWhitespace("  Hello  \n  World  ")).toBe("Hello\nWorld");
-    });
-    it("should remove empty lines", () => {
-        expect(normalizeWhitespace("Hello\n\n\nWorld")).toBe("Hello\nWorld");
-    });
-});
-describe("sanitizeLine", () => {
-    it("should remove common error prefixes", () => {
-        expect(sanitizeLine("[error] Something went wrong")).toBe("Something went wrong");
-        expect(sanitizeLine("error: Something went wrong")).toBe("Something went wrong");
-    });
-    it("should remove check/cross marks", () => {
-        expect(sanitizeLine("× Error message")).toBe("Error message");
-        expect(sanitizeLine("✓ Success message")).toBe("Success message");
-    });
-    it("should normalize whitespace", () => {
-        expect(sanitizeLine("  Error   message  ")).toBe("Error message");
-    });
-});
-describe("sanitizeOutput", () => {
-    it("should return empty string for empty input", () => {
-        expect(sanitizeOutput("")).toBe("");
-        expect(sanitizeOutput("   ")).toBe("");
-    });
-    it("should filter out detail lines", () => {
-        const output = "Error message\n    at line 10\n    at function foo";
-        const result = sanitizeOutput(output);
-        expect(result).toBe("Error message");
-    });
-    it("should remove ANSI codes and normalize", () => {
-        const output = "\x1b[31mError\x1b[0m\n\x1b[32mSuccess\x1b[0m";
-        const result = sanitizeOutput(output);
-        expect(result).toBe("Error\nSuccess");
-    });
-});
-describe("extractErrorMessage", () => {
-    it("should return undefined for empty input", () => {
-        expect(extractErrorMessage("")).toBeUndefined();
-        expect(extractErrorMessage("   ")).toBeUndefined();
-    });
-    it("should return first error line containing error indicator", () => {
-        // Note: extractErrorMessage sanitizes lines first, then checks isErrorLine
-        // Since "error:" prefix is removed by sanitizeLine, we need to use a keyword
-        // that remains in the sanitized line, like "failed" or "syntax"
-        const output = "Some info\nOperation failed: disk full\nMore info";
-        const result = extractErrorMessage(output);
-        expect(result).toBe("Operation failed: disk full");
-    });
-    it("should fall back to first non-empty line", () => {
-        const output = "info line\nanother info\nand more";
-        expect(extractErrorMessage(output)).toBe("info line");
-    });
-    it("should find error by keyword", () => {
-        const result = extractErrorMessage("warning: low severity\nfailed: operation");
-        // extractErrorMessage returns the first line with error indicators
-        // "failed:" contains "failed" which matches ERROR_INDICATORS
-        expect(result).toBe("failed: operation");
-    });
-});
-describe("truncateMessage", () => {
-    it("should not truncate short messages", () => {
-        const msg = "Short message";
-        expect(truncateMessage(msg, 100)).toBe(msg);
-    });
-    it("should truncate long messages", () => {
-        const msg = "A".repeat(200);
-        const result = truncateMessage(msg, 50);
-        expect(result).toBe(`${"A".repeat(49)}…`);
-    });
-    it("should use default max length of 140", () => {
-        const msg = "A".repeat(200);
-        const result = truncateMessage(msg);
-        expect(result.length).toBe(140);
-    });
-});
-describe("sanitizeToolOutput", () => {
-    it("should return empty result for empty input", () => {
-        const result = sanitizeToolOutput("");
-        expect(result.summary).toBeUndefined();
-        expect(result.details).toBeUndefined();
-        expect(result.truncated).toBe(false);
-    });
-    it("should extract summary and details", () => {
-        const output = "error: something failed\nline 2\nline 3\nline 4";
-        const result = sanitizeToolOutput(output);
-        // sanitizeLine removes "error:" prefix
-        expect(result.summary).toContain("something failed");
-        expect(result.details).toBeDefined();
-    });
-    it("should mark as truncated when too many lines", () => {
-        const lines = [];
-        for (let i = 0; i < 30; i++) {
-            lines.push(`error line ${i}`);
-        }
-        const result = sanitizeToolOutput(lines.join("\n"));
-        expect(result.truncated).toBe(true);
-        expect(result.details).toContain("more lines");
-    });
-    it("should respect max summary length", () => {
-        const output = `error: ${"x".repeat(200)}`;
-        const result = sanitizeToolOutput(output, 50);
-        expect(result.summary?.length).toBeLessThanOrEqual(50);
-    });
-});
-describe("sanitizeBiomeOutput", () => {
-    it("should parse JSON diagnostics", () => {
-        const json = JSON.stringify({
-            diagnostics: [
-                {
-                    location: {
-                        path: "file.ts",
-                        span: { start: { line: 10, column: 0 } },
-                    },
-                    message: "Unexpected token",
-                },
-            ],
-        });
-        const result = sanitizeBiomeOutput(json);
-        expect(result).toContain("file.ts");
-        expect(result).toContain("11"); // line + 1
-        expect(result).toContain("Unexpected token");
-    });
-    it("should handle text output with errors", () => {
-        const output = "error: something went wrong\ninfo: some info";
-        const result = sanitizeBiomeOutput(output);
-        expect(result).toContain("error");
-    });
-    it("should return empty for empty input", () => {
-        expect(sanitizeBiomeOutput("")).toBe("");
-    });
-});
-describe("sanitizeRuffOutput", () => {
-    it("should parse JSON diagnostics", () => {
-        const json = JSON.stringify([
-            {
-                location: { row: 10, column: 5 },
-                code: "E501",
-                message: "Line too long",
-            },
-        ]);
-        const result = sanitizeRuffOutput(json);
-        expect(result).toContain("10:5");
-        expect(result).toContain("[E501]");
-        expect(result).toContain("Line too long");
-    });
-    it("should handle text output", () => {
-        const output = "file.py:10:5 [E501] Line too long";
-        const result = sanitizeRuffOutput(output);
-        expect(result).toContain("E501");
-    });
-    it("should return empty for empty input", () => {
-        expect(sanitizeRuffOutput("")).toBe("");
-    });
-});

package/clients/secrets-scanner.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatSecrets, scanForSecrets } from "./secrets-scanner.js";
-describe("scanForSecrets", () => {
-    it("should detect Stripe/OpenAI keys (sk-*)", () => {
-        const content = `const apiKey = "sk-live-1234567890abcdefghij";`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        expect(findings[0].message).toContain("Stripe or OpenAI");
-    });
-    it("should detect GitHub personal tokens (ghp_*)", () => {
-        const content = `token = "ghp_1234567890abcdefghijklmnopqrstuvwxyz";`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        expect(findings[0].message).toContain("GitHub personal");
-    });
-    it("should detect AWS access keys (AKIA*)", () => {
-        const content = `const AWS_KEY = "AKIAIOSFODNN7EXAMPLE";`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        expect(findings[0].message).toContain("AWS access key");
-    });
-    it("should detect private key material", () => {
-        const content = `-----BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEA...`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        expect(findings[0].message).toContain("Private key");
-    });
-    it("should detect hardcoded passwords", () => {
-        const content = `const config = { password: "hunter2" };`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        expect(findings[0].message).toContain("password");
-    });
-    it("should detect secrets in .env format", () => {
-        const content = `API_KEY=sk-live-1234567890abcdefghij
-DATABASE_URL=postgres://localhost`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        // sk-* pattern catches this first (more specific)
-        expect(findings[0].message).toContain("Stripe or OpenAI");
-    });
-    it("should NOT flag safe content", () => {
-        const content = `
-const name = "test";
-const url = "https://example.com";
-const port = 3000;
-const message = "Hello world";
-`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(0);
-    });
-    it("should NOT flag env var references", () => {
-        const content = `const key = process.env.API_KEY;`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(0);
-    });
-    it("should detect multiple secrets", () => {
-        const content = `
-const sk = "sk-live-1234567890abcdefghij";
-const gh = "ghp_1234567890abcdefghijklmnopqrstuvwxyz";
-`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(2);
-    });
-    it("should report correct line numbers", () => {
-        const content = `line 1
-line 2
-const secret = "sk-live-1234567890abcdefghij";
-line 4`;
-        const findings = scanForSecrets(content);
-        expect(findings.length).toBe(1);
-        expect(findings[0].line).toBe(3);
-    });
-});
-describe("formatSecrets", () => {
-    it("should format findings for terminal output", () => {
-        const findings = [
-            { line: 5, message: "Possible Stripe or OpenAI API key (sk-*)" },
-        ];
-        const output = formatSecrets(findings, "src/config.ts");
-        expect(output).toContain("STOP");
-        expect(output).toContain("1 potential secret(s)");
-        expect(output).toContain("L5");
-        expect(output).toContain("src/config.ts");
-    });
-    it("should return empty string for no findings", () => {
-        const output = formatSecrets([], "src/config.ts");
-        expect(output).toBe("");
-    });
-    it("should truncate at 5 findings", () => {
-        const findings = Array.from({ length: 10 }, (_, i) => ({
-            line: i + 1,
-            message: "Test secret",
-        }));
-        const output = formatSecrets(findings, "src/config.ts");
-        expect(output).toContain("10 potential secret(s)");
-        expect(output).toContain("... and 5 more");
-    });
-});