workspace-utils 1.0.0

package/src/commands/run.ts

@@ -0,0 +1,118 @@
+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 RunCommandOptions {
+	parallel?: boolean;
+	concurrency?: string;
+	filter?: string;
+	sequential?: boolean;
+}
+
+export async function runCommand(scriptName: string, options: RunCommandOptions): Promise<void> {
+	try {
+		Output.info(`Running script "${scriptName}" across packages...\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 script
+		const { valid: packagesWithScript, invalid: packagesWithoutScript } =
+			validatePackagesHaveScript(targetPackages, scriptName);
+
+		if (packagesWithoutScript.length > 0) {
+			Output.warning(`The following packages don't have the "${scriptName}" script:`);
+			packagesWithoutScript.forEach(pkg => {
+				Output.listItem(pkg.name);
+			});
+			console.log();
+		}
+
+		if (packagesWithScript.length === 0) {
+			Output.error(`No packages found with the "${scriptName}" script.`);
+			process.exit(1);
+		}
+
+		Output.success(`Running "${scriptName}" in ${packagesWithScript.length} packages:`);
+		packagesWithScript.forEach(pkg => {
+			Output.listItem(pkg.name);
+		});
+		console.log();
+
+		// Determine execution mode (parallel by default unless explicitly sequential)
+		const isParallel = !options.sequential;
+		const concurrency = parseInt(options.concurrency || '4', 10);
+
+		Output.log(`Package manager: ${workspace.packageManager.name}`, 'wrench', 'blue');
+		Output.log(
+			`Execution mode: ${isParallel ? `parallel (concurrency: ${concurrency})` : 'sequential'}`,
+			'lightning',
+			'blue'
+		);
+		console.log();
+
+		// Prepare command execution
+		const commands = prepareCommandExecution(
+			packagesWithScript,
+			scriptName,
+			workspace.packageManager
+		);
+
+		// Execute commands
+		const startTime = Date.now();
+		let results;
+
+		if (isParallel) {
+			results = await ProcessRunner.runParallel(commands, concurrency);
+		} else {
+			results = await ProcessRunner.runSequential(commands);
+		}
+
+		const totalDuration = Date.now() - startTime;
+
+		// Print summary
+		const successful = results.filter(r => r.success);
+		const failed = results.filter(r => !r.success);
+
+		Output.executionSummary(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 duration: ${Output.formatDuration(avgDuration)}`, 'chart');
+		}
+
+		// Exit with error code if any commands failed
+		if (failed.length > 0) {
+			process.exit(1);
+		}
+	} catch (error) {
+		Output.log(`Error: ${error instanceof Error ? error.message : String(error)}`, 'fire', 'red');
+		process.exit(1);
+	}
+}

package/src/core/dependency-graph.ts

@@ -0,0 +1,262 @@
+export interface DependencyNode {
+	name: string;
+	dependencies: Set<string>;
+	dependents: Set<string>;
+}
+
+export interface TopologicalResult {
+	order: string[];
+	cycles: string[][];
+}
+
+export class DependencyGraph {
+	private nodes: Map<string, DependencyNode> = new Map();
+
+	/**
+	 * Add a package to the dependency graph
+	 */
+	addPackage(packageName: string): void {
+		if (!this.nodes.has(packageName)) {
+			this.nodes.set(packageName, {
+				name: packageName,
+				dependencies: new Set(),
+				dependents: new Set(),
+			});
+		}
+	}
+
+	/**
+	 * Add a dependency relationship between two packages
+	 */
+	addDependency(packageName: string, dependencyName: string): void {
+		this.addPackage(packageName);
+		this.addPackage(dependencyName);
+
+		const packageNode = this.nodes.get(packageName)!;
+		const dependencyNode = this.nodes.get(dependencyName)!;
+
+		packageNode.dependencies.add(dependencyName);
+		dependencyNode.dependents.add(packageName);
+	}
+
+	/**
+	 * Get all packages in the graph
+	 */
+	getPackages(): string[] {
+		return Array.from(this.nodes.keys());
+	}
+
+	/**
+	 * Get direct dependencies of a package
+	 */
+	getDependencies(packageName: string): string[] {
+		const node = this.nodes.get(packageName);
+		return node ? Array.from(node.dependencies) : [];
+	}
+
+	/**
+	 * Get direct dependents of a package
+	 */
+	getDependents(packageName: string): string[] {
+		const node = this.nodes.get(packageName);
+		return node ? Array.from(node.dependents) : [];
+	}
+
+	/**
+	 * Perform topological sort using Kahn's algorithm
+	 * Returns the build order and any detected cycles
+	 */
+	topologicalSort(): TopologicalResult {
+		const result: string[] = [];
+		const inDegree: Map<string, number> = new Map();
+		const queue: string[] = [];
+
+		// Initialize in-degree count for all nodes
+		for (const [packageName, node] of this.nodes) {
+			inDegree.set(packageName, node.dependencies.size);
+
+			// Add nodes with no dependencies to the queue
+			if (node.dependencies.size === 0) {
+				queue.push(packageName);
+			}
+		}
+
+		// Process nodes with no incoming edges
+		while (queue.length > 0) {
+			const currentPackage = queue.shift()!;
+			result.push(currentPackage);
+
+			// Reduce in-degree for all dependents
+			const dependents = this.getDependents(currentPackage);
+			for (const dependent of dependents) {
+				const currentInDegree = inDegree.get(dependent)! - 1;
+				inDegree.set(dependent, currentInDegree);
+
+				// If no more dependencies, add to queue
+				if (currentInDegree === 0) {
+					queue.push(dependent);
+				}
+			}
+		}
+
+		// Detect cycles
+		const cycles: string[][] = [];
+		if (result.length !== this.nodes.size) {
+			const remainingNodes = this.getPackages().filter(pkg => !result.includes(pkg));
+			const detectedCycles = this.detectCycles(remainingNodes);
+			cycles.push(...detectedCycles);
+		}
+
+		return { order: result, cycles };
+	}
+
+	/**
+	 * Detect cycles in the remaining nodes using DFS
+	 */
+	private detectCycles(remainingNodes: string[]): string[][] {
+		const cycles: string[][] = [];
+		const visited = new Set<string>();
+		const recStack = new Set<string>();
+
+		const dfs = (node: string, path: string[]): void => {
+			if (recStack.has(node)) {
+				// Found a cycle
+				const cycleStart = path.indexOf(node);
+				if (cycleStart !== -1) {
+					cycles.push(path.slice(cycleStart).concat([node]));
+				}
+				return;
+			}
+
+			if (visited.has(node)) {
+				return;
+			}
+
+			visited.add(node);
+			recStack.add(node);
+
+			const dependencies = this.getDependencies(node);
+			for (const dep of dependencies) {
+				if (remainingNodes.includes(dep)) {
+					dfs(dep, [...path, node]);
+				}
+			}
+
+			recStack.delete(node);
+		};
+
+		for (const node of remainingNodes) {
+			if (!visited.has(node)) {
+				dfs(node, []);
+			}
+		}
+
+		return cycles;
+	}
+
+	/**
+	 * Get build batches - packages that can be built in parallel
+	 */
+	getBuildBatches(): string[][] {
+		const { order, cycles } = this.topologicalSort();
+
+		if (cycles.length > 0) {
+			throw new Error(
+				`Circular dependencies detected: ${cycles.map(cycle => cycle.join(' -> ')).join(', ')}`
+			);
+		}
+
+		const batches: string[][] = [];
+		const processed = new Set<string>();
+
+		while (processed.size < order.length) {
+			const currentBatch: string[] = [];
+
+			for (const packageName of order) {
+				if (processed.has(packageName)) {
+					continue;
+				}
+
+				// Check if all dependencies are already processed
+				const dependencies = this.getDependencies(packageName);
+				const allDepsProcessed = dependencies.every(dep => processed.has(dep));
+
+				if (allDepsProcessed) {
+					currentBatch.push(packageName);
+				}
+			}
+
+			if (currentBatch.length === 0) {
+				// This shouldn't happen if topological sort worked correctly
+				throw new Error('Unable to determine build order - possible circular dependency');
+			}
+
+			batches.push(currentBatch);
+			currentBatch.forEach(pkg => processed.add(pkg));
+		}
+
+		return batches;
+	}
+
+	/**
+	 * Filter the graph to only include specified packages
+	 */
+	filterGraph(packageNames: string[]): DependencyGraph {
+		const filteredGraph = new DependencyGraph();
+		const packageSet = new Set(packageNames);
+
+		// Add all specified packages
+		for (const packageName of packageNames) {
+			if (this.nodes.has(packageName)) {
+				filteredGraph.addPackage(packageName);
+			}
+		}
+
+		// Add dependencies between filtered packages
+		for (const packageName of packageNames) {
+			if (this.nodes.has(packageName)) {
+				const dependencies = this.getDependencies(packageName);
+				for (const dep of dependencies) {
+					if (packageSet.has(dep)) {
+						filteredGraph.addDependency(packageName, dep);
+					}
+				}
+			}
+		}
+
+		return filteredGraph;
+	}
+
+	/**
+	 * Get packages that have no dependencies (root packages)
+	 */
+	getRootPackages(): string[] {
+		return this.getPackages().filter(pkg => this.getDependencies(pkg).length === 0);
+	}
+
+	/**
+	 * Get packages that have no dependents (leaf packages)
+	 */
+	getLeafPackages(): string[] {
+		return this.getPackages().filter(pkg => this.getDependents(pkg).length === 0);
+	}
+
+	/**
+	 * Print the dependency graph for debugging
+	 */
+	printGraph(): void {
+		console.log('\n📊 Dependency Graph:');
+		for (const [packageName, node] of this.nodes) {
+			const deps = Array.from(node.dependencies);
+			const dependents = Array.from(node.dependents);
+
+			console.log(`\n📦 ${packageName}`);
+			if (deps.length > 0) {
+				console.log(`  ⬇️  Dependencies: ${deps.join(', ')}`);
+			}
+			if (dependents.length > 0) {
+				console.log(`  ⬆️  Dependents: ${dependents.join(', ')}`);
+			}
+		}
+	}
+}