depfixer 1.0.0 → 1.1.1

package/dist/commands/smart.js

@@ -0,0 +1,1024 @@
+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 { AuthManager } from '../services/auth-manager.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, renderHealthBar, getHealthStatus, printCostBox, printSuccessBox, printProjectHeader, printDiagnosis, printUserDetails, printCreditCheck, } from '../utils/design-system.js';
+/**
+ * Smart command (DEFAULT)
+ *
+ * The main funnel:
+ * 1. Run audit analysis (FREE)
+ * 2. Show issues with cost
+ * 3. Prompt to pay and fix
+ * 4. If YES: auth → balance check → pay → apply fix
+ * 5. If NO: Save to session, user can run `fix` later
+ *
+ * Usage:
+ *   npx depfixer
+ *   npx depfixer --yes
+ */
+export async function smartCommand(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);
+        const frameworkInfo = framework ? `${framework.charAt(0).toUpperCase() + framework.slice(1)}` : '';
+        // ================== CI MODE ==================
+        // CI mode uses dedicated endpoint with API key or JWT auth
+        // Returns complete analysis for pass/fail pipeline decisions
+        if (options.ci) {
+            const authManager = new AuthManager();
+            const authHeader = await authManager.getAuthHeader();
+            if (!authHeader) {
+                // No authentication available
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: false,
+                        error: 'Authentication required for CI mode',
+                        help: 'Set DEPFIXER_TOKEN environment variable',
+                        docs: 'https://depfixer.com/docs/ci-setup',
+                    }, null, 2));
+                }
+                else {
+                    console.log();
+                    console.log(chalk.red('  Authentication required for CI mode'));
+                    console.log();
+                    console.log(chalk.bold('  Setup:'));
+                    console.log('    1. Get API token: https://app.depfixer.com/dashboard/api-keys');
+                    console.log('    2. Add to GitHub Secrets as DEPFIXER_TOKEN');
+                    console.log('    3. Use in workflow:');
+                    console.log();
+                    console.log(chalk.dim('       - run: npx depfixer --ci'));
+                    console.log(chalk.dim('         env:'));
+                    console.log(chalk.dim('           DEPFIXER_TOKEN: ${{ secrets.DEPFIXER_TOKEN }}'));
+                    console.log();
+                }
+                process.exit(2);
+            }
+            // Call CI endpoint (full analysis with API key auth)
+            try {
+                const ciResponse = await apiClient.analyzeForCi(sanitized, framework);
+                if (!ciResponse.success || !ciResponse.data) {
+                    if (options.json) {
+                        console.log(JSON.stringify({ success: false, error: ciResponse.error || 'CI analysis failed' }, null, 2));
+                    }
+                    else {
+                        console.log(chalk.red(`  ${ciResponse.error || 'CI analysis failed'}`));
+                    }
+                    process.exit(2);
+                }
+                const ciData = ciResponse.data;
+                const issueCount = ciData.summary.critical + ciData.summary.high + ciData.summary.medium + ciData.summary.low;
+                // JSON output for CI pipelines (machine-readable)
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        mode: 'ci',
+                        analysisId: ciData.analysisId,
+                        healthScore: ciData.healthScore,
+                        totalPackages: ciData.totalPackages,
+                        summary: ciData.summary,
+                        issueCount,
+                        conflicts: ciData.conflicts,
+                        framework: ciData.framework,
+                        requiresAttention: ciData.requiresAttention,
+                    }, null, 2));
+                    process.exit(ciData.requiresAttention ? 1 : 0);
+                }
+                // Human-readable output for CI logs
+                console.log();
+                console.log(chalk.bold('  CI Mode - Dependency Analysis'));
+                console.log(chalk.dim('  ' + '─'.repeat(40)));
+                console.log(`  Health Score: ${ciData.healthScore}/100`);
+                console.log(`  Total Packages: ${ciData.totalPackages}`);
+                console.log(`  Issues Found: ${issueCount}`);
+                if (ciData.summary.critical > 0)
+                    console.log(chalk.red(`    Critical: ${ciData.summary.critical}`));
+                if (ciData.summary.high > 0)
+                    console.log(chalk.yellow(`    High: ${ciData.summary.high}`));
+                if (ciData.summary.medium > 0)
+                    console.log(chalk.blue(`    Medium: ${ciData.summary.medium}`));
+                if (ciData.summary.low > 0)
+                    console.log(chalk.dim(`    Low: ${ciData.summary.low}`));
+                console.log();
+                if (ciData.requiresAttention) {
+                    console.log(chalk.red('  Pipeline should fail - critical/high issues detected'));
+                    process.exit(1);
+                }
+                else if (issueCount > 0) {
+                    console.log(chalk.yellow('  Minor issues detected (medium/low severity)'));
+                    process.exit(0);
+                }
+                else {
+                    console.log(chalk.green('  No dependency issues found'));
+                    process.exit(0);
+                }
+            }
+            catch (ciError) {
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: ciError.message }, null, 2));
+                }
+                else {
+                    console.log(chalk.red(`  CI analysis failed: ${ciError.message}`));
+                }
+                process.exit(2);
+            }
+            return; // CI mode exits above, this is just for type safety
+        }
+        // ================== END CI MODE ==================
+        // Print CLI header (skip for JSON output)
+        if (!options.json) {
+            printCliHeader();
+        }
+        // Track: analyze_started
+        analytics.analyzeStarted({ command: 'smart' });
+        // Print project info (skip for JSON output)
+        if (!options.json) {
+            printProjectHeader(sanitized.name || 'unnamed', frameworkInfo);
+        }
+        // Calculate package.json hash for integrity check
+        const packageJsonHash = sessionManager.calculateHash(packageJsonContent);
+        // Analysis steps - enough to cover ~3-4 seconds before showing elapsed time
+        const analysisSteps = [
+            'Parsing dependency tree...',
+            `Detecting framework...${frameworkInfo ? ` ${frameworkInfo}` : ''}`,
+            'Loading compatibility matrix...',
+            'Scanning package versions...',
+            'Resolving peer dependencies...',
+            'Checking version constraints...',
+            'Analyzing transitive dependencies...',
+            'Detecting breaking changes...',
+            'Evaluating deprecation status...',
+            'Calculating version intersections...',
+            'Checking cross-package rules...',
+            'Generating recommendations...',
+        ];
+        let response;
+        // First phase: Initial API call
+        if (options.json) {
+            // Silent mode for JSON output
+            response = await apiClient.analyzeAudit(sanitized, framework);
+            if (!response.success || !response.data) {
+                throw new Error(response.error || 'Unknown error');
+            }
+        }
+        else {
+            // Steps cycle through at 300ms each (~3.6s total), then show elapsed time for large projects
+            await runStepSequence(analysisSteps, async () => {
+                response = await apiClient.analyzeAudit(sanitized, framework);
+                if (!response.success || !response.data) {
+                    throw new Error(response.error || 'Unknown error');
+                }
+            }, { successMessage: null, minStepDuration: 300 });
+        }
+        let data = response.data;
+        const { analysisId, prefetchId, hasPendingPackages } = data;
+        // Set project context for analytics
+        analytics.setProjectContext({
+            packageCount: data.totalPackages,
+            framework: data.framework?.name,
+            frameworkVersion: data.framework?.version,
+            projectHash: analytics.hashProject(sanitized),
+        });
+        // Track: project_detected
+        analytics.projectDetected({
+            packageCount: data.totalPackages,
+            framework: data.framework?.name,
+        });
+        // Audit mode: instant results from cache (no polling)
+        // Background re-analysis happens server-side automatically
+        // Polling will happen AFTER unlock when user is authenticated
+        if (!options.json) {
+            console.log(chalk.green('  ✓ Analysis complete'));
+        }
+        // Get cost from server response (database-driven tier pricing)
+        const cost = data.cost;
+        const tierName = data.tierName;
+        const packageCount = data.totalPackages;
+        // JSON output mode (no interactive prompts, clean output only)
+        // Note: CI mode with --json is handled earlier in the function
+        if (options.json) {
+            const issueCount = data.summary.critical + data.summary.high + data.summary.medium + data.summary.low;
+            const output = {
+                mode: 'audit',
+                analysisId,
+                healthScore: data.healthScore,
+                totalPackages: data.totalPackages,
+                summary: data.summary,
+                issueCount,
+                conflicts: data.conflicts,
+                framework: data.framework,
+                cost,
+                tierName,
+                hasCriticalIssues: data.summary.critical > 0,
+                hasHighIssues: data.summary.high > 0,
+                requiresAttention: data.summary.critical > 0 || data.summary.high > 0,
+            };
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        // Pretty output - TEASER MODE (locked until payment)
+        const issueCount = data.summary.critical + data.summary.high + data.summary.medium + data.summary.low;
+        const healthInfo = getHealthStatus(data.healthScore);
+        // Smooth reveal of analysis report
+        console.log();
+        await sleep(100);
+        console.log(colors.whiteBold('📊 ANALYSIS REPORT'));
+        await sleep(80);
+        console.log(colors.gray('─'.repeat(50)));
+        await sleep(120);
+        console.log(`${colors.whiteBold('🏥 Health:')}  ${renderHealthBar(data.healthScore)} ${healthInfo.color.bold(`${data.healthScore}/100`)} (${healthInfo.color(healthInfo.text)})`);
+        // Track: analysis_completed
+        analytics.analysisCompleted({
+            healthScore: data.healthScore,
+            issueCount,
+            criticalCount: data.summary.critical,
+            highCount: data.summary.high,
+        });
+        // Check if there are issues to fix FIRST
+        if (issueCount === 0) {
+            await sleep(100);
+            console.log();
+            printSuccess('No issues found! Your dependencies are healthy.');
+            // Check if migration is available (not on latest version)
+            if (data.framework?.name && data.framework?.version) {
+                try {
+                    const currentMajor = parseInt(data.framework.version.split('.')[0], 10);
+                    const versionsResponse = await apiClient.getFrameworkVersions(data.framework.name, currentMajor);
+                    if (versionsResponse.success && versionsResponse.data) {
+                        // Find the recommended/latest version
+                        const recommended = versionsResponse.data.quickOptions?.find(opt => opt.isRecommended);
+                        const latestMajor = recommended ? parseInt(recommended.value, 10) : null;
+                        if (latestMajor && latestMajor > currentMajor) {
+                            const versionsBehind = latestMajor - currentMajor;
+                            console.log();
+                            console.log(colors.whiteBold('💡 WHY NOT 100%?'));
+                            console.log(colors.dim(`    Your ${data.framework.name} version is `) + colors.warning(`${versionsBehind} major version${versionsBehind > 1 ? 's' : ''} behind`) + colors.dim(' the latest.'));
+                            console.log(colors.dim(`    This affects your health score even without dependency conflicts.`));
+                            console.log();
+                            console.log(colors.whiteBold('    👉 UPGRADE:'));
+                            console.log(`       Run ${colors.brand('npx depfixer migrate')} to upgrade to ${data.framework.name} ${latestMajor}.`);
+                        }
+                    }
+                }
+                catch {
+                    // Silently ignore - migration suggestion is optional
+                }
+            }
+            console.log();
+            return;
+        }
+        await sleep(100);
+        console.log(`${colors.whiteBold('⚠️  Issues:')}  ${colors.dangerBold(`${issueCount}`)} Conflicts Found`);
+        await sleep(150);
+        console.log();
+        // Show LIMITED preview - protect small conflict counts from bypass
+        if (data.conflicts && data.conflicts.length > 0) {
+            // Filter out "not installed" packages from audit display
+            const installedConflicts = data.conflicts.filter((c) => c.currentVersion && c.currentVersion.toLowerCase() !== 'not installed');
+            const missingPackagesCount = data.conflicts.length - installedConflicts.length;
+            if (installedConflicts.length <= 3) {
+                // For small conflict counts, only show severity summary - no package names
+                // This prevents users from easily bypassing with AI
+                await sleep(80);
+                const W = 50; // Inner width
+                const row = (label, colorFn, count, desc) => {
+                    const issueWord = count > 1 ? 'issues' : 'issue';
+                    const content = `  ${label.padEnd(10)}${count} ${issueWord} ${desc}`;
+                    console.log(colors.gray('│') + colorFn(content.padEnd(W)) + colors.gray('│'));
+                };
+                console.log(colors.gray('┌' + '─'.repeat(W) + '┐'));
+                console.log(colors.gray('│') + colors.whiteBold('  SEVERITY BREAKDOWN'.padEnd(W)) + colors.gray('│'));
+                console.log(colors.gray('├' + '─'.repeat(W) + '┤'));
+                if (data.summary.critical > 0)
+                    row('CRITICAL', colors.dangerBold, data.summary.critical, 'require attention');
+                if (data.summary.high > 0)
+                    row('HIGH', colors.danger, data.summary.high, 'with compatibility problems');
+                if (data.summary.medium > 0)
+                    row('MEDIUM', colors.warning, data.summary.medium, 'with version conflicts');
+                if (data.summary.low > 0)
+                    row('LOW', colors.dim, data.summary.low, 'to review');
+                console.log(colors.gray('└' + '─'.repeat(W) + '┘'));
+                await sleep(80);
+                // Show hint about missing packages if any
+                if (missingPackagesCount > 0) {
+                    console.log(colors.dim(`    + ${missingPackagesCount} missing peer ${missingPackagesCount > 1 ? 'dependencies' : 'dependency'} to install.`));
+                }
+                console.log(colors.dim('    Unlock to see details and recommended fixes.'));
+            }
+            else {
+                // For larger counts, show first 2 installed packages only
+                const tableLines = createTeaserTable(installedConflicts.slice(0, 2)).split('\n');
+                for (const line of tableLines) {
+                    console.log(line);
+                    await sleep(40);
+                }
+                await sleep(80);
+                const hiddenCount = installedConflicts.length - 2;
+                if (hiddenCount > 0) {
+                    console.log(colors.dim(`    + ${hiddenCount} other conflicts hidden.`));
+                }
+                // Show hint about missing packages if any
+                if (missingPackagesCount > 0) {
+                    console.log(colors.dim(`    + ${missingPackagesCount} missing peer ${missingPackagesCount > 1 ? 'dependencies' : 'dependency'} to install.`));
+                }
+            }
+        }
+        // Diagnosis section with smooth reveal
+        await sleep(150);
+        printDiagnosis(issueCount);
+        // Save session for potential later fix
+        await sessionManager.saveSession({
+            analysisId,
+            intent: 'ANALYZE',
+            originalFileHash: packageJsonHash,
+            cost,
+            status: 'UNPAID',
+            projectName: sanitized.name || 'unnamed',
+            packageCount,
+            tierName,
+        });
+        // Check if user is already logged in
+        const authManager = new AuthManager();
+        const isAlreadyLoggedIn = await authManager.isAuthenticated();
+        const paymentFlow = new PaymentFlowService();
+        // Track if user has active pass (set in both branches)
+        let userHasActivePass = false;
+        if (isAlreadyLoggedIn) {
+            // User is logged in - show account details and credit check
+            const balanceInfo = await paymentFlow.getBalanceInfo();
+            userHasActivePass = balanceInfo?.hasActivePass || false;
+            // Show user details
+            printUserDetails({
+                name: balanceInfo?.name,
+                email: balanceInfo?.email,
+                credits: balanceInfo?.credits || 0,
+                hasActivePass: userHasActivePass,
+                showHeader: false,
+            });
+            // Show credit check (needed vs available)
+            printCreditCheck({
+                needed: cost,
+                available: balanceInfo?.credits || 0,
+                hasActivePass: userHasActivePass,
+            });
+            // Cost box with prompt
+            printCostBox({
+                cost,
+                tierName,
+                prompt: userHasActivePass ? 'Continue? (Enter/Esc)' : `Deduct ${cost} credit${cost > 1 ? 's' : ''} to unlock? (Enter/Esc)`,
+                hasActivePass: userHasActivePass,
+            });
+            // Track: unlock_prompt_shown
+            analytics.unlockPromptShown({
+                creditsNeeded: cost,
+                creditsAvailable: balanceInfo?.credits || 0,
+                tier: tierName,
+                hasActivePass: userHasActivePass,
+            });
+            // Single prompt with cost info
+            const confirmUnlock = options.yes || await promptYesNo('' // Prompt already shown in cost box
+            );
+            if (!confirmUnlock) {
+                // Track: unlock_rejected
+                analytics.unlockRejected({ reason: 'user_cancelled' });
+                console.log();
+                printInfo('Solution saved. Run `npx depfixer fix` anytime to resume.');
+                return;
+            }
+            // Track: unlock_accepted
+            analytics.unlockAccepted({ creditsDeducted: userHasActivePass ? 0 : cost });
+            // Check balance is sufficient
+            if (!userHasActivePass && (balanceInfo?.credits || 0) < cost) {
+                // Track: unlock_failed (insufficient credits, but user will try to top up)
+                analytics.unlockFailed({
+                    reason: 'insufficient_credits',
+                    needed: cost,
+                    available: balanceInfo?.credits || 0,
+                });
+                const hasBalance = await paymentFlow.ensureSufficientBalance(cost);
+                if (!hasBalance) {
+                    console.log();
+                    printInfo('Run `npx depfixer fix` when ready to continue.');
+                    return;
+                }
+                // After top-up, show cost box again and confirm
+                printCostBox({
+                    cost,
+                    tierName,
+                    prompt: `Deduct ${cost} credit${cost > 1 ? 's' : ''} to unlock? (Enter/Esc)`,
+                });
+                const confirmAfterTopUp = options.yes || await promptYesNo('');
+                if (!confirmAfterTopUp) {
+                    console.log();
+                    printInfo('Solution saved. Run `npx depfixer fix` anytime to resume.');
+                    return;
+                }
+            }
+        }
+        else {
+            // User not logged in - show cost box and login prompt
+            printCostBox({
+                cost,
+                tierName,
+                prompt: '',
+            });
+            // Track: unlock_prompt_shown (anonymous user)
+            analytics.unlockPromptShown({
+                creditsNeeded: cost,
+                creditsAvailable: 0,
+                tier: tierName,
+                isAnonymous: true,
+            });
+            // Track: auth_required
+            analytics.authRequired({ creditsNeeded: cost });
+            console.log();
+            console.log(colors.warning('⚠️  Login required to unlock'));
+            console.log(colors.gray('[?] Continue to login? (Enter/Esc)'));
+            const wantsToUnlock = options.yes || await promptYesNo('');
+            if (!wantsToUnlock) {
+                // Track: auth_abandoned
+                analytics.authAbandoned({ reason: 'user_cancelled' });
+                console.log();
+                printInfo('Solution saved. Run `npx depfixer fix` anytime to resume.');
+                return;
+            }
+            // Run full auth + balance flow (shows user details after login)
+            const paymentResult = await paymentFlow.ensureReadyToPay(cost);
+            if (!paymentResult.ready) {
+                // Track: auth_abandoned (failed to complete auth/balance)
+                analytics.authAbandoned({ reason: 'auth_flow_incomplete' });
+                console.log();
+                printInfo('Run `npx depfixer fix` when ready to continue.');
+                return;
+            }
+            userHasActivePass = paymentResult.hasActivePass || false;
+            // Confirm after login (user details already shown by ensureReadyToPay)
+            printCostBox({
+                cost,
+                tierName,
+                prompt: userHasActivePass ? 'Continue? (Enter/Esc)' : `Confirm: Deduct ${cost} credit${cost > 1 ? 's' : ''}? (Enter/Esc)`,
+                hasActivePass: userHasActivePass,
+            });
+            const confirmUnlock = options.yes || await promptYesNo('');
+            if (!confirmUnlock) {
+                // Track: unlock_rejected (after login)
+                analytics.unlockRejected({ reason: 'user_cancelled_after_login' });
+                console.log();
+                printInfo('Solution saved. Run `npx depfixer fix` anytime to resume.');
+                return;
+            }
+            // Track: unlock_accepted (after login flow)
+            analytics.unlockAccepted({ creditsDeducted: userHasActivePass ? 0 : cost });
+        }
+        // Step 5: Deduct credits and get solution
+        const fixResult = await paymentFlow.deductCredits(analysisId, userHasActivePass);
+        if (!fixResult.success || !fixResult.solution) {
+            throw new Error(fixResult.error || 'Unknown error');
+        }
+        // Update session status
+        await sessionManager.updateStatus('PAID');
+        // If there were pending packages, poll until re-analysis completes
+        // User is now authenticated, so polling works
+        if (hasPendingPackages && prefetchId) {
+            const spinner = createSpinner('Finalizing complete analysis...').start();
+            let pollCount = 0;
+            const maxPolls = 120; // 2 minutes max
+            while (pollCount < maxPolls) {
+                try {
+                    const status = await apiClient.pollPrefetchStatus(prefetchId);
+                    if (status.isComplete && status.reanalysisStatus === 'completed') {
+                        // Re-fetch complete data from DB
+                        const updatedResponse = await apiClient.getAnalysisById(analysisId);
+                        if (updatedResponse.success && updatedResponse.data) {
+                            const updated = updatedResponse.data;
+                            const analysisResult = updated.analysisResult || {};
+                            // Update fixResult with fresh data from re-analysis
+                            fixResult.conflicts = analysisResult.conflicts || fixResult.conflicts;
+                            fixResult.missingDependencies = analysisResult.missingDependencies || fixResult.missingDependencies;
+                            fixResult.deprecations = analysisResult.deprecations || fixResult.deprecations;
+                            fixResult.healthScore = analysisResult.healthScore || fixResult.healthScore;
+                            if (analysisResult.conflicts) {
+                                fixResult.summary = calculateSummary(analysisResult.conflicts);
+                            }
+                        }
+                        break;
+                    }
+                    // Update spinner with progress
+                    if (status.percentage !== undefined) {
+                        const percent = Math.round(status.percentage);
+                        spinner.text = `Finalizing complete analysis... ${percent}%`;
+                    }
+                    await sleep(1000);
+                    pollCount++;
+                }
+                catch (err) {
+                    // Network error - retry
+                    await sleep(2000);
+                    pollCount++;
+                }
+            }
+            spinner.succeed('Complete analysis ready');
+        }
+        // Update data with full unfiltered results from DB
+        if (fixResult.conflicts) {
+            data = {
+                ...data,
+                conflicts: fixResult.conflicts,
+                missingDependencies: fixResult.missingDependencies,
+                deprecations: fixResult.deprecations,
+                healthScore: fixResult.healthScore,
+                summary: fixResult.summary,
+            };
+        }
+        // Extract solution for type safety in closures
+        const solution = fixResult.solution;
+        // Step 6: Show FULL analysis with solutions (recommended versions) - smooth reveal
+        console.log();
+        await sleep(100);
+        console.log(chalk.bold.green('🔓 FULL ANALYSIS'));
+        await sleep(80);
+        console.log(chalk.dim('─'.repeat(50)));
+        await sleep(120);
+        console.log();
+        // Separate package conflicts from engine conflicts
+        const packageConflicts = data.conflicts.filter((c) => c.package !== 'Node.js' && c.package !== 'npm' && c.category !== 'engine');
+        const engineConflicts = data.conflicts.filter((c) => c.package === 'Node.js' || c.package === 'npm' || c.category === 'engine');
+        // Show full table with recommended versions - row by row (only if there are package conflicts)
+        if (packageConflicts.length > 0) {
+            const fullTableLines = createFullSolutionTable(packageConflicts, solution).split('\n');
+            for (const line of fullTableLines) {
+                console.log(line);
+                await sleep(35);
+            }
+            console.log();
+        }
+        // 1. Show engine requirements first (from solution.engines)
+        if (solution.engines && Object.keys(solution.engines).length > 0) {
+            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)}`);
+            }
+            console.log();
+        }
+        else if (engineConflicts.length > 0) {
+            // Fallback to conflict data if solution.engines is empty
+            console.log(colors.whiteBold('⚙️  Engine Requirements:'));
+            for (const ec of engineConflicts) {
+                const engine = ec.package || 'Unknown';
+                let required = ec.recommendedVersion || ec.requiredVersion;
+                if (!required && ec.engineDetails?.requiredVersion) {
+                    required = ec.engineDetails.requiredVersion.replace(/^>=/, '');
+                }
+                if (required) {
+                    console.log(`   ${colors.dim('•')} ${engine}: ${colors.brand('>=' + required)}`);
+                }
+            }
+            console.log();
+        }
+        // 2. Show packages to add (not installed)
+        const packagesToAdd = packageConflicts.filter((c) => !c.currentVersion || c.currentVersion.toLowerCase() === 'not installed');
+        if (packagesToAdd.length > 0) {
+            console.log(colors.whiteBold('📦 Packages to Add:'));
+            for (const pkg of packagesToAdd) {
+                await sleep(60);
+                // Build message from requiredBy if available, otherwise fallback
+                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)}`);
+            }
+            console.log();
+        }
+        // 3. Show removals
+        if (solution.removals && solution.removals.length > 0) {
+            await sleep(100);
+            console.log(colors.whiteBold('🗑  Packages to Remove:'));
+            const removalLines = createMigrationTable(solution.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);
+            }
+            console.log();
+        }
+        // If no package conflicts and no removals, show a message
+        if (packageConflicts.length === 0 && (!solution.removals || solution.removals.length === 0)) {
+            console.log(colors.dim('   No package version changes needed.'));
+            console.log();
+        }
+        // Track: results_shown (full solution visible)
+        analytics.resultsShown({
+            conflictCount: data.conflicts.length,
+            removalsCount: solution.removals?.length || 0,
+        });
+        // Step 7: Ask to apply fix
+        // Explain what will be changed
+        await sleep(100);
+        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: fix_prompt_shown
+        analytics.fixPromptShown({
+            updatesCount: Object.keys(solution.dependencies || {}).length + Object.keys(solution.devDependencies || {}).length,
+            removalsCount: solution.removals?.length || 0,
+        });
+        const shouldApply = options.yes || await promptYesNo('Apply fix to package.json?');
+        if (!shouldApply) {
+            // Track: fix_deferred
+            analytics.fixDeferred({ reason: 'user_declined' });
+            console.log();
+            printInfo('Solution unlocked but not applied. Run `npx depfixer fix` to apply later.');
+            return;
+        }
+        // Track: fix_accepted
+        analytics.fixAccepted();
+        // Step 8: Apply the solution surgically (preserves formatting)
+        console.log();
+        console.log(chalk.bold('🔧 Applying fixes...'));
+        console.log();
+        // Get changes list for surgical update
+        const changes = packageJsonService.getChanges(parsed, solution);
+        // Map removals to the format expected by applySurgicalFixes
+        const removals = (solution.removals || []).map(r => ({
+            package: r.package,
+            reason: r.reason || 'Deprecated',
+            type: r.type,
+        }));
+        // Fix steps
+        const fixSteps = [
+            'Reading package.json...',
+            'Calculating safe versions...',
+            `Updating dependencies...`,
+            `Updating devDependencies...`,
+            'Validating changes...',
+            'Writing package.json...',
+        ];
+        let fixResult2;
+        await runStepSequence(fixSteps, async () => {
+            fixResult2 = await packageJsonService.applySurgicalFixes(projectDir, changes, removals, solution.engines);
+        }, { successMessage: 'Fix complete', minStepDuration: 100 });
+        const { backupPath, applied, removed, enginesUpdated } = fixResult2;
+        // Show success
+        printSuccessBox({
+            updated: applied,
+            removed,
+            backupPath,
+            enginesUpdated,
+        });
+        // Track: fix_applied
+        analytics.fixApplied({
+            updatedCount: applied,
+            removedCount: removed,
+            enginesUpdated,
+        });
+        // Track: session_ended (successful completion)
+        await analytics.sessionEnded({
+            outcome: 'fix_applied',
+            healthScore: data.healthScore,
+        });
+        // Note: No exit(1) here - fixes were applied successfully
+        // CI mode already exits early before interactive prompts
+    }
+    catch (error) {
+        // Track: session_ended (error)
+        await analytics.sessionEnded({
+            outcome: 'error',
+            error: error.message,
+        });
+        if (options.json) {
+            console.log(JSON.stringify({ error: error.message }, null, 2));
+        }
+        else {
+            printError(error.message);
+        }
+        process.exit(options.ci ? 2 : 1);
+    }
+}
+/**
+ * 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();
+            // Enter key
+            if (char === '\r' || char === '\n') {
+                cleanup();
+                console.log(chalk.green('Yes'));
+                resolve(true);
+            }
+            // Escape key
+            else if (char === '\x1b') {
+                cleanup();
+                console.log(chalk.red('No'));
+                resolve(false);
+            }
+            // 'y' or 'Y'
+            else if (char.toLowerCase() === 'y') {
+                cleanup();
+                console.log(chalk.green('Yes'));
+                resolve(true);
+            }
+            // 'n' or 'N'
+            else if (char.toLowerCase() === 'n') {
+                cleanup();
+                console.log(chalk.red('No'));
+                resolve(false);
+            }
+            // 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);
+    });
+}
+/**
+ * Apply fixes to package.json
+ */
+function applyFixes(original, solution) {
+    const updated = JSON.parse(JSON.stringify(original)); // Deep clone
+    // Update dependencies
+    if (solution.dependencies) {
+        for (const [pkg, version] of Object.entries(solution.dependencies)) {
+            if (updated.dependencies?.[pkg]) {
+                updated.dependencies[pkg] = version;
+            }
+        }
+    }
+    // Update devDependencies
+    if (solution.devDependencies) {
+        for (const [pkg, version] of Object.entries(solution.devDependencies)) {
+            if (updated.devDependencies?.[pkg]) {
+                updated.devDependencies[pkg] = version;
+            }
+        }
+    }
+    // Remove deprecated packages
+    if (solution.removals) {
+        for (const removal of solution.removals) {
+            if (removal.type === 'dependency') {
+                delete updated.dependencies?.[removal.package];
+            }
+            else {
+                delete updated.devDependencies?.[removal.package];
+            }
+        }
+    }
+    return updated;
+}
+/**
+ * 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;
+}
+/**
+ * Calculate severity summary from conflicts array
+ */
+function calculateSummary(conflicts) {
+    return {
+        critical: conflicts.filter(c => c.severity === 'critical').length,
+        high: conflicts.filter(c => c.severity === 'high').length,
+        medium: conflicts.filter(c => c.severity === 'medium').length,
+        low: conflicts.filter(c => c.severity === 'low').length,
+    };
+}
+/**
+ * Wrap text to specified width
+ */
+function wrapText(text, maxWidth) {
+    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) {
+    // Column widths
+    const COL1 = 12; // SEVERITY
+    const COL2 = 30; // PACKAGE
+    const COL3 = 14; // ISSUE
+    const TOTAL_WIDTH = COL1 + COL2 + COL3;
+    const lines = [];
+    // Header row
+    lines.push(colors.whiteBold('SEVERITY'.padEnd(COL1)) +
+        colors.whiteBold('PACKAGE'.padEnd(COL2)) +
+        colors.whiteBold('ISSUE'.padEnd(COL3)));
+    // Single separator line
+    lines.push(colors.gray('─'.repeat(TOTAL_WIDTH)));
+    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, COL2 - 1).padEnd(COL2);
+        // Generic issue description (no details)
+        const issueType = severity === 'CRITICAL' ? 'Peer Clash' :
+            severity === 'HIGH' ? 'Version Gap' :
+                severity === 'MEDIUM' ? 'Conflict' : 'Minor';
+        lines.push(severityColor(severity.padEnd(COL1)) +
+            pkg +
+            issueType);
+    }
+    return lines.join('\n');
+}
+/**
+ * Create full solution table (shows recommended versions and removals)
+ * Clean design: simple headers with dash separator line
+ */
+function createFullSolutionTable(conflicts, solution) {
+    // Column widths
+    const COL1 = 35; // PACKAGE
+    const COL2 = 14; // CURRENT
+    const COL3 = 14; // TARGET
+    const COL4 = 10; // TYPE
+    const TOTAL_WIDTH = COL1 + COL2 + COL3 + COL4;
+    const lines = [];
+    // Header row
+    lines.push(colors.whiteBold('PACKAGE'.padEnd(COL1)) +
+        colors.whiteBold('CURRENT'.padEnd(COL2)) +
+        colors.whiteBold('TARGET'.padEnd(COL3)) +
+        colors.whiteBold('TYPE'.padEnd(COL4)));
+    // Single separator line
+    lines.push(colors.gray('─'.repeat(TOTAL_WIDTH)));
+    // Merge solution deps
+    const allSolutions = { ...solution.dependencies, ...solution.devDependencies };
+    // Separate conflicts into updates vs adds
+    const updates = [];
+    const adds = [];
+    for (const conflict of conflicts) {
+        const recommended = allSolutions[conflict.package] || conflict.recommendedVersion || '';
+        const currentRaw = conflict.currentVersion || '';
+        const isNotInstalled = !currentRaw || currentRaw.toLowerCase() === 'not installed';
+        if (isNotInstalled) {
+            // Package to add
+            adds.push({ conflict, recommended });
+        }
+        else if (recommended) {
+            // Package to update - determine change type
+            let changeType = 'patch';
+            const cleanCurrent = currentRaw.replace(/[~^]/g, '');
+            const cleanRec = recommended.replace(/[~^]/g, '');
+            const currMajor = parseInt(cleanCurrent.split('.')[0], 10);
+            const recMajor = parseInt(cleanRec.split('.')[0], 10);
+            if (!isNaN(currMajor) && !isNaN(recMajor)) {
+                if (recMajor > currMajor)
+                    changeType = 'major';
+                else if (recMajor === currMajor) {
+                    const currMinor = parseInt(cleanCurrent.split('.')[1] || '0', 10);
+                    const recMinor = parseInt(cleanRec.split('.')[1] || '0', 10);
+                    if (recMinor > currMinor)
+                        changeType = 'minor';
+                }
+            }
+            updates.push({ conflict, recommended, changeType });
+        }
+        // Skip if no recommendation and already installed
+    }
+    // Render updates first
+    for (const { conflict, recommended, changeType } of updates) {
+        const pkg = (conflict.package || '').substring(0, COL1 - 1).padEnd(COL1);
+        let currentRaw = (conflict.currentVersion || '').replace(/[~^]/g, '').substring(0, COL2 - 1);
+        if (currentRaw.toLowerCase() === 'installed')
+            currentRaw = '—';
+        const currentPadded = currentRaw.padEnd(COL2);
+        const recommendedClean = recommended.replace(/[~^]/g, '').substring(0, COL3 - 1);
+        const recommendedPadded = recommendedClean.padEnd(COL3);
+        const typeLabel = changeType === 'major' ? 'Major' :
+            changeType === 'minor' ? 'Minor' : 'Patch';
+        const typeColor = changeType === 'major' ? colors.danger :
+            changeType === 'minor' ? colors.warning : colors.success;
+        lines.push(pkg +
+            colors.versionOld(currentPadded) +
+            colors.version(recommendedPadded) +
+            typeColor(typeLabel));
+    }
+    // Render adds
+    for (const { conflict, recommended } of adds) {
+        const pkg = (conflict.package || '').substring(0, COL1 - 1).padEnd(COL1);
+        const currentPadded = '—'.padEnd(COL2);
+        const recommendedClean = recommended ? recommended.replace(/[~^]/g, '').substring(0, COL3 - 1) : 'Add';
+        const recommendedPadded = recommendedClean.padEnd(COL3);
+        lines.push(pkg +
+            colors.dim(currentPadded) +
+            colors.version(recommendedPadded) +
+            colors.brand('+ Add'));
+    }
+    // Render removals
+    if (solution.removals && solution.removals.length > 0) {
+        for (const removal of solution.removals) {
+            const pkg = (removal.package || '').substring(0, COL1 - 1).padEnd(COL1);
+            const currentPadded = 'installed'.padEnd(COL2);
+            const targetPadded = '—'.padEnd(COL3);
+            lines.push(pkg +
+                colors.versionOld(currentPadded) +
+                colors.dim(targetPadded) +
+                colors.danger('Remove'));
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=smart.js.map