pi-lens 3.2.0 → 3.3.1

package/clients/sanitize.test.js

@@ -0,0 +1,177 @@
+/**
+ * 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

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

package/clients/test-runner-client.test.js

@@ -0,0 +1,192 @@
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { TestRunnerClient } from "./test-runner-client.js";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
+describe("TestRunnerClient", () => {
+    let client;
+    let tmpDir;
+    let cleanup;
+    beforeEach(() => {
+        client = new TestRunnerClient();
+        ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-test-runner-"));
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    afterEach(() => {
+        cleanup();
+    });
+    describe("detectRunner", () => {
+        it("should detect vitest from config file", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            const result = client.detectRunner(tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.runner).toBe("vitest");
+        });
+        it("should detect jest from config file", () => {
+            createTempFile(tmpDir, "jest.config.js", "module.exports = {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            const result = client.detectRunner(tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.runner).toBe("jest");
+        });
+        it("should detect pytest from config file", () => {
+            createTempFile(tmpDir, "pytest.ini", "[tool:pytest]");
+            createTempFile(tmpDir, "src/app.py", "x = 1");
+            const result = client.detectRunner(tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.runner).toBe("pytest");
+        });
+        it("should detect runner from node_modules", () => {
+            // Create a node_modules/vitest to simulate installed package
+            createTempFile(tmpDir, "node_modules/vitest/package.json", "{}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            const result = client.detectRunner(tmpDir);
+            // Should detect vitest from node_modules
+            expect(result).not.toBeNull();
+        });
+        it("should prefer vitest over jest when both exist", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "jest.config.js", "module.exports = {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            const result = client.detectRunner(tmpDir);
+            expect(result?.runner).toBe("vitest");
+        });
+    });
+    describe("findTestFile", () => {
+        it("should find test file with .test.ts suffix", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            createTempFile(tmpDir, "src/app.test.ts", "describe('app', () => {});");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.testFile).toContain("app.test.ts");
+            expect(result?.runner).toBe("vitest");
+        });
+        it("should find test file with .spec.ts suffix", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            createTempFile(tmpDir, "src/app.spec.ts", "describe('app', () => {});");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.testFile).toContain("app.spec.ts");
+        });
+        it("should find test file in __tests__ directory", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            createTempFile(tmpDir, "src/__tests__/app.test.ts", "describe('app', () => {});");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.testFile).toContain("__tests__");
+        });
+        it("should find test file in top-level tests/ directory", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            createTempFile(tmpDir, "tests/app.test.ts", "describe('app', () => {});");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.testFile).toContain(path.join("tests", "app.test.ts"));
+        });
+        it("should find pytest test file with test_ prefix", () => {
+            createTempFile(tmpDir, "pytest.ini", "[tool:pytest]");
+            createTempFile(tmpDir, "src/app.py", "x = 1");
+            createTempFile(tmpDir, "tests/test_app.py", "def test_app(): pass");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.py"), tmpDir);
+            expect(result).not.toBeNull();
+            expect(result?.testFile).toContain("test_app.py");
+            expect(result?.runner).toBe("pytest");
+        });
+        it("should return null when no test file found", () => {
+            createTempFile(tmpDir, "vitest.config.ts", "export default {}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
+            expect(result).toBeNull();
+        });
+        it("should find test file even without config (if runner installed)", () => {
+            // Simulate vitest installed in node_modules
+            createTempFile(tmpDir, "node_modules/vitest/package.json", "{}");
+            createTempFile(tmpDir, "src/app.ts", "export const app = {};");
+            createTempFile(tmpDir, "src/app.test.ts", "describe('app', () => {});");
+            const result = client.findTestFile(path.join(tmpDir, "src/app.ts"), tmpDir);
+            // Should find the test file since vitest is "installed"
+            expect(result).not.toBeNull();
+        });
+    });
+    describe("formatResult", () => {
+        it("should format passing tests", () => {
+            const result = {
+                file: "/test/app.test.ts",
+                sourceFile: "/test/app.ts",
+                runner: "vitest",
+                passed: 5,
+                failed: 0,
+                skipped: 0,
+                failures: [],
+                duration: 420,
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("✓");
+            expect(formatted).toContain("5/5 passed");
+            expect(formatted).toContain("0.42s");
+        });
+        it("should format failing tests", () => {
+            const result = {
+                file: "/test/app.test.ts",
+                sourceFile: "/test/app.ts",
+                runner: "vitest",
+                passed: 3,
+                failed: 2,
+                skipped: 0,
+                failures: [
+                    {
+                        name: "should add",
+                        message: "expected 4, got 3",
+                        location: "app.test.ts:10",
+                    },
+                    {
+                        name: "should subtract",
+                        message: "expected 1, got 2",
+                        location: "app.test.ts:20",
+                    },
+                ],
+                duration: 420,
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("✗");
+            expect(formatted).toContain("2/5 failed");
+            expect(formatted).toContain("should add");
+            expect(formatted).toContain("should subtract");
+        });
+        it("should format runner errors", () => {
+            const result = {
+                file: "/test/app.test.ts",
+                sourceFile: "/test/app.ts",
+                runner: "vitest",
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                failures: [],
+                duration: 0,
+                error: "Test file not found",
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toContain("⚠");
+            expect(formatted).toContain("Could not run tests");
+        });
+        it("should return empty string for no tests", () => {
+            const result = {
+                file: "/test/app.test.ts",
+                sourceFile: "/test/app.ts",
+                runner: "vitest",
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                failures: [],
+                duration: 0,
+            };
+            const formatted = client.formatResult(result);
+            expect(formatted).toBe("");
+        });
+    });
+});