pi-lens 3.2.0 → 3.3.0

package/clients/__tests__/formatters.test.js

@@ -0,0 +1,271 @@
+/**
+ * Formatter Detection Tests
+ *
+ * Tests smart detection of formatters based on:
+ * - Config files (biome.json, .prettierrc, etc.)
+ * - Dependencies (package.json, requirements.txt)
+ * - Binary availability
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { biomeFormatter, prettierFormatter, ruffFormatter, blackFormatter, gofmtFormatter, rustfmtFormatter, getFormattersForFile, clearFormatterCache, formatFile, } from "../formatters.js";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEST_DIR = path.join(__dirname, "..", "..", "test-formatters");
+describe("Formatter Detection", () => {
+    beforeEach(() => {
+        clearFormatterCache();
+        if (fs.existsSync(TEST_DIR)) {
+            fs.rmSync(TEST_DIR, { recursive: true });
+        }
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+    });
+    afterEach(() => {
+        clearFormatterCache();
+        if (fs.existsSync(TEST_DIR)) {
+            fs.rmSync(TEST_DIR, { recursive: true });
+        }
+    });
+    describe("biomeFormatter.detect()", () => {
+        it("should detect biome.json config file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), '{"formatter": {}}');
+            const detected = await biomeFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect biome.jsonc config file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.jsonc"), "{}");
+            const detected = await biomeFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect @biomejs/biome in devDependencies", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { "@biomejs/biome": "^1.0.0" } }));
+            const detected = await biomeFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should return false when no biome config", async () => {
+            const detected = await biomeFormatter.detect(TEST_DIR);
+            expect(detected).toBe(false);
+        });
+        it("should find biome.json in parent directory", async () => {
+            const subDir = path.join(TEST_DIR, "src", "components");
+            fs.mkdirSync(subDir, { recursive: true });
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const detected = await biomeFormatter.detect(subDir);
+            expect(detected).toBe(true);
+        });
+    });
+    describe("prettierFormatter.detect()", () => {
+        it("should detect .prettierrc config file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, ".prettierrc"), "{}");
+            const detected = await prettierFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect prettier in devDependencies", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
+            const detected = await prettierFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect prettier field in package.json", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ prettier: { semi: false } }));
+            const detected = await prettierFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should return false when no prettier config", async () => {
+            const detected = await prettierFormatter.detect(TEST_DIR);
+            expect(detected).toBe(false);
+        });
+    });
+    describe("ruffFormatter.detect()", () => {
+        it("should detect [tool.ruff] in pyproject.toml", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.ruff]\nline-length = 100");
+            const detected = await ruffFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect ruff.toml config file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "ruff.toml"), "line-length = 100");
+            const detected = await ruffFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect .ruff.toml config file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, ".ruff.toml"), "line-length = 100");
+            const detected = await ruffFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect ruff in requirements.txt", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "requirements.txt"), "ruff==0.1.0\n");
+            const detected = await ruffFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect ruff even if [tool.black] exists (no preference logic)", async () => {
+            // Create pyproject.toml with black config
+            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.black]\nline-length = 100");
+            // Also write requirements with ruff
+            fs.writeFileSync(path.join(TEST_DIR, "requirements.txt"), "ruff\n");
+            // The current implementation doesn't have preference logic
+            // Both black and ruff would be detected if their configs exist
+            // This is intentional - users can disable one if needed
+            const detected = await blackFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+    });
+    describe("blackFormatter.detect()", () => {
+        it("should detect [tool.black] in pyproject.toml", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.black]\nline-length = 100");
+            const detected = await blackFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should detect black in requirements.txt", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "requirements.txt"), "black==23.0.0\n");
+            const detected = await blackFormatter.detect(TEST_DIR);
+            expect(detected).toBe(true);
+        });
+        it("should return false when no black config", async () => {
+            const detected = await blackFormatter.detect(TEST_DIR);
+            expect(detected).toBe(false);
+        });
+    });
+    describe("gofmtFormatter.detect()", () => {
+        it("should detect gofmt binary availability", async () => {
+            // This test depends on whether gofmt is installed
+            // We can't reliably test this in CI, but we can verify the logic
+            const detected = await gofmtFormatter.detect(TEST_DIR);
+            // Should return boolean based on binary availability
+            expect(typeof detected).toBe("boolean");
+        });
+    });
+    describe("rustfmtFormatter.detect()", () => {
+        it("should detect rustfmt binary availability", async () => {
+            const detected = await rustfmtFormatter.detect(TEST_DIR);
+            expect(typeof detected).toBe("boolean");
+        });
+    });
+    describe("getFormattersForFile()", () => {
+        it("should return formatters for TypeScript file with biome config", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
+            expect(formatters.map(f => f.name)).toContain("biome");
+        });
+        it("should return formatters for TypeScript file with prettier", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
+            expect(formatters.map(f => f.name)).toContain("prettier");
+        });
+        it("should return multiple formatters for TypeScript file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
+            // Both biome and prettier should be returned
+            expect(formatters.length).toBeGreaterThanOrEqual(1);
+            const names = formatters.map(f => f.name);
+            expect(names).toContain("biome");
+        });
+        it("should return ruff for Python file with pyproject.toml", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.ruff]\nline-length = 100");
+            const pyFile = path.join(TEST_DIR, "test.py");
+            const formatters = await getFormattersForFile(pyFile, TEST_DIR);
+            expect(formatters.map(f => f.name)).toContain("ruff");
+        });
+        it("should return black for Python file with black config", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.black]\nline-length = 100");
+            const pyFile = path.join(TEST_DIR, "test.py");
+            const formatters = await getFormattersForFile(pyFile, TEST_DIR);
+            // Should prefer black over ruff
+            expect(formatters.map(f => f.name)).toContain("black");
+        });
+        it("should return empty array for unsupported extensions", async () => {
+            const txtFile = path.join(TEST_DIR, "test.txt");
+            fs.writeFileSync(txtFile, "content");
+            const formatters = await getFormattersForFile(txtFile, TEST_DIR);
+            expect(formatters).toEqual([]);
+        });
+        it("should cache detection results", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            // First call
+            await getFormattersForFile(tsFile, TEST_DIR);
+            // Second call should use cache
+            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
+            expect(formatters.map(f => f.name)).toContain("biome");
+        });
+    });
+    describe("clearFormatterCache()", () => {
+        it("should clear cached detection results", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            // First detection
+            await getFormattersForFile(tsFile, TEST_DIR);
+            // Clear cache
+            clearFormatterCache();
+            // Delete config
+            fs.rmSync(path.join(TEST_DIR, "biome.json"));
+            // Should re-detect (now without biome)
+            const formatters = await getFormattersForFile(tsFile, TEST_DIR);
+            expect(formatters.map(f => f.name)).not.toContain("biome");
+        });
+    });
+    describe("formatFile()", () => {
+        it("should format file and report changes", async () => {
+            // Create a simple test - we'll skip actual formatter execution
+            // because we can't guarantee formatters are installed
+            const testFile = path.join(TEST_DIR, "test.txt");
+            fs.writeFileSync(testFile, "unchanged");
+            const mockFormatter = {
+                name: "mock",
+                command: ["echo", "$FILE"],
+                extensions: [".txt"],
+                detect: async () => true,
+            };
+            const result = await formatFile(testFile, mockFormatter);
+            // echo command should succeed but not change file
+            expect(result.success).toBe(true);
+        });
+        it("should handle formatter execution with valid command", async () => {
+            const testFile = path.join(TEST_DIR, "valid.txt");
+            fs.writeFileSync(testFile, "content");
+            // Use a valid command that succeeds but doesn't modify file
+            const mockFormatter = {
+                name: "valid",
+                command: process.platform === "win32" ? ["cmd", "/c", "echo", "$FILE"] : ["echo", "$FILE"],
+                extensions: [".txt"],
+                detect: async () => true,
+            };
+            const result = await formatFile(testFile, mockFormatter);
+            // Should not throw, completes with success
+            expect(result).toBeDefined();
+            expect(typeof result.success).toBe("boolean");
+        });
+    });
+    describe("Formatter extensions", () => {
+        it("biome should handle TS/JS/JSON/CSS/Vue/Svelte", () => {
+            expect(biomeFormatter.extensions).toContain(".ts");
+            expect(biomeFormatter.extensions).toContain(".tsx");
+            expect(biomeFormatter.extensions).toContain(".js");
+            expect(biomeFormatter.extensions).toContain(".json");
+            expect(biomeFormatter.extensions).toContain(".css");
+            expect(biomeFormatter.extensions).toContain(".vue");
+            expect(biomeFormatter.extensions).toContain(".svelte");
+        });
+        it("prettier should handle Markdown and YAML", () => {
+            expect(prettierFormatter.extensions).toContain(".md");
+            expect(prettierFormatter.extensions).toContain(".mdx");
+            expect(prettierFormatter.extensions).toContain(".yaml");
+            expect(prettierFormatter.extensions).toContain(".yml");
+        });
+        it("ruff should handle Python files", () => {
+            expect(ruffFormatter.extensions).toContain(".py");
+            expect(ruffFormatter.extensions).toContain(".pyi");
+        });
+        it("gofmt should handle Go files", () => {
+            expect(gofmtFormatter.extensions).toContain(".go");
+        });
+        it("rustfmt should handle Rust files", () => {
+            expect(rustfmtFormatter.extensions).toContain(".rs");
+        });
+    });
+});

package/clients/agent-behavior-client.test.js

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { AgentBehaviorClient } from "./agent-behavior-client.js";
+describe("AgentBehaviorClient", () => {
+    let client;
+    beforeEach(() => {
+        client = new AgentBehaviorClient();
+        client.reset();
+    });
+    describe("blind write detection", () => {
+        it("should NOT warn when read precedes write", () => {
+            client.recordToolCall("read", "src/file.ts");
+            client.recordToolCall("edit", "src/file.ts");
+            const warnings = client.recordToolCall("write", "src/file.ts");
+            expect(warnings).toHaveLength(0);
+        });
+        it("should warn when multiple writes happen without reads", () => {
+            // First write is OK (no history)
+            client.recordToolCall("write", "src/file1.ts");
+            // Second write - still in window, accumulates
+            client.recordToolCall("edit", "src/file2.ts");
+            // Third write without any read - now we have a pattern
+            const warnings = client.recordToolCall("edit", "src/file3.ts");
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].type).toBe("blind-write");
+        });
+        it("should not warn for single write with no history", () => {
+            const warnings = client.recordToolCall("write", "src/file.ts");
+            expect(warnings).toHaveLength(0);
+        });
+    });
+    describe("thrashing detection", () => {
+        it("should warn after 3 consecutive identical tool calls", () => {
+            client.recordToolCall("bash", undefined);
+            // Second call - no warning yet
+            let warnings = client.recordToolCall("bash", undefined);
+            expect(warnings).toHaveLength(0);
+            // Third consecutive - should warn
+            warnings = client.recordToolCall("bash", undefined);
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].type).toBe("thrashing");
+            expect(warnings[0].details.callCount).toBe(3);
+        });
+        it("should NOT warn for different tool calls", () => {
+            client.recordToolCall("read", "src/file.ts");
+            client.recordToolCall("bash", "npm test");
+            const warnings = client.recordToolCall("edit", "src/file.ts");
+            expect(warnings).toHaveLength(0);
+        });
+        it("should reset count when tool changes", () => {
+            client.recordToolCall("bash", undefined);
+            client.recordToolCall("bash", undefined);
+            // Different tool resets the count
+            client.recordToolCall("read", "src/file.ts");
+            // Now start new consecutive sequence
+            client.recordToolCall("bash", undefined);
+            const warnings = client.recordToolCall("bash", undefined);
+            expect(warnings).toHaveLength(0); // Only 2 consecutive, not 3
+        });
+    });
+    describe("edit counting", () => {
+        it("should track edit count per file", () => {
+            client.recordToolCall("edit", "src/a.ts");
+            client.recordToolCall("edit", "src/a.ts");
+            client.recordToolCall("edit", "src/b.ts");
+            expect(client.getEditCount("src/a.ts")).toBe(2);
+            expect(client.getEditCount("src/b.ts")).toBe(1);
+            expect(client.getEditCount("src/c.ts")).toBe(0);
+        });
+    });
+    describe("formatWarnings", () => {
+        it("should format multiple warnings", () => {
+            const warnings = [
+                {
+                    type: "blind-write",
+                    message: "⚠ BLIND WRITE — editing file",
+                    severity: "warning",
+                    details: {},
+                },
+                {
+                    type: "thrashing",
+                    message: "🔴 THRASHING — 3 consecutive calls",
+                    severity: "error",
+                    details: {},
+                },
+            ];
+            const formatted = client.formatWarnings(warnings);
+            expect(formatted).toContain("BLIND WRITE");
+            expect(formatted).toContain("THRASHING");
+        });
+        it("should return empty string for no warnings", () => {
+            expect(client.formatWarnings([])).toBe("");
+        });
+    });
+});

package/clients/biome-client.test.js

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