vite-plus 0.1.23 → 0.2.0

package/dist/migration/bin.js

@@ -1,12 +1,12 @@
-import { r as __toESM } from "../chunk-DnnnRqeS.js";
-import { c as isForceOverrideMode } from "../constants-DCBWlNrn.js";
-import { A as q, C as log, D as spinner, E as select, T as outro, c as defaultInteractive, d as promptGitHooks, g as upgradeYarn, h as selectPackageManager, i as hasBaseUrlInTsconfig, l as downloadPackageManager, m as runViteInstall, r as fixBaseUrlInTsconfig, s as cancelAndExit, t as confirmBaseUrlFix, v as PackageManager, x as confirm, y as require_semver } from "../tsconfig-DlUVXT3J.js";
-import { a as printHeader, i as muted, r as log$1, t as accent } from "../terminal-uTv0ZaMr.js";
+import { r as __toESM } from "../rolldown-runtime-DnnnRqeS.js";
+import { u as isForceOverrideMode } from "../constants-CrfJQIUX.js";
+import { A as select, C as require_semver, D as log, P as R, S as PackageManager, T as confirm, c as cancelAndExit, d as promptGitHooks, g as upgradeYarn, h as selectPackageManager, i as hasBaseUrlInTsconfig, j as spinner, k as outro, l as defaultInteractive, m as runViteInstall, r as fixBaseUrlInTsconfig, t as confirmBaseUrlFix, u as downloadPackageManager } from "../tsconfig-CJ_StdFc.js";
+import { a as printHeader, i as muted, r as log$1, s as warnMsg, t as accent } from "../terminal-uTv0ZaMr.js";
 import { t as lib_default } from "../lib-L3DWSRQp.js";
-import { a as readNearestPackageJson, i as hasVitePlusDependency } from "../package-PmBUZ-ve.js";
-import { A as promptEslintMigration, C as injectLintTypeCheckDefaults, D as migrateNodeVersionManagerFile, E as migrateEslintToOxlint, H as displayRelative, I as warnIncompatibleEslintIntegration, L as warnLegacyEslintConfig, M as rewriteMonorepo, O as migratePrettierToOxfmt, P as rewriteStandaloneProject, R as warnPackageLevelEslint, T as mergeViteConfigFiles, _ as detectNodeVersionManagerFile, b as hasFrameworkShim, d as checkVitestVersion, f as confirmEslintMigration, g as detectIncompatibleEslintIntegration, h as detectFramework, i as selectAgentTargetPaths, j as promptPrettierMigration, k as preflightGitHooksSetup, l as addFrameworkShim, m as detectEslintProject, n as detectAgentConflicts, p as confirmPrettierMigration, r as detectExistingAgentTargetPaths, s as writeAgentInstructions, u as checkViteVersion, v as detectPrettierProject, w as installGitHooks, z as warnPackageLevelPrettier } from "../agent-aSGY0osq.js";
-import { n as addMigrationWarning, r as createMigrationReport } from "../report-DgSBQUdz.js";
-import { c as writeEditorConfigs, i as detectEditorConflicts, o as selectEditor, t as detectWorkspace } from "../workspace-DElv730L.js";
+import { a as readNearestPackageJson, i as hasVitePlusDependency } from "../package-BHirM1_v.js";
+import { A as mergeViteConfigFiles, C as ensureVitePlusBootstrap, H as warnLegacyEslintConfig, L as rewriteMonorepo, M as migrateNodeVersionManagerFile, N as migratePrettierToOxfmt, O as injectLintTypeCheckDefaults, P as preflightGitHooksSetup, T as hasFrameworkShim, U as warnPackageLevelEslint, V as warnIncompatibleEslintIntegration, W as warnPackageLevelPrettier, _ as detectLegacyGitHooksMigrationCandidate, b as detectPrettierProject, d as checkVitestVersion, f as confirmEslintMigration, g as detectIncompatibleEslintIntegration, h as detectFramework, i as selectAgentTargetPaths, j as migrateEslintToOxlint, k as installGitHooks, l as addFrameworkShim, m as detectEslintProject, n as detectAgentConflicts, p as confirmPrettierMigration, q as displayRelative, r as detectExistingAgentTargetPaths, s as writeAgentInstructions, u as checkViteVersion, v as detectNodeVersionManagerFile, w as finalizeCoreMigrationForExistingVitePlus, x as detectVitePlusBootstrapPending, y as detectPendingCoreMigration, z as rewriteStandaloneProject } from "../agent-BD31CsvU.js";
+import { n as addMigrationWarning, r as createMigrationReport } from "../report-BHSkWqRR.js";
+import { a as detectEditorConflicts, l as writeEditorConfigs, s as selectEditor, t as detectWorkspace } from "../workspace-Cjoc1c_A.js";
 import { t as renderCliDoc } from "../help-YP84FSEz.js";
 import path from "node:path";
 import { styleText } from "node:util";
@@ -22,7 +22,7 @@ async function confirmNodeVersionFileMigration(interactive, detection) {
 			message,
 			initialValue: true
 		});
-		if (q(confirmed)) cancelAndExit();
+		if (R(confirmed)) cancelAndExit();
 		return confirmed;
 	}
 	return true;
@@ -37,7 +37,7 @@ async function confirmFrameworkShim(framework, interactive) {
 			message: `Add TypeScript shim for ${name} component files (*.${framework})?\n  ` + styleText("gray", `Lets TypeScript recognize .${framework} files until vp check fully supports them.`),
 			initialValue: true
 		});
-		if (q(confirmed)) cancelAndExit();
+		if (R(confirmed)) cancelAndExit();
 		return confirmed;
 	}
 	return true;
@@ -144,8 +144,9 @@ const helpMessage = renderCliDoc({
 				"  After the migration:",
 				"  - Confirm `vite` imports were rewritten to `vite-plus` where needed",
 				"  - Confirm `vitest` imports were rewritten to `vite-plus/test` where needed",
-				"  - Remove old `vite` and `vitest` dependencies only after those rewrites",
-				"    are confirmed",
+				"  - On pnpm, keep the `vite` / `vitest` entries that `vp migrate` aliased to",
+				"    the Vite+ packages so the workspace override stays effective; with other",
+				"    package managers you can remove them once those rewrites are confirmed",
 				"  - Move remaining tool-specific config into the appropriate blocks in",
 				"    `vite.config.ts`",
 				"",
@@ -196,16 +197,65 @@ function parseArgs() {
 		}
 	};
 }
-async function collectMigrationPlan(rootDir, detectedPackageManager, options, packages) {
-	const packageManager = detectedPackageManager ?? await selectPackageManager(options.interactive, true);
+function getFrameworkShimCandidates(rootDir, packages) {
+	const allDetectedFrameworks = new Set(detectFramework(rootDir));
+	for (const pkg of packages ?? []) for (const framework of detectFramework(path.join(rootDir, pkg.path))) allDetectedFrameworks.add(framework);
+	return [...allDetectedFrameworks].filter((framework) => {
+		if (detectFramework(rootDir).includes(framework) && !hasFrameworkShim(rootDir, framework)) return true;
+		return (packages ?? []).some((pkg) => {
+			const pkgPath = path.join(rootDir, pkg.path);
+			return detectFramework(pkgPath).includes(framework) && !hasFrameworkShim(pkgPath, framework);
+		});
+	});
+}
+async function collectFrameworkShimFrameworks(rootDir, options, packages) {
+	const frameworkShimFrameworks = [];
+	for (const framework of getFrameworkShimCandidates(rootDir, packages)) if (await confirmFrameworkShim(framework, options.interactive)) frameworkShimFrameworks.push(framework);
+	return frameworkShimFrameworks.length > 0 ? frameworkShimFrameworks : void 0;
+}
+function addFrameworkShimsForWorkspace(rootDir, frameworks, packages, report, updateMigrationProgress) {
+	if (!frameworks) return false;
+	let changed = false;
+	updateMigrationProgress("Adding TypeScript shim");
+	for (const framework of frameworks) {
+		if (detectFramework(rootDir).includes(framework) && !hasFrameworkShim(rootDir, framework)) {
+			addFrameworkShim(rootDir, framework, report);
+			changed = true;
+		}
+		for (const pkg of packages ?? []) {
+			const pkgPath = path.join(rootDir, pkg.path);
+			if (detectFramework(pkgPath).includes(framework) && !hasFrameworkShim(pkgPath, framework)) {
+				addFrameworkShim(pkgPath, framework, report);
+				changed = true;
+			}
+		}
+	}
+	return changed;
+}
+function hasEnabledOption(value) {
+	if (Array.isArray(value)) return value.some((item) => Boolean(item));
+	return value !== void 0 && value !== false && value !== "";
+}
+function hasExplicitExistingVitePlusSetupRequest(options) {
+	return options.hooks === true || hasEnabledOption(options.agent) || hasEnabledOption(options.editor);
+}
+function hasExistingVitePlusMigrationCandidates(workspaceInfo, options) {
+	const eslintProject = detectEslintProject(workspaceInfo.rootDir, workspaceInfo.packages);
+	const prettierProject = detectPrettierProject(workspaceInfo.rootDir, workspaceInfo.packages);
+	return hasExplicitExistingVitePlusSetupRequest(options) || detectLegacyGitHooksMigrationCandidate(workspaceInfo.rootDir) || hasBaseUrlInWorkspace(workspaceInfo) || eslintProject.hasDependency || prettierProject.hasDependency || detectNodeVersionManagerFile(workspaceInfo.rootDir) !== void 0 || getFrameworkShimCandidates(workspaceInfo.rootDir, workspaceInfo.packages).length > 0;
+}
+async function collectGitHooksDecision(rootDir, packageManager, options) {
 	let shouldSetupHooks = await promptGitHooks(options);
 	if (shouldSetupHooks) {
-		const reason = preflightGitHooksSetup(rootDir);
+		const reason = preflightGitHooksSetup(rootDir, packageManager);
 		if (reason) {
 			log.warn(`⚠ ${reason}`);
 			shouldSetupHooks = false;
 		}
 	}
+	return shouldSetupHooks;
+}
+async function collectAgentInstructionPlan(rootDir, options) {
 	const existingAgentTargetPaths = options.agent !== void 0 || !options.interactive ? void 0 : detectExistingAgentTargetPaths(rootDir);
 	const selectedAgentTargetPaths = existingAgentTargetPaths !== void 0 ? existingAgentTargetPaths : await selectAgentTargetPaths({
 		interactive: options.interactive,
@@ -231,9 +281,15 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, options, pa
 			}],
 			initialValue: "skip"
 		});
-		if (q(action)) cancelAndExit();
+		if (R(action)) cancelAndExit();
 		agentConflictDecisions.set(conflict.targetPath, action);
 	} else agentConflictDecisions.set(conflict.targetPath, "skip");
+	return {
+		selectedAgentTargetPaths,
+		agentConflictDecisions
+	};
+}
+async function collectEditorConfigPlan(rootDir, options) {
 	const selectedEditor = await selectEditor({
 		interactive: options.interactive,
 		editor: options.editor,
@@ -258,9 +314,15 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, options, pa
 			}],
 			initialValue: "skip"
 		});
-		if (q(action)) cancelAndExit();
+		if (R(action)) cancelAndExit();
 		editorConflictDecisions.set(conflict.fileName, action);
 	} else editorConflictDecisions.set(conflict.fileName, "merge");
+	return {
+		selectedEditor,
+		editorConflictDecisions
+	};
+}
+async function collectEslintMigrationDecision(rootDir, options, packages) {
 	const eslintProject = detectEslintProject(rootDir, packages);
 	const incompatibleEslintIntegration = detectIncompatibleEslintIntegration(rootDir, packages);
 	let migrateEslint = false;
@@ -268,6 +330,35 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, options, pa
 	else 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();
+	return {
+		migrateEslint,
+		eslintConfigFile: eslintProject.configFile
+	};
+}
+async function collectMigrationSetupPlan(rootDir, packageManager, options, packages, includeEslint = true) {
+	const shouldSetupHooks = await collectGitHooksDecision(rootDir, packageManager, options);
+	const agentPlan = await collectAgentInstructionPlan(rootDir, options);
+	const editorPlan = await collectEditorConfigPlan(rootDir, options);
+	const eslintPlan = includeEslint ? await collectEslintMigrationDecision(rootDir, options, packages) : { migrateEslint: false };
+	return {
+		shouldSetupHooks,
+		...agentPlan,
+		...editorPlan,
+		...eslintPlan
+	};
+}
+function getExistingVitePlusSetupOptions(options, legacyGitHooksMigrationCandidate, useFullMigrationDefaults = false) {
+	if (useFullMigrationDefaults) return options;
+	return {
+		...options,
+		hooks: options.hooks ?? (legacyGitHooksMigrationCandidate ? options.interactive ? void 0 : true : false),
+		agent: options.agent ?? false,
+		editor: options.editor ?? false
+	};
+}
+async function collectMigrationPlan(rootDir, detectedPackageManager, options, packages) {
+	const packageManager = detectedPackageManager ?? await selectPackageManager(options.interactive, true);
+	const setupPlan = await collectMigrationSetupPlan(rootDir, packageManager, options, packages);
 	const prettierProject = detectPrettierProject(rootDir, packages);
 	let migratePrettier = false;
 	if (prettierProject.hasDependency && prettierProject.configFile) migratePrettier = await confirmPrettierMigration(options.interactive);
@@ -279,30 +370,16 @@ async function collectMigrationPlan(rootDir, detectedPackageManager, options, pa
 	const nodeVersionDetection = detectNodeVersionManagerFile(rootDir);
 	let migrateNodeVersionFile = false;
 	if (nodeVersionDetection) migrateNodeVersionFile = await confirmNodeVersionFileMigration(options.interactive, nodeVersionDetection);
-	const allDetectedFrameworks = new Set(detectFramework(rootDir));
-	for (const pkg of packages ?? []) for (const framework of detectFramework(path.join(rootDir, pkg.path))) allDetectedFrameworks.add(framework);
-	const frameworkShimFrameworks = [];
-	for (const framework of allDetectedFrameworks) if (detectFramework(rootDir).includes(framework) && !hasFrameworkShim(rootDir, framework) || (packages ?? []).some((pkg) => {
-		const pkgPath = path.join(rootDir, pkg.path);
-		return detectFramework(pkgPath).includes(framework) && !hasFrameworkShim(pkgPath, framework);
-	})) {
-		if (await confirmFrameworkShim(framework, options.interactive)) frameworkShimFrameworks.push(framework);
-	}
+	const frameworkShimFrameworks = await collectFrameworkShimFrameworks(rootDir, options, packages);
 	return {
 		packageManager,
-		shouldSetupHooks,
-		selectedAgentTargetPaths,
-		agentConflictDecisions,
-		selectedEditor,
-		editorConflictDecisions,
-		migrateEslint,
-		eslintConfigFile: eslintProject.configFile,
+		...setupPlan,
 		migratePrettier,
 		prettierConfigFile: prettierProject.configFile,
 		fixBaseUrl,
 		migrateNodeVersionFile,
 		nodeVersionDetection,
-		frameworkShimFrameworks: frameworkShimFrameworks.length > 0 ? frameworkShimFrameworks : void 0
+		frameworkShimFrameworks
 	};
 }
 function formatDuration(durationMs) {
@@ -311,13 +388,34 @@ function formatDuration(durationMs) {
 	if (durationSeconds < 10) return `${durationSeconds.toFixed(1)}s`;
 	return `${Math.round(durationSeconds)}s`;
 }
+/**
+* Reconcile a CommandRunSummary from `runViteInstall` with the migration's
+* duration counter and exit-code state. `runViteInstall` returns
+* `{ status: 'failed', exitCode }` without throwing; treating that as a success
+* (incrementing duration unconditionally) would let the migration claim
+* "Dependencies installed" while node_modules is desynced from the just-mutated
+* package.json. This helper centralizes the right handling: credit duration on
+* success, warn + flip exitCode on failure, stay silent on skip.
+*/
+function handleInstallResult(installSummary, rootDir, report, options) {
+	if (installSummary.status === "installed") return installSummary.durationMs;
+	if (installSummary.status === "failed") {
+		const exitCode = installSummary.exitCode ?? 1;
+		const message = `Dependency installation failed (exit code ${exitCode}). Run \`vp install\` manually in ${rootDir} to resync node_modules.`;
+		warnMsg(message);
+		report.warnings.push(message);
+		if (options?.propagateExitCode !== false) process.exitCode = exitCode;
+		return 0;
+	}
+	return 0;
+}
 function showMigrationSummary(options) {
-	const { projectRoot, packageManager, packageManagerVersion, installDurationMs, report, updatedExistingVitePlus } = options;
+	const { projectRoot, packageManager, packageManagerVersion, installDurationMs, finalInstallOk, report, updatedExistingVitePlus } = options;
 	const projectLabel = displayRelative(projectRoot) || ".";
-	const configUpdates = report.createdViteConfigCount + report.mergedConfigCount + report.mergedStagedConfigCount + report.inlinedLintStagedConfigCount + report.removedConfigCount + report.tsdownImportCount;
+	const configUpdates = report.createdViteConfigCount + report.mergedConfigCount + report.mergedStagedConfigCount + report.inlinedLintStagedConfigCount + report.removedConfigCount + report.tsdownImportCount + report.wrappedPluginConfigCount;
 	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 (finalInstallOk && 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`);
@@ -327,8 +425,10 @@ function showMigrationSummary(options) {
 	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.nodeVersionFileMigrated) log$1(`${styleText("gray", "•")} Node version manager file migrated to .node-version`);
+	if (report.wrappedPluginConfigCount > 0) log$1(`${styleText("gray", "•")} Inline Vite plugins wrapped with lazyPlugins for check/lint/fmt`);
 	if (report.gitHooksConfigured) log$1(`${styleText("gray", "•")} Git hooks configured`);
 	if (report.frameworkShimAdded) log$1(`${styleText("gray", "•")} TypeScript shim added for framework component files`);
+	if (report.packageManagerBootstrapConfigured) log$1(`${styleText("gray", "•")} Package manager settings configured`);
 	if (report.warnings.length > 0) {
 		log$1(`${styleText("yellow", "!")} Warnings:`);
 		for (const warning of report.warnings) log$1(`  - ${warning}`);
@@ -341,7 +441,7 @@ function showMigrationSummary(options) {
 async function checkRolldownCompatibility(rootDir, report) {
 	try {
 		const { resolveConfig } = await import("../index.js");
-		const { checkManualChunksCompat } = await import("../compat-DXZgnEyq.js");
+		const { checkManualChunksCompat } = await import("../compat-Cql3K40m.js");
 		checkManualChunksCompat((await resolveConfig({
 			root: rootDir,
 			logLevel: "silent",
@@ -349,6 +449,24 @@ async function checkRolldownCompatibility(rootDir, report) {
 		}, "build")).build?.rollupOptions?.output, report);
 	} catch {}
 }
+async function downloadSupportedPackageManager(options) {
+	const { rootDir, packageManager, packageManagerVersion, interactive, updateMigrationProgress, failMigrationProgress } = options;
+	updateMigrationProgress("Preparing migration");
+	const downloadResult = await downloadPackageManager(packageManager, packageManagerVersion, interactive, true);
+	if (packageManager === PackageManager.yarn && import_semver.default.satisfies(downloadResult.version, ">=4.0.0 <4.10.0")) {
+		updateMigrationProgress("Upgrading Yarn");
+		await upgradeYarn(rootDir, interactive, true);
+	} else if (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")) {
+		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);
+	}
+	return downloadResult;
+}
 async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 	const report = createMigrationReport();
 	const migrationProgress = interactive ? spinner({ indicator: "timer" }) : void 0;
@@ -374,25 +492,19 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 			migrationProgressStarted = false;
 		}
 	};
-	updateMigrationProgress("Preparing migration");
-	const downloadResult = await downloadPackageManager(plan.packageManager, workspaceInfoOptional.packageManagerVersion, interactive, true);
+	const downloadResult = await downloadSupportedPackageManager({
+		rootDir: workspaceInfoOptional.rootDir,
+		packageManager: plan.packageManager,
+		packageManagerVersion: workspaceInfoOptional.packageManagerVersion,
+		interactive,
+		updateMigrationProgress,
+		failMigrationProgress
+	});
 	const workspaceInfo = {
 		...workspaceInfoOptional,
 		packageManager: plan.packageManager,
 		downloadPackageManager: downloadResult
 	};
-	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 (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);
-	}
 	if (plan.migrateNodeVersionFile && plan.nodeVersionDetection) {
 		updateMigrationProgress("Migrating node version file");
 		migrateNodeVersionManagerFile(workspaceInfo.rootDir, plan.nodeVersionDetection, report);
@@ -440,7 +552,7 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 	else rewriteStandaloneProject(workspaceInfo.rootDir, workspaceInfo, skipStagedMigration, true, report);
 	if (plan.shouldSetupHooks) {
 		updateMigrationProgress("Configuring git hooks");
-		installGitHooks(workspaceInfo.rootDir, true, report);
+		installGitHooks(workspaceInfo.rootDir, true, report, plan.packageManager);
 	}
 	updateMigrationProgress("Writing agent instructions");
 	await writeAgentInstructions({
@@ -458,17 +570,8 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 		conflictDecisions: plan.editorConflictDecisions,
 		silent: true
 	});
-	if (plan.frameworkShimFrameworks) {
-		updateMigrationProgress("Adding TypeScript shim");
-		for (const framework of plan.frameworkShimFrameworks) {
-			if (detectFramework(workspaceInfo.rootDir).includes(framework) && !hasFrameworkShim(workspaceInfo.rootDir, framework)) addFrameworkShim(workspaceInfo.rootDir, framework, report);
-			for (const pkg of workspaceInfo.packages) {
-				const pkgPath = path.join(workspaceInfo.rootDir, pkg.path);
-				if (detectFramework(pkgPath).includes(framework) && !hasFrameworkShim(pkgPath, framework)) addFrameworkShim(pkgPath, framework, report);
-			}
-		}
-	}
-	const installArgs = plan.packageManager === PackageManager.npm || plan.packageManager === PackageManager.bun ? ["--force"] : void 0;
+	addFrameworkShimsForWorkspace(workspaceInfo.rootDir, plan.frameworkShimFrameworks, workspaceInfo.packages, report, updateMigrationProgress);
+	const installArgs = plan.packageManager === PackageManager.npm || plan.packageManager === PackageManager.bun ? ["--force"] : ["--no-frozen-lockfile"];
 	updateMigrationProgress("Installing dependencies");
 	const finalInstallSummary = await runViteInstall(workspaceInfo.rootDir, interactive, installArgs, {
 		silent: true,
@@ -477,7 +580,8 @@ async function executeMigrationPlan(workspaceInfoOptional, plan, interactive) {
 	});
 	clearMigrationProgress();
 	return {
-		installDurationMs: initialInstallSummary.durationMs + finalInstallSummary.durationMs,
+		installDurationMs: handleInstallResult(initialInstallSummary, workspaceInfo.rootDir, report, { propagateExitCode: false }) + handleInstallResult(finalInstallSummary, workspaceInfo.rootDir, report),
+		finalInstallOk: finalInstallSummary.status === "installed",
 		packageManagerVersion: downloadResult.version,
 		report
 	};
@@ -492,10 +596,10 @@ async function main() {
 	printHeader();
 	const workspaceInfoOptional = await detectWorkspace(projectPath);
 	const resolvedPackageManager = workspaceInfoOptional.packageManager ?? "unknown";
-	const rootPkg = readNearestPackageJson(workspaceInfoOptional.rootDir);
-	if (hasVitePlusDependency(rootPkg) && !isForceOverrideMode()) {
+	if (hasVitePlusDependency(readNearestPackageJson(workspaceInfoOptional.rootDir)) && !isForceOverrideMode()) {
 		let didMigrate = false;
 		let installDurationMs = 0;
+		let finalInstallOk = true;
 		const report = createMigrationReport();
 		const migrationProgress = options.interactive ? spinner({ indicator: "timer" }) : void 0;
 		let migrationProgressStarted = false;
@@ -514,6 +618,60 @@ async function main() {
 				migrationProgressStarted = false;
 			}
 		};
+		const failMigrationProgress = (message) => {
+			if (migrationProgress && migrationProgressStarted) {
+				migrationProgress.error(message);
+				migrationProgressStarted = false;
+			}
+		};
+		const pendingCoreMigration = detectPendingCoreMigration(workspaceInfoOptional);
+		const legacyGitHooksMigrationCandidate = detectLegacyGitHooksMigrationCandidate(workspaceInfoOptional.rootDir);
+		const vitePlusBootstrapPending = detectVitePlusBootstrapPending(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager);
+		let packageManager = vitePlusBootstrapPending ? workspaceInfoOptional.packageManager ?? await selectPackageManager(options.interactive, true) : workspaceInfoOptional.packageManager;
+		let downloadedPackageManager;
+		let packageManagerVersion = workspaceInfoOptional.packageManagerVersion;
+		const downloadExistingPackageManager = async () => {
+			if (!packageManager) return;
+			downloadedPackageManager ??= await downloadSupportedPackageManager({
+				rootDir: workspaceInfoOptional.rootDir,
+				packageManager,
+				packageManagerVersion,
+				interactive: options.interactive,
+				updateMigrationProgress,
+				failMigrationProgress
+			});
+			packageManagerVersion = downloadedPackageManager.version;
+			return downloadedPackageManager;
+		};
+		const ensureExistingPackageManager = async () => {
+			packageManager ??= await selectPackageManager(options.interactive, true);
+			return downloadExistingPackageManager();
+		};
+		if (vitePlusBootstrapPending) await ensureExistingPackageManager();
+		const coreMigrationResult = finalizeCoreMigrationForExistingVitePlus(workspaceInfoOptional, true, report, pendingCoreMigration);
+		if (coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports) didMigrate = true;
+		if (!didMigrate && report.warnings.length === 0 && !vitePlusBootstrapPending && !hasExistingVitePlusMigrationCandidates(workspaceInfoOptional, options)) {
+			outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
+			return;
+		}
+		const fullMigrationSummary = vitePlusBootstrapPending || coreMigrationResult.scripts || coreMigrationResult.tsconfigTypes || coreMigrationResult.imports;
+		const setupOptions = getExistingVitePlusSetupOptions(options, legacyGitHooksMigrationCandidate, options.interactive && fullMigrationSummary);
+		const plan = await collectMigrationSetupPlan(workspaceInfoOptional.rootDir, packageManager, setupOptions, workspaceInfoOptional.packages);
+		const frameworkShimFrameworks = await collectFrameworkShimFrameworks(workspaceInfoOptional.rootDir, options, workspaceInfoOptional.packages);
+		let needsInstall = false;
+		if (vitePlusBootstrapPending) {
+			const downloadResult = await ensureExistingPackageManager();
+			if (downloadResult && packageManager) {
+				updateMigrationProgress("Configuring package manager");
+				const bootstrapResult = ensureVitePlusBootstrap({
+					...workspaceInfoOptional,
+					packageManager,
+					downloadPackageManager: downloadResult
+				}, report);
+				didMigrate = bootstrapResult.changed || didMigrate;
+				needsInstall = bootstrapResult.changed || needsInstall;
+			}
+		}
 		const fixedBaseUrlProjectPaths = await fixBaseUrlForWorkspace(workspaceInfoOptional, hasBaseUrlInWorkspace(workspaceInfoOptional) ? await confirmBaseUrlFix(options.interactive) : false, updateMigrationProgress, report);
 		if (fixedBaseUrlProjectPaths.length > 0) {
 			updateMigrationProgress("Updating lint defaults");
@@ -521,32 +679,89 @@ async function main() {
 			didMigrate = true;
 		}
 		clearMigrationProgress();
-		const eslintMigrated = await promptEslintMigration(workspaceInfoOptional.rootDir, options.interactive, workspaceInfoOptional.packages);
-		const prettierMigrated = await promptPrettierMigration(workspaceInfoOptional.rootDir, options.interactive, workspaceInfoOptional.packages);
+		let eslintMigrated = false;
+		if (plan.migrateEslint) {
+			await ensureExistingPackageManager();
+			updateMigrationProgress("Migrating ESLint");
+			if (!await migrateEslintToOxlint(workspaceInfoOptional.rootDir, options.interactive, plan.eslintConfigFile, workspaceInfoOptional.packages, {
+				silent: true,
+				report
+			})) {
+				clearMigrationProgress();
+				cancelAndExit("ESLint migration failed. Fix the issue and re-run `vp migrate`.", 1);
+			}
+			eslintMigrated = true;
+		}
+		const prettierProject = detectPrettierProject(workspaceInfoOptional.rootDir, workspaceInfoOptional.packages);
+		let prettierMigrated = false;
+		if (prettierProject.hasDependency && prettierProject.configFile) {
+			if (await confirmPrettierMigration(options.interactive)) {
+				await ensureExistingPackageManager();
+				updateMigrationProgress("Migrating Prettier");
+				if (!await migratePrettierToOxfmt(workspaceInfoOptional.rootDir, options.interactive, prettierProject.configFile, workspaceInfoOptional.packages, {
+					silent: true,
+					report
+				})) {
+					clearMigrationProgress();
+					cancelAndExit("Prettier migration failed. Fix the issue and re-run `vp migrate`.", 1);
+				}
+				prettierMigrated = true;
+			}
+		} else if (prettierProject.hasDependency) warnPackageLevelPrettier();
 		const nodeVersionDetection = detectNodeVersionManagerFile(workspaceInfoOptional.rootDir);
 		if (nodeVersionDetection) {
 			if (await confirmNodeVersionFileMigration(options.interactive, nodeVersionDetection) && migrateNodeVersionManagerFile(workspaceInfoOptional.rootDir, nodeVersionDetection, report)) didMigrate = true;
 		}
+		if (addFrameworkShimsForWorkspace(workspaceInfoOptional.rootDir, frameworkShimFrameworks, workspaceInfoOptional.packages, report, updateMigrationProgress)) didMigrate = true;
 		if (eslintMigrated || prettierMigrated) {
 			updateMigrationProgress("Rewriting configs");
 			mergeViteConfigFiles(workspaceInfoOptional.rootDir, true, report, workspaceInfoOptional.packages);
+			needsInstall = true;
+			didMigrate = true;
+			report.eslintMigrated = eslintMigrated;
+			report.prettierMigrated = prettierMigrated;
+		}
+		if (plan.shouldSetupHooks) {
+			await ensureExistingPackageManager();
+			updateMigrationProgress("Configuring git hooks");
+			if (installGitHooks(workspaceInfoOptional.rootDir, true, report, packageManager)) {
+				didMigrate = true;
+				needsInstall = true;
+			}
+		}
+		if (needsInstall) {
+			const resolved = await ensureExistingPackageManager();
 			updateMigrationProgress("Installing dependencies");
-			let resolvedVersion = workspaceInfoOptional.packageManagerVersion;
-			if (workspaceInfoOptional.packageManager && !import_semver.default.valid(import_semver.default.coerce(resolvedVersion) ?? "")) resolvedVersion = (await downloadPackageManager(workspaceInfoOptional.packageManager, resolvedVersion, options.interactive, true)).version;
-			const installSummary = await runViteInstall(workspaceInfoOptional.rootDir, options.interactive, void 0, {
+			const resolvedVersion = resolved?.version ?? packageManagerVersion;
+			const installSummary = await runViteInstall(workspaceInfoOptional.rootDir, options.interactive, packageManager === PackageManager.npm || packageManager === PackageManager.bun ? ["--force"] : ["--no-frozen-lockfile"], {
 				silent: true,
-				packageManager: workspaceInfoOptional.packageManager,
+				packageManager,
 				packageManagerVersion: resolvedVersion
 			});
-			installDurationMs += installSummary.durationMs;
+			if (installSummary.status === "failed") clearMigrationProgress();
+			installDurationMs += handleInstallResult(installSummary, workspaceInfoOptional.rootDir, report);
+		}
+		if (plan.selectedAgentTargetPaths && plan.selectedAgentTargetPaths.length > 0) {
+			updateMigrationProgress("Writing agent instructions");
+			await writeAgentInstructions({
+				projectRoot: workspaceInfoOptional.rootDir,
+				targetPaths: plan.selectedAgentTargetPaths,
+				interactive: options.interactive,
+				conflictDecisions: plan.agentConflictDecisions,
+				silent: true
+			});
 			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 (plan.selectedEditor) {
+			updateMigrationProgress("Writing editor configs");
+			await writeEditorConfigs({
+				projectRoot: workspaceInfoOptional.rootDir,
+				editorId: plan.selectedEditor,
+				interactive: options.interactive,
+				conflictDecisions: plan.editorConflictDecisions,
+				silent: true
+			});
+			didMigrate = true;
 		}
 		await checkRolldownCompatibility(workspaceInfoOptional.rootDir, report);
 		if (workspaceInfoOptional.packages) for (const pkg of workspaceInfoOptional.packages) await checkRolldownCompatibility(path.join(workspaceInfoOptional.rootDir, pkg.path), report);
@@ -554,13 +769,14 @@ async function main() {
 			clearMigrationProgress();
 			showMigrationSummary({
 				projectRoot: workspaceInfoOptional.rootDir,
-				packageManager: resolvedPackageManager,
-				packageManagerVersion: workspaceInfoOptional.packageManagerVersion,
+				packageManager: packageManager ?? resolvedPackageManager,
+				packageManagerVersion,
 				installDurationMs,
+				finalInstallOk,
 				report,
-				updatedExistingVitePlus: true
+				updatedExistingVitePlus: !fullMigrationSummary
 			});
-		} else outro(`This project is already using Vite+! ${accent(`Happy coding!`)}`);
+		} else outro(`This project is already using Vite+! ${accent("Happy coding!")}`);
 		return;
 	}
 	const plan = await collectMigrationPlan(workspaceInfoOptional.rootDir, workspaceInfoOptional.packageManager, options, workspaceInfoOptional.packages);
@@ -570,6 +786,7 @@ async function main() {
 		packageManager: plan.packageManager,
 		packageManagerVersion: result.packageManagerVersion,
 		installDurationMs: result.installDurationMs,
+		finalInstallOk: result.finalInstallOk,
 		report: result.report
 	});
 }

package/dist/{oxlint-plugin-config-B89iKTKN.js → oxlint-plugin-config-q8a5PFch.js}

@@ -1,4 +1,4 @@
-import { i as VITE_PLUS_NAME } from "./constants-DCBWlNrn.js";
+import { o as VITE_PLUS_NAME } from "./constants-CrfJQIUX.js";
 //#region src/oxlint-plugin-config.ts
 const VITE_PLUS_OXLINT_PLUGIN_NAME = VITE_PLUS_NAME;
 const VITE_PLUS_OXLINT_PLUGIN_SPECIFIER = `${VITE_PLUS_NAME}/oxlint-plugin`;

package/dist/oxlint-plugin.js

@@ -1,17 +1,23 @@
-import { n as VITE_PLUS_OXLINT_PLUGIN_NAME, t as PREFER_VITE_PLUS_IMPORTS_RULE_NAME } from "./oxlint-plugin-config-B89iKTKN.js";
+import { n as VITE_PLUS_OXLINT_PLUGIN_NAME, t as PREFER_VITE_PLUS_IMPORTS_RULE_NAME } from "./oxlint-plugin-config-q8a5PFch.js";
 import { definePlugin, defineRule } from "@oxlint/plugins";
 //#region src/oxlint-plugin.ts
+function isVitestFamilyDeclareModuleSpecifier(specifier) {
+	return specifier === "vitest" || specifier.startsWith("vitest/") || specifier === "@vitest/browser" || specifier.startsWith("@vitest/browser/") || specifier.startsWith("@vitest/browser-");
+}
 function rewriteVitePlusImportSpecifier(specifier) {
 	if (specifier === "vite") return "vite-plus";
 	if (specifier.startsWith("vite/")) return `vite-plus/${specifier.slice(5)}`;
 	if (specifier === "vitest/config") return "vite-plus";
 	if (specifier === "vitest") return "vite-plus/test";
+	if (specifier === "vitest/package.json") return null;
 	if (specifier.startsWith("vitest/")) return `vite-plus/test/${specifier.slice(7)}`;
 	if (specifier === "@vitest/browser") return "vite-plus/test/browser";
 	const browserSubpathRewrites = {
 		"@vitest/browser/context": "vite-plus/test/browser/context",
 		"@vitest/browser/client": "vite-plus/test/client",
-		"@vitest/browser/locators": "vite-plus/test/locators"
+		"@vitest/browser/locators": "vite-plus/test/locators",
+		"@vitest/browser/matchers": "vite-plus/test/matchers",
+		"@vitest/browser/utils": "vite-plus/test/utils"
 	};
 	if (specifier in browserSubpathRewrites) return browserSubpathRewrites[specifier];
 	for (const [prefix, provider] of [
@@ -78,7 +84,9 @@ const preferVitePlusImportsRule = defineRule({
 			},
 			TSModuleDeclaration(node) {
 				if (node.global) return;
-				maybeReportLiteral(context, node.id);
+				const id = node.id;
+				if (id?.type === "Literal" && typeof id.value === "string" && isVitestFamilyDeclareModuleSpecifier(id.value)) return;
+				maybeReportLiteral(context, id);
 			}
 		};
 	}