pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/bus-dispatcher.ts

@@ -0,0 +1,251 @@
+/**
+ * Bus-Integrated Dispatcher for pi-lens
+ * 
+ * Bridges the declarative dispatch system with the event bus.
+ * 
+ * Changes from original dispatcher:
+ * - Publishes events for each runner lifecycle phase
+ * - Supports concurrent execution with progress tracking
+ * - Integrates with DiagnosticAggregator for results
+ */
+
+import {
+	DiagnosticFound,
+	RunnerStarted,
+	RunnerCompleted,
+	AutoFixApplied,
+	FileModified,
+	ReportReady,
+	type Diagnostic,
+	type OutputSemantic,
+} from "../bus/events.js";
+import { publish } from "../bus/bus.js";
+import { formatDiagnostic, formatDiagnostics, EMOJI } from "./utils/format-utils.js";
+// Import runners to register them
+import "./runners/index.js";
+
+import type { DispatchContext, RunnerDefinition, RunnerResult, RunnerGroup } from "./types.js";
+
+// --- Enhanced Dispatch Result ---
+
+export interface BusDispatchResult {
+	diagnostics: Diagnostic[];
+	blockers: Diagnostic[];
+	warnings: Diagnostic[];
+	fixed: Diagnostic[];
+	silent: Diagnostic[];
+	output: string;
+	hasBlockers: boolean;
+	durationMs: number;
+	runnerResults: Array<{
+		runnerId: string;
+		status: "succeeded" | "failed" | "skipped" | "completed";
+		durationMs: number;
+		diagnosticCount: number;
+	}>;
+}
+
+// --- Core Functions ---
+
+async function runRunner(
+	ctx: DispatchContext,
+	runner: RunnerDefinition,
+	defaultSemantic: OutputSemantic,
+): Promise<RunnerResult & { durationMs: number }> {
+	const startTime = Date.now();
+	
+	// Publish runner started event
+	RunnerStarted.publish({
+		runnerId: runner.id,
+		filePath: ctx.filePath,
+		timestamp: startTime,
+	});
+
+	try {
+		const result = await runner.run(ctx);
+		const durationMs = Date.now() - startTime;
+
+		// Publish diagnostic found event
+		if (result.diagnostics.length > 0) {
+			DiagnosticFound.publish({
+				runnerId: runner.id,
+				filePath: ctx.filePath,
+				diagnostics: result.diagnostics,
+				durationMs,
+			});
+		}
+
+		// Publish runner completed event
+		// Map "succeeded" to "completed" for the event status
+		const eventStatus = result.status === "succeeded" ? "completed" : result.status;
+		RunnerCompleted.publish({
+			runnerId: runner.id,
+			filePath: ctx.filePath,
+			status: eventStatus,
+			durationMs,
+			diagnosticCount: result.diagnostics.length,
+		});
+
+		return {
+			...result,
+			semantic: result.semantic ?? defaultSemantic,
+			durationMs,
+		};
+	} catch (error) {
+		const durationMs = Date.now() - startTime;
+		ctx.log?.(`Runner ${runner.id} failed: ${error}`);
+
+		RunnerCompleted.publish({
+			runnerId: runner.id,
+			filePath: ctx.filePath,
+			status: "failed",
+			durationMs,
+			diagnosticCount: 0,
+		});
+
+		return {
+			status: "failed",
+			diagnostics: [],
+			semantic: defaultSemantic,
+			durationMs,
+		};
+	}
+}
+
+// --- Concurrent Dispatch (new feature) ---
+
+export async function dispatchConcurrent(
+	ctx: DispatchContext,
+	groups: RunnerGroup[],
+): Promise<BusDispatchResult> {
+	const startTime = Date.now();
+	const allDiagnostics: Diagnostic[] = [];
+	const runnerResults: BusDispatchResult["runnerResults"] = [];
+	let stopped = false;
+
+	for (const group of groups) {
+		if (stopped && ctx.pi.getFlag("stop-on-error")) {
+			break;
+		}
+
+		// Get applicable runners
+		const { getRunner } = await import("./dispatcher.js");
+		const runnerIds = group.filterKinds
+			? group.runnerIds.filter((id) => {
+					const runner = getRunner(id);
+					return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
+				})
+			: group.runnerIds;
+
+		const runners = runnerIds
+			.map((id) => getRunner(id))
+			.filter((r): r is RunnerDefinition => r !== undefined)
+			.filter((r) => (r.when ? r.when(ctx) : true));
+
+		const semantic = group.semantic ?? "warning";
+
+		if (group.mode === "all") {
+			// Run all runners concurrently
+			const results = await Promise.all(
+				runners.map((runner) => runRunner(ctx, runner, semantic)),
+			);
+
+			for (const result of results) {
+				runnerResults.push({
+					runnerId: runners[results.indexOf(result)].id,
+					status: result.status === "succeeded" ? "completed" : result.status,
+					durationMs: result.durationMs,
+					diagnosticCount: result.diagnostics.length,
+				});
+				allDiagnostics.push(...result.diagnostics);
+
+				if (semantic === "blocking" && result.diagnostics.length > 0) {
+					stopped = true;
+				}
+			}
+		} else if (group.mode === "fallback") {
+			// Run sequentially until first success
+			for (const runner of runners) {
+				const result = await runRunner(ctx, runner, semantic);
+				runnerResults.push({
+					runnerId: runner.id,
+					status: result.status === "succeeded" ? "completed" : result.status,
+					durationMs: result.durationMs,
+					diagnosticCount: result.diagnostics.length,
+				});
+				allDiagnostics.push(...result.diagnostics);
+
+				if (result.diagnostics.length === 0 || result.semantic === "fixed") {
+					break;
+				}
+			}
+		}
+	}
+
+	// Categorize results
+	const blockers = allDiagnostics.filter((d) => d.semantic === "blocking");
+	const warnings = allDiagnostics.filter(
+		(d) => d.semantic === "warning" || d.semantic === "none",
+	);
+	const fixedItems = allDiagnostics.filter((d) => d.semantic === "fixed");
+	const silentItems = allDiagnostics.filter((d) => d.semantic === "silent");
+
+	// Format output
+	let output = formatDiagnostics(blockers, "blocking");
+	output += formatDiagnostics(fixedItems, "fixed");
+
+	const durationMs = Date.now() - startTime;
+
+	// Publish report ready event
+	ReportReady.publish({
+		filePath: ctx.filePath,
+		report: {
+			blockers,
+			warnings,
+			fixed: fixedItems,
+			silent: silentItems,
+		},
+		durationMs,
+	});
+
+	return {
+		diagnostics: allDiagnostics,
+		blockers,
+		warnings,
+		fixed: fixedItems,
+		silent: silentItems,
+		output,
+		hasBlockers: blockers.length > 0,
+		durationMs,
+		runnerResults,
+	};
+}
+
+// --- Simple Integration Helper ---
+
+export async function dispatchLintWithBus(
+	filePath: string,
+	cwd: string,
+	pi: { getFlag(flag: string): string | boolean | undefined; log?: (msg: string) => void },
+): Promise<string> {
+	const { createDispatchContext } = await import("./dispatcher.js");
+	const { getRunnersForKind } = await import("./dispatcher.js");
+	const { TOOL_PLANS } = await import("./plan.js");
+
+	// Publish file modified event to trigger any background processing
+	FileModified.publish({
+		filePath,
+		changeType: "external",
+	});
+
+	const ctx = createDispatchContext(filePath, cwd, pi);
+
+	const kind = ctx.kind;
+	if (!kind) return "";
+
+	const plan = TOOL_PLANS[kind];
+	if (!plan) return "";
+
+	const result = await dispatchConcurrent(ctx, plan.groups);
+	return result.output;
+}

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.edge.test.ts

@@ -0,0 +1,100 @@
+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" as const,
+			semantic: "warning" as const,
+			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" as const,
+			semantic: "blocking" as const,
+			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" as const,
+			semantic: "warning" as const,
+			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" as const,
+				semantic: "warning" as const,
+				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");
+    });
+});

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

@@ -0,0 +1,58 @@
+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" as const,
+			semantic: "blocking" as const,
+			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" as const,
+			semantic: "blocking" as const,
+			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" as const,
+			semantic: "warning" as const,
+			tool: "test",
+			rule: "test",
+		};
+
+		const formatted = formatDiagnostic(diagnostic);
+
+		expect(formatted).toBe("  General error\n  💡 Fix: Do something");
+	});
+});

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);
+        }
+    });
+});