pi-lens 3.6.2 → 3.6.4

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

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

@@ -1,286 +0,0 @@
-/**
- * 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 type { FileKind } from "../../file-kinds.js";
-import {
-	clearRunnerRegistry,
-	getRunner,
-	getRunnersForKind,
-	listRunners,
-} from "../dispatcher.js";
-import type { RunnerDefinition } from "../types.js";
-
-describe("Runner Registration", () => {
-	let allRunners: RunnerDefinition[];
-
-	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: FileKind[] = [
-				"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" as FileKind,
-					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: FileKind[] = ["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/debug.log

@@ -1 +0,0 @@
-DEBUG LOG CREATED

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

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