workspace-utils 1.0.0

package/src/package-managers/pnpm.ts

@@ -0,0 +1,101 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+import type { PackageManager, WorkspaceConfig } from './types.ts';
+
+export class PnpmPackageManager implements PackageManager {
+	readonly name = 'pnpm';
+
+	isActive(workspaceRoot: string): boolean {
+		// Check for pnpm-lock.yaml file
+		const lockFile = join(workspaceRoot, 'pnpm-lock.yaml');
+		if (existsSync(lockFile)) {
+			return true;
+		}
+
+		// Check for pnpm-workspace.yaml
+		const workspaceFile = join(workspaceRoot, 'pnpm-workspace.yaml');
+		if (existsSync(workspaceFile)) {
+			return true;
+		}
+
+		// Check for .pnpmfile.cjs or pnpm configuration in package.json
+		const pnpmFile = join(workspaceRoot, '.pnpmfile.cjs');
+		if (existsSync(pnpmFile)) {
+			return true;
+		}
+
+		const packageJsonPath = join(workspaceRoot, 'package.json');
+		if (existsSync(packageJsonPath)) {
+			try {
+				const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as Record<
+					string,
+					unknown
+				>;
+				// Check for pnpm-specific fields
+				const publishConfig = packageJson.publishConfig as Record<string, unknown> | undefined;
+				if (packageJson.pnpm || publishConfig?.registry) {
+					return true;
+				}
+			} catch {
+				// Ignore JSON parse errors
+			}
+		}
+
+		return false;
+	}
+
+	getRunCommand(scriptName: string): { command: string; args: string[] } {
+		return {
+			command: 'pnpm',
+			args: ['run', scriptName],
+		};
+	}
+
+	parseWorkspaceConfig(workspaceRoot: string): WorkspaceConfig {
+		// First try pnpm-workspace.yaml
+		const workspaceFile = join(workspaceRoot, 'pnpm-workspace.yaml');
+		if (existsSync(workspaceFile)) {
+			const content = readFileSync(workspaceFile, 'utf8');
+			const config = parseYaml(content) as { packages?: string[] };
+
+			if (!config.packages || !Array.isArray(config.packages)) {
+				throw new Error('Invalid pnpm-workspace.yaml: packages must be an array');
+			}
+
+			return { packages: config.packages };
+		}
+
+		// Fallback to package.json workspaces
+		const packageJsonPath = join(workspaceRoot, 'package.json');
+		if (!existsSync(packageJsonPath)) {
+			throw new Error('No pnpm-workspace.yaml or package.json found in workspace root');
+		}
+
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as Record<
+			string,
+			unknown
+		>;
+
+		if (!packageJson.workspaces) {
+			throw new Error(
+				'No pnpm-workspace.yaml found and no workspaces configuration in package.json'
+			);
+		}
+
+		const workspaces = packageJson.workspaces as string[] | { packages: string[] };
+		const packages = Array.isArray(workspaces) ? workspaces : workspaces.packages;
+
+		if (!Array.isArray(packages)) {
+			throw new Error(
+				'Invalid workspaces configuration: must be an array or object with packages array'
+			);
+		}
+
+		return { packages };
+	}
+
+	getLockFileName(): string {
+		return 'pnpm-lock.yaml';
+	}
+}

package/src/package-managers/types.ts

@@ -0,0 +1,42 @@
+export interface PackageManagerConfig {
+	name: string;
+	lockFile: string;
+	command: string;
+	runArgs: string[];
+}
+
+export interface WorkspaceConfig {
+	packages: string[];
+}
+
+export interface PackageManager {
+	/**
+	 * Name of the package manager
+	 */
+	readonly name: string;
+
+	/**
+	 * Check if this package manager is being used in the current directory
+	 */
+	isActive(workspaceRoot: string): boolean;
+
+	/**
+	 * Get the command and arguments to run a script
+	 */
+	getRunCommand(scriptName: string): { command: string; args: string[] };
+
+	/**
+	 * Parse workspace configuration
+	 */
+	parseWorkspaceConfig(workspaceRoot: string): WorkspaceConfig;
+
+	/**
+	 * Get the lock file name for this package manager
+	 */
+	getLockFileName(): string;
+}
+
+export interface PackageManagerDetectionResult {
+	packageManager: PackageManager;
+	confidence: number;
+}

package/src/utils/output.ts

@@ -0,0 +1,301 @@
+import pc from 'picocolors';
+
+interface OutputSymbols {
+	rocket: string;
+	folder: string;
+	package: string;
+	checkmark: string;
+	crossmark: string;
+	warning: string;
+	wrench: string;
+	lightning: string;
+	clock: string;
+	target: string;
+	magnifying: string;
+	chart: string;
+	fire: string;
+	trophy: string;
+	seedling: string;
+	leaf: string;
+	books: string;
+	gear: string;
+	construction: string;
+	movie: string;
+	lightbulb: string;
+	sparkles: string;
+	party: string;
+	boom: string;
+	building: string;
+	arrow: string;
+	dot: string;
+}
+
+// Always use ASCII for maximum compatibility
+function supportsUnicode(): boolean {
+	// Only use Unicode if explicitly requested
+	if (process.env.WSU_UNICODE === '1' || process.env.WSU_UNICODE === 'true') {
+		return true;
+	}
+
+	// Default to ASCII for all environments
+	return false;
+}
+
+// Create symbol sets based on Unicode support
+const UNICODE_SYMBOLS: OutputSymbols = {
+	rocket: '🚀',
+	folder: '📁',
+	package: '📦',
+	checkmark: '✅',
+	crossmark: '❌',
+	warning: '⚠️',
+	wrench: '🔧',
+	lightning: '🚀',
+	clock: '⏱️',
+	target: '🎯',
+	magnifying: '🔍',
+	chart: '📊',
+	fire: '💥',
+	trophy: '🏆',
+	seedling: '🌱',
+	leaf: '🍃',
+	books: '📚',
+	gear: '🔧',
+	construction: '🏗️',
+	movie: '🎬',
+	lightbulb: '💡',
+	sparkles: '✨',
+	party: '🎉',
+	boom: '💥',
+	building: '🏢',
+	arrow: '🔗',
+	dot: '🔸',
+};
+
+const ASCII_SYMBOLS: OutputSymbols = {
+	rocket: '>',
+	folder: '[DIR]',
+	package: '[PKG]',
+	checkmark: '[OK]',
+	crossmark: '[ERR]',
+	warning: '[WARN]',
+	wrench: '[TOOL]',
+	lightning: '[FAST]',
+	clock: '[TIME]',
+	target: '[TARGET]',
+	magnifying: '[FIND]',
+	chart: '[CHART]',
+	fire: '[BOOM]',
+	trophy: '[WIN]',
+	seedling: '[ROOT]',
+	leaf: '[LEAF]',
+	books: '[DOCS]',
+	gear: '[GEAR]',
+	construction: '[BUILD]',
+	movie: '[START]',
+	lightbulb: '[TIP]',
+	sparkles: '[DONE]',
+	party: '[SUCCESS]',
+	boom: '[ERROR]',
+	building: '[CORP]',
+	arrow: '->',
+	dot: '*',
+};
+
+// Select appropriate symbol set
+const symbols: OutputSymbols = supportsUnicode() ? UNICODE_SYMBOLS : ASCII_SYMBOLS;
+
+/**
+ * Output utility class for consistent, terminal-compatible logging
+ */
+export class Output {
+	private static readonly symbols = symbols;
+
+	/**
+	 * Log a message with appropriate formatting and symbols
+	 */
+	static log(
+		message: string,
+		symbol?: keyof OutputSymbols,
+		color?: 'blue' | 'green' | 'red' | 'yellow' | 'dim'
+	): void {
+		const prefix = symbol ? `${this.symbols[symbol]} ` : '';
+		const formattedMessage = `${prefix}${message}`;
+
+		if (color) {
+			console.log(pc[color](formattedMessage));
+		} else {
+			console.log(formattedMessage);
+		}
+	}
+
+	/**
+	 * Log an info message (blue with rocket)
+	 */
+	static info(message: string): void {
+		this.log(message, 'rocket', 'blue');
+	}
+
+	/**
+	 * Log a success message (green with checkmark)
+	 */
+	static success(message: string): void {
+		this.log(message, 'checkmark', 'green');
+	}
+
+	/**
+	 * Log an error message (red with crossmark)
+	 */
+	static error(message: string): void {
+		this.log(message, 'crossmark', 'red');
+	}
+
+	/**
+	 * Log a warning message (yellow with warning)
+	 */
+	static warning(message: string): void {
+		this.log(message, 'warning', 'yellow');
+	}
+
+	/**
+	 * Log a dim/muted message
+	 */
+	static dim(message: string, symbol?: keyof OutputSymbols): void {
+		this.log(message, symbol, 'dim');
+	}
+
+	/**
+	 * Log a build-related message
+	 */
+	static build(message: string): void {
+		this.log(message, 'construction', 'blue');
+	}
+
+	/**
+	 * Log a development-related message
+	 */
+	static dev(message: string): void {
+		this.log(message, 'movie', 'blue');
+	}
+
+	/**
+	 * Log a package-related message
+	 */
+	static package(message: string): void {
+		this.log(message, 'package', 'blue');
+	}
+
+	/**
+	 * Log a timing message
+	 */
+	static timing(message: string): void {
+		this.log(message, 'clock', 'blue');
+	}
+
+	/**
+	 * Log a target/summary message
+	 */
+	static summary(message: string): void {
+		this.log(message, 'target', 'blue');
+	}
+
+	/**
+	 * Log a celebration message
+	 */
+	static celebrate(message: string): void {
+		this.log(message, 'party', 'green');
+	}
+
+	/**
+	 * Log a tip message
+	 */
+	static tip(message: string): void {
+		this.log(message, 'lightbulb', 'yellow');
+	}
+
+	/**
+	 * Create a formatted list item
+	 */
+	static listItem(item: string, indent: number = 2): void {
+		const spaces = ' '.repeat(indent);
+		this.log(`${spaces}${item}`, 'dot', 'dim');
+	}
+
+	/**
+	 * Create a separator line
+	 */
+	static separator(): void {
+		const line = supportsUnicode()
+			? '────────────────────────────────────────────────────────'
+			: '--------------------------------------------------------';
+		console.log(pc.dim(line));
+	}
+
+	/**
+	 * Get a symbol without logging
+	 */
+	static getSymbol(symbol: keyof OutputSymbols): string {
+		return this.symbols[symbol];
+	}
+
+	/**
+	 * Format a package name with brackets
+	 */
+	static formatPackageName(name: string, color?: string): string {
+		const formatted = `[${name}]`;
+		return color ? pc[color as keyof typeof pc](formatted) : formatted;
+	}
+
+	/**
+	 * Format duration in a human-readable way
+	 */
+	static formatDuration(ms: number): string {
+		if (ms < 1000) {
+			return `${ms}ms`;
+		} else if (ms < 60000) {
+			return `${(ms / 1000).toFixed(1)}s`;
+		} else {
+			const minutes = Math.floor(ms / 60000);
+			const seconds = ((ms % 60000) / 1000).toFixed(0);
+			return `${minutes}m ${seconds}s`;
+		}
+	}
+
+	/**
+	 * Log execution summary with consistent formatting
+	 */
+	static executionSummary(successful: number, failed: number, totalDuration: number): void {
+		console.log(pc.bold(`\n${this.symbols.chart} Execution Summary:`));
+		this.success(`Successful: ${successful}`);
+
+		if (failed > 0) {
+			this.error(`Failed: ${failed}`);
+		}
+
+		this.timing(`Total duration: ${this.formatDuration(totalDuration)}`);
+	}
+
+	/**
+	 * Log build summary with consistent formatting
+	 */
+	static buildSummary(successful: number, failed: number, totalDuration: number): void {
+		console.log(pc.bold(`\n${this.symbols.target} Build Summary:`));
+		this.success(`Successfully built: ${successful} packages`);
+
+		if (failed > 0) {
+			this.error(`Failed to build: ${failed} packages`);
+		}
+
+		this.timing(`Total build time: ${this.formatDuration(totalDuration)}`);
+	}
+
+	/**
+	 * Check if Unicode is supported in current environment
+	 */
+	static get supportsUnicode(): boolean {
+		return supportsUnicode();
+	}
+}
+
+// Re-export symbols for direct access if needed
+export { symbols };

package/src/utils/package-utils.ts

@@ -0,0 +1,243 @@
+import type { PackageInfo, WorkspaceInfo } from '../core/workspace.ts';
+import { DependencyGraph } from '../core/dependency-graph.ts';
+import type { ProcessResult } from '../core/process-runner.ts';
+import type { PackageManager } from '../package-managers/index.ts';
+
+export interface BuildContext {
+	workspace: WorkspaceInfo;
+	packages: PackageInfo[];
+	dependencyGraph: DependencyGraph;
+}
+
+/**
+ * Build a dependency graph from workspace packages
+ */
+export function buildDependencyGraph(packages: PackageInfo[]): DependencyGraph {
+	const graph = new DependencyGraph();
+	const packageNames = new Set(packages.map(pkg => pkg.name));
+
+	// Add all packages to the graph
+	packages.forEach(pkg => {
+		graph.addPackage(pkg.name);
+	});
+
+	// Add dependency relationships
+	packages.forEach(pkg => {
+		// Check both dependencies and devDependencies
+		const allDeps = [...pkg.dependencies, ...pkg.devDependencies];
+
+		allDeps.forEach(depName => {
+			// Only add dependency if it's also a workspace package
+			if (packageNames.has(depName)) {
+				graph.addDependency(pkg.name, depName);
+			}
+		});
+	});
+
+	return graph;
+}
+
+/**
+ * Filter packages by script availability
+ */
+export function filterPackagesByScript(packages: PackageInfo[], scriptName: string): PackageInfo[] {
+	return packages.filter(pkg => pkg.scripts[scriptName]);
+}
+
+/**
+ * Build command arguments for running a script with the specified package manager
+ */
+export function buildScriptCommand(
+	scriptName: string,
+	packageManager: PackageManager
+): { command: string; args: string[] } {
+	return packageManager.getRunCommand(scriptName);
+}
+
+/**
+ * Validate that packages have the required script
+ */
+export function validatePackagesHaveScript(
+	packages: PackageInfo[],
+	scriptName: string
+): {
+	valid: PackageInfo[];
+	invalid: PackageInfo[];
+} {
+	const valid: PackageInfo[] = [];
+	const invalid: PackageInfo[] = [];
+
+	packages.forEach(pkg => {
+		if (pkg.scripts && typeof pkg.scripts === 'object' && pkg.scripts[scriptName]) {
+			valid.push(pkg);
+		} else {
+			invalid.push(pkg);
+		}
+	});
+
+	return { valid, invalid };
+}
+
+/**
+ * Prepare command execution data for process runner
+ */
+export function prepareCommandExecution(
+	packages: PackageInfo[],
+	scriptName: string,
+	packageManager: PackageManager
+) {
+	const { command, args } = buildScriptCommand(scriptName, packageManager);
+
+	return packages.map(pkg => {
+		if (!isValidPackagePath(pkg.path)) {
+			throw new Error(`Invalid package path: ${pkg.path}`);
+		}
+
+		return {
+			command,
+			args,
+			options: {
+				cwd: pkg.path,
+				env: {
+					// Ensure consistent environment
+					FORCE_COLOR: '1',
+					NODE_ENV: process.env.NODE_ENV || 'development',
+				},
+			},
+			logOptions: {
+				prefix: pkg.name,
+				color: getPackageColor(pkg.name),
+			},
+			packageInfo: pkg,
+		};
+	});
+}
+
+/**
+ * Simple color assignment for packages
+ */
+const colorPalette = [
+	'red',
+	'green',
+	'yellow',
+	'blue',
+	'magenta',
+	'cyan',
+	'gray',
+	'redBright',
+	'greenBright',
+	'yellowBright',
+	'blueBright',
+	'magentaBright',
+	'cyanBright',
+];
+
+const packageColors = new Map<string, string>();
+let colorIndex = 0;
+
+function getPackageColor(packageName: string): string {
+	if (!packageColors.has(packageName)) {
+		const color = colorPalette[colorIndex % colorPalette.length];
+		if (color) {
+			packageColors.set(packageName, color);
+		}
+		colorIndex++;
+	}
+	return packageColors.get(packageName) || 'white';
+}
+
+/**
+ * Format package names for display
+ */
+export function formatPackageName(packageName: string, maxLength = 20): string {
+	if (packageName.length <= maxLength) {
+		return packageName.padEnd(maxLength);
+	}
+
+	// Truncate and add ellipsis
+	return packageName.substring(0, maxLength - 3) + '...';
+}
+
+/**
+ * Group packages by their scope (for @scope/package naming)
+ */
+export function groupPackagesByScope(packages: PackageInfo[]): Map<string, PackageInfo[]> {
+	const groups = new Map<string, PackageInfo[]>();
+
+	packages.forEach(pkg => {
+		const scope = pkg.name.startsWith('@') ? pkg.name.split('/')[0] || 'unscoped' : 'unscoped';
+
+		if (!groups.has(scope)) {
+			groups.set(scope, []);
+		}
+		const group = groups.get(scope);
+		if (group) {
+			group.push(pkg);
+		}
+	});
+
+	return groups;
+}
+
+/**
+ * Calculate execution statistics
+ */
+export interface ExecutionStats {
+	totalPackages: number;
+	successfulPackages: number;
+	failedPackages: number;
+	totalDuration: number;
+	averageDuration: number;
+	longestDuration: number;
+	shortestDuration: number;
+}
+
+export function calculateExecutionStats(results: ProcessResult[]): ExecutionStats {
+	const successful = results.filter(r => r.success);
+	const failed = results.filter(r => !r.success);
+	const durations = results.map(r => r.duration);
+	const totalDuration = durations.reduce((sum, d) => sum + d, 0);
+	const avgDuration = durations.length > 0 ? Math.round(totalDuration / durations.length) : 0;
+	const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+	const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
+
+	return {
+		totalPackages: results.length,
+		successfulPackages: successful.length,
+		failedPackages: failed.length,
+		totalDuration,
+		averageDuration: avgDuration,
+		longestDuration: maxDuration,
+		shortestDuration: minDuration,
+	};
+}
+
+/**
+ * Check if a package path exists and is valid
+ */
+export function isValidPackagePath(packagePath: string): boolean {
+	const fs = require('fs');
+	const path = require('path');
+
+	try {
+		const packageJsonPath = path.join(packagePath, 'package.json');
+		if (!fs.existsSync(packageJsonPath)) {
+			return false;
+		}
+
+		// Try to parse the package.json to ensure it's valid
+		const content = fs.readFileSync(packageJsonPath, 'utf8');
+		const pkg = JSON.parse(content);
+		return typeof pkg === 'object' && pkg !== null && typeof pkg.name === 'string';
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Extract package name from path (for display purposes)
+ */
+export function extractPackageNameFromPath(packagePath: string): string {
+	const parts = packagePath.split('/');
+	return parts[parts.length - 1] || '';
+}

package/tests/bun-workspace/apps/web-app/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@test/web-app",
+	"version": "1.0.0",
+	"description": "Web application",
+	"main": "src/index.js",
+	"scripts": {
+		"build": "echo 'Building web-app with Bun...' && sleep 4 && echo 'web-app build complete!'",
+		"dev": "echo 'Starting web-app dev server with Bun...' && while true; do echo '[web-app] Dev server running on port 3000...'; sleep 3; done",
+		"test": "echo 'Running web-app tests with Bun...' && sleep 2 && echo 'web-app tests passed!'",
+		"lint": "echo 'Linting web-app with Bun...' && sleep 1 && echo 'web-app linting complete!'",
+		"start": "echo 'Starting web-app production server with Bun...' && echo 'web-app running on port 3000'"
+	},
+	"dependencies": {
+		"@test/shared-utils": "workspace:*",
+		"@test/ui-components": "workspace:*"
+	},
+	"devDependencies": {}
+}