workspace-utils 1.0.0 → 1.0.2

package/src/commands/run.ts

@@ -1,118 +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 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

@@ -1,262 +0,0 @@
-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(', ')}`);
-			}
-		}
-	}
-}