pi-lens 3.2.0 → 3.3.1

package/clients/dispatch/dispatcher.inline.test.js

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { formatDiagnostic } from "./utils/format-utils.js";
+describe("formatDiagnostic inline output verification", () => {
+    it("should display complete architect messages (NOT truncated to 'No ')", () => {
+        // Simulate actual architect diagnostic
+        const diagnostic = {
+            id: "architect-1",
+            message: "No absolute Windows paths — breaks CI and cross-platform builds.",
+            filePath: "/test.ts",
+            line: 5,
+            severity: "warning",
+            semantic: "warning",
+            tool: "architect",
+            rule: "no-absolute-windows-paths",
+        };
+        const output = formatDiagnostic(diagnostic);
+        console.log("\n=== Architect Message Output ===");
+        console.log(output);
+        console.log("=================================\n");
+        // Verify complete message is shown
+        expect(output).toBe("  L5: No absolute Windows paths — breaks CI and cross-platform builds.");
+    });
+    it("should display code fix messages inline correctly", () => {
+        // This is what I actually see from ts-lsp runner
+        const diagnostic = {
+            id: "ts-12-2345",
+            message: "Property 'debug' is missing in type 'Config'\n💡 Quick fix: Add missing property 'debug'",
+            filePath: "/src/config.ts",
+            line: 12,
+            severity: "error",
+            semantic: "blocking",
+            tool: "ts-lsp",
+            rule: "TS2345",
+            fixable: true,
+            fixSuggestion: "Add missing property 'debug'",
+        };
+        const output = formatDiagnostic(diagnostic);
+        console.log("\n=== Code Fix Message Output ===");
+        console.log(output);
+        console.log("================================\n");
+        // Both lines should be properly indented
+        expect(output).toBe("  L12: Property 'debug' is missing in type 'Config'\n  💡 Quick fix: Add missing property 'debug'");
+    });
+    it("should prove architect 'No ' messages are complete (not noise)", () => {
+        // All the "No " messages from default-architect.yaml
+        const testMessages = [
+            "No absolute Windows paths — breaks CI and cross-platform builds.",
+            "No hardcoded localhost URLs — use environment variables or a config service.",
+            "No empty catch/except blocks. Swallowing errors makes debugging impossible — at least log the error.",
+            "No hardcoded secrets — use environment variables or a secrets manager.",
+            "No 'any' types — use 'unknown' or define a proper interface to maintain type safety.",
+        ];
+        for (let i = 0; i < testMessages.length; i++) {
+            const diagnostic = {
+                id: `architect-${i}`,
+                message: testMessages[i],
+                filePath: "/test.ts",
+                line: i + 1,
+                severity: "warning",
+                semantic: "warning",
+                tool: "architect",
+                rule: "test",
+            };
+            const output = formatDiagnostic(diagnostic);
+            // Each message should be complete, NOT truncated to just "No "
+            expect(output.length).toBeGreaterThan(15); // More than "  L1: No "
+            expect(output).toContain("No ");
+            expect(output).toContain("—"); // Contains the em-dash explanation
+            // Verify it's not truncated
+            const messageAfterNo = output.split("No ")[1];
+            expect(messageAfterNo.length).toBeGreaterThan(5);
+        }
+    });
+});

package/clients/dispatch/dispatcher.test.js

@@ -0,0 +1,116 @@
+/**
+ * Tests for declarative dispatch system
+ */
+import { beforeEach, describe, expect, it } from "vitest";
+import { createDispatchContext, getRunner, getRunnersForKind, listRunners, registerRunner, } from "./dispatcher.js";
+// --- Test Runners ---
+const testRunner1 = {
+    id: "test-runner-1",
+    appliesTo: ["jsts", "python"],
+    priority: 10,
+    enabledByDefault: true,
+    async run() {
+        return { status: "succeeded", diagnostics: [], semantic: "none" };
+    },
+};
+const testRunner2 = {
+    id: "test-runner-2",
+    appliesTo: ["python"],
+    priority: 20,
+    enabledByDefault: true,
+    async run() {
+        return { status: "succeeded", diagnostics: [], semantic: "none" };
+    },
+};
+const testRunnerWithCondition = {
+    id: "test-runner-conditional",
+    appliesTo: ["jsts"],
+    priority: 5,
+    enabledByDefault: false,
+    when: async (ctx) => ctx.autofix,
+    async run() {
+        return { status: "succeeded", diagnostics: [], semantic: "none" };
+    },
+};
+// --- Tests ---
+describe("Runner Registry", () => {
+    beforeEach(() => {
+        // Note: In a real test suite, we'd reset the registry between tests
+        registerRunner(testRunner1);
+        registerRunner(testRunner2);
+        registerRunner(testRunnerWithCondition);
+    });
+    it("should register a runner", () => {
+        const runner = getRunner("test-runner-1");
+        expect(runner).toBeDefined();
+        expect(runner?.id).toBe("test-runner-1");
+    });
+    it("should return undefined for unknown runner", () => {
+        const runner = getRunner("unknown-runner");
+        expect(runner).toBeUndefined();
+    });
+    it("should get runners for a specific kind", () => {
+        const jstsRunners = getRunnersForKind("jsts");
+        expect(jstsRunners.length).toBeGreaterThan(0);
+        expect(jstsRunners.some((r) => r.id === "test-runner-1")).toBe(true);
+    });
+    it("should return runners sorted by priority", () => {
+        const jstsRunners = getRunnersForKind("jsts");
+        const priorities = jstsRunners.map((r) => r.priority ?? 100);
+        for (let i = 1; i < priorities.length; i++) {
+            expect(priorities[i - 1]).toBeLessThanOrEqual(priorities[i]);
+        }
+    });
+    it("should list all registered runners", () => {
+        const all = listRunners();
+        expect(all.length).toBeGreaterThanOrEqual(3);
+    });
+    it("should reject duplicate registrations", () => {
+        // This should log an error but not throw
+        expect(() => registerRunner(testRunner1)).not.toThrow();
+    });
+});
+describe("Dispatch Context", () => {
+    it("should create a dispatch context", () => {
+        const mockPi = { getFlag: (flag) => flag === "autofix" };
+        const ctx = createDispatchContext("test.ts", "/project", mockPi);
+        // Path is normalized to absolute path (Windows compatibility)
+        expect(ctx.filePath).toContain("test.ts");
+        expect(ctx.cwd).toBe("/project");
+        expect(ctx.autofix).toBe(false);
+        expect(ctx.deltaMode).toBe(true);
+    });
+    it("should detect file kind", () => {
+        const mockPi = { getFlag: () => false };
+        const ctxTs = createDispatchContext("test.ts", "/project", mockPi);
+        expect(ctxTs.kind).toBe("jsts");
+        const ctxPy = createDispatchContext("test.py", "/project", mockPi);
+        expect(ctxPy.kind).toBe("python");
+        const ctxGo = createDispatchContext("test.go", "/project", mockPi);
+        expect(ctxGo.kind).toBe("go");
+    });
+    it("should respect autofix flag", () => {
+        const mockPiNoFix = { getFlag: (_f) => false };
+        const ctx1 = createDispatchContext("test.ts", "/project", mockPiNoFix);
+        expect(ctx1.autofix).toBe(false);
+        const mockPiWithFix = { getFlag: (f) => f === "autofix-biome" };
+        const ctx2 = createDispatchContext("test.ts", "/project", mockPiWithFix);
+        expect(ctx2.autofix).toBe(true);
+    });
+});
+describe("Conditional Runners", () => {
+    beforeEach(() => {
+        registerRunner(testRunnerWithCondition);
+    });
+    it("should respect when condition", async () => {
+        const runner = getRunner("test-runner-conditional");
+        expect(runner).toBeDefined();
+        const mockPiNoFix = { getFlag: () => false };
+        const ctxNoFix = createDispatchContext("test.ts", "/project", mockPiNoFix);
+        // When autofix is false, the condition should return false
+        if (runner?.when) {
+            const shouldRun = await runner.when(ctxNoFix);
+            expect(shouldRun).toBe(false);
+        }
+    });
+});

package/clients/dispatch/runners/architect.test.js

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+function createMockContext(filePath, kind = "jsts", cwd) {
+    return {
+        filePath,
+        cwd: cwd || process.cwd(),
+        kind,
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => undefined, set: () => { }, clear: () => { } },
+        pi: { getFlag: () => false },
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+describe("architect runner", () => {
+    const testDir = path.join(process.env.TEMP || "/tmp", `architect_test_${Date.now()}`);
+    const configPath = path.join(testDir, ".pi-lens", "architect.yaml");
+    beforeAll(() => {
+        // Create test config
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        fs.writeFileSync(configPath, `version: "1.0"
+rules:
+  - pattern: "**/*.ts"
+    max_lines: 50
+    must_not:
+      - pattern: 'hardcoded_secret_12345'
+        message: "No hardcoded secrets"
+        fix: "Use process.env.SECRET"
+      - pattern: 'console\.log'
+        message: "No console.log in production"
+`);
+    });
+    afterAll(() => {
+        try {
+            if (fs.existsSync(testDir)) {
+                fs.rmSync(testDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    it("should load default config when no user config exists", async () => {
+        const module = await import("./architect.js");
+        const runner = module.default;
+        // Use a unique temp dir with no user config (will fall back to default)
+        const noUserConfigDir = path.join(process.env.TEMP || "/tmp", `no_arch_user_config_${Date.now()}`);
+        fs.mkdirSync(noUserConfigDir, { recursive: true });
+        // Create a very large file that should trigger default max_lines rule
+        const tmpFile = path.join(noUserConfigDir, `large_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, Array(5000).fill("// line").join("\n"));
+        try {
+            const result = await runner.run(createMockContext(tmpFile, "jsts", noUserConfigDir));
+            // Should use default config and find violations
+            expect(result.status).toBe("succeeded");
+            // Should have size violation from default config
+            expect(result.diagnostics.some((d) => d.message.includes("line limit"))).toBe(true);
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile))
+                    fs.unlinkSync(tmpFile);
+                if (fs.existsSync(noUserConfigDir))
+                    fs.rmdirSync(noUserConfigDir);
+            }
+            catch { }
+        }
+    });
+    it("should detect file size violations", async () => {
+        const module = await import("./architect.js");
+        const runner = module.default;
+        const tmpFile = path.join(testDir, `large_file_${Date.now()}.ts`);
+        // Create file with 100 lines (exceeds 50 line limit)
+        fs.writeFileSync(tmpFile, Array(100).fill("// line").join("\n"));
+        try {
+            const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
+            expect(result.status).toBe("succeeded");
+            expect(result.diagnostics.length).toBeGreaterThan(0);
+            expect(result.diagnostics.some((d) => d.message.includes("50 line limit"))).toBe(true);
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile))
+                    fs.unlinkSync(tmpFile);
+            }
+            catch { }
+        }
+    });
+    it("should detect pattern violations", async () => {
+        const module = await import("./architect.js");
+        const runner = module.default;
+        const tmpFile = path.join(testDir, `bad_patterns_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `const x = hardcoded_secret_12345;
+console.log(x);
+`);
+        try {
+            const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
+            expect(result.status).toBe("succeeded");
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(2);
+            expect(result.diagnostics.some((d) => d.message.includes("hardcoded"))).toBe(true);
+            expect(result.diagnostics.some((d) => d.message.includes("console.log"))).toBe(true);
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile))
+                    fs.unlinkSync(tmpFile);
+            }
+            catch { }
+        }
+    });
+    it("should return no diagnostics for clean files", async () => {
+        const module = await import("./architect.js");
+        const runner = module.default;
+        const tmpFile = path.join(testDir, `clean_${Date.now()}.ts`);
+        // Small file (20 lines) with no violations
+        fs.writeFileSync(tmpFile, Array(20).fill("// clean code").join("\n"));
+        try {
+            const result = await runner.run(createMockContext(tmpFile, "jsts", testDir));
+            expect(result.status).toBe("succeeded");
+            expect(result.diagnostics.length).toBe(0);
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile))
+                    fs.unlinkSync(tmpFile);
+            }
+            catch { }
+        }
+    });
+    it("should skip test files", async () => {
+        const module = await import("./architect.js");
+        const runner = module.default;
+        // The runner should have skipTestFiles: true
+        expect(runner.skipTestFiles).toBe(true);
+    });
+});

package/clients/dispatch/runners/ast-grep-napi.test.js

@@ -0,0 +1,106 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+function createMockContext(filePath, kind = "jsts") {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind,
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+describe("ast-grep-napi vs CLI comparison", () => {
+    it("should load the napi module", async () => {
+        const napiModule = await import("./ast-grep-napi.js");
+        expect(napiModule.default.id).toBe("ast-grep-napi");
+        expect(napiModule.default.appliesTo).toEqual(["jsts"]);
+    });
+    it("should scan TypeScript file and return succeeded status", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `napi_test_${Date.now()}.ts`);
+        fs.writeFileSync(tmpFile, `// Test file with various patterns
+function test(items: string[]) {
+    for (let i = 0; i < items.length; i++) {
+        console.log(items[i]);
+    }
+
+    try {
+        riskyOperation();
+    } catch (e) {
+        // empty catch
+    }
+
+    return await fetchData();
+}
+
+async function fetchData() {
+    return await Promise.resolve(42);
+}
+
+function riskyOperation() {
+    debugger;
+}
+`);
+        try {
+            // Test NAPI version
+            const napiModule = await import("./ast-grep-napi.js");
+            const napiRunner = napiModule.default;
+            console.time("napi");
+            let napiResult;
+            try {
+                napiResult = await napiRunner.run(createMockContext(tmpFile));
+            }
+            catch (error) {
+                console.error("NAPI runner threw error:", error);
+                throw error;
+            }
+            console.timeEnd("napi");
+            console.log("NAPI result status:", napiResult.status);
+            console.log("NAPI result semantic:", napiResult.semantic);
+            console.log("NAPI result diagnostics count:", napiResult.diagnostics?.length);
+            // Should complete successfully (not skipped, not failed)
+            expect(napiResult.status).toBe("succeeded");
+            expect(napiResult.semantic).toBe("warning"); // Has findings, so marked as warning
+            // Log findings
+            console.log("NAPI found:", napiResult.diagnostics.length, "issues");
+            console.log("\n=== NAPI FINDINGS ===");
+            napiResult.diagnostics.forEach((d, i) => {
+                console.log(`${i + 1}. Line ${d.line}: ${d.rule}`);
+            });
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile)) {
+                    fs.unlinkSync(tmpFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    });
+    it("should skip non-TS/JS files", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `napi_test_py_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, "# Python file\nprint('hello')");
+        try {
+            const napiModule = await import("./ast-grep-napi.js");
+            const napiRunner = napiModule.default;
+            const result = await napiRunner.run(createMockContext(tmpFile, "python"));
+            expect(result.status).toBe("skipped");
+        }
+        finally {
+            try {
+                if (fs.existsSync(tmpFile)) {
+                    fs.unlinkSync(tmpFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    });
+});

package/clients/dispatch/runners/lsp.js

@@ -34,11 +34,48 @@ const lspRunner = {
         if (!content) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        // Open file in LSP and get diagnostics
-        await lspService.openFile(ctx.filePath, content);
-        // getDiagnostics() internally calls waitForDiagnostics() with bus
-        // subscription + 150ms debounce + 3s timeout
-        const lspDiags = await lspService.getDiagnostics(ctx.filePath);
+        // Try to open file in LSP and get diagnostics
+        // If the server fails to spawn or crashes, this will be caught
+        let lspDiags = [];
+        let serverFailed = false;
+        let failureReason = "";
+        try {
+            await lspService.openFile(ctx.filePath, content);
+            // getDiagnostics() internally calls waitForDiagnostics() with bus
+            // subscription + 150ms debounce + 3s timeout
+            lspDiags = await lspService.getDiagnostics(ctx.filePath);
+        }
+        catch (err) {
+            serverFailed = true;
+            failureReason = err instanceof Error ? err.message : String(err);
+            // Check if this is a server spawn/connection error
+            if (failureReason.includes("spawn") ||
+                failureReason.includes("exited") ||
+                failureReason.includes("connection") ||
+                failureReason.includes("JSON RPC")) {
+                // Mark this server as broken so we don't keep trying
+                console.error(`[lsp-runner] LSP server failed for ${ctx.filePath}: ${failureReason}`);
+            }
+        }
+        // If server failed to provide diagnostics, report as failed status
+        if (serverFailed) {
+            return {
+                status: "failed",
+                diagnostics: [
+                    {
+                        id: `lsp:server-error:0`,
+                        message: `LSP server failed: ${failureReason}`,
+                        filePath: ctx.filePath,
+                        line: 1,
+                        column: 1,
+                        severity: "error",
+                        semantic: "warning", // Don't block - fallback to other runners
+                        tool: "lsp",
+                    },
+                ],
+                semantic: "warning",
+            };
+        }
         // Convert LSP diagnostics to our format
         // Defensive: filter out malformed diagnostics that may lack range
         const diagnostics = lspDiags