pi-lens 2.2.9 → 3.0.0

package/clients/services/__tests__/effect-integration.test.ts

@@ -0,0 +1,111 @@
+/**
+ * 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");
+	});
+});

package/clients/services/effect-integration.js

@@ -0,0 +1,194 @@
+/**
+ * Effect-TS Integration for pi-lens Dispatch
+ *
+ * Bridges the Effect service layer with the existing dispatch system.
+ *
+ * This provides:
+ * - Concurrent runner execution with Effect.all
+ * - Timeout handling for slow runners
+ * - Graceful error recovery
+ * - Bus event integration
+ */
+import { runRunnersConcurrent, executeEffect, } from "./runner-service.js";
+import { DiagnosticFound, RunnerStarted, RunnerCompleted, FileModified, } from "../bus/events.js";
+import { formatDiagnostics } from "../dispatch/utils/format-utils.js";
+// Import runners to register them in the dispatcher
+import "../dispatch/runners/index.js";
+// --- Core Functions ---
+/**
+ * Run all runners in a group concurrently using Effect
+ */
+async function runGroupConcurrent(ctx, group) {
+    const { getRunner, getRunnersForKind } = await import("../dispatch/dispatcher.js");
+    const startTime = Date.now();
+    // Get runner definitions
+    const runnerDefs = group.filterKinds
+        ? group.runnerIds
+            .filter((id) => {
+            const runner = getRunner(id);
+            return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
+        })
+        : group.runnerIds;
+    const runners = runnerDefs
+        .map((id) => getRunner(id))
+        .filter((r) => r !== undefined)
+        .filter((r) => (r.when ? r.when(ctx) : true));
+    if (runners.length === 0) {
+        return { results: [], diagnostics: [] };
+    }
+    // Build the single runner execution function
+    const runSingle = async (filePath, runnerId) => {
+        const runner = getRunner(runnerId);
+        if (!runner) {
+            return { diagnostics: [], durationMs: 0 };
+        }
+        // Publish started event
+        RunnerStarted.publish({
+            runnerId,
+            filePath,
+            timestamp: Date.now(),
+        });
+        const runnerStart = Date.now();
+        let status = "completed";
+        let diagnostics = [];
+        try {
+            const result = await runner.run(ctx);
+            diagnostics = result.diagnostics.map((d) => ({
+                id: d.id,
+                message: d.message,
+                filePath: ctx.filePath,
+                line: d.line,
+                column: d.column,
+                severity: d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "info",
+                semantic: d.semantic ?? result.semantic ?? "warning",
+                tool: runnerId,
+                rule: d.rule,
+                fixable: d.fixable,
+                fixSuggestion: d.fixSuggestion,
+            }));
+            // Publish diagnostic found event
+            if (diagnostics.length > 0) {
+                DiagnosticFound.publish({
+                    runnerId,
+                    filePath: ctx.filePath,
+                    diagnostics,
+                    durationMs: Date.now() - runnerStart,
+                });
+            }
+            return {
+                diagnostics: diagnostics.map((d) => ({
+                    id: d.id,
+                    message: d.message,
+                    severity: d.severity,
+                    semantic: d.semantic,
+                })),
+                durationMs: Date.now() - runnerStart,
+            };
+        }
+        catch (err) {
+            status = "failed";
+            return {
+                diagnostics: [],
+                durationMs: Date.now() - runnerStart,
+                error: String(err),
+            };
+        }
+        finally {
+            // Publish completed event
+            RunnerCompleted.publish({
+                runnerId,
+                filePath: ctx.filePath,
+                status,
+                durationMs: Date.now() - runnerStart,
+                diagnosticCount: diagnostics.length,
+            });
+        }
+    };
+    // Run all runners concurrently using Effect
+    const runnerIds = runners.map((r) => r.id);
+    const concurrentResults = await executeEffect(runRunnersConcurrent(ctx.filePath, runnerIds, runSingle, 30000));
+    // Collect all diagnostics
+    const allDiagnostics = [];
+    for (const result of concurrentResults) {
+        if (result.status === "success") {
+            allDiagnostics.push(...result.diagnostics.map((d) => ({
+                id: d.id,
+                message: d.message,
+                filePath: ctx.filePath,
+                severity: d.severity,
+                semantic: d.semantic ?? group.semantic ?? "warning",
+                tool: result.runnerId,
+            })));
+        }
+    }
+    return {
+        results: concurrentResults,
+        diagnostics: allDiagnostics,
+    };
+}
+// --- Main Dispatch Function ---
+export async function dispatchWithEffect(ctx, groups) {
+    const startTime = Date.now();
+    const allDiagnostics = [];
+    const allRunnerResults = [];
+    let stopped = false;
+    // Publish file modified event
+    FileModified.publish({
+        filePath: ctx.filePath,
+        changeType: "external",
+    });
+    for (const group of groups) {
+        if (stopped && ctx.pi.getFlag("stop-on-error")) {
+            break;
+        }
+        const { results, diagnostics } = await runGroupConcurrent(ctx, group);
+        allDiagnostics.push(...diagnostics);
+        allRunnerResults.push(...results);
+        // Check for blockers
+        const semantic = group.semantic ?? "warning";
+        if (semantic === "blocking" && diagnostics.length > 0) {
+            stopped = true;
+        }
+    }
+    // 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;
+    // Log performance info in debug mode
+    if (ctx.pi.getFlag("lens-bus-debug")) {
+        console.error(`[effect] Total duration: ${durationMs}ms`);
+        for (const r of allRunnerResults) {
+            console.error(`[effect] ${r.runnerId}: ${r.status} (${r.durationMs}ms)`);
+        }
+    }
+    return {
+        diagnostics: allDiagnostics,
+        blockers,
+        warnings,
+        fixed: fixedItems,
+        silent: silentItems,
+        output,
+        hasBlockers: blockers.length > 0,
+        durationMs,
+        runnerResults: allRunnerResults,
+    };
+}
+// --- Simple Integration Helper ---
+export async function dispatchLintWithEffect(filePath, cwd, pi) {
+    const { createDispatchContext } = await import("../dispatch/dispatcher.js");
+    const { TOOL_PLANS } = await import("../dispatch/plan.js");
+    const ctx = createDispatchContext(filePath, cwd, pi);
+    const kind = ctx.kind;
+    if (!kind)
+        return "";
+    const plan = TOOL_PLANS[kind];
+    if (!plan)
+        return "";
+    const result = await dispatchWithEffect(ctx, plan.groups);
+    return result.output;
+}

package/clients/services/effect-integration.ts

@@ -0,0 +1,268 @@
+/**
+ * Effect-TS Integration for pi-lens Dispatch
+ * 
+ * Bridges the Effect service layer with the existing dispatch system.
+ * 
+ * This provides:
+ * - Concurrent runner execution with Effect.all
+ * - Timeout handling for slow runners
+ * - Graceful error recovery
+ * - Bus event integration
+ */
+
+import {
+	runRunnersConcurrent,
+	executeEffect,
+	formatError,
+	type RunnerResult,
+	type ConcurrentRunnerResult,
+} from "./runner-service.js";
+
+import {
+	DiagnosticFound,
+	RunnerStarted,
+	RunnerCompleted,
+	FileModified,
+	type Diagnostic,
+} from "../bus/events.js";
+import { formatDiagnostic, formatDiagnostics } from "../dispatch/utils/format-utils.js";
+// Import runners to register them in the dispatcher
+import "../dispatch/runners/index.js";
+
+import type { DispatchContext, RunnerGroup } from "../dispatch/types.js";
+
+// --- Enhanced Result Type ---
+
+export interface EffectDispatchResult {
+	diagnostics: Diagnostic[];
+	blockers: Diagnostic[];
+	warnings: Diagnostic[];
+	fixed: Diagnostic[];
+	silent: Diagnostic[];
+	output: string;
+	hasBlockers: boolean;
+	durationMs: number;
+	runnerResults: ConcurrentRunnerResult[];
+}
+
+// --- Core Functions ---
+
+/**
+ * Run all runners in a group concurrently using Effect
+ */
+async function runGroupConcurrent(
+	ctx: DispatchContext,
+	group: RunnerGroup,
+): Promise<{ results: ConcurrentRunnerResult[]; diagnostics: Diagnostic[] }> {
+	const { getRunner, getRunnersForKind } = await import("../dispatch/dispatcher.js");
+	const startTime = Date.now();
+
+	// Get runner definitions
+	const runnerDefs = group.filterKinds
+		? group.runnerIds
+				.filter((id) => {
+					const runner = getRunner(id);
+					return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
+				})
+		: group.runnerIds;
+
+	const runners = runnerDefs
+		.map((id) => getRunner(id))
+		.filter((r): r is NonNullable<typeof r> => r !== undefined)
+		.filter((r) => (r.when ? r.when(ctx) : true));
+
+	if (runners.length === 0) {
+		return { results: [], diagnostics: [] };
+	}
+
+	// Build the single runner execution function
+	const runSingle = async (filePath: string, runnerId: string): Promise<RunnerResult> => {
+		const runner = getRunner(runnerId);
+		if (!runner) {
+			return { diagnostics: [], durationMs: 0 };
+		}
+
+		// Publish started event
+		RunnerStarted.publish({
+			runnerId,
+			filePath,
+			timestamp: Date.now(),
+		});
+
+		const runnerStart = Date.now();
+		let status: "completed" | "failed" = "completed";
+		let diagnostics: Diagnostic[] = [];
+
+		try {
+			const result = await runner.run(ctx);
+			diagnostics = result.diagnostics.map((d) => ({
+				id: d.id,
+				message: d.message,
+				filePath: ctx.filePath,
+				line: d.line,
+				column: d.column,
+				severity: d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "info",
+				semantic: d.semantic ?? result.semantic ?? "warning",
+				tool: runnerId,
+				rule: d.rule,
+				fixable: d.fixable,
+				fixSuggestion: d.fixSuggestion,
+			}));
+
+			// Publish diagnostic found event
+			if (diagnostics.length > 0) {
+				DiagnosticFound.publish({
+					runnerId,
+					filePath: ctx.filePath,
+					diagnostics,
+					durationMs: Date.now() - runnerStart,
+				});
+			}
+
+			return {
+				diagnostics: diagnostics.map((d) => ({
+					id: d.id,
+					message: d.message,
+					severity: d.severity,
+					semantic: d.semantic,
+				})),
+				durationMs: Date.now() - runnerStart,
+			};
+		} catch (err) {
+			status = "failed";
+			return {
+				diagnostics: [],
+				durationMs: Date.now() - runnerStart,
+				error: String(err),
+			};
+		} finally {
+			// Publish completed event
+			RunnerCompleted.publish({
+				runnerId,
+				filePath: ctx.filePath,
+				status,
+				durationMs: Date.now() - runnerStart,
+				diagnosticCount: diagnostics.length,
+			});
+		}
+	};
+
+	// Run all runners concurrently using Effect
+	const runnerIds = runners.map((r) => r.id);
+	const concurrentResults = await executeEffect(
+		runRunnersConcurrent(ctx.filePath, runnerIds, runSingle, 30_000)
+	);
+
+	// Collect all diagnostics
+	const allDiagnostics: Diagnostic[] = [];
+	for (const result of concurrentResults) {
+		if (result.status === "success") {
+			allDiagnostics.push(
+				...result.diagnostics.map((d) => ({
+					id: d.id,
+					message: d.message,
+					filePath: ctx.filePath,
+					severity: d.severity,
+					semantic: d.semantic ?? group.semantic ?? "warning",
+					tool: result.runnerId,
+				}))
+			);
+		}
+	}
+
+	return {
+		results: concurrentResults,
+		diagnostics: allDiagnostics,
+	};
+}
+
+// --- Main Dispatch Function ---
+
+export async function dispatchWithEffect(
+	ctx: DispatchContext,
+	groups: RunnerGroup[],
+): Promise<EffectDispatchResult> {
+	const startTime = Date.now();
+	const allDiagnostics: Diagnostic[] = [];
+	const allRunnerResults: ConcurrentRunnerResult[] = [];
+	let stopped = false;
+
+	// Publish file modified event
+	FileModified.publish({
+		filePath: ctx.filePath,
+		changeType: "external",
+	});
+
+	for (const group of groups) {
+		if (stopped && ctx.pi.getFlag("stop-on-error")) {
+			break;
+		}
+
+		const { results, diagnostics } = await runGroupConcurrent(ctx, group);
+
+		allDiagnostics.push(...diagnostics);
+		allRunnerResults.push(...results);
+
+		// Check for blockers
+		const semantic = group.semantic ?? "warning";
+		if (semantic === "blocking" && diagnostics.length > 0) {
+			stopped = true;
+		}
+	}
+
+	// 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;
+
+	// Log performance info in debug mode
+	if (ctx.pi.getFlag("lens-bus-debug")) {
+		console.error(`[effect] Total duration: ${durationMs}ms`);
+		for (const r of allRunnerResults) {
+			console.error(`[effect] ${r.runnerId}: ${r.status} (${r.durationMs}ms)`);
+		}
+	}
+
+	return {
+		diagnostics: allDiagnostics,
+		blockers,
+		warnings,
+		fixed: fixedItems,
+		silent: silentItems,
+		output,
+		hasBlockers: blockers.length > 0,
+		durationMs,
+		runnerResults: allRunnerResults,
+	};
+}
+
+// --- Simple Integration Helper ---
+
+export async function dispatchLintWithEffect(
+	filePath: string,
+	cwd: string,
+	pi: { getFlag(flag: string): string | boolean | undefined },
+): Promise<string> {
+	const { createDispatchContext } = await import("../dispatch/dispatcher.js");
+	const { TOOL_PLANS } = await import("../dispatch/plan.js");
+
+	const ctx = createDispatchContext(filePath, cwd, pi);
+
+	const kind = ctx.kind;
+	if (!kind) return "";
+
+	const plan = TOOL_PLANS[kind];
+	if (!plan) return "";
+
+	const result = await dispatchWithEffect(ctx, plan.groups);
+	return result.output;
+}

package/clients/services/index.js

@@ -0,0 +1,7 @@
+/**
+ * Effect-TS Services for pi-lens
+ *
+ * Provides composable, testable async operations.
+ */
+export * from "./runner-service.js";
+export * from "./effect-integration.js";

package/clients/services/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Effect-TS Services for pi-lens
+ * 
+ * Provides composable, testable async operations.
+ */
+
+export * from "./runner-service.js";
+export * from "./effect-integration.js";

package/clients/services/runner-service.js

@@ -0,0 +1,105 @@
+/**
+ * Effect-TS Service Infrastructure for pi-lens
+ *
+ * Simplified implementation focusing on:
+ * - Concurrent runner execution
+ * - Timeout handling
+ * - Error recovery
+ */
+import { Effect } from "effect";
+// --- Error Types ---
+export class RunnerError {
+    constructor(runnerId, cause) {
+        this.runnerId = runnerId;
+        this.cause = cause;
+        this._tag = "RunnerError";
+    }
+}
+export class TimeoutError {
+    constructor(operation, timeoutMs) {
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+        this._tag = "TimeoutError";
+    }
+}
+// --- Concurrent Execution Helper ---
+/**
+ * Run multiple runners concurrently with Effect
+ *
+ * Features:
+ * - Parallel execution with Effect.all
+ * - Per-runner timeout handling
+ * - Graceful error recovery (individual failures don't stop others)
+ * - Automatic resource cleanup
+ */
+export function runRunnersConcurrent(filePath, runnerIds, runSingle, timeoutMs = 30000) {
+    return Effect.gen(function* () {
+        const startTime = Date.now();
+        // Run all runners in parallel
+        const results = yield* Effect.all(runnerIds.map((runnerId) => Effect.gen(function* () {
+            const runnerStart = Date.now();
+            // Execute with timeout and error handling
+            const result = yield* Effect.tryPromise({
+                try: () => runSingle(filePath, runnerId),
+                catch: (err) => err,
+            }).pipe(Effect.timeout(timeoutMs), Effect.catchAll((err) => Effect.succeed({
+                diagnostics: [],
+                durationMs: Date.now() - runnerStart,
+                error: String(err),
+            })));
+            const isError = "error" in result;
+            return {
+                runnerId,
+                status: isError ? "failure" : "success",
+                diagnostics: isError ? [] : result.diagnostics,
+                durationMs: isError ? result.durationMs : result.durationMs,
+                error: isError ? result.error : undefined,
+            };
+        })), { concurrency: "unbounded" });
+        return results;
+    });
+}
+/**
+ * Run a single runner with timeout and error handling
+ */
+export function runRunnerWithTimeout(filePath, runnerId, runSingle, timeoutMs = 30000) {
+    return Effect.gen(function* () {
+        const startTime = Date.now();
+        const result = yield* Effect.tryPromise({
+            try: () => runSingle(filePath, runnerId),
+            catch: (err) => new RunnerError(runnerId, err),
+        }).pipe(Effect.timeout(timeoutMs), Effect.mapError((err) => {
+            if (err instanceof RunnerError)
+                return err;
+            return new TimeoutError(`runner:${runnerId}`, timeoutMs);
+        }));
+        return {
+            diagnostics: result.diagnostics,
+            durationMs: Date.now() - startTime,
+        };
+    });
+}
+// --- Execution Helpers ---
+/**
+ * Execute Effect and get result
+ */
+export function executeEffect(effect) {
+    return Effect.runPromise(effect);
+}
+/**
+ * Execute Effect with error handling
+ */
+export function executeEffectWithError(effect, onError) {
+    return Effect.runPromise(Effect.catchAll(effect, (err) => Effect.succeed(onError(err))));
+}
+// --- Error Formatting ---
+export function formatError(err) {
+    switch (err._tag) {
+        case "RunnerError":
+            return `Runner ${err.runnerId} failed: ${err.cause}`;
+        case "TimeoutError":
+            return `Operation ${err.operation} timed out after ${err.timeoutMs}ms`;
+        default:
+            return "Unknown error";
+    }
+}