add global command handling

Author: Yonom

README.md

@@ -35,6 +35,8 @@ xpm               # Install dependencies
 xpm add react     # Add a package
 xpm dev           # Run a script
 
+xpm add -g turbo  # Installs global dependency
+
 xpx prettier      # Download and run from the registry
 ```
 
@@ -43,16 +45,28 @@ xpx prettier      # Download and run from the registry
 Set the default package manager for new projects:
 
 ```bash
-xpm set-config default-package-manager pnpm
+xpm set-config default-package-manager <npm|yarn|pnpm|bun>
 ```
 
 The default is used when no lockfile or package.json `packageManager` field is found.
 
 You can also set it via environment variable:
 ```bash
-export XPM_DEFAULT_PM=bun
+export XPM_DEFAULT_PM=<npm|yarn|pnpm|bun>
+```
+
+Set the package manager for -g commands:
+
+```bash
+xpm set-config global-package-manager <npm|yarn|pnpm|bun>
+```
+
+You can also set it via environment variable:
+```bash
+export XPM_GLOBAL_PM=<npm|yarn|pnpm|bun>
 ```
 
+
 ## License
 
 MIT

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/xpm",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Universal package manager wrapper that automatically detects and uses the right package manager",
   "main": "dist/index.js",
   "bin": {

src/command-constants.ts

@@ -0,0 +1,83 @@
+// All install command aliases (from npm documentation)
+export const INSTALL_COMMANDS = [
+  'install',
+  'add',
+  'i',
+  'in',
+  'ins',
+  'inst',
+  'insta',
+  'instal',
+  'isnt',
+  'isnta',
+  'isntal',
+  'isntall'
+] as const;
+
+// All uninstall/remove command aliases (from npm documentation)
+export const UNINSTALL_COMMANDS = [
+  'uninstall',
+  'unlink',
+  'remove',
+  'rm',
+  'r',
+  'un'
+] as const;
+
+// All update command aliases (from npm documentation)
+export const UPDATE_COMMANDS = [
+  'update',
+  'up',
+  'upgrade',
+  'udpate'
+] as const;
+
+// Combined list for commands that should skip auto-sync
+export const SKIP_SYNC_COMMANDS = [
+  ...INSTALL_COMMANDS,
+  ...UNINSTALL_COMMANDS,
+  ...UPDATE_COMMANDS
+] as const;
+
+// Commands that support global flag (from npm documentation)
+export const GLOBAL_SUPPORT_COMMANDS = [
+  ...INSTALL_COMMANDS,
+  ...UNINSTALL_COMMANDS,
+  ...UPDATE_COMMANDS,
+  'list',
+  'ls',
+  'll',
+  'outdated',
+  'bin',
+  'root',
+  'rebuild'
+] as const;
+
+// Commands that should run at workspace root when no args provided
+export const WORKSPACE_ROOT_COMMANDS = new Set([
+  ...INSTALL_COMMANDS,  // All install aliases
+  ...UPDATE_COMMANDS,    // All update aliases
+  'audit',
+  'outdated'
+]);
+
+// Known npm commands that shouldn't be treated as scripts
+export const NPM_BUILTIN_COMMANDS = new Set([
+  'access', 'adduser', 'audit', 'bin', 'bugs', 'cache', 'ci', 'completion',
+  'config', 'dedupe', 'deprecate', 'diff', 'dist-tag', 'docs', 'doctor',
+  'edit', 'exec', 'explain', 'explore', 'fund', 'help', 'hook', 'init',
+  'install-ci-test', 'install-test', 'link', 'll', 'login',
+  'logout', 'ls', 'org', 'outdated', 'owner', 'pack', 'ping', 'pkg',
+  'prefix', 'profile', 'prune', 'publish', 'query', 'rebuild', 'repo',
+  'restart', 'root', 'run', 'run-script', 'search', 'set', 'shrinkwrap',
+  'star', 'stars', 'start', 'stop', 'team', 'test', 'token',
+  'unpublish', 'unstar', 'version', 'view', 'whoami',
+  // Add all our command aliases
+  ...INSTALL_COMMANDS,
+  ...UNINSTALL_COMMANDS,
+  ...UPDATE_COMMANDS
+]);
+
+export type InstallCommand = typeof INSTALL_COMMANDS[number];
+export type UninstallCommand = typeof UNINSTALL_COMMANDS[number];
+export type GlobalSupportCommand = typeof GLOBAL_SUPPORT_COMMANDS[number];

src/command-mapper.ts

@@ -1,45 +1,49 @@
 import { PackageManager } from './package-manager-config';
 import { hasScript } from './package-json';
+import { INSTALL_COMMANDS, UNINSTALL_COMMANDS, UPDATE_COMMANDS, NPM_BUILTIN_COMMANDS } from './command-constants';
+
+// Helper to create mappings for all aliases
+function createMappings(aliases: readonly string[], mappings: Partial<Record<PackageManager, [string, ...string[]]>>) {
+  const result: Record<string, Partial<Record<PackageManager, [string, ...string[]]>>> = {};
+  for (const alias of aliases) {
+    result[alias] = mappings;
+  }
+  return result;
+}
+
+// Command mappings - what differs between package managers
+const installMappings = createMappings(
+  INSTALL_COMMANDS,
+  { yarn: ['add'], pnpm: ['add'], bun: ['add'] }
+);
+
+const uninstallMappings = createMappings(
+  UNINSTALL_COMMANDS,
+  { yarn: ['remove'], pnpm: ['remove'], bun: ['remove'] }
+);
+
+const updateMappings = createMappings(
+  UPDATE_COMMANDS,
+  { yarn: ['update'], bun: ['update'] }
+);
 
-// Simplified command mappings - only what differs between package managers
 const commandMappings: Record<string, Partial<Record<PackageManager, [string, ...string[]]>>> = {
-  // Install/add commands
-  'install': { yarn: ['add'], pnpm: ['add'], bun: ['add'] },
-  'i': { yarn: ['add'], pnpm: ['add'], bun: ['add'] },
-  
-  // Remove commands
-  'uninstall': { yarn: ['remove'], pnpm: ['remove'], bun: ['remove'] },
-  'rm': { yarn: ['remove'], pnpm: ['remove'], bun: ['remove'] },
-  
-  // Update commands
-  'upgrade': { yarn: ['update'], bun: ['update'] },
-  'up': { yarn: ['update'], bun: ['update'] },
-  
+  ...installMappings,
+  ...uninstallMappings,
+  ...updateMappings,
   // Execute commands  
   'exec': { bun: ["run"] },
 };
 
-// Known npm commands that shouldn't be treated as scripts
-const npmBuiltinCommands = new Set([
-  'access', 'adduser', 'audit', 'bin', 'bugs', 'cache', 'ci', 'completion',
-  'config', 'dedupe', 'deprecate', 'diff', 'dist-tag', 'docs', 'doctor',
-  'edit', 'exec', 'explain', 'explore', 'fund', 'help', 'hook', 'init',
-  'install', 'install-ci-test', 'install-test', 'link', 'll', 'login',
-  'logout', 'ls', 'org', 'outdated', 'owner', 'pack', 'ping', 'pkg',
-  'prefix', 'profile', 'prune', 'publish', 'query', 'rebuild', 'repo',
-  'restart', 'root', 'run', 'run-script', 'search', 'set', 'shrinkwrap',
-  'star', 'stars', 'start', 'stop', 'team', 'test', 'token', 'uninstall',
-  'unpublish', 'unstar', 'update', 'version', 'view', 'whoami', 'i'
-]);
 
 export function mapCommand(command: string, args: string[], packageManager: PackageManager, projectRoot?: string): { command: string; args: string[] } {
   // Special case: install without args always uses 'install'
-  if ((command === 'install' || command === 'i') && args.length === 0) {
+  if (INSTALL_COMMANDS.includes(command as any) && args.length === 0) {
     return { command: 'install', args: [] };
   }
 
   // Only map dev flags for install/add commands
-  const isInstallCommand = ['install', 'i', 'add'].includes(command);
+  const isInstallCommand = INSTALL_COMMANDS.includes(command as any);
   const mappedArgs = isInstallCommand ? args.map(arg => {
     // Map all dev flags to package manager specific format
     if (arg === '-D' || arg === '--save-dev' || arg === '--dev') {
@@ -57,7 +61,7 @@ export function mapCommand(command: string, args: string[], packageManager: Pack
   }
 
   // npm needs 'run' prefix for scripts not in built-in commands
-  if (packageManager === 'npm' && !npmBuiltinCommands.has(command) && hasScript(command, projectRoot)) {
+  if (packageManager === 'npm' && !NPM_BUILTIN_COMMANDS.has(command) && projectRoot && hasScript(command, projectRoot)) {
     return { command: 'run', args: [command, ...args] };
   }
 

src/config.ts

@@ -5,49 +5,65 @@ import { PackageManager } from './package-manager-config';
 
 const CONFIG_PATH = join(homedir(), '.xpmrc');
 
-export function getDefaultPackageManager(): PackageManager {
+function getConfig(): any {
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    } catch {}
+  }
+  return {};
+}
+
+function saveConfig(config: any): void {
+  const dir = dirname(CONFIG_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function getPackageManager(envVar: string, configKey: string): PackageManager {
   // 1. Check environment variable
-  const envPM = process.env.XPM_DEFAULT_PM;
+  const envPM = process.env[envVar];
   if (envPM && isValidPackageManager(envPM)) {
     return envPM as PackageManager;
   }
 
-  // 2. Check config file in home directory
-  if (existsSync(CONFIG_PATH)) {
-    try {
-      const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-      if (config.defaultPackageManager && isValidPackageManager(config.defaultPackageManager)) {
-        return config.defaultPackageManager;
-      }
-    } catch {}
+  // 2. Check config file
+  const config = getConfig();
+  if (config[configKey] && isValidPackageManager(config[configKey])) {
+    return config[configKey];
   }
 
   // 3. Fall back to npm
   return 'npm';
 }
 
-export function setDefaultPackageManager(pm: string): void {
+export function getDefaultPackageManager(): PackageManager {
+  return getPackageManager('XPM_DEFAULT_PM', 'defaultPackageManager');
+}
+
+export function getGlobalPackageManager(): PackageManager {
+  return getPackageManager('XPM_GLOBAL_PM', 'globalPackageManager');
+}
+
+function setPackageManager(pm: string, configKey: string, displayName: string): void {
   if (!isValidPackageManager(pm)) {
     throw new Error(`Invalid package manager: ${pm}. Must be one of: npm, yarn, pnpm, bun`);
   }
 
-  let config: any = {};
-  if (existsSync(CONFIG_PATH)) {
-    try {
-      config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-    } catch {}
-  }
-  
-  config.defaultPackageManager = pm;
-  
-  // Ensure directory exists
-  const dir = dirname(CONFIG_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-  console.log(`Default package manager set to: ${pm}`);
+  const config = getConfig();
+  config[configKey] = pm;
+  saveConfig(config);
+  console.log(`${displayName} set to: ${pm}`);
+}
+
+export function setDefaultPackageManager(pm: string): void {
+  setPackageManager(pm, 'defaultPackageManager', 'Default package manager');
+}
+
+export function setGlobalPackageManager(pm: string): void {
+  setPackageManager(pm, 'globalPackageManager', 'Global package manager');
 }
 
 function isValidPackageManager(pm: string): boolean {

src/dependency-synchronizer.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { execSync } from 'child_process';
+import { spawnSync } from 'child_process';
 import { PackageManager, getConfig } from './package-manager-config';
 import { readCache, writeCache, hashFile } from './lockfile-hash-cache';
 
@@ -45,7 +45,16 @@ export function synchronizeDependencies(options: SyncOptions): void {
   }
 
   try {
-    execSync(command, { stdio: 'inherit', encoding: 'utf8', cwd: executionRoot });
+    const installCmd = ciMode ? config.ciCommand : config.installCommand;
+    const args = installCmd.split(' ');
+    const result = spawnSync(packageManager, args, { stdio: 'inherit', encoding: 'utf8', cwd: executionRoot });
+    
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      throw new Error(`Command failed with exit code ${result.status}`);
+    }
 
     const lockfilePath = path.join(executionRoot, getConfig(packageManager).lockfile);
     writeCache(executionRoot, {

src/detector.ts

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { PackageManager, PACKAGE_MANAGERS, SUPPORTED_PACKAGE_MANAGERS } from './package-manager-config';
 import { getDefaultPackageManager } from './config';
+import { INSTALL_COMMANDS, WORKSPACE_ROOT_COMMANDS } from './command-constants';
 
 export interface DetectionResult {
   packageManager: PackageManager;
@@ -84,14 +85,12 @@ export function detectPackageManager(startDir = process.cwd()): DetectionResult
 }
 
 export function shouldRunAtWorkspaceRoot(command: string, args: string[]): boolean {
-  const workspaceRootCommands = new Set(['install', 'i', 'update', 'upgrade', 'audit', 'outdated']);
-  
-  // Install/i with packages should run in current dir, without should run at root
-  if ((command === 'install' || command === 'i')) {
+  // Install commands with packages should run in current dir, without should run at root
+  if (INSTALL_COMMANDS.includes(command as any)) {
     return args.length === 0;
   }
 
-  return workspaceRootCommands.has(command);
+  return WORKSPACE_ROOT_COMMANDS.has(command);
 }
 
 export function isWorkspaceRoot(dir: string): boolean {