workspace-utils 1.0.0

package/src/package-managers/bun.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { BunPackageManager } from './bun.ts';
+
+describe('BunPackageManager', () => {
+	const testDir = join(process.cwd(), 'test-temp-bun');
+	let bunManager: BunPackageManager;
+
+	beforeEach(() => {
+		// Clean up test directory if it exists
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+		mkdirSync(testDir, { recursive: true });
+		bunManager = new BunPackageManager();
+	});
+
+	afterEach(() => {
+		// Clean up test directory
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	describe('name', () => {
+		it('should return "bun"', () => {
+			expect(bunManager.name).toBe('bun');
+		});
+	});
+
+	describe('isActive', () => {
+		it('should return true when bun.lockb exists', () => {
+			writeFileSync(join(testDir, 'bun.lockb'), '');
+
+			expect(bunManager.isActive(testDir)).toBe(true);
+		});
+
+		it('should return true when bunfig.toml exists', () => {
+			writeFileSync(
+				join(testDir, 'bunfig.toml'),
+				'[install]\nregistry = "https://registry.npmjs.org/"'
+			);
+
+			expect(bunManager.isActive(testDir)).toBe(true);
+		});
+
+		it('should return true when package.json has bun field', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					bun: {
+						install: {
+							dev: true,
+						},
+					},
+				})
+			);
+
+			expect(bunManager.isActive(testDir)).toBe(true);
+		});
+
+		it('should return true when package.json has trustedDependencies field', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					trustedDependencies: ['some-package'],
+				})
+			);
+
+			expect(bunManager.isActive(testDir)).toBe(true);
+		});
+
+		it('should return false when no bun indicators exist', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					dependencies: {},
+				})
+			);
+
+			expect(bunManager.isActive(testDir)).toBe(false);
+		});
+
+		it('should return false when package.json is invalid', () => {
+			writeFileSync(join(testDir, 'package.json'), 'invalid json');
+
+			expect(bunManager.isActive(testDir)).toBe(false);
+		});
+
+		it('should return false when no files exist', () => {
+			expect(bunManager.isActive(testDir)).toBe(false);
+		});
+	});
+
+	describe('getRunCommand', () => {
+		it('should return correct bun run command', () => {
+			const result = bunManager.getRunCommand('test');
+
+			expect(result).toEqual({
+				command: 'bun',
+				args: ['run', 'test'],
+			});
+		});
+
+		it('should work with different script names', () => {
+			expect(bunManager.getRunCommand('build')).toEqual({
+				command: 'bun',
+				args: ['run', 'build'],
+			});
+
+			expect(bunManager.getRunCommand('dev')).toEqual({
+				command: 'bun',
+				args: ['run', 'dev'],
+			});
+		});
+	});
+
+	describe('parseWorkspaceConfig', () => {
+		it('should parse workspaces array from package.json', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test-workspace',
+					workspaces: ['packages/*', 'apps/*'],
+				})
+			);
+
+			const result = bunManager.parseWorkspaceConfig(testDir);
+
+			expect(result.packages).toEqual(['packages/*', 'apps/*']);
+		});
+
+		it('should parse workspaces object from package.json', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test-workspace',
+					workspaces: {
+						packages: ['packages/*', 'tools/*'],
+					},
+				})
+			);
+
+			const result = bunManager.parseWorkspaceConfig(testDir);
+
+			expect(result.packages).toEqual(['packages/*', 'tools/*']);
+		});
+
+		it('should throw error when package.json does not exist', () => {
+			expect(() => bunManager.parseWorkspaceConfig(testDir)).toThrow(
+				'No package.json found in workspace root'
+			);
+		});
+
+		it('should throw error when no workspaces field exists', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test-workspace',
+					dependencies: {},
+				})
+			);
+
+			expect(() => bunManager.parseWorkspaceConfig(testDir)).toThrow(
+				'No workspaces configuration found in package.json'
+			);
+		});
+
+		it('should throw error when workspaces is not an array or valid object', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test-workspace',
+					workspaces: 'invalid',
+				})
+			);
+
+			expect(() => bunManager.parseWorkspaceConfig(testDir)).toThrow(
+				'Invalid workspaces configuration: must be an array or object with packages array'
+			);
+		});
+
+		it('should throw error when workspaces object lacks packages field', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test-workspace',
+					workspaces: {
+						notPackages: ['packages/*'],
+					},
+				})
+			);
+
+			expect(() => bunManager.parseWorkspaceConfig(testDir)).toThrow(
+				'Invalid workspaces configuration: must be an array or object with packages array'
+			);
+		});
+	});
+
+	describe('getLockFileName', () => {
+		it('should return "bun.lockb"', () => {
+			expect(bunManager.getLockFileName()).toBe('bun.lockb');
+		});
+	});
+});

package/src/package-managers/bun.ts

@@ -0,0 +1,79 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import type { PackageManager, WorkspaceConfig } from './types.ts';
+
+export class BunPackageManager implements PackageManager {
+	readonly name = 'bun';
+
+	isActive(workspaceRoot: string): boolean {
+		// Check for bun.lockb file
+		const lockFile = join(workspaceRoot, 'bun.lockb');
+		if (existsSync(lockFile)) {
+			return true;
+		}
+
+		// Check for bunfig.toml
+		const bunConfig = join(workspaceRoot, 'bunfig.toml');
+		if (existsSync(bunConfig)) {
+			return true;
+		}
+
+		// Check if package.json has bun-specific fields
+		const packageJsonPath = join(workspaceRoot, 'package.json');
+		if (existsSync(packageJsonPath)) {
+			try {
+				const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as Record<
+					string,
+					unknown
+				>;
+				// Check for bun-specific fields
+				if (packageJson.bun || packageJson.trustedDependencies) {
+					return true;
+				}
+			} catch {
+				// Ignore JSON parse errors
+			}
+		}
+
+		return false;
+	}
+
+	getRunCommand(scriptName: string): { command: string; args: string[] } {
+		return {
+			command: 'bun',
+			args: ['run', scriptName],
+		};
+	}
+
+	parseWorkspaceConfig(workspaceRoot: string): WorkspaceConfig {
+		const packageJsonPath = join(workspaceRoot, 'package.json');
+
+		if (!existsSync(packageJsonPath)) {
+			throw new Error('No package.json found in workspace root');
+		}
+
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as Record<
+			string,
+			unknown
+		>;
+
+		if (!packageJson.workspaces) {
+			throw new Error('No workspaces configuration found 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 'bun.lockb';
+	}
+}

package/src/package-managers/detector.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { PackageManagerDetector } from './detector.ts';
+import { BunPackageManager } from './bun.ts';
+import { PnpmPackageManager } from './pnpm.ts';
+import { NpmPackageManager } from './npm.ts';
+
+describe('PackageManagerDetector', () => {
+	const testDir = join(process.cwd(), 'test-temp');
+
+	beforeEach(() => {
+		// Clean up test directory if it exists
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		// Clean up test directory
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	describe('detect', () => {
+		it('should detect Bun when bun.lockb exists', () => {
+			// Create bun.lockb file
+			writeFileSync(join(testDir, 'bun.lockb'), '');
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					workspaces: ['packages/*'],
+				})
+			);
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			expect(result.packageManager).toBeInstanceOf(BunPackageManager);
+			expect(result.confidence).toBeGreaterThan(100);
+		});
+
+		it('should detect pnpm when pnpm-lock.yaml exists', () => {
+			// Create pnpm-lock.yaml file
+			writeFileSync(join(testDir, 'pnpm-lock.yaml'), 'lockfileVersion: 6.0');
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					workspaces: ['packages/*'],
+				})
+			);
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			expect(result.packageManager).toBeInstanceOf(PnpmPackageManager);
+			expect(result.confidence).toBeGreaterThan(100);
+		});
+
+		it('should detect npm when package-lock.json exists', () => {
+			// Create package-lock.json file
+			writeFileSync(
+				join(testDir, 'package-lock.json'),
+				JSON.stringify({
+					name: 'test',
+					lockfileVersion: 2,
+				})
+			);
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					workspaces: ['packages/*'],
+				})
+			);
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			expect(result.packageManager).toBeInstanceOf(NpmPackageManager);
+			expect(result.confidence).toBeGreaterThan(100);
+		});
+
+		it('should prefer pnpm when pnpm-workspace.yaml exists', () => {
+			// Create both pnpm and npm indicators
+			writeFileSync(join(testDir, 'pnpm-lock.yaml'), 'lockfileVersion: 6.0');
+			writeFileSync(join(testDir, 'package-lock.json'), '{}');
+			writeFileSync(join(testDir, 'pnpm-workspace.yaml'), 'packages:\n  - packages/*');
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			expect(result.packageManager).toBeInstanceOf(PnpmPackageManager);
+			expect(result.confidence).toBeGreaterThan(150); // Lock file + workspace file
+		});
+
+		it('should detect Bun with bunfig.toml', () => {
+			writeFileSync(
+				join(testDir, 'bunfig.toml'),
+				'[install]\nregistry = "https://registry.npmjs.org/"'
+			);
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					workspaces: ['packages/*'],
+				})
+			);
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			expect(result.packageManager).toBeInstanceOf(BunPackageManager);
+			expect(result.confidence).toBeGreaterThan(50);
+		});
+
+		it('should detect Bun with bun-specific package.json fields', () => {
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					workspaces: ['packages/*'],
+					bun: {
+						install: {
+							dev: true,
+						},
+					},
+				})
+			);
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			expect(result.packageManager).toBeInstanceOf(BunPackageManager);
+			expect(result.confidence).toBeGreaterThanOrEqual(20);
+		});
+
+		it('should throw error when no package manager is detected', () => {
+			expect(() => PackageManagerDetector.detect(testDir)).toThrow(
+				'No package manager detected. Please ensure you have a lock file (bun.lockb, pnpm-lock.yaml, or package-lock.json) or workspace configuration in your project.'
+			);
+		});
+
+		it('should handle multiple package managers and choose highest confidence', () => {
+			// Create indicators for multiple package managers
+			writeFileSync(join(testDir, 'package-lock.json'), '{}'); // npm - confidence 100
+			writeFileSync(join(testDir, 'pnpm-lock.yaml'), 'lockfileVersion: 6.0'); // pnpm - confidence 100
+			writeFileSync(join(testDir, 'pnpm-workspace.yaml'), 'packages:\n  - packages/*'); // pnpm +80
+			writeFileSync(
+				join(testDir, 'package.json'),
+				JSON.stringify({
+					name: 'test',
+					workspaces: ['packages/*'],
+				})
+			);
+
+			const result = PackageManagerDetector.detect(testDir);
+
+			// pnpm should win with 200 confidence (100 + 80 + 20)
+			expect(result.packageManager).toBeInstanceOf(PnpmPackageManager);
+			expect(result.confidence).toBe(200);
+		});
+	});
+
+	describe('getPackageManager', () => {
+		it('should return correct package manager by name', () => {
+			expect(PackageManagerDetector.getPackageManager('bun')).toBeInstanceOf(BunPackageManager);
+			expect(PackageManagerDetector.getPackageManager('pnpm')).toBeInstanceOf(PnpmPackageManager);
+			expect(PackageManagerDetector.getPackageManager('npm')).toBeInstanceOf(NpmPackageManager);
+		});
+
+		it('should throw error for unknown package manager', () => {
+			expect(() => PackageManagerDetector.getPackageManager('unknown')).toThrow(
+				'Unknown package manager: unknown'
+			);
+		});
+	});
+
+	describe('getSupportedPackageManagers', () => {
+		it('should return all supported package managers', () => {
+			const managers = PackageManagerDetector.getSupportedPackageManagers();
+
+			expect(managers).toHaveLength(3);
+			expect(managers[0]).toBeInstanceOf(BunPackageManager);
+			expect(managers[1]).toBeInstanceOf(PnpmPackageManager);
+			expect(managers[2]).toBeInstanceOf(NpmPackageManager);
+		});
+	});
+
+	describe('isPackageManagerAvailable', () => {
+		it('should check if bun is available', async () => {
+			const isAvailable = await PackageManagerDetector.isPackageManagerAvailable('bun');
+			expect(typeof isAvailable).toBe('boolean');
+		});
+
+		it('should return false for non-existent package manager', async () => {
+			const isAvailable = await PackageManagerDetector.isPackageManagerAvailable('nonexistent-pm');
+			expect(isAvailable).toBe(false);
+		});
+	});
+});

package/src/package-managers/detector.ts

@@ -0,0 +1,111 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import type { PackageManager, PackageManagerDetectionResult } from './types.ts';
+import { BunPackageManager } from './bun.ts';
+import { PnpmPackageManager } from './pnpm.ts';
+import { NpmPackageManager } from './npm.ts';
+
+export class PackageManagerDetector {
+	private static readonly packageManagers = [
+		new BunPackageManager(),
+		new PnpmPackageManager(),
+		new NpmPackageManager(),
+	];
+
+	/**
+	 * Detect the package manager being used in the workspace
+	 */
+	static detect(workspaceRoot: string): PackageManagerDetectionResult {
+		const results: PackageManagerDetectionResult[] = [];
+
+		for (const pm of this.packageManagers) {
+			if (pm.isActive(workspaceRoot)) {
+				const confidence = this.calculateConfidence(pm, workspaceRoot);
+				results.push({ packageManager: pm, confidence });
+			}
+		}
+
+		// Sort by confidence and return the highest
+		results.sort((a, b) => b.confidence - a.confidence);
+
+		const [result] = results;
+		if (!result) {
+			throw new Error(
+				'No package manager detected. Please ensure you have a lock file (bun.lockb, pnpm-lock.yaml, or package-lock.json) or workspace configuration in your project.'
+			);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Get a specific package manager by name
+	 */
+	static getPackageManager(name: string): PackageManager {
+		const pm = this.packageManagers.find(pm => pm.name === name);
+		if (!pm) {
+			throw new Error(`Unknown package manager: ${name}`);
+		}
+		return pm;
+	}
+
+	/**
+	 * Get all supported package managers
+	 */
+	static getSupportedPackageManagers(): PackageManager[] {
+		return [...this.packageManagers];
+	}
+
+	/**
+	 * Calculate confidence score for a package manager
+	 */
+	private static calculateConfidence(pm: PackageManager, workspaceRoot: string): number {
+		let confidence = 0;
+
+		// Check for lock file (highest confidence)
+		const lockFile = join(workspaceRoot, pm.getLockFileName());
+		if (existsSync(lockFile)) {
+			confidence += 100;
+		}
+
+		// Check for package manager specific files
+		switch (pm.name) {
+			case 'bun':
+				if (existsSync(join(workspaceRoot, 'bunfig.toml'))) confidence += 50;
+				break;
+			case 'pnpm':
+				if (existsSync(join(workspaceRoot, 'pnpm-workspace.yaml'))) confidence += 80;
+				if (existsSync(join(workspaceRoot, '.pnpmfile.cjs'))) confidence += 30;
+				break;
+			case 'npm':
+				if (existsSync(join(workspaceRoot, '.npmrc'))) confidence += 30;
+				break;
+		}
+
+		// Check for workspace configuration
+		try {
+			pm.parseWorkspaceConfig(workspaceRoot);
+			confidence += 20;
+		} catch {
+			// Workspace config not found or invalid
+		}
+
+		return confidence;
+	}
+
+	/**
+	 * Check if a specific package manager is available in the system
+	 */
+	static async isPackageManagerAvailable(name: string): Promise<boolean> {
+		try {
+			const { spawn } = await import('child_process');
+			return new Promise(resolve => {
+				const child = spawn(name, ['--version'], { stdio: 'ignore' });
+				child.on('close', code => resolve(code === 0));
+				child.on('error', () => resolve(false));
+			});
+		} catch {
+			return false;
+		}
+	}
+}

package/src/package-managers/index.ts

@@ -0,0 +1,10 @@
+export { BunPackageManager } from './bun.ts';
+export { PnpmPackageManager } from './pnpm.ts';
+export { NpmPackageManager } from './npm.ts';
+export { PackageManagerDetector } from './detector.ts';
+export type {
+	PackageManager,
+	PackageManagerConfig,
+	WorkspaceConfig,
+	PackageManagerDetectionResult,
+} from './types.ts';

package/src/package-managers/npm.ts

@@ -0,0 +1,79 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import type { PackageManager, WorkspaceConfig } from './types.ts';
+
+export class NpmPackageManager implements PackageManager {
+	readonly name = 'npm';
+
+	isActive(workspaceRoot: string): boolean {
+		// Check for package-lock.json file
+		const lockFile = join(workspaceRoot, 'package-lock.json');
+		if (existsSync(lockFile)) {
+			return true;
+		}
+
+		// Check for .npmrc file
+		const npmrcFile = join(workspaceRoot, '.npmrc');
+		if (existsSync(npmrcFile)) {
+			return true;
+		}
+
+		// Check if package.json has npm-specific fields or workspaces
+		const packageJsonPath = join(workspaceRoot, 'package.json');
+		if (existsSync(packageJsonPath)) {
+			try {
+				const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as Record<
+					string,
+					unknown
+				>;
+				// Check for npm-specific fields or workspaces
+				if (packageJson.workspaces || packageJson.publishConfig) {
+					return true;
+				}
+			} catch {
+				// Ignore JSON parse errors
+			}
+		}
+
+		return false;
+	}
+
+	getRunCommand(scriptName: string): { command: string; args: string[] } {
+		return {
+			command: 'npm',
+			args: ['run', scriptName],
+		};
+	}
+
+	parseWorkspaceConfig(workspaceRoot: string): WorkspaceConfig {
+		const packageJsonPath = join(workspaceRoot, 'package.json');
+
+		if (!existsSync(packageJsonPath)) {
+			throw new Error('No package.json found in workspace root');
+		}
+
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as Record<
+			string,
+			unknown
+		>;
+
+		if (!packageJson.workspaces) {
+			throw new Error('No workspaces configuration found 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 'package-lock.json';
+	}
+}