inup 1.4.9 → 1.4.12

package/README.md

@@ -50,14 +50,17 @@ inup [options]
 
 -d, --dir <path>              Run in specific directory
 -e, --exclude <patterns>      Skip directories (comma-separated regex)
+-i, --ignore <packages>       Ignore packages (comma-separated, glob supported)
+--max-depth <number>          Maximum scan depth for package discovery (default: 10)
 --package-manager <name>      Force package manager (npm, yarn, pnpm, bun)
+--debug                       Write verbose debug logs
 ```
 
 ## 🔒 Privacy
 
 We don't track anything. Ever.
 
-The only network requests made are to the npm registry and jsDelivr CDN to fetch package version data. That's it.
+Version checks and package metadata are fetched from the npm registry. When needed for immutable exact-version manifests, inup may also fetch a pinned `package.json` from jsDelivr. Weekly download counts come from the npm downloads API.
 
 ## 📄 License
 

package/dist/cli.js

@@ -21,12 +21,11 @@ program
     .option('-d, --dir <directory>', 'specify directory to run in', process.cwd())
     .option('-e, --exclude <patterns>', 'exclude paths matching regex patterns (comma-separated)', '')
     .option('-i, --ignore <packages>', 'ignore packages (comma-separated, supports glob patterns like @babel/*)')
+    .option('--max-depth <number>', 'maximum directory depth for package.json discovery', '10')
     .option('--package-manager <name>', 'manually specify package manager (npm, yarn, pnpm, bun)')
     .option('--debug', 'write verbose debug log to /tmp/inup-debug-YYYY-MM-DD.log')
     .action(async (options) => {
     console.log(chalk_1.default.bold.blue(`🚀 `) + chalk_1.default.bold.red(`i`) + chalk_1.default.bold.yellow(`n`) + chalk_1.default.bold.blue(`u`) + chalk_1.default.bold.magenta(`p`) + `\n`);
-    // Check for updates in the background (non-blocking)
-    const updateCheckPromise = (0, services_1.checkForUpdateAsync)('inup', packageJson.version);
     const cwd = (0, path_1.resolve)(options.dir);
     if (options.debug || process.env.INUP_DEBUG === '1') {
         (0, utils_1.enableDebugLogging)();
@@ -49,6 +48,14 @@ program
             .filter(Boolean)
         : [];
     const ignorePackages = [...new Set([...cliIgnorePatterns, ...(projectConfig.ignore || [])])];
+    const maxDepth = Number.parseInt(options.maxDepth, 10);
+    if (!Number.isInteger(maxDepth) || maxDepth < 0) {
+        console.error(chalk_1.default.red(`Invalid max depth: ${options.maxDepth}`));
+        console.error(chalk_1.default.yellow('Expected a non-negative integer, for example: --max-depth 10'));
+        process.exit(1);
+    }
+    // Check for updates in the background (non-blocking)
+    const updateCheckPromise = (0, services_1.checkForUpdateAsync)('inup', packageJson.version);
     // Validate package manager if provided
     let packageManager;
     if (options.packageManager) {
@@ -63,6 +70,7 @@ program
     const upgrader = new index_1.UpgradeRunner({
         cwd,
         excludePatterns,
+        maxDepth,
         ignorePackages,
         packageManager,
         debug: options.debug || process.env.INUP_DEBUG === '1',

package/dist/config/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_REGISTRY = exports.JSDELIVR_POOL_TIMEOUT = exports.JSDELIVR_RETRY_DELAYS = exports.JSDELIVR_RETRY_TIMEOUTS = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = exports.PACKAGE_NAME = void 0;
+exports.JSDELIVR_POOL_TIMEOUT = exports.JSDELIVR_RETRY_DELAYS = exports.JSDELIVR_RETRY_TIMEOUTS = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = exports.PACKAGE_NAME = void 0;
 exports.PACKAGE_NAME = 'inup';
 exports.NPM_REGISTRY_URL = 'https://registry.npmjs.org';
 exports.JSDELIVR_CDN_URL = 'https://cdn.jsdelivr.net/npm';
@@ -10,5 +10,4 @@ exports.REQUEST_TIMEOUT = 60000; // 60 seconds in milliseconds
 exports.JSDELIVR_RETRY_TIMEOUTS = [2000, 3500]; // short retry budget to keep fallback fast
 exports.JSDELIVR_RETRY_DELAYS = [150]; // tiny backoff between jsDelivr retries in ms
 exports.JSDELIVR_POOL_TIMEOUT = 60000; // keep-alive/connect lifecycle should be looser than per-request timeouts
-exports.DEFAULT_REGISTRY = 'jsdelivr';
 //# sourceMappingURL=constants.js.map

package/dist/core/package-detector.js

@@ -44,9 +44,12 @@ class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
+        this.batchSizes = [10, 15, 20, 25];
+        this.batchConcurrency = 5;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
+        this.maxDepth = options?.maxDepth ?? 10;
         this.packageJsonPath = (0, utils_1.findPackageJson)(this.cwd);
         if (this.packageJsonPath) {
             this.packageJson = (0, utils_1.readPackageJson)(this.packageJsonPath);
@@ -56,21 +59,87 @@ class PackageDetector {
         return this.packageJsonPath !== null && this.packageJson !== null;
     }
     async getOutdatedPackages() {
+        const packages = [];
+        await this.streamOutdatedPackages((event) => {
+            if (event.type === 'batch') {
+                event.payload.batch.forEach((item) => {
+                    packages.push(...item.packageInfo);
+                });
+            }
+            else if (event.type === 'complete') {
+                packages.splice(0, packages.length, ...event.payload.packages);
+            }
+        });
+        return packages;
+    }
+    async streamOutdatedPackages(onEvent) {
         if (!this.packageJson) {
             throw new Error('No package.json found in current directory');
         }
-        const packages = [];
         const t0 = Date.now();
         utils_3.debugLog.info('PackageDetector', `Starting scan in ${this.cwd}`);
-        // Always check all package.json files recursively with timeout protection
+        const prepared = await this.prepareDependencies();
+        const initialPayload = {
+            allDependencies: prepared.allDependencies,
+            uniquePackages: prepared.uniquePackages,
+            currentVersions: prepared.currentVersions,
+            progress: this.createProgressSnapshot(prepared.uniquePackages.length, 0, 0, true),
+        };
+        onEvent({ type: 'initial', payload: initialPayload });
+        const packageLookup = new Map();
+        let resolved = 0;
+        let failed = 0;
+        const tFetch = Date.now();
+        utils_3.debugLog.info('PackageDetector', 'fetching version data via npm registry in batches');
+        await (0, services_1.getAllPackageDataBatched)(prepared.uniquePackages, (batch) => {
+            const batchItems = batch.map((batchItem) => {
+                const packageInfo = this.resolvePackageGroup(batchItem.packageName, prepared.allDependencies, batchItem.data);
+                packageLookup.set(batchItem.packageName, packageInfo);
+                resolved++;
+                const isFailed = batchItem.data.latestVersion === 'unknown';
+                if (isFailed) {
+                    failed++;
+                }
+                return {
+                    packageName: batchItem.packageName,
+                    packageInfo,
+                    failed: isFailed,
+                };
+            });
+            const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, resolved < prepared.uniquePackages.length);
+            onEvent({
+                type: 'batch',
+                payload: {
+                    batch: batchItems,
+                    progress,
+                },
+            });
+        }, prepared.currentVersions, {
+            batchSizes: this.batchSizes,
+            concurrency: this.batchConcurrency,
+        });
+        utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
+        const finalPackages = prepared.uniquePackages.flatMap((packageName) => packageLookup.get(packageName) ?? []);
+        const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, false);
+        utils_3.debugLog.perf('PackageDetector', `total scan complete (${finalPackages.filter((p) => p.isOutdated).length} outdated of ${finalPackages.length} deps)`, t0);
+        onEvent({
+            type: 'complete',
+            payload: {
+                packages: finalPackages,
+                progress,
+            },
+        });
+        utils_2.ConsoleUtils.clearProgress();
+        return finalPackages;
+    }
+    async prepareDependencies() {
         this.showProgress('🔍 Scanning repository for package.json files...');
         const tScan = Date.now();
-        const allPackageJsonFiles = this.findPackageJsonFilesWithTimeout(30000); // 30 second timeout
+        const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000);
         utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
             files: allPackageJsonFiles,
         });
         this.showProgress(`🔍 Found ${allPackageJsonFiles.length} package.json file${allPackageJsonFiles.length === 1 ? '' : 's'}`);
-        // Step 2: Collect all dependencies from package.json files (parallelized)
         this.showProgress('🔍 Reading dependencies from package.json files...');
         const tDeps = Date.now();
         const allDepsRaw = await (0, utils_1.collectAllDependenciesAsync)(allPackageJsonFiles, {
@@ -78,10 +147,9 @@ class PackageDetector {
             includeOptionalDeps: true,
         });
         utils_3.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
-        // Step 3: Get unique package names while filtering out workspace references and ignored packages
         this.showProgress('🔍 Identifying unique packages...');
         const uniquePackageNames = new Set();
-        const allDeps = [];
+        const allDependencies = [];
         let ignoredCount = 0;
         const seenWorkspaceRefs = new Set();
         const seenIgnored = new Set();
@@ -102,119 +170,139 @@ class PackageDetector {
                 }
                 continue;
             }
-            allDeps.push(dep);
+            allDependencies.push({
+                name: dep.name,
+                version: dep.version,
+                type: dep.type,
+                packageJsonPath: dep.packageJsonPath,
+            });
             uniquePackageNames.add(dep.name);
         }
         if (ignoredCount > 0) {
             this.showProgress(`🔍 Skipped ${ignoredCount} ignored package(s)`);
         }
-        const packageNames = Array.from(uniquePackageNames);
-        utils_3.debugLog.info('PackageDetector', `${packageNames.length} unique packages to check, ${ignoredCount} ignored`);
-        // Step 4: Fetch all package data in one call per package
-        // Create a map of package names to their current versions for major version optimization
+        const uniquePackages = Array.from(uniquePackageNames).sort((a, b) => {
+            const aIsScoped = a.startsWith('@');
+            const bIsScoped = b.startsWith('@');
+            if (aIsScoped && !bIsScoped)
+                return -1;
+            if (!aIsScoped && bIsScoped)
+                return 1;
+            return a.localeCompare(b);
+        });
+        utils_3.debugLog.info('PackageDetector', `${uniquePackages.length} unique packages to check, ${ignoredCount} ignored`);
         const currentVersions = new Map();
-        for (const dep of allDeps) {
-            // Use the first occurrence of each package's version
+        for (const dep of allDependencies) {
             if (!currentVersions.has(dep.name)) {
                 currentVersions.set(dep.name, dep.version);
             }
         }
-        const tFetch = Date.now();
-        utils_3.debugLog.info('PackageDetector', `fetching version data via ${config_1.DEFAULT_REGISTRY}`);
-        const allPackageData = config_1.DEFAULT_REGISTRY === 'jsdelivr'
-            ? await (0, services_1.getAllPackageDataFromJsdelivr)(packageNames, currentVersions, (_currentPackage, completed, total) => {
-                this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
-            })
-            : await (0, services_1.getAllPackageData)(packageNames, (_currentPackage, completed, total) => {
-                this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
-            });
-        utils_3.debugLog.perf('PackageDetector', `registry fetch (${allPackageData.size}/${packageNames.length} resolved)`, tFetch);
-        const loggedOutdated = new Set();
+        return {
+            allDependencies,
+            uniquePackages,
+            currentVersions,
+        };
+    }
+    resolvePackageGroup(packageName, allDependencies, packageData) {
+        const dependencies = allDependencies.filter((dep) => dep.name === packageName);
         const loggedNoData = new Set();
-        try {
-            for (const dep of allDeps) {
-                try {
-                    const packageData = allPackageData.get(dep.name);
-                    if (!packageData) {
-                        if (!loggedNoData.has(dep.name)) {
-                            loggedNoData.add(dep.name);
-                            utils_3.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — skipping`);
-                        }
-                        continue;
-                    }
-                    const { latestVersion, allVersions } = packageData;
-                    // Find closest minor version (same major, higher minor) that satisfies the current range
-                    // Falls back to patch updates if no minor updates are available
-                    const closestMinorVersion = (0, utils_1.findClosestMinorVersion)(dep.version, allVersions);
-                    const installedClean = semver.coerce(dep.version)?.version || dep.version;
-                    const minorClean = closestMinorVersion
-                        ? semver.coerce(closestMinorVersion)?.version || closestMinorVersion
-                        : null;
-                    const latestClean = semver.coerce(latestVersion)?.version || latestVersion;
-                    const hasRangeUpdate = minorClean !== null && minorClean !== installedClean;
-                    const hasMajorUpdate = semver.major(latestClean) > semver.major(installedClean);
-                    const isOutdated = hasRangeUpdate || hasMajorUpdate;
-                    if (isOutdated) {
-                        const outdatedKey = `${dep.name}@${dep.version}`;
-                        if (!loggedOutdated.has(outdatedKey)) {
-                            loggedOutdated.add(outdatedKey);
-                            utils_3.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
-                        }
+        const loggedOutdated = new Set();
+        return dependencies.map((dep) => {
+            try {
+                if (!packageData || packageData.latestVersion === 'unknown') {
+                    if (!loggedNoData.has(dep.name)) {
+                        loggedNoData.add(dep.name);
+                        utils_3.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — marking unavailable`);
                     }
-                    packages.push({
-                        name: dep.name,
-                        currentVersion: dep.version, // Keep original version specifier with prefix
-                        rangeVersion: closestMinorVersion || dep.version,
-                        latestVersion,
-                        type: dep.type,
-                        packageJsonPath: dep.packageJsonPath,
-                        isOutdated,
-                        hasRangeUpdate,
-                        hasMajorUpdate,
-                    });
+                    return this.createFailedPackageInfo(dep);
                 }
-                catch (error) {
-                    utils_3.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
-                    // Skip packages that can't be checked (private packages, etc.)
-                    packages.push({
-                        name: dep.name,
-                        currentVersion: dep.version,
-                        rangeVersion: 'unknown',
-                        latestVersion: 'unknown',
-                        type: dep.type,
-                        packageJsonPath: dep.packageJsonPath,
-                        isOutdated: false,
-                        hasRangeUpdate: false,
-                        hasMajorUpdate: false,
-                    });
+                const { latestVersion, allVersions } = packageData;
+                const closestMinorVersion = (0, utils_1.findClosestMinorVersion)(dep.version, allVersions);
+                const installedClean = semver.coerce(dep.version)?.version || dep.version;
+                const minorClean = closestMinorVersion
+                    ? semver.coerce(closestMinorVersion)?.version || closestMinorVersion
+                    : null;
+                const latestClean = semver.coerce(latestVersion)?.version || latestVersion;
+                const hasRangeUpdate = minorClean !== null && minorClean !== installedClean;
+                const hasMajorUpdate = semver.valid(latestClean) !== null &&
+                    semver.valid(installedClean) !== null &&
+                    semver.major(latestClean) > semver.major(installedClean);
+                const isOutdated = hasRangeUpdate || hasMajorUpdate;
+                if (isOutdated) {
+                    const outdatedKey = `${dep.name}@${dep.version}`;
+                    if (!loggedOutdated.has(outdatedKey)) {
+                        loggedOutdated.add(outdatedKey);
+                        utils_3.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
+                    }
                 }
+                return {
+                    name: dep.name,
+                    currentVersion: dep.version,
+                    rangeVersion: closestMinorVersion || dep.version,
+                    latestVersion,
+                    type: dep.type,
+                    packageJsonPath: dep.packageJsonPath,
+                    isOutdated,
+                    hasRangeUpdate,
+                    hasMajorUpdate,
+                };
             }
-            const outdatedCount = packages.filter((p) => p.isOutdated).length;
-            utils_3.debugLog.perf('PackageDetector', `total scan complete (${outdatedCount} outdated of ${packages.length} deps)`, t0);
-            return packages;
-        }
-        catch (error) {
-            this.showProgress('❌ Failed to check packages\n');
-            utils_3.debugLog.error('PackageDetector', 'fatal error during package check', error);
-            throw error;
-        }
+            catch (error) {
+                utils_3.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
+                return this.createFailedPackageInfo(dep);
+            }
+        });
+    }
+    createFailedPackageInfo(dep) {
+        return {
+            name: dep.name,
+            currentVersion: dep.version,
+            rangeVersion: 'unknown',
+            latestVersion: 'unknown',
+            type: dep.type,
+            packageJsonPath: dep.packageJsonPath,
+            isOutdated: false,
+            hasRangeUpdate: false,
+            hasMajorUpdate: false,
+        };
+    }
+    createProgressSnapshot(total, resolved, failed, isLoading) {
+        return {
+            discovered: total,
+            resolved,
+            total,
+            failed,
+            isLoading,
+        };
     }
-    findPackageJsonFilesWithTimeout(timeoutMs) {
-        // Synchronous file search with depth limiting and symlink protection
-        // The timeout parameter is kept for future async implementation
+    async findPackageJsonFilesWithTimeout(timeoutMs) {
         try {
-            return (0, utils_1.findAllPackageJsonFiles)(this.cwd, this.excludePatterns, 10, (currentDir, foundCount) => {
-                // Show scanning progress with current directory and count
-                const truncatedDir = currentDir.length > 50 ? '...' + currentDir.slice(-47) : currentDir;
-                this.showProgress(`🔍 Scanning ${truncatedDir} (found ${foundCount})`);
-            });
+            let timeoutId;
+            try {
+                return await Promise.race([
+                    (0, utils_1.findAllPackageJsonFilesAsync)(this.cwd, this.excludePatterns, this.maxDepth, (currentDir, foundCount) => {
+                        const truncatedDir = currentDir.length > 50 ? '...' + currentDir.slice(-47) : currentDir;
+                        this.showProgress(`🔍 Scanning ${truncatedDir} (found ${foundCount})`);
+                    }),
+                    new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => {
+                            reject(new Error(`Scan timed out after ${timeoutMs}ms`));
+                        }, timeoutMs);
+                        timeoutId.unref?.();
+                    }),
+                ]);
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
         }
         catch (err) {
             throw new Error(`Failed to scan for package.json files: ${err}. Try using --exclude patterns to skip problematic directories.`);
         }
     }
     isWorkspaceReference(version) {
-        // Check for common workspace reference patterns
         return (version.includes('workspace:') ||
             version === '*' ||
             version.startsWith('file:') ||

package/dist/core/upgrade-runner.js

@@ -31,27 +31,72 @@ class UpgradeRunner {
         try {
             // Check prerequisites
             this.checkPrerequisites();
-            // Detect packages
-            const packages = await this.detector.getOutdatedPackages();
-            // Display packages table
-            await this.ui.displayPackagesTable(packages);
-            const outdatedPackages = this.detector.getOutdatedPackagesOnly(packages);
-            if (outdatedPackages.length === 0) {
+            const progress = {
+                discovered: 0,
+                resolved: 0,
+                total: 0,
+                failed: 0,
+                isLoading: true,
+            };
+            let selectionStates = [];
+            let refreshUI;
+            let latestPackages = [];
+            let previousSelections;
+            const selectionPromise = new Promise((resolve, reject) => {
+                const streamPromise = this.detector.streamOutdatedPackages((event) => {
+                    if (event.type === 'initial') {
+                        progress.discovered = event.payload.progress.discovered;
+                        progress.resolved = event.payload.progress.resolved;
+                        progress.total = event.payload.progress.total;
+                        progress.failed = event.payload.progress.failed;
+                        progress.isLoading = event.payload.progress.isLoading;
+                        selectionStates = [];
+                        this.ui
+                            .selectPackagesToUpgradeProgressive(selectionStates, progress, (refresh) => {
+                            refreshUI = refresh;
+                        })
+                            .then(resolve)
+                            .catch(reject);
+                    }
+                    if (event.type === 'batch') {
+                        latestPackages = latestPackages
+                            .filter((pkg) => !event.payload.batch.some((item) => item.packageName === pkg.name))
+                            .concat(event.payload.batch.flatMap((item) => item.packageInfo));
+                        progress.discovered = event.payload.progress.discovered;
+                        progress.resolved = event.payload.progress.resolved;
+                        progress.total = event.payload.progress.total;
+                        progress.failed = event.payload.progress.failed;
+                        progress.isLoading = event.payload.progress.isLoading;
+                        this.ui.appendOutdatedBatchToSelectionStates(selectionStates, event.payload.batch, previousSelections);
+                        refreshUI?.();
+                    }
+                    if (event.type === 'complete') {
+                        latestPackages = event.payload.packages;
+                        progress.discovered = event.payload.progress.discovered;
+                        progress.resolved = event.payload.progress.resolved;
+                        progress.total = event.payload.progress.total;
+                        progress.failed = event.payload.progress.failed;
+                        progress.isLoading = event.payload.progress.isLoading;
+                        refreshUI?.();
+                    }
+                });
+                streamPromise.catch(reject);
+            });
+            let selectedChoices = await selectionPromise;
+            const outdatedPackages = this.detector.getOutdatedPackagesOnly(latestPackages);
+            if (outdatedPackages.length === 0 && selectedChoices.length === 0) {
+                console.log(chalk_1.default.green('✅ All packages are up to date!'));
                 return;
             }
             // Interactive selection and confirmation loop
-            let selectedChoices = [];
             let shouldProceed = false;
-            let previousSelections;
             while (true) {
-                // Interactive selection
-                selectedChoices = await this.ui.selectPackagesToUpgrade(packages, previousSelections);
                 if (selectedChoices.length === 0) {
                     console.log(chalk_1.default.yellow('No packages selected. Exiting...'));
                     return;
                 }
                 // Validate selected choices before confirmation
-                this.validateSelectedChoices(selectedChoices, packages);
+                this.validateSelectedChoices(selectedChoices, latestPackages);
                 // Store current selections for potential return to selection
                 previousSelections = new Map();
                 // Convert selectedChoices back to selection state format
@@ -71,7 +116,11 @@ class UpgradeRunner {
                     // User pressed N or ESC - go back to selection with current selections preserved
                     console.clear();
                     console.log(chalk_1.default.bold.blue('🚀 inup\n'));
-                    // previousSelections is already set from above
+                    selectedChoices = progress.isLoading
+                        ? await this.ui.selectPackagesToUpgradeProgressive(selectionStates, progress, (refresh) => {
+                            refreshUI = refresh;
+                        })
+                        : await this.ui.selectPackagesToUpgrade(latestPackages, previousSelections);
                     continue;
                 }
                 if (!shouldProceed) {
@@ -82,7 +131,7 @@ class UpgradeRunner {
                 break;
             }
             // Perform upgrade
-            await this.upgrader.upgradePackages(selectedChoices, packages);
+            await this.upgrader.upgradePackages(selectedChoices, latestPackages);
         }
         catch (error) {
             console.error(chalk_1.default.red(`Error: ${error}`));