workspace-utils 1.0.0 → 1.0.2

package/src/package-managers/pnpm.ts

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

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

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

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

@@ -1,18 +0,0 @@
-{
-	"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": {}
-}