inup 1.5.2 → 1.5.4

package/dist/core/package-detector.js

@@ -45,8 +45,8 @@ class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
-        this.batchSize = 25;
-        this.batchConcurrency = 25;
+        this.batchSize = 10;
+        this.maxConcurrency = 10;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
@@ -95,45 +95,47 @@ class PackageDetector {
         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);
-                resolved++;
-                const isFailed = batchItem.data.latestVersion === 'unknown';
-                if (isFailed) {
-                    failed++;
-                    batchFailedCount++;
-                    performanceTracker.recordFailedPackage(batchItem.packageName);
-                }
-                return {
-                    packageName: batchItem.packageName,
-                    packageInfo,
-                    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',
-                payload: {
-                    batch: batchItems,
-                    progress,
-                },
-            });
-        }, prepared.currentVersions, {
+        await (0, services_1.fetchPackageVersions)(prepared.uniquePackages, {
+            currentVersions: prepared.currentVersions,
             batchSize: this.batchSize,
-            concurrency: this.batchConcurrency,
+            maxConcurrency: this.maxConcurrency,
+            onBatchReady: (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);
+                    resolved++;
+                    const isFailed = batchItem.data.latestVersion === 'unknown';
+                    if (isFailed) {
+                        failed++;
+                        batchFailedCount++;
+                        performanceTracker.recordFailedPackage(batchItem.packageName);
+                    }
+                    return {
+                        packageName: batchItem.packageName,
+                        packageInfo,
+                        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',
+                    payload: {
+                        batch: batchItems,
+                        progress,
+                    },
+                });
+            },
         });
         utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
         performanceTracker.recordPhaseDuration('registryFetch', Date.now() - tFetch);

package/dist/interactive-ui.js

@@ -348,6 +348,11 @@ class InteractiveUI {
                             return;
                         }
                         break;
+                    case 'switch_info_modal_tab': {
+                        const nextTab = stateManager.getInfoModalTab() === 'info' ? 'usedBy' : 'info';
+                        stateManager.setInfoModalTab(nextTab);
+                        break;
+                    }
                     case 'navigate_info_modal_version':
                         {
                             if (uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
@@ -553,15 +558,20 @@ class InteractiveUI {
                     }
                     else {
                         // Show full info with scroll support
-                        const result = this.renderer.renderPackageInfoModal(selectedState, terminalWidth, Math.max(8, terminalHeight - 4), uiState.infoModalScrollOffset);
+                        const activeTab = uiState.infoModalTab;
+                        const result = this.renderer.renderPackageInfoModal(selectedState, terminalWidth, Math.max(8, terminalHeight - 4), uiState.infoModalScrollOffset, activeTab);
                         infoModalMaxScrollOffset = result.maxScrollOffset;
                         stateManager.clampInfoModalScrollOffset(infoModalMaxScrollOffset);
                         const scrollHint = result.usesInternalScroll && result.maxScrollOffset > 0
                             ? chalk_1.default.bold.white('↑/↓ ') + chalk_1.default.gray('Scroll  ·  ')
                             : '';
+                        const versionHint = activeTab === 'info'
+                            ? chalk_1.default.bold.white('←/→ ') + chalk_1.default.gray('Version  ·  ')
+                            : '';
                         renderModalViewport('info-modal', scrollHint +
-                            chalk_1.default.bold.white('←/→ ') +
-                            chalk_1.default.gray('Version  ·  ') +
+                            versionHint +
+                            chalk_1.default.bold.white('Tab ') +
+                            chalk_1.default.gray('Switch tab  ·  ') +
                             chalk_1.default.bold.white('I / Esc ') +
                             chalk_1.default.gray('Exit this view'), result.lines, terminalWidth, terminalHeight, bgCode);
                     }

package/dist/services/npm-registry.js

@@ -33,8 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllPackageData = getAllPackageData;
-exports.getAllPackageDataBatched = getAllPackageDataBatched;
+exports.fetchPackageVersions = fetchPackageVersions;
 exports.clearPackageCache = clearPackageCache;
 exports.closeRegistryPool = closeRegistryPool;
 const semver = __importStar(require("semver"));
@@ -46,19 +45,25 @@ 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(/\/$/, '');
+// Few connections + many requests per connection = maximum keep-alive reuse.
+// No per-request timeouts: correctness matters more than speed for a CLI that
+// runs on demand. Slow responses are tolerated; only true errors cause retry.
 const registryPool = new undici_1.Pool(registryOrigin, {
-    connections: 64,
-    pipelining: 10,
+    connections: 6,
+    pipelining: 1,
     keepAliveTimeout: 30000,
     keepAliveMaxTimeout: 600000,
-    headersTimeout: config_1.REQUEST_TIMEOUT,
-    bodyTimeout: config_1.REQUEST_TIMEOUT,
+    headersTimeout: 0,
+    bodyTimeout: 0,
+    connectTimeout: 15000,
     allowH2: false,
 });
+const MAX_REGISTRY_ATTEMPTS = 3;
+const RETRY_BACKOFF_MS = [500, 1500, 3000];
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
 const isTransientNetworkError = (error) => {
     if (!(error instanceof Error)) {
@@ -104,12 +109,14 @@ function parseVersions(raw) {
     const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
     return { latestVersion, allVersions };
 }
-async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
+const encodeRegistryPath = (packageName) => {
+    const encodedName = packageName.startsWith('@')
+        ? `@${encodeURIComponent(packageName.slice(1).split('/')[0])}/${encodeURIComponent(packageName.slice(packageName.indexOf('/') + 1))}`
+        : encodeURIComponent(packageName);
+    return `${registryPathPrefix}/${encodedName}`;
+};
+async function attemptRegistryFetch(path) {
     try {
-        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',
@@ -117,16 +124,16 @@ async function fetchPackageFromRegistryWithFallback(packageName, currentVersion)
                 accept: 'application/vnd.npm.install-v1+json',
                 'accept-encoding': 'gzip, deflate, br',
             },
-            headersTimeout: config_1.REQUEST_TIMEOUT,
-            bodyTimeout: config_1.REQUEST_TIMEOUT,
+            headersTimeout: 0,
+            bodyTimeout: 0,
             blocking: false,
         });
         if (statusCode < 200 || statusCode >= 300) {
-            await body.dump();
+            await body.dump().catch(() => undefined);
             if (isRetryableStatus(statusCode)) {
-                return await fetchFromJsdelivrFallback(packageName, currentVersion);
+                return { kind: 'retryable' };
             }
-            return { latestVersion: 'unknown', allVersions: [] };
+            return { kind: 'not-found' };
         }
         const raw = Buffer.from(await body.arrayBuffer());
         const encodingHeader = headers['content-encoding'];
@@ -146,97 +153,128 @@ async function fetchPackageFromRegistryWithFallback(packageName, currentVersion)
         else {
             decoded = raw;
         }
-        return parseVersions(decoded.toString('utf8'));
+        return { kind: 'success', data: parseVersions(decoded.toString('utf8')) };
     }
     catch (error) {
         if (isTransientNetworkError(error)) {
-            return await fetchFromJsdelivrFallback(packageName, currentVersion);
+            return { kind: 'transient' };
         }
-        return { latestVersion: 'unknown', allVersions: [] };
+        // Unknown error: treat as transient so we try the fallback rather than
+        // silently returning 'unknown'.
+        return { kind: 'transient' };
     }
 }
-/**
- * Fetches package version data from npm registry for multiple packages.
- * 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) {
-    const packageData = new Map();
-    if (packageNames.length === 0) {
-        return packageData;
-    }
-    const total = packageNames.length;
-    let completedCount = 0;
-    const allPromises = packageNames.map(async (packageName) => {
-        const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
-        packageData.set(packageName, data);
-        completedCount++;
-        if (onProgress) {
-            onProgress(packageName, completedCount, total);
+async function fetchFromRegistryWithRetries(path) {
+    let lastOutcome = { kind: 'transient' };
+    for (let attempt = 0; attempt < MAX_REGISTRY_ATTEMPTS; attempt++) {
+        const outcome = await attemptRegistryFetch(path);
+        if (outcome.kind === 'success' || outcome.kind === 'not-found') {
+            return outcome;
+        }
+        lastOutcome = outcome;
+        if (attempt < MAX_REGISTRY_ATTEMPTS - 1) {
+            const backoff = RETRY_BACKOFF_MS[Math.min(attempt, RETRY_BACKOFF_MS.length - 1)];
+            await sleep(backoff);
         }
-    });
-    await Promise.all(allPromises);
-    if (!onProgress) {
-        utils_1.ConsoleUtils.clearProgress();
     }
-    return packageData;
+    return lastOutcome;
 }
-async function runWithConcurrencyLimit(items, concurrency, worker) {
-    if (items.length === 0) {
-        return;
+async function fetchPackageFromRegistryWithFallback(packageName, currentVersion) {
+    const path = encodeRegistryPath(packageName);
+    const outcome = await fetchFromRegistryWithRetries(path);
+    if (outcome.kind === 'success') {
+        return outcome.data;
     }
-    const limit = Math.max(1, Math.min(concurrency, items.length));
-    let nextIndex = 0;
-    const runWorker = async () => {
-        while (nextIndex < items.length) {
-            const currentIndex = nextIndex++;
-            await worker(items[currentIndex], currentIndex);
-        }
-    };
-    await Promise.all(Array.from({ length: limit }, () => runWorker()));
+    if (outcome.kind === 'not-found') {
+        return { latestVersion: 'unknown', allVersions: [] };
+    }
+    // Only reach here after exhausted retries against real errors — try jsdelivr
+    // as last-resort safety net so we don't silently return 'unknown'.
+    const fallback = await fetchFromJsdelivrFallback(packageName, currentVersion).catch(() => null);
+    return fallback ?? { latestVersion: 'unknown', allVersions: [] };
 }
-async function getAllPackageDataBatched(packageNames, onBatchReady, currentVersions, options = {}) {
+/**
+ * Fetches version data for a list of packages from the npm registry.
+ *
+ * Concurrency model:
+ * - `maxConcurrency` is a global cap on in-flight fetches at any moment.
+ *   It doesn't interact with batch size — batches exist only to group
+ *   emissions for the UI.
+ * - No per-request timeouts: slow responses are allowed to finish. Real
+ *   network errors are retried with exponential backoff; after that, we
+ *   fall back to jsdelivr as a last resort. A result is never silently
+ *   dropped due to slowness.
+ *
+ * Callbacks:
+ * - `onBatchReady` fires once a whole emission batch has resolved, in
+ *   original batch order.
+ */
+async function fetchPackageVersions(packageNames, options = {}) {
     const packageData = new Map();
     if (packageNames.length === 0) {
         return packageData;
     }
     const batchSizes = options.batchSizes && options.batchSizes.length > 0
         ? options.batchSizes.map((size) => Math.max(1, size))
-        : [Math.max(1, options.batchSize ?? 20)];
-    const concurrency = Math.max(1, options.concurrency ?? 5);
+        : [Math.max(1, options.batchSize ?? 25)];
+    const maxConcurrency = Math.max(1, options.maxConcurrency ?? 10);
     const total = packageNames.length;
     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);
+            options.onBatchReady?.(ready);
             nextEmitIndex++;
         }
     };
+    // Global semaphore: `maxConcurrency` is the total in-flight cap across
+    // all batches. Batches don't gate concurrency — only emission order.
+    let inFlight = 0;
+    const waiters = [];
+    const acquire = async () => {
+        if (inFlight < maxConcurrency) {
+            inFlight++;
+            return;
+        }
+        await new Promise((resolve) => waiters.push(resolve));
+        inFlight++;
+    };
+    const release = () => {
+        inFlight--;
+        const next = waiters.shift();
+        if (next)
+            next();
+    };
+    const batchPromises = [];
+    let batchStart = 0;
+    let batchIndex = 0;
     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);
-        const batchPromise = runWithConcurrencyLimit(batchNames, concurrency, async (packageName, itemIndex) => {
-            const data = await getFreshPackageData(packageName, currentVersions?.get(packageName));
-            packageData.set(packageName, data);
-            completedCount++;
-            batchResults[itemIndex] = {
-                packageName,
-                data,
-                completed: completedCount,
-                total,
-                batchIndex: capturedBatchIndex,
-                itemIndex,
-            };
-        }).then(() => {
+        const batchPromise = Promise.all(batchNames.map(async (packageName, itemIndex) => {
+            await acquire();
+            try {
+                const data = await getFreshPackageData(packageName, options.currentVersions?.get(packageName));
+                packageData.set(packageName, data);
+                completedCount++;
+                batchResults[itemIndex] = {
+                    packageName,
+                    data,
+                    completed: completedCount,
+                    total,
+                    batchIndex: capturedBatchIndex,
+                    itemIndex,
+                };
+            }
+            finally {
+                release();
+            }
+        })).then(() => {
             pendingEmissions.set(capturedBatchIndex, batchResults.filter(Boolean));
             flushPending();
         });

package/dist/ui/input-handler.js

@@ -81,6 +81,9 @@ class InputHandler {
                     case 'I':
                         this.onAction({ type: 'toggle_info_modal' });
                         return;
+                    case 'tab':
+                        this.onAction({ type: 'switch_info_modal_tab' });
+                        return;
                     case 'up':
                         this.onAction({ type: 'scroll_info_modal_up' });
                         return;
@@ -88,10 +91,14 @@ class InputHandler {
                         this.onAction({ type: 'scroll_info_modal_down' });
                         return;
                     case 'left':
-                        this.onAction({ type: 'navigate_info_modal_version', direction: 'newer' });
+                        if (uiState.infoModalTab === 'info') {
+                            this.onAction({ type: 'navigate_info_modal_version', direction: 'newer' });
+                        }
                         return;
                     case 'right':
-                        this.onAction({ type: 'navigate_info_modal_version', direction: 'older' });
+                        if (uiState.infoModalTab === 'info') {
+                            this.onAction({ type: 'navigate_info_modal_version', direction: 'older' });
+                        }
                         return;
                     default:
                         return; // Consume all other keys while modal is open

package/dist/ui/modal/package-info-sections.js

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildReleaseNotesSections = buildReleaseNotesSections;
+exports.buildUsedBySections = buildUsedBySections;
 exports.buildPackageInfoSections = buildPackageInfoSections;
+const node_path_1 = __importDefault(require("node:path"));
 const chalk_1 = __importDefault(require("chalk"));
 const themes_colors_1 = require("../themes-colors");
 const vulnerability_1 = require("../presenters/vulnerability");
@@ -240,8 +242,47 @@ function formatNumber(num) {
         return (num / 1000).toFixed(1) + 'K';
     return num.toString();
 }
-function buildPackageInfoSections(state, modalWidth) {
-    const title = chalk_1.default.cyan.bold(`Package: ${state.name}`);
+function getUsedByPaths(state) {
+    return state.packageJsonPaths ?? [state.packageJsonPath];
+}
+function buildTabBarSuffix(activeTab, usedByCount) {
+    const styleFor = (tab) => tab === activeTab ? chalk_1.default.bold.underline : chalk_1.default.gray;
+    const usedByLabel = `Used by${usedByCount > 0 ? ` (${usedByCount})` : ''}`;
+    return ('  ' +
+        chalk_1.default.gray('[ ') +
+        styleFor('info')('Info') +
+        chalk_1.default.gray(' │ ') +
+        styleFor('usedBy')(usedByLabel) +
+        chalk_1.default.gray(' ]'));
+}
+function buildUsedBySections(state, modalWidth) {
+    const paths = getUsedByPaths(state);
+    const cwd = process.cwd();
+    const contentWidth = Math.max(10, modalWidth - 4);
+    const formatRelative = (absolutePath) => {
+        const display = node_path_1.default.relative(cwd, absolutePath) || absolutePath;
+        return (0, utils_1.truncatePlainText)(display, contentWidth);
+    };
+    return [
+        {
+            key: 'used-by-summary',
+            rows: [
+                chalk_1.default.bold(`${paths.length} package.json file${paths.length === 1 ? '' : 's'} depend on ${state.name}`),
+                chalk_1.default.gray(`Type: ${state.type}`),
+            ],
+            required: true,
+            behavior: 'pinned',
+        },
+        {
+            key: 'used-by-list',
+            rows: paths.map((p) => `${chalk_1.default.gray('•')} ${formatRelative(p)}`),
+            behavior: 'body',
+        },
+    ];
+}
+function buildPackageInfoSections(state, modalWidth, activeTab) {
+    const title = chalk_1.default.cyan.bold(`Package: ${state.name}`) +
+        buildTabBarSuffix(activeTab, getUsedByPaths(state).length);
     const authorLicense = chalk_1.default.gray(`${state.author || 'Unknown'} • ${state.license || 'MIT'}`);
     const currentVersion = chalk_1.default.yellow(state.currentVersionSpecifier);
     const targetVersion = chalk_1.default.green(state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion);
@@ -252,18 +293,22 @@ function buildPackageInfoSections(state, modalWidth) {
             required: true,
             behavior: 'pinned',
         },
-        {
-            key: 'meta',
-            rows: [
-                `Current: ${currentVersion}  Target: ${targetVersion}`,
-                ...(state.weeklyDownloads !== undefined
-                    ? [(0, themes_colors_1.getThemeColor)('primary')(`Downloads/week: ${formatNumber(state.weeklyDownloads)}`)]
-                    : []),
-            ],
-            required: true,
-            behavior: 'pinned',
-        },
     ];
+    if (activeTab === 'usedBy') {
+        sections.push(...buildUsedBySections(state, modalWidth));
+        return sections;
+    }
+    sections.push({
+        key: 'meta',
+        rows: [
+            `Current: ${currentVersion}  Target: ${targetVersion}`,
+            ...(state.weeklyDownloads !== undefined
+                ? [(0, themes_colors_1.getThemeColor)('primary')(`Downloads/week: ${formatNumber(state.weeklyDownloads)}`)]
+                : []),
+        ],
+        required: true,
+        behavior: 'pinned',
+    });
     if (state.homepage) {
         sections.push({
             key: 'homepage',

package/dist/ui/modal/package-info.js

@@ -29,9 +29,9 @@ function renderPackageInfoLoading(state, terminalWidth = 80, terminalHeight = 24
         usesInternalScroll: false,
     };
 }
-function renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0) {
+function renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0, activeTab = 'info') {
     const modalWidth = (0, layout_1.getModalWidth)(terminalWidth, 60, 120);
-    const allSections = (0, package_info_sections_1.buildPackageInfoSections)(state, modalWidth);
+    const allSections = (0, package_info_sections_1.buildPackageInfoSections)(state, modalWidth, activeTab);
     const maxHeight = Math.max(10, terminalHeight - 2);
     const trimOrder = ['homepage', 'changelog', 'description'];
     const compactSections = (0, layout_1.fitModalSections)(allSections, maxHeight, trimOrder);

package/dist/ui/renderer/index.js

@@ -65,8 +65,8 @@ class UIRenderer {
     renderPackageInfoLoading(state, terminalWidth = 80, terminalHeight = 24) {
         return Modal.renderPackageInfoLoading(state, terminalWidth, terminalHeight);
     }
-    renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0) {
-        return Modal.renderPackageInfoModal(state, terminalWidth, terminalHeight, scrollOffset);
+    renderPackageInfoModal(state, terminalWidth = 80, terminalHeight = 24, scrollOffset = 0, activeTab = 'info') {
+        return Modal.renderPackageInfoModal(state, terminalWidth, terminalHeight, scrollOffset, activeTab);
     }
     renderThemeSelectorModal(currentTheme, previewTheme, terminalWidth = 80, terminalHeight = 24) {
         return Modal.renderThemeSelectorModal(currentTheme, previewTheme, terminalWidth, terminalHeight);

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

@@ -9,10 +9,21 @@ class ModalManager {
             isLoadingModalInfo: false,
             infoModalScrollOffset: 0,
             infoModalSessionId: 0,
+            infoModalTab: 'info',
             showDebugModal: false,
             debugModalScrollOffset: 0,
         };
     }
+    getInfoModalTab() {
+        return this.state.infoModalTab;
+    }
+    setInfoModalTab(tab) {
+        if (this.state.infoModalTab === tab)
+            return false;
+        this.state.infoModalTab = tab;
+        this.state.infoModalScrollOffset = 0;
+        return true;
+    }
     isDebugModalOpen() {
         return this.state.showDebugModal;
     }
@@ -99,6 +110,7 @@ class ModalManager {
         this.state.infoModalRow = currentRow;
         this.state.infoModalScrollOffset = 0;
         this.state.isLoadingModalInfo = false;
+        this.state.infoModalTab = 'info';
         this.state.infoModalSessionId += 1;
         return this.state.infoModalSessionId;
     }
@@ -107,6 +119,7 @@ class ModalManager {
         this.state.infoModalRow = -1;
         this.state.isLoadingModalInfo = false;
         this.state.infoModalScrollOffset = 0;
+        this.state.infoModalTab = 'info';
         this.state.infoModalSessionId += 1;
     }
     setModalLoading(isLoading, sessionId) {

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

@@ -43,6 +43,7 @@ class StateManager {
             infoModalRow: modalState.infoModalRow,
             isLoadingModalInfo: modalState.isLoadingModalInfo,
             infoModalScrollOffset: modalState.infoModalScrollOffset,
+            infoModalTab: modalState.infoModalTab,
             showDebugModal: modalState.showDebugModal,
             debugModalScrollOffset: modalState.debugModalScrollOffset,
             filterMode: filterState.filterMode,
@@ -189,6 +190,16 @@ class StateManager {
     clampInfoModalScrollOffset(maxOffset) {
         return this.modalManager.clampScrollOffset(maxOffset);
     }
+    setInfoModalTab(tab) {
+        const changed = this.modalManager.setInfoModalTab(tab);
+        if (changed) {
+            this.renderState.forceFullRender = true;
+        }
+        return changed;
+    }
+    getInfoModalTab() {
+        return this.modalManager.getInfoModalTab();
+    }
     toggleDebugModal() {
         this.modalManager.toggleDebugModal();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inup",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "Interactive dependency upgrader for npm, yarn, pnpm & bun. Zero-config, monorepo-ready. Upgrade-interactive for every package manager.",
   "main": "dist/index.js",
   "bin": {