inup 1.4.5 → 1.4.7

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

@@ -38,6 +38,8 @@ const semver = __importStar(require("semver"));
 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;
@@ -58,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);
@@ -88,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();
@@ -97,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)`);
@@ -104,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
@@ -122,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
@@ -135,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,
@@ -149,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;
         }
     }
@@ -181,8 +224,7 @@ class PackageDetector {
             version.startsWith('bitbucket:'));
     }
     showProgress(message) {
-        // Clear current line and show new message
-        process.stdout.write(`\r${' '.repeat(80)}\r${message}`);
+        utils_2.ConsoleUtils.showProgress(message);
     }
     getOutdatedPackagesOnly(packages) {
         return packages.filter((pkg) => pkg.isOutdated);

package/dist/interactive-ui.js

@@ -221,10 +221,10 @@ class InteractiveUI {
                         }
                         break;
                     case 'enter_filter_mode':
-                        stateManager.enterFilterMode();
+                        stateManager.enterFilterMode(action.preserveQuery);
                         break;
                     case 'exit_filter_mode':
-                        stateManager.exitFilterMode();
+                        stateManager.exitFilterMode(action.clearQuery);
                         break;
                     case 'filter_input':
                         stateManager.appendToFilterQuery(action.char);

package/dist/services/cache-manager.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageCache = exports.CacheManager = void 0;
+const config_1 = require("../config");
+const persistent_cache_1 = require("./persistent-cache");
+/**
+ * Unified cache manager that handles both in-memory and persistent disk caching.
+ * Consolidates caching logic used across registry services.
+ */
+class CacheManager {
+    constructor(ttl = config_1.CACHE_TTL) {
+        this.memoryCache = new Map();
+        this.ttl = ttl;
+    }
+    /**
+     * Get cached data for a key, checking memory first, then disk.
+     * Returns null if not found or expired.
+     */
+    get(key) {
+        // Check in-memory cache first (fastest)
+        const memoryCached = this.memoryCache.get(key);
+        if (memoryCached && Date.now() - memoryCached.timestamp < this.ttl) {
+            return memoryCached.data;
+        }
+        // Check persistent disk cache (survives restarts)
+        const diskCached = persistent_cache_1.persistentCache.get(key);
+        if (diskCached) {
+            // Populate in-memory cache for subsequent accesses
+            this.memoryCache.set(key, {
+                data: diskCached,
+                timestamp: Date.now(),
+            });
+            return diskCached;
+        }
+        return null;
+    }
+    /**
+     * Store data in both memory and disk cache.
+     */
+    set(key, data) {
+        // Cache in memory
+        this.memoryCache.set(key, {
+            data,
+            timestamp: Date.now(),
+        });
+        // Cache to disk for persistence
+        persistent_cache_1.persistentCache.set(key, data);
+    }
+    /**
+     * Get data from cache or fetch it using the provided fetcher function.
+     * This is the main entry point for cache-aside pattern.
+     */
+    async getOrFetch(key, fetcher) {
+        // Try cache first
+        const cached = this.get(key);
+        if (cached) {
+            return cached;
+        }
+        // Fetch fresh data
+        const data = await fetcher();
+        if (data) {
+            this.set(key, data);
+        }
+        return data;
+    }
+    /**
+     * Check if a key exists and is not expired in cache.
+     */
+    has(key) {
+        return this.get(key) !== null;
+    }
+    /**
+     * Clear in-memory cache (useful for testing).
+     */
+    clear() {
+        this.memoryCache.clear();
+    }
+    /**
+     * Flush pending disk cache writes.
+     */
+    flush() {
+        persistent_cache_1.persistentCache.flush();
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        return {
+            memoryEntries: this.memoryCache.size,
+            diskStats: persistent_cache_1.persistentCache.getStats(),
+        };
+    }
+}
+exports.CacheManager = CacheManager;
+// Default package version cache instance
+exports.packageCache = new CacheManager();
+//# sourceMappingURL=cache-manager.js.map

package/dist/services/index.js

@@ -22,4 +22,5 @@ __exportStar(require("./jsdelivr-registry"), exports);
 __exportStar(require("./changelog-fetcher"), exports);
 __exportStar(require("./version-checker"), exports);
 __exportStar(require("./persistent-cache"), exports);
+__exportStar(require("./cache-manager"), exports);
 //# sourceMappingURL=index.js.map