fix: bun text lockfile support and add XDG config support (#1)

* feat: support XDG standard for config

* update readme

* fis: support bun text lockfiles

and some minor refactoring

* add todo to fix yarn global support

Author: AVGVSTVS96

README.md

@@ -42,31 +42,43 @@ xpx prettier      # Download and run from the registry
 
 ## Configuration
 
-Set the default package manager for new projects:
+xpm defaults to npm for global installs. Configure this with a config file at `~/.config/xpm/config.json` or `~/.xpmrc`.
+
+### Default Package Manager
+
+Set the default package manager for new projects (when no lockfile or package.json `packageManager` field is found):
 
 ```bash
 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:
+Environment variable (takes precedence):
 ```bash
 export XPM_DEFAULT_PM=<npm|yarn|pnpm|bun>
 ```
 
-Set the package manager for -g commands:
+### Global Package Manager
+
+Set which package manager to use for global installs (`-g` flag):
 
 ```bash
 xpm set-config global-package-manager <npm|yarn|pnpm|bun>
 ```
 
-You can also set it via environment variable:
+Environment variable (takes precedence):
 ```bash
 export XPM_GLOBAL_PM=<npm|yarn|pnpm|bun>
 ```
 
+Default: `npm`
+
+### Configuration Priority
+
+1. Environment variables (`XPM_DEFAULT_PM`, `XPM_GLOBAL_PM`)
+2. Config file (`~/.config/xpm/config.json` or `~/.xpmrc`)
+3. Default fallback (`npm`)
+
 
 ## License
 
-MIT
+MIT

src/config.ts

@@ -1,41 +1,68 @@
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { join, dirname } from 'path';
-import { PackageManager } from './package-manager-config';
+import { PackageManager, SUPPORTED_PACKAGE_MANAGERS } from './package-manager-config';
 
-const CONFIG_PATH = join(homedir(), '.xpmrc');
+function isValidPackageManager(pm: string): pm is PackageManager {
+  return SUPPORTED_PACKAGE_MANAGERS.includes(pm as any);
+}
+
+const CONFIG_PATHS = [
+  () => join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'xpm', 'config.json'),
+  () => join(homedir(), '.xpmrc')
+];
+
+function getConfigPath(): string {
+  for (const pathFn of CONFIG_PATHS) {
+    const path = pathFn();
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  // Default to XDG config for new config files
+  return CONFIG_PATHS[0]();
+}
+
+interface Config {
+  defaultPackageManager?: PackageManager;
+  globalPackageManager?: PackageManager;
+}
 
-function getConfig(): any {
-  if (existsSync(CONFIG_PATH)) {
+function getConfig(): Config {
+  const configPath = getConfigPath();
+  if (existsSync(configPath)) {
     try {
-      return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-    } catch {}
+      return JSON.parse(readFileSync(configPath, 'utf-8'));
+    } catch {
+      console.warn(`Failed to parse config at ${configPath}`);
+    }
   }
   return {};
 }
 
-function saveConfig(config: any): void {
-  const dir = dirname(CONFIG_PATH);
+function saveConfig(config: Config): void {
+  const configPath = getConfigPath();
+  const dir = dirname(configPath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
 
-function getPackageManager(envVar: string, configKey: string): PackageManager {
-  // 1. Check environment variable
+function getPackageManager(envVar: string, configKey: keyof Config): PackageManager {
+  // 1. Environment variable (highest priority)
   const envPM = process.env[envVar];
   if (envPM && isValidPackageManager(envPM)) {
     return envPM as PackageManager;
   }
 
-  // 2. Check config file
+  // 2. Config file
   const config = getConfig();
   if (config[configKey] && isValidPackageManager(config[configKey])) {
     return config[configKey];
   }
 
-  // 3. Fall back to npm
+  // 3. Default fallback
   return 'npm';
 }
 
@@ -47,13 +74,13 @@ export function getGlobalPackageManager(): PackageManager {
   return getPackageManager('XPM_GLOBAL_PM', 'globalPackageManager');
 }
 
-function setPackageManager(pm: string, configKey: string, displayName: string): void {
+function setPackageManager(pm: string, configKey: keyof Config, displayName: string): void {
   if (!isValidPackageManager(pm)) {
-    throw new Error(`Invalid package manager: ${pm}. Must be one of: npm, yarn, pnpm, bun`);
+    throw new Error(`Invalid package manager: ${pm}. Must be one of: ${SUPPORTED_PACKAGE_MANAGERS.join(', ')}`);
   }
 
   const config = getConfig();
-  config[configKey] = pm;
+  config[configKey] = pm as PackageManager;
   saveConfig(config);
   console.log(`${displayName} set to: ${pm}`);
 }
@@ -66,6 +93,3 @@ export function setGlobalPackageManager(pm: string): void {
   setPackageManager(pm, 'globalPackageManager', 'Global package manager');
 }
 
-function isValidPackageManager(pm: string): boolean {
-  return ['npm', 'yarn', 'pnpm', 'bun'].includes(pm);
-}

src/dependency-synchronizer.ts

@@ -1,7 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { spawnSync } from 'child_process';
-import { PackageManager, getConfig } from './package-manager-config';
+import { PackageManager, getPMConfig } from './package-manager-config';
+import { findExistingLockfile } from './detector';
 import { readCache, writeCache, hashFile } from './lockfile-hash-cache';
 
 export interface SyncOptions {
@@ -15,15 +16,16 @@ export interface SyncOptions {
 
 function needsInstall(packageManager: PackageManager, projectRoot: string, workspaceRoot?: string): boolean {
   const checkRoot = workspaceRoot || projectRoot;
-  const lockfilePath = path.join(checkRoot, getConfig(packageManager).lockfile);
-  
-  if (!fs.existsSync(lockfilePath)) return false;
-  
+  const lockfilePath = findExistingLockfile(packageManager, checkRoot);
+  const hasNodeModules = fs.existsSync(path.join(checkRoot, 'node_modules'));
+
+  if (!lockfilePath) return !hasNodeModules;
+
   const currentHash = hashFile(lockfilePath);
   const cache = readCache(checkRoot);
-  
-  return cache.lockfileHash !== currentHash || 
-         !fs.existsSync(path.join(checkRoot, 'node_modules'));
+  const hasLockfileChanged = cache.lockfileHash !== currentHash;
+
+  return hasLockfileChanged || !hasNodeModules;
 }
 
 export function synchronizeDependencies(options: SyncOptions): void {
@@ -32,7 +34,7 @@ export function synchronizeDependencies(options: SyncOptions): void {
 
   if (!force && !needsInstall(packageManager, projectRoot, workspaceRoot) && !ciMode) return;
 
-  const config = getConfig(packageManager);
+  const config = getPMConfig(packageManager);
   const command = `${packageManager} ${ciMode ? config.ciCommand : config.installCommand}`;
 
   if (dryRun) {
@@ -56,7 +58,8 @@ export function synchronizeDependencies(options: SyncOptions): void {
       throw new Error(`Command failed with exit code ${result.status}`);
     }
 
-    const lockfilePath = path.join(executionRoot, getConfig(packageManager).lockfile);
+    const lockfilePath = findExistingLockfile(packageManager, executionRoot);
+    if (!lockfilePath) return;
     writeCache(executionRoot, {
       lockfileHash: hashFile(lockfilePath) || undefined,
       lastSync: new Date().toISOString()
@@ -69,4 +72,4 @@ export function synchronizeDependencies(options: SyncOptions): void {
 
 export function checkDependencies(packageManager: PackageManager, projectRoot: string, workspaceRoot?: string): boolean {
   return needsInstall(packageManager, projectRoot, workspaceRoot);
-}
+}

src/detector.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { PackageManager, PACKAGE_MANAGERS, SUPPORTED_PACKAGE_MANAGERS } from './package-manager-config';
+import { PackageManager, SUPPORTED_PACKAGE_MANAGERS, getPMConfig } from './package-manager-config';
 import { getDefaultPackageManager } from './config';
 import { INSTALL_COMMANDS, WORKSPACE_ROOT_COMMANDS } from './command-constants';
 
@@ -31,9 +31,8 @@ export function detectPackageManager(startDir = process.cwd()): DetectionResult
   dir = packageJsonDir;
 
   while (dir !== path.dirname(dir)) {
-    const hasLockfile = ['bun', 'pnpm', 'yarn', 'npm'].some(mgr => 
-      fs.existsSync(path.join(dir, PACKAGE_MANAGERS[mgr as PackageManager].lockfile))
-    );
+    const hasLockfile = SUPPORTED_PACKAGE_MANAGERS
+      .some(mgr => !!findExistingLockfile(mgr, dir));
 
     if (hasLockfile) {
       lockfileDir = dir;
@@ -63,8 +62,8 @@ export function detectPackageManager(startDir = process.cwd()): DetectionResult
 
   // Check for lockfiles if no corepack config
   if (!detectedPM) {
-    for (const manager of ['bun', 'pnpm', 'yarn', 'npm'] as PackageManager[]) {
-      if (fs.existsSync(path.join(detectionRoot, PACKAGE_MANAGERS[manager].lockfile))) {
+    for (const manager of SUPPORTED_PACKAGE_MANAGERS) {
+      if (findExistingLockfile(manager, detectionRoot)) {
         detectedPM = manager;
         break;
       }
@@ -84,6 +83,16 @@ export function detectPackageManager(startDir = process.cwd()): DetectionResult
   };
 }
 
+export function findExistingLockfile(pm: PackageManager, dir: string): string | undefined {
+  const lf = getPMConfig(pm).lockfile;
+  const candidates = Array.isArray(lf) ? lf : [lf];
+  for (const name of candidates) {
+    const p = path.join(dir, name);
+    if (fs.existsSync(p)) return p;
+  }
+  return undefined;
+}
+
 export function shouldRunAtWorkspaceRoot(command: string, args: string[]): boolean {
   // Install commands with packages should run in current dir, without should run at root
   if (INSTALL_COMMANDS.includes(command as any)) {
@@ -102,4 +111,4 @@ export function isWorkspaceRoot(dir: string): boolean {
   } catch {
     return false;
   }
-}
+}

src/index.ts

@@ -1,8 +1,8 @@
 export { XPM } from './xpm';
 export { detectPackageManager } from './detector';
 export { synchronizeDependencies, checkDependencies } from './dependency-synchronizer';
-export { PACKAGE_MANAGERS, getConfig } from './package-manager-config';
+export { PACKAGE_MANAGERS, getPMConfig } from './package-manager-config';
 export { readCache, writeCache, hashFile } from './lockfile-hash-cache';
 export type { PackageManager } from './package-manager-config';
 export type { CacheData } from './lockfile-hash-cache';
-export type { SyncOptions } from './dependency-synchronizer';
+export type { SyncOptions } from './dependency-synchronizer';

src/package-json.ts

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 
 const loadPackageJson = (dir = process.cwd()): any => {
@@ -8,4 +8,4 @@ const loadPackageJson = (dir = process.cwd()): any => {
 };
 
 export const hasScript = (name: string, root?: string): boolean => 
-  loadPackageJson(root)?.scripts?.[name] !== undefined;
+  loadPackageJson(root)?.scripts?.[name] !== undefined;

src/package-manager-config.ts

@@ -1,14 +1,17 @@
 export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
 
-// Only store what we actually use
-type PMConfig = { lockfile: string; installCommand: string; ciCommand: string };
+type PMConfig = {
+  lockfile: string | string[];
+  installCommand: string;
+  ciCommand: string;
+};
 
 export const PACKAGE_MANAGERS: Record<PackageManager, PMConfig> = {
   npm: { lockfile: 'package-lock.json', installCommand: 'install', ciCommand: 'ci' },
   yarn: { lockfile: 'yarn.lock', installCommand: 'install', ciCommand: 'install --frozen-lockfile' },
   pnpm: { lockfile: 'pnpm-lock.yaml', installCommand: 'install', ciCommand: 'install --frozen-lockfile' },
-  bun: { lockfile: 'bun.lockb', installCommand: 'install', ciCommand: 'install --frozen-lockfile' }
+  bun: { lockfile: ['bun.lock', 'bun.lockb'], installCommand: 'install', ciCommand: 'install --frozen-lockfile' }
 };
 
 export const SUPPORTED_PACKAGE_MANAGERS = Object.keys(PACKAGE_MANAGERS) as PackageManager[];
-export const getConfig = (pm: PackageManager) => PACKAGE_MANAGERS[pm];
+export const getPMConfig = (pm: PackageManager) => PACKAGE_MANAGERS[pm];

src/xpm.ts

@@ -100,6 +100,10 @@ Detects: npm/yarn/pnpm/bun`);
     const hasGlobalFlag = this.args.includes('-g') || this.args.includes('--global');
 
     if (hasGlobalFlag && command && GLOBAL_SUPPORT_COMMANDS.includes(command as any)) {
+      // TODO(yarn-global): Yarn differs for global installs.
+      // - Yarn v1 uses: `yarn global <subcmd> ...` (no -g flag)
+      // - Yarn v2+ removed persistent global installs; prefer error + guidance or fallback
+      // Consider: detect Yarn major via `yarn -v` and special-case here.
       // Handle global installs/uninstalls
       const globalPackageManager = getGlobalPackageManager();
       const filteredArgs = this.args.filter(arg => arg !== '-g' && arg !== '--global');
@@ -159,4 +163,4 @@ Detects: npm/yarn/pnpm/bun`);
       process.exit(1);
     }
   }
-}
+}