feat: add vite migration command

Author: fengmk2

packages/global/src/index.ts

@@ -1,9 +1,11 @@
-// Parse command line arguments to intercept 'new' and 'gen' commands
+// Parse command line arguments to intercept 'new', 'gen', and 'migration' commands
 const args = process.argv.slice(2);
 
 const command = args[0];
 if (command === 'gen' || command === 'g' || command === 'generate' || command === 'new') {
   import('./gen.ts');
+} else if (command === 'migration' || command === 'migrate') {
+  import('./migrate.ts');
 } else {
   // Delegate all other commands to vite-plus CLI
   import('@voidzero-dev/vite-plus/bin');

packages/global/src/migrate.ts

@@ -0,0 +1,246 @@
+import path from 'node:path';
+
+import * as prompts from '@clack/prompts';
+import mri from 'mri';
+import colors from 'picocolors';
+
+import { detectTools, hasVitePlus } from './migration/detector.ts';
+import { performMigration, previewMigration } from './migration/migrator.ts';
+import type { MigrationOptions } from './migration/types.ts';
+
+const { blue, cyan, green, gray, red, yellow } = colors;
+
+// prettier-ignore
+const helpMessage = `\\\
+Usage: vite migration [PATH] [OPTIONS]
+
+Migrate standalone vite, vitest, tsdown, oxlint, and oxfmt to unified vite-plus.
+
+Arguments:
+  PATH                       Path to the package to migrate (default: current directory)
+
+Options:
+  --dry-run                  Preview changes without applying them
+  --no-interactive           Run in non-interactive mode (skip prompts and use defaults)
+  --all                      Migrate all packages in workspace (monorepo)
+  --tools                    Migrate specific tools only (comma-separated: vite,vitest,tsdown,oxlint,oxfmt)
+  --check                    Check if migration is needed without applying
+  -h, --help                 Show this help message
+
+Examples:
+  ${gray('# Migrate current package')}
+  vite migration
+
+  ${gray('# Migrate specific package')}
+  vite migration packages/my-app
+
+  ${gray('# Preview changes without applying')}
+  vite migration --dry-run
+
+  ${gray('# Migrate specific tools only')}
+  vite migration --tools=vite,vitest
+
+  ${gray('# Check if migration is needed')}
+  vite migration --check
+
+  ${gray('# Non-interactive mode')}
+  vite migration --no-interactive
+
+Aliases: ${gray('migrate')}
+`;
+
+function parseArgs() {
+  const args = process.argv.slice(3); // Skip 'node', 'vite', 'migration'
+
+  const parsed = mri<{
+    'dry-run'?: boolean;
+    all?: boolean;
+    tools?: string;
+    check?: boolean;
+    help?: boolean;
+    interactive?: boolean;
+  }>(args, {
+    alias: { h: 'help' },
+    boolean: ['help', 'dry-run', 'all', 'check', 'interactive'],
+    string: ['tools'],
+    default: { interactive: process.stdin.isTTY },
+  });
+
+  const projectPath = parsed._[0] as string | undefined;
+
+  return {
+    projectPath: projectPath || process.cwd(),
+    options: {
+      path: projectPath || process.cwd(),
+      dryRun: parsed['dry-run'] || false,
+      all: parsed.all || false,
+      tools: parsed.tools?.split(',').map(t => t.trim()),
+      check: parsed.check || false,
+      interactive: parsed.interactive,
+      help: parsed.help || false,
+    } as MigrationOptions,
+  };
+}
+
+async function main() {
+  const { projectPath, options } = parseArgs();
+
+  // Handle help flag
+  if (options.help) {
+    console.log(helpMessage);
+    return;
+  }
+
+  // Start migration
+  prompts.intro(cyan('Vite+ Migration'));
+
+  const spinner = prompts.spinner();
+  spinner.start('Analyzing project...');
+
+  // Check if already using vite-plus
+  if (hasVitePlus(projectPath)) {
+    spinner.stop('Analysis complete');
+    prompts.log.warn('Package already uses vite-plus!');
+    prompts.log.info('Nothing to migrate.');
+    if (options.interactive) {
+      prompts.outro('Done');
+    }
+    return;
+  }
+
+  // Detect tools
+  const detection = await detectTools(projectPath);
+  spinner.stop('Analysis complete');
+
+  // Check if there's anything to migrate
+  if (!detection.hasVite && !detection.hasVitest && !detection.hasOxlint && !detection.hasOxfmt) {
+    prompts.log.warn('No standalone tools detected. Nothing to migrate.');
+    if (options.interactive) {
+      prompts.outro('Done');
+    }
+    return;
+  }
+
+  // Show detected tools
+  prompts.log.info('Detected standalone tools:');
+  if (detection.hasVite) prompts.log.success(`  vite ${detection.dependencies.vite}`);
+  if (detection.hasVitest) prompts.log.success(`  vitest ${detection.dependencies.vitest}`);
+  if (detection.hasOxlint) prompts.log.success(`  oxlint ${detection.dependencies.oxlint}`);
+  if (detection.hasOxfmt) prompts.log.success(`  oxfmt ${detection.dependencies.oxfmt}`);
+
+  // Show configuration files found
+  const configFiles = Object.values(detection.configs).filter(Boolean);
+  if (configFiles.length > 0) {
+    prompts.log.info('\\nConfiguration files found:');
+    for (const config of configFiles) {
+      prompts.log.info(`  • ${config}`);
+    }
+  }
+
+  // If --check mode, exit here
+  if (options.check) {
+    prompts.log.success('\\nMigration is available for this project.');
+    if (options.interactive) {
+      prompts.outro('Run without --check to perform migration');
+    }
+    return;
+  }
+
+  // Preview migration plan
+  const plan = await previewMigration(projectPath);
+
+  prompts.log.info('\\nMigration plan:');
+
+  if (plan.dependencies.toRemove.length > 0) {
+    prompts.log.info('  Dependencies (package.json):');
+    for (const dep of plan.dependencies.toRemove) {
+      console.log(`    ${red('-')} ${dep}`);
+    }
+    for (const dep of plan.dependencies.toAdd) {
+      console.log(`    ${green('+')} ${dep}`);
+    }
+  }
+
+  if (plan.configs.changes.length > 0) {
+    prompts.log.info('\\n  Configuration:');
+    for (const change of plan.configs.changes) {
+      prompts.log.success(`    ✓ ${change}`);
+    }
+  }
+
+  if (plan.filesToDelete.length > 0) {
+    prompts.log.info('\\n  Files to remove:');
+    for (const file of plan.filesToDelete) {
+      console.log(`    ${red('×')} ${file}`);
+    }
+  }
+
+  // Confirm migration
+  if (options.interactive && !options.dryRun) {
+    const shouldProceed = await prompts.confirm({
+      message: 'Proceed with migration?',
+    });
+
+    if (prompts.isCancel(shouldProceed) || !shouldProceed) {
+      prompts.cancel('Migration cancelled');
+      return;
+    }
+  }
+
+  // Perform migration
+  spinner.start(options.dryRun ? 'Previewing migrations...' : 'Applying migrations...');
+
+  const result = await performMigration(projectPath, options);
+
+  if (result.success) {
+    spinner.stop(options.dryRun ? 'Preview completed!' : 'Migration completed!');
+
+    // Show results
+    prompts.log.success(options.dryRun ? '\\nChanges preview:' : '\\nChanges applied:');
+    for (const r of result.results) {
+      if (r.success) {
+        prompts.log.success(`  ✓ ${r.message}`);
+      } else {
+        prompts.log.error(`  × ${r.message}`);
+      }
+    }
+
+    if (!options.dryRun) {
+      // Show next steps
+      const nextSteps = `
+${blue('Next steps:')}
+  1. Review vite.config.ts to ensure configurations are correct
+  2. Run ${cyan('vite install')} to update dependencies
+  3. Run ${cyan('vite build')} and ${cyan('vite test')} to verify everything works
+
+${result.backup ? yellow(`Backup created at: ${result.backup}`) : ''}
+${result.backup ? gray('To rollback: restore files from backup directory') : ''}
+      `.trim();
+
+      console.log('\\n' + nextSteps + '\\n');
+    }
+
+    if (options.interactive) {
+      prompts.outro(green('✨ ' + (options.dryRun ? 'Preview completed!' : 'Migration completed!')));
+    }
+  } else {
+    spinner.stop('Migration failed');
+
+    for (const r of result.results) {
+      if (!r.success) {
+        prompts.log.error(r.message);
+      }
+    }
+
+    if (options.interactive) {
+      prompts.outro(red('Migration failed'));
+    }
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  prompts.log.error(err.message);
+  console.error(err);
+  process.exit(1);
+});

packages/global/src/migration/dependencies.ts

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { DetectionResult, PackageManager } from './types.ts';
+
+export function detectPackageManager(projectPath: string): PackageManager {
+  // Check for lock files to detect package manager
+  if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml'))) {
+    return 'pnpm' as PackageManager;
+  }
+  if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
+    return 'yarn' as PackageManager;
+  }
+  if (fs.existsSync(path.join(projectPath, 'bun.lockb'))) {
+    return 'bun' as PackageManager;
+  }
+  if (fs.existsSync(path.join(projectPath, 'package-lock.json'))) {
+    return 'npm' as PackageManager;
+  }
+
+  // Default to npm if no lock file found
+  return 'npm' as PackageManager;
+}
+
+export function migrateDependencies(
+  projectPath: string,
+  detection: DetectionResult,
+  vitePlusVersion = '^0.1.0',
+): void {
+  const pkgJsonPath = path.join(projectPath, 'package.json');
+  const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+
+  // Remove standalone tool dependencies
+  const depsToRemove = ['vite', 'vitest', 'oxlint', 'oxfmt'];
+
+  for (const dep of depsToRemove) {
+    if (pkgJson.dependencies?.[dep]) {
+      delete pkgJson.dependencies[dep];
+    }
+    if (pkgJson.devDependencies?.[dep]) {
+      delete pkgJson.devDependencies[dep];
+    }
+  }
+
+  // Add vite-plus
+  if (!pkgJson.devDependencies) {
+    pkgJson.devDependencies = {};
+  }
+  pkgJson.devDependencies['vite-plus'] = vitePlusVersion;
+
+  // Add overrides for vite → vite-plus (package manager specific)
+  const packageManager = detectPackageManager(projectPath);
+
+  if (packageManager === 'yarn') {
+    // Yarn uses 'resolutions'
+    if (!pkgJson.resolutions) {
+      pkgJson.resolutions = {};
+    }
+    pkgJson.resolutions.vite = `npm:vite-plus@${vitePlusVersion}`;
+  } else {
+    // npm, pnpm, bun use 'overrides'
+    if (!pkgJson.overrides) {
+      pkgJson.overrides = {};
+    }
+    pkgJson.overrides.vite = `npm:vite-plus@${vitePlusVersion}`;
+  }
+
+  // Write back to package.json (preserve formatting)
+  fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n', 'utf-8');
+}