inup 1.5.0 → 1.5.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Donfear
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,49 +1,45 @@
-# 🚀 inup
+# inup — Interactive Dependency Upgrader
 
 [![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)
+[![CI](https://img.shields.io/github/actions/workflow/status/donfear/inup/ci.yml?branch=main&style=for-the-badge&label=CI)](https://github.com/donfear/inup/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://github.com/donfear/inup/blob/main/LICENSE)
 
-Upgrade your dependencies interactively. Works with npm, yarn, pnpm, and bun.
+Interactively upgrade outdated dependencies across npm, yarn, pnpm, and bun. Auto-detects your package manager, works in monorepos and workspaces, and requires zero configuration.
 
 ![Interactive Upgrade Demo](docs/demo/interactive-upgrade.gif)
 
-## 🚀 Usage
+## Quick Start
 
 ```bash
 npx inup
 ```
 
-Or install globally:
+Or install globally with your preferred package manager:
 
 ```bash
 npm install -g inup
+pnpm add -g inup
+yarn global add inup
+bun add -g inup
 ```
 
-That's it. The tool scans your project, finds outdated packages, and lets you pick what to upgrade.
+Run `inup` in any project — it scans for outdated packages and lets you pick what to upgrade.
 
-## 💡 Why inup?
+## Why inup?
 
-- **Inclusive by Default**: We load Dev, Peer, and Optional dependencies automatically. No more restarting the tool because you forgot a `--peer` flag.
-- **Live Toggles**: Toggle dependency types (`d`, `p`, `o`) on the fly without exiting.
-- **Zero Config**: Auto-detects your package manager.
-- **Monorepo Ready**: Seamlessly handles workspaces.
-- **Modern UX**: Search with `/`, view package details with `i`, and swap themes with `t`.
+- **All Dependencies at Once** — Dev, peer, and optional dependencies load automatically. No more re-running with `--peer` or `--dev` flags.
+- **Live Toggles** — Filter dependency types (`d`, `p`, `o`) on the fly without restarting.
+- **Zero Config** — Auto-detects npm, yarn, pnpm, or bun from your lockfile.
+- **Monorepo Ready** — Discovers and upgrades across workspaces seamlessly.
+- **Vulnerability Audit** — Flags known security vulnerabilities right in the package list so you know what's risky before upgrading.
+- **Changelog Viewer** — Read release notes and changelogs inline without leaving the terminal.
+- **Built-in Search** — Press `/` to filter packages instantly.
+- **Package Details** — Press `i` to view package info, download stats, and more.
+- **Themes** — Press `t` to switch between color themes.
 
-## ⌨️ Keyboard Shortcuts
-
-- `↑/↓` - Navigate packages
-- `←/→` - Select version (current, patch, minor, major)
-- `Space` - Toggle selection
-- `m` - Select all minor updates
-- `l` - Select all latest updates
-- `u` - Unselect all
-- `/` - Search packages
-- `t` - Change theme
-- `i` - View package info
-- `Enter` - Confirm and upgrade
-
-## ⚙️ Options
+## Options
 
 ```bash
 inup [options]
@@ -56,12 +52,25 @@ inup [options]
 --debug                       Write verbose debug logs
 ```
 
-## 🔒 Privacy
+## Keyboard Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `↑` `↓` | Navigate packages |
+| `←` `→` | Select version (current, patch, minor, major) |
+| `Space` | Toggle selection |
+| `m` | Select all minor updates |
+| `l` | Select all latest updates |
+| `u` | Unselect all |
+| `/` | Search packages |
+| `i` | View package info |
+| `t` | Change theme |
+| `Enter` | Confirm and upgrade |
 
-We don't track anything. Ever.
+## Privacy
 
-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.
+No tracking, no telemetry, no data collection. Package metadata is fetched directly from the npm registry. Download counts come from the npm downloads API. When needed for exact-version manifests, inup may fetch a pinned `package.json` from jsDelivr.
 
-## 📄 License
+## License
 
-MIT
+[MIT](LICENSE)

package/dist/cli.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const fs_1 = require("fs");
@@ -12,23 +13,23 @@ const index_1 = require("./index");
 const services_1 = require("./services");
 const config_1 = require("./config");
 const utils_1 = require("./utils");
+const git_1 = require("./utils/git");
+const terminal_input_1 = require("./ui/utils/terminal-input");
 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('-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) => {
+async function runCli(options) {
     const cwd = (0, path_1.resolve)(options.dir);
     if (options.debug || process.env.INUP_DEBUG === '1') {
         (0, utils_1.enableDebugLogging)();
     }
+    const gitState = (0, git_1.getGitWorkingTreeState)(cwd);
+    if (gitState.isRepo && gitState.isDirty) {
+        const shouldProceed = await terminal_input_1.TerminalInput.promptForImmediateConfirmation(`${chalk_1.default.yellow('Warning:')} dirty working tree. Proceed anyway? ${chalk_1.default.dim('[y/N]')} `, false);
+        if (!shouldProceed) {
+            console.log(chalk_1.default.yellow('Upgrade cancelled.'));
+            return;
+        }
+    }
     // Load project config from .inuprc
     const projectConfig = (0, config_1.loadProjectConfig)(cwd);
     // Merge CLI exclude patterns with config
@@ -99,7 +100,18 @@ program
         console.log(chalk_1.default.yellow('└' + '─'.repeat(78) + '┘'));
         console.log('');
     }
-});
+}
+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('-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(runCli);
 // Handle uncaught errors gracefully
 process.on('uncaughtException', (error) => {
     console.error(chalk_1.default.red('Uncaught Exception:'), error.message);
@@ -128,5 +140,7 @@ process.on('SIGTERM', () => {
     console.log(chalk_1.default.yellow('\n\nOperation cancelled.'));
     process.exit(0);
 });
-program.parse();
+if (require.main === module) {
+    program.parse();
+}
 //# sourceMappingURL=cli.js.map

package/dist/core/package-detector.js

@@ -40,12 +40,13 @@ const services_1 = require("../services");
 const config_1 = require("../config");
 const utils_2 = require("../ui/utils");
 const utils_3 = require("../utils");
+const debug_1 = require("../features/debug");
 class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
         this.batchSize = 25;
-        this.batchConcurrency = 5;
+        this.batchConcurrency = 25;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
@@ -89,9 +90,14 @@ class PackageDetector {
         const packageLookup = new Map();
         let resolved = 0;
         let failed = 0;
+        const performanceTracker = (0, debug_1.getPerformanceTracker)();
+        let batchIndex = 0;
+        let lastBatchEndAt = Date.now();
         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 batchStart = lastBatchEndAt;
+            let batchFailedCount = 0;
             const batchItems = batch.map((batchItem) => {
                 const packageInfo = this.resolvePackageGroup(batchItem.packageName, prepared.allDependencies, batchItem.data);
                 packageLookup.set(batchItem.packageName, packageInfo);
@@ -99,6 +105,8 @@ class PackageDetector {
                 const isFailed = batchItem.data.latestVersion === 'unknown';
                 if (isFailed) {
                     failed++;
+                    batchFailedCount++;
+                    performanceTracker.recordFailedPackage(batchItem.packageName);
                 }
                 return {
                     packageName: batchItem.packageName,
@@ -106,6 +114,15 @@ class PackageDetector {
                     failed: isFailed,
                 };
             });
+            const batchEnd = Date.now();
+            performanceTracker.recordBatch({
+                index: batchIndex++,
+                size: batch.length,
+                durationMs: batchEnd - batchStart,
+                failedCount: batchFailedCount,
+            });
+            lastBatchEndAt = batchEnd;
+            performanceTracker.recordCounts({ resolved, failed });
             const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, resolved < prepared.uniquePackages.length);
             onEvent({
                 type: 'batch',
@@ -119,6 +136,7 @@ class PackageDetector {
             concurrency: this.batchConcurrency,
         });
         utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
+        performanceTracker.recordPhaseDuration('registryFetch', Date.now() - 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);
@@ -133,12 +151,15 @@ class PackageDetector {
         return finalPackages;
     }
     async prepareDependencies() {
+        const performanceTracker = (0, debug_1.getPerformanceTracker)();
         this.showProgress('🔍 Scanning repository for package.json files...');
         const tScan = Date.now();
         const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000);
         utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
             files: allPackageJsonFiles,
         });
+        performanceTracker.recordPhaseDuration('discovery', Date.now() - tScan);
+        performanceTracker.recordCounts({ packageJsonFiles: allPackageJsonFiles.length });
         this.showProgress(`🔍 Found ${allPackageJsonFiles.length} package.json file${allPackageJsonFiles.length === 1 ? '' : 's'}`);
         this.showProgress('🔍 Reading dependencies from package.json files...');
         const tDeps = Date.now();
@@ -147,7 +168,10 @@ class PackageDetector {
             includeOptionalDeps: true,
         });
         utils_3.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
+        performanceTracker.recordPhaseDuration('depCollection', Date.now() - tDeps);
+        performanceTracker.recordCounts({ rawDependencies: allDepsRaw.length });
         this.showProgress('🔍 Identifying unique packages...');
+        const tFilter = Date.now();
         const uniquePackageNames = new Set();
         const allDependencies = [];
         let ignoredCount = 0;
@@ -191,6 +215,12 @@ class PackageDetector {
             return a.localeCompare(b);
         });
         utils_3.debugLog.info('PackageDetector', `${uniquePackages.length} unique packages to check, ${ignoredCount} ignored`);
+        performanceTracker.recordPhaseDuration('filter', Date.now() - tFilter);
+        performanceTracker.recordCounts({
+            uniquePackages: uniquePackages.length,
+            ignoredPackages: ignoredCount,
+            workspaceRefsSkipped: seenWorkspaceRefs.size,
+        });
         const currentVersions = new Map();
         for (const dep of allDependencies) {
             if (!currentVersions.has(dep.name)) {

package/dist/core/upgrade-runner.js

@@ -10,6 +10,7 @@ const interactive_ui_1 = require("../interactive-ui");
 const upgrader_1 = require("./upgrader");
 const package_manager_detector_1 = require("../services/package-manager-detector");
 const utils_1 = require("../ui/utils");
+const debug_1 = require("../features/debug");
 /**
  * Main orchestrator for the inup upgrade process
  */
@@ -35,6 +36,9 @@ class UpgradeRunner {
         try {
             // Check prerequisites
             this.checkPrerequisites();
+            const performanceTracker = (0, debug_1.getPerformanceTracker)();
+            performanceTracker.start();
+            performanceTracker.setPackageManager(this.packageManager.name);
             const progress = {
                 discovered: 0,
                 resolved: 0,
@@ -71,6 +75,7 @@ class UpgradeRunner {
                         progress.total = event.payload.progress.total;
                         progress.failed = event.payload.progress.failed;
                         progress.isLoading = event.payload.progress.isLoading;
+                        performanceTracker.mark('firstBatch');
                         this.ui.appendOutdatedBatchToSelectionStates(selectionStates, event.payload.batch, previousSelections);
                         refreshUI?.();
                     }
@@ -81,6 +86,8 @@ class UpgradeRunner {
                         progress.total = event.payload.progress.total;
                         progress.failed = event.payload.progress.failed;
                         progress.isLoading = event.payload.progress.isLoading;
+                        performanceTracker.mark('firstBatch');
+                        performanceTracker.mark('allLoaded');
                         refreshUI?.();
                     }
                 });

package/dist/features/debug/index.js

@@ -0,0 +1,20 @@
+"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 __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("./types/debug.types"), exports);
+__exportStar(require("./services/performance-tracker"), exports);
+__exportStar(require("./renderer/performance-modal"), exports);
+//# sourceMappingURL=index.js.map

package/dist/features/debug/renderer/performance-modal.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPerformanceModal = renderPerformanceModal;
+const chalk_1 = __importDefault(require("chalk"));
+const modal_1 = require("../../../ui/modal");
+function formatMs(value) {
+    if (value === undefined || value === null)
+        return chalk_1.default.gray('—');
+    return chalk_1.default.yellow(`${value} ms`);
+}
+function formatCount(value) {
+    if (value === undefined)
+        return chalk_1.default.gray('—');
+    return chalk_1.default.cyan(String(value));
+}
+function labelValue(label, value, labelWidth = 22) {
+    const padded = label.padEnd(labelWidth, ' ');
+    return `${chalk_1.default.white(padded)} ${value}`;
+}
+function buildSections(snapshot) {
+    const { phases, counts, batches, failedPackages, packageManager, totalMs } = snapshot;
+    const pinned = [
+        {
+            key: 'header',
+            rows: [
+                chalk_1.default.cyan('⚡ Performance'),
+                chalk_1.default.gray(`Package manager: ${packageManager ? chalk_1.default.white(packageManager) : chalk_1.default.gray('unknown')}`),
+            ],
+            required: true,
+            behavior: 'pinned',
+        },
+    ];
+    const bodyRows = [];
+    bodyRows.push(chalk_1.default.bold('Timings'));
+    bodyRows.push(labelValue('Discovery', formatMs(phases.discovery)));
+    bodyRows.push(labelValue('Dep collection', formatMs(phases.depCollection)));
+    bodyRows.push(labelValue('Filter', formatMs(phases.filter)));
+    bodyRows.push(labelValue('Registry fetch', formatMs(phases.registryFetch)));
+    bodyRows.push(labelValue('First batch ready', formatMs(phases.firstBatch)));
+    bodyRows.push(labelValue('All packages loaded', formatMs(phases.allLoaded)));
+    bodyRows.push(labelValue('Elapsed total', formatMs(totalMs ?? undefined)));
+    bodyRows.push('');
+    bodyRows.push(chalk_1.default.bold('Counts'));
+    bodyRows.push(labelValue('package.json files', formatCount(counts.packageJsonFiles)));
+    bodyRows.push(labelValue('Raw dependencies', formatCount(counts.rawDependencies)));
+    bodyRows.push(labelValue('Unique packages', formatCount(counts.uniquePackages)));
+    bodyRows.push(labelValue('Ignored', formatCount(counts.ignoredPackages)));
+    bodyRows.push(labelValue('Workspace refs', formatCount(counts.workspaceRefsSkipped)));
+    bodyRows.push(labelValue('Resolved', formatCount(counts.resolved)));
+    bodyRows.push(labelValue('Failed', formatCount(counts.failed)));
+    bodyRows.push('');
+    bodyRows.push(chalk_1.default.bold('Batches'));
+    if (batches.length > 0) {
+        const durations = batches.map((b) => b.durationMs);
+        const total = durations.reduce((a, b) => a + b, 0);
+        const avg = Math.round(total / batches.length);
+        const slowest = Math.max(...durations);
+        const slowestBatch = batches.find((b) => b.durationMs === slowest);
+        bodyRows.push(labelValue('Batch count', formatCount(batches.length)));
+        bodyRows.push(labelValue('Avg batch', formatMs(avg)));
+        bodyRows.push(labelValue('Slowest batch', `${formatMs(slowest)} ${chalk_1.default.gray(`(#${slowestBatch?.index})`)}`));
+    }
+    else {
+        bodyRows.push(chalk_1.default.gray('  (no batches recorded)'));
+    }
+    bodyRows.push('');
+    bodyRows.push(chalk_1.default.bold('Failures'));
+    if (failedPackages.length > 0) {
+        for (const name of failedPackages) {
+            bodyRows.push(`  ${chalk_1.default.red('✗')} ${name}`);
+        }
+    }
+    else {
+        bodyRows.push(chalk_1.default.gray('  (none)'));
+    }
+    const body = [
+        {
+            key: 'body',
+            rows: bodyRows,
+            required: true,
+            behavior: 'body',
+        },
+    ];
+    return { pinned, body };
+}
+function renderPerformanceModal(snapshot, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0) {
+    const modalWidth = (0, modal_1.getModalWidth)(terminalWidth, 60, 84);
+    const padding = Math.floor((terminalWidth - modalWidth) / 2);
+    const fixedModalHeight = Math.max(10, terminalHeight - 2);
+    const { pinned, body } = buildSections(snapshot);
+    const pinnedRowCount = pinned.reduce((sum, s) => sum + s.rows.length, 0);
+    // frame: top border + pinned rows + separator + body rows + bottom border
+    const availableForBody = Math.max(3, fixedModalHeight - 2 - pinnedRowCount - 1);
+    const bodyRows = body[0].rows;
+    const totalScrollableRows = bodyRows.length;
+    const needsScroll = totalScrollableRows > availableForBody;
+    const visibleBodyRows = needsScroll ? Math.max(1, availableForBody - 1) : availableForBody;
+    const maxScroll = Math.max(0, totalScrollableRows - visibleBodyRows);
+    const clampedOffset = Math.min(Math.max(0, scrollOffset), maxScroll);
+    const visibleSlice = bodyRows.slice(clampedOffset, clampedOffset + visibleBodyRows);
+    const lines = [];
+    const topPadding = Math.max(0, Math.floor((terminalHeight - fixedModalHeight) / 2));
+    for (let i = 0; i < topPadding; i++) {
+        lines.push('');
+    }
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╭' + '─'.repeat(modalWidth - 2) + '╮'));
+    for (const section of pinned) {
+        for (const row of section.rows) {
+            lines.push((0, modal_1.renderModalRow)(padding, modalWidth, row));
+        }
+    }
+    lines.push((0, modal_1.renderModalSeparator)(padding, modalWidth));
+    let renderedBodyRows = 0;
+    for (const row of visibleSlice) {
+        lines.push((0, modal_1.renderModalRow)(padding, modalWidth, row));
+        renderedBodyRows++;
+    }
+    const footer = needsScroll
+        ? chalk_1.default.gray(`Lines ${clampedOffset + 1}-${Math.min(clampedOffset + visibleBodyRows, totalScrollableRows)} of ${totalScrollableRows}`)
+        : null;
+    const usedContentRows = pinnedRowCount + 1 + renderedBodyRows + (footer ? 1 : 0);
+    const totalContentSlots = fixedModalHeight - 2;
+    const emptyRows = Math.max(0, totalContentSlots - usedContentRows);
+    for (let i = 0; i < emptyRows; i++) {
+        lines.push((0, modal_1.renderModalRow)(padding, modalWidth, ''));
+    }
+    if (footer) {
+        lines.push((0, modal_1.renderModalRow)(padding, modalWidth, footer));
+    }
+    lines.push(' '.repeat(padding) + chalk_1.default.gray('╰' + '─'.repeat(modalWidth - 2) + '╯'));
+    return {
+        lines,
+        maxScrollOffset: maxScroll,
+        totalContentRows: totalScrollableRows,
+        usesInternalScroll: needsScroll,
+    };
+}
+//# sourceMappingURL=performance-modal.js.map

package/dist/features/debug/services/performance-tracker.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPerformanceTracker = getPerformanceTracker;
+class PerformanceTracker {
+    constructor() {
+        this.startedAt = null;
+        this.phases = {};
+        this.counts = {};
+        this.batches = [];
+        this.failedPackages = [];
+        this.packageManager = null;
+    }
+    start() {
+        this.startedAt = Date.now();
+        this.phases = {};
+        this.counts = {};
+        this.batches = [];
+        this.failedPackages = [];
+        this.packageManager = null;
+    }
+    mark(phase) {
+        if (this.startedAt === null || this.phases[phase] !== undefined)
+            return;
+        this.phases[phase] = Date.now() - this.startedAt;
+    }
+    recordPhaseDuration(phase, durationMs) {
+        this.phases[phase] = durationMs;
+    }
+    recordCounts(partial) {
+        this.counts = { ...this.counts, ...partial };
+    }
+    recordBatch(batch) {
+        this.batches.push(batch);
+    }
+    recordFailedPackage(name) {
+        if (!this.failedPackages.includes(name)) {
+            this.failedPackages.push(name);
+        }
+    }
+    setPackageManager(name) {
+        this.packageManager = name;
+    }
+    snapshot() {
+        const totalMs = this.startedAt === null
+            ? null
+            : (this.phases.allLoaded ?? Date.now() - this.startedAt);
+        return {
+            startedAt: this.startedAt,
+            phases: { ...this.phases },
+            totalMs,
+            counts: { ...this.counts },
+            batches: [...this.batches],
+            failedPackages: [...this.failedPackages],
+            packageManager: this.packageManager,
+        };
+    }
+    reset() {
+        this.startedAt = null;
+        this.phases = {};
+        this.counts = {};
+        this.batches = [];
+        this.failedPackages = [];
+        this.packageManager = null;
+    }
+}
+let instance = null;
+function getPerformanceTracker() {
+    if (!instance)
+        instance = new PerformanceTracker();
+    return instance;
+}
+//# sourceMappingURL=performance-tracker.js.map

package/dist/features/debug/types/debug.types.js

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

package/dist/interactive-ui.js

@@ -43,6 +43,7 @@ const ui_1 = require("./ui");
 const controllers_1 = require("./ui/controllers");
 const themes_1 = require("./ui/themes");
 const themes_colors_1 = require("./ui/themes-colors");
+const debug_1 = require("./features/debug");
 const DEFAULT_VULNERABILITY_DISPLAY_OPTIONS = {
     showPeerDependencyVulnerabilities: false,
     showOptionalDependencyVulnerabilities: false,
@@ -236,6 +237,8 @@ class InteractiveUI {
             stateManager.setRenderableItems([]);
             // Track the current max scroll offset for the info modal
             let infoModalMaxScrollOffset = 0;
+            // Track the current max scroll offset for the debug modal
+            let debugModalMaxScrollOffset = 0;
             let previousViewportMode = null;
             let previousModalViewportLineCount = null;
             const handleAction = (action) => {
@@ -332,6 +335,19 @@ class InteractiveUI {
                             return;
                         }
                         break;
+                    case 'toggle_debug_modal':
+                        stateManager.toggleDebugModal();
+                        break;
+                    case 'scroll_debug_modal_up':
+                        if (!stateManager.scrollDebugModalUp()) {
+                            return;
+                        }
+                        break;
+                    case 'scroll_debug_modal_down':
+                        if (!stateManager.scrollDebugModalDown(debugModalMaxScrollOffset)) {
+                            return;
+                        }
+                        break;
                     case 'navigate_info_modal_version':
                         {
                             if (uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
@@ -511,6 +527,18 @@ class InteractiveUI {
                     const modalLines = this.renderer.renderThemeSelectorModal(themeManager.getCurrentTheme(), themeManager.getPreviewTheme(), terminalWidth, terminalHeight);
                     renderModalViewport('theme-modal', chalk_1.default.bold.white('T ') + chalk_1.default.gray('/ Esc Exit theme selector'), modalLines, terminalWidth, terminalHeight, bgCode);
                 }
+                else if (uiState.showDebugModal) {
+                    const terminalWidth = process.stdout.columns || 80;
+                    const terminalHeight = this.getTerminalHeight();
+                    const snapshot = (0, debug_1.getPerformanceTracker)().snapshot();
+                    const result = (0, debug_1.renderPerformanceModal)(snapshot, terminalWidth, Math.max(8, terminalHeight - 4), uiState.debugModalScrollOffset);
+                    debugModalMaxScrollOffset = result.maxScrollOffset;
+                    stateManager.clampDebugModalScrollOffset(debugModalMaxScrollOffset);
+                    const scrollHint = result.usesInternalScroll && result.maxScrollOffset > 0
+                        ? chalk_1.default.bold.white('↑/↓ ') + chalk_1.default.gray('Scroll  ·  ')
+                        : '';
+                    renderModalViewport('info-modal', scrollHint + chalk_1.default.bold.white('! / Esc ') + chalk_1.default.gray('Close'), result.lines, terminalWidth, terminalHeight, bgCode);
+                }
                 else if (uiState.showInfoModal &&
                     uiState.infoModalRow >= 0 &&
                     uiState.infoModalRow < filteredStates.length) {

package/dist/services/npm-registry.js

@@ -36,11 +36,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllPackageData = getAllPackageData;
 exports.getAllPackageDataBatched = getAllPackageDataBatched;
 exports.clearPackageCache = clearPackageCache;
+exports.closeRegistryPool = closeRegistryPool;
 const semver = __importStar(require("semver"));
+const undici_1 = require("undici");
+const node_zlib_1 = require("node:zlib");
+const node_util_1 = require("node:util");
+const gunzipAsync = (0, node_util_1.promisify)(node_zlib_1.gunzip);
+const inflateAsync = (0, node_util_1.promisify)(node_zlib_1.inflate);
+const brotliDecompressAsync = (0, node_util_1.promisify)(node_zlib_1.brotliDecompress);
 const config_1 = require("../config");
 const jsdelivr_registry_1 = require("./jsdelivr-registry");
 const utils_1 = require("../ui/utils");
 const inFlightLookups = new Map();
+const registryOrigin = new URL(config_1.NPM_REGISTRY_URL).origin;
+const registryPathPrefix = new URL(config_1.NPM_REGISTRY_URL).pathname.replace(/\/$/, '');
+const registryPool = new undici_1.Pool(registryOrigin, {
+    connections: 64,
+    pipelining: 10,
+    keepAliveTimeout: 30000,
+    keepAliveMaxTimeout: 600000,
+    headersTimeout: config_1.REQUEST_TIMEOUT,
+    bodyTimeout: config_1.REQUEST_TIMEOUT,
+    allowH2: false,
+});
 const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
 const isTransientNetworkError = (error) => {
     if (!(error instanceof Error)) {
@@ -48,6 +66,14 @@ const isTransientNetworkError = (error) => {
     }
     const maybeCode = error.code;
     return (error.name === 'AbortError' ||
+        error.name === 'HeadersTimeoutError' ||
+        error.name === 'BodyTimeoutError' ||
+        error.name === 'ConnectTimeoutError' ||
+        error.name === 'SocketError' ||
+        maybeCode === 'UND_ERR_HEADERS_TIMEOUT' ||
+        maybeCode === 'UND_ERR_BODY_TIMEOUT' ||
+        maybeCode === 'UND_ERR_CONNECT_TIMEOUT' ||
+        maybeCode === 'UND_ERR_SOCKET' ||
         maybeCode === 'ENOTFOUND' ||
         maybeCode === 'EAI_AGAIN' ||
         maybeCode === 'ECONNRESET' ||
@@ -71,43 +97,56 @@ async function getFreshPackageData(packageName, currentVersion) {
     inFlightLookups.set(cacheKey, lookupPromise);
     return await lookupPromise;
 }
-/**
- * Fetches package data from npm registry.
- * Falls back to jsDelivr when npm is temporarily unavailable.
- */
+function parseVersions(raw) {
+    const data = JSON.parse(raw);
+    const allVersions = Object.keys(data.versions || {}).filter((v) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(v));
+    const sortedVersions = allVersions.sort(semver.rcompare);
+    const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
+    return { latestVersion, allVersions };
+}
 async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
     try {
-        const url = `${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), config_1.REQUEST_TIMEOUT);
-        try {
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: {
-                    accept: 'application/vnd.npm.install-v1+json',
-                },
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                if (isRetryableStatus(response.status)) {
-                    return await fetchFromJsdelivrFallback(packageName, currentVersion);
-                }
-                throw new Error(`HTTP ${response.status}`);
+        const encodedName = packageName.startsWith('@')
+            ? `@${encodeURIComponent(packageName.slice(1).split('/')[0])}/${encodeURIComponent(packageName.slice(packageName.indexOf('/') + 1))}`
+            : encodeURIComponent(packageName);
+        const path = `${registryPathPrefix}/${encodedName}`;
+        const { statusCode, headers, body } = await registryPool.request({
+            path,
+            method: 'GET',
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json',
+                'accept-encoding': 'gzip, deflate, br',
+            },
+            headersTimeout: config_1.REQUEST_TIMEOUT,
+            bodyTimeout: config_1.REQUEST_TIMEOUT,
+            blocking: false,
+        });
+        if (statusCode < 200 || statusCode >= 300) {
+            await body.dump();
+            if (isRetryableStatus(statusCode)) {
+                return await fetchFromJsdelivrFallback(packageName, currentVersion);
             }
-            const text = await response.text();
-            const data = JSON.parse(text);
-            const allVersions = Object.keys(data.versions || {}).filter((version) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version));
-            const sortedVersions = allVersions.sort(semver.rcompare);
-            const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
-            return {
-                latestVersion,
-                allVersions,
-            };
+            return { latestVersion: 'unknown', allVersions: [] };
         }
-        finally {
-            clearTimeout(timeoutId);
+        const raw = Buffer.from(await body.arrayBuffer());
+        const encodingHeader = headers['content-encoding'];
+        const encoding = (Array.isArray(encodingHeader) ? encodingHeader[0] : encodingHeader)
+            ?.toString()
+            .toLowerCase();
+        let decoded;
+        if (encoding === 'gzip') {
+            decoded = await gunzipAsync(raw);
         }
+        else if (encoding === 'br') {
+            decoded = await brotliDecompressAsync(raw);
+        }
+        else if (encoding === 'deflate') {
+            decoded = await inflateAsync(raw);
+        }
+        else {
+            decoded = raw;
+        }
+        return parseVersions(decoded.toString('utf8'));
     }
     catch (error) {
         if (isTransientNetworkError(error)) {
@@ -118,7 +157,7 @@ async function fetchPackageFromRegistryWithFallback(packageName, currentVersion)
 }
 /**
  * Fetches package version data from npm registry for multiple packages.
- * Uses native fetch with timeout support for reliable performance.
+ * Uses an undici Pool with HTTP/1.1 pipelining for high throughput.
  * Only returns valid semantic versions (X.Y.Z format, excluding pre-releases).
  */
 async function getAllPackageData(packageNames, onProgress, currentVersions) {
@@ -136,9 +175,7 @@ async function getAllPackageData(packageNames, onProgress, currentVersions) {
             onProgress(packageName, completedCount, total);
         }
     });
-    // Wait for all requests to complete
     await Promise.all(allPromises);
-    // Clear the progress line if no custom progress handler
     if (!onProgress) {
         utils_1.ConsoleUtils.clearProgress();
     }
@@ -171,11 +208,23 @@ async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersi
     let completedCount = 0;
     let batchStart = 0;
     let batchIndex = 0;
+    const batchPromises = [];
+    const pendingEmissions = new Map();
+    let nextEmitIndex = 0;
+    const flushPending = () => {
+        while (pendingEmissions.has(nextEmitIndex)) {
+            const ready = pendingEmissions.get(nextEmitIndex);
+            pendingEmissions.delete(nextEmitIndex);
+            onBatchReady?.(ready);
+            nextEmitIndex++;
+        }
+    };
     while (batchStart < packageNames.length) {
         const batchSize = batchSizes[Math.min(batchIndex, batchSizes.length - 1)];
         const batchNames = packageNames.slice(batchStart, batchStart + batchSize);
+        const capturedBatchIndex = batchIndex;
         const batchResults = new Array(batchNames.length);
-        await runWithConcurrencyLimit(batchNames, concurrency, async (packageName, itemIndex) => {
+        const batchPromise = runWithConcurrencyLimit(batchNames, concurrency, async (packageName, itemIndex) => {
             const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
             packageData.set(packageName, data);
             completedCount++;
@@ -184,14 +233,18 @@ async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersi
                 data,
                 completed: completedCount,
                 total,
-                batchIndex,
+                batchIndex: capturedBatchIndex,
                 itemIndex,
             };
+        }).then(() => {
+            pendingEmissions.set(capturedBatchIndex, batchResults.filter(Boolean));
+            flushPending();
         });
-        onBatchReady?.(batchResults.filter(Boolean));
+        batchPromises.push(batchPromise);
         batchStart += batchSize;
         batchIndex++;
     }
+    await Promise.all(batchPromises);
     return packageData;
 }
 /**
@@ -200,4 +253,7 @@ async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersi
 function clearPackageCache() {
     inFlightLookups.clear();
 }
+async function closeRegistryPool() {
+    await registryPool.close();
+}
 //# sourceMappingURL=npm-registry.js.map

package/dist/ui/input-handler.js

@@ -47,6 +47,29 @@ class InputHandler {
             }
             return;
         }
+        // Handle debug modal input (scroll and close)
+        if (uiState.showDebugModal) {
+            if (str === '!') {
+                this.onAction({ type: 'toggle_debug_modal' });
+                return;
+            }
+            if (key) {
+                switch (key.name) {
+                    case 'escape':
+                        this.onAction({ type: 'toggle_debug_modal' });
+                        return;
+                    case 'up':
+                        this.onAction({ type: 'scroll_debug_modal_up' });
+                        return;
+                    case 'down':
+                        this.onAction({ type: 'scroll_debug_modal_down' });
+                        return;
+                    default:
+                        return; // consume other keys while modal is open
+                }
+            }
+            return;
+        }
         // Handle info modal input (scroll and close)
         if (uiState.showInfoModal) {
             if (key) {
@@ -76,6 +99,11 @@ class InputHandler {
             }
             return;
         }
+        // '!' toggles the debug/performance modal (outside of filter mode)
+        if (str === '!' && !uiState.filterMode) {
+            this.onAction({ type: 'toggle_debug_modal' });
+            return;
+        }
         // Check for '/' character to handle filter mode (only when not in modal)
         if (str === '/') {
             if (uiState.filterMode) {

package/dist/ui/state/modal-manager.js

@@ -9,8 +9,42 @@ class ModalManager {
             isLoadingModalInfo: false,
             infoModalScrollOffset: 0,
             infoModalSessionId: 0,
+            showDebugModal: false,
+            debugModalScrollOffset: 0,
         };
     }
+    isDebugModalOpen() {
+        return this.state.showDebugModal;
+    }
+    toggleDebugModal() {
+        this.state.showDebugModal = !this.state.showDebugModal;
+        this.state.debugModalScrollOffset = 0;
+    }
+    closeDebugModal() {
+        this.state.showDebugModal = false;
+        this.state.debugModalScrollOffset = 0;
+    }
+    scrollDebugModalUp() {
+        if (this.state.debugModalScrollOffset > 0) {
+            this.state.debugModalScrollOffset--;
+            return true;
+        }
+        return false;
+    }
+    scrollDebugModalDown(maxOffset) {
+        if (this.state.debugModalScrollOffset < maxOffset) {
+            this.state.debugModalScrollOffset++;
+            return true;
+        }
+        return false;
+    }
+    clampDebugModalScrollOffset(maxOffset) {
+        const nextOffset = Math.max(0, Math.min(this.state.debugModalScrollOffset, maxOffset));
+        if (nextOffset === this.state.debugModalScrollOffset)
+            return false;
+        this.state.debugModalScrollOffset = nextOffset;
+        return true;
+    }
     getState() {
         return { ...this.state };
     }

package/dist/ui/state/state-manager.js

@@ -43,6 +43,8 @@ class StateManager {
             infoModalRow: modalState.infoModalRow,
             isLoadingModalInfo: modalState.isLoadingModalInfo,
             infoModalScrollOffset: modalState.infoModalScrollOffset,
+            showDebugModal: modalState.showDebugModal,
+            debugModalScrollOffset: modalState.debugModalScrollOffset,
             filterMode: filterState.filterMode,
             filterQuery: filterState.filterQuery,
             showThemeModal: themeState.showThemeModal,
@@ -187,6 +189,21 @@ class StateManager {
     clampInfoModalScrollOffset(maxOffset) {
         return this.modalManager.clampScrollOffset(maxOffset);
     }
+    toggleDebugModal() {
+        this.modalManager.toggleDebugModal();
+    }
+    closeDebugModal() {
+        this.modalManager.closeDebugModal();
+    }
+    scrollDebugModalUp() {
+        return this.modalManager.scrollDebugModalUp();
+    }
+    scrollDebugModalDown(maxOffset) {
+        return this.modalManager.scrollDebugModalDown(maxOffset);
+    }
+    clampDebugModalScrollOffset(maxOffset) {
+        return this.modalManager.clampDebugModalScrollOffset(maxOffset);
+    }
     // Filter delegation
     enterFilterMode(preserveQuery = false) {
         this.filterManager.enterFilterMode(preserveQuery);

package/dist/ui/utils/terminal-input.js

@@ -60,7 +60,7 @@ exports.TerminalInput = {
             },
         };
     },
-    promptForConfirmation(prompt) {
+    promptForConfirmation(prompt, defaultValue = true) {
         return new Promise((resolve) => {
             const rl = readline.createInterface({
                 input: process.stdin,
@@ -73,10 +73,53 @@ exports.TerminalInput = {
             };
             rl.question(prompt, (answer) => {
                 const normalizedAnswer = answer.trim().toLowerCase();
-                finish(normalizedAnswer === '' || normalizedAnswer === 'y' || normalizedAnswer === 'yes');
+                if (normalizedAnswer === '') {
+                    finish(defaultValue);
+                    return;
+                }
+                finish(normalizedAnswer === 'y' || normalizedAnswer === 'yes');
             });
             rl.on('SIGINT', () => finish(false));
         });
     },
+    promptForImmediateConfirmation(prompt, defaultValue = true) {
+        return new Promise((resolve) => {
+            process.stdout.write(prompt);
+            let cleanup = () => { };
+            const finish = (value) => {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(value);
+            };
+            try {
+                const session = exports.TerminalInput.startKeypressSession((str, key) => {
+                    const normalized = str.trim().toLowerCase();
+                    if (key.name === 'return' || key.name === 'enter') {
+                        finish(defaultValue);
+                        return;
+                    }
+                    if (normalized === 'y') {
+                        finish(true);
+                        return;
+                    }
+                    if (normalized === 'n') {
+                        finish(false);
+                        return;
+                    }
+                    if (key.ctrl && key.name === 'c') {
+                        finish(false);
+                    }
+                });
+                cleanup = () => {
+                    session.close();
+                };
+            }
+            catch {
+                exports.TerminalInput.promptForConfirmation(prompt, defaultValue)
+                    .then(resolve)
+                    .catch(() => resolve(false));
+            }
+        });
+    },
 };
 //# sourceMappingURL=terminal-input.js.map

package/dist/utils/git.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitWorkingTreeState = getGitWorkingTreeState;
+const child_process_1 = require("child_process");
+/**
+ * Detect whether cwd is a git work tree and whether it has local changes.
+ * Fail soft if git is unavailable or cwd is not a repository.
+ */
+function getGitWorkingTreeState(cwd) {
+    try {
+        const isInsideWorkTree = (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (isInsideWorkTree !== 'true') {
+            return { isRepo: false, isDirty: false };
+        }
+        const status = (0, child_process_1.execSync)('git status --porcelain', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return {
+            isRepo: true,
+            isDirty: status.trim().length > 0,
+        };
+    }
+    catch {
+        return { isRepo: false, isDirty: false };
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/utils/index.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectAllDependenciesAsync = exports.readPackageJsonAsync = void 0;
 __exportStar(require("./filesystem"), exports);
 __exportStar(require("./exec"), exports);
+__exportStar(require("./git"), exports);
 __exportStar(require("./version"), exports);
 __exportStar(require("./debug-logger"), exports);
 // Re-export async functions for convenience

package/package.json

@@ -1,26 +1,33 @@
 {
   "name": "inup",
-  "version": "1.5.0",
-  "description": "Interactive CLI tool for upgrading dependencies with ease. Auto-detects and works with npm, yarn, pnpm, and bun. Inspired by yarn upgrade-interactive. Supports monorepos, workspaces, and batch upgrades.",
+  "version": "1.5.2",
+  "description": "Interactive dependency upgrader for npm, yarn, pnpm & bun. Zero-config, monorepo-ready. Upgrade-interactive for every package manager.",
   "main": "dist/index.js",
   "bin": {
     "inup": "./dist/cli.js"
   },
   "author": "Donfear",
   "keywords": [
+    "upgrade-interactive",
+    "interactive",
+    "dependency-management",
+    "outdated",
+    "upgrade",
+    "update",
     "npm",
     "yarn",
     "pnpm",
     "bun",
-    "upgrade",
-    "interactive",
-    "cli",
-    "package-manager",
-    "dependency-management",
-    "yarn-upgrade-interactive",
     "monorepo",
     "workspace",
-    "batch-upgrade"
+    "cli",
+    "vulnerability",
+    "audit",
+    "changelog",
+    "package-manager",
+    "dependencies",
+    "semver",
+    "ncu"
   ],
   "license": "MIT",
   "homepage": "https://github.com/donfear/inup#readme",