vite-plus 0.1.2 → 0.1.4

package/dist/global/migrate.js

@@ -1,22 +1,77 @@
-import { i as __toESM } from "./chunk-CtfvYSle.js";
-import { C as log, E as outro, S as intro, c as upgradeYarn, f as selectAgentTargetPaths, i as promptGitHooks, k as Ct, n as defaultInteractive, o as runViteInstall, p as writeAgentInstructions, r as downloadPackageManager$1, s as selectPackageManager, t as cancelAndExit, x as confirm, y as PackageManager } from "./prompts-CAIahN1u.js";
-import { t as lib_default } from "./lib-CibYHP32.js";
-import { a as selectEditor, c as checkVitestVersion, d as rewriteMonorepo, l as installGitHooks, m as require_semver, o as writeEditorConfigs, p as rewriteStandaloneProject, s as checkViteVersion, t as detectWorkspace$1, u as preflightGitHooksSetup } from "./workspace-MTwAF3M9.js";
-import "./browser-CY4NBwxR.js";
-import "./json-Bfvtp2rL.js";
-import { i as readNearestPackageJson, r as hasVitePlusDependency } from "./package-Pq2biU7_.js";
-import { a as renderCliDoc, n as log$1, r as muted, t as accent } from "./terminal-Cb-NuRkb.js";
+import { i as __toESM } from "./chunk-CgnkrU7a.js";
+import { A as select, E as log, N as Ct, S as PackageManager, a as selectAgentTargetPaths, c as defaultInteractive, d as promptGitHooks, g as displayRelative, h as upgradeYarn, j as spinner, k as outro, l as downloadPackageManager$1, m as selectPackageManager, o as writeAgentInstructions, p as runViteInstall, s as cancelAndExit, t as detectAgentConflicts, w as confirm } from "./agent-CpNB3GIY.js";
+import { t as lib_default } from "./lib-DxappLRQ.js";
+import { _ as rewriteMonorepo, b as createMigrationReport, c as checkViteVersion, d as detectPrettierProject, f as installGitHooks, g as preflightGitHooksSetup, h as migratePrettierToOxfmt, i as detectEditorConflicts, l as checkVitestVersion, m as migrateEslintToOxlint, o as selectEditor, p as mergeViteConfigFiles, s as writeEditorConfigs, t as detectWorkspace$1, u as detectEslintProject, x as require_semver, y as rewriteStandaloneProject } from "./workspace-CiqQdO1L.js";
+import "./browser-CBapUTD0.js";
+import "./json-BRdVJ52a.js";
+import { i as readNearestPackageJson, r as hasVitePlusDependency } from "./package-YAMvX5PJ.js";
+import { i as muted, n as accent, r as log$1, t as renderCliDoc } from "./help-BAGHa8fD.js";
 import path from "node:path";
 import { styleText } from "node:util";
-import colors from "picocolors";
 import { vitePlusHeader } from "../../binding/index.js";
-
 //#region src/migration/bin.ts
 var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
-const { green } = colors;
+function warnPackageLevelEslint() {
+	log.warn("ESLint detected in workspace packages but no root config found. Package-level ESLint must be migrated manually.");
+}
+function warnLegacyEslintConfig(legacyConfigFile) {
+	log.warn(`Legacy ESLint configuration detected (${legacyConfigFile}). Automatic migration to Oxlint requires ESLint v9+ with flat config format (eslint.config.*). Please upgrade to ESLint v9 first: https://eslint.org/docs/latest/use/migrate-to-9.0.0`);
+}
+async function confirmEslintMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate ESLint rules to Oxlint using @oxlint/migrate?",
+			initialValue: true
+		});
+		if (Ct(confirmed)) cancelAndExit();
+		return !!confirmed;
+	}
+	return true;
+}
+async function promptEslintMigration(projectPath, interactive, packages) {
+	const eslintProject = detectEslintProject(projectPath, packages);
+	if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) {
+		warnLegacyEslintConfig(eslintProject.legacyConfigFile);
+		return false;
+	}
+	if (!eslintProject.hasDependency) return false;
+	if (!eslintProject.configFile) {
+		warnPackageLevelEslint();
+		return false;
+	}
+	if (!await confirmEslintMigration(interactive)) return false;
+	if (!await migrateEslintToOxlint(projectPath, interactive, eslintProject.configFile, packages)) cancelAndExit("ESLint migration failed. Fix the issue and re-run `vp migrate`.", 1);
+	return true;
+}
+function warnPackageLevelPrettier() {
+	log.warn("Prettier detected in workspace packages but no root config found. Package-level Prettier must be migrated manually.");
+}
+async function confirmPrettierMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate Prettier to Oxfmt?",
+			initialValue: true
+		});
+		if (Ct(confirmed)) cancelAndExit();
+		return !!confirmed;
+	}
+	log.info("Prettier configuration detected. Auto-migrating to Oxfmt...");
+	return true;
+}
+async function promptPrettierMigration(projectPath, interactive, packages) {
+	const prettierProject = detectPrettierProject(projectPath, packages);
+	if (!prettierProject.hasDependency) return false;
+	if (!prettierProject.configFile) {
+		warnPackageLevelPrettier();
+		return false;
+	}
+	if (!await confirmPrettierMigration(interactive)) return false;
+	if (!await migratePrettierToOxfmt(projectPath, interactive, prettierProject.configFile, packages)) cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
+	return true;
+}
 const helpMessage = renderCliDoc({
 	usage: "vp migrate [PATH] [OPTIONS]",
-	summary: "Migrate standalone Vite, Vitest, Oxlint, and Oxfmt projects to unified Vite+.",
+	summary: "Migrate standalone Vite, Vitest, Oxlint, Oxfmt, and Prettier projects to unified Vite+.",
 	sections: [
 		{
 			title: "Arguments",
@@ -78,8 +133,7 @@ const helpMessage = renderCliDoc({
 	]
 });
 function parseArgs() {
-	const args = process.argv.slice(3);
-	const parsed = lib_default(args, {
+	const parsed = lib_default(process.argv.slice(3), {
 		alias: { h: "help" },
 		boolean: [
 			"help",
@@ -90,11 +144,8 @@ function parseArgs() {
 	});
 	const interactive = parsed.interactive;
 	let projectPath = parsed._[0];
-	if (projectPath) {
-		projectPath = path.resolve(process.cwd(), projectPath);
-	} else {
-		projectPath = process.cwd();
-	}
+	if (projectPath) projectPath = path.resolve(process.cwd(), projectPath);
+	else projectPath = process.cwd();
 	return {
 		projectPath,
 		options: {
@@ -106,112 +157,305 @@ function parseArgs() {
 		}
 	};
 }
-async function main() {
-	const { projectPath, options } = parseArgs();
-	if (options.help) {
-		log$1(vitePlusHeader() + "\n");
-		log$1(helpMessage);
-		return;
-	}
-	intro(vitePlusHeader());
-	const workspaceInfoOptional = await detectWorkspace$1(projectPath);
-	const rootPkg = readNearestPackageJson(workspaceInfoOptional.rootDir);
-	if (hasVitePlusDependency(rootPkg)) {
-		const hasHooksToMigrate = rootPkg?.devDependencies?.husky || rootPkg?.dependencies?.husky || rootPkg?.devDependencies?.["lint-staged"] || rootPkg?.dependencies?.["lint-staged"];
-		if (!hasHooksToMigrate) {
-			outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
-			return;
-		}
-		const shouldSetupHooks = await promptGitHooks(options);
-		if (shouldSetupHooks && installGitHooks(workspaceInfoOptional.rootDir)) {
-			outro(green("✔ Migration completed!"));
-		} else {
-			outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
-		}
-		return;
-	}
-	if (options.interactive) {
-		log.info([
-			styleText("bold", "Migration plan:"),
-			"- Inspect workspace and package manager",
-			`- Run ${accent("vp install")} to prepare dependencies`,
-			"- Rewrite configs and dependencies for Vite+"
-		].join("\n") + "\n");
-		const approved = await confirm({
-			message: "Migrate this project to Vite+?",
-			initialValue: true
-		});
-		if (Ct(approved) || !approved) {
-			cancelAndExit("Migration cancelled");
+async function collectMigrationPlan(rootDir, detectedPackageManager, options, packages) {
+	const packageManager = detectedPackageManager ?? await selectPackageManager(options.interactive, true);
+	let shouldSetupHooks = await promptGitHooks(options);
+	if (shouldSetupHooks) {
+		const reason = preflightGitHooksSetup(rootDir);
+		if (reason) {
+			log.warn(`⚠ ${reason}`);
+			shouldSetupHooks = false;
 		}
 	}
-	const packageManager = workspaceInfoOptional.packageManager ?? await selectPackageManager(options.interactive);
-	let shouldSetupHooks = await promptGitHooks(options);
 	const selectedAgentTargetPaths = await selectAgentTargetPaths({
 		interactive: options.interactive,
 		agent: options.agent,
 		onCancel: () => cancelAndExit()
 	});
+	const agentConflicts = await detectAgentConflicts({
+		projectRoot: rootDir,
+		targetPaths: selectedAgentTargetPaths
+	});
+	const agentConflictDecisions = /* @__PURE__ */ new Map();
+	for (const conflict of agentConflicts) if (options.interactive) {
+		const action = await select({
+			message: `Agent instructions already exist at ${conflict.targetPath}.`,
+			options: [{
+				label: "Append",
+				value: "append",
+				hint: "Add template content to the end"
+			}, {
+				label: "Skip",
+				value: "skip",
+				hint: "Leave existing file unchanged"
+			}],
+			initialValue: "skip"
+		});
+		if (Ct(action)) cancelAndExit();
+		agentConflictDecisions.set(conflict.targetPath, action);
+	} else agentConflictDecisions.set(conflict.targetPath, "skip");
 	const selectedEditor = await selectEditor({
 		interactive: options.interactive,
 		editor: options.editor,
 		onCancel: () => cancelAndExit()
 	});
-	const downloadResult = await downloadPackageManager$1(packageManager, workspaceInfoOptional.packageManagerVersion, options.interactive);
+	const editorConflicts = detectEditorConflicts({
+		projectRoot: rootDir,
+		editorId: selectedEditor
+	});
+	const editorConflictDecisions = /* @__PURE__ */ new Map();
+	for (const conflict of editorConflicts) if (options.interactive) {
+		const action = await select({
+			message: `${conflict.displayPath} already exists.`,
+			options: [{
+				label: "Merge",
+				value: "merge",
+				hint: "Merge new settings into existing file"
+			}, {
+				label: "Skip",
+				value: "skip",
+				hint: "Leave existing file unchanged"
+			}],
+			initialValue: "skip"
+		});
+		if (Ct(action)) cancelAndExit();
+		editorConflictDecisions.set(conflict.fileName, action);
+	} else editorConflictDecisions.set(conflict.fileName, "merge");
+	const eslintProject = detectEslintProject(rootDir, packages);
+	let migrateEslint = false;
+	if (eslintProject.hasDependency && !eslintProject.configFile && eslintProject.legacyConfigFile) warnLegacyEslintConfig(eslintProject.legacyConfigFile);
+	else if (eslintProject.hasDependency && eslintProject.configFile) migrateEslint = await confirmEslintMigration(options.interactive);
+	else if (eslintProject.hasDependency) warnPackageLevelEslint();
+	const prettierProject = detectPrettierProject(rootDir, packages);
+	let migratePrettier = false;
+	if (prettierProject.hasDependency && prettierProject.configFile) migratePrettier = await confirmPrettierMigration(options.interactive);
+	else if (prettierProject.hasDependency) warnPackageLevelPrettier();
+	return {
+		packageManager,
+		shouldSetupHooks,
+		selectedAgentTargetPaths,
+		agentConflictDecisions,
+		selectedEditor,
+		editorConflictDecisions,
+		migrateEslint,
+		eslintConfigFile: eslintProject.configFile,
+		migratePrettier,
+		prettierConfigFile: prettierProject.configFile
+	};
+}
+function formatDuration(durationMs) {
+	if (durationMs < 1e3) return `${Math.max(1, durationMs)}ms`;
+	const durationSeconds = durationMs / 1e3;
+	if (durationSeconds < 10) return `${durationSeconds.toFixed(1)}s`;
+	return `${Math.round(durationSeconds)}s`;
+}
+function showMigrationSummary(options) {
+	const { projectRoot, packageManager, packageManagerVersion, installDurationMs, report, updatedExistingVitePlus } = options;
+	const projectLabel = displayRelative(projectRoot) || ".";
+	const configUpdates = report.createdViteConfigCount + report.mergedConfigCount + report.mergedStagedConfigCount + report.inlinedLintStagedConfigCount + report.removedConfigCount + report.tsdownImportCount;
+	log$1(`${styleText("magenta", "◇")} ${updatedExistingVitePlus ? "Updated" : "Migrated"} ${accent(projectLabel)}${updatedExistingVitePlus ? "" : " to Vite+"}`);
+	log$1(`${styleText("gray", "•")} Node ${process.versions.node}  ${packageManager} ${packageManagerVersion}`);
+	if (installDurationMs > 0) log$1(`${styleText("green", "✓")} Dependencies installed in ${formatDuration(installDurationMs)}`);
+	if (configUpdates > 0 || report.rewrittenImportFileCount > 0) {
+		const parts = [];
+		if (configUpdates > 0) parts.push(`${configUpdates} ${configUpdates === 1 ? "config update" : "config updates"} applied`);
+		if (report.rewrittenImportFileCount > 0) parts.push(`${report.rewrittenImportFileCount} ${report.rewrittenImportFileCount === 1 ? "file had" : "files had"} imports rewritten`);
+		log$1(`${styleText("gray", "•")} ${parts.join(", ")}`);
+	}
+	if (report.eslintMigrated) log$1(`${styleText("gray", "•")} ESLint rules migrated to Oxlint`);
+	if (report.prettierMigrated) log$1(`${styleText("gray", "•")} Prettier migrated to Oxfmt`);
+	if (report.gitHooksConfigured) log$1(`${styleText("gray", "•")} Git hooks configured`);
+	if (report.warnings.length > 0) {
+		log$1(`${styleText("yellow", "!")} Warnings:`);
+		for (const warning of report.warnings) log$1(`  - ${warning}`);
+	}
+	if (report.manualSteps.length > 0) {
+		log$1(`${styleText("blue", "→")} Manual follow-up:`);
+		for (const step of report.manualSteps) log$1(`  - ${step}`);
+	}
+}
+async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
+	const report = createMigrationReport();
+	const migrationProgress = interactive ? spinner({ indicator: "timer" }) : void 0;
+	let migrationProgressStarted = false;
+	const updateMigrationProgress = (message) => {
+		if (!migrationProgress) return;
+		if (migrationProgressStarted) {
+			migrationProgress.message(message);
+			return;
+		}
+		migrationProgress.start(message);
+		migrationProgressStarted = true;
+	};
+	const clearMigrationProgress = () => {
+		if (migrationProgress && migrationProgressStarted) {
+			migrationProgress.clear();
+			migrationProgressStarted = false;
+		}
+	};
+	const failMigrationProgress = (message) => {
+		if (migrationProgress && migrationProgressStarted) {
+			migrationProgress.error(message);
+			migrationProgressStarted = false;
+		}
+	};
+	updateMigrationProgress("Preparing migration");
+	const downloadResult = await downloadPackageManager$1(plan.packageManager, workspaceInfoOptional.packageManagerVersion, interactive, true);
 	const workspaceInfo = {
 		...workspaceInfoOptional,
-		packageManager,
+		packageManager: plan.packageManager,
 		downloadPackageManager: downloadResult
 	};
-	if (packageManager === PackageManager.yarn && import_semver.default.satisfies(downloadResult.version, ">=4.0.0 <4.10.0")) {
-		await upgradeYarn(workspaceInfo.rootDir, options.interactive);
-	} else if (packageManager === PackageManager.pnpm && import_semver.default.satisfies(downloadResult.version, "< 9.5.0")) {
+	if (plan.packageManager === PackageManager.yarn && import_semver.default.satisfies(downloadResult.version, ">=4.0.0 <4.10.0")) {
+		updateMigrationProgress("Upgrading Yarn");
+		await upgradeYarn(workspaceInfo.rootDir, interactive, true);
+	} else if (plan.packageManager === PackageManager.pnpm && import_semver.default.satisfies(downloadResult.version, "< 9.5.0")) {
+		failMigrationProgress("Migration failed");
 		log.error(`✘ pnpm@${downloadResult.version} is not supported by auto migration, please upgrade pnpm to >=9.5.0 first`);
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
-	} else if (packageManager === PackageManager.npm && import_semver.default.satisfies(downloadResult.version, "< 8.3.0")) {
+	} else if (plan.packageManager === PackageManager.npm && import_semver.default.satisfies(downloadResult.version, "< 8.3.0")) {
+		failMigrationProgress("Migration failed");
 		log.error(`✘ npm@${downloadResult.version} is not supported by auto migration, please upgrade npm to >=8.3.0 first`);
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	}
-	await runViteInstall(workspaceInfo.rootDir, options.interactive);
+	updateMigrationProgress("Installing dependencies");
+	const initialInstallSummary = await runViteInstall(workspaceInfo.rootDir, interactive, void 0, { silent: true });
+	updateMigrationProgress("Validating toolchain");
 	const isViteSupported = checkViteVersion(workspaceInfo.rootDir);
 	const isVitestSupported = checkVitestVersion(workspaceInfo.rootDir);
 	if (!isViteSupported || !isVitestSupported) {
+		failMigrationProgress("Migration failed");
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	}
-	if (shouldSetupHooks) {
-		const reason = preflightGitHooksSetup(workspaceInfo.rootDir);
-		if (reason) {
-			log.warn(`⚠ ${reason}`);
-			shouldSetupHooks = false;
+	if (plan.migrateEslint) {
+		updateMigrationProgress("Migrating ESLint");
+		if (!await migrateEslintToOxlint(workspaceInfo.rootDir, interactive, plan.eslintConfigFile, workspaceInfo.packages, {
+			silent: true,
+			report
+		})) {
+			failMigrationProgress("Migration failed");
+			cancelAndExit("ESLint migration failed. Fix the issue and re-run `vp migrate`.", 1);
 		}
 	}
-	const skipStagedMigration = !shouldSetupHooks;
-	if (workspaceInfo.isMonorepo) {
-		rewriteMonorepo(workspaceInfo, skipStagedMigration);
-	} else {
-		rewriteStandaloneProject(workspaceInfo.rootDir, workspaceInfo, skipStagedMigration);
+	if (plan.migratePrettier) {
+		updateMigrationProgress("Migrating Prettier");
+		if (!await migratePrettierToOxfmt(workspaceInfo.rootDir, interactive, plan.prettierConfigFile, workspaceInfo.packages, {
+			silent: true,
+			report
+		})) {
+			failMigrationProgress("Migration failed");
+			cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
+		}
 	}
-	if (shouldSetupHooks) {
-		installGitHooks(workspaceInfo.rootDir);
+	const skipStagedMigration = !plan.shouldSetupHooks;
+	updateMigrationProgress("Rewriting configs");
+	if (workspaceInfo.isMonorepo) rewriteMonorepo(workspaceInfo, skipStagedMigration, true, report);
+	else rewriteStandaloneProject(workspaceInfo.rootDir, workspaceInfo, skipStagedMigration, true, report);
+	if (plan.shouldSetupHooks) {
+		updateMigrationProgress("Configuring git hooks");
+		installGitHooks(workspaceInfo.rootDir, true, report);
 	}
+	updateMigrationProgress("Writing agent instructions");
 	await writeAgentInstructions({
 		projectRoot: workspaceInfo.rootDir,
-		targetPaths: selectedAgentTargetPaths,
-		interactive: options.interactive
+		targetPaths: plan.selectedAgentTargetPaths,
+		interactive,
+		conflictDecisions: plan.agentConflictDecisions,
+		silent: true
 	});
+	updateMigrationProgress("Writing editor configs");
 	await writeEditorConfigs({
 		projectRoot: workspaceInfo.rootDir,
-		editorId: selectedEditor,
-		interactive: options.interactive
+		editorId: plan.selectedEditor,
+		interactive,
+		conflictDecisions: plan.editorConflictDecisions,
+		silent: true
+	});
+	const installArgs = plan.packageManager === PackageManager.npm ? ["--force"] : void 0;
+	updateMigrationProgress("Installing dependencies");
+	const finalInstallSummary = await runViteInstall(workspaceInfo.rootDir, interactive, installArgs, { silent: true });
+	clearMigrationProgress();
+	return {
+		installDurationMs: initialInstallSummary.durationMs + finalInstallSummary.durationMs,
+		packageManagerVersion: downloadResult.version,
+		report
+	};
+}
+async function main() {
+	const { projectPath, options } = parseArgs();
+	if (options.help) {
+		log$1(vitePlusHeader() + "\n");
+		log$1(helpMessage);
+		return;
+	}
+	log$1(`${vitePlusHeader()}\n`);
+	const workspaceInfoOptional = await detectWorkspace$1(projectPath);
+	const resolvedPackageManager = workspaceInfoOptional.packageManager ?? "unknown";
+	const rootPkg = readNearestPackageJson(workspaceInfoOptional.rootDir);
+	if (hasVitePlusDependency(rootPkg)) {
+		let didMigrate = false;
+		let installDurationMs = 0;
+		const report = createMigrationReport();
+		const migrationProgress = options.interactive ? spinner({ indicator: "timer" }) : void 0;
+		let migrationProgressStarted = false;
+		const updateMigrationProgress = (message) => {
+			if (!migrationProgress) return;
+			if (migrationProgressStarted) {
+				migrationProgress.message(message);
+				return;
+			}
+			migrationProgress.start(message);
+			migrationProgressStarted = true;
+		};
+		const clearMigrationProgress = () => {
+			if (migrationProgress && migrationProgressStarted) {
+				migrationProgress.clear();
+				migrationProgressStarted = false;
+			}
+		};
+		const eslintMigrated = await promptEslintMigration(workspaceInfoOptional.rootDir, options.interactive, workspaceInfoOptional.packages);
+		const prettierMigrated = await promptPrettierMigration(workspaceInfoOptional.rootDir, options.interactive, workspaceInfoOptional.packages);
+		if (eslintMigrated || prettierMigrated) {
+			updateMigrationProgress("Rewriting configs");
+			mergeViteConfigFiles(workspaceInfoOptional.rootDir, true, report);
+			updateMigrationProgress("Installing dependencies");
+			const installSummary = await runViteInstall(workspaceInfoOptional.rootDir, options.interactive, void 0, { silent: true });
+			installDurationMs += installSummary.durationMs;
+			didMigrate = true;
+			report.eslintMigrated = eslintMigrated;
+			report.prettierMigrated = prettierMigrated;
+		}
+		if (rootPkg?.devDependencies?.husky || rootPkg?.dependencies?.husky || rootPkg?.devDependencies?.["lint-staged"] || rootPkg?.dependencies?.["lint-staged"]) {
+			const shouldSetupHooks = await promptGitHooks(options);
+			if (shouldSetupHooks) updateMigrationProgress("Configuring git hooks");
+			if (shouldSetupHooks && installGitHooks(workspaceInfoOptional.rootDir, true, report)) didMigrate = true;
+		}
+		if (didMigrate) {
+			clearMigrationProgress();
+			showMigrationSummary({
+				projectRoot: workspaceInfoOptional.rootDir,
+				packageManager: resolvedPackageManager,
+				packageManagerVersion: workspaceInfoOptional.packageManagerVersion,
+				installDurationMs,
+				report,
+				updatedExistingVitePlus: true
+			});
+		} else outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
+		return;
+	}
+	const plan = await collectMigrationPlan(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, options, workspaceInfoOptional.packages);
+	const result = await executeMigrationPlan(workspaceInfoOptional, plan, options.interactive);
+	showMigrationSummary({
+		projectRoot: workspaceInfoOptional.rootDir,
+		packageManager: plan.packageManager,
+		packageManagerVersion: result.packageManagerVersion,
+		installDurationMs: result.installDurationMs,
+		report: result.report
 	});
-	const installArgs = packageManager === PackageManager.npm ? ["--force"] : undefined;
-	await runViteInstall(workspaceInfo.rootDir, options.interactive, installArgs);
-	outro(green("✔ Migration completed!"));
 }
 main().catch((err) => {
 	log.error(err.message);
 	console.error(err);
 	process.exit(1);
 });
-
-//#endregion
+//#endregion

package/dist/global/{package-Pq2biU7_.js → package-YAMvX5PJ.js}

@@ -1,19 +1,15 @@
-import { o as VITE_PLUS_NAME, r as readJsonFile } from "./json-Bfvtp2rL.js";
+import { r as readJsonFile } from "./json-BRdVJ52a.js";
 import path from "node:path";
 import fs from "node:fs";
 import { createRequire } from "node:module";
-
 //#region src/utils/package.ts
 function getScopeFromPackageName(packageName) {
-	if (packageName.startsWith("@")) {
-		return packageName.split("/")[0];
-	}
+	if (packageName.startsWith("@")) return packageName.split("/")[0];
 	return "";
 }
 function detectPackageMetadata(projectPath, packageName) {
 	try {
-		const require = createRequire(path.join(projectPath, "noop.js"));
-		const pkgFilePath = require.resolve(`${packageName}/package.json`);
+		const pkgFilePath = createRequire(path.join(projectPath, "noop.js")).resolve(`${packageName}/package.json`);
 		const pkg = JSON.parse(fs.readFileSync(pkgFilePath, "utf8"));
 		return {
 			name: pkg.name,
@@ -32,16 +28,13 @@ function detectPackageMetadata(projectPath, packageName) {
 function readNearestPackageJson(currentDir) {
 	do {
 		const packageJsonPath = path.join(currentDir, "package.json");
-		if (fs.existsSync(packageJsonPath)) {
-			return readJsonFile(packageJsonPath);
-		}
+		if (fs.existsSync(packageJsonPath)) return readJsonFile(packageJsonPath);
 		currentDir = path.dirname(currentDir);
 	} while (currentDir !== path.dirname(currentDir));
 	return null;
 }
 function hasVitePlusDependency(pkg) {
-	return Boolean(pkg?.dependencies?.[VITE_PLUS_NAME] || pkg?.devDependencies?.[VITE_PLUS_NAME]);
+	return Boolean(pkg?.dependencies?.["vite-plus"] || pkg?.devDependencies?.["vite-plus"]);
 }
-
 //#endregion
-export { readNearestPackageJson as i, getScopeFromPackageName as n, hasVitePlusDependency as r, detectPackageMetadata as t };
+export { readNearestPackageJson as i, getScopeFromPackageName as n, hasVitePlusDependency as r, detectPackageMetadata as t };

package/dist/global/{slice-ansi-BhwAwMdF.js → slice-ansi-Fap0ehe9.js}

@@ -1,48 +1,34 @@
-import { a as ansiStyles, i as isWide, r as isFullWidth } from "./strip-ansi-BL-dgd7n.js";
-
+import { a as ansiStyles, i as isWide, r as isFullWidth } from "./strip-ansi-CE-VDMdw.js";
 //#region ../../node_modules/.pnpm/is-fullwidth-code-point@5.1.0/node_modules/is-fullwidth-code-point/index.js
 function isFullwidthCodePoint(codePoint) {
-	if (!Number.isInteger(codePoint)) {
-		return false;
-	}
+	if (!Number.isInteger(codePoint)) return false;
 	return isFullWidth(codePoint) || isWide(codePoint);
 }
-
 //#endregion
 //#region ../../node_modules/.pnpm/slice-ansi@7.1.2/node_modules/slice-ansi/index.js
 const ESCAPES = new Set([27, 155]);
 const CODE_POINT_0 = "0".codePointAt(0);
 const CODE_POINT_9 = "9".codePointAt(0);
 const MAX_ANSI_SEQUENCE_LENGTH = 19;
-const endCodesSet = new Set();
-const endCodesMap = new Map();
+const endCodesSet = /* @__PURE__ */ new Set();
+const endCodesMap = /* @__PURE__ */ new Map();
 for (const [start, end] of ansiStyles.codes) {
 	endCodesSet.add(ansiStyles.color.ansi(end));
 	endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
 }
 function getEndCode(code) {
-	if (endCodesSet.has(code)) {
-		return code;
-	}
-	if (endCodesMap.has(code)) {
-		return endCodesMap.get(code);
-	}
+	if (endCodesSet.has(code)) return code;
+	if (endCodesMap.has(code)) return endCodesMap.get(code);
 	code = code.slice(2);
-	if (code.includes(";")) {
-		code = code[0] + "0";
-	}
+	if (code.includes(";")) code = code[0] + "0";
 	const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10));
-	if (returnValue) {
-		return ansiStyles.color.ansi(returnValue);
-	}
+	if (returnValue) return ansiStyles.color.ansi(returnValue);
 	return ansiStyles.reset.open;
 }
 function findNumberIndex(string) {
 	for (let index = 0; index < string.length; index++) {
 		const codePoint = string.codePointAt(index);
-		if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) {
-			return index;
-		}
+		if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) return index;
 	}
 	return -1;
 }
@@ -51,9 +37,7 @@ function parseAnsiCode(string, offset) {
 	const startIndex = findNumberIndex(string);
 	if (startIndex !== -1) {
 		let endIndex = string.indexOf("m", startIndex);
-		if (endIndex === -1) {
-			endIndex = string.length;
-		}
+		if (endIndex === -1) endIndex = string.length;
 		return string.slice(0, endIndex + 1);
 	}
 }
@@ -84,30 +68,22 @@ function tokenize(string, endCharacter = Number.POSITIVE_INFINITY) {
 		});
 		index += character.length;
 		visibleCount += isFullWidth ? 2 : character.length;
-		if (visibleCount >= endCharacter) {
-			break;
-		}
+		if (visibleCount >= endCharacter) break;
 	}
 	return returnValue;
 }
 function reduceAnsiCodes(codes) {
 	let returnValue = [];
-	for (const code of codes) {
-		if (code.code === ansiStyles.reset.open) {
-			returnValue = [];
-		} else if (endCodesSet.has(code.code)) {
-			returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.code);
-		} else {
-			returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.endCode);
-			returnValue.push(code);
-		}
+	for (const code of codes) if (code.code === ansiStyles.reset.open) returnValue = [];
+	else if (endCodesSet.has(code.code)) returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.code);
+	else {
+		returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.endCode);
+		returnValue.push(code);
 	}
 	return returnValue;
 }
 function undoAnsiCodes(codes) {
-	const reduced = reduceAnsiCodes(codes);
-	const endCodes = reduced.map(({ endCode }) => endCode);
-	return endCodes.reverse().join("");
+	return reduceAnsiCodes(codes).map(({ endCode }) => endCode).reverse().join("");
 }
 function sliceAnsi(string, start, end) {
 	const tokens = tokenize(string, end);
@@ -116,29 +92,22 @@ function sliceAnsi(string, start, end) {
 	let returnValue = "";
 	let include = false;
 	for (const token of tokens) {
-		if (end !== undefined && position >= end) {
-			break;
-		}
+		if (end !== void 0 && position >= end) break;
 		if (token.type === "ansi") {
 			activeCodes.push(token);
-			if (include) {
-				returnValue += token.code;
-			}
+			if (include) returnValue += token.code;
 		} else {
 			if (!include && position >= start) {
 				include = true;
 				activeCodes = reduceAnsiCodes(activeCodes);
 				returnValue = activeCodes.map(({ code }) => code).join("");
 			}
-			if (include) {
-				returnValue += token.value;
-			}
+			if (include) returnValue += token.value;
 			position += token.isFullWidth ? 2 : token.value.length;
 		}
 	}
 	returnValue += undoAnsiCodes(activeCodes);
 	return returnValue;
 }
-
 //#endregion
-export { sliceAnsi as t };
+export { sliceAnsi as t };