depfixer 1.0.0 → 1.1.1

package/dist/commands/migrate.js

@@ -0,0 +1,874 @@
+import chalk from 'chalk';
+import { ApiClient } from '../services/api-client.js';
+import { PackageJsonService } from '../services/package-json.js';
+import { SessionManager } from '../services/session-manager.js';
+import { PaymentFlowService } from '../services/payment-flow.js';
+import { analytics } from '../services/analytics.js';
+import { getDeviceId } from '../services/device-id.js';
+import { createSpinner, createMigrationTable, printError, printSuccess, printInfo, runStepSequence, sleep, } from '../utils/output.js';
+import { colors, printCliHeader, printMigrationPlanHeader, printProjectionStats, printCostBox, printSuccessBox, renderHealthBar, getHealthStatus, printUserDetails, } from '../utils/design-system.js';
+/**
+ * Migrate command
+ *
+ * Interactive migration with version selection:
+ * 1. Detect framework and current version
+ * 2. Fetch available versions from server
+ * 3. Show version selector (minor patches vs major upgrades)
+ * 4. User selects target version
+ * 5. Show migration plan with cost
+ * 6. Confirm and execute
+ *
+ * Usage:
+ *   npx depfixer migrate
+ *   npx depfixer migrate --yes
+ */
+export async function migrateCommand(options) {
+    const projectDir = options.path || process.cwd();
+    // Create device ID early (for anonymous user tracking before login)
+    getDeviceId();
+    try {
+        const packageJsonService = new PackageJsonService();
+        const apiClient = new ApiClient();
+        const sessionManager = new SessionManager(projectDir);
+        // Read and sanitize package.json
+        const { content: packageJsonContent, parsed } = await packageJsonService.read(projectDir);
+        const sanitized = packageJsonService.sanitize(parsed);
+        // Detect framework
+        const framework = detectFramework(sanitized);
+        if (!framework) {
+            printError('Could not detect framework. Migration requires Angular or React project.');
+            process.exit(1);
+        }
+        // Detect current version
+        const currentVersion = detectCurrentVersion(sanitized, framework);
+        const currentMajor = currentVersion ? parseInt(currentVersion.split('.')[0], 10) : 0;
+        const frameworkName = framework.charAt(0).toUpperCase() + framework.slice(1);
+        // Print CLI header
+        printCliHeader('migrate');
+        // Track: migrate_started
+        analytics.migrateStarted({ command: 'migrate' });
+        console.log();
+        console.log(colors.whiteBold(`📦 Project: ${colors.brand(sanitized.name || 'unnamed')}`));
+        console.log(colors.dim(`   Framework: ${frameworkName} ${currentVersion || 'unknown'}`));
+        console.log();
+        let targetVersion;
+        // Interactive version selector
+        {
+            const spinner = createSpinner('Fetching available versions...').start();
+            try {
+                const versionsResponse = await apiClient.getFrameworkVersions(framework, currentMajor);
+                // Check if already on latest version (no newer versions available)
+                if (!versionsResponse.success) {
+                    const errorMsg = versionsResponse.error || '';
+                    // If error indicates no newer versions, user is on latest
+                    if (errorMsg.includes('No newer versions') || errorMsg.includes('No supported versions')) {
+                        spinner.succeed('Version check complete');
+                        await showLatestVersionInfo(apiClient, sanitized, framework, frameworkName, currentVersion);
+                        return;
+                    }
+                    spinner.fail('Failed to fetch versions');
+                    throw new Error(errorMsg || 'Could not fetch available versions');
+                }
+                spinner.succeed('Versions loaded');
+                // Track: versions_loaded
+                analytics.versionsLoaded({
+                    framework,
+                    currentVersion,
+                    groupCount: versionsResponse.data?.groups?.length || 0,
+                });
+                const groups = versionsResponse.data?.groups;
+                if (!groups || groups.length === 0) {
+                    await showLatestVersionInfo(apiClient, sanitized, framework, frameworkName, currentVersion);
+                    return;
+                }
+                // Build version options from groups - get latest version from each major
+                const versionOptions = [];
+                for (const group of groups) {
+                    // Get the first (latest) option from each group
+                    const latestInGroup = group.options[0];
+                    if (latestInGroup) {
+                        const major = parseInt(latestInGroup.value.split('.')[0], 10);
+                        const isMajorUpgrade = major > currentMajor;
+                        versionOptions.push({
+                            version: latestInGroup.value,
+                            major,
+                            // Show full version number like "Angular 20.3.15 (Latest)"
+                            label: `${frameworkName} ${latestInGroup.value}` + (latestInGroup.badge ? ` (${latestInGroup.badge})` : ''),
+                            type: isMajorUpgrade ? 'major' : 'minor',
+                            isLatest: latestInGroup.badge === 'Latest',
+                        });
+                    }
+                }
+                // Show version selector
+                console.log();
+                console.log(colors.whiteBold('🎯 Select target version:'));
+                console.log();
+                // Group by type
+                const minorOptions = versionOptions.filter(v => v.type === 'minor');
+                const majorOptions = versionOptions.filter(v => v.type === 'major');
+                if (minorOptions.length > 0) {
+                    console.log(colors.dim('  Minor Patches:'));
+                    for (const opt of minorOptions) {
+                        console.log(colors.brand(`    ${opt.label}`));
+                    }
+                    console.log();
+                }
+                if (majorOptions.length > 0) {
+                    console.log(colors.dim('  Major Upgrades:'));
+                    for (const opt of majorOptions) {
+                        console.log(colors.action(`    ${opt.label}`));
+                    }
+                    console.log();
+                }
+                // Interactive selection
+                const selectedVersion = await selectVersion(versionOptions, frameworkName);
+                if (!selectedVersion) {
+                    console.log();
+                    printInfo('Migration cancelled.');
+                    return;
+                }
+                targetVersion = selectedVersion.version;
+                // Track: version_selected
+                analytics.versionSelected({
+                    framework,
+                    currentVersion,
+                    targetVersion,
+                    isMajorUpgrade: selectedVersion.type === 'major',
+                });
+                console.log();
+                console.log(colors.success(`✓ Selected: ${frameworkName} ${targetVersion}`));
+            }
+            catch (error) {
+                spinner.fail('Failed to fetch versions');
+                throw error;
+            }
+        }
+        // Validate version format if provided directly
+        if (!/^\d+(\.\d+)?(\.\d+)?$/.test(targetVersion)) {
+            printError('Invalid version format. Use major version (e.g., "19") or semver (e.g., "19.0.0")');
+            process.exit(1);
+        }
+        // Step 1: Get cost estimate from server (uses free audit endpoint)
+        const costSpinner = createSpinner('Getting cost estimate...').start();
+        let cost;
+        let tierName;
+        let packageCount;
+        let auditData;
+        try {
+            const auditResponse = await apiClient.analyzeAudit(sanitized, framework);
+            if (!auditResponse.success || !auditResponse.data) {
+                costSpinner.fail('Failed to get cost estimate');
+                throw new Error(auditResponse.error || 'Could not get cost estimate');
+            }
+            auditData = auditResponse.data;
+            cost = auditData.cost;
+            tierName = auditData.tierName;
+            packageCount = auditData.totalPackages;
+            costSpinner.succeed('Cost estimate ready');
+            // Set project context for analytics
+            analytics.setProjectContext({
+                packageCount,
+                framework,
+                frameworkVersion: currentVersion,
+                projectHash: analytics.hashProject(sanitized),
+            });
+            // Track: project_detected
+            analytics.projectDetected({
+                packageCount,
+                framework,
+                currentVersion,
+            });
+        }
+        catch (error) {
+            costSpinner.fail('Failed to get cost estimate');
+            throw error;
+        }
+        // Show project overview with packages to migrate - smooth reveal
+        const healthScore = auditData.healthScore || 0;
+        const healthInfo = getHealthStatus(healthScore);
+        console.log();
+        await sleep(100);
+        console.log(colors.whiteBold('📊 PROJECT OVERVIEW'));
+        await sleep(80);
+        console.log(colors.gray('─'.repeat(50)));
+        await sleep(120);
+        console.log(`${colors.whiteBold('🏥 Health:')}  ${renderHealthBar(healthScore)} ${healthInfo.color.bold(`${healthScore}/100`)} (${healthInfo.color(healthInfo.text)})`);
+        await sleep(100);
+        console.log(`${colors.whiteBold('📦 Packages:')} ${colors.brand(`${packageCount}`)} to migrate`);
+        await sleep(150);
+        console.log();
+        console.log(colors.whiteBold('🚀 MIGRATION PLAN:'));
+        await sleep(80);
+        console.log(colors.dim(`    ${frameworkName} ${currentVersion || '?'} → ${targetVersion}`));
+        await sleep(60);
+        console.log(colors.dim('    All dependencies will be aligned to the target version.'));
+        // Migration highlight box - smooth reveal
+        const targetMajor = parseInt(targetVersion.split('.')[0], 10);
+        const majorJump = targetMajor - currentMajor;
+        await sleep(150);
+        console.log();
+        // Box with 49 visible chars between borders
+        // Using simple ASCII to avoid emoji width issues
+        console.log(colors.brandBold('┌─────────────────────────────────────────────────┐'));
+        await sleep(40);
+        console.log(colors.brandBold('│') + colors.whiteBold('  MIGRATION HIGHLIGHT                            ') + colors.brandBold('│'));
+        await sleep(40);
+        console.log(colors.brandBold('├─────────────────────────────────────────────────┤'));
+        await sleep(60);
+        if (majorJump > 1) {
+            console.log(colors.brandBold('│') + colors.warning(`  ${majorJump} major versions jump - Full ecosystem update `.padEnd(49)) + colors.brandBold('│'));
+        }
+        else if (majorJump === 1) {
+            console.log(colors.brandBold('│') + colors.success('  Single major version upgrade                   ') + colors.brandBold('│'));
+        }
+        else {
+            console.log(colors.brandBold('│') + colors.success('  Minor/patch update - Low risk                  ') + colors.brandBold('│'));
+        }
+        await sleep(50);
+        console.log(colors.brandBold('│') + colors.dim('  - TypeScript alignment included                ') + colors.brandBold('│'));
+        await sleep(50);
+        console.log(colors.brandBold('│') + colors.dim('  - Peer dependency conflicts auto-resolved      ') + colors.brandBold('│'));
+        await sleep(50);
+        console.log(colors.brandBold('│') + colors.dim('  - Deprecated packages flagged for removal      ') + colors.brandBold('│'));
+        await sleep(40);
+        console.log(colors.brandBold('└─────────────────────────────────────────────────┘'));
+        // Payment flow - check auth and balance BEFORE running migration analysis
+        const paymentFlow = new PaymentFlowService();
+        // Step 2: Check authentication
+        console.log();
+        const authResult = await paymentFlow.ensureAuthenticated();
+        if (!authResult.success) {
+            console.log();
+            printInfo('Run `npx depfixer migrate` when ready to continue.');
+            return;
+        }
+        // Get balance info (needed for pass check and user display)
+        const balanceInfo = await paymentFlow.getBalanceInfo();
+        // Show user details if already logged in (if not already shown during login)
+        if (authResult.wasAlreadyLoggedIn && balanceInfo) {
+            printUserDetails({
+                name: balanceInfo.name,
+                email: balanceInfo.email,
+                credits: balanceInfo.credits,
+                hasActivePass: balanceInfo.hasActivePass,
+                showHeader: false,
+            });
+        }
+        console.log();
+        // Step 3: Show cost and confirm payment
+        const hasPass = balanceInfo?.hasActivePass;
+        printCostBox({
+            cost,
+            tierName,
+            prompt: hasPass ? 'Execute migration? (Enter/Esc)' : 'Execute migration? (Enter/Esc)',
+            isMigration: true,
+            hasActivePass: hasPass,
+        });
+        // Track: migration_prompt_shown
+        analytics.migrationPromptShown({
+            creditsNeeded: cost,
+            creditsAvailable: balanceInfo?.credits || 0,
+            tier: tierName,
+            hasActivePass: hasPass,
+            targetVersion,
+        });
+        const shouldExecute = options.yes || await promptYesNo('');
+        if (!shouldExecute) {
+            // Track: migration_rejected
+            analytics.migrationRejected({ reason: 'user_cancelled' });
+            console.log();
+            printInfo('Migration cancelled.');
+            return;
+        }
+        // Track: migration_accepted
+        analytics.migrationAccepted({ creditsDeducted: hasPass ? 0 : cost });
+        // Step 4: Check balance
+        const readyToPay = await paymentFlow.ensureSufficientBalance(cost);
+        if (!readyToPay) {
+            console.log();
+            printInfo('Run `npx depfixer migrate` when ready to continue.');
+            return;
+        }
+        // Step 5: Run migration analysis
+        console.log();
+        console.log(colors.whiteBold(`🔄 Analyzing Migration → ${frameworkName} ${targetVersion}`));
+        console.log(colors.gray('─'.repeat(50)));
+        const packageJsonHash = sessionManager.calculateHash(packageJsonContent);
+        const migrationSteps = [
+            'Analyzing current state...',
+            `Mapping migration path: ${currentVersion || '?'} → ${targetVersion}`,
+            'Checking ecosystem compatibility...',
+            'Calculating optimal versions...',
+            'Resolving dependency conflicts...',
+            'Building migration plan...',
+        ];
+        let response;
+        await runStepSequence(migrationSteps, async () => {
+            response = await apiClient.analyzeMigrate(sanitized, targetVersion, framework);
+            if (!response.success || !response.data) {
+                throw new Error(response.error || 'Unknown error');
+            }
+        }, { successMessage: 'Migration plan ready', minStepDuration: 200 });
+        const data = response.data;
+        const { analysisId } = data;
+        // Track: migration_plan_ready
+        analytics.migrationPlanReady({
+            analysisId,
+            targetVersion,
+            conflictCount: (data.conflicts || []).length,
+        });
+        // Step 6: Deduct credits and get solution (payment happens HERE)
+        const fixResult = await paymentFlow.deductCredits(analysisId, hasPass);
+        if (!fixResult.success || !fixResult.solution) {
+            throw new Error(fixResult.error || 'Unknown error');
+        }
+        // Extract solution for type safety in closures
+        const solution = fixResult.solution;
+        // Save session as PAID
+        await sessionManager.saveSession({
+            analysisId,
+            intent: 'MIGRATE',
+            args: { target: targetVersion },
+            originalFileHash: packageJsonHash,
+            cost,
+            status: 'PAID',
+            projectName: sanitized.name || 'unnamed',
+            packageCount,
+            tierName,
+        });
+        // Step 7: Show FULL migration plan (user already paid)
+        // Get package changes first
+        const changes = packageJsonService.getChanges(parsed, solution);
+        const removals = (solution.removals || []).map(r => ({
+            package: r.package,
+            reason: r.reason || 'Deprecated',
+            type: r.type,
+        }));
+        // Calculate health scores
+        // Use audit healthScore for "before" (already shown in PROJECT OVERVIEW)
+        // Use migration API response for "after" (projected)
+        const currentHealthScore = healthScore; // From auditData (line 215)
+        const projectedHealthScore = typeof data.healthScore === 'object'
+            ? (data.healthScore.after || data.healthScore.projected || 0)
+            : (typeof data.healthScore === 'number' ? data.healthScore : 0);
+        const breakingChanges = (data.conflicts || []).filter((c) => c.severity === 'critical' || c.severity === 'high').length;
+        // Show migration plan header - smooth reveal
+        await sleep(100);
+        printMigrationPlanHeader(frameworkName, currentVersion || '?', targetVersion);
+        // Show projection stats
+        await sleep(150);
+        printProjectionStats({
+            currentHealth: currentHealthScore,
+            projectedHealth: projectedHealthScore,
+            packageCount: changes.length,
+            breakingChanges,
+        });
+        if (changes.length > 0) {
+            await sleep(150);
+            console.log();
+            console.log(colors.whiteBold('📦 Package Updates:'));
+            // Map and sort changes: major at top, then minor, then patch
+            const mappedChanges = changes.map((c) => ({
+                package: c.package,
+                currentVersion: c.from,
+                targetVersion: c.to,
+                changeType: getChangeType(c.from, c.to),
+            }));
+            // Sort by change type: major > minor > patch > none
+            const changeTypeOrder = { major: 0, minor: 1, patch: 2, none: 3 };
+            mappedChanges.sort((a, b) => {
+                const orderA = changeTypeOrder[a.changeType] ?? 3;
+                const orderB = changeTypeOrder[b.changeType] ?? 3;
+                return orderA - orderB;
+            });
+            // Show table rows with smooth reveal
+            const tableLines = createMigrationTable(mappedChanges).split('\n');
+            for (const line of tableLines) {
+                console.log(line);
+                await sleep(30);
+            }
+        }
+        // Show engine requirements (from solution.engines)
+        if (solution.engines && Object.keys(solution.engines).length > 0) {
+            await sleep(100);
+            console.log();
+            console.log(colors.whiteBold('⚙️  Engine Requirements:'));
+            if (solution.engines.node) {
+                console.log(`   ${colors.dim('•')} Node.js: ${colors.brand(solution.engines.node)}`);
+            }
+            if (solution.engines.npm) {
+                console.log(`   ${colors.dim('•')} npm: ${colors.brand(solution.engines.npm)}`);
+            }
+        }
+        // Show packages to add (missing peer dependencies)
+        const packagesToAdd = (data.conflicts || []).filter((c) => !c.currentVersion || c.currentVersion.toLowerCase() === 'not installed');
+        if (packagesToAdd.length > 0) {
+            await sleep(100);
+            console.log();
+            console.log(colors.whiteBold('📦 Packages to Add:'));
+            for (const pkg of packagesToAdd) {
+                await sleep(60);
+                // Build message from requiredBy if available
+                let message;
+                if (pkg.requiredBy && Array.isArray(pkg.requiredBy) && pkg.requiredBy.length > 0) {
+                    const requiredRange = pkg.requiredRange || 'required version';
+                    message = `Required as peer dependency by ${pkg.requiredBy.join(', ')} (${requiredRange})`;
+                }
+                else if (pkg.isPeerDependency && pkg.requiredRange) {
+                    message = `Missing peer dependency (${pkg.requiredRange})`;
+                }
+                else {
+                    message = pkg.description || 'Required dependency';
+                }
+                console.log(`   ${colors.brand('+')} ${pkg.package}`);
+                console.log(`     ${colors.dim(message)}`);
+            }
+        }
+        // Show packages to remove (using table format)
+        if (removals.length > 0) {
+            await sleep(100);
+            console.log();
+            console.log(colors.whiteBold('🗑  Packages to Remove:'));
+            const removalLines = createMigrationTable(removals.map(r => ({
+                package: r.package,
+                currentVersion: '*',
+                targetVersion: 'REMOVE',
+                changeType: 'deprec',
+                isRemoval: true,
+            }))).split('\n');
+            for (const line of removalLines) {
+                console.log(line);
+                await sleep(30);
+            }
+        }
+        // Step 8: Ask to apply (FREE - already paid)
+        await sleep(200);
+        console.log();
+        // Explain what will be changed
+        console.log(colors.gray('────────────────────────────────────────'));
+        await sleep(50);
+        console.log(colors.gray('  📝 Only ') + colors.white('package.json') + colors.gray(' will be modified'));
+        await sleep(50);
+        console.log(colors.gray('  💾 A backup (') + colors.white('package.json.bak') + colors.gray(') will be created'));
+        await sleep(50);
+        console.log(colors.gray('────────────────────────────────────────'));
+        await sleep(100);
+        console.log();
+        // Track: migration_apply_prompt
+        analytics.migrationApplyPrompt({
+            changeCount: changes.length,
+            removalCount: removals.length,
+        });
+        console.log(colors.gray('[?] Apply changes now? (Enter/Esc)'));
+        const shouldApplyFix = options.yes || await promptYesNo('');
+        if (!shouldApplyFix) {
+            // Track: migration_deferred
+            analytics.migrationDeferred({ reason: 'user_declined_apply' });
+            console.log();
+            printInfo('Solution saved. Run `npx depfixer fix` anytime to apply.');
+            return;
+        }
+        // Step 9: Apply fix (FREE) - smooth reveal
+        await sleep(150);
+        console.log();
+        console.log(colors.whiteBold(`🔧 Applying Migration...`));
+        await sleep(80);
+        console.log(colors.gray('─'.repeat(50)));
+        const upgradeCount = changes.length;
+        const removalCount = removals.length;
+        const migrationFixSteps = [
+            'Reading package.json...',
+            `Applying ${upgradeCount} upgrade${upgradeCount !== 1 ? 's' : ''}...`,
+            'Resolving peer conflicts...',
+            removalCount > 0 ? `Removing ${removalCount} deprecated package${removalCount !== 1 ? 's' : ''}...` : 'Checking for deprecated packages...',
+            'Validating final state...',
+            'Writing package.json...',
+        ];
+        let applyResult;
+        await sleep(100);
+        await runStepSequence(migrationFixSteps, async () => {
+            applyResult = await packageJsonService.applySurgicalFixes(projectDir, changes, removals, solution.engines);
+        }, { successMessage: 'Migration complete', minStepDuration: 150 });
+        const { backupPath, applied, removed, enginesUpdated } = applyResult;
+        // Show success using design system - smooth reveal
+        await sleep(200);
+        printSuccessBox({
+            updated: applied,
+            removed,
+            backupPath,
+            enginesUpdated,
+        });
+        // Track: migration_applied
+        analytics.migrationApplied({
+            updatedCount: applied,
+            removedCount: removed,
+            enginesUpdated,
+            targetVersion,
+        });
+        // Track: session_ended (successful migration)
+        await analytics.sessionEnded({
+            outcome: 'migration_applied',
+            targetVersion,
+        });
+    }
+    catch (error) {
+        // Track: session_ended (error)
+        await analytics.sessionEnded({
+            outcome: 'error',
+            error: error.message,
+        });
+        printError(error.message);
+        process.exit(1);
+    }
+}
+/**
+ * Interactive version selector using arrow keys
+ */
+async function selectVersion(options, frameworkName) {
+    // Auto-select first option in dev mode when env var is set
+    if (isAutoConfirmEnabled() && options.length > 0) {
+        console.log(`${colors.dim('  Auto-selecting:')} ${colors.brand(options[0].label)} ${colors.dim('[auto]')}`);
+        return options[0];
+    }
+    return new Promise((resolve) => {
+        let selectedIndex = 0;
+        const render = () => {
+            // Move cursor up and clear previous render
+            if (selectedIndex > 0 || options.length > 0) {
+                process.stdout.write(`\x1b[${options.length + 2}A`);
+            }
+            console.log(colors.dim('  Use ↑↓ arrows to select, Enter to confirm, Esc to cancel'));
+            console.log();
+            for (let i = 0; i < options.length; i++) {
+                const opt = options[i];
+                const isSelected = i === selectedIndex;
+                const prefix = isSelected ? colors.brand('❯ ') : '  ';
+                const color = opt.type === 'major' ? colors.action : colors.brand;
+                const label = isSelected ? chalk.bold(color(opt.label)) : colors.dim(opt.label);
+                console.log(`${prefix}${label}`);
+            }
+        };
+        // Initial render
+        console.log(colors.dim('  Use ↑↓ arrows to select, Enter to confirm, Esc to cancel'));
+        console.log();
+        for (let i = 0; i < options.length; i++) {
+            const opt = options[i];
+            const isSelected = i === selectedIndex;
+            const prefix = isSelected ? colors.brand('❯ ') : '  ';
+            const color = opt.type === 'major' ? colors.action : colors.brand;
+            const label = isSelected ? chalk.bold(color(opt.label)) : colors.dim(opt.label);
+            console.log(`${prefix}${label}`);
+        }
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        const onKeyPress = (key) => {
+            const char = key.toString();
+            // Up arrow
+            if (char === '\x1b[A') {
+                selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+                render();
+            }
+            // Down arrow
+            else if (char === '\x1b[B') {
+                selectedIndex = (selectedIndex + 1) % options.length;
+                render();
+            }
+            // Enter
+            else if (char === '\r' || char === '\n') {
+                cleanup();
+                resolve(options[selectedIndex]);
+            }
+            // Escape
+            else if (char === '\x1b' && key.length === 1) {
+                cleanup();
+                resolve(null);
+            }
+            // Ctrl+C
+            else if (char === '\x03') {
+                cleanup();
+                process.exit(0);
+            }
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('data', onKeyPress);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+        };
+        process.stdin.on('data', onKeyPress);
+    });
+}
+/**
+ * Check if auto-confirm is enabled (dev mode only)
+ */
+function isAutoConfirmEnabled() {
+    const isDevMode = process.env.NODE_ENV === 'development' ||
+        (process.env.DEPFIXER_API_URL?.includes('localhost') ?? false);
+    return isDevMode && process.env.DEPFIXER_AUTO_CONFIRM === 'true';
+}
+/**
+ * Simple Enter/Esc prompt (Enter = Yes, Esc = No)
+ */
+async function promptYesNo(question) {
+    // Auto-confirm in dev mode when env var is set
+    if (isAutoConfirmEnabled()) {
+        if (question) {
+            console.log(`${question} ${colors.dim('(Enter/Esc)')} ${colors.success('Yes')} ${colors.dim('[auto]')}`);
+        }
+        else {
+            console.log(`${colors.success('Yes')} ${colors.dim('[auto]')}`);
+        }
+        return true;
+    }
+    return new Promise((resolve) => {
+        if (question) {
+            process.stdout.write(`${question} ${colors.dim('(Enter/Esc)')} `);
+        }
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        const onKeyPress = (key) => {
+            const char = key.toString();
+            if (char === '\r' || char === '\n') {
+                cleanup();
+                console.log(colors.success('Yes'));
+                resolve(true);
+            }
+            else if (char === '\x1b') {
+                cleanup();
+                console.log(colors.danger('No'));
+                resolve(false);
+            }
+            else if (char.toLowerCase() === 'y') {
+                cleanup();
+                console.log(colors.success('Yes'));
+                resolve(true);
+            }
+            else if (char.toLowerCase() === 'n') {
+                cleanup();
+                console.log(colors.danger('No'));
+                resolve(false);
+            }
+            else if (char === '\x03') {
+                cleanup();
+                process.exit(0);
+            }
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('data', onKeyPress);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+        };
+        process.stdin.on('data', onKeyPress);
+    });
+}
+/**
+ * Simple client-side framework detection
+ */
+function detectFramework(pkg) {
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps['@angular/core'])
+        return 'angular';
+    if (deps['react'])
+        return 'react';
+    if (deps['vue'])
+        return 'vue';
+    if (deps['svelte'])
+        return 'svelte';
+    if (deps['next'])
+        return 'react';
+    if (deps['nuxt'])
+        return 'vue';
+    return undefined;
+}
+/**
+ * Detect current framework version
+ */
+function detectCurrentVersion(pkg, framework) {
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    switch (framework) {
+        case 'angular':
+            return extractVersion(deps['@angular/core']);
+        case 'react':
+            return extractVersion(deps['react']);
+        case 'vue':
+            return extractVersion(deps['vue']);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Extract clean version from semver string
+ */
+function extractVersion(version) {
+    if (!version)
+        return undefined;
+    const cleaned = version.replace(/[~^]/g, '');
+    return cleaned;
+}
+/**
+ * Determine change type for migration display
+ */
+function getChangeType(current, target) {
+    if (!current || !target)
+        return 'none';
+    const currentMajor = parseInt(current.replace(/[~^]/g, '').split('.')[0], 10);
+    const targetMajor = parseInt(target.replace(/[~^]/g, '').split('.')[0], 10);
+    if (isNaN(currentMajor) || isNaN(targetMajor))
+        return 'none';
+    if (targetMajor > currentMajor)
+        return 'major';
+    const currentMinor = parseInt(current.replace(/[~^]/g, '').split('.')[1] || '0', 10);
+    const targetMinor = parseInt(target.replace(/[~^]/g, '').split('.')[1] || '0', 10);
+    if (targetMinor > currentMinor)
+        return 'minor';
+    return 'patch';
+}
+/**
+ * Get meaningful reason for migration
+ */
+function getMigrationReason(packageName, framework) {
+    // Core framework packages
+    if (framework === 'angular') {
+        if (packageName.startsWith('@angular/')) {
+            return 'Core framework';
+        }
+        if (packageName === 'zone.js') {
+            return 'Angular requirement';
+        }
+        if (packageName === 'rxjs') {
+            return 'Angular dependency';
+        }
+        if (packageName === 'typescript') {
+            return 'Build requirement';
+        }
+    }
+    if (framework === 'react') {
+        if (packageName === 'react' || packageName === 'react-dom') {
+            return 'Core framework';
+        }
+        if (packageName.startsWith('@types/react')) {
+            return 'Type definitions';
+        }
+    }
+    // Type definitions
+    if (packageName.startsWith('@types/')) {
+        return 'Type definitions';
+    }
+    // Build tools
+    if (['typescript', 'webpack', 'esbuild', 'vite', 'rollup'].includes(packageName)) {
+        return 'Build tool';
+    }
+    // Testing
+    if (['jest', 'karma', 'jasmine', 'mocha', 'vitest'].some(t => packageName.includes(t))) {
+        return 'Testing';
+    }
+    // Linting
+    if (packageName.includes('eslint') || packageName.includes('prettier')) {
+        return 'Code quality';
+    }
+    return 'Compatibility';
+}
+/**
+ * Wrap text at specified width
+ */
+function wrapText(text, maxWidth) {
+    if (!text)
+        return [];
+    const words = text.split(' ');
+    const lines = [];
+    let currentLine = '';
+    for (const word of words) {
+        if (currentLine.length + word.length + 1 <= maxWidth) {
+            currentLine += (currentLine ? ' ' : '') + word;
+        }
+        else {
+            if (currentLine)
+                lines.push(currentLine);
+            currentLine = word;
+        }
+    }
+    if (currentLine)
+        lines.push(currentLine);
+    return lines;
+}
+/**
+ * Create teaser table (limited info, no solutions)
+ * Shows only severity and package name with generic issue type
+ */
+function createTeaserTable(conflicts) {
+    const lines = [];
+    lines.push(colors.gray('┌────────────┬─────────────────────────┬────────────────┐'));
+    lines.push(colors.gray('│') + colors.whiteBold('  SEVERITY  ') + colors.gray('│') + colors.whiteBold('  PACKAGE                ') + colors.gray('│') + colors.whiteBold('  ISSUE          ') + colors.gray('│'));
+    lines.push(colors.gray('├────────────┼─────────────────────────┼────────────────┤'));
+    for (const conflict of conflicts) {
+        const severity = conflict.severity?.toUpperCase() || 'UNKNOWN';
+        const severityColor = severity === 'CRITICAL' ? colors.dangerBold :
+            severity === 'HIGH' ? colors.danger :
+                severity === 'MEDIUM' ? colors.warning :
+                    colors.dim;
+        // Truncate package name if too long
+        const pkg = (conflict.package || '').substring(0, 23).padEnd(23);
+        // Generic issue description (no details)
+        const issueType = severity === 'CRITICAL' ? 'Peer Clash' :
+            severity === 'HIGH' ? 'Version Gap' :
+                severity === 'MEDIUM' ? 'Conflict' : 'Minor';
+        lines.push(colors.gray('│') +
+            `  ${severityColor(severity.padEnd(10))}` +
+            colors.gray('│') +
+            `  ${pkg}` +
+            colors.gray('│') +
+            `  ${issueType.padEnd(14)}` +
+            colors.gray('│'));
+    }
+    lines.push(colors.gray('└────────────┴─────────────────────────┴────────────────┘'));
+    return lines.join('\n');
+}
+/**
+ * Show project info when already on latest version
+ */
+async function showLatestVersionInfo(apiClient, sanitized, framework, frameworkName, currentVersion) {
+    // Get audit data for health info
+    try {
+        const auditResponse = await apiClient.analyzeAudit(sanitized, framework);
+        if (auditResponse.success && auditResponse.data) {
+            const healthScore = auditResponse.data.healthScore || 0;
+            const packageCount = auditResponse.data.totalPackages || 0;
+            const conflicts = auditResponse.data.conflicts || [];
+            const issueCount = conflicts.length;
+            const healthInfo = getHealthStatus(healthScore);
+            console.log();
+            console.log(colors.whiteBold('📊 PROJECT OVERVIEW'));
+            console.log(colors.gray('─'.repeat(50)));
+            console.log(`${colors.whiteBold('🏥 Health:')}  ${renderHealthBar(healthScore)} ${healthInfo.color.bold(`${healthScore}/100`)} (${healthInfo.color(healthInfo.text)})`);
+            console.log(`${colors.whiteBold('📦 Packages:')} ${colors.brand(`${packageCount}`)} total`);
+            console.log(`${colors.whiteBold('🎯 Version:')} ${colors.success(`${frameworkName} ${currentVersion || 'latest'}`)}`);
+            console.log();
+            console.log(colors.successBold('✓ You\'re already on the latest supported version!'));
+            console.log(colors.dim('  No migration needed.'));
+            // If there are issues, suggest running analyze
+            if (issueCount > 0) {
+                console.log();
+                console.log(colors.warningBold(`⚠️  ${issueCount} issue${issueCount !== 1 ? 's' : ''} detected in your dependencies`));
+                console.log(colors.dim('  Run the following command to analyze and fix:'));
+                console.log();
+                console.log(`  ${colors.brand('npx depfixer')}`);
+            }
+        }
+        else {
+            console.log();
+            printSuccess(`You're already on the latest supported version of ${frameworkName}!`);
+        }
+    }
+    catch {
+        console.log();
+        printSuccess(`You're already on the latest supported version of ${frameworkName}!`);
+    }
+}
+//# sourceMappingURL=migrate.js.map