feat(migrate): migrate .nvmrc to .node-version during vp migrate

packages/cli/src/migration/__tests__/migrator.spec.ts

@@ -1,4 +1,8 @@
-import { describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { PackageManager } from '../../types/index.js';
 
@@ -10,7 +14,12 @@ vi.mock('../../utils/constants.js', async (importOriginal) => {
   return { ...mod, VITE_PLUS_VERSION: 'latest' };
 });
 
-const { rewritePackageJson } = await import('../migrator.js');
+const {
+  rewritePackageJson,
+  parseNvmrcVersion,
+  detectNodeVersionManagerFile,
+  migrateNodeVersionManagerFile,
+} = await import('../migrator.js');
 
 describe('rewritePackageJson', () => {
   it('should rewrite package.json scripts and extract staged config', async () => {
@@ -121,3 +130,105 @@ describe('rewritePackageJson', () => {
     expect(pkg).toMatchSnapshot();
   });
 });
+
+describe('parseNvmrcVersion', () => {
+  it('strips v prefix', () => {
+    expect(parseNvmrcVersion('v20.5.0\n')).toBe('20.5.0');
+    expect(parseNvmrcVersion('v20.5.0')).toBe('20.5.0');
+  });
+
+  it('passes through version without prefix', () => {
+    expect(parseNvmrcVersion('20.5.0\n')).toBe('20.5.0');
+    expect(parseNvmrcVersion('20\n')).toBe('20');
+  });
+
+  it('passes through lts aliases', () => {
+    expect(parseNvmrcVersion('lts/*\n')).toBe('lts/*');
+    expect(parseNvmrcVersion('lts/iron\n')).toBe('lts/iron');
+    expect(parseNvmrcVersion('lts/-1\n')).toBe('lts/-1');
+  });
+
+  it('returns null for unsupported aliases', () => {
+    expect(parseNvmrcVersion('node\n')).toBeNull();
+    expect(parseNvmrcVersion('stable\n')).toBeNull();
+    expect(parseNvmrcVersion('system\n')).toBeNull();
+    expect(parseNvmrcVersion('')).toBeNull();
+  });
+
+  it('returns null for invalid version strings', () => {
+    expect(parseNvmrcVersion('v\n')).toBeNull();
+    expect(parseNvmrcVersion('laetst\n')).toBeNull();
+    expect(parseNvmrcVersion('20.5.0.1\n')).toBeNull();
+  });
+});
+
+describe('detectNodeVersionManagerFile', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vp-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns undefined when no version files found', () => {
+    expect(detectNodeVersionManagerFile(tmpDir)).toBeUndefined();
+  });
+
+  it('returns undefined when .node-version already exists', () => {
+    fs.writeFileSync(path.join(tmpDir, '.node-version'), '20.5.0\n');
+    fs.writeFileSync(path.join(tmpDir, '.nvmrc'), 'v20.5.0\n');
+    expect(detectNodeVersionManagerFile(tmpDir)).toBeUndefined();
+  });
+
+  it('detects .nvmrc', () => {
+    fs.writeFileSync(path.join(tmpDir, '.nvmrc'), 'v20.5.0\n');
+    expect(detectNodeVersionManagerFile(tmpDir)).toEqual({ file: '.nvmrc' });
+  });
+});
+
+describe('migrateNodeVersionManagerFile', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vp-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('migrates .nvmrc to .node-version and removes .nvmrc', () => {
+    fs.writeFileSync(path.join(tmpDir, '.nvmrc'), 'v20.5.0\n');
+    const ok = migrateNodeVersionManagerFile(tmpDir, { file: '.nvmrc' });
+    expect(ok).toBe(true);
+    expect(fs.readFileSync(path.join(tmpDir, '.node-version'), 'utf8')).toBe('20.5.0\n');
+    expect(fs.existsSync(path.join(tmpDir, '.nvmrc'))).toBe(false);
+  });
+
+  it('returns false and warns for unsupported alias', () => {
+    fs.writeFileSync(path.join(tmpDir, '.nvmrc'), 'node\n');
+    const report = {
+      createdViteConfigCount: 0,
+      mergedConfigCount: 0,
+      mergedStagedConfigCount: 0,
+      inlinedLintStagedConfigCount: 0,
+      removedConfigCount: 0,
+      tsdownImportCount: 0,
+      rewrittenImportFileCount: 0,
+      rewrittenImportErrors: [],
+      eslintMigrated: false,
+      prettierMigrated: false,
+      nodeVersionFileMigrated: false,
+      gitHooksConfigured: false,
+      warnings: [],
+      manualSteps: [],
+    };
+    const ok = migrateNodeVersionManagerFile(tmpDir, { file: '.nvmrc' }, report);
+    expect(ok).toBe(false);
+    expect(report.warnings.length).toBe(1);
+    expect(fs.existsSync(path.join(tmpDir, '.node-version'))).toBe(false);
+  });
+});

packages/cli/src/migration/bin.ts

@@ -44,14 +44,17 @@ import {
   checkVitestVersion,
   checkViteVersion,
   detectEslintProject,
+  detectNodeVersionManagerFile,
   detectPrettierProject,
   installGitHooks,
   mergeViteConfigFiles,
   migrateEslintToOxlint,
+  migrateNodeVersionManagerFile,
   migratePrettierToOxfmt,
   preflightGitHooksSetup,
   rewriteMonorepo,
   rewriteStandaloneProject,
+  type NodeVersionManagerDetection,
 } from './migrator.js';
 import { createMigrationReport, type MigrationReport } from './report.js';
 
@@ -168,6 +171,21 @@ async function promptPrettierMigration(
   return true;
 }
 
+async function confirmNodeVersionFileMigration(interactive: boolean): Promise<boolean> {
+  if (interactive) {
+    const confirmed = await prompts.confirm({
+      message: 'Migrate .nvmrc to .node-version?',
+      initialValue: true,
+    });
+    if (prompts.isCancel(confirmed)) {
+      cancelAndExit();
+    }
+    return !!confirmed;
+  }
+  prompts.log.info('.nvmrc detected. Auto-migrating to .node-version...');
+  return true;
+}
+
 const helpMessage = renderCliDoc({
   usage: 'vp migrate [PATH] [OPTIONS]',
   summary:
@@ -319,6 +337,8 @@ interface MigrationPlan {
   eslintConfigFile?: string;
   migratePrettier: boolean;
   prettierConfigFile?: string;
+  migrateNodeVersionFile: boolean;
+  nodeVersionDetection?: NodeVersionManagerDetection;
 }
 
 async function collectMigrationPlan(
@@ -436,6 +456,13 @@ async function collectMigrationPlan(
     warnPackageLevelPrettier();
   }
 
+  // 10. Node version manager file detection + prompt
+  const nodeVersionDetection = detectNodeVersionManagerFile(rootDir);
+  let migrateNodeVersionFile = false;
+  if (nodeVersionDetection) {
+    migrateNodeVersionFile = await confirmNodeVersionFileMigration(options.interactive);
+  }
+
   const plan: MigrationPlan = {
     packageManager,
     shouldSetupHooks,
@@ -447,6 +474,8 @@ async function collectMigrationPlan(
     eslintConfigFile: eslintProject.configFile,
     migratePrettier,
     prettierConfigFile: prettierProject.configFile,
+    migrateNodeVersionFile,
+    nodeVersionDetection,
   };
 
   return plan;
@@ -523,6 +552,9 @@ function showMigrationSummary(options: {
   if (report.prettierMigrated) {
     log(`${styleText('gray', '•')} Prettier migrated to Oxfmt`);
   }
+  if (report.nodeVersionFileMigrated) {
+    log(`${styleText('gray', '•')} Node version manager file migrated to .node-version`);
+  }
   if (report.gitHooksConfigured) {
     log(`${styleText('gray', '•')} Git hooks configured`);
   }
@@ -633,7 +665,13 @@ async function executeMigrationPlan(
     cancelAndExit('Vite+ cannot automatically migrate this project yet.', 1);
   }
 
-  // 3. Run vp install to ensure the project is ready
+  // 3. Migrate node version manager file → .node-version (independent of vite version)
+  if (plan.migrateNodeVersionFile && plan.nodeVersionDetection) {
+    updateMigrationProgress('Migrating node version file');
+    migrateNodeVersionManagerFile(workspaceInfo.rootDir, plan.nodeVersionDetection, report);
+  }
+
+  // 4. Run vp install to ensure the project is ready
   updateMigrationProgress('Installing dependencies');
   const initialInstallSummary = await runViteInstall(
     workspaceInfo.rootDir,
@@ -816,6 +854,18 @@ async function main() {
       workspaceInfoOptional.packages,
     );
 
+    // Check if node version manager file migration is needed
+    const nodeVersionDetection = detectNodeVersionManagerFile(workspaceInfoOptional.rootDir);
+    if (nodeVersionDetection) {
+      const confirmed = await confirmNodeVersionFileMigration(options.interactive);
+      if (
+        confirmed &&
+        migrateNodeVersionManagerFile(workspaceInfoOptional.rootDir, nodeVersionDetection, report)
+      ) {
+        didMigrate = true;
+      }
+    }
+
     // Merge configs and reinstall once if any tool migration happened
     if (eslintMigrated || prettierMigrated) {
       updateMigrationProgress('Rewriting configs');

packages/cli/src/migration/detector.ts

@@ -11,6 +11,7 @@ export interface ConfigFiles {
   eslintLegacyConfig?: string;
   prettierConfig?: string; // e.g. '.prettierrc.json', 'prettier.config.js', PRETTIER_PACKAGE_JSON_CONFIG
   prettierIgnore?: boolean;
+  nvmrcFile?: boolean;
 }
 
 // Sentinel value indicating Prettier config lives inside package.json "prettier" key.
@@ -178,5 +179,10 @@ export function detectConfigs(projectPath: string): ConfigFiles {
     configs.prettierIgnore = true;
   }
 
+  // Check for .nvmrc (nvm)
+  if (fs.existsSync(path.join(projectPath, '.nvmrc'))) {
+    configs.nvmrcFile = true;
+  }
+
   return configs;
 }

packages/cli/src/migration/migrator.ts

@@ -1977,3 +1977,86 @@ function setPackageManager(
     return pkg;
   });
 }
+
+export interface NodeVersionManagerDetection {
+  file: string;
+}
+
+/**
+ * Detect a .nvmrc file in the project directory.
+ * Returns undefined if not found or .node-version already exists.
+ */
+export function detectNodeVersionManagerFile(
+  projectPath: string,
+): NodeVersionManagerDetection | undefined {
+  // already has .node-version — skip detection to avoid false positives and preserve existing file
+  if (fs.existsSync(path.join(projectPath, '.node-version'))) {
+    return undefined;
+  }
+
+  const configs = detectConfigs(projectPath);
+  if (configs.nvmrcFile) {
+    return { file: '.nvmrc' };
+  }
+  return undefined;
+}
+
+/**
+ * Parse a version string from a .nvmrc file.
+ * Returns null for unsupported aliases like "node", "stable", "system".
+ */
+export function parseNvmrcVersion(content: string): string | null {
+  const version = content.split('\n')[0]?.trim();
+
+  if (!version) {
+    return null;
+  }
+
+  // Unsupported nvm aliases that have no direct version equivalent
+  if (['node', 'stable', 'iojs', 'system', 'default'].includes(version)) {
+    return null;
+  }
+
+  // LTS aliases (lts/*, lts/iron, etc.) pass through as-is
+  if (version.startsWith('lts/')) {
+    return version;
+  }
+
+  // Strip optional 'v' prefix, then validate as a semver version or range
+  const normalized = version.startsWith('v') ? version.slice(1) : version;
+  if (!normalized || !semver.validRange(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+/**
+ * Migrate .nvmrc to .node-version and remove .nvmrc.
+ * Returns true on success, false if migration was skipped or failed.
+ */
+export function migrateNodeVersionManagerFile(
+  projectPath: string,
+  _detection: NodeVersionManagerDetection,
+  report?: MigrationReport,
+): boolean {
+  const sourcePath = path.join(projectPath, '.nvmrc');
+  const nodeVersionPath = path.join(projectPath, '.node-version');
+  const content = fs.readFileSync(sourcePath, 'utf8');
+  const version = parseNvmrcVersion(content);
+
+  if (!version) {
+    warnMigration(
+      '.nvmrc contains an unsupported version alias. Create .node-version manually with your desired Node.js version.',
+      report,
+    );
+    return false;
+  }
+
+  fs.writeFileSync(nodeVersionPath, `${version}\n`);
+  fs.unlinkSync(sourcePath);
+
+  if (report) {
+    report.nodeVersionFileMigrated = true;
+  }
+  return true;
+}

packages/cli/src/migration/report.ts

@@ -9,6 +9,7 @@ export interface MigrationReport {
   rewrittenImportErrors: Array<{ path: string; message: string }>;
   eslintMigrated: boolean;
   prettierMigrated: boolean;
+  nodeVersionFileMigrated: boolean;
   gitHooksConfigured: boolean;
   warnings: string[];
   manualSteps: string[];
@@ -26,6 +27,7 @@ export function createMigrationReport(): MigrationReport {
     rewrittenImportErrors: [],
     eslintMigrated: false,
     prettierMigrated: false,
+    nodeVersionFileMigrated: false,
     gitHooksConfigured: false,
     warnings: [],
     manualSteps: [],