inup 1.4.6 → 1.4.8

package/dist/cli.js

@@ -11,6 +11,7 @@ const path_1 = require("path");
 const index_1 = require("./index");
 const services_1 = require("./services");
 const config_1 = require("./config");
+const utils_1 = require("./utils");
 const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf-8'));
 const program = new commander_1.Command();
 program
@@ -21,11 +22,15 @@ program
     .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('--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) => {
     console.log(chalk_1.default.bold.blue(`🚀 `) + chalk_1.default.bold.red(`i`) + chalk_1.default.bold.yellow(`n`) + chalk_1.default.bold.blue(`u`) + chalk_1.default.bold.magenta(`p`) + `\n`);
     // Check for updates in the background (non-blocking)
     const updateCheckPromise = (0, services_1.checkForUpdateAsync)('inup', packageJson.version);
     const cwd = (0, path_1.resolve)(options.dir);
+    if (options.debug || process.env.INUP_DEBUG === '1') {
+        (0, utils_1.enableDebugLogging)();
+    }
     // Load project config from .inuprc
     const projectConfig = (0, config_1.loadProjectConfig)(cwd);
     // Merge CLI exclude patterns with config
@@ -60,6 +65,7 @@ program
         excludePatterns,
         ignorePackages,
         packageManager,
+        debug: options.debug || process.env.INUP_DEBUG === '1',
     });
     await upgrader.run();
     // After the main flow completes, check if there's an update available

package/dist/config/constants.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_REGISTRY = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = exports.PACKAGE_NAME = void 0;
+exports.DEFAULT_REGISTRY = exports.JSDELIVR_POOL_TIMEOUT = exports.JSDELIVR_RETRY_DELAYS = exports.JSDELIVR_RETRY_TIMEOUTS = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = exports.PACKAGE_NAME = void 0;
 exports.PACKAGE_NAME = 'inup';
 exports.NPM_REGISTRY_URL = 'https://registry.npmjs.org';
 exports.JSDELIVR_CDN_URL = 'https://cdn.jsdelivr.net/npm';
 exports.MAX_CONCURRENT_REQUESTS = 150;
 exports.CACHE_TTL = 5 * 60 * 1000; // 5 minutes in milliseconds
 exports.REQUEST_TIMEOUT = 60000; // 60 seconds in milliseconds
+exports.JSDELIVR_RETRY_TIMEOUTS = [2000, 3500]; // short retry budget to keep fallback fast
+exports.JSDELIVR_RETRY_DELAYS = [150]; // tiny backoff between jsDelivr retries in ms
+exports.JSDELIVR_POOL_TIMEOUT = 60000; // keep-alive/connect lifecycle should be looser than per-request timeouts
 exports.DEFAULT_REGISTRY = 'jsdelivr';
 //# sourceMappingURL=constants.js.map

package/dist/core/package-detector.js

@@ -39,6 +39,7 @@ const utils_1 = require("../utils");
 const services_1 = require("../services");
 const config_1 = require("../config");
 const utils_2 = require("../ui/utils");
+const utils_3 = require("../utils");
 class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
@@ -59,27 +60,46 @@ class PackageDetector {
             throw new Error('No package.json found in current directory');
         }
         const packages = [];
+        const t0 = Date.now();
+        utils_3.debugLog.info('PackageDetector', `Starting scan in ${this.cwd}`);
         // Always check all package.json files recursively with timeout protection
         this.showProgress('🔍 Scanning repository for package.json files...');
+        const tScan = Date.now();
         const allPackageJsonFiles = this.findPackageJsonFilesWithTimeout(30000); // 30 second timeout
+        utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
+            files: allPackageJsonFiles,
+        });
         this.showProgress(`🔍 Found ${allPackageJsonFiles.length} package.json file${allPackageJsonFiles.length === 1 ? '' : 's'}`);
         // Step 2: Collect all dependencies from package.json files (parallelized)
         this.showProgress('🔍 Reading dependencies from package.json files...');
+        const tDeps = Date.now();
         const allDepsRaw = await (0, utils_1.collectAllDependenciesAsync)(allPackageJsonFiles, {
             includePeerDeps: true,
             includeOptionalDeps: true,
         });
+        utils_3.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
         // Step 3: Get unique package names while filtering out workspace references and ignored packages
         this.showProgress('🔍 Identifying unique packages...');
         const uniquePackageNames = new Set();
         const allDeps = [];
         let ignoredCount = 0;
+        const seenWorkspaceRefs = new Set();
+        const seenIgnored = new Set();
         for (const dep of allDepsRaw) {
             if (this.isWorkspaceReference(dep.version)) {
+                const key = `${dep.name}@${dep.version}`;
+                if (!seenWorkspaceRefs.has(key)) {
+                    seenWorkspaceRefs.add(key);
+                    utils_3.debugLog.info('PackageDetector', `skipping workspace ref: ${key}`);
+                }
                 continue;
             }
             if (this.ignorePackages.length > 0 && (0, config_1.isPackageIgnored)(dep.name, this.ignorePackages)) {
                 ignoredCount++;
+                if (!seenIgnored.has(dep.name)) {
+                    seenIgnored.add(dep.name);
+                    utils_3.debugLog.info('PackageDetector', `ignoring package: ${dep.name}`);
+                }
                 continue;
             }
             allDeps.push(dep);
@@ -89,6 +109,7 @@ class PackageDetector {
             this.showProgress(`🔍 Skipped ${ignoredCount} ignored package(s)`);
         }
         const packageNames = Array.from(uniquePackageNames);
+        utils_3.debugLog.info('PackageDetector', `${packageNames.length} unique packages to check, ${ignoredCount} ignored`);
         // Step 4: Fetch all package data in one call per package
         // Create a map of package names to their current versions for major version optimization
         const currentVersions = new Map();
@@ -98,6 +119,8 @@ class PackageDetector {
                 currentVersions.set(dep.name, dep.version);
             }
         }
+        const tFetch = Date.now();
+        utils_3.debugLog.info('PackageDetector', `fetching version data via ${config_1.DEFAULT_REGISTRY}`);
         const allPackageData = config_1.DEFAULT_REGISTRY === 'jsdelivr'
             ? await (0, services_1.getAllPackageDataFromJsdelivr)(packageNames, currentVersions, (_currentPackage, completed, total) => {
                 this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
@@ -105,12 +128,20 @@ class PackageDetector {
             : await (0, services_1.getAllPackageData)(packageNames, (_currentPackage, completed, total) => {
                 this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
             });
+        utils_3.debugLog.perf('PackageDetector', `registry fetch (${allPackageData.size}/${packageNames.length} resolved)`, tFetch);
+        const loggedOutdated = new Set();
+        const loggedNoData = new Set();
         try {
             for (const dep of allDeps) {
                 try {
                     const packageData = allPackageData.get(dep.name);
-                    if (!packageData)
+                    if (!packageData) {
+                        if (!loggedNoData.has(dep.name)) {
+                            loggedNoData.add(dep.name);
+                            utils_3.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — skipping`);
+                        }
                         continue;
+                    }
                     const { latestVersion, allVersions } = packageData;
                     // Find closest minor version (same major, higher minor) that satisfies the current range
                     // Falls back to patch updates if no minor updates are available
@@ -123,6 +154,13 @@ class PackageDetector {
                     const hasRangeUpdate = minorClean !== null && minorClean !== installedClean;
                     const hasMajorUpdate = semver.major(latestClean) > semver.major(installedClean);
                     const isOutdated = hasRangeUpdate || hasMajorUpdate;
+                    if (isOutdated) {
+                        const outdatedKey = `${dep.name}@${dep.version}`;
+                        if (!loggedOutdated.has(outdatedKey)) {
+                            loggedOutdated.add(outdatedKey);
+                            utils_3.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
+                        }
+                    }
                     packages.push({
                         name: dep.name,
                         currentVersion: dep.version, // Keep original version specifier with prefix
@@ -136,6 +174,7 @@ class PackageDetector {
                     });
                 }
                 catch (error) {
+                    utils_3.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
                     // Skip packages that can't be checked (private packages, etc.)
                     packages.push({
                         name: dep.name,
@@ -150,10 +189,13 @@ class PackageDetector {
                     });
                 }
             }
+            const outdatedCount = packages.filter((p) => p.isOutdated).length;
+            utils_3.debugLog.perf('PackageDetector', `total scan complete (${outdatedCount} outdated of ${packages.length} deps)`, t0);
             return packages;
         }
         catch (error) {
             this.showProgress('❌ Failed to check packages\n');
+            utils_3.debugLog.error('PackageDetector', 'fatal error during package check', error);
             throw error;
         }
     }

package/dist/core/upgrader.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const nanospinner_1 = require("nanospinner");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const child_process_1 = require("child_process");
 const utils_1 = require("../utils");
 class PackageUpgrader {
     constructor(packageManager) {
@@ -54,15 +55,14 @@ class PackageUpgrader {
                 `  ${this.packageManager.installCommand}\n`));
             return; // Skip install, let user do it manually
         }
-        const spinner = (0, nanospinner_1.createSpinner)(`Running ${this.packageManager.displayName} install...`).start();
-        try {
-            (0, utils_1.executeCommand)(this.packageManager.installCommand, installDir);
-            spinner.success();
-        }
-        catch (error) {
-            spinner.error();
-            console.error(chalk_1.default.red(`Error: ${error}`));
-            throw error;
+        console.log(chalk_1.default.cyan(`\n📦 Running ${this.packageManager.installCommand}...\n`));
+        const [cmd, ...args] = this.packageManager.installCommand.split(' ');
+        const result = (0, child_process_1.spawnSync)(cmd, args, {
+            cwd: installDir,
+            stdio: 'inherit',
+        });
+        if (result.status !== 0) {
+            throw new Error(`${this.packageManager.installCommand} exited with code ${result.status}`);
         }
     }
     groupChoicesByFileAndType(choices, packageInfos) {

package/dist/interactive-ui.js

@@ -237,7 +237,7 @@ class InteractiveUI {
                     case 'resize':
                         const heightChanged = stateManager.updateTerminalHeight(action.height);
                         if (heightChanged) {
-                            stateManager.resetForResize();
+                            stateManager.resetForResize(filteredStates.length);
                         }
                         else {
                             // Even if height didn't change, width might have changed
@@ -400,7 +400,8 @@ class InteractiveUI {
                 // This handles cases where process.stdout.rows might not be accurate at startup
                 const currentHeight = this.getTerminalHeight();
                 if (stateManager.updateTerminalHeight(currentHeight)) {
-                    stateManager.resetForResize();
+                    const initialFiltered = stateManager.getFilteredStates(states);
+                    stateManager.resetForResize(initialFiltered.length);
                 }
                 // Initial render
                 renderInterface();

package/dist/services/jsdelivr-registry.js

@@ -42,50 +42,250 @@ const config_1 = require("../config");
 const npm_registry_1 = require("./npm-registry");
 const cache_manager_1 = require("./cache-manager");
 const utils_1 = require("../ui/utils");
+const utils_2 = require("../utils");
+// Batch configuration for progressive loading
+const BATCH_SIZE = 5;
+const BATCH_TIMEOUT_MS = 500;
+const DEFAULT_JSDELIVR_RETRY_TIMEOUT_MS = 2000;
+const DEFAULT_JSDELIVR_POOL_TIMEOUT_MS = 60000;
+const MIN_JSDELIVR_CONNECT_TIMEOUT_MS = 500;
+const toPositiveInteger = (value) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : null;
+};
+const RETRY_TIMEOUTS = (() => {
+    const configured = Array.from(new Set(config_1.JSDELIVR_RETRY_TIMEOUTS.map(toPositiveInteger).filter((value) => value !== null))).sort((a, b) => a - b);
+    return configured.length > 0 ? configured : [DEFAULT_JSDELIVR_RETRY_TIMEOUT_MS];
+})();
+const RETRY_DELAYS = config_1.JSDELIVR_RETRY_DELAYS.map(toPositiveInteger).filter((value) => value !== null);
+const MAX_RETRY_AFTER_DELAY_MS = RETRY_TIMEOUTS[RETRY_TIMEOUTS.length - 1];
+const RETRY_AFTER_HEADER = 'retry-after';
+const parseRetryAfterMs = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds)) {
+        if (seconds <= 0) {
+            return null;
+        }
+        const delayMs = Math.floor(seconds * 1000);
+        return delayMs > 0 ? delayMs : null;
+    }
+    const dateMs = Date.parse(trimmed);
+    if (Number.isNaN(dateMs)) {
+        return null;
+    }
+    const delayMs = dateMs - Date.now();
+    return delayMs > 0 ? delayMs : null;
+};
+const getHeaderValue = (headers, name) => {
+    if (!headers) {
+        return null;
+    }
+    const direct = headers[name];
+    if (typeof direct === 'string') {
+        return direct;
+    }
+    if (Array.isArray(direct)) {
+        return direct.find((value) => typeof value === 'string') ?? null;
+    }
+    const headerEntry = Object.entries(headers).find(([headerName]) => headerName.toLowerCase() === name);
+    if (!headerEntry) {
+        return null;
+    }
+    const [, rawValue] = headerEntry;
+    if (typeof rawValue === 'string') {
+        return rawValue;
+    }
+    if (Array.isArray(rawValue)) {
+        return rawValue.find((value) => typeof value === 'string') ?? null;
+    }
+    return null;
+};
+const getRetryAfterDelay = (headers) => {
+    const retryAfterValue = getHeaderValue(headers, RETRY_AFTER_HEADER);
+    if (!retryAfterValue) {
+        return null;
+    }
+    const parsedDelay = parseRetryAfterMs(retryAfterValue);
+    if (parsedDelay === null) {
+        return null;
+    }
+    return Math.min(parsedDelay, MAX_RETRY_AFTER_DELAY_MS);
+};
+const getRetryDelay = (attempt, headers) => {
+    const configuredDelay = RETRY_DELAYS.length === 0 ? 0 : RETRY_DELAYS[Math.min(attempt, RETRY_DELAYS.length - 1)];
+    const retryAfterDelay = getRetryAfterDelay(headers);
+    return retryAfterDelay === null ? configuredDelay : Math.max(configuredDelay, retryAfterDelay);
+};
+// Keep connection setup bounded by retry budget so fallback stays responsive.
+const JSDELIVR_CONNECT_TIMEOUT_MS = Math.max(RETRY_TIMEOUTS[0], MIN_JSDELIVR_CONNECT_TIMEOUT_MS);
+const JSDELIVR_POOL_TIMEOUT_MS = toPositiveInteger(config_1.JSDELIVR_POOL_TIMEOUT) ?? DEFAULT_JSDELIVR_POOL_TIMEOUT_MS;
+const JSDELIVR_CONNECTIONS = toPositiveInteger(config_1.MAX_CONCURRENT_REQUESTS) ?? 1;
 // Create a persistent connection pool for jsDelivr CDN with optimal settings
 // This enables connection reuse and HTTP/1.1 keep-alive for blazing fast requests
 const jsdelivrPool = new undici_1.Pool('https://cdn.jsdelivr.net', {
-    connections: config_1.MAX_CONCURRENT_REQUESTS, // Maximum concurrent connections
-    pipelining: 10, // Enable request pipelining for even better performance
-    keepAliveTimeout: config_1.REQUEST_TIMEOUT, // Keep connections alive for 60 seconds
-    keepAliveMaxTimeout: config_1.REQUEST_TIMEOUT, // Maximum keep-alive timeout
-    connectTimeout: config_1.REQUEST_TIMEOUT, // 60 seconds connect timeout
+    connections: JSDELIVR_CONNECTIONS,
+    pipelining: 10,
+    keepAliveTimeout: JSDELIVR_POOL_TIMEOUT_MS,
+    keepAliveMaxTimeout: JSDELIVR_POOL_TIMEOUT_MS,
+    connectTimeout: JSDELIVR_CONNECT_TIMEOUT_MS,
 });
-// Batch configuration for progressive loading
-const BATCH_SIZE = 5;
-const BATCH_TIMEOUT_MS = 500;
+const isTimeoutError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const maybeCode = error.code;
+    const message = error.message.toLowerCase();
+    return (maybeCode === 'UND_ERR_HEADERS_TIMEOUT' ||
+        maybeCode === 'UND_ERR_BODY_TIMEOUT' ||
+        maybeCode === 'UND_ERR_CONNECT_TIMEOUT' ||
+        error.name === 'HeadersTimeoutError' ||
+        error.name === 'BodyTimeoutError' ||
+        error.name === 'ConnectTimeoutError' ||
+        message.includes('timeout'));
+};
+const isTransientNetworkError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const maybeCode = error.code;
+    return (maybeCode === 'UND_ERR_SOCKET' ||
+        maybeCode === 'ENOTFOUND' ||
+        maybeCode === 'EAI_AGAIN' ||
+        maybeCode === 'ECONNRESET' ||
+        maybeCode === 'ECONNREFUSED' ||
+        maybeCode === 'ETIMEDOUT' ||
+        maybeCode === 'EPIPE');
+};
+const isRetryableStatus = (statusCode) => statusCode === 408 || statusCode === 429 || statusCode >= 500;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const consumeBodySafely = async (body) => {
+    try {
+        await body.text();
+    }
+    catch {
+        // Ignore body read errors on non-200 responses because request will be retried/fallback.
+    }
+};
+const extractMajorVersion = (version) => {
+    if (!version) {
+        return null;
+    }
+    const coerced = semver.coerce(version);
+    if (!coerced) {
+        return null;
+    }
+    return semver.major(coerced).toString();
+};
+const toComparableVersion = (version) => {
+    const validVersion = semver.valid(version);
+    if (validVersion) {
+        return validVersion;
+    }
+    const coerced = semver.coerce(version);
+    return coerced ? coerced.version : null;
+};
+const versionIdentity = (version) => {
+    const comparable = toComparableVersion(version);
+    return comparable ?? `raw:${version}`;
+};
+const sortVersionsDescending = (versions) => {
+    const uniqueVersions = [];
+    const seenVersions = new Set();
+    for (const version of versions) {
+        const identity = versionIdentity(version);
+        if (!seenVersions.has(identity)) {
+            seenVersions.add(identity);
+            uniqueVersions.push(version);
+        }
+    }
+    return uniqueVersions.sort((a, b) => {
+        const comparableA = toComparableVersion(a);
+        const comparableB = toComparableVersion(b);
+        if (comparableA && comparableB) {
+            return semver.rcompare(comparableA, comparableB);
+        }
+        if (comparableA) {
+            return -1;
+        }
+        if (comparableB) {
+            return 1;
+        }
+        return b.localeCompare(a);
+    });
+};
+const isExpectedTransientError = (error) => isTimeoutError(error) || isTransientNetworkError(error);
 /**
  * Fetches package.json from jsdelivr CDN for a specific version tag using undici pool.
  * Uses connection pooling and keep-alive for maximum performance.
+ * Retries on transient failures while keeping a short fallback budget.
  * @param packageName - The npm package name
  * @param versionTag - The version tag (e.g., '14', 'latest')
  * @returns The package.json content or null if not found
  */
 async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
-    try {
-        const url = `${config_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
-        const { statusCode, body } = await (0, undici_1.request)(url, {
-            dispatcher: jsdelivrPool,
-            method: 'GET',
-            headers: {
-                accept: 'application/json',
-            },
-            headersTimeout: config_1.REQUEST_TIMEOUT,
-            bodyTimeout: config_1.REQUEST_TIMEOUT,
-        });
-        if (statusCode !== 200) {
-            // Consume body to prevent memory leaks
-            await body.text();
+    const url = `${config_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
+    for (let attempt = 0; attempt < RETRY_TIMEOUTS.length; attempt++) {
+        const timeout = RETRY_TIMEOUTS[attempt];
+        const tReq = Date.now();
+        try {
+            const { statusCode, headers, body } = await (0, undici_1.request)(url, {
+                dispatcher: jsdelivrPool,
+                method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
+                headersTimeout: timeout,
+                bodyTimeout: timeout,
+            });
+            if (statusCode !== 200) {
+                // Consume body to prevent memory leaks
+                await consumeBodySafely(body);
+                if (isRetryableStatus(statusCode) && attempt < RETRY_TIMEOUTS.length - 1) {
+                    const delay = getRetryDelay(attempt, headers);
+                    utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, retry ${attempt + 1} in ${delay}ms`);
+                    if (delay > 0) {
+                        await sleep(delay);
+                    }
+                    continue;
+                }
+                utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} HTTP ${statusCode}, no more retries`);
+                return null;
+            }
+            const text = await body.text();
+            const data = JSON.parse(text);
+            const version = typeof data.version === 'string' ? data.version.trim() : '';
+            utils_2.debugLog.perf('jsdelivr', `fetch ${packageName}@${versionTag} → ${version || 'no version'}`, tReq);
+            return version ? { version } : null;
+        }
+        catch (error) {
+            if ((isTimeoutError(error) || isTransientNetworkError(error)) &&
+                attempt < RETRY_TIMEOUTS.length - 1) {
+                const delay = getRetryDelay(attempt);
+                utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} transient error on attempt ${attempt + 1}, retry in ${delay}ms`, error);
+                if (delay > 0) {
+                    await sleep(delay);
+                }
+                continue;
+            }
+            if (!isExpectedTransientError(error)) {
+                // Unexpected errors are logged for observability.
+                console.error(`jsDelivr fetch failed for ${packageName}@${versionTag} on attempt ${attempt + 1}/${RETRY_TIMEOUTS.length}`, error);
+                utils_2.debugLog.error('jsdelivr', `unexpected error for ${packageName}@${versionTag} attempt ${attempt + 1}`, error);
+            }
+            else {
+                utils_2.debugLog.warn('jsdelivr', `${packageName}@${versionTag} exhausted retries`, error);
+            }
             return null;
         }
-        const text = await body.text();
-        const data = JSON.parse(text);
-        return data.version ? { version: data.version } : null;
-    }
-    catch (error) {
-        console.error(`Error fetching from jsdelivr for package: ${packageName}@${versionTag}`, error);
-        return null;
     }
+    return null;
 }
 /**
  * Fetches package version data from jsdelivr CDN for multiple packages.
@@ -105,14 +305,41 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
     }
     const total = packageNames.length;
     let completedCount = 0;
+    let progressCallback = onProgress;
+    let batchReadyCallback = onBatchReady;
     // Batch buffer for progressive updates
     let batchBuffer = [];
     let batchTimer = null;
+    const emitProgress = (packageName, completed, packageTotal) => {
+        if (!progressCallback) {
+            return;
+        }
+        try {
+            progressCallback(packageName, completed, packageTotal);
+        }
+        catch (error) {
+            console.error('Progress callback failed, disabling progress updates for this run.', error);
+            progressCallback = undefined;
+        }
+    };
+    const emitBatch = (batch) => {
+        if (!batchReadyCallback) {
+            return;
+        }
+        try {
+            batchReadyCallback(batch);
+        }
+        catch (error) {
+            console.error('Batch callback failed, disabling batch updates for this run.', error);
+            batchReadyCallback = undefined;
+        }
+    };
     // Helper to flush the current batch
     const flushBatch = () => {
-        if (batchBuffer.length > 0 && onBatchReady) {
-            onBatchReady([...batchBuffer]);
+        if (batchBuffer.length > 0) {
+            const batch = [...batchBuffer];
             batchBuffer = [];
+            emitBatch(batch);
         }
         if (batchTimer) {
             clearTimeout(batchTimer);
@@ -121,113 +348,119 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
     };
     // Helper to add package to batch and flush if needed
     const addToBatch = (packageName, data) => {
-        if (onBatchReady) {
-            batchBuffer.push({ name: packageName, data });
-            // Flush if batch is full
-            if (batchBuffer.length >= BATCH_SIZE) {
-                flushBatch();
-            }
-            else if (!batchTimer) {
-                // Set timer to flush batch after timeout
-                batchTimer = setTimeout(flushBatch, BATCH_TIMEOUT_MS);
-            }
+        if (!batchReadyCallback) {
+            return;
+        }
+        batchBuffer.push({ name: packageName, data });
+        // Flush if batch is full
+        if (batchBuffer.length >= BATCH_SIZE) {
+            flushBatch();
+        }
+        else if (!batchTimer) {
+            // Set timer to flush batch after timeout
+            batchTimer = setTimeout(flushBatch, BATCH_TIMEOUT_MS);
         }
     };
     // Process individual package fetch with immediate npm fallback on failure
-    const fetchPackageWithFallback = async (packageName) => {
-        const currentVersion = currentVersions?.get(packageName);
-        // Use CacheManager for unified caching (memory + disk)
-        const cached = cache_manager_1.packageCache.get(packageName);
-        if (cached) {
-            packageData.set(packageName, cached);
-            completedCount++;
-            if (onProgress) {
-                onProgress(packageName, completedCount, total);
+    const inFlightLookups = new Map();
+    const fetchFromNpmFallback = async (packageName) => {
+        const tFallback = Date.now();
+        utils_2.debugLog.info('jsdelivr', `falling back to npm registry for ${packageName}`);
+        try {
+            const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
+            const result = npmData.get(packageName) ?? null;
+            if (result) {
+                cache_manager_1.packageCache.set(packageName, result);
+                utils_2.debugLog.perf('jsdelivr', `npm fallback resolved ${packageName} → ${result.latestVersion}`, tFallback);
             }
-            addToBatch(packageName, cached);
-            return;
+            else {
+                utils_2.debugLog.warn('jsdelivr', `npm fallback returned no data for ${packageName}`);
+            }
+            return result;
         }
+        catch (error) {
+            utils_2.debugLog.error('jsdelivr', `npm fallback failed for ${packageName}`, error);
+            return null;
+        }
+    };
+    const fetchFreshPackageData = async (packageName, currentVersion) => {
         try {
-            // Determine major version from current version if provided
-            const majorVersion = currentVersion
-                ? semver.major(semver.coerce(currentVersion) || '0.0.0').toString()
-                : null;
-            // Prepare requests: always fetch @latest, @major if we have a current version
-            const requests = [
-                fetchPackageJsonFromJsdelivr(packageName, 'latest'),
-            ];
-            if (majorVersion) {
-                requests.push(fetchPackageJsonFromJsdelivr(packageName, majorVersion));
-            }
-            // Execute all requests simultaneously
-            const results = await Promise.all(requests);
-            const latestResult = results[0];
-            const majorResult = results[1];
+            const majorVersion = extractMajorVersion(currentVersion);
+            const latestResult = await fetchPackageJsonFromJsdelivr(packageName, 'latest');
             if (!latestResult) {
-                // Package not on jsDelivr, immediately try npm fallback
-                const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
-                const result = npmData.get(packageName);
-                if (result) {
-                    packageData.set(packageName, result);
-                    // CacheManager handles both memory and disk caching
-                    cache_manager_1.packageCache.set(packageName, result);
-                    addToBatch(packageName, result);
-                }
-                completedCount++;
-                if (onProgress) {
-                    onProgress(packageName, completedCount, total);
-                }
-                return;
+                return await fetchFromNpmFallback(packageName);
             }
             const latestVersion = latestResult.version;
+            const latestMajorVersion = extractMajorVersion(latestVersion);
+            const shouldFetchMajorVersion = Boolean(majorVersion && (latestMajorVersion === null || majorVersion !== latestMajorVersion));
+            const majorResult = shouldFetchMajorVersion
+                ? await fetchPackageJsonFromJsdelivr(packageName, majorVersion)
+                : null;
             const allVersions = [latestVersion];
-            // Add the major version result if different from latest
             if (majorResult && majorResult.version !== latestVersion) {
                 allVersions.push(majorResult.version);
             }
+            const sortedVersions = sortVersionsDescending(allVersions);
+            const orderedVersions = sortedVersions[0] === latestVersion
+                ? sortedVersions
+                : [latestVersion, ...sortedVersions.filter((version) => version !== latestVersion)];
             const result = {
                 latestVersion,
-                allVersions: allVersions.sort(semver.rcompare),
+                allVersions: orderedVersions,
             };
-            // Cache the result using CacheManager (handles both memory and disk)
             cache_manager_1.packageCache.set(packageName, result);
-            packageData.set(packageName, result);
-            completedCount++;
-            if (onProgress) {
-                onProgress(packageName, completedCount, total);
+            return result;
+        }
+        catch {
+            return await fetchFromNpmFallback(packageName);
+        }
+    };
+    const getPackageData = async (packageName, currentVersion) => {
+        const cached = cache_manager_1.packageCache.get(packageName);
+        if (cached) {
+            utils_2.debugLog.info('jsdelivr', `cache hit: ${packageName} → ${cached.latestVersion}`);
+            return cached;
+        }
+        const inFlight = inFlightLookups.get(packageName);
+        if (inFlight) {
+            return await inFlight;
+        }
+        const lookupPromise = fetchFreshPackageData(packageName, currentVersion).finally(() => {
+            inFlightLookups.delete(packageName);
+        });
+        inFlightLookups.set(packageName, lookupPromise);
+        return await lookupPromise;
+    };
+    const fetchPackageWithFallback = async (packageName) => {
+        try {
+            const currentVersion = currentVersions?.get(packageName);
+            const result = await getPackageData(packageName, currentVersion);
+            if (result) {
+                packageData.set(packageName, result);
+                addToBatch(packageName, result);
             }
-            addToBatch(packageName, result);
         }
         catch (error) {
-            // On error, immediately try npm fallback
-            try {
-                const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
-                const result = npmData.get(packageName);
-                if (result) {
-                    packageData.set(packageName, result);
-                    // CacheManager handles both memory and disk caching
-                    cache_manager_1.packageCache.set(packageName, result);
-                    addToBatch(packageName, result);
-                }
-            }
-            catch (npmError) {
-                // If both fail, just continue
-            }
+            console.error(`Failed to resolve package data for ${packageName}; continuing with others.`, error);
+        }
+        finally {
             completedCount++;
-            if (onProgress) {
-                onProgress(packageName, completedCount, total);
-            }
+            emitProgress(packageName, completedCount, total);
         }
     };
-    // Fire all requests simultaneously - they handle fallback internally and immediately
-    await Promise.all(packageNames.map(fetchPackageWithFallback));
-    // Flush any remaining batch items
-    flushBatch();
-    // Flush persistent cache to disk
-    cache_manager_1.packageCache.flush();
-    // Clear the progress line if no custom progress handler
-    if (!onProgress) {
-        utils_1.ConsoleUtils.clearProgress();
+    try {
+        // Fire all requests simultaneously - each request internally handles retries/fallback.
+        await Promise.all(packageNames.map(fetchPackageWithFallback));
+    }
+    finally {
+        // Flush any remaining batch items
+        flushBatch();
+        // Flush persistent cache to disk
+        cache_manager_1.packageCache.flush();
+        // Clear the progress line if no custom progress handler
+        if (!onProgress) {
+            utils_1.ConsoleUtils.clearProgress();
+        }
     }
     return packageData;
 }

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

@@ -129,9 +129,9 @@ class NavigationManager {
         if (targetVisualIndex < this.state.scrollOffset) {
             this.state.scrollOffset = targetVisualIndex;
         }
-        // Scrolling down: scroll down by 1 item (smooth scrolling)
+        // Scrolling down: adjust scroll to keep item visible
         else if (visualIndex >= this.state.scrollOffset + this.maxVisibleItems) {
-            this.state.scrollOffset += 1;
+            this.state.scrollOffset = visualIndex - this.maxVisibleItems + 1;
         }
         // Ensure scrollOffset doesn't go negative or beyond bounds
         const maxScroll = Math.max(0, totalVisualItems - this.maxVisibleItems);

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

@@ -167,8 +167,10 @@ class StateManager {
     }
     exitFilterMode(clearQuery = false) {
         this.filterManager.exitFilterMode(clearQuery);
-        this.navigationManager.setCurrentRow(0);
-        this.navigationManager.setScrollOffset(0);
+        if (clearQuery) {
+            this.navigationManager.setCurrentRow(0);
+            this.navigationManager.setScrollOffset(0);
+        }
         // Use incremental render for search mode toggle (no blink)
     }
     updateFilterQuery(query) {
@@ -218,8 +220,8 @@ class StateManager {
     setInitialRender(isInitial) {
         this.renderState.forceFullRender = isInitial;
     }
-    resetForResize() {
-        const totalItems = this.renderState.renderableItems.length || this.displayState.maxVisibleItems;
+    resetForResize(totalFilteredItems) {
+        const totalItems = totalFilteredItems || this.renderState.renderableItems.length || this.displayState.maxVisibleItems;
         this.navigationManager.resetForResize(totalItems);
         this.renderState.forceFullRender = true;
     }

package/dist/utils/debug-logger.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = void 0;
+exports.enableDebugLogging = enableDebugLogging;
+exports.isDebugEnabled = isDebugEnabled;
+exports.getDebugLogPath = getDebugLogPath;
+const fs_1 = require("fs");
+const path_1 = require("path");
+let _enabled = false;
+let _logFile = null;
+const pad = (n, width = 2) => String(n).padStart(width, '0');
+function timestamp() {
+    const d = new Date();
+    return (`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+        `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`);
+}
+function getLogFile() {
+    if (!_logFile) {
+        const d = new Date();
+        const dateStr = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+        _logFile = (0, path_1.join)(`inup-debug-${dateStr}.log`);
+        // Write a header so the file is easy to identify
+        (0, fs_1.writeFileSync)(_logFile, `=== inup debug log started at ${timestamp()} ===\n`, { flag: 'a' });
+    }
+    return _logFile;
+}
+function enableDebugLogging() {
+    _enabled = true;
+    const file = getLogFile();
+    // Print the path so the user knows where to look
+    process.stderr.write(`[inup] debug logging enabled → ${file}\n`);
+}
+function isDebugEnabled() {
+    return _enabled;
+}
+function getDebugLogPath() {
+    return _logFile;
+}
+function write(level, context, message, extra) {
+    if (!_enabled)
+        return;
+    let line = `[${timestamp()}] [${level}] [${context}] ${message}`;
+    if (extra !== undefined) {
+        if (extra instanceof Error) {
+            line += ` | ${extra.name}: ${extra.message}`;
+            if (extra.stack) {
+                const stackLines = extra.stack.split('\n').slice(1, 4).join(' | ');
+                line += ` | ${stackLines}`;
+            }
+        }
+        else if (typeof extra === 'object') {
+            try {
+                line += ` | ${JSON.stringify(extra)}`;
+            }
+            catch {
+                line += ` | [unserializable]`;
+            }
+        }
+        else {
+            line += ` | ${extra}`;
+        }
+    }
+    line += '\n';
+    try {
+        (0, fs_1.appendFileSync)(getLogFile(), line);
+    }
+    catch {
+        // Never crash the app because of debug logging
+    }
+}
+exports.debugLog = {
+    info: (context, message, extra) => write('INFO', context, message, extra),
+    warn: (context, message, extra) => write('WARN', context, message, extra),
+    error: (context, message, extra) => write('ERROR', context, message, extra),
+    /** Log elapsed time since a start timestamp obtained via Date.now() */
+    perf: (context, label, startMs, extra) => {
+        const elapsed = Date.now() - startMs;
+        write('PERF', context, `${label} — ${elapsed}ms`, extra);
+    },
+};
+//# sourceMappingURL=debug-logger.js.map

package/dist/utils/index.js

@@ -21,6 +21,7 @@ exports.collectAllDependenciesAsync = exports.readPackageJsonAsync = void 0;
 __exportStar(require("./filesystem"), exports);
 __exportStar(require("./exec"), exports);
 __exportStar(require("./version"), exports);
+__exportStar(require("./debug-logger"), exports);
 // Re-export async functions for convenience
 var filesystem_1 = require("./filesystem");
 Object.defineProperty(exports, "readPackageJsonAsync", { enumerable: true, get: function () { return filesystem_1.readPackageJsonAsync; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inup",
-  "version": "1.4.6",
+  "version": "1.4.8",
   "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.",
   "main": "dist/index.js",
   "bin": {