pi-lens 3.2.0 → 3.3.1

package/clients/dispatch/bus-dispatcher.js

@@ -1,178 +0,0 @@
-import { DiagnosticFound, FileModified, ReportReady, RunnerCompleted, RunnerStarted, } from "../bus/events.js";
-import { formatDiagnostics } from "./utils/format-utils.js";
-// Import runners to register them
-import "./runners/index.js";
-// --- Core Functions ---
-async function runRunner(ctx, runner, defaultSemantic) {
-    const startTime = Date.now();
-    // Publish runner started event
-    RunnerStarted.publish({
-        runnerId: runner.id,
-        filePath: ctx.filePath,
-        timestamp: startTime,
-    });
-    try {
-        // Check when() condition async-safely (sync filter in caller can't await Promises)
-        if (runner.when && !(await runner.when(ctx))) {
-            return {
-                status: "skipped",
-                diagnostics: [],
-                semantic: defaultSemantic,
-                durationMs: Date.now() - startTime,
-            };
-        }
-        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, groups) {
-    const startTime = Date.now();
-    const allDiagnostics = [];
-    const 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;
-        // Note: when() is async — must be awaited. Filter it out here synchronously
-        // (runners without when always run; runners with when are checked inside runRunner).
-        const runners = runnerIds
-            .map((id) => getRunner(id))
-            .filter((r) => r !== undefined);
-        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, cwd, pi) {
-    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",
-    });
-    // blockingOnly=true: post-write dispatch only reports blocking errors (same as standard dispatchLint)
-    const ctx = createDispatchContext(filePath, cwd, pi, undefined, true);
-    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/bus-dispatcher.ts

@@ -1,258 +0,0 @@
-import {
-	type Diagnostic,
-	DiagnosticFound,
-	FileModified,
-	type OutputSemantic,
-	ReportReady,
-	RunnerCompleted,
-	RunnerStarted,
-} from "../bus/events.js";
-import { formatDiagnostics } from "./utils/format-utils.js";
-// Import runners to register them
-import "./runners/index.js";
-
-import type {
-	DispatchContext,
-	RunnerDefinition,
-	RunnerGroup,
-	RunnerResult,
-} 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 {
-		// Check when() condition async-safely (sync filter in caller can't await Promises)
-		if (runner.when && !(await runner.when(ctx))) {
-			return {
-				status: "skipped",
-				diagnostics: [],
-				semantic: defaultSemantic,
-				durationMs: Date.now() - startTime,
-			};
-		}
-		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;
-
-		// Note: when() is async — must be awaited. Filter it out here synchronously
-		// (runners without when always run; runners with when are checked inside runRunner).
-		const runners = runnerIds
-			.map((id) => getRunner(id))
-			.filter((r): r is RunnerDefinition => r !== undefined);
-
-		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",
-	});
-
-	// blockingOnly=true: post-write dispatch only reports blocking errors (same as standard dispatchLint)
-	const ctx = createDispatchContext(filePath, cwd, pi, undefined, true);
-
-	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/services/__tests__/effect-integration.test.ts

@@ -1,111 +0,0 @@
-/**
- * Effect Integration Tests
- *
- * Tests for Effect-TS concurrent runner execution.
- */
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type {
-	DispatchContext,
-	RunnerDefinition,
-	RunnerGroup,
-	RunnerResult,
-} from "../../dispatch/types.js";
-import {
-	clearRunnerRegistry,
-	getRunner,
-	listRunners,
-	registerRunner,
-} from "../../dispatch/dispatcher.js";
-import {
-	dispatchLintWithEffect,
-	dispatchWithEffect,
-	type EffectDispatchResult,
-} from "../effect-integration.js";
-
-describe("Effect Integration", () => {
-	beforeEach(async () => {
-		clearRunnerRegistry();
-		// Register a simple test runner
-		const testRunner: RunnerDefinition = {
-			id: "test-runner",
-			appliesTo: ["jsts"],
-			priority: 10,
-			enabledByDefault: true,
-			async run(ctx) {
-				return {
-					status: "succeeded",
-					diagnostics: [{
-						id: "test:1",
-						message: "Test diagnostic",
-						filePath: ctx.filePath,
-						severity: "info",
-						semantic: "silent",
-						tool: "test-runner",
-					}],
-					semantic: "none",
-				};
-			},
-		};
-		registerRunner(testRunner);
-	});
-
-	it("should have runners registered", () => {
-		const runners = listRunners();
-		expect(runners.length).toBeGreaterThan(0);
-		expect(runners.some(r => r.id === "test-runner")).toBe(true);
-	});
-
-	it("should run effect integration with real runners", async () => {
-		const ctx: DispatchContext = {
-			filePath: "test.ts",
-			cwd: "/test",
-			kind: "jsts",
-			pi: {
-				getFlag: vi.fn(() => false),
-			},
-			autofix: true,
-			deltaMode: false,
-			baselines: new Map(),
-			hasTool: vi.fn(() => Promise.resolve(false)),
-			log: vi.fn(),
-		};
-
-		// Get actual runners for jsts
-		const { getRunnersForKind } = await import("../../dispatch/dispatcher.js");
-		const runners = getRunnersForKind("jsts");
-		
-		const group: RunnerGroup = {
-			runnerIds: runners.slice(0, 2).map(r => r.id), // Use first 2 runners
-			mode: "all",
-		};
-
-		const result = await dispatchWithEffect(ctx, [group]);
-		
-		// Just verify it doesn't crash and returns valid result
-		expect(result).toBeDefined();
-		expect(typeof result.durationMs).toBe("number");
-	});
-
-	it("should handle --lens-effect flag path", async () => {
-		const mockPi = {
-			getFlag: vi.fn((flag: string) => flag === "lens-effect"),
-			readFile: vi.fn(),
-			writeFile: vi.fn(),
-			editFile: vi.fn(),
-			bash: vi.fn(),
-			ui: {
-				notify: vi.fn(),
-				progress: vi.fn(),
-				prompt: vi.fn(),
-			},
-			llm: {
-				stream: vi.fn(),
-				createMessage: vi.fn(),
-			},
-		};
-
-		const output = await dispatchLintWithEffect("test.ts", "/test", mockPi);
-		expect(typeof output).toBe("string");
-	});
-});