pi-lens 3.2.0 → 3.3.1

package/clients/dispatch/__tests__/autofix-integration.test.js

@@ -0,0 +1,245 @@
+/**
+ * Autofix Integration Tests
+ *
+ * Tests for auto-format and auto-fix behavior.
+ * Validates that autofix runs by default and can be disabled.
+ */
+import { describe, expect, it, vi } from "vitest";
+// --- Mock Runners ---
+const createAutofixRunner = (id) => ({
+    id,
+    appliesTo: ["jsts"],
+    priority: 10,
+    enabledByDefault: true,
+    when: async (ctx) => ctx.autofix,
+    async run(ctx) {
+        return {
+            status: "succeeded",
+            diagnostics: [
+                {
+                    id: `${id}:fixed`,
+                    message: `Fixed by ${id}`,
+                    filePath: ctx.filePath,
+                    line: 1,
+                    column: 1,
+                    severity: "info",
+                    semantic: "fixed",
+                    tool: id,
+                },
+            ],
+            semantic: "fixed",
+        };
+    },
+});
+const createNonAutofixRunner = (id) => ({
+    id,
+    appliesTo: ["jsts"],
+    priority: 20,
+    enabledByDefault: true,
+    async run(ctx) {
+        return {
+            status: "succeeded",
+            diagnostics: [
+                {
+                    id: `${id}:info`,
+                    message: `Info from ${id}`,
+                    filePath: ctx.filePath,
+                    line: 1,
+                    column: 1,
+                    severity: "info",
+                    semantic: "silent",
+                    tool: id,
+                },
+            ],
+            semantic: "none",
+        };
+    },
+});
+const createMockContext = (filePath = "test.ts", autofix = true) => ({
+    filePath,
+    cwd: "/test",
+    kind: "jsts",
+    pi: {
+        getFlag: vi.fn((flag) => {
+            if (flag === "no-autofix")
+                return !autofix;
+            return autofix;
+        }),
+    },
+    autofix,
+    deltaMode: false,
+    baselines: new Map(),
+    hasTool: vi.fn(() => Promise.resolve(false)),
+    log: vi.fn(),
+});
+const _createMockGroup = (runners) => ({
+    runnerIds: runners.map((r) => r.id),
+    mode: "all",
+});
+// --- Tests ---
+describe("Autofix Integration", () => {
+    describe("Autofix by Default", () => {
+        it("should run autofix runners when enabled", async () => {
+            const autofixRunner = createAutofixRunner("biome-fix");
+            const ctx = createMockContext("test.ts", true);
+            // The runner should apply (autofix is true)
+            const shouldRun = await autofixRunner.when?.(ctx);
+            expect(shouldRun).toBe(true);
+        });
+        it("should skip autofix runners when disabled", async () => {
+            const autofixRunner = createAutofixRunner("biome-fix");
+            const ctx = createMockContext("test.ts", false);
+            // The runner should not apply (autofix is false)
+            const shouldRun = await autofixRunner.when?.(ctx);
+            expect(shouldRun).toBe(false);
+        });
+    });
+    describe("--no-autofix Flag", () => {
+        it("should disable autofix with --no-autofix flag", () => {
+            const mockPi = {
+                getFlag: vi.fn((flag) => flag === "no-autofix"),
+            };
+            // Simulate flag check in dispatch context
+            const autofixEnabled = !mockPi.getFlag("no-autofix");
+            expect(autofixEnabled).toBe(false);
+        });
+        it("should enable autofix without --no-autofix flag", () => {
+            const mockPi = {
+                getFlag: vi.fn((_flag) => false),
+            };
+            const autofixEnabled = !mockPi.getFlag("no-autofix");
+            expect(autofixEnabled).toBe(true);
+        });
+    });
+    describe("File Modification Warnings", () => {
+        it("should track when format changes files", async () => {
+            // Simulate format result
+            const formatResult = {
+                formatChanged: true,
+                fixedCount: 0,
+            };
+            // Should show warning
+            const shouldWarn = formatResult.formatChanged || formatResult.fixedCount > 0;
+            expect(shouldWarn).toBe(true);
+        });
+        it("should track when autofix changes files", async () => {
+            // Simulate autofix result
+            const fixResult = {
+                formatChanged: false,
+                fixedCount: 3,
+            };
+            // Should show warning
+            const shouldWarn = fixResult.formatChanged || fixResult.fixedCount > 0;
+            expect(shouldWarn).toBe(true);
+        });
+        it("should show warning message format", () => {
+            const warningMessage = "⚠️ **File modified by auto-format/fix. Re-read before next edit.**";
+            expect(warningMessage).toContain("File modified");
+            expect(warningMessage).toContain("auto-format");
+            expect(warningMessage).toContain("fix");
+        });
+    });
+    describe("Runner Categories", () => {
+        it("should have autofix runners with when conditions", () => {
+            const autofixRunner = createAutofixRunner("ruff-fix");
+            expect(autofixRunner.when).toBeDefined();
+            expect(typeof autofixRunner.when).toBe("function");
+        });
+        it("should have non-autofix runners without when conditions", () => {
+            const regularRunner = createNonAutofixRunner("ts-lsp");
+            // Regular runners run regardless of autofix setting
+            expect(regularRunner.when).toBeUndefined();
+        });
+        it("should categorize fixed diagnostics correctly", async () => {
+            const autofixRunner = createAutofixRunner("biome-fix");
+            const ctx = createMockContext("test.ts", true);
+            const result = await autofixRunner.run(ctx);
+            // Should have semantic: "fixed"
+            expect(result.semantic).toBe("fixed");
+            // Diagnostics should also be fixed
+            for (const diag of result.diagnostics || []) {
+                expect(diag.semantic).toBe("fixed");
+            }
+        });
+    });
+    describe("Format vs Autofix Coordination", () => {
+        it("should run format before lint", async () => {
+            const order = [];
+            const formatRunner = {
+                id: "format",
+                appliesTo: ["jsts"],
+                priority: 5, // Lower = runs first
+                enabledByDefault: true,
+                async run() {
+                    order.push("format");
+                    return { status: "succeeded", diagnostics: [], semantic: "none" };
+                },
+            };
+            const lintRunner = {
+                id: "lint",
+                appliesTo: ["jsts"],
+                priority: 10, // Higher = runs after
+                enabledByDefault: true,
+                async run() {
+                    order.push("lint");
+                    return { status: "succeeded", diagnostics: [], semantic: "none" };
+                },
+            };
+            // Verify priority ordering
+            expect(formatRunner.priority).toBeLessThan(lintRunner.priority);
+        });
+        it("should handle format and lint race conditions", async () => {
+            // Simulate format changing file while lint is running
+            const _ctx = createMockContext("test.ts", true);
+            // Format result
+            const formatChanged = true;
+            // Lint should still work
+            const lintResult = {
+                status: "succeeded",
+                diagnostics: [],
+                semantic: "none",
+            };
+            // Both should complete without error
+            expect(formatChanged).toBe(true);
+            expect(lintResult.status).toBe("succeeded");
+        });
+    });
+    describe("Real-world Scenarios", () => {
+        it("should handle ruff autofix flow", async () => {
+            const ruffRunner = createAutofixRunner("ruff");
+            const ctxWithAutofix = createMockContext("test.py", true);
+            const ctxNoAutofix = createMockContext("test.py", false);
+            // With autofix
+            const shouldRunWith = await ruffRunner.when?.(ctxWithAutofix);
+            expect(shouldRunWith).toBe(true);
+            // Without autofix
+            const shouldRunWithout = await ruffRunner.when?.(ctxNoAutofix);
+            expect(shouldRunWithout).toBe(false);
+        });
+        it("should handle biome autofix flow", async () => {
+            const biomeRunner = createAutofixRunner("biome-fix");
+            const ctxWithAutofix = createMockContext("test.ts", true);
+            const ctxNoAutofix = createMockContext("test.ts", false);
+            // With autofix
+            const shouldRunWith = await biomeRunner.when?.(ctxWithAutofix);
+            expect(shouldRunWith).toBe(true);
+            // Without autofix
+            const shouldRunWithout = await biomeRunner.when?.(ctxNoAutofix);
+            expect(shouldRunWithout).toBe(false);
+        });
+        it("should show file modification warning only when changes made", async () => {
+            // No changes
+            const noChanges = { formatChanged: false, fixedCount: 0 };
+            expect(noChanges.formatChanged || noChanges.fixedCount > 0).toBe(false);
+            // Format only
+            const formatOnly = { formatChanged: true, fixedCount: 0 };
+            expect(formatOnly.formatChanged || formatOnly.fixedCount > 0).toBe(true);
+            // Fix only
+            const fixOnly = { formatChanged: false, fixedCount: 5 };
+            expect(fixOnly.formatChanged || fixOnly.fixedCount > 0).toBe(true);
+            // Both
+            const both = { formatChanged: true, fixedCount: 3 };
+            expect(both.formatChanged || both.fixedCount > 0).toBe(true);
+        });
+    });
+});

package/clients/dispatch/__tests__/runner-registration.test.js

@@ -0,0 +1,234 @@
+/**
+ * Runner Registration Verification Tests
+ *
+ * Ensures all runners are properly registered and unique.
+ * Catches issues like missing runner imports.
+ */
+import { beforeAll, describe, expect, it } from "vitest";
+import { clearRunnerRegistry, getRunner, getRunnersForKind, listRunners, } from "../dispatcher.js";
+describe("Runner Registration", () => {
+    let allRunners;
+    beforeAll(async () => {
+        // Clear any existing registrations for clean slate
+        clearRunnerRegistry();
+        // Import runners to trigger registration
+        // This is the critical import that ensures runners are registered before dispatch
+        await import("../runners/index.js");
+        // Get all registered runners
+        allRunners = listRunners();
+    });
+    describe("Basic Registration", () => {
+        it("should have runners registered", () => {
+            expect(allRunners.length).toBeGreaterThan(0);
+        });
+        it("should have unique runner IDs", () => {
+            const ids = allRunners.map((r) => r.id);
+            const uniqueIds = new Set(ids);
+            // All IDs should be unique
+            expect(uniqueIds.size).toBe(ids.length);
+        });
+        it("should be able to retrieve any registered runner by ID", () => {
+            for (const runner of allRunners) {
+                // Skip disabled runners (those with no appliesTo)
+                if (!(runner.appliesTo?.length ?? 0))
+                    continue;
+                const retrieved = getRunner(runner.id);
+                expect(retrieved).toBeDefined();
+                expect(retrieved?.id).toBe(runner.id);
+            }
+        });
+        it("should return undefined for unknown runner IDs", () => {
+            const unknown = getRunner("definitely-not-a-real-runner-id");
+            expect(unknown).toBeUndefined();
+        });
+    });
+    describe("Runner Properties", () => {
+        it("should have valid appliesTo for all runners", () => {
+            const validKinds = [
+                "jsts",
+                "python",
+                "rust",
+                "go",
+                "shell",
+                "json",
+                "markdown",
+                "cmake",
+                "cxx",
+            ];
+            for (const runner of allRunners) {
+                // Skip disabled runners (those with no appliesTo)
+                if (!(runner.appliesTo?.length ?? 0))
+                    continue;
+                // Each runner should have at least one appliesTo
+                if (!(runner.appliesTo?.length ?? 0)) {
+                    console.error(`Runner ${runner.id} has no appliesTo`);
+                }
+                expect(runner.appliesTo?.length ?? 0, `Runner ${runner.id} should have appliesTo`).toBeGreaterThan(0);
+                // All appliesTo should be valid kinds
+                for (const kind of runner.appliesTo) {
+                    expect(validKinds).toContain(kind);
+                }
+            }
+        });
+        it("should have priority defined", () => {
+            for (const runner of allRunners) {
+                // Skip disabled runners (those with no appliesTo)
+                if (!(runner.appliesTo?.length ?? 0))
+                    continue;
+                // Priority should be a number (or undefined, which defaults to 100)
+                if (runner.priority !== undefined) {
+                    expect(typeof runner.priority).toBe("number");
+                    expect(runner.priority).toBeGreaterThanOrEqual(0);
+                }
+            }
+        });
+        it("should have enabledByDefault boolean", () => {
+            for (const runner of allRunners) {
+                // Skip disabled runners (those with no appliesTo)
+                if (!(runner.appliesTo?.length ?? 0))
+                    continue;
+                expect(typeof runner.enabledByDefault).toBe("boolean");
+            }
+        });
+        it("should have a run function", () => {
+            for (const runner of allRunners) {
+                // Skip disabled runners (those with no appliesTo)
+                if (!(runner.appliesTo?.length ?? 0))
+                    continue;
+                expect(typeof runner.run).toBe("function");
+            }
+        });
+    });
+    describe("Expected Runners", () => {
+        const expectedRunners = [
+            "ts-lsp",
+            "ts-slop",
+            "pyright",
+            "python-slop",
+            "biome-lint",
+            "oxlint",
+            "ruff-lint",
+            "shellcheck",
+            "spellcheck",
+            "ast-grep-napi",
+            "architect",
+            "config-validation",
+        ];
+        it("should have all expected critical runners", () => {
+            const registeredIds = allRunners.map((r) => r.id);
+            for (const expectedId of expectedRunners) {
+                expect(registeredIds).toContain(expectedId);
+            }
+        });
+        it("should have TypeScript-related runners", () => {
+            const tsRunners = getRunnersForKind("jsts");
+            const tsIds = tsRunners.map((r) => r.id);
+            // Should have at least ts-lsp
+            expect(tsIds).toContain("ts-lsp");
+            // Should have ts-slop
+            expect(tsIds).toContain("ts-slop");
+        });
+        it("should have Python-related runners", () => {
+            const pyRunners = getRunnersForKind("python");
+            const pyIds = pyRunners.map((r) => r.id);
+            // Should have pyright
+            expect(pyIds).toContain("pyright");
+            // Should have python-slop
+            expect(pyIds).toContain("python-slop");
+        });
+        it("should have lint runners", () => {
+            const jstsRunners = getRunnersForKind("jsts");
+            const lintIds = ["biome-lint", "oxlint", "ts-slop"];
+            for (const lintId of lintIds) {
+                // At least one should be present
+                const hasLintRunner = jstsRunners.some((r) => r.id === lintId);
+                if (hasLintRunner) {
+                    // Found at least one
+                    expect(hasLintRunner).toBe(true);
+                    break;
+                }
+            }
+        });
+        it("should have format runners", () => {
+            const jstsRunners = getRunnersForKind("jsts");
+            const formatIds = ["biome-lint"];
+            for (const formatId of formatIds) {
+                const hasFormatRunner = jstsRunners.some((r) => r.id === formatId);
+                if (hasFormatRunner) {
+                    expect(hasFormatRunner).toBe(true);
+                    break;
+                }
+            }
+        });
+    });
+    describe("Runner Import Verification", () => {
+        it("should load runner index without errors", async () => {
+            // This catches the bug where runners weren't imported
+            // in the dispatch system
+            expect(async () => {
+                await import("../runners/index.js");
+            }).not.toThrow();
+        });
+        it("should have runners available after import", async () => {
+            // Clear and re-import to verify fresh load
+            const initialCount = listRunners().length;
+            // Import again - should not duplicate due to id check
+            await import("../runners/index.js");
+            const finalCount = listRunners().length;
+            // Should be same count (no duplicates)
+            expect(finalCount).toBe(initialCount);
+        });
+    });
+    describe("Runner Condition Functions", () => {
+        it("should handle runners with when conditions", () => {
+            const runnersWithWhen = allRunners.filter((r) => r.when !== undefined);
+            for (const runner of runnersWithWhen) {
+                // when should be a function
+                expect(typeof runner.when).toBe("function");
+            }
+        });
+        it("should evaluate when conditions correctly", async () => {
+            // Find a runner with a when condition (e.g., autofix runners)
+            const conditionalRunner = allRunners.find((r) => r.when !== undefined);
+            if (conditionalRunner) {
+                // Create mock contexts
+                const ctxWithAutofix = {
+                    autofix: true,
+                    filePath: "test.ts",
+                    cwd: "/test",
+                    kind: "jsts",
+                    pi: { getFlag: () => false },
+                    deltaMode: false,
+                    baselines: new Map(),
+                    hasTool: async () => false,
+                    log: () => { },
+                };
+                const ctxWithoutAutofix = {
+                    ...ctxWithAutofix,
+                    autofix: false,
+                };
+                // Evaluate condition
+                const shouldRunWith = await conditionalRunner.when?.(ctxWithAutofix);
+                const shouldRunWithout = await conditionalRunner.when?.(ctxWithoutAutofix);
+                // Results should be boolean
+                expect(typeof shouldRunWith).toBe("boolean");
+                expect(typeof shouldRunWithout).toBe("boolean");
+            }
+        });
+    });
+    describe("Priority Ordering", () => {
+        it("should return runners sorted by priority", () => {
+            const kinds = ["jsts", "python", "rust", "go"];
+            for (const kind of kinds) {
+                const runners = getRunnersForKind(kind);
+                if (runners.length > 1) {
+                    const priorities = runners.map((r) => r.priority ?? 100);
+                    // Should be sorted ascending
+                    for (let i = 1; i < priorities.length; i++) {
+                        expect(priorities[i - 1]).toBeLessThanOrEqual(priorities[i]);
+                    }
+                }
+            }
+        });
+    });
+});

package/clients/dispatch/__tests__/runner-registration.test.ts

@@ -23,7 +23,7 @@ describe("Runner Registration", () => {
 		clearRunnerRegistry();
 
 		// Import runners to trigger registration
-		// This is the critical import that was missing in the effect-integration bug
+		// This is the critical import that ensures runners are registered before dispatch
 		await import("../runners/index.js");
 
 		// Get all registered runners
@@ -200,7 +200,7 @@ describe("Runner Registration", () => {
 	describe("Runner Import Verification", () => {
 		it("should load runner index without errors", async () => {
 			// This catches the bug where runners weren't imported
-			// in effect-integration.ts and bus-dispatcher.ts
+			// in the dispatch system
 			expect(async () => {
 				await import("../runners/index.js");
 			}).not.toThrow();

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

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { formatDiagnostic } from "./utils/format-utils.js";
+describe("formatDiagnostic edge cases", () => {
+    it("should handle messages with colons correctly", () => {
+        // This tests the actual format of inline code fix messages
+        const diagnostic = {
+            id: "architect-1",
+            // This is the format of architect warnings - starts with "No "
+            message: "No absolute Windows paths — breaks CI and cross-platform builds.",
+            filePath: "/test.ts",
+            line: 10,
+            severity: "warning",
+            semantic: "warning",
+            tool: "architect",
+            rule: "no-absolute-paths",
+        };
+        const formatted = formatDiagnostic(diagnostic);
+        // Should show the complete message, not cut off at "No "
+        expect(formatted).toContain("No absolute Windows paths");
+        expect(formatted).toContain("breaks CI and cross-platform builds");
+        expect(formatted).not.toBe("  L10: No "); // Should NOT be truncated
+    });
+    it("should handle code fix messages with newlines", () => {
+        const diagnostic = {
+            id: "ts-12-2345",
+            // This is the actual format from ts-lsp runner
+            message: "Property 'debug' is missing in type 'Config'\n💡 Quick fix: Add missing property 'debug'",
+            filePath: "/test.ts",
+            line: 12,
+            severity: "error",
+            semantic: "blocking",
+            tool: "ts-lsp",
+            rule: "TS2345",
+        };
+        const formatted = formatDiagnostic(diagnostic);
+        // Should have both lines properly indented
+        expect(formatted).toBe("  L12: Property 'debug' is missing in type 'Config'\n  💡 Quick fix: Add missing property 'debug'");
+    });
+    it("should handle messages with em-dashes (—)", () => {
+        const diagnostic = {
+            id: "architect-2",
+            message: "No hardcoded secrets — use environment variables or a secrets manager.",
+            filePath: "/test.ts",
+            line: 5,
+            severity: "warning",
+            semantic: "warning",
+            tool: "architect",
+            rule: "no-secrets",
+        };
+        const formatted = formatDiagnostic(diagnostic);
+        // Should preserve the full message with em-dash
+        expect(formatted).toContain("No hardcoded secrets");
+        expect(formatted).toContain("use environment variables");
+    });
+    it("should not truncate architect 'No ' messages", () => {
+        // Testing all the "No " patterns 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 (const message of testMessages) {
+            const diagnostic = {
+                id: "test-1",
+                message,
+                filePath: "/test.ts",
+                line: 1,
+                severity: "warning",
+                semantic: "warning",
+                tool: "architect",
+                rule: "test",
+            };
+            const formatted = formatDiagnostic(diagnostic);
+            // Each formatted message should be more than just "  L1: No "
+            expect(formatted.length).toBeGreaterThan(10);
+            expect(formatted).toContain("No ");
+            expect(formatted).toContain("—"); // Should have the em-dash
+        }
+    });
+});

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

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { formatDiagnostic } from "./utils/format-utils.js";
+describe("formatDiagnostic with code fixes", () => {
+    it("should format multi-line messages with proper indentation", () => {
+        const diagnostic = {
+            id: "ts-12-2345",
+            message: "Property 'debug' is missing in type 'Config'\n💡 Quick fix: Add missing property 'debug'",
+            filePath: "/test.ts",
+            line: 12,
+            severity: "error",
+            semantic: "blocking",
+            tool: "ts-lsp",
+            rule: "TS2345",
+        };
+        const formatted = formatDiagnostic(diagnostic);
+        // Should have proper indentation on both lines
+        expect(formatted).toBe("  L12: Property 'debug' is missing in type 'Config'\n  💡 Quick fix: Add missing property 'debug'");
+    });
+    it("should format single-line messages", () => {
+        const diagnostic = {
+            id: "ts-5-1234",
+            message: "Cannot find name 'foo'",
+            filePath: "/test.ts",
+            line: 5,
+            severity: "error",
+            semantic: "blocking",
+            tool: "ts-lsp",
+            rule: "TS1234",
+        };
+        const formatted = formatDiagnostic(diagnostic);
+        expect(formatted).toBe("  L5: Cannot find name 'foo'");
+    });
+    it("should handle diagnostics without line numbers", () => {
+        const diagnostic = {
+            id: "test-1",
+            message: "General error\n💡 Fix: Do something",
+            filePath: "/test.ts",
+            severity: "warning",
+            semantic: "warning",
+            tool: "test",
+            rule: "test",
+        };
+        const formatted = formatDiagnostic(diagnostic);
+        expect(formatted).toBe("  General error\n  💡 Fix: Do something");
+    });
+});