inup 1.4.0

package/dist/services/package-manager-detector.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManagerDetector = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const PACKAGE_MANAGERS = {
+    npm: {
+        name: 'npm',
+        displayName: 'npm',
+        lockFile: 'package-lock.json',
+        workspaceFile: null, // Uses package.json workspaces field
+        installCommand: 'npm install',
+        color: chalk_1.default.red,
+    },
+    yarn: {
+        name: 'yarn',
+        displayName: 'yarn',
+        lockFile: 'yarn.lock',
+        workspaceFile: null, // Uses package.json workspaces field
+        installCommand: 'yarn install',
+        color: chalk_1.default.blue,
+    },
+    pnpm: {
+        name: 'pnpm',
+        displayName: 'pnpm',
+        lockFile: 'pnpm-lock.yaml',
+        workspaceFile: 'pnpm-workspace.yaml',
+        installCommand: 'pnpm install',
+        color: chalk_1.default.yellow,
+    },
+    bun: {
+        name: 'bun',
+        displayName: 'bun',
+        lockFile: 'bun.lockb',
+        workspaceFile: null, // Uses package.json workspaces field
+        installCommand: 'bun install',
+        color: chalk_1.default.magenta,
+    },
+};
+class PackageManagerDetector {
+    /**
+     * Detect package manager from packageManager field or lock files
+     */
+    static detect(cwd = process.cwd()) {
+        // 1. Check packageManager field in package.json
+        const fromPackageJson = this.detectFromPackageJson(cwd);
+        if (fromPackageJson) {
+            return fromPackageJson;
+        }
+        // 2. Check for lock files
+        const fromLockFile = this.detectFromLockFiles(cwd);
+        if (fromLockFile) {
+            return fromLockFile;
+        }
+        // 3. Fallback to npm
+        console.log(chalk_1.default.yellow('⚠️  No package manager detected. Defaulting to npm. Consider adding a "packageManager" field to your package.json.'));
+        return PACKAGE_MANAGERS.npm;
+    }
+    /**
+     * Detect from package.json packageManager field
+     */
+    static detectFromPackageJson(cwd) {
+        const packageJsonPath = (0, path_1.join)(cwd, 'package.json');
+        if (!(0, fs_1.existsSync)(packageJsonPath)) {
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(content);
+            if (packageJson.packageManager) {
+                // Parse format: "pnpm@10.28.1" or "npm@9.0.0+sha512.abc..."
+                const match = packageJson.packageManager.match(/^(npm|yarn|pnpm|bun)(@|$)/);
+                if (match) {
+                    const pmName = match[1];
+                    return PACKAGE_MANAGERS[pmName];
+                }
+            }
+        }
+        catch (error) {
+            // Invalid package.json, continue to lock file detection
+        }
+        return null;
+    }
+    /**
+     * Detect from lock files (with priority and recency)
+     */
+    static detectFromLockFiles(cwd) {
+        const lockFileChecks = [
+            { pm: PACKAGE_MANAGERS.pnpm, path: (0, path_1.join)(cwd, 'pnpm-lock.yaml') },
+            { pm: PACKAGE_MANAGERS.bun, path: (0, path_1.join)(cwd, 'bun.lockb') },
+            { pm: PACKAGE_MANAGERS.yarn, path: (0, path_1.join)(cwd, 'yarn.lock') },
+            { pm: PACKAGE_MANAGERS.npm, path: (0, path_1.join)(cwd, 'package-lock.json') },
+        ];
+        const existingLocks = lockFileChecks
+            .filter(({ path }) => (0, fs_1.existsSync)(path))
+            .map(({ pm, path }) => ({
+            pm,
+            path,
+            mtime: (0, fs_1.statSync)(path).mtime.getTime(),
+        }));
+        if (existingLocks.length === 0) {
+            return null;
+        }
+        // If multiple lock files, use most recently modified
+        if (existingLocks.length > 1) {
+            console.log(chalk_1.default.yellow('⚠️  Multiple lock files detected. Using most recently modified. Consider cleaning up unused lock files.'));
+            existingLocks.sort((a, b) => b.mtime - a.mtime);
+        }
+        return existingLocks[0].pm;
+    }
+    /**
+     * Get package manager info by name
+     */
+    static getInfo(name) {
+        return PACKAGE_MANAGERS[name];
+    }
+    /**
+     * Find workspace root for any package manager
+     */
+    static findWorkspaceRoot(cwd = process.cwd(), packageManager) {
+        const pmInfo = PACKAGE_MANAGERS[packageManager];
+        let currentDir = cwd;
+        while (currentDir !== (0, path_1.join)(currentDir, '..')) {
+            // Check for package manager-specific workspace file
+            if (pmInfo.workspaceFile) {
+                const workspaceFilePath = (0, path_1.join)(currentDir, pmInfo.workspaceFile);
+                if ((0, fs_1.existsSync)(workspaceFilePath)) {
+                    return currentDir;
+                }
+            }
+            else {
+                // Check for package.json with workspaces field
+                const packageJsonPath = (0, path_1.join)(currentDir, 'package.json');
+                if ((0, fs_1.existsSync)(packageJsonPath)) {
+                    try {
+                        const content = (0, fs_1.readFileSync)(packageJsonPath, 'utf-8');
+                        const packageJson = JSON.parse(content);
+                        // Check if workspaces field exists and is non-empty
+                        if (packageJson.workspaces) {
+                            if (Array.isArray(packageJson.workspaces) && packageJson.workspaces.length > 0) {
+                                return currentDir;
+                            }
+                            else if (typeof packageJson.workspaces === 'object' &&
+                                packageJson.workspaces.packages &&
+                                packageJson.workspaces.packages.length > 0) {
+                                // Yarn berry format: { packages: [...] }
+                                return currentDir;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // Invalid package.json, continue searching
+                    }
+                }
+            }
+            currentDir = (0, path_1.join)(currentDir, '..');
+        }
+        return null;
+    }
+    /**
+     * Check if directory is in a workspace
+     */
+    static isInWorkspace(cwd, packageManager) {
+        return this.findWorkspaceRoot(cwd, packageManager) !== null;
+    }
+}
+exports.PackageManagerDetector = PackageManagerDetector;
+//# sourceMappingURL=package-manager-detector.js.map

package/dist/services/version-checker.js

@@ -0,0 +1,92 @@
+"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.checkForUpdate = checkForUpdate;
+exports.checkForUpdateAsync = checkForUpdateAsync;
+const child_process_1 = require("child_process");
+const semver = __importStar(require("semver"));
+const constants_1 = require("../constants");
+/**
+ * Check if the current package version is outdated compared to npm registry
+ */
+async function checkForUpdate(packageName, currentVersion) {
+    try {
+        // Use npm view to get the latest version from registry
+        const result = (0, child_process_1.execSync)(`npm view ${packageName} version`, {
+            encoding: 'utf-8',
+            timeout: constants_1.REQUEST_TIMEOUT,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const latestVersion = result.trim();
+        // Compare versions
+        const isOutdated = semver.lt(currentVersion, latestVersion);
+        // Determine update command based on how the tool was likely invoked
+        // Check if we're running via npx (node_modules/.bin path indicates local/npx)
+        const isNpx = process.argv[1]?.includes('.npm') || process.argv[1]?.includes('_npx');
+        const updateCommand = isNpx ? `npx inup@latest` : `npm install -g inup@latest`;
+        return {
+            currentVersion,
+            latestVersion,
+            isOutdated,
+            updateCommand,
+        };
+    }
+    catch (error) {
+        // Silently fail - don't interrupt the user experience
+        return null;
+    }
+}
+/**
+ * Check for updates in the background without blocking
+ * Resolves immediately, result available via promise
+ */
+function checkForUpdateAsync(packageName, currentVersion) {
+    return new Promise((resolve) => {
+        // Set a timeout to prevent hanging
+        const timeout = setTimeout(() => {
+            resolve(null);
+        }, 5000);
+        checkForUpdate(packageName, currentVersion)
+            .then((result) => {
+            clearTimeout(timeout);
+            resolve(result);
+        })
+            .catch(() => {
+            clearTimeout(timeout);
+            resolve(null);
+        });
+    });
+}
+//# sourceMappingURL=version-checker.js.map

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/ui/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationInputHandler = exports.InputHandler = exports.UIRenderer = exports.StateManager = exports.VersionUtils = void 0;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "VersionUtils", { enumerable: true, get: function () { return utils_1.VersionUtils; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "StateManager", { enumerable: true, get: function () { return state_1.StateManager; } });
+var index_1 = require("./renderer/index");
+Object.defineProperty(exports, "UIRenderer", { enumerable: true, get: function () { return index_1.UIRenderer; } });
+var input_handler_1 = require("./input-handler");
+Object.defineProperty(exports, "InputHandler", { enumerable: true, get: function () { return input_handler_1.InputHandler; } });
+Object.defineProperty(exports, "ConfirmationInputHandler", { enumerable: true, get: function () { return input_handler_1.ConfirmationInputHandler; } });
+//# sourceMappingURL=index.js.map

package/dist/ui/input-handler.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationInputHandler = exports.InputHandler = void 0;
+class InputHandler {
+    constructor(stateManager, onAction, onConfirm, onCancel) {
+        this.stateManager = stateManager;
+        this.onAction = onAction;
+        this.onConfirm = onConfirm;
+        this.onCancel = onCancel;
+    }
+    handleKeypress(str, key, states) {
+        if (key.ctrl && key.name === 'c') {
+            process.exit(0);
+        }
+        switch (key.name) {
+            case 'up':
+                this.onAction({ type: 'navigate_up' });
+                break;
+            case 'down':
+                this.onAction({ type: 'navigate_down' });
+                break;
+            case 'left':
+                this.onAction({ type: 'select_left' });
+                break;
+            case 'right':
+                this.onAction({ type: 'select_right' });
+                break;
+            case 'return':
+                // Check if any packages are selected
+                const selectedCount = states.filter((s) => s.selectedOption !== 'none').length;
+                if (selectedCount === 0) {
+                    // Show warning and stay in selection mode
+                    console.log('\n' +
+                        '\x1b[33m⚠️  No packages selected. Press ↑/↓ to navigate and ←/→ to select versions, or ESC to exit.\x1b[39m');
+                    // Re-render will happen automatically
+                    return;
+                }
+                this.cleanup();
+                this.onConfirm(states);
+                return;
+            case 'm':
+            case 'M':
+                this.onAction({ type: 'bulk_select_minor' });
+                break;
+            case 'l':
+            case 'L':
+                this.onAction({ type: 'bulk_select_latest' });
+                break;
+            case 'u':
+            case 'U':
+                this.onAction({ type: 'bulk_unselect_all' });
+                break;
+            case 'i':
+            case 'I':
+                this.onAction({ type: 'toggle_info_modal' });
+                break;
+            case 'escape':
+                // Check if modal is open - if so, close it; otherwise cancel
+                const uiState = this.stateManager.getUIState();
+                if (uiState.showInfoModal) {
+                    this.onAction({ type: 'toggle_info_modal' });
+                }
+                else {
+                    this.onAction({ type: 'cancel' });
+                }
+                break;
+        }
+    }
+    handleResize(height) {
+        this.onAction({ type: 'resize', height });
+    }
+    cleanup() {
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+    }
+}
+exports.InputHandler = InputHandler;
+class ConfirmationInputHandler {
+    constructor(onConfirm) {
+        this.onConfirm = onConfirm;
+    }
+    handleKeypress(str, key) {
+        if (key.ctrl && key.name === 'c') {
+            process.exit(0);
+        }
+        switch (key.name) {
+            case 'y':
+            case 'return':
+                this.cleanup();
+                this.onConfirm(true);
+                break;
+            case 'n':
+                this.cleanup();
+                this.onConfirm(null); // Go back to selection
+                break;
+            case 'escape':
+                this.cleanup();
+                this.onConfirm(false); // Cancel
+                break;
+        }
+    }
+    cleanup() {
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+    }
+}
+exports.ConfirmationInputHandler = ConfirmationInputHandler;
+//# sourceMappingURL=input-handler.js.map

package/dist/ui/renderer/confirmation.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderConfirmation = renderConfirmation;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Render confirmation screen
+ */
+function renderConfirmation(choices) {
+    if (choices.length === 0) {
+        return chalk_1.default.yellow('No packages selected for upgrade.');
+    }
+    // Group choices by package name to show unique packages
+    const packagesByName = new Map();
+    choices.forEach((choice) => {
+        if (!packagesByName.has(choice.name)) {
+            packagesByName.set(choice.name, []);
+        }
+        packagesByName.get(choice.name).push(choice);
+    });
+    let output = chalk_1.default.bold(`\n🚀 Ready to upgrade ${packagesByName.size} package(s):\n`);
+    packagesByName.forEach((packageChoices, packageName) => {
+        // Use the first choice for display (they should all have the same target version for the same package)
+        const choice = packageChoices[0];
+        const upgradeTypeColor = choice.upgradeType === 'range' ? chalk_1.default.yellow : chalk_1.default.red;
+        const instancesText = packageChoices.length > 1 ? chalk_1.default.gray(` (${packageChoices.length} instances)`) : '';
+        output += `  • ${chalk_1.default.cyan(packageName)} → ${upgradeTypeColor(choice.targetVersion)} ${chalk_1.default.gray(`(${choice.upgradeType})`)}${instancesText}\n`;
+    });
+    output += chalk_1.default.gray('Press Enter/Y to proceed, N to go back to selection, ESC to cancel\n');
+    return output;
+}
+//# sourceMappingURL=confirmation.js.map

package/dist/ui/renderer/index.js

@@ -0,0 +1,77 @@
+"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 __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 });
+exports.UIRenderer = void 0;
+const PackageList = __importStar(require("./package-list"));
+const Confirmation = __importStar(require("./confirmation"));
+const Modal = __importStar(require("./modal"));
+/**
+ * Main UI renderer class that composes all rendering parts
+ */
+class UIRenderer {
+    renderPackageLine(state, index, isCurrentRow) {
+        return PackageList.renderPackageLine(state, index, isCurrentRow);
+    }
+    renderSectionHeader(title, sectionType) {
+        return PackageList.renderSectionHeader(title, sectionType);
+    }
+    renderSpacer() {
+        return PackageList.renderSpacer();
+    }
+    renderInterface(states, currentRow, scrollOffset, maxVisibleItems, isInitialRender, renderableItems, dependencyTypeLabel, packageManager) {
+        return PackageList.renderInterface(states, currentRow, scrollOffset, maxVisibleItems, isInitialRender, renderableItems, dependencyTypeLabel, packageManager);
+    }
+    renderPackagesTable(packages) {
+        return PackageList.renderPackagesTable(packages);
+    }
+    renderConfirmation(choices) {
+        return Confirmation.renderConfirmation(choices);
+    }
+    renderPackageInfoLoading(state, terminalWidth = 80, terminalHeight = 24) {
+        return Modal.renderPackageInfoLoading(state, terminalWidth, terminalHeight);
+    }
+    renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24) {
+        return Modal.renderPackageInfoModal(state, terminalWidth, terminalHeight);
+    }
+}
+exports.UIRenderer = UIRenderer;
+// Re-export all functions for direct use if needed
+__exportStar(require("./package-list"), exports);
+__exportStar(require("./confirmation"), exports);
+__exportStar(require("./modal"), exports);
+//# sourceMappingURL=index.js.map