pi-lens 3.2.0 → 3.3.1

package/clients/services/effect-integration.js

@@ -1,198 +0,0 @@
-/**
- * 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 { DiagnosticFound, FileModified, RunnerCompleted, RunnerStarted, } from "../bus/events.js";
-import { formatDiagnostics } from "../dispatch/utils/format-utils.js";
-import { executeEffect, runRunnersConcurrent, } from "./runner-service.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");
-    // 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 dispatchWithEffect(ctx, plan.groups);
-    return result.output;
-}

package/clients/services/effect-integration.ts

@@ -1,276 +0,0 @@
-/**
- * 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 {
-	type Diagnostic,
-	DiagnosticFound,
-	FileModified,
-	RunnerCompleted,
-	RunnerStarted,
-} from "../bus/events.js";
-import { formatDiagnostics } from "../dispatch/utils/format-utils.js";
-import {
-	type ConcurrentRunnerResult,
-	executeEffect,
-	type RunnerResult,
-	runRunnersConcurrent,
-} from "./runner-service.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");
-
-	// 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 dispatchWithEffect(ctx, plan.groups);
-	return result.output;
-}

package/clients/services/index.js

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

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

@@ -1,134 +0,0 @@
-/**
- * Effect-TS Service Infrastructure for pi-lens
- *
- * Simplified implementation focusing on:
- * - Concurrent runner execution with resource limits
- * - Timeout handling with proper process cleanup
- * - Error recovery
- */
-import { Effect } from "effect";
-// --- Configuration ---
-/** Maximum concurrent runner processes to prevent resource contention */
-const DEFAULT_CONCURRENCY = 3;
-/** Maximum concurrent formatters */
-const DEFAULT_FORMATTER_CONCURRENCY = 2;
-// --- 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 (limited concurrency to prevent resource exhaustion)
- * - Per-runner timeout handling
- * - Graceful error recovery (individual failures don't stop others)
- * - Automatic resource cleanup
- *
- * Concurrency is limited to DEFAULT_CONCURRENCY (3) to prevent:
- * - CPU thrashing from too many parallel processes
- * - Memory exhaustion from large LSP initializations
- * - File descriptor exhaustion
- */
-export function runRunnersConcurrent(filePath, runnerIds, runSingle, timeoutMs = 30000, concurrency = DEFAULT_CONCURRENCY) {
-    return Effect.gen(function* () {
-        const _startTime = Date.now();
-        // Run runners with limited concurrency
-        // This prevents resource contention when many linters are configured
-        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 });
-        return results;
-    });
-}
-/**
- * Run multiple formatters concurrently with limited concurrency
- *
- * Formatters are typically I/O bound, so we can be slightly more aggressive
- * than runners, but still limit to prevent overwhelming the system.
- */
-export function runFormattersConcurrent(formatters, timeoutMs = 30000, concurrency = DEFAULT_FORMATTER_CONCURRENCY) {
-    return Effect.gen(function* () {
-        const results = yield* Effect.all(formatters.map((formatter) => Effect.gen(function* () {
-            const result = yield* Effect.tryPromise({
-                try: () => formatter(),
-                catch: (err) => err,
-            }).pipe(Effect.timeout(timeoutMs), Effect.catchAll((err) => Effect.succeed(err)));
-            return result;
-        })), { concurrency });
-        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";
-    }
-}