workspace-utils 1.0.0

package/src/core/process-runner.ts

@@ -0,0 +1,355 @@
+import { spawn } from 'child_process';
+import pc from 'picocolors';
+
+export interface ProcessOptions {
+	cwd: string;
+	env?: Record<string, string>;
+	stdio?: 'inherit' | 'pipe';
+}
+
+export interface LogOptions {
+	prefix: string;
+	color: string;
+	showTimestamp?: boolean;
+}
+
+export interface ProcessResult {
+	success: boolean;
+	exitCode: number;
+	packageName: string;
+	command: string;
+	duration: number;
+}
+
+export class ProcessRunner {
+	private static colorPalette: string[] = [
+		'red',
+		'green',
+		'yellow',
+		'blue',
+		'magenta',
+		'cyan',
+		'gray',
+		'redBright',
+		'greenBright',
+		'yellowBright',
+		'blueBright',
+		'magentaBright',
+		'cyanBright',
+	];
+
+	private static assignedColors = new Map<string, string>();
+	private static colorIndex = 0;
+
+	/**
+	 * Get a consistent color for a package
+	 */
+	static getPackageColor(packageName: string): string {
+		if (!this.assignedColors.has(packageName)) {
+			const colorIndex = this.colorIndex % this.colorPalette.length;
+			const color = this.colorPalette[colorIndex] || 'white';
+			this.assignedColors.set(packageName, color);
+			this.colorIndex++;
+		}
+		const color = this.assignedColors.get(packageName);
+		return color || 'white';
+	}
+
+	/**
+	 * Get color function from picocolors
+	 */
+	private static getColorFn(color: string) {
+		switch (color) {
+			case 'red':
+				return pc.red;
+			case 'green':
+				return pc.green;
+			case 'yellow':
+				return pc.yellow;
+			case 'blue':
+				return pc.blue;
+			case 'magenta':
+				return pc.magenta;
+			case 'cyan':
+				return pc.cyan;
+			case 'gray':
+				return pc.gray;
+			case 'redBright':
+				return pc.redBright;
+			case 'greenBright':
+				return pc.greenBright;
+			case 'yellowBright':
+				return pc.yellowBright;
+			case 'blueBright':
+				return pc.blueBright;
+			case 'magentaBright':
+				return pc.magentaBright;
+			case 'cyanBright':
+				return pc.cyanBright;
+			default:
+				return pc.white;
+		}
+	}
+
+	/**
+	 * Run a single command with real-time log streaming
+	 */
+	static async runCommand(
+		command: string,
+		args: string[],
+		options: ProcessOptions,
+		logOptions: LogOptions
+	): Promise<ProcessResult> {
+		const startTime = Date.now();
+		const fullCommand = [command, ...args].join(' ');
+
+		const colorFn = this.getColorFn(logOptions.color);
+		console.log(`[${colorFn(logOptions.prefix)}] ` + pc.gray(`Starting: ${fullCommand}`));
+
+		return new Promise(resolve => {
+			const childProcess = spawn(command, args, {
+				cwd: options.cwd,
+				env: { ...process.env, ...options.env },
+				stdio: ['inherit', 'pipe', 'pipe'],
+			});
+
+			// Stream stdout with prefix and color
+			if (childProcess.stdout) {
+				childProcess.stdout.on('data', data => {
+					const lines = data.toString().split('\n');
+					lines.forEach((line: string) => {
+						if (line.trim()) {
+							this.logLine(line, logOptions, false);
+						}
+					});
+				});
+			}
+
+			// Stream stderr with prefix and color
+			if (childProcess.stderr) {
+				childProcess.stderr.on('data', data => {
+					const lines = data.toString().split('\n');
+					lines.forEach((line: string) => {
+						if (line.trim()) {
+							this.logLine(line, logOptions, true);
+						}
+					});
+				});
+			}
+
+			childProcess.on('close', exitCode => {
+				const duration = Date.now() - startTime;
+				const code = exitCode || 0;
+
+				const result: ProcessResult = {
+					success: code === 0,
+					exitCode: code,
+					packageName: logOptions.prefix,
+					command: fullCommand,
+					duration,
+				};
+
+				const colorFn = this.getColorFn(logOptions.color);
+				if (code === 0) {
+					console.log(
+						`[${colorFn(logOptions.prefix)}] ` + pc.green(`✅ Completed in ${duration}ms`)
+					);
+				} else {
+					console.log(
+						`[${colorFn(logOptions.prefix)}] ` +
+							pc.red(`❌ Failed with exit code ${code} (${duration}ms)`)
+					);
+				}
+
+				resolve(result);
+			});
+
+			childProcess.on('error', error => {
+				const duration = Date.now() - startTime;
+				const colorFn = this.getColorFn(logOptions.color);
+				console.error(`[${colorFn(logOptions.prefix)}] ` + pc.red(`💥 Error: ${error.message}`));
+
+				resolve({
+					success: false,
+					exitCode: 1,
+					packageName: logOptions.prefix,
+					command: fullCommand,
+					duration,
+				});
+			});
+		});
+	}
+
+	/**
+	 * Log a single line with prefix and color
+	 */
+	private static logLine(line: string, logOptions: LogOptions, isError = false): void {
+		const timestamp = logOptions.showTimestamp ? pc.dim(`[${new Date().toISOString()}] `) : '';
+
+		// Only color the package name in brackets, not the entire line
+		const colorFn = this.getColorFn(logOptions.color);
+		const coloredPrefix = `[${colorFn(logOptions.prefix)}] `;
+
+		// Apply error color only to the actual log content if it's an error
+		const logContent = isError ? pc.red(line) : line;
+
+		console.log(timestamp + coloredPrefix + logContent);
+	}
+
+	/**
+	 * Run multiple commands in parallel with concurrency limit
+	 */
+	static async runParallel(
+		commands: Array<{
+			command: string;
+			args: string[];
+			options: ProcessOptions;
+			logOptions: LogOptions;
+		}>,
+		concurrency = 4
+	): Promise<ProcessResult[]> {
+		const results: ProcessResult[] = [];
+		const executing: Promise<ProcessResult>[] = [];
+
+		for (let i = 0; i < commands.length; i++) {
+			const cmd = commands[i];
+			if (!cmd) continue;
+
+			// Start the command
+			const promise = this.runCommand(cmd.command, cmd.args, cmd.options, cmd.logOptions);
+
+			executing.push(promise);
+
+			// If we've reached the concurrency limit or this is the last command
+			if (executing.length >= concurrency || i === commands.length - 1) {
+				// Wait for at least one to complete
+				const completedIndex = await this.waitForAny(executing);
+				const completedPromise = executing[completedIndex];
+				if (completedPromise) {
+					const completed = await completedPromise;
+					results.push(completed);
+				}
+
+				// Remove completed promise from executing array
+				executing.splice(completedIndex, 1);
+			}
+		}
+
+		// Wait for all remaining commands to complete
+		const remainingResults = await Promise.all(executing);
+		results.push(...remainingResults);
+
+		return results;
+	}
+
+	/**
+	 * Wait for any promise to complete and return its index
+	 */
+	private static async waitForAny(promises: Promise<ProcessResult>[]): Promise<number> {
+		return new Promise(resolve => {
+			promises.forEach((promise, index) => {
+				promise.then(() => resolve(index));
+			});
+		});
+	}
+
+	/**
+	 * Run commands sequentially (one after another)
+	 */
+	static async runSequential(
+		commands: Array<{
+			command: string;
+			args: string[];
+			options: ProcessOptions;
+			logOptions: LogOptions;
+		}>
+	): Promise<ProcessResult[]> {
+		const results: ProcessResult[] = [];
+
+		for (const cmd of commands) {
+			const result = await this.runCommand(cmd.command, cmd.args, cmd.options, cmd.logOptions);
+
+			results.push(result);
+
+			// Stop on first failure unless explicitly configured to continue
+			if (!result.success) {
+				console.log(pc.red(`\n❌ Stopping execution due to failure in ${result.packageName}`));
+				break;
+			}
+		}
+
+		return results;
+	}
+
+	/**
+	 * Run commands in batches (for dependency-aware execution)
+	 */
+	static async runBatches(
+		batches: Array<
+			Array<{
+				command: string;
+				args: string[];
+				options: ProcessOptions;
+				logOptions: LogOptions;
+			}>
+		>,
+		concurrency = 4
+	): Promise<ProcessResult[]> {
+		const allResults: ProcessResult[] = [];
+
+		for (let i = 0; i < batches.length; i++) {
+			const batch = batches[i];
+			if (!batch) continue;
+
+			console.log(
+				pc.blue(`\n🔄 Running batch ${i + 1}/${batches.length} (${batch.length} packages)`)
+			);
+
+			// Run all commands in this batch in parallel
+			const batchResults = await this.runParallel(batch, concurrency);
+			allResults.push(...batchResults);
+
+			// Check if any command in this batch failed
+			const failures = batchResults.filter(r => !r.success);
+			if (failures.length > 0) {
+				console.log(pc.red(`\n❌ Batch ${i + 1} failed. The following packages failed:`));
+				failures.forEach(f => {
+					console.log(pc.red(`  • ${f.packageName}: ${f.command}`));
+				});
+				console.log(pc.red(`\nStopping execution due to batch failure.`));
+				break;
+			}
+
+			console.log(pc.green(`✅ Batch ${i + 1} completed successfully`));
+		}
+
+		return allResults;
+	}
+
+	/**
+	 * Print execution summary
+	 */
+	static printSummary(results: ProcessResult[]): void {
+		const successful = results.filter(r => r.success);
+		const failed = results.filter(r => !r.success);
+		const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+
+		console.log(pc.bold('\n📊 Execution Summary:'));
+		console.log(pc.green(`✅ Successful: ${successful.length}`));
+
+		if (failed.length > 0) {
+			console.log(pc.red(`❌ Failed: ${failed.length}`));
+			console.log(pc.red('\nFailed packages:'));
+			failed.forEach(f => {
+				console.log(pc.red(`  • ${f.packageName} (exit code ${f.exitCode})`));
+			});
+		}
+
+		console.log(pc.blue(`⏱️  Total duration: ${totalDuration}ms`));
+
+		if (successful.length > 0) {
+			const avgDuration = Math.round(totalDuration / successful.length);
+			console.log(pc.dim(`📈 Average duration: ${avgDuration}ms`));
+		}
+	}
+}