workspace-utils 1.0.0 → 1.0.1

package/src/commands/build.ts

@@ -1,158 +0,0 @@
-import pc from 'picocolors';
-import { WorkspaceParser } from '../core/workspace.ts';
-import {
-	buildDependencyGraph,
-	validatePackagesHaveScript,
-	prepareCommandExecution,
-} from '../utils/package-utils.ts';
-import { ProcessRunner } from '../core/process-runner.ts';
-import { Output } from '../utils/output.ts';
-
-interface BuildCommandOptions {
-	filter?: string;
-	concurrency?: string;
-	skipUnchanged?: boolean;
-}
-
-export async function buildCommand(options: BuildCommandOptions): Promise<void> {
-	try {
-		Output.build('Building packages in dependency order...\n');
-
-		// Parse workspace
-		const parser = new WorkspaceParser();
-		const workspace = await parser.parseWorkspace();
-
-		Output.dim(`Workspace root: ${workspace.root}`, 'folder');
-		Output.dim(`Found ${workspace.packages.length} packages\n`, 'package');
-
-		// Filter packages if pattern provided
-		let targetPackages = workspace.packages;
-		if (options.filter) {
-			targetPackages = parser.filterPackages(workspace.packages, options.filter);
-			Output.log(
-				`Filtered to ${targetPackages.length} packages matching "${options.filter}"`,
-				'magnifying',
-				'yellow'
-			);
-		}
-
-		// Validate packages have the build script
-		const { valid: packagesWithBuild, invalid: packagesWithoutBuild } = validatePackagesHaveScript(
-			targetPackages,
-			'build'
-		);
-
-		if (packagesWithoutBuild.length > 0) {
-			Output.warning(`The following packages don't have a "build" script:`);
-			packagesWithoutBuild.forEach(pkg => {
-				Output.listItem(pkg.name);
-			});
-			console.log();
-		}
-
-		if (packagesWithBuild.length === 0) {
-			Output.error('No packages found with a "build" script.');
-			process.exit(1);
-		}
-
-		// Build dependency graph
-		Output.log('Building dependency graph...', 'chart', 'blue');
-		const dependencyGraph = buildDependencyGraph(packagesWithBuild);
-
-		// Filter graph to only include packages that need to be built
-		const packageNames = packagesWithBuild.map(pkg => pkg.name);
-		const filteredGraph = dependencyGraph.filterGraph(packageNames);
-
-		// Get build batches (topological order)
-		let buildBatches;
-		try {
-			buildBatches = filteredGraph.getBuildBatches();
-		} catch (error) {
-			Output.error(
-				`Dependency cycle detected: ${error instanceof Error ? error.message : String(error)}`
-			);
-			Output.tip('Check for circular dependencies between packages.');
-			process.exit(1);
-		}
-
-		Output.success(`Build order determined: ${buildBatches.length} batches`);
-
-		// Display build plan
-		console.log(pc.blue(`\n${Output.getSymbol('books')} Build Plan:`));
-		buildBatches.forEach((batch, index) => {
-			Output.listItem(`Batch ${index + 1}: ${batch.join(', ')}`);
-		});
-		console.log();
-
-		const concurrency = parseInt(options.concurrency || '4', 10);
-
-		Output.log(`Package manager: ${workspace.packageManager.name}`, 'wrench', 'blue');
-		Output.log(`Batch concurrency: ${concurrency}`, 'lightning', 'blue');
-		console.log();
-
-		// Prepare commands organized by batches
-		const packageMap = new Map(packagesWithBuild.map(pkg => [pkg.name, pkg]));
-		const commandBatches = buildBatches.map(batch => {
-			return batch
-				.map(packageName => packageMap.get(packageName))
-				.filter((pkg): pkg is NonNullable<typeof pkg> => pkg !== undefined)
-				.map(pkg => {
-					const commands = prepareCommandExecution([pkg], 'build', workspace.packageManager);
-					return commands[0];
-				})
-				.filter((cmd): cmd is NonNullable<typeof cmd> => cmd !== undefined);
-		});
-
-		// Execute builds in batches
-		const startTime = Date.now();
-		const allResults = await ProcessRunner.runBatches(commandBatches, concurrency);
-		const totalDuration = Date.now() - startTime;
-
-		// Print final summary
-		const successful = allResults.filter(r => r.success);
-		const failed = allResults.filter(r => !r.success);
-
-		Output.buildSummary(successful.length, failed.length, totalDuration);
-
-		if (failed.length > 0) {
-			console.log(pc.red('\nFailed packages:'));
-			failed.forEach(f => {
-				Output.listItem(`${f.packageName} (exit code ${f.exitCode})`);
-			});
-		}
-
-		if (successful.length > 0) {
-			const avgDuration = Math.round(
-				successful.reduce((sum, r) => sum + r.duration, 0) / successful.length
-			);
-			Output.dim(`Average package build time: ${Output.formatDuration(avgDuration)}`, 'chart');
-		}
-
-		// Show dependency chain info
-		const rootPackages = filteredGraph.getRootPackages();
-		const leafPackages = filteredGraph.getLeafPackages();
-
-		if (rootPackages.length > 0) {
-			Output.dim(`Root packages (no dependencies): ${rootPackages.join(', ')}`, 'seedling');
-		}
-
-		if (leafPackages.length > 0) {
-			Output.dim(`Leaf packages (no dependents): ${leafPackages.join(', ')}`, 'leaf');
-		}
-
-		// Exit with error code if any builds failed
-		if (failed.length > 0) {
-			Output.log('\nBuild failed due to package failures.', 'fire', 'red');
-			process.exit(1);
-		} else {
-			Output.celebrate('\nAll packages built successfully!');
-		}
-	} catch (error) {
-		Output.log(
-			`Build error: ${error instanceof Error ? error.message : String(error)}`,
-			'fire',
-			'red'
-		);
-		process.exit(1);
-	}
-}

package/src/commands/dev.ts

@@ -1,192 +0,0 @@
-import pc from 'picocolors';
-import { WorkspaceParser } from '../core/workspace.ts';
-import { validatePackagesHaveScript, prepareCommandExecution } from '../utils/package-utils.ts';
-import { ProcessRunner } from '../core/process-runner.ts';
-import { Output } from '../utils/output.ts';
-
-interface DevCommandOptions {
-	filter?: string;
-	concurrency?: string;
-}
-
-export async function devCommand(options: DevCommandOptions): Promise<void> {
-	try {
-		Output.dev('Starting development servers with live log streaming...\n');
-
-		// Parse workspace
-		const parser = new WorkspaceParser();
-		const workspace = await parser.parseWorkspace();
-
-		Output.dim(`Workspace root: ${workspace.root}`, 'folder');
-		Output.dim(`Found ${workspace.packages.length} packages\n`, 'package');
-
-		// Filter packages if pattern provided
-		let targetPackages = workspace.packages;
-		if (options.filter) {
-			targetPackages = parser.filterPackages(workspace.packages, options.filter);
-			Output.log(
-				`Filtered to ${targetPackages.length} packages matching "${options.filter}"`,
-				'magnifying',
-				'yellow'
-			);
-		}
-
-		// Validate packages have the dev script
-		const { valid: packagesWithDev, invalid: packagesWithoutDev } = validatePackagesHaveScript(
-			targetPackages,
-			'dev'
-		);
-
-		if (packagesWithoutDev.length > 0) {
-			Output.warning(`The following packages don't have a "dev" script:`);
-			packagesWithoutDev.forEach(pkg => {
-				Output.listItem(pkg.name);
-			});
-			console.log();
-		}
-
-		if (packagesWithDev.length === 0) {
-			Output.error('No packages found with a "dev" script.');
-			process.exit(1);
-		}
-
-		Output.success(`Starting dev servers for ${packagesWithDev.length} packages:`);
-		packagesWithDev.forEach(pkg => {
-			const color = ProcessRunner.getPackageColor(pkg.name);
-			const getColorFn = (colorName: string) => {
-				switch (colorName) {
-					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;
-				}
-			};
-			const colorFn = getColorFn(color);
-			console.log(`  • ${colorFn(pkg.name)}`);
-		});
-		console.log();
-
-		const concurrency = parseInt(options.concurrency || '4', 10);
-
-		Output.log(`Package manager: ${workspace.packageManager.name}`, 'wrench', 'blue');
-		Output.log(
-			`Running ${Math.min(packagesWithDev.length, concurrency)} dev servers simultaneously`,
-			'lightning',
-			'blue'
-		);
-		Output.tip('Use Ctrl+C to stop all development servers\n');
-
-		// Prepare command execution with enhanced logging for dev mode
-		const commands = prepareCommandExecution(packagesWithDev, 'dev', workspace.packageManager).map(
-			cmd => ({
-				...cmd,
-				logOptions: {
-					...cmd.logOptions,
-					showTimestamp: false, // Disable timestamps for dev mode
-				},
-			})
-		);
-
-		// Set up graceful shutdown
-		let isShuttingDown = false;
-		const shutdown = () => {
-			if (isShuttingDown) return;
-			isShuttingDown = true;
-
-			Output.log('\n\nShutting down development servers...', 'warning', 'yellow');
-			Output.dim('This may take a moment to gracefully stop all processes.\n');
-
-			// Force exit after a timeout
-			setTimeout(() => {
-				Output.log('Timeout reached, forcing exit...', 'clock', 'red');
-				process.exit(0);
-			}, 5000);
-		};
-
-		process.on('SIGINT', shutdown);
-		process.on('SIGTERM', shutdown);
-
-		Output.log('Starting development servers...\n', 'movie', 'green');
-		Output.separator();
-
-		// Execute all dev commands in parallel (they're meant to run indefinitely)
-		const startTime = Date.now();
-
-		try {
-			// For dev mode, we don't wait for completion since these are long-running processes
-			const promises = commands.map(cmd =>
-				ProcessRunner.runCommand(cmd.command, cmd.args, cmd.options, cmd.logOptions).catch(
-					error => {
-						Output.log(`Error in ${cmd.logOptions.prefix}: ${error}`, 'fire', 'red');
-						return {
-							success: false,
-							exitCode: 1,
-							packageName: cmd.logOptions.prefix,
-							command: `${cmd.command} ${cmd.args.join(' ')}`,
-							duration: Date.now() - startTime,
-						};
-					}
-				)
-			);
-
-			// Wait for all processes to start
-			await Promise.allSettled(promises.slice(0, Math.min(concurrency, promises.length)));
-
-			// If we reach here, some processes may have exited unexpectedly
-			if (!isShuttingDown) {
-				Output.warning('\nSome development servers may have stopped unexpectedly.');
-				Output.dim('Check the logs above for any error messages.\n');
-			}
-		} catch (error) {
-			if (!isShuttingDown) {
-				Output.log(
-					`Development server error: ${error instanceof Error ? error.message : String(error)}`,
-					'fire',
-					'red'
-				);
-			}
-		}
-
-		const totalDuration = Date.now() - startTime;
-
-		if (!isShuttingDown) {
-			Output.log(
-				`\nDevelopment session lasted: ${Output.formatDuration(totalDuration)}`,
-				'chart',
-				'blue'
-			);
-			Output.success('All development servers have stopped.');
-		}
-	} catch (error) {
-		Output.log(
-			`Dev command error: ${error instanceof Error ? error.message : String(error)}`,
-			'fire',
-			'red'
-		);
-		process.exit(1);
-	}
-}

package/src/commands/run.test.ts

@@ -1,329 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import { runCommand } from './run.ts';
-import { spyOn } from 'bun:test';
-
-describe('runCommand', () => {
-	const testDir = join(process.cwd(), 'test-temp-run');
-
-	beforeEach(() => {
-		// Clean up test directory if it exists
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-		mkdirSync(testDir, { recursive: true });
-
-		// Change to test directory
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		// Change back to original directory
-		process.chdir(process.cwd().replace('/test-temp-run', ''));
-
-		// Clean up test directory
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
-	describe('Bun workspace', () => {
-		beforeEach(() => {
-			// Create Bun workspace
-			writeFileSync(join(testDir, 'bun.lockb'), '');
-			writeFileSync(
-				join(testDir, 'package.json'),
-				JSON.stringify({
-					name: 'test-workspace',
-					workspaces: ['packages/*'],
-				})
-			);
-
-			// Create test packages
-			mkdirSync(join(testDir, 'packages', 'pkg1'), { recursive: true });
-			writeFileSync(
-				join(testDir, 'packages', 'pkg1', 'package.json'),
-				JSON.stringify({
-					name: '@test/pkg1',
-					version: '1.0.0',
-					scripts: {
-						test: 'echo "Testing pkg1"',
-						build: 'echo "Building pkg1"',
-						lint: 'echo "Linting pkg1"',
-					},
-				})
-			);
-
-			mkdirSync(join(testDir, 'packages', 'pkg2'), { recursive: true });
-			writeFileSync(
-				join(testDir, 'packages', 'pkg2', 'package.json'),
-				JSON.stringify({
-					name: '@test/pkg2',
-					version: '1.0.0',
-					scripts: {
-						test: 'echo "Testing pkg2"',
-						build: 'echo "Building pkg2"',
-					},
-				})
-			);
-		});
-
-		it('should run test script in parallel by default', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = {};
-
-			try {
-				await runCommand('test', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('🔧 Package manager: bun'));
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('⚡ Execution mode: parallel (concurrency: 4)')
-			);
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-
-		it('should run script sequentially when --sequential flag is used', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = { sequential: true };
-
-			try {
-				await runCommand('test', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('⚡ Execution mode: sequential')
-			);
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-
-		it('should filter packages when filter option is provided', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = { filter: '*pkg1*' };
-
-			try {
-				await runCommand('test', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('🔍 Filtered to 1 packages matching "*pkg1*"')
-			);
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('✅ Running "test" in 1 packages:')
-			);
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-
-		it('should handle packages without the specified script', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = {};
-
-			try {
-				await runCommand('lint', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('⚠️  The following packages don\'t have the "lint" script:')
-			);
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('• @test/pkg2'));
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-
-		it('should exit with error when no packages have the script', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = {};
-
-			try {
-				await runCommand('nonexistent', options);
-			} catch (error) {
-				expect((error as Error).message).toBe('process.exit called');
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('❌ No packages found with the "nonexistent" script.')
-			);
-			expect(processExitSpy).toHaveBeenCalledWith(1);
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-
-		it('should use custom concurrency when specified', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = { concurrency: '8' };
-
-			try {
-				await runCommand('test', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('⚡ Execution mode: parallel (concurrency: 8)')
-			);
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-	});
-
-	describe('pnpm workspace', () => {
-		beforeEach(() => {
-			// Create pnpm workspace
-			writeFileSync(join(testDir, 'pnpm-lock.yaml'), 'lockfileVersion: 6.0');
-			writeFileSync(join(testDir, 'pnpm-workspace.yaml'), 'packages:\n  - packages/*');
-
-			// Create test package
-			mkdirSync(join(testDir, 'packages', 'utils'), { recursive: true });
-			writeFileSync(
-				join(testDir, 'packages', 'utils', 'package.json'),
-				JSON.stringify({
-					name: '@test/utils',
-					version: '1.0.0',
-					scripts: {
-						test: 'echo "Testing utils with pnpm"',
-					},
-				})
-			);
-		});
-
-		it('should detect pnpm as package manager', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = {};
-
-			try {
-				await runCommand('test', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('🔧 Package manager: pnpm'));
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-	});
-
-	describe('npm workspace', () => {
-		beforeEach(() => {
-			// Create npm workspace
-			writeFileSync(join(testDir, 'package-lock.json'), '{}');
-			writeFileSync(
-				join(testDir, 'package.json'),
-				JSON.stringify({
-					name: 'test-workspace',
-					workspaces: ['libs/*'],
-				})
-			);
-
-			// Create test package
-			mkdirSync(join(testDir, 'libs', 'core'), { recursive: true });
-			writeFileSync(
-				join(testDir, 'libs', 'core', 'package.json'),
-				JSON.stringify({
-					name: 'core',
-					version: '1.0.0',
-					scripts: {
-						test: 'echo "Testing core with npm"',
-					},
-				})
-			);
-		});
-
-		it('should detect npm as package manager', async () => {
-			const consoleSpy = spyOn(console, 'log');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = {};
-
-			try {
-				await runCommand('test', options);
-			} catch {
-				// Expected to throw due to process.exit mock
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('🔧 Package manager: npm'));
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-	});
-
-	describe('error handling', () => {
-		it('should handle workspace parsing errors gracefully', async () => {
-			// Create invalid workspace (no workspaces config)
-			writeFileSync(
-				join(testDir, 'package.json'),
-				JSON.stringify({
-					name: 'invalid-workspace',
-				})
-			);
-
-			const consoleSpy = spyOn(console, 'error');
-			const processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
-				throw new Error('process.exit called');
-			});
-
-			const options = {};
-
-			try {
-				await runCommand('test', options);
-			} catch (error) {
-				expect((error as Error).message).toBe('process.exit called');
-			}
-
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('💥 Error:'));
-			expect(processExitSpy).toHaveBeenCalledWith(1);
-
-			consoleSpy.mockRestore();
-			processExitSpy.mockRestore();
-		});
-	});
-});