inup 1.4.0

package/README.md

@@ -0,0 +1,142 @@
+# inup
+
+[![npm version](https://img.shields.io/npm/v/inup?logo=npm&logoColor=%23CB3837&style=for-the-badge&color=crimson)](https://www.npmjs.com/package/inup)
+[![Downloads](https://img.shields.io/npm/dm/inup?style=for-the-badge&color=646CFF&logoColor=white)](https://www.npmjs.com/package/inup)
+[![Total downloads](https://img.shields.io/npm/dt/inup?style=for-the-badge&color=informational)](https://www.npmjs.com/package/inup)
+
+A powerful interactive CLI tool for upgrading dependencies with ease. **Auto-detects and works with npm, yarn, pnpm, and bun**. Inspired by `yarn upgrade-interactive`, this tool makes dependency management a breeze for any project. Perfect for monorepos, workspaces, and batch upgrades ❤️
+
+![Interactive Upgrade Demo](docs/demo/interactive-upgrade.gif)
+
+## What it does
+
+Ever found yourself staring at a wall of outdated packages, wondering which ones to upgrade? This tool helps you:
+
+- **Scans your entire project** - finds all package.json files in your workspace
+- **Auto-detects your package manager** - works seamlessly with npm, yarn, pnpm, or bun
+- **Checks for updates** - compares your current versions against the latest available
+- **Lets you pick what to upgrade** - interactive interface to select exactly what you want
+- **Does the heavy lifting** - updates your package.json files and runs the appropriate install command
+
+## Why choose inup?
+
+If you miss the convenience of `yarn upgrade-interactive` but want it to work with **any package manager**, this tool is perfect for you!
+
+- **🚀 Fast & Efficient** - Batch upgrade multiple packages at once
+- **🔒 Safe Updates** - Choose between minor updates or major version jumps
+- **🏢 Monorepo Friendly** - Works seamlessly with workspaces
+- **📦 Registry Aware** - Checks npm registry for latest versions
+- **🎯 Selective Upgrades** - Pick exactly which packages to upgrade
+- **⚡ Zero Config** - Works out of the box with sensible defaults
+
+## Installation
+
+### With npx (no installation needed)
+
+```bash
+npx inup
+```
+
+### Install globally with pnpm
+
+```bash
+pnpm add -g inup
+```
+
+### Alternative: npm
+
+```bash
+npm install -g inup
+```
+
+## Usage
+
+Just run it in your project directory:
+
+```bash
+inup
+```
+
+The tool will scan your entire workspace (including monorepos), find outdated packages, and let you choose which ones to upgrade interactively.
+
+### Command line options
+
+- `-d, --dir <directory>`: Run in a specific directory (default: current directory)
+- `-e, --exclude <patterns>`: Skip directories matching these regex patterns (comma-separated)
+- `-p, --peer`: Include peer dependencies in upgrade process (default: false)
+- `-o, --optional`: Include optional dependencies in upgrade process (default: false)
+- `--package-manager <name>`: Manually specify package manager (npm, yarn, pnpm, bun) - overrides auto-detection
+
+**Note:** By default, the tool only processes `dependencies` and `devDependencies`. Both `peerDependencies` and `optionalDependencies` are excluded by default and must be explicitly included with their respective flags.
+
+Examples:
+
+```bash
+# Basic usage - scans only dependencies and devDependencies
+inup
+
+# Include peer dependencies in the upgrade process
+inup --peer
+
+# Include optional dependencies
+inup --optional
+
+# Include both peer and optional dependencies
+inup --peer --optional
+
+# Skip example and test directories
+inup --exclude "example,test"
+
+# Skip specific paths with regex
+inup -e "example/.*,.*\.test\..*"
+
+# Run in a different directory
+inup --dir ../my-other-project
+
+# Combine multiple options
+inup --dir ./packages --peer --exclude "test,dist"
+
+# Force a specific package manager
+inup --package-manager npm
+```
+
+### How it works
+
+1. **Detects your package manager** - Auto-detects from lock files (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) or package.json
+2. **Scans your project** - Finds all package.json files recursively (respects exclude patterns)
+3. **Collects dependencies** - Gathers dependencies based on your options (dependencies, devDependencies, and optionally peerDependencies/optionalDependencies)
+4. **Checks for updates** - Queries npm registry for latest versions
+5. **Shows you options** - Interactive UI lets you pick what to upgrade (minor updates or latest versions)
+6. **Updates safely** - Modifies package.json files and runs the appropriate install command (`npm install`, `yarn install`, `pnpm install`, or `bun install`)
+
+### Package Manager Detection
+
+inup automatically detects which package manager you're using by:
+
+1. **Checking package.json** - Looks for the `packageManager` field
+2. **Checking lock files** - Scans for:
+   - `pnpm-lock.yaml` → pnpm
+   - `bun.lockb` → bun
+   - `yarn.lock` → yarn
+   - `package-lock.json` → npm
+3. **Fallback to npm** - If nothing is detected, defaults to npm with a warning
+
+You can override auto-detection using the `--package-manager` flag.
+
+### FAQ
+
+**Q: How does inup detect my package manager?**
+A: It checks your `package.json` `packageManager` field first, then looks for lock files. You can manually override with `--package-manager`.
+
+**Q: What if I have multiple lock files?**
+A: inup will use the most recently modified lock file and show a warning. Consider cleaning up unused lock files.
+
+**Q: Can I force a specific package manager?**
+A: Yes! Use `--package-manager npm` (or yarn, pnpm, bun) to override auto-detection.
+
+**Q: What if the detected package manager isn't installed?**
+A: inup will still update your package.json files but skip the install step. It will show you the manual install command to run.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const index_1 = require("./index");
+const services_1 = require("./services");
+const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf-8'));
+const program = new commander_1.Command();
+program
+    .name('inup')
+    .description('Interactive upgrade tool for package managers. Auto-detects and works with npm, yarn, pnpm, and bun.')
+    .version(packageJson.version)
+    .option('-d, --dir <directory>', 'specify directory to run in', process.cwd())
+    .option('-e, --exclude <patterns>', 'exclude paths matching regex patterns (comma-separated)', '')
+    .option('-p, --peer', 'include peer dependencies in upgrade process')
+    .option('-o, --optional', 'include optional dependencies in upgrade process')
+    .option('--package-manager <name>', 'manually specify package manager (npm, yarn, pnpm, bun)')
+    .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 excludePatterns = options.exclude
+        ? options.exclude
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean)
+        : [];
+    // Commander.js: boolean flags are undefined if not provided, true if provided
+    // Both flags default to false (opt-in)
+    const includePeerDeps = options.peer === true;
+    const includeOptionalDeps = options.optional === true;
+    // Validate package manager if provided
+    let packageManager;
+    if (options.packageManager) {
+        const validPMs = ['npm', 'yarn', 'pnpm', 'bun'];
+        if (!validPMs.includes(options.packageManager)) {
+            console.error(chalk_1.default.red(`Invalid package manager: ${options.packageManager}`));
+            console.error(chalk_1.default.yellow(`Valid options: ${validPMs.join(', ')}`));
+            process.exit(1);
+        }
+        packageManager = options.packageManager;
+    }
+    const upgrader = new index_1.UpgradeRunner({
+        cwd: options.dir,
+        excludePatterns,
+        includePeerDeps,
+        includeOptionalDeps,
+        packageManager,
+    });
+    await upgrader.run();
+    // After the main flow completes, check if there's an update available
+    const updateCheck = await updateCheckPromise;
+    if (updateCheck?.isOutdated) {
+        console.log('');
+        console.log(chalk_1.default.yellow('┌' + '─'.repeat(78) + '┐'));
+        console.log(chalk_1.default.yellow('│') +
+            ' ' +
+            chalk_1.default.bold.yellow('Update available! ') +
+            chalk_1.default.gray(`${updateCheck.currentVersion}`) +
+            ' → ' +
+            chalk_1.default.green(`${updateCheck.latestVersion}`) +
+            ' '.repeat(78 - 19 - updateCheck.currentVersion.length - 3 - updateCheck.latestVersion.length - 1) +
+            chalk_1.default.yellow('│'));
+        console.log(chalk_1.default.yellow('│') +
+            ' ' +
+            chalk_1.default.gray('Run: ') +
+            chalk_1.default.cyan(updateCheck.updateCommand) +
+            ' '.repeat(78 - 6 - updateCheck.updateCommand.length - 1) +
+            chalk_1.default.yellow('│'));
+        console.log(chalk_1.default.yellow('└' + '─'.repeat(78) + '┘'));
+        console.log('');
+    }
+});
+// Handle uncaught errors gracefully
+process.on('uncaughtException', (error) => {
+    console.error(chalk_1.default.red('Uncaught Exception:'), error.message);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error(chalk_1.default.red('Unhandled Rejection:'), reason);
+    process.exit(1);
+});
+// Handle Ctrl+C gracefully
+let sigintReceived = false;
+process.on('SIGINT', () => {
+    if (sigintReceived) {
+        // Force exit on second Ctrl+C
+        console.log(chalk_1.default.red('\n\nForce exiting...'));
+        process.exit(1);
+    }
+    else {
+        sigintReceived = true;
+        console.log(chalk_1.default.yellow('\n\nOperation cancelled by user. Press Ctrl+C again to force exit.'));
+        process.exit(0);
+    }
+});
+// Also handle SIGTERM
+process.on('SIGTERM', () => {
+    console.log(chalk_1.default.yellow('\n\nOperation cancelled.'));
+    process.exit(0);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Constants for npm registry queries and configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKSPACE_FILES = exports.LOCK_FILES = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = void 0;
+exports.NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+exports.JSDELIVR_CDN_URL = 'https://cdn.jsdelivr.net/npm';
+exports.MAX_CONCURRENT_REQUESTS = 80;
+exports.CACHE_TTL = 5 * 60 * 1000; // 5 minutes in milliseconds
+exports.REQUEST_TIMEOUT = 30000; // 30 seconds in milliseconds
+/**
+ * Package manager lock files
+ */
+exports.LOCK_FILES = {
+    npm: 'package-lock.json',
+    yarn: 'yarn.lock',
+    pnpm: 'pnpm-lock.yaml',
+    bun: 'bun.lockb',
+};
+/**
+ * Package manager workspace files
+ */
+exports.WORKSPACE_FILES = {
+    pnpm: 'pnpm-workspace.yaml',
+    // npm, yarn, and bun use package.json workspaces field
+};
+//# sourceMappingURL=constants.js.map

package/dist/core/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Core business logic
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./upgrade-runner"), exports);
+__exportStar(require("./package-detector"), exports);
+__exportStar(require("./upgrader"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/package-detector.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageDetector = void 0;
+const semver = __importStar(require("semver"));
+const utils_1 = require("../utils");
+const services_1 = require("../services");
+class PackageDetector {
+    constructor(options) {
+        this.packageJsonPath = null;
+        this.packageJson = null;
+        this.cwd = options?.cwd || process.cwd();
+        this.excludePatterns = options?.excludePatterns || [];
+        // Explicitly check for true to ensure false/undefined both become false (opt-in)
+        this.includePeerDeps = options?.includePeerDeps === true;
+        this.includeOptionalDeps = options?.includeOptionalDeps === true;
+        this.packageJsonPath = (0, utils_1.findPackageJson)(this.cwd);
+        if (this.packageJsonPath) {
+            this.packageJson = (0, utils_1.readPackageJson)(this.packageJsonPath);
+        }
+    }
+    hasPackageJson() {
+        return this.packageJsonPath !== null && this.packageJson !== null;
+    }
+    async getOutdatedPackages() {
+        if (!this.packageJson) {
+            throw new Error('No package.json found in current directory');
+        }
+        const packages = [];
+        // Always check all package.json files recursively with timeout protection
+        this.showProgress('🔍 Scanning repository for package.json files...');
+        const allPackageJsonFiles = this.findPackageJsonFilesWithTimeout(30000); // 30 second timeout
+        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 allDepsRaw = await (0, utils_1.collectAllDependenciesAsync)(allPackageJsonFiles, {
+            includePeerDeps: this.includePeerDeps,
+            includeOptionalDeps: this.includeOptionalDeps,
+        });
+        // Step 3: Get unique package names while filtering out workspace references
+        this.showProgress('🔍 Identifying unique packages...');
+        const uniquePackageNames = new Set();
+        const allDeps = [];
+        for (const dep of allDepsRaw) {
+            if (!this.isWorkspaceReference(dep.version)) {
+                allDeps.push(dep);
+                uniquePackageNames.add(dep.name);
+            }
+        }
+        const packageNames = Array.from(uniquePackageNames);
+        // Step 4: Fetch all package data in one call per package using jsdelivr CDN
+        // Create a map of package names to their current versions for major version optimization
+        const currentVersions = new Map();
+        for (const dep of allDeps) {
+            // Use the first occurrence of each package's version
+            if (!currentVersions.has(dep.name)) {
+                currentVersions.set(dep.name, dep.version);
+            }
+        }
+        const allPackageData = await (0, services_1.getAllPackageDataFromJsdelivr)(packageNames, currentVersions, (currentPackage, completed, total) => {
+            const percentage = Math.round((completed / total) * 100);
+            const truncatedPackage = currentPackage.length > 40 ? currentPackage.substring(0, 37) + '...' : currentPackage;
+            this.showProgress(`🌐 Fetching ${percentage}% (${truncatedPackage})`);
+        });
+        try {
+            for (const dep of allDeps) {
+                try {
+                    const packageData = allPackageData.get(dep.name);
+                    if (!packageData)
+                        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;
+                    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,
+                    });
+                }
+                catch (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,
+                    });
+                }
+            }
+            return packages;
+        }
+        catch (error) {
+            this.showProgress('❌ Failed to check packages\n');
+            throw error;
+        }
+    }
+    findPackageJsonFilesWithTimeout(timeoutMs) {
+        // Synchronous file search with depth limiting and symlink protection
+        // The timeout parameter is kept for future async implementation
+        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})`);
+            });
+        }
+        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:') ||
+            version.startsWith('link:') ||
+            version.startsWith('github:') ||
+            version.startsWith('gitlab:') ||
+            version.startsWith('bitbucket:'));
+    }
+    showProgress(message) {
+        // Clear current line and show new message
+        process.stdout.write(`\r${' '.repeat(80)}\r${message}`);
+    }
+    getOutdatedPackagesOnly(packages) {
+        return packages.filter((pkg) => pkg.isOutdated);
+    }
+}
+exports.PackageDetector = PackageDetector;
+//# sourceMappingURL=package-detector.js.map

package/dist/core/upgrade-runner.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmUpgradeInteractive = exports.UpgradeRunner = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const package_detector_1 = require("./package-detector");
+const interactive_ui_1 = require("../interactive-ui");
+const upgrader_1 = require("./upgrader");
+const package_manager_detector_1 = require("../services/package-manager-detector");
+/**
+ * Main orchestrator for the inup upgrade process
+ */
+class UpgradeRunner {
+    constructor(options) {
+        this.options = options;
+        // Detect package manager
+        const cwd = options?.cwd || process.cwd();
+        if (options?.packageManager) {
+            this.packageManager = package_manager_detector_1.PackageManagerDetector.getInfo(options.packageManager);
+        }
+        else {
+            this.packageManager = package_manager_detector_1.PackageManagerDetector.detect(cwd);
+        }
+        this.detector = new package_detector_1.PackageDetector(options);
+        this.ui = new interactive_ui_1.InteractiveUI(this.packageManager);
+        this.upgrader = new upgrader_1.PackageUpgrader(this.packageManager);
+    }
+    async run() {
+        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) {
+                return;
+            }
+            // Interactive selection and confirmation loop
+            let selectedChoices = [];
+            let shouldProceed = false;
+            let previousSelections;
+            while (true) {
+                // Interactive selection (pass options for filtering)
+                selectedChoices = await this.ui.selectPackagesToUpgrade(packages, previousSelections, {
+                    includePeerDeps: this.options?.includePeerDeps,
+                    includeOptionalDeps: this.options?.includeOptionalDeps,
+                });
+                if (selectedChoices.length === 0) {
+                    console.log(chalk_1.default.yellow('No packages selected. Exiting...'));
+                    return;
+                }
+                // Validate selected choices before confirmation
+                this.validateSelectedChoices(selectedChoices, packages);
+                // Store current selections for potential return to selection
+                previousSelections = new Map();
+                // Convert selectedChoices back to selection state format
+                // Group by package name and version specifier
+                const choiceMap = new Map();
+                selectedChoices.forEach((choice) => {
+                    const key = `${choice.name}@${choice.currentVersionSpecifier}`;
+                    choiceMap.set(key, choice.upgradeType);
+                });
+                // Convert to the format expected by selectPackagesToUpgrade
+                choiceMap.forEach((upgradeType, key) => {
+                    previousSelections.set(key, upgradeType);
+                });
+                // Confirm upgrade
+                shouldProceed = await this.ui.confirmUpgrade(selectedChoices);
+                if (shouldProceed === null) {
+                    // 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
+                    continue;
+                }
+                if (!shouldProceed) {
+                    console.log(chalk_1.default.yellow('Upgrade cancelled.'));
+                    return;
+                }
+                // User confirmed - break out of loop and proceed
+                break;
+            }
+            // Perform upgrade
+            await this.upgrader.upgradePackages(selectedChoices, packages);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Error: ${error}`));
+            process.exit(1);
+        }
+    }
+    checkPrerequisites() {
+        // Check if package.json exists
+        if (!this.detector.hasPackageJson()) {
+            throw new Error('No package.json found in current directory');
+        }
+    }
+    validateSelectedChoices(selectedChoices, allPackages) {
+        // Validate that all selected packages have valid target versions
+        const invalidChoices = selectedChoices.filter((choice) => {
+            const packageInfo = allPackages.find((pkg) => pkg.name === choice.name && pkg.packageJsonPath === choice.packageJsonPath);
+            return !packageInfo || !choice.targetVersion;
+        });
+        if (invalidChoices.length > 0) {
+            throw new Error(`Invalid selections detected: ${invalidChoices.map((c) => c.name).join(', ')}. Please review your selections.`);
+        }
+        // Print summary of what will be upgraded
+        const packageJsonPaths = new Set(selectedChoices.map((c) => c.packageJsonPath));
+        const uniquePackages = new Set(selectedChoices.map((c) => c.name));
+        console.log('\n' + chalk_1.default.bold('📋 Upgrade Summary'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(`${chalk_1.default.cyan(uniquePackages.size.toString())} package(s) will be upgraded`);
+        console.log(`${chalk_1.default.cyan(packageJsonPaths.size.toString())} package.json file(s) will be modified`);
+        const rangeUpgrades = selectedChoices.filter((c) => c.upgradeType === 'range').length;
+        const majorUpgrades = selectedChoices.filter((c) => c.upgradeType === 'latest').length;
+        if (rangeUpgrades > 0) {
+            console.log(`  ${chalk_1.default.yellow('●')} ${rangeUpgrades} minor/patch upgrade(s)`);
+        }
+        if (majorUpgrades > 0) {
+            console.log(`  ${chalk_1.default.red('●')} ${majorUpgrades} major upgrade(s)`);
+        }
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+    }
+}
+exports.UpgradeRunner = UpgradeRunner;
+/**
+ * @deprecated Use UpgradeRunner instead
+ */
+class PnpmUpgradeInteractive extends UpgradeRunner {
+}
+exports.PnpmUpgradeInteractive = PnpmUpgradeInteractive;
+//# sourceMappingURL=upgrade-runner.js.map