tywrap 0.5.0 → 0.5.1

package/src/utils/parallel-processor.ts

@@ -1,955 +0,0 @@
-/**
- * Parallel Processing System for tywrap
- * High-performance parallel processing for large Python codebases
- */
-
-import { EventEmitter } from 'events';
-import { cpus } from 'os';
-import { performance } from 'perf_hooks';
-import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
-import { fileURLToPath } from 'node:url';
-
-import type { AnalysisResult, PythonModule, GeneratedCode } from '../types/index.js';
-
-import { CodeGenerator } from '../core/generator.js';
-import { PyAnalyzer } from '../core/analyzer.js';
-import { globalCache } from './cache.js';
-import { getComponentLogger } from './logger.js';
-
-const log = getComponentLogger('ParallelProcessor');
-
-export interface ParallelTask<Data = unknown> {
-  id: string;
-  type: 'analyze' | 'generate' | 'validate' | 'custom';
-  data: Data;
-  options?: Record<string, unknown>;
-  priority?: number;
-  timeout?: number;
-}
-
-export interface ParallelResult<T = unknown> {
-  taskId: string;
-  success: boolean;
-  result?: T;
-  error?: string;
-  duration: number;
-  memoryUsage?: number;
-}
-
-export interface WorkerStats {
-  workerId: string;
-  tasksCompleted: number;
-  totalTime: number;
-  averageTime: number;
-  errorCount: number;
-  memoryPeak: number;
-  isActive: boolean;
-}
-
-export interface ParallelProcessorOptions {
-  maxWorkers?: number;
-  taskTimeout?: number; // milliseconds
-  retryAttempts?: number;
-  enableMemoryMonitoring?: boolean;
-  enableCaching?: boolean;
-  workerScript?: string; // Custom worker script path
-  batchSize?: number; // Number of tasks to batch per worker
-  loadBalancing?: 'round-robin' | 'least-loaded' | 'weighted';
-  debug?: boolean;
-}
-
-export interface ParallelProcessorStats {
-  activeWorkers: number;
-  totalWorkers: number;
-  tasksCompleted: number;
-  totalErrors: number;
-  averageTaskTime: number;
-  queueLength: number;
-  activeTasks: number;
-  workerStats: WorkerStats[];
-}
-
-interface AnalyzeTaskData {
-  sources: Array<{ name: string; content: string; path?: string }>;
-}
-
-interface GenerationTaskData {
-  modules: Array<{ name: string; module: PythonModule; options?: Record<string, unknown> }>;
-}
-
-type ValidationTaskData = unknown;
-
-interface AnalyzeTaskResult extends Array<ParallelResult<AnalysisResult>> {}
-interface GenerateTaskResult extends Array<ParallelResult<GeneratedCode>> {}
-interface ValidateTaskResult {
-  validated: true;
-}
-
-type AnalyzeTask = ParallelTask<AnalyzeTaskData> & { type: 'analyze' };
-type GenerateTask = ParallelTask<GenerationTaskData> & { type: 'generate' };
-type ValidateTask = ParallelTask<ValidationTaskData> & { type: 'validate' };
-type CustomTask = ParallelTask<unknown> & { type: 'custom' };
-
-type WorkerTask = AnalyzeTask | GenerateTask | ValidateTask | CustomTask;
-
-interface WorkerTaskResult {
-  result: unknown;
-  error?: string;
-  duration: number;
-  memoryUsage: number;
-}
-
-type WorkerMessage =
-  | {
-      type: 'task_complete';
-      taskId: string;
-      result?: unknown;
-      error?: string;
-      duration: number;
-      memoryUsage?: number;
-    }
-  | {
-      type: 'worker_ready';
-      workerId: string;
-    };
-
-type WorkerControlMessage = { type: 'task'; task: WorkerTask } | { type: 'shutdown' };
-
-interface WorkerData {
-  workerId: string;
-  options?: {
-    enableMemoryMonitoring: boolean;
-    enableCaching: boolean;
-  };
-}
-
-export class ParallelProcessor extends EventEmitter {
-  private workers = new Map<string, Worker>();
-  private workerStats = new Map<string, WorkerStats>();
-  private taskQueue: ParallelTask[] = [];
-  private queueInterval?: NodeJS.Timeout;
-  private activeTasks = new Map<string, ParallelTask>();
-  private pendingResults = new Map<
-    string,
-    {
-      workerId: string;
-      resolve: (result: ParallelResult<unknown>) => void;
-      reject: (error: Error) => void;
-      timeout?: NodeJS.Timeout;
-    }
-  >();
-  private roundRobinIndex = 0;
-  private options: Required<ParallelProcessorOptions>;
-  private disposed = false;
-  private debug = false;
-
-  constructor(options: ParallelProcessorOptions = {}) {
-    super();
-
-    const defaultWorkerScript = fileURLToPath(import.meta.url);
-    this.options = {
-      maxWorkers: options.maxWorkers ?? Math.min(cpus().length, 8),
-      taskTimeout: options.taskTimeout ?? 30000,
-      retryAttempts: options.retryAttempts ?? 2,
-      enableMemoryMonitoring: options.enableMemoryMonitoring ?? true,
-      enableCaching: options.enableCaching ?? true,
-      workerScript: options.workerScript ?? defaultWorkerScript,
-      batchSize: options.batchSize ?? 1,
-      loadBalancing: options.loadBalancing ?? 'least-loaded',
-      debug: options.debug ?? false,
-    };
-
-    this.debug = this.options.debug;
-
-    if (this.debug) {
-      this.debugLog(`🚀 Parallel processor initialized with ${this.options.maxWorkers} workers`);
-    }
-  }
-
-  private debugLog(message: string): void {
-    if (!this.debug) {
-      return;
-    }
-    process.stdout.write(`${message}\n`);
-  }
-
-  /**
-   * Initialize worker pool
-   */
-  async init(): Promise<void> {
-    if (this.disposed) {
-      throw new Error('Processor has been disposed');
-    }
-
-    // Spawn initial worker pool
-    for (let i = 0; i < this.options.maxWorkers; i++) {
-      await this.spawnWorker(`worker_${i}`);
-    }
-
-    // Start task processing
-    this.processQueue();
-
-    this.debugLog(`✅ Worker pool initialized with ${this.workers.size} workers`);
-  }
-
-  /**
-   * Process Python module analysis in parallel
-   */
-  async analyzeModulesParallel(
-    sources: Array<{ name: string; content: string; path?: string }>,
-    options: { chunkSize?: number } = {}
-  ): Promise<Array<ParallelResult<AnalysisResult>>> {
-    const chunkSize = options.chunkSize ?? Math.ceil(sources.length / this.options.maxWorkers);
-    const chunks = this.chunkArray(sources, chunkSize);
-
-    this.debugLog(`📊 Analyzing ${sources.length} modules in ${chunks.length} chunks`);
-
-    const tasks: Array<ParallelTask<AnalyzeTaskData>> = chunks.map((chunk, index) => ({
-      id: `analyze_chunk_${index}`,
-      type: 'analyze',
-      data: { sources: chunk },
-      priority: 1,
-    }));
-
-    const results = await this.executeTasks<AnalyzeTaskData, AnalyzeTaskResult>(tasks);
-
-    // Flatten chunked results
-    const flatResults: ParallelResult<AnalysisResult>[] = [];
-    for (const result of results) {
-      if (!result.success || !result.result) {
-        continue;
-      }
-      if (result.success && result.result) {
-        const chunkResults = result.result;
-        if (Array.isArray(chunkResults)) {
-          flatResults.push(...chunkResults);
-        }
-      }
-    }
-
-    return flatResults;
-  }
-
-  /**
-   * Generate TypeScript wrappers in parallel
-   */
-  async generateWrappersParallel(
-    modules: Array<{ name: string; module: PythonModule; options?: Record<string, unknown> }>,
-    options: { chunkSize?: number } = {}
-  ): Promise<Array<ParallelResult<GeneratedCode>>> {
-    const chunkSize = options.chunkSize ?? Math.ceil(modules.length / this.options.maxWorkers);
-    const chunks = this.chunkArray(modules, chunkSize);
-
-    this.debugLog(`🏗️  Generating ${modules.length} wrappers in ${chunks.length} chunks`);
-
-    const tasks: Array<ParallelTask<GenerationTaskData>> = chunks.map((chunk, index) => ({
-      id: `generate_chunk_${index}`,
-      type: 'generate',
-      data: { modules: chunk },
-      priority: 1,
-    }));
-
-    const results = await this.executeTasks<GenerationTaskData, GenerateTaskResult>(tasks);
-
-    // Flatten chunked results
-    const flatResults: ParallelResult<GeneratedCode>[] = [];
-    for (const result of results) {
-      if (result.success && result.result) {
-        const chunkResults = result.result;
-        if (Array.isArray(chunkResults)) {
-          flatResults.push(...chunkResults);
-        }
-      }
-    }
-
-    return flatResults;
-  }
-
-  /**
-   * Execute tasks in parallel with load balancing
-   */
-  async executeTasks<Data, Result>(
-    tasks: ParallelTask<Data>[]
-  ): Promise<Array<ParallelResult<Result>>> {
-    if (this.workers.size === 0) {
-      await this.init();
-    }
-
-    // Sort tasks by priority
-    const sortedTasks = [...tasks].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-
-    // Execute tasks with batching
-    const results: Array<ParallelResult<Result>> = [];
-    const inFlight = new Set<Promise<ParallelResult<Result>>>();
-    const maxInFlight = this.workers.size * 2;
-
-    for (const task of sortedTasks) {
-      const promise = this.executeTask<Data, Result>(task);
-      inFlight.add(promise);
-      promise
-        .finally(() => {
-          inFlight.delete(promise);
-        })
-        .catch(() => {
-          // no-op: individual task failures are encoded in results
-        });
-
-      // Limit concurrent tasks to prevent overwhelming workers
-      if (inFlight.size >= maxInFlight) {
-        const completed = await Promise.race(inFlight);
-        results.push(completed);
-      }
-    }
-
-    // Wait for remaining tasks
-    const remaining = await Promise.all(inFlight);
-    results.push(...remaining);
-
-    return results;
-  }
-
-  /**
-   * Execute single task
-   */
-  private async executeTask<Data, Result>(
-    task: ParallelTask<Data>
-  ): Promise<ParallelResult<Result>> {
-    // Check cache first if enabled
-    if (this.options.enableCaching) {
-      const cacheKey = globalCache.generateKey('parallel_task', task.type, task.data);
-      const cached = await globalCache.get<ParallelResult<Result>>(cacheKey);
-      if (cached) {
-        this.debugLog(`🎯 Cache HIT for task ${task.id}`);
-        return cached;
-      }
-    }
-
-    let attempts = 0;
-    let lastError: Error | undefined;
-
-    while (attempts < this.options.retryAttempts) {
-      attempts++;
-
-      try {
-        const selected = this.selectOptimalWorker();
-        if (!selected) {
-          throw new Error('No available workers');
-        }
-
-        const result = await this.sendTaskToWorker<Data, Result>(
-          selected.workerId,
-          selected.worker,
-          task
-        );
-
-        // Cache successful results
-        if (this.options.enableCaching && result.success) {
-          const cacheKey = globalCache.generateKey('parallel_task', task.type, task.data);
-          await globalCache.set(cacheKey, result, { computeTime: result.duration });
-        }
-
-        return result;
-      } catch (error) {
-        lastError = error as Error;
-        log.warn('Task failed', { taskId: task.id, attempt: attempts, error: String(error) });
-
-        if (attempts < this.options.retryAttempts) {
-          // Exponential backoff
-          await this.sleep(Math.pow(2, attempts) * 1000);
-        }
-      }
-    }
-
-    // Return failure result
-    return {
-      taskId: task.id,
-      success: false,
-      error: lastError?.message ?? 'Task failed after retries',
-      duration: 0,
-    };
-  }
-
-  /**
-   * Select optimal worker using load balancing strategy
-   */
-  private selectOptimalWorker(): { workerId: string; worker: Worker } | null {
-    const availableWorkers = Array.from(this.workers.entries())
-      .map(([workerId, worker]) => ({ workerId, worker }))
-      .filter(({ workerId, worker }) => {
-        if (worker.threadId <= 0) {
-          return false;
-        }
-        const stats = this.workerStats.get(workerId);
-        return stats?.isActive !== false;
-      });
-
-    if (availableWorkers.length === 0) {
-      return null;
-    }
-
-    switch (this.options.loadBalancing) {
-      case 'round-robin': {
-        const selected = availableWorkers[this.roundRobinIndex % availableWorkers.length];
-        this.roundRobinIndex = (this.roundRobinIndex + 1) % availableWorkers.length;
-        return selected ?? null;
-      }
-
-      case 'least-loaded': {
-        // Find worker with least active tasks
-        const workerLoads = availableWorkers.map(({ workerId, worker }) => {
-          const stats = this.workerStats.get(workerId);
-          return { workerId, worker, load: stats?.tasksCompleted ?? 0 };
-        });
-
-        workerLoads.sort((a, b) => a.load - b.load);
-        const first = workerLoads[0];
-        return first ? { workerId: first.workerId, worker: first.worker } : null;
-      }
-
-      case 'weighted': {
-        // Weight by average task completion time
-        const workerWeights = availableWorkers.map(({ workerId, worker }) => {
-          const stats = this.workerStats.get(workerId);
-          const avgTime = stats?.averageTime ?? 1000;
-          return { workerId, worker, weight: 1 / avgTime };
-        });
-
-        // Weighted random selection
-        const totalWeight = workerWeights.reduce((sum, w) => sum + w.weight, 0);
-        let random = Math.random() * totalWeight;
-
-        for (const { workerId, worker: candidate, weight } of workerWeights) {
-          random -= weight;
-          if (random <= 0) {
-            return { workerId, worker: candidate };
-          }
-        }
-
-        const fallback = workerWeights[0];
-        return fallback ? { workerId: fallback.workerId, worker: fallback.worker } : null;
-      }
-
-      default:
-        return availableWorkers[0] ?? null;
-    }
-  }
-
-  /**
-   * Send task to specific worker
-   */
-  private async sendTaskToWorker<Data, Result>(
-    workerId: string,
-    worker: Worker,
-    task: ParallelTask<Data>
-  ): Promise<ParallelResult<Result>> {
-    return new Promise((resolve, reject) => {
-      if (this.disposed) {
-        reject(new Error('Processor has been disposed'));
-        return;
-      }
-
-      const timeoutMs = task.timeout ?? this.options.taskTimeout;
-      const timeout = setTimeout(() => {
-        const pending = this.pendingResults.get(task.id);
-        if (!pending) {
-          return;
-        }
-        this.pendingResults.delete(task.id);
-        this.activeTasks.delete(task.id);
-        pending.reject(new Error(`Task ${task.id} timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-
-      this.pendingResults.set(task.id, {
-        workerId,
-        resolve: resolve as unknown as (result: ParallelResult<unknown>) => void,
-        reject,
-        timeout,
-      });
-
-      this.activeTasks.set(task.id, task);
-
-      try {
-        worker.postMessage({
-          type: 'task',
-          task,
-        });
-      } catch (error: unknown) {
-        this.pendingResults.delete(task.id);
-        this.activeTasks.delete(task.id);
-        clearTimeout(timeout);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-  }
-
-  /**
-   * Spawn new worker
-   */
-  private async spawnWorker(workerId: string): Promise<Worker> {
-    const worker = new Worker(this.options.workerScript, {
-      workerData: {
-        workerId,
-        options: {
-          enableMemoryMonitoring: this.options.enableMemoryMonitoring,
-          enableCaching: this.options.enableCaching,
-        },
-      },
-    });
-
-    // Setup worker message handling
-    worker.on('message', message => {
-      this.handleWorkerMessage(workerId, message);
-    });
-
-    // Setup worker error handling
-    worker.on('error', error => {
-      const workerError = error instanceof Error ? error : new Error(String(error));
-      log.error('Worker error', { workerId, error: String(workerError) });
-      this.handleWorkerError(workerId, workerError);
-    });
-
-    // Setup worker exit handling
-    worker.on('exit', code => {
-      log.warn('Worker exited', { workerId, code });
-      this.handleWorkerExit(workerId, code);
-    });
-
-    this.workers.set(workerId, worker);
-    this.workerStats.set(workerId, {
-      workerId,
-      tasksCompleted: 0,
-      totalTime: 0,
-      averageTime: 0,
-      errorCount: 0,
-      memoryPeak: 0,
-      isActive: true,
-    });
-
-    this.debugLog(`👷 Spawned worker ${workerId}`);
-    return worker;
-  }
-
-  /**
-   * Handle message from worker
-   */
-  private handleWorkerMessage(workerId: string, message: WorkerMessage): void {
-    if (message.type === 'task_complete') {
-      const { taskId, result, error, duration, memoryUsage } = message;
-      const pending = this.pendingResults.get(taskId);
-      if (pending) {
-        this.pendingResults.delete(taskId);
-        this.activeTasks.delete(taskId);
-
-        if (pending.timeout) {
-          clearTimeout(pending.timeout);
-        }
-
-        // Update worker stats
-        const stats = this.workerStats.get(workerId);
-        if (stats) {
-          stats.tasksCompleted++;
-          stats.totalTime += duration;
-          stats.averageTime = stats.totalTime / stats.tasksCompleted;
-
-          if (error) {
-            stats.errorCount++;
-          }
-
-          if (memoryUsage && memoryUsage > stats.memoryPeak) {
-            stats.memoryPeak = memoryUsage;
-          }
-        }
-
-        const parallelResult: ParallelResult = {
-          taskId,
-          success: !error,
-          result,
-          error,
-          duration,
-          memoryUsage,
-        };
-
-        pending.resolve(parallelResult);
-      }
-    } else if (message.type === 'worker_ready') {
-      this.emit('worker_ready', workerId);
-    }
-  }
-
-  /**
-   * Handle worker error
-   */
-  private handleWorkerError(workerId: string, error: Error): void {
-    const stats = this.workerStats.get(workerId);
-    if (stats) {
-      stats.errorCount++;
-      stats.isActive = false;
-    }
-
-    // Reject only tasks owned by this worker.
-    const ownedTasks: string[] = [];
-    for (const [taskId, pending] of this.pendingResults) {
-      if (pending.workerId === workerId) {
-        ownedTasks.push(taskId);
-      }
-    }
-    for (const taskId of ownedTasks) {
-      const pending = this.pendingResults.get(taskId);
-      if (!pending) {
-        continue;
-      }
-      if (pending.timeout) {
-        clearTimeout(pending.timeout);
-      }
-      pending.reject(new Error(`Worker ${workerId} error: ${error.message}`));
-      this.pendingResults.delete(taskId);
-      this.activeTasks.delete(taskId);
-    }
-
-    this.emit('worker_error', workerId, error);
-  }
-
-  /**
-   * Handle worker exit
-   */
-  private handleWorkerExit(workerId: string, code: number): void {
-    this.workers.delete(workerId);
-
-    const stats = this.workerStats.get(workerId);
-    if (stats) {
-      stats.isActive = false;
-    }
-
-    // Reject any tasks that were in-flight on this worker.
-    const ownedTasks: string[] = [];
-    for (const [taskId, pending] of this.pendingResults) {
-      if (pending.workerId === workerId) {
-        ownedTasks.push(taskId);
-      }
-    }
-    for (const taskId of ownedTasks) {
-      const pending = this.pendingResults.get(taskId);
-      if (!pending) {
-        continue;
-      }
-      if (pending.timeout) {
-        clearTimeout(pending.timeout);
-      }
-      pending.reject(new Error(`Worker ${workerId} exited with code ${code}`));
-      this.pendingResults.delete(taskId);
-      this.activeTasks.delete(taskId);
-    }
-
-    // Respawn worker if not disposing
-    if (!this.disposed && this.workers.size < this.options.maxWorkers) {
-      this.spawnWorker(`${workerId}_respawn_${Date.now()}`).catch(error => {
-        log.error('Failed to respawn worker', { workerId, error: String(error) });
-      });
-    }
-
-    this.emit('worker_exit', workerId, code);
-  }
-
-  /**
-   * Process task queue
-   */
-  private processQueue(): void {
-    // Simple queue processing - could be enhanced with priority scheduling
-    if (this.queueInterval) {
-      return;
-    }
-    this.queueInterval = setInterval(() => {
-      if (this.taskQueue.length > 0 && this.workers.size > 0) {
-        const task = this.taskQueue.shift();
-        if (task) {
-          this.executeTask(task).catch(error => {
-            log.error('Queue task execution failed', { error: String(error) });
-          });
-        }
-      }
-    }, 100);
-    // Don't keep the event loop alive just for an idle queue pump.
-    this.queueInterval.unref?.();
-  }
-
-  /**
-   * Get worker statistics
-   */
-  getWorkerStats(): WorkerStats[] {
-    return Array.from(this.workerStats.values());
-  }
-
-  /**
-   * Get overall processing statistics
-   */
-  getStats(): ParallelProcessorStats {
-    const workers = Array.from(this.workerStats.values());
-    const totalTasks = workers.reduce((sum, w) => sum + w.tasksCompleted, 0);
-    const totalErrors = workers.reduce((sum, w) => sum + w.errorCount, 0);
-    const totalTime = workers.reduce((sum, w) => sum + w.totalTime, 0);
-    const avgTime = totalTasks > 0 ? totalTime / totalTasks : 0;
-
-    return {
-      activeWorkers: workers.filter(w => w.isActive).length,
-      totalWorkers: workers.length,
-      tasksCompleted: totalTasks,
-      totalErrors,
-      averageTaskTime: avgTime,
-      queueLength: this.taskQueue.length,
-      activeTasks: this.activeTasks.size,
-      workerStats: workers,
-    };
-  }
-
-  /**
-   * Utility methods
-   */
-  private chunkArray<T>(array: T[], chunkSize: number): T[][] {
-    const chunks: T[][] = [];
-    for (let i = 0; i < array.length; i += chunkSize) {
-      chunks.push(array.slice(i, i + chunkSize));
-    }
-    return chunks;
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Gracefully dispose all workers
-   */
-  async dispose(): Promise<void> {
-    if (this.disposed) {
-      return;
-    }
-
-    this.disposed = true;
-
-    this.debugLog('🛑 Disposing parallel processor...');
-
-    if (this.queueInterval) {
-      clearInterval(this.queueInterval);
-      this.queueInterval = undefined;
-    }
-
-    // Reject any pending results immediately so callers don't hang.
-    const disposedError = new Error('Processor has been disposed');
-    for (const pending of this.pendingResults.values()) {
-      if (pending.timeout) {
-        clearTimeout(pending.timeout);
-      }
-      pending.reject(disposedError);
-    }
-    this.pendingResults.clear();
-    this.activeTasks.clear();
-
-    // Terminate all workers
-    const terminationPromises = Array.from(this.workers.values()).map(worker => {
-      return new Promise<void>(resolve => {
-        const timeout = setTimeout(() => {
-          worker.terminate();
-          resolve();
-        }, 5000);
-
-        worker.once('exit', () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-
-        try {
-          worker.postMessage({ type: 'shutdown' });
-        } catch {
-          // Ignore: worker may already be dead.
-        }
-      });
-    });
-
-    await Promise.all(terminationPromises);
-
-    // Clear data structures
-    this.workers.clear();
-    this.workerStats.clear();
-    this.taskQueue.length = 0;
-
-    this.removeAllListeners();
-
-    this.debugLog('✅ Parallel processor disposed');
-  }
-
-  setDebug(debug: boolean): void {
-    this.debug = debug;
-  }
-}
-
-// Worker script implementation (this runs in worker threads)
-if (!isMainThread && parentPort) {
-  const port = parentPort;
-  const { workerId } = workerData as WorkerData;
-
-  let analyzer: PyAnalyzer | null = null;
-  let analyzerInitialized = false;
-  let generator: CodeGenerator | null = null;
-
-  const getAnalyzer = async (): Promise<PyAnalyzer> => {
-    analyzer ??= new PyAnalyzer();
-    if (!analyzerInitialized) {
-      await analyzer.initialize();
-      analyzerInitialized = true;
-    }
-    return analyzer;
-  };
-
-  const getGenerator = (): CodeGenerator => {
-    generator ??= new CodeGenerator();
-    return generator;
-  };
-
-  const createResultId = (prefix: string, name: string, index: number): string =>
-    `${prefix}:${name}:${index}`;
-
-  // Import required modules in worker context
-  const workerImplementation = {
-    async processTask(task: WorkerTask): Promise<WorkerTaskResult> {
-      const startTime = performance.now();
-      let result: unknown;
-      let error: string | undefined;
-
-      try {
-        switch (task.type) {
-          case 'analyze':
-            result = await this.processAnalysisTask(task.data);
-            break;
-          case 'generate':
-            result = await this.processGenerationTask(task.data);
-            break;
-          case 'validate':
-            result = await this.processValidationTask(task.data);
-            break;
-          default:
-            throw new Error(`Unknown task type: ${task.type}`);
-        }
-      } catch (err) {
-        error = String(err);
-      }
-
-      const duration = performance.now() - startTime;
-      const memoryUsage = process.memoryUsage().heapUsed;
-
-      return { result, error, duration, memoryUsage };
-    },
-
-    async processAnalysisTask(data: AnalyzeTaskData): Promise<AnalyzeTaskResult> {
-      const results: AnalyzeTaskResult = [];
-      const activeAnalyzer = await getAnalyzer();
-
-      for (const [index, source] of data.sources.entries()) {
-        const start = performance.now();
-        try {
-          const modulePath = source.path ?? `${source.name}.py`;
-          const analysis = await activeAnalyzer.analyzePythonModule(source.content, modulePath);
-          results.push({
-            taskId: createResultId('analyze', source.name, index),
-            success: true,
-            result: analysis,
-            duration: performance.now() - start,
-            memoryUsage: process.memoryUsage().heapUsed,
-          });
-        } catch (error) {
-          results.push({
-            taskId: createResultId('analyze', source.name, index),
-            success: false,
-            error: String(error),
-            duration: performance.now() - start,
-            memoryUsage: process.memoryUsage().heapUsed,
-          });
-        }
-      }
-
-      return results;
-    },
-
-    async processGenerationTask(data: GenerationTaskData): Promise<GenerateTaskResult> {
-      const results: GenerateTaskResult = [];
-      const activeGenerator = getGenerator();
-
-      for (const [index, moduleData] of data.modules.entries()) {
-        const start = performance.now();
-        try {
-          const generationOptions = {
-            moduleName: moduleData.name,
-            ...moduleData.options,
-          } as {
-            moduleName: string;
-            exportAll?: boolean;
-            annotatedJSDoc?: boolean;
-          };
-          const generated = await activeGenerator.generateModule(
-            moduleData.module,
-            generationOptions
-          );
-          results.push({
-            taskId: createResultId('generate', moduleData.name, index),
-            success: true,
-            result: generated,
-            duration: performance.now() - start,
-            memoryUsage: process.memoryUsage().heapUsed,
-          });
-        } catch (error) {
-          results.push({
-            taskId: createResultId('generate', moduleData.name, index),
-            success: false,
-            error: String(error),
-            duration: performance.now() - start,
-            memoryUsage: process.memoryUsage().heapUsed,
-          });
-        }
-      }
-
-      return results;
-    },
-
-    async processValidationTask(_data: ValidationTaskData): Promise<ValidateTaskResult> {
-      // Validation logic would go here
-      return { validated: true };
-    },
-  };
-
-  port.on('message', async (raw: unknown) => {
-    const message = raw as WorkerControlMessage;
-    if (!message || typeof message !== 'object') {
-      return;
-    }
-
-    if (message.type === 'task') {
-      try {
-        const taskResult = await workerImplementation.processTask(message.task);
-
-        port.postMessage({
-          type: 'task_complete',
-          taskId: message.task.id,
-          ...(typeof taskResult === 'object' && taskResult !== null
-            ? taskResult
-            : { result: taskResult }),
-        });
-      } catch (error) {
-        port.postMessage({
-          type: 'task_complete',
-          taskId: message.task.id,
-          error: String(error),
-          duration: 0,
-        });
-      }
-    } else if (message.type === 'shutdown') {
-      process.exit(0);
-    }
-  });
-
-  // Signal that worker is ready
-  port.postMessage({
-    type: 'worker_ready',
-    workerId,
-  });
-}
-
-export const globalParallelProcessor = new ParallelProcessor();