patch-pulse/lib/index.js

Check for outdated npm dependencies

#!/usr/bin/env node
import chalk from 'chalk';
import { join } from 'path';
import { checkDependencyVersions } from './core/dependency-checker.js';
import { getConfig } from './services/config.js';
import { checkForCliUpdate } from './services/npm.js';
import { readPackageJson } from './services/package.js';
import { detectPackageManager, getPackageManagerInfo, updateDependencies, } from './services/package-manager.js';
import { displayHelp } from './ui/display/help.js';
import { displayLicense } from './ui/display/license.js';
import { displaySummary } from './ui/display/summary.js';
import { displayThankYouMessage } from './ui/display/thankYouMessage.js';
import { displayUnknownArguments } from './ui/display/unknownArguments.js';
import { displayUpdatePrompt } from './ui/display/updatePrompt.js';
import { displayVersion } from './ui/display/version.js';
import { getUnknownArgs } from './utils/getUnknownArgs.js';
import { hasAnyFlag } from './utils/hasAnyFlag.js';
async function main() {
    /**
     * Force colors in output
     */
    process.env.FORCE_COLOR = '1';
    const packageJsonPath = join(process.cwd(), 'package.json');
    try {
        const packageJson = await readPackageJson(packageJsonPath);
        const allDependencies = [];
        const config = getConfig();
        const dependencyTypeLabels = {
            dependencies: 'Dependencies',
            devDependencies: 'Dev Dependencies',
            peerDependencies: 'Peer Dependencies',
            optionalDependencies: 'Optional Dependencies',
        };
        for (const [key, value] of Object.entries(packageJson)) {
            if (dependencyTypeLabels[key] && value && typeof value === 'object') {
                try {
                    const dependencies = await checkDependencyVersions(value, dependencyTypeLabels[key], config);
                    allDependencies.push(...dependencies);
                }
                catch (error) {
                    console.error(chalk.red(`Error checking ${key.toLowerCase()}: ${error}`));
                }
            }
        }
        if (allDependencies.length > 0) {
            displaySummary(allDependencies);
            // Check if we should show the update prompt
            if (!config.noUpdatePrompt) {
                // Detect package manager
                const packageManager = config.packageManager
                    ? getPackageManagerInfo(config.packageManager)
                    : detectPackageManager();
                // Show update prompt
                const updateType = await displayUpdatePrompt(allDependencies, config);
                if (updateType) {
                    const outdatedDeps = allDependencies.filter(d => d.isOutdated && !d.isSkipped);
                    let depsToUpdate = [];
                    if (updateType === 'patch') {
                        depsToUpdate = outdatedDeps
                            .filter(d => d.updateType === 'patch' && d.latestVersion)
                            .map(d => ({
                            packageName: d.packageName,
                            currentVersion: d.currentVersion,
                            latestVersion: d.latestVersion,
                            updateType: d.updateType,
                            category: d.category || 'Dependencies',
                        }));
                    }
                    else if (updateType === 'minor') {
                        depsToUpdate = outdatedDeps
                            .filter(d => (d.updateType === 'minor' || d.updateType === 'patch') &&
                            d.latestVersion)
                            .map(d => ({
                            packageName: d.packageName,
                            currentVersion: d.currentVersion,
                            latestVersion: d.latestVersion,
                            updateType: d.updateType,
                            category: d.category || 'Dependencies',
                        }));
                    }
                    else if (updateType === 'all') {
                        depsToUpdate = outdatedDeps
                            .filter(d => d.latestVersion)
                            .map(d => ({
                            packageName: d.packageName,
                            currentVersion: d.currentVersion,
                            latestVersion: d.latestVersion,
                            updateType: d.updateType,
                            category: d.category || 'Dependencies',
                        }));
                    }
                    if (depsToUpdate.length > 0) {
                        await updateDependencies({
                            dependencies: depsToUpdate,
                            packageManager,
                        });
                    }
                }
            }
            displayThankYouMessage();
        }
        else {
            console.log(chalk.yellow('⚠️  No dependencies found to check'));
        }
        try {
            await checkForCliUpdate();
        }
        catch {
            // Silently fail for CLI updates, i.e. don't let CLI update errors stop the main flow
        }
        // Ensure the process exits properly
        process.exit(0);
    }
    catch (error) {
        console.error(chalk.red(`Error: ${error}`));
        process.exit(1);
    }
}
const args = process.argv.slice(2);
const validFlags = [
    '-h',
    '--help',
    '-i',
    '--info',
    '-v',
    '--version',
    '-l',
    '--license',
    '-s',
    '--skip',
    '--package-manager',
    '--update-prompt',
    '--no-update-prompt',
];
const unknownArgs = getUnknownArgs({ args, validFlags });
if (unknownArgs.length > 0) {
    displayUnknownArguments(unknownArgs);
    process.exit(1);
}
if (hasAnyFlag({ args, flags: ['--help', '-h', '--info', '-i'] })) {
    displayHelp();
    process.exit(0);
}
if (hasAnyFlag({ args, flags: ['--version', '-v'] })) {
    displayVersion();
    process.exit(0);
}
if (hasAnyFlag({ args, flags: ['--license', '-l'] })) {
    displayLicense();
    process.exit(0);
}
main().catch(error => {
    console.error(chalk.red(`Fatal error: ${error}`));
    process.exit(1);
});
//# sourceMappingURL=index.js.map