depfixer 1.1.8 → 1.2.0

package/dist/commands/check.js

@@ -0,0 +1,742 @@
+/**
+ * Check Command
+ *
+ * Pre-install compatibility check: verify if packages are compatible
+ * with your project's framework before installing them.
+ *
+ * Usage:
+ *   npx depfixer check react                 # interactive: pick major, then exact
+ *   npx depfixer check react@19              # interactive: pick exact 19.x
+ *   npx depfixer check react@19.1.0          # direct check (no prompts)
+ *   npx depfixer check react@19 react-dom@19 # multi-package: auto-resolve + confirm
+ *   npx depfixer check @emotion/react@11 --json
+ *   npx depfixer check react@19 --path ./my-app
+ *   npx depfixer check react --yes           # skip all prompts, pick latest
+ */
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { ApiClient, NetworkError } from '../services/api-client.js';
+import { PackageJsonService } from '../services/package-json.js';
+import { detectFramework } from '../services/framework-detector.js';
+import { parsePackageSpec } from '../utils/package-parser.js';
+import { createSpinner, printError, printSuccess, printInfo, printWarning, } from '../utils/output.js';
+import { colors, printCliHeader, printSectionHeader, } from '../utils/design-system.js';
+import { pickOne } from '../utils/interactive-picker.js';
+import { promptYesNo } from '../utils/prompt.js';
+export async function checkCommand(packages, options, command) {
+    // Merge global options (--json, --path, --yes declared on program) into local options
+    // so users can pass these flags naturally: `depfixer check pkg@1 --json`
+    if (command?.parent) {
+        const globalOpts = command.parent.opts() || {};
+        options = { ...globalOpts, ...options };
+    }
+    const projectDir = options.path || process.cwd();
+    // Show header unless JSON mode
+    if (!options.json) {
+        printCliHeader();
+        console.log();
+    }
+    try {
+        // 1. Parse each package spec
+        const pendingSpecs = parsePackageSpecs(packages, options.json);
+        if (pendingSpecs.length === 0) {
+            return;
+        }
+        // 2. Read local package.json
+        const packageJsonService = new PackageJsonService();
+        let packageJson;
+        try {
+            const { parsed } = await packageJsonService.read(projectDir);
+            packageJson = parsed;
+        }
+        catch (err) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: false,
+                    error: err.message,
+                }));
+            }
+            else {
+                printError(err.message);
+                printInfo('Run this command from a directory with a package.json, or use --path <dir>');
+            }
+            process.exit(1);
+            return;
+        }
+        // 3. Detect framework + version from package.json
+        const framework = detectFramework(packageJson);
+        if (!framework) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: false,
+                    error: 'Could not detect a supported framework (Angular, React, or Vue) in your package.json',
+                }));
+            }
+            else {
+                printError('Could not detect a supported framework in your package.json');
+                printInfo('Supported frameworks: Angular, React, Vue');
+                printInfo('Make sure your package.json has the framework as a dependency');
+            }
+            process.exit(1);
+            return;
+        }
+        if (!options.json) {
+            printInfo(`Detected ${chalk.bold(framework.name)} v${chalk.bold(framework.version)} from ${chalk.dim(framework.detectedFrom)}`);
+            console.log();
+        }
+        // 3b. Framework-self check (only if a version was explicitly provided).
+        // If no version was provided, the user is asking us to resolve — fall through to resolution.
+        const frameworkSelfCheck = pendingSpecs.find(p => isFrameworkPackage(p.name, framework.name) &&
+            p.version && !isSameMajor(p.version, framework.version));
+        if (frameworkSelfCheck) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: false,
+                    error: `You're checking ${frameworkSelfCheck.name}@${frameworkSelfCheck.version} against your own ${framework.name} ${framework.version}. Use 'depfixer migrate ${framework.name}@${frameworkSelfCheck.version}' for a full migration analysis.`,
+                    suggestion: `depfixer migrate ${framework.name}@${frameworkSelfCheck.version}`,
+                }));
+            }
+            else {
+                printWarning(`You're checking ${chalk.bold(frameworkSelfCheck.name + '@' + frameworkSelfCheck.version)} against your own ${framework.name} ${framework.version}`);
+                console.log();
+                printInfo(`For framework upgrades, use ${chalk.bold('migrate')} — it ${chalk.bold('previews')} the upgrade and shows:`);
+                console.log(`  ${chalk.dim('• Which packages will break')}`);
+                console.log(`  ${chalk.dim('• Breaking changes & migration steps')}`);
+                console.log(`  ${chalk.dim('• Recommended versions')}`);
+                console.log();
+                console.log(`  ${colors.brand('npx depfixer migrate')}  ${chalk.dim('# read-only analysis — does NOT modify your code')}`);
+                console.log(`  ${colors.brand('npx depfixer fix')}      ${chalk.dim('# applies the changes after you review them')}`);
+                console.log();
+                printInfo(`The ${chalk.bold('check')} command is for third-party packages (e.g. ${chalk.dim('react-router, @emotion/react')}).`);
+            }
+            process.exit(1);
+            return;
+        }
+        // 4. Version resolution phase
+        const apiClient = new ApiClient();
+        let resolved;
+        try {
+            resolved = await resolveVersions(pendingSpecs, apiClient, options);
+        }
+        catch (err) {
+            if (err instanceof NetworkError) {
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: err.message }));
+                }
+                else {
+                    printError(err.message);
+                }
+            }
+            else {
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: err.message }));
+                }
+                else {
+                    printError(err.message || 'Failed to resolve package versions');
+                }
+            }
+            process.exit(1);
+            return;
+        }
+        if (resolved.length === 0) {
+            // Cancelled by user
+            if (!options.json) {
+                printInfo('Cancelled.');
+            }
+            process.exit(1);
+            return;
+        }
+        // 5. Call API: POST /compatibility/check-exact
+        const spinner = options.json ? null : createSpinner('Checking compatibility...').start();
+        let result;
+        try {
+            result = await apiClient.checkCompatibility(resolved.map(p => ({ name: p.name, version: p.version })), framework.name, framework.version);
+        }
+        catch (err) {
+            if (spinner)
+                spinner.fail('Compatibility check failed');
+            if (err instanceof NetworkError) {
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: err.message }));
+                }
+                else {
+                    printError(err.message);
+                }
+            }
+            else {
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: err.message }));
+                }
+                else {
+                    printError(err.message || 'Failed to check compatibility');
+                }
+            }
+            process.exit(1);
+            return;
+        }
+        if (spinner) {
+            spinner.stop();
+        }
+        if (!result.success) {
+            if (options.json) {
+                console.log(JSON.stringify(result));
+            }
+            else {
+                printError(result.reason || result.error || 'Compatibility check failed');
+            }
+            process.exit(1);
+            return;
+        }
+        // 6. Display results
+        const finalPackages = resolved.map(r => ({ name: r.name, version: r.version }));
+        if (options.json) {
+            printJsonOutput(result, framework, finalPackages);
+        }
+        else {
+            printHumanOutput(result, framework, finalPackages);
+        }
+        // Exit with code 1 if any package is incompatible (useful for CI)
+        if (!result.compatible) {
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: err.message }));
+        }
+        else {
+            printError(err.message);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Resolve pending specs into exact versions.
+ *
+ * Single package:
+ *   - no version → pick major, pick exact
+ *   - partial (no patch) → pick exact within major
+ *   - exact → pass through
+ *
+ * Multi package:
+ *   - auto-resolve partials to latest matching
+ *   - show resolution summary + confirmation (unless --yes / --json)
+ */
+async function resolveVersions(pendingSpecs, apiClient, options) {
+    const isSingle = pendingSpecs.length === 1;
+    if (isSingle) {
+        return resolveSinglePackage(pendingSpecs[0], apiClient, options);
+    }
+    return resolveMultiPackage(pendingSpecs, apiClient, options);
+}
+async function resolveSinglePackage(spec, apiClient, options) {
+    // Exact version → pass through
+    if (spec.version && isExactVersion(spec.version)) {
+        return [{
+                name: spec.name,
+                version: normalizeVersion(spec.version),
+                originalVersion: spec.version,
+                wasResolved: false,
+            }];
+    }
+    // --json mode: must have exact version
+    if (options.json) {
+        throw new Error(`Version required in --json mode for ${spec.name}. Provide an exact version like ${spec.name}@1.2.3`);
+    }
+    // --yes mode: auto-pick latest matching (or overall latest)
+    if (options.yes) {
+        const resolved = await autoResolveLatest(spec, apiClient);
+        printInfo(`Auto-resolved ${chalk.bold(spec.name + '@' + (spec.version || 'latest'))} → ${chalk.bold(resolved)}`);
+        console.log();
+        return [{
+                name: spec.name,
+                version: resolved,
+                originalVersion: spec.version,
+                wasResolved: true,
+            }];
+    }
+    // Interactive path
+    let major;
+    if (spec.version) {
+        // Partial version: extract major, skip major picker
+        const parsedMajor = parseMajor(spec.version);
+        if (parsedMajor === null) {
+            throw new Error(`Invalid version "${spec.version}" for ${spec.name}`);
+        }
+        major = parsedMajor;
+    }
+    else {
+        // No version: show major picker
+        const majorResponse = await apiClient.getPackageMajors(spec.name);
+        if (!majorResponse.success || !majorResponse.data) {
+            throw new Error(majorResponse.error || `No versions found for ${spec.name}`);
+        }
+        const majors = majorResponse.data.majors;
+        if (majors.length === 0) {
+            throw new Error(`No versions available for ${spec.name}`);
+        }
+        // Auto-skip major picker when only one major exists
+        if (majors.length === 1) {
+            major = majors[0].major;
+            printInfo(`Only one major version available: ${chalk.bold(major)}`);
+            console.log();
+        }
+        else {
+            const choices = majors.map((m) => {
+                const parts = [];
+                if (m.latest)
+                    parts.push(`latest: ${m.latest}`);
+                parts.push(`${m.count} version${m.count !== 1 ? 's' : ''}`);
+                if (m.deprecated)
+                    parts.push(chalk.red('deprecated'));
+                if (m.isLatest)
+                    parts.push(chalk.green('current'));
+                return {
+                    label: `${m.major}`,
+                    value: m.major,
+                    hint: `(${parts.join(', ')})`,
+                };
+            });
+            const picked = await pickOne(`Pick major version for ${chalk.bold(spec.name)}:`, choices);
+            if (picked === null)
+                return [];
+            major = picked;
+        }
+    }
+    // Now pick exact version within the major
+    const versionsResponse = await apiClient.getPackageVersionsForMajor(spec.name, major);
+    if (!versionsResponse.success || !versionsResponse.data) {
+        throw new Error(versionsResponse.error || `No ${major}.x versions found for ${spec.name}`);
+    }
+    const versions = versionsResponse.data.versions;
+    if (versions.length === 0) {
+        throw new Error(`No ${major}.x versions available for ${spec.name}`);
+    }
+    // Auto-skip version picker when only one version exists
+    if (versions.length === 1) {
+        const only = versions[0].version;
+        printInfo(`Only one ${major}.x version available: ${chalk.bold(only)}`);
+        console.log();
+        return [{
+                name: spec.name,
+                version: only,
+                originalVersion: spec.version,
+                wasResolved: true,
+            }];
+    }
+    const versionChoices = versions.map((v) => {
+        const hints = [];
+        if (v.isLatest)
+            hints.push(chalk.green('latest'));
+        if (v.deprecated)
+            hints.push(chalk.red('deprecated'));
+        if (v.publishedAt) {
+            const date = v.publishedAt.slice(0, 10);
+            hints.push(colors.dim(date));
+        }
+        return {
+            label: v.version,
+            value: v.version,
+            hint: hints.length > 0 ? `(${hints.join(', ')})` : undefined,
+        };
+    });
+    const pickedVersion = await pickOne(`Pick exact ${major}.x version for ${chalk.bold(spec.name)}:`, versionChoices);
+    if (pickedVersion === null)
+        return [];
+    return [{
+            name: spec.name,
+            version: pickedVersion,
+            originalVersion: spec.version,
+            wasResolved: true,
+        }];
+}
+async function resolveMultiPackage(pendingSpecs, apiClient, options) {
+    const resolvedList = [];
+    const resolutionLog = [];
+    for (const spec of pendingSpecs) {
+        if (spec.version && isExactVersion(spec.version)) {
+            resolvedList.push({
+                name: spec.name,
+                version: normalizeVersion(spec.version),
+                originalVersion: spec.version,
+                wasResolved: false,
+            });
+            continue;
+        }
+        if (options.json) {
+            throw new Error(`Version required in --json mode for ${spec.name}. Provide an exact version like ${spec.name}@1.2.3`);
+        }
+        const resolved = await autoResolveLatest(spec, apiClient);
+        resolvedList.push({
+            name: spec.name,
+            version: resolved,
+            originalVersion: spec.version,
+            wasResolved: true,
+        });
+        resolutionLog.push({
+            original: `${spec.name}@${spec.version || 'latest'}`,
+            resolved: `${spec.name}@${resolved}`,
+        });
+    }
+    // If nothing was auto-resolved, no need to show summary or confirm
+    if (resolutionLog.length === 0) {
+        return resolvedList;
+    }
+    if (options.json) {
+        // Already threw above for missing versions; exact-only multi falls through here.
+        return resolvedList;
+    }
+    // Show resolution summary
+    console.log(colors.brand('Auto-resolving partial versions:'));
+    for (const entry of resolutionLog) {
+        console.log(`  ${chalk.green('✓')} ${entry.original} → ${chalk.bold(entry.resolved)}`);
+    }
+    console.log();
+    // Skip confirmation in --yes mode
+    if (options.yes) {
+        return resolvedList;
+    }
+    const confirmed = await promptYesNo('Check with these versions?');
+    if (confirmed) {
+        return resolvedList;
+    }
+    // User declined auto-resolve → let them pick per package
+    console.log();
+    printInfo('Customize versions for each package (press Enter to keep auto-resolved version):');
+    console.log();
+    const customized = [];
+    for (const spec of pendingSpecs) {
+        // Keep exact versions as-is
+        if (spec.version && isExactVersion(spec.version)) {
+            customized.push({
+                name: spec.name,
+                version: normalizeVersion(spec.version),
+                originalVersion: spec.version,
+                wasResolved: false,
+            });
+            continue;
+        }
+        const existing = resolvedList.find(r => r.name === spec.name);
+        const defaultVersion = existing?.version;
+        const picked = await pickVersionInteractive(spec, apiClient, defaultVersion);
+        if (picked === null) {
+            return []; // user cancelled
+        }
+        customized.push({
+            name: spec.name,
+            version: picked,
+            originalVersion: spec.version,
+            wasResolved: true,
+        });
+    }
+    return customized;
+}
+/**
+ * Interactive version picker for a single package (used in multi-package customize flow).
+ * If `defaultVersion` provided, it's highlighted as the default choice.
+ */
+async function pickVersionInteractive(spec, apiClient, defaultVersion) {
+    let major;
+    if (spec.version) {
+        const parsedMajor = parseMajor(spec.version);
+        if (parsedMajor === null) {
+            throw new Error(`Invalid version "${spec.version}" for ${spec.name}`);
+        }
+        major = parsedMajor;
+    }
+    else {
+        // No version — pick major first
+        const majorResponse = await apiClient.getPackageMajors(spec.name);
+        if (!majorResponse.success || !majorResponse.data) {
+            throw new Error(majorResponse.error || `No versions found for ${spec.name}`);
+        }
+        const majors = majorResponse.data.majors;
+        if (majors.length === 0) {
+            throw new Error(`No versions available for ${spec.name}`);
+        }
+        if (majors.length === 1) {
+            major = majors[0].major;
+        }
+        else {
+            const majorChoices = majors.map(m => {
+                const parts = [];
+                if (m.latest)
+                    parts.push(`latest: ${m.latest}`);
+                parts.push(`${m.count} version${m.count !== 1 ? 's' : ''}`);
+                if (m.deprecated)
+                    parts.push(chalk.red('deprecated'));
+                if (m.isLatest)
+                    parts.push(chalk.green('current'));
+                return { label: `${m.major}`, value: m.major, hint: `(${parts.join(', ')})` };
+            });
+            const picked = await pickOne(`Pick major for ${chalk.bold(spec.name)}:`, majorChoices);
+            if (picked === null)
+                return null;
+            major = picked;
+        }
+    }
+    const versionsResponse = await apiClient.getPackageVersionsForMajor(spec.name, major);
+    if (!versionsResponse.success || !versionsResponse.data) {
+        throw new Error(versionsResponse.error || `No ${major}.x versions found for ${spec.name}`);
+    }
+    const versions = versionsResponse.data.versions;
+    if (versions.length === 0) {
+        throw new Error(`No ${major}.x versions available for ${spec.name}`);
+    }
+    if (versions.length === 1) {
+        return versions[0].version;
+    }
+    const versionChoices = versions.map(v => {
+        const hints = [];
+        if (v.version === defaultVersion)
+            hints.push(chalk.cyan('auto-resolved'));
+        if (v.isLatest)
+            hints.push(chalk.green('latest'));
+        if (v.deprecated)
+            hints.push(chalk.red('deprecated'));
+        if (v.publishedAt)
+            hints.push(colors.dim(v.publishedAt.slice(0, 10)));
+        return {
+            label: v.version,
+            value: v.version,
+            hint: hints.length > 0 ? `(${hints.join(', ')})` : undefined,
+        };
+    });
+    // Find index of defaultVersion to pre-select it
+    const defaultIdx = defaultVersion
+        ? versionChoices.findIndex(c => c.value === defaultVersion)
+        : 0;
+    return pickOne(`Pick version for ${chalk.bold(spec.name + '@' + major + '.x')}:`, versionChoices, defaultIdx >= 0 ? defaultIdx : 0);
+}
+/**
+ * Auto-resolve to latest matching version.
+ * If spec has a partial version → latest within that major.
+ * If spec has no version → overall latest (most recent major's latest).
+ */
+async function autoResolveLatest(spec, apiClient) {
+    if (spec.version && !isExactVersion(spec.version)) {
+        const major = parseMajor(spec.version);
+        if (major === null) {
+            throw new Error(`Invalid version "${spec.version}" for ${spec.name}`);
+        }
+        const versionsResponse = await apiClient.getPackageVersionsForMajor(spec.name, major);
+        if (!versionsResponse.success || !versionsResponse.data || versionsResponse.data.versions.length === 0) {
+            throw new Error(versionsResponse.error || `No ${major}.x versions found for ${spec.name}`);
+        }
+        return versionsResponse.data.versions[0].version; // sorted desc → latest
+    }
+    // No version: overall latest
+    const majorResponse = await apiClient.getPackageMajors(spec.name);
+    if (!majorResponse.success || !majorResponse.data || majorResponse.data.majors.length === 0) {
+        throw new Error(majorResponse.error || `No versions found for ${spec.name}`);
+    }
+    const latestMajor = majorResponse.data.majors[0]; // sorted desc
+    if (!latestMajor.latest) {
+        throw new Error(`No stable version found for ${spec.name}`);
+    }
+    return latestMajor.latest;
+}
+/**
+ * A version is "exact" if it has major.minor.patch (no ranges, no missing parts).
+ * We strip leading ^/~/= since those narrow to exact for our purposes when a full triplet follows.
+ * Actually — we treat anything with all three numeric parts as exact.
+ */
+function isExactVersion(version) {
+    const cleaned = version.replace(/^[\^~=v]/, '').trim();
+    return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(cleaned);
+}
+function normalizeVersion(version) {
+    return version.replace(/^[\^~=v]/, '').trim();
+}
+function parseMajor(version) {
+    const cleaned = version.replace(/^[\^~=v]/, '').trim();
+    const match = cleaned.match(/^(\d+)/);
+    if (!match)
+        return null;
+    const n = parseInt(match[1], 10);
+    return isNaN(n) ? null : n;
+}
+/**
+ * Check if a package is the framework itself (e.g. "react" for React, "@angular/core" for Angular).
+ */
+function isFrameworkPackage(packageName, frameworkName) {
+    const fw = frameworkName.toLowerCase();
+    const pkg = packageName.toLowerCase();
+    if (fw === 'react')
+        return pkg === 'react' || pkg === 'react-dom';
+    if (fw === 'vue')
+        return pkg === 'vue';
+    if (fw === 'angular')
+        return pkg === '@angular/core' || pkg === '@angular/cli';
+    if (fw === 'next' || fw === 'nextjs')
+        return pkg === 'next';
+    return false;
+}
+/**
+ * Compare major versions. Returns true if both versions have the same major.
+ */
+function isSameMajor(version1, version2) {
+    const major1 = parseInt(version1.split('.')[0].replace(/[\^~]/, ''), 10);
+    const major2 = parseInt(version2.split('.')[0].replace(/[\^~]/, ''), 10);
+    if (isNaN(major1) || isNaN(major2))
+        return false;
+    return major1 === major2;
+}
+/**
+ * Parse and validate package specs from CLI arguments.
+ * Packages without a version are allowed — they will be resolved interactively.
+ */
+function parsePackageSpecs(packages, jsonMode) {
+    const parsed = [];
+    const errors = [];
+    for (const spec of packages) {
+        try {
+            const result = parsePackageSpec(spec);
+            parsed.push({ name: result.name, version: result.version, raw: spec });
+        }
+        catch (err) {
+            errors.push(`${spec}: ${err.message}`);
+        }
+    }
+    if (errors.length > 0) {
+        if (jsonMode) {
+            console.log(JSON.stringify({
+                success: false,
+                error: 'Invalid package specs',
+                details: errors,
+            }));
+        }
+        else {
+            for (const error of errors) {
+                printError(error);
+            }
+            console.log();
+            printInfo('Usage: npx depfixer check <package>[@<version>] [<package>[@<version>] ...]');
+            printInfo('Examples:');
+            printInfo('  npx depfixer check react           # interactive version picker');
+            printInfo('  npx depfixer check react@19        # pick exact 19.x version');
+            printInfo('  npx depfixer check react@19.1.0    # check exact version');
+        }
+        if (errors.length === packages.length) {
+            process.exit(1);
+            return [];
+        }
+    }
+    return parsed;
+}
+/**
+ * Print JSON output for --json mode
+ */
+function printJsonOutput(result, framework, packages) {
+    const output = {
+        success: true,
+        framework: {
+            name: framework.name,
+            version: framework.version,
+        },
+        compatible: result.compatible,
+        packages: [],
+        executionTimeMs: result.executionTimeMs,
+    };
+    if (result.results && Array.isArray(result.results)) {
+        output.packages = result.results.map((r) => ({
+            name: r.packageName,
+            version: r.packageVersion,
+            compatible: r.compatible,
+            reason: r.reason,
+            details: r.details || null,
+        }));
+    }
+    console.log(JSON.stringify(output, null, 2));
+}
+/**
+ * Print human-readable output with colored indicators
+ */
+function printHumanOutput(result, framework, packages) {
+    const frameworkLabel = `${framework.name}@${framework.version}`;
+    printSectionHeader(`Compatibility Check vs ${frameworkLabel}`, '');
+    const results = result.results || [];
+    if (results.length === 0) {
+        printWarning('No results returned from compatibility check');
+        return;
+    }
+    // Build results table
+    const table = new Table({
+        head: [
+            chalk.bold('Status'),
+            chalk.bold('Package'),
+            chalk.bold('Version'),
+            chalk.bold('Result'),
+        ],
+        colWidths: [10, 30, 14, 45],
+        wordWrap: true,
+        style: {
+            head: [],
+            border: ['gray'],
+        },
+        chars: {
+            'mid': '', 'left-mid': '', 'mid-mid': '', 'right-mid': '',
+        },
+    });
+    let compatibleCount = 0;
+    let incompatibleCount = 0;
+    let unknownCount = 0;
+    for (const pkg of results) {
+        let statusIcon;
+        let reasonText;
+        if (pkg.compatible) {
+            statusIcon = chalk.green('  OK  ');
+            reasonText = chalk.green(pkg.reason || 'Compatible');
+            compatibleCount++;
+        }
+        else if (pkg.reason && (pkg.reason.includes('Unknown') || pkg.reason.includes('No data'))) {
+            statusIcon = chalk.yellow('  ??  ');
+            reasonText = chalk.yellow(pkg.reason);
+            unknownCount++;
+        }
+        else {
+            statusIcon = chalk.red('  NO  ');
+            reasonText = chalk.red(pkg.reason || 'Incompatible');
+            incompatibleCount++;
+        }
+        table.push([
+            statusIcon,
+            pkg.packageName,
+            pkg.packageVersion,
+            reasonText,
+        ]);
+    }
+    console.log(table.toString());
+    console.log();
+    // Summary line
+    const totalChecked = results.length;
+    if (result.compatible) {
+        printSuccess(`All ${totalChecked} package${totalChecked !== 1 ? 's' : ''} compatible with ${frameworkLabel}`);
+        console.log();
+        console.log(colors.success('  Safe to install:'));
+        console.log(colors.dim(`  npm install ${packages.map(p => `${p.name}@${p.version}`).join(' ')}`));
+    }
+    else {
+        const parts = [];
+        if (compatibleCount > 0)
+            parts.push(chalk.green(`${compatibleCount} compatible`));
+        if (incompatibleCount > 0)
+            parts.push(chalk.red(`${incompatibleCount} incompatible`));
+        if (unknownCount > 0)
+            parts.push(chalk.yellow(`${unknownCount} unknown`));
+        printWarning(`${parts.join(', ')} with ${frameworkLabel}`);
+        if (incompatibleCount > 0) {
+            console.log();
+            console.log(chalk.yellow('  Review incompatible packages before installing.'));
+            console.log(chalk.dim('  Run a full analysis for recommended versions:'));
+            console.log(chalk.dim('  npx depfixer'));
+        }
+    }
+    // Execution time
+    if (result.executionTimeMs) {
+        console.log();
+        console.log(colors.dim(`  Checked in ${result.executionTimeMs}ms`));
+    }
+    console.log();
+}
+//# sourceMappingURL=check.js.map