inup 1.4.0

package/dist/core/upgrader.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageUpgrader = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const nanospinner_1 = require("nanospinner");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const utils_1 = require("../utils");
+class PackageUpgrader {
+    constructor(packageManager) {
+        this.packageManager = packageManager;
+    }
+    async upgradePackages(choices, packageInfos) {
+        if (choices.length === 0) {
+            console.log(chalk_1.default.yellow('No packages to upgrade.'));
+            return;
+        }
+        // Group choices by package.json path and dependency type
+        const choicesByFileAndType = this.groupChoicesByFileAndType(choices, packageInfos);
+        for (const [fileAndType, choiceList] of Object.entries(choicesByFileAndType)) {
+            if (choiceList.length === 0)
+                continue;
+            const [packageJsonPath, type] = fileAndType.split('|');
+            console.log(`Processing ${type} in ${packageJsonPath}`);
+            await this.upgradeChoiceGroup(choiceList, packageJsonPath, type);
+        }
+        // Count unique packages upgraded
+        const uniquePackages = new Set(choices.map((c) => c.name));
+        console.log(chalk_1.default.green(`\n✅ Successfully upgraded ${uniquePackages.size} package(s)!`));
+        // Execute package manager install after all upgrades are complete
+        await this.runInstall(choices, packageInfos);
+    }
+    async runInstall(choices, packageInfos) {
+        if (choices.length === 0) {
+            return;
+        }
+        // Determine the directory to run install in
+        // Use workspace root if it exists, otherwise use the directory of the first package.json
+        const firstPackageJsonPath = choices[0].packageJsonPath;
+        const firstPackageDir = (0, path_1.dirname)(firstPackageJsonPath);
+        const workspaceRoot = (0, utils_1.findWorkspaceRoot)(firstPackageDir, this.packageManager.name);
+        const installDir = workspaceRoot || firstPackageDir;
+        // Check if package manager is installed
+        try {
+            (0, utils_1.executeCommand)(`${this.packageManager.name} --version`, installDir);
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow(`\n⚠️  ${this.packageManager.displayName} is detected but not installed on your system.\n` +
+                `Please run the install command manually:\n` +
+                `  cd ${installDir}\n` +
+                `  ${this.packageManager.installCommand}\n`));
+            return; // Skip install, let user do it manually
+        }
+        const spinner = (0, nanospinner_1.createSpinner)(`Running ${this.packageManager.displayName} install...`).start();
+        try {
+            (0, utils_1.executeCommand)(this.packageManager.installCommand, installDir);
+            spinner.success();
+        }
+        catch (error) {
+            spinner.error();
+            console.error(chalk_1.default.red(`Error: ${error}`));
+            throw error;
+        }
+    }
+    groupChoicesByFileAndType(choices, packageInfos) {
+        const groups = {};
+        choices.forEach((choice) => {
+            const info = packageInfos.find((p) => p.name === choice.name && p.packageJsonPath === choice.packageJsonPath);
+            if (info) {
+                const key = `${choice.packageJsonPath}|${info.type}`;
+                if (!groups[key]) {
+                    groups[key] = [];
+                }
+                groups[key].push(choice);
+            }
+        });
+        return groups;
+    }
+    async upgradeChoiceGroup(choices, packageJsonPath, type) {
+        // Validate that package.json exists
+        if (!(0, fs_1.existsSync)(packageJsonPath)) {
+            console.warn(chalk_1.default.yellow(`⚠️  Skipping ${type} in ${packageJsonPath} - package.json file not found`));
+            return;
+        }
+        const packageDir = packageJsonPath.replace('/package.json', '');
+        const spinner = (0, nanospinner_1.createSpinner)(`Upgrading ${type} in ${packageDir}...`).start();
+        try {
+            // Read the current package.json
+            const packageJson = (0, utils_1.readPackageJson)(packageJsonPath);
+            // Find workspace root
+            const workspaceRoot = (0, utils_1.findWorkspaceRoot)(packageDir, this.packageManager.name);
+            const isWorkspaceRoot = packageDir === workspaceRoot;
+            // Group by upgrade type (range vs latest)
+            const rangeChoices = choices.filter((c) => c.upgradeType === 'range');
+            const latestChoices = choices.filter((c) => c.upgradeType === 'latest');
+            let modified = false;
+            // Upgrade range versions by directly modifying package.json
+            if (rangeChoices.length > 0) {
+                if (!packageJson[type]) {
+                    packageJson[type] = {};
+                }
+                rangeChoices.forEach((choice) => {
+                    packageJson[type][choice.name] = choice.targetVersion;
+                    modified = true;
+                });
+            }
+            // Upgrade to latest versions by directly modifying package.json
+            if (latestChoices.length > 0) {
+                if (!packageJson[type]) {
+                    packageJson[type] = {};
+                }
+                latestChoices.forEach((choice) => {
+                    packageJson[type][choice.name] = choice.targetVersion;
+                    modified = true;
+                });
+            }
+            // Write back the modified package.json
+            if (modified) {
+                (0, fs_1.writeFileSync)(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+            }
+            spinner.success({ text: `Upgraded ${choices.length} ${type} in ${packageDir}` });
+            // Show which packages were upgraded
+            choices.forEach((choice) => {
+                const upgradeTypeColor = choice.upgradeType === 'range' ? chalk_1.default.yellow : chalk_1.default.red;
+                console.log(`  ${chalk_1.default.green('✓')} ${chalk_1.default.cyan(choice.name)} → ${upgradeTypeColor(choice.targetVersion)}`);
+            });
+        }
+        catch (error) {
+            spinner.error({ text: `Failed to upgrade ${type} in ${packageDir}` });
+            console.error(chalk_1.default.red(`Error: ${error}`));
+            throw error;
+        }
+    }
+}
+exports.PackageUpgrader = PackageUpgrader;
+//# sourceMappingURL=upgrader.js.map

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Public API for inup
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmUpgradeInteractive = exports.UpgradeRunner = void 0;
+var core_1 = require("./core");
+Object.defineProperty(exports, "UpgradeRunner", { enumerable: true, get: function () { return core_1.UpgradeRunner; } });
+Object.defineProperty(exports, "PnpmUpgradeInteractive", { enumerable: true, get: function () { return core_1.PnpmUpgradeInteractive; } });
+//# sourceMappingURL=index.js.map

package/dist/interactive-ui.js

@@ -0,0 +1,411 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveUI = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const semver = __importStar(require("semver"));
+const keypress = require('keypress');
+const ui_1 = require("./ui");
+const services_1 = require("./services");
+class InteractiveUI {
+    constructor(packageManager) {
+        this.renderer = new ui_1.UIRenderer();
+        this.packageManager = packageManager;
+    }
+    async displayPackagesTable(packages) {
+        console.log(this.renderer.renderPackagesTable(packages));
+    }
+    async selectPackagesToUpgrade(packages, previousSelections, options) {
+        const outdatedPackages = packages.filter((p) => p.isOutdated);
+        if (outdatedPackages.length === 0) {
+            return [];
+        }
+        // Filter packages based on CLI options.
+        // IMPORTANT: This uses an opt-in approach where:
+        // - Default (no flags): shows dependencies + devDependencies
+        // - With -p flag: shows ONLY peerDependencies (excludes dependencies)
+        // - With -o flag: shows ONLY optionalDependencies (excludes dependencies)
+        // - With -p -o flags: shows peerDependencies + optionalDependencies (excludes dependencies)
+        //
+        // This design allows users to focus on one dependency type at a time,
+        // which is useful since peer/optional deps have different upgrade semantics.
+        let filteredPackages = outdatedPackages;
+        let dependencyTypeLabel = '';
+        if (options?.includePeerDeps || options?.includeOptionalDeps) {
+            // If any special-case flag is provided, filter to show ONLY those types
+            // (excluding regular dependencies/devDependencies)
+            filteredPackages = outdatedPackages.filter((pkg) => {
+                if (options.includePeerDeps && pkg.type === 'peerDependencies')
+                    return true;
+                if (options.includeOptionalDeps && pkg.type === 'optionalDependencies')
+                    return true;
+                return false;
+            });
+            // Build label describing which types are shown
+            const types = [];
+            if (options.includePeerDeps)
+                types.push('Peer Dependencies');
+            if (options.includeOptionalDeps)
+                types.push('Optional Dependencies');
+            dependencyTypeLabel = types.join(' & ');
+        }
+        else {
+            // Default: show only regular dependencies and devDependencies
+            filteredPackages = outdatedPackages.filter((pkg) => pkg.type === 'dependencies' || pkg.type === 'devDependencies');
+            dependencyTypeLabel = 'Dependencies & Dev Dependencies';
+        }
+        if (filteredPackages.length === 0) {
+            return [];
+        }
+        // Deduplicate packages by name and version specifier, but track all package.json paths
+        const uniquePackages = new Map();
+        for (const pkg of filteredPackages) {
+            const key = `${pkg.name}@${pkg.currentVersion}`;
+            if (!uniquePackages.has(key)) {
+                uniquePackages.set(key, {
+                    pkg,
+                    packageJsonPaths: new Set([pkg.packageJsonPath]),
+                    type: pkg.type,
+                });
+            }
+            else {
+                uniquePackages.get(key).packageJsonPaths.add(pkg.packageJsonPath);
+            }
+        }
+        // Convert to array and sort alphabetically by name (@scoped packages first, then unscoped)
+        const deduplicatedPackages = Array.from(uniquePackages.values()).map(({ pkg, packageJsonPaths, type }) => ({
+            ...pkg,
+            packageJsonPaths: Array.from(packageJsonPaths),
+            type,
+        }));
+        deduplicatedPackages.sort((a, b) => {
+            const aIsScoped = a.name.startsWith('@');
+            const bIsScoped = b.name.startsWith('@');
+            // If one is scoped and the other isn't, scoped comes first
+            if (aIsScoped && !bIsScoped)
+                return -1;
+            if (!aIsScoped && bIsScoped)
+                return 1;
+            // Both scoped or both unscoped - sort alphabetically
+            return a.name.localeCompare(b.name);
+        });
+        // Create selection states for each unique package
+        const selectionStates = deduplicatedPackages.map((pkg) => {
+            const currentClean = semver.coerce(pkg.currentVersion)?.version || pkg.currentVersion;
+            const rangeClean = semver.coerce(pkg.rangeVersion)?.version || pkg.rangeVersion;
+            const latestClean = semver.coerce(pkg.latestVersion)?.version || pkg.latestVersion;
+            // Use previous selection if available, otherwise default to 'none'
+            const key = `${pkg.name}@${pkg.currentVersion}`;
+            const previousSelection = previousSelections?.get(key) || 'none';
+            return {
+                name: pkg.name,
+                packageJsonPath: pkg.packageJsonPaths[0], // Use first path for display
+                packageJsonPaths: pkg.packageJsonPaths, // Store all paths for upgrading
+                currentVersionSpecifier: pkg.currentVersion, // Keep original with prefix
+                currentVersion: currentClean,
+                rangeVersion: rangeClean,
+                latestVersion: latestClean,
+                selectedOption: previousSelection,
+                hasRangeUpdate: pkg.hasRangeUpdate,
+                hasMajorUpdate: pkg.hasMajorUpdate,
+                type: pkg.type,
+            };
+        });
+        // Use custom interactive table selector (simplified - no grouping)
+        const selectedStates = await this.interactiveTableSelector(selectionStates, dependencyTypeLabel);
+        // Convert to PackageUpgradeChoice[] - create one choice per package.json path
+        const choices = [];
+        selectedStates
+            .filter((state) => state.selectedOption !== 'none')
+            .forEach((state) => {
+            const targetVersion = state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion;
+            const targetVersionWithPrefix = ui_1.VersionUtils.applyVersionPrefix(state.currentVersionSpecifier, targetVersion);
+            // Create a choice for each package.json path where this package appears
+            const pathsToUpdate = state.packageJsonPaths || [state.packageJsonPath];
+            pathsToUpdate.forEach((packageJsonPath) => {
+                choices.push({
+                    name: state.name,
+                    packageJsonPath,
+                    upgradeType: state.selectedOption,
+                    targetVersion: targetVersionWithPrefix,
+                    currentVersionSpecifier: state.currentVersionSpecifier,
+                });
+            });
+        });
+        return choices;
+    }
+    getTerminalHeight() {
+        // Check if stdout is a TTY and has rows property
+        if (process.stdout.isTTY && typeof process.stdout.rows === 'number' && process.stdout.rows > 0) {
+            return process.stdout.rows;
+        }
+        return 24; // Fallback default
+    }
+    async interactiveTableSelector(selectionStates, dependencyTypeLabel) {
+        return new Promise((resolve) => {
+            const states = [...selectionStates];
+            const stateManager = new ui_1.StateManager(0, this.getTerminalHeight());
+            // No grouping needed - packages are already filtered by type
+            // This simplifies scrolling and avoids rendering issues
+            stateManager.setRenderableItems([]);
+            const handleAction = (action) => {
+                const uiState = stateManager.getUIState();
+                switch (action.type) {
+                    case 'navigate_up':
+                        if (!uiState.showInfoModal) {
+                            stateManager.navigateUp(states.length);
+                        }
+                        break;
+                    case 'navigate_down':
+                        if (!uiState.showInfoModal) {
+                            stateManager.navigateDown(states.length);
+                        }
+                        break;
+                    case 'select_left':
+                        if (!uiState.showInfoModal) {
+                            stateManager.updateSelection(states, 'left');
+                        }
+                        break;
+                    case 'select_right':
+                        if (!uiState.showInfoModal) {
+                            stateManager.updateSelection(states, 'right');
+                        }
+                        break;
+                    case 'bulk_select_minor':
+                        if (!uiState.showInfoModal) {
+                            stateManager.bulkSelectMinor(states);
+                        }
+                        break;
+                    case 'bulk_select_latest':
+                        if (!uiState.showInfoModal) {
+                            stateManager.bulkSelectLatest(states);
+                        }
+                        break;
+                    case 'bulk_unselect_all':
+                        if (!uiState.showInfoModal) {
+                            stateManager.bulkUnselectAll(states);
+                        }
+                        break;
+                    case 'toggle_info_modal':
+                        if (!uiState.showInfoModal) {
+                            // Opening modal - load package info asynchronously
+                            stateManager.toggleInfoModal();
+                            const currentState = states[uiState.currentRow];
+                            stateManager.setModalLoading(true);
+                            renderInterface();
+                            // Fetch metadata asynchronously
+                            services_1.changelogFetcher.fetchPackageMetadata(currentState.name).then((metadata) => {
+                                if (metadata) {
+                                    currentState.description = metadata.description;
+                                    currentState.homepage = metadata.homepage;
+                                    currentState.repository = metadata.releaseNotes;
+                                    currentState.weeklyDownloads = metadata.weeklyDownloads;
+                                    currentState.author = metadata.author;
+                                    currentState.license = metadata.license;
+                                }
+                                stateManager.setModalLoading(false);
+                                renderInterface();
+                            });
+                        }
+                        else {
+                            // Closing modal
+                            stateManager.toggleInfoModal();
+                            renderInterface();
+                        }
+                        break;
+                    case 'resize':
+                        const heightChanged = stateManager.updateTerminalHeight(action.height);
+                        if (heightChanged) {
+                            stateManager.resetForResize();
+                        }
+                        else {
+                            // Even if height didn't change, width might have changed
+                            // Force a full re-render to clear any wrapping issues
+                            stateManager.setInitialRender(true);
+                        }
+                        break;
+                    case 'cancel':
+                        handleCancel();
+                        return;
+                }
+                if (action.type !== 'toggle_info_modal') {
+                    renderInterface();
+                }
+            };
+            const handleConfirm = (selectedStates) => {
+                // Clean up listeners
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.removeAllListeners('keypress');
+                process.stdin.pause();
+                process.removeAllListeners('SIGWINCH');
+                resolve(selectedStates);
+            };
+            const handleCancel = () => {
+                // Clean up listeners
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.removeAllListeners('keypress');
+                process.stdin.pause();
+                process.removeAllListeners('SIGWINCH');
+                resolve(states.map((s) => ({ ...s, selectedOption: 'none' })));
+            };
+            const inputHandler = new ui_1.InputHandler(stateManager, handleAction, handleConfirm, handleCancel);
+            const renderInterface = () => {
+                const uiState = stateManager.getUIState();
+                if (uiState.isInitialRender) {
+                    console.clear();
+                }
+                else {
+                    // Move cursor to top and rewrite everything to minimize flicker
+                    process.stdout.write('\x1b[H');
+                }
+                // If modal is open, render only the modal with header/footer
+                if (uiState.showInfoModal && uiState.infoModalRow >= 0 && uiState.infoModalRow < states.length) {
+                    const selectedState = states[uiState.infoModalRow];
+                    const terminalWidth = process.stdout.columns || 80;
+                    const terminalHeight = this.getTerminalHeight();
+                    // Render header
+                    const headerLines = [];
+                    headerLines.push('  ' + chalk_1.default.bold.magenta('🚀 inup'));
+                    headerLines.push('');
+                    headerLines.push('  ' +
+                        chalk_1.default.bold.white('I / Esc ') +
+                        chalk_1.default.gray('Exit this view'));
+                    headerLines.push('');
+                    headerLines.forEach((line) => console.log(line));
+                    if (uiState.isLoadingModalInfo) {
+                        // Show loading state
+                        const modalLines = this.renderer.renderPackageInfoLoading(selectedState, terminalWidth, terminalHeight);
+                        modalLines.forEach((line) => console.log(line));
+                    }
+                    else {
+                        // Show full info
+                        const modalLines = this.renderer.renderPackageInfoModal(selectedState, terminalWidth, terminalHeight);
+                        modalLines.forEach((line) => console.log(line));
+                    }
+                    // Clear any remaining lines from previous render
+                    process.stdout.write('\x1b[J');
+                    stateManager.markRendered([]);
+                }
+                else {
+                    // Normal list view (flat rendering - no grouping)
+                    const lines = this.renderer.renderInterface(states, uiState.currentRow, uiState.scrollOffset, uiState.maxVisibleItems, uiState.isInitialRender, [], // No renderable items - use flat rendering
+                    dependencyTypeLabel, // Show which dependency type we're upgrading
+                    this.packageManager // Pass package manager info for header
+                    );
+                    // Print all lines
+                    lines.forEach((line) => console.log(line));
+                    // Clear any remaining lines from previous render
+                    if (!uiState.isInitialRender) {
+                        process.stdout.write('\x1b[J');
+                    }
+                    stateManager.markRendered(lines);
+                }
+                stateManager.setInitialRender(false);
+            };
+            const handleResize = () => {
+                // On resize (width or height change), always trigger a re-render
+                // This prevents layout breaking when terminal width changes
+                // The action handler will update height and force a full re-render
+                inputHandler.handleResize(this.getTerminalHeight());
+            };
+            // Setup keypress handling
+            try {
+                keypress(process.stdin);
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(true);
+                }
+                process.stdin.resume();
+                process.stdin.on('keypress', (str, key) => inputHandler.handleKeypress(str, key, states));
+                // Setup resize handler
+                process.on('SIGWINCH', handleResize);
+                // Update terminal height directly before initial render to ensure correct dimensions
+                // This handles cases where process.stdout.rows might not be accurate at startup
+                const currentHeight = this.getTerminalHeight();
+                if (stateManager.updateTerminalHeight(currentHeight)) {
+                    stateManager.resetForResize();
+                }
+                // Initial render
+                renderInterface();
+            }
+            catch (error) {
+                // Fallback to simple interface if raw mode fails
+                console.log(chalk_1.default.yellow('Raw mode not available, using fallback interface...'));
+                resolve(states);
+            }
+        });
+    }
+    async confirmUpgrade(choices) {
+        console.log(this.renderer.renderConfirmation(choices));
+        return new Promise((resolve) => {
+            const handleConfirm = (confirmed) => {
+                resolve(confirmed);
+            };
+            const inputHandler = new ui_1.ConfirmationInputHandler(handleConfirm);
+            // Setup keypress handling
+            try {
+                keypress(process.stdin);
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(true);
+                }
+                process.stdin.resume();
+                process.stdin.on('keypress', (str, key) => inputHandler.handleKeypress(str, key));
+            }
+            catch (error) {
+                // Fallback to inquirer
+                inquirer_1.default
+                    .prompt([
+                    {
+                        type: 'confirm',
+                        name: 'proceed',
+                        message: 'Proceed with upgrade?',
+                        default: true,
+                    },
+                ])
+                    .then((answer) => resolve(answer.proceed))
+                    .catch(() => resolve(false));
+            }
+        });
+    }
+}
+exports.InteractiveUI = InteractiveUI;
+//# sourceMappingURL=interactive-ui.js.map