pi-lens 3.2.0 → 3.3.1

package/clients/services/runner-service.ts

@@ -1,225 +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 {
-	readonly _tag = "RunnerError";
-	constructor(
-		readonly runnerId: string,
-		readonly cause: unknown,
-	) {}
-}
-
-export class TimeoutError {
-	readonly _tag = "TimeoutError";
-	constructor(
-		readonly operation: string,
-		readonly timeoutMs: number,
-	) {}
-}
-
-// --- Result Types ---
-
-export interface RunnerResult {
-	diagnostics: Array<{
-		id: string;
-		message: string;
-		severity: "error" | "warning" | "info" | "hint";
-		semantic?: "blocking" | "warning" | "fixed" | "silent" | "none";
-	}>;
-	durationMs: number;
-	error?: string;
-}
-
-export interface ConcurrentRunnerResult {
-	runnerId: string;
-	status: "success" | "failure" | "skipped";
-	diagnostics: Array<{
-		id: string;
-		message: string;
-		severity: "error" | "warning" | "info" | "hint";
-		semantic?: "blocking" | "warning" | "fixed" | "silent" | "none";
-	}>;
-	durationMs: number;
-	error?: string;
-}
-
-// --- 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: string,
-	runnerIds: string[],
-	runSingle: (filePath: string, runnerId: string) => Promise<RunnerResult>,
-	timeoutMs = 30_000,
-	concurrency = DEFAULT_CONCURRENCY,
-): Effect.Effect<ConcurrentRunnerResult[], never, never> {
-	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" as const) : ("success" as const),
-						diagnostics: isError ? [] : result.diagnostics,
-						durationMs: isError ? result.durationMs : result.durationMs,
-						error: isError ? result.error : undefined,
-					};
-				}),
-			),
-			{ concurrency }, // Limited concurrency to prevent resource exhaustion
-		);
-
-		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<T>(
-	formatters: Array<() => Promise<T>>,
-	timeoutMs = 30_000,
-	concurrency = DEFAULT_FORMATTER_CONCURRENCY,
-): Effect.Effect<T[], never, never> {
-	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 as T)),
-					);
-					return result;
-				}),
-			),
-			{ concurrency },
-		);
-		return results;
-	});
-}
-
-/**
- * Run a single runner with timeout and error handling
- */
-export function runRunnerWithTimeout(
-	filePath: string,
-	runnerId: string,
-	runSingle: (filePath: string, runnerId: string) => Promise<RunnerResult>,
-	timeoutMs = 30_000,
-): Effect.Effect<RunnerResult, RunnerError | TimeoutError, never> {
-	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<T>(
-	effect: Effect.Effect<T, never, never>,
-): Promise<T> {
-	return Effect.runPromise(effect);
-}
-
-/**
- * Execute Effect with error handling
- */
-export function executeEffectWithError<T, E>(
-	effect: Effect.Effect<T, E, never>,
-	onError: (err: E) => T,
-): Promise<T> {
-	return Effect.runPromise(
-		Effect.catchAll(effect, (err) => Effect.succeed(onError(err))),
-	);
-}
-
-// --- Error Formatting ---
-
-export function formatError(err: RunnerError | TimeoutError): string {
-	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";
-	}
-}