inup 1.4.4 → 1.4.6

package/dist/cli.js

@@ -10,6 +10,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const index_1 = require("./index");
 const services_1 = require("./services");
+const config_1 = require("./config");
 const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json'), 'utf-8'));
 const program = new commander_1.Command();
 program
@@ -18,17 +19,31 @@ program
     .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('--package-manager <name>', 'manually specify package manager (npm, yarn, pnpm, bun)')
     .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 excludePatterns = options.exclude
+    const cwd = (0, path_1.resolve)(options.dir);
+    // Load project config from .inuprc
+    const projectConfig = (0, config_1.loadProjectConfig)(cwd);
+    // Merge CLI exclude patterns with config
+    const cliExcludePatterns = options.exclude
         ? options.exclude
             .split(',')
             .map((p) => p.trim())
             .filter(Boolean)
         : [];
+    const excludePatterns = [...cliExcludePatterns, ...(projectConfig.exclude || [])];
+    // Merge CLI ignore patterns with config (CLI takes precedence / adds to config)
+    const cliIgnorePatterns = options.ignore
+        ? options.ignore
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean)
+        : [];
+    const ignorePackages = [...new Set([...cliIgnorePatterns, ...(projectConfig.ignore || [])])];
     // Validate package manager if provided
     let packageManager;
     if (options.packageManager) {
@@ -41,8 +56,9 @@ program
         packageManager = options.packageManager;
     }
     const upgrader = new index_1.UpgradeRunner({
-        cwd: options.dir,
+        cwd,
         excludePatterns,
+        ignorePackages,
         packageManager,
     });
     await upgrader.run();

package/dist/config/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./constants"), exports);
+__exportStar(require("./project-config"), exports);
 //# sourceMappingURL=index.js.map

package/dist/config/project-config.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProjectConfig = loadProjectConfig;
+exports.isPackageIgnored = isPackageIgnored;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const CONFIG_FILES = ['.inuprc', '.inuprc.json', 'inup.config.json'];
+/**
+ * Load project configuration from .inuprc, .inuprc.json, or inup.config.json
+ * Searches in the specified directory and parent directories up to root
+ */
+function loadProjectConfig(cwd) {
+    let currentDir = cwd;
+    while (currentDir !== '/') {
+        for (const configFile of CONFIG_FILES) {
+            const configPath = (0, path_1.join)(currentDir, configFile);
+            if ((0, fs_1.existsSync)(configPath)) {
+                try {
+                    const content = (0, fs_1.readFileSync)(configPath, 'utf-8');
+                    const config = JSON.parse(content);
+                    return normalizeConfig(config);
+                }
+                catch (error) {
+                    // Invalid JSON or read error - continue searching
+                    console.warn(`Warning: Failed to parse ${configPath}: ${error}`);
+                }
+            }
+        }
+        // Move to parent directory
+        const parentDir = (0, path_1.join)(currentDir, '..');
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return {};
+}
+/**
+ * Normalize and validate the config
+ */
+function normalizeConfig(config) {
+    const normalized = {};
+    if (config.ignore) {
+        if (Array.isArray(config.ignore)) {
+            normalized.ignore = config.ignore.filter((item) => typeof item === 'string');
+        }
+    }
+    if (config.exclude) {
+        if (Array.isArray(config.exclude)) {
+            normalized.exclude = config.exclude.filter((item) => typeof item === 'string');
+        }
+    }
+    return normalized;
+}
+/**
+ * Check if a package name matches any of the ignore patterns
+ * Supports exact matches and glob patterns (* and ?)
+ */
+function isPackageIgnored(packageName, ignorePatterns) {
+    for (const pattern of ignorePatterns) {
+        if (matchesPattern(packageName, pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Match a package name against a pattern
+ * Supports:
+ * - Exact match: "lodash"
+ * - Wildcard: "*" matches any sequence of characters
+ * - Single char wildcard: "?" matches single character
+ * - Scoped packages: "@babel/*" matches all @babel packages
+ */
+function matchesPattern(name, pattern) {
+    // Exact match
+    if (pattern === name) {
+        return true;
+    }
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars except * and ?
+        .replace(/\*/g, '.*') // * matches any sequence
+        .replace(/\?/g, '.'); // ? matches single char
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(name);
+}
+//# sourceMappingURL=project-config.js.map

package/dist/core/package-detector.js

@@ -38,12 +38,14 @@ 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");
 class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
         this.packageJson = null;
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
+        this.ignorePackages = options?.ignorePackages || [];
         this.packageJsonPath = (0, utils_1.findPackageJson)(this.cwd);
         if (this.packageJsonPath) {
             this.packageJson = (0, utils_1.readPackageJson)(this.packageJsonPath);
@@ -67,15 +69,24 @@ class PackageDetector {
             includePeerDeps: true,
             includeOptionalDeps: true,
         });
-        // Step 3: Get unique package names while filtering out workspace references
+        // 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;
         for (const dep of allDepsRaw) {
-            if (!this.isWorkspaceReference(dep.version)) {
-                allDeps.push(dep);
-                uniquePackageNames.add(dep.name);
+            if (this.isWorkspaceReference(dep.version)) {
+                continue;
             }
+            if (this.ignorePackages.length > 0 && (0, config_1.isPackageIgnored)(dep.name, this.ignorePackages)) {
+                ignoredCount++;
+                continue;
+            }
+            allDeps.push(dep);
+            uniquePackageNames.add(dep.name);
+        }
+        if (ignoredCount > 0) {
+            this.showProgress(`🔍 Skipped ${ignoredCount} ignored package(s)`);
         }
         const packageNames = Array.from(uniquePackageNames);
         // Step 4: Fetch all package data in one call per package
@@ -171,8 +182,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

@@ -21,4 +21,6 @@ __exportStar(require("./npm-registry"), exports);
 __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

package/dist/services/jsdelivr-registry.js

@@ -40,6 +40,8 @@ const undici_1 = require("undici");
 const semver = __importStar(require("semver"));
 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");
 // 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', {
@@ -52,7 +54,6 @@ const jsdelivrPool = new undici_1.Pool('https://cdn.jsdelivr.net', {
 // Batch configuration for progressive loading
 const BATCH_SIZE = 5;
 const BATCH_TIMEOUT_MS = 500;
-const packageCache = new Map();
 /**
  * Fetches package.json from jsdelivr CDN for a specific version tag using undici pool.
  * Uses connection pooling and keep-alive for maximum performance.
@@ -135,15 +136,15 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
     // Process individual package fetch with immediate npm fallback on failure
     const fetchPackageWithFallback = async (packageName) => {
         const currentVersion = currentVersions?.get(packageName);
-        // Try to get from cache first
-        const cached = packageCache.get(packageName);
-        if (cached && Date.now() - cached.timestamp < config_1.CACHE_TTL) {
-            packageData.set(packageName, cached.data);
+        // 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);
             }
-            addToBatch(packageName, cached.data);
+            addToBatch(packageName, cached);
             return;
         }
         try {
@@ -168,10 +169,8 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
                 const result = npmData.get(packageName);
                 if (result) {
                     packageData.set(packageName, result);
-                    packageCache.set(packageName, {
-                        data: result,
-                        timestamp: Date.now(),
-                    });
+                    // CacheManager handles both memory and disk caching
+                    cache_manager_1.packageCache.set(packageName, result);
                     addToBatch(packageName, result);
                 }
                 completedCount++;
@@ -190,11 +189,8 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
                 latestVersion,
                 allVersions: allVersions.sort(semver.rcompare),
             };
-            // Cache the result
-            packageCache.set(packageName, {
-                data: result,
-                timestamp: Date.now(),
-            });
+            // Cache the result using CacheManager (handles both memory and disk)
+            cache_manager_1.packageCache.set(packageName, result);
             packageData.set(packageName, result);
             completedCount++;
             if (onProgress) {
@@ -209,10 +205,8 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
                 const result = npmData.get(packageName);
                 if (result) {
                     packageData.set(packageName, result);
-                    packageCache.set(packageName, {
-                        data: result,
-                        timestamp: Date.now(),
-                    });
+                    // CacheManager handles both memory and disk caching
+                    cache_manager_1.packageCache.set(packageName, result);
                     addToBatch(packageName, result);
                 }
             }
@@ -229,9 +223,11 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
     await Promise.all(packageNames.map(fetchPackageWithFallback));
     // Flush any remaining batch items
     flushBatch();
-    // Clear the progress line and show completion time if no custom progress handler
+    // Flush persistent cache to disk
+    cache_manager_1.packageCache.flush();
+    // Clear the progress line if no custom progress handler
     if (!onProgress) {
-        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+        utils_1.ConsoleUtils.clearProgress();
     }
     return packageData;
 }
@@ -239,7 +235,7 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
  * Clear the package cache (useful for testing)
  */
 function clearJsdelivrPackageCache() {
-    packageCache.clear();
+    cache_manager_1.packageCache.clear();
 }
 /**
  * Close the jsDelivr connection pool (useful for graceful shutdown)

package/dist/services/npm-registry.js

@@ -37,16 +37,17 @@ exports.getAllPackageData = getAllPackageData;
 exports.clearPackageCache = clearPackageCache;
 const semver = __importStar(require("semver"));
 const config_1 = require("../config");
-const packageCache = new Map();
+const cache_manager_1 = require("./cache-manager");
+const utils_1 = require("../ui/utils");
 /**
- * Fetches package data from npm registry with caching using native fetch.
- * Includes timeout support for slow connections.
+ * Fetches package data from npm registry.
+ * Uses the shared CacheManager for caching.
  */
 async function fetchPackageFromRegistry(packageName) {
-    // Check cache first
-    const cached = packageCache.get(packageName);
-    if (cached && Date.now() - cached.timestamp < config_1.CACHE_TTL) {
-        return cached.data;
+    // Use CacheManager for unified caching (memory + disk)
+    const cached = cache_manager_1.packageCache.get(packageName);
+    if (cached) {
+        return cached;
     }
     try {
         const url = `${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
@@ -78,11 +79,8 @@ async function fetchPackageFromRegistry(packageName) {
                 latestVersion,
                 allVersions,
             };
-            // Cache the result
-            packageCache.set(packageName, {
-                data: result,
-                timestamp: Date.now(),
-            });
+            // Cache the result using CacheManager (handles both memory and disk)
+            cache_manager_1.packageCache.set(packageName, result);
             return result;
         }
         finally {
@@ -118,9 +116,11 @@ async function getAllPackageData(packageNames, onProgress) {
     });
     // Wait for all requests to complete
     await Promise.all(allPromises);
-    // Clear the progress line and show completion time if no custom progress handler
+    // Flush persistent cache to disk
+    cache_manager_1.packageCache.flush();
+    // Clear the progress line if no custom progress handler
     if (!onProgress) {
-        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+        utils_1.ConsoleUtils.clearProgress();
     }
     return packageData;
 }
@@ -128,6 +128,6 @@ async function getAllPackageData(packageNames, onProgress) {
  * Clear the package cache (useful for testing)
  */
 function clearPackageCache() {
-    packageCache.clear();
+    cache_manager_1.packageCache.clear();
 }
 //# sourceMappingURL=npm-registry.js.map

package/dist/services/persistent-cache.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistentCache = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const env_paths_1 = __importDefault(require("env-paths"));
+// Cache TTL: 24 hours for disk cache (much longer than in-memory 5 minutes)
+const DISK_CACHE_TTL = 24 * 60 * 60 * 1000;
+// Maximum cache size (number of packages)
+const MAX_CACHE_ENTRIES = 5000;
+// Cache file format version (increment when structure changes)
+const CACHE_VERSION = 1;
+/**
+ * Persistent cache manager for package registry data.
+ * Stores cache on disk for fast repeated runs across CLI invocations.
+ */
+class PersistentCacheManager {
+    constructor() {
+        this.index = null;
+        this.dirty = false;
+        const paths = (0, env_paths_1.default)('inup');
+        this.cacheDir = (0, path_1.join)(paths.cache, 'registry');
+        this.indexPath = (0, path_1.join)(this.cacheDir, 'index.json');
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    ensureCacheDir() {
+        if (!(0, fs_1.existsSync)(this.cacheDir)) {
+            (0, fs_1.mkdirSync)(this.cacheDir, { recursive: true });
+        }
+    }
+    /**
+     * Load cache index from disk
+     */
+    loadIndex() {
+        if (this.index) {
+            return this.index;
+        }
+        try {
+            if ((0, fs_1.existsSync)(this.indexPath)) {
+                const content = (0, fs_1.readFileSync)(this.indexPath, 'utf-8');
+                const parsed = JSON.parse(content);
+                // Check cache version - invalidate if outdated
+                if (parsed.version !== CACHE_VERSION) {
+                    this.clearCache();
+                    this.index = { version: CACHE_VERSION, entries: {} };
+                    return this.index;
+                }
+                this.index = parsed;
+                return this.index;
+            }
+        }
+        catch {
+            // Corrupted index, start fresh
+        }
+        this.index = { version: CACHE_VERSION, entries: {} };
+        return this.index;
+    }
+    /**
+     * Save cache index to disk
+     */
+    saveIndex() {
+        if (!this.dirty || !this.index) {
+            return;
+        }
+        try {
+            this.ensureCacheDir();
+            (0, fs_1.writeFileSync)(this.indexPath, JSON.stringify(this.index), 'utf-8');
+            this.dirty = false;
+        }
+        catch {
+            // Silently fail - cache is not critical
+        }
+    }
+    /**
+     * Generate a safe filename for a package name
+     */
+    getFilename(packageName) {
+        // Handle scoped packages: @scope/name -> scope__name
+        const safeName = packageName.replace(/^@/, '').replace(/\//g, '__');
+        return `${safeName}.json`;
+    }
+    /**
+     * Get cached data for a package
+     */
+    get(packageName) {
+        const index = this.loadIndex();
+        const entry = index.entries[packageName];
+        if (!entry) {
+            return null;
+        }
+        // Check TTL
+        if (Date.now() - entry.timestamp > DISK_CACHE_TTL) {
+            // Expired, remove from index
+            delete index.entries[packageName];
+            this.dirty = true;
+            return null;
+        }
+        // Read the actual cache file
+        try {
+            const filePath = (0, path_1.join)(this.cacheDir, entry.file);
+            if (!(0, fs_1.existsSync)(filePath)) {
+                delete index.entries[packageName];
+                this.dirty = true;
+                return null;
+            }
+            const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            const cached = JSON.parse(content);
+            return {
+                latestVersion: cached.latestVersion,
+                allVersions: cached.allVersions,
+            };
+        }
+        catch {
+            // Corrupted cache file, remove from index
+            delete index.entries[packageName];
+            this.dirty = true;
+            return null;
+        }
+    }
+    /**
+     * Store data for a package
+     */
+    set(packageName, data) {
+        const index = this.loadIndex();
+        // Evict old entries if cache is too large
+        const entryCount = Object.keys(index.entries).length;
+        if (entryCount >= MAX_CACHE_ENTRIES) {
+            this.evictOldest(Math.floor(MAX_CACHE_ENTRIES * 0.1)); // Evict 10%
+        }
+        const filename = this.getFilename(packageName);
+        const entry = {
+            ...data,
+            timestamp: Date.now(),
+        };
+        try {
+            this.ensureCacheDir();
+            const filePath = (0, path_1.join)(this.cacheDir, filename);
+            (0, fs_1.writeFileSync)(filePath, JSON.stringify(entry), 'utf-8');
+            index.entries[packageName] = {
+                file: filename,
+                timestamp: Date.now(),
+            };
+            this.dirty = true;
+        }
+        catch {
+            // Silently fail - cache is not critical
+        }
+    }
+    /**
+     * Batch get multiple packages (returns map of found entries)
+     */
+    getMany(packageNames) {
+        const results = new Map();
+        for (const name of packageNames) {
+            const cached = this.get(name);
+            if (cached) {
+                results.set(name, cached);
+            }
+        }
+        return results;
+    }
+    /**
+     * Batch set multiple packages
+     */
+    setMany(entries) {
+        for (const [name, data] of entries) {
+            this.set(name, data);
+        }
+        this.flush();
+    }
+    /**
+     * Evict oldest cache entries
+     */
+    evictOldest(count) {
+        const index = this.loadIndex();
+        const entries = Object.entries(index.entries);
+        // Sort by timestamp (oldest first)
+        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+        // Remove oldest entries
+        const toRemove = entries.slice(0, count);
+        for (const [packageName, entry] of toRemove) {
+            try {
+                const filePath = (0, path_1.join)(this.cacheDir, entry.file);
+                if ((0, fs_1.existsSync)(filePath)) {
+                    (0, fs_1.unlinkSync)(filePath);
+                }
+            }
+            catch {
+                // Ignore deletion errors
+            }
+            delete index.entries[packageName];
+        }
+        this.dirty = true;
+    }
+    /**
+     * Clear all cache
+     */
+    clearCache() {
+        try {
+            if ((0, fs_1.existsSync)(this.cacheDir)) {
+                const files = (0, fs_1.readdirSync)(this.cacheDir);
+                for (const file of files) {
+                    try {
+                        (0, fs_1.unlinkSync)((0, path_1.join)(this.cacheDir, file));
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
+        this.index = { version: CACHE_VERSION, entries: {} };
+        this.dirty = true;
+    }
+    /**
+     * Flush pending changes to disk
+     */
+    flush() {
+        this.saveIndex();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const index = this.loadIndex();
+        return {
+            entries: Object.keys(index.entries).length,
+            cacheDir: this.cacheDir,
+        };
+    }
+}
+// Export singleton instance
+exports.persistentCache = new PersistentCacheManager();
+//# sourceMappingURL=persistent-cache.js.map

package/dist/ui/input-handler.js

@@ -47,24 +47,34 @@ class InputHandler {
             }
             return;
         }
-        // Check for '/' character to enter filter mode (only in normal mode, not in modal or already in filter)
-        if (str === '/' && !uiState.showInfoModal && !uiState.filterMode) {
-            this.onAction({ type: 'enter_filter_mode' });
+        // Check for '/' character to handle filter mode (only when not in modal)
+        if (str === '/' && !uiState.showInfoModal) {
+            if (uiState.filterMode) {
+                // Apply search (exit filter mode but keep the filter)
+                this.onAction({ type: 'exit_filter_mode' });
+            }
+            else {
+                // Enter filter mode - preserve query if one exists (to edit it)
+                this.onAction({ type: 'enter_filter_mode', preserveQuery: !!uiState.filterQuery });
+            }
             return;
         }
         // Handle filter mode input
         if (uiState.filterMode) {
+            // Check for escape key (either via key.name or raw escape character)
+            if ((key && key.name === 'escape') || str === '\x1b') {
+                // Escape clears the filter and exits filter mode
+                this.onAction({ type: 'exit_filter_mode', clearQuery: true });
+                return;
+            }
             if (key) {
                 switch (key.name) {
-                    case 'escape':
-                        this.onAction({ type: 'exit_filter_mode' });
-                        return;
                     case 'backspace':
                     case 'delete':
                         this.onAction({ type: 'filter_backspace' });
                         return;
                     case 'return':
-                        // Exit filter mode but keep the filter applied
+                        // Apply search (exit filter mode but keep the filter)
                         this.onAction({ type: 'exit_filter_mode' });
                         return;
                     case 'up':
@@ -116,10 +126,7 @@ class InputHandler {
                 // Check if any packages are selected
                 const selectedCount = states.filter((s) => s.selectedOption !== 'none').length;
                 if (selectedCount === 0) {
-                    // Show warning and stay in selection mode
-                    console.log('\n' +
-                        '\x1b[33m⚠️  No packages selected. Press ↑/↓ to navigate and ←/→ to select versions, or ESC to exit.\x1b[39m');
-                    // Re-render will happen automatically
+                    // Do nothing if no packages selected
                     return;
                 }
                 this.cleanup();
@@ -164,13 +171,15 @@ class InputHandler {
                 this.onAction({ type: 'toggle_theme_modal' });
                 break;
             case 'escape':
-                // Check if modal is open - if so, close it; otherwise cancel
+                // Close modal if open
                 if (uiState.showInfoModal) {
                     this.onAction({ type: 'toggle_info_modal' });
                 }
-                else {
-                    this.onAction({ type: 'cancel' });
+                else if (uiState.filterQuery) {
+                    // Clear filter if one is applied
+                    this.onAction({ type: 'exit_filter_mode', clearQuery: true });
                 }
+                // Otherwise do nothing - Escape no longer exits the CLI
                 break;
         }
     }
@@ -178,11 +187,7 @@ class InputHandler {
         this.onAction({ type: 'resize', height });
     }
     cleanup() {
-        utils_1.CursorUtils.show();
-        if (process.stdin.setRawMode) {
-            process.stdin.setRawMode(false);
-        }
-        process.stdin.pause();
+        utils_1.CursorUtils.cleanup();
     }
 }
 exports.InputHandler = InputHandler;
@@ -219,11 +224,7 @@ class ConfirmationInputHandler {
         }
     }
     cleanup() {
-        utils_1.CursorUtils.show();
-        if (process.stdin.setRawMode) {
-            process.stdin.setRawMode(false);
-        }
-        process.stdin.pause();
+        utils_1.CursorUtils.cleanup();
     }
 }
 exports.ConfirmationInputHandler = ConfirmationInputHandler;

package/dist/ui/renderer/modal.js

@@ -7,12 +7,9 @@ exports.renderPackageInfoLoading = renderPackageInfoLoading;
 exports.renderPackageInfoModal = renderPackageInfoModal;
 const chalk_1 = __importDefault(require("chalk"));
 const themes_colors_1 = require("../themes-colors");
-/**
- * Remove ANSI color codes from a string for length calculation
- */
-function stripAnsi(str) {
-    return str.replace(/\u001b\[[0-9;]*m/g, '');
-}
+const utils_1 = require("../utils");
+// Use shared ANSI stripping utility
+const stripAnsi = utils_1.VersionUtils.stripAnsi;
 /**
  * Format a number for display (e.g., 1000000 -> "1M", 1000 -> "1K")
  */

package/dist/ui/renderer/package-list.js

@@ -213,6 +213,12 @@ function renderInterface(states, currentRow, scrollOffset, maxVisibleItems, forc
         const padding = Math.max(0, terminalWidth - utils_1.VersionUtils.getVisualLength(filterDisplay));
         output.push(filterDisplay + ' '.repeat(padding));
     }
+    else if (filterQuery) {
+        // Show applied filter when not in filter mode but filter is active
+        const filterDisplay = '  ' + chalk_1.default.bold.white('Search: ') + (0, themes_colors_1.getThemeColor)('primary')(filterQuery) + (0, themes_colors_1.getThemeColor)('textSecondary')(' (press / to edit)');
+        const padding = Math.max(0, terminalWidth - utils_1.VersionUtils.getVisualLength(filterDisplay));
+        output.push(filterDisplay + ' '.repeat(padding));
+    }
     else {
         // Show instructions when not filtering
         output.push('  ' +
@@ -249,51 +255,54 @@ function renderInterface(states, currentRow, scrollOffset, maxVisibleItems, forc
     const endItem = Math.min(scrollOffset + maxVisibleItems, totalVisualItems);
     let statusLine = '';
     if (filterMode) {
-        // In filter mode, show ESC to exit filter
+        // In filter mode, show Enter to apply and ESC to clear
         if (totalPackages === 0) {
             statusLine = (0, themes_colors_1.getThemeColor)('warning')(`No matches found`) +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Esc ') +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Clear filter');
+                chalk_1.default.bold.white('Esc ') + chalk_1.default.gray('Clear');
         }
         else if (totalVisualItems > maxVisibleItems) {
-            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing ${chalk_1.default.white(startItem)}-${chalk_1.default.white(endItem)} of ${chalk_1.default.white(totalPackages)} matches (${chalk_1.default.white(totalBeforeFilter)} total)`) +
+            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing ${chalk_1.default.white(startItem)}-${chalk_1.default.white(endItem)} of ${chalk_1.default.white(totalPackages)} matches`) +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Esc ') +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Clear filter');
+                chalk_1.default.bold.white('Enter ') + chalk_1.default.gray('Apply') +
+                '  ' +
+                chalk_1.default.bold.white('Esc ') + chalk_1.default.gray('Clear');
         }
         else {
-            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing all ${chalk_1.default.white(totalPackages)} matches (${chalk_1.default.white(totalBeforeFilter)} total)`) +
+            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing all ${chalk_1.default.white(totalPackages)} matches`) +
+                '  ' +
+                chalk_1.default.bold.white('Enter ') + chalk_1.default.gray('Apply') +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Esc ') +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Clear filter');
+                chalk_1.default.bold.white('Esc ') + chalk_1.default.gray('Clear');
         }
     }
     else if (totalPackages < totalBeforeFilter) {
         // Filter is applied but not in filter mode
         if (totalVisualItems > maxVisibleItems) {
-            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing ${chalk_1.default.white(startItem)}-${chalk_1.default.white(endItem)} of ${chalk_1.default.white(totalPackages)} matches (${chalk_1.default.white(totalBeforeFilter)} total)`) +
+            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing ${chalk_1.default.white(startItem)}-${chalk_1.default.white(endItem)} of ${chalk_1.default.white(totalPackages)} matches`) +
+                '  ' +
+                chalk_1.default.bold.white('D/P/O ') + chalk_1.default.gray('Filter') +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('/ ') +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Edit filter') +
+                chalk_1.default.bold.white('M ') + chalk_1.default.gray('Minor') +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Enter ') +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Confirm') +
+                chalk_1.default.bold.white('L ') + chalk_1.default.gray('All') +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Esc ') +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('Cancel');
+                chalk_1.default.bold.white('U ') + chalk_1.default.gray('None') +
+                '  ' +
+                chalk_1.default.bold.white('Esc ') + chalk_1.default.gray('Clear');
         }
         else {
-            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing all ${chalk_1.default.white(totalPackages)} matches (${chalk_1.default.white(totalBeforeFilter)} total)`) +
+            statusLine = (0, themes_colors_1.getThemeColor)('textSecondary')(`Showing all ${chalk_1.default.white(totalPackages)} matches`) +
+                '  ' +
+                chalk_1.default.bold.white('D/P/O ') + chalk_1.default.gray('Filter') +
+                '  ' +
+                chalk_1.default.bold.white('M ') + chalk_1.default.gray('Minor') +
                 '  ' +
-                (0, themes_colors_1.getThemeColor)('textSecondary')('/ ') +
-                chalk_1.default.gray('Edit filter') +
+                chalk_1.default.bold.white('L ') + chalk_1.default.gray('All') +
                 '  ' +
-                chalk_1.default.gray('Enter ') +
-                chalk_1.default.gray('Confirm') +
+                chalk_1.default.bold.white('U ') + chalk_1.default.gray('None') +
                 '  ' +
-                chalk_1.default.gray('Esc ') +
-                chalk_1.default.gray('Cancel');
+                chalk_1.default.bold.white('Esc ') + chalk_1.default.gray('Clear');
         }
     }
     else {
@@ -301,23 +310,18 @@ function renderInterface(states, currentRow, scrollOffset, maxVisibleItems, forc
         if (totalVisualItems > maxVisibleItems) {
             statusLine = chalk_1.default.gray(`Showing ${chalk_1.default.white(startItem)}-${chalk_1.default.white(endItem)} of ${chalk_1.default.white(totalPackages)} packages`) +
                 '  ' +
-                chalk_1.default.gray('Enter ') +
-                chalk_1.default.gray('Confirm') +
-                '  ' +
-                chalk_1.default.gray('Esc ') +
-                chalk_1.default.gray('Cancel');
+                chalk_1.default.bold.white('Enter ') + chalk_1.default.gray('Confirm');
         }
         else {
             statusLine = chalk_1.default.gray(`Showing all ${chalk_1.default.white(totalPackages)} packages`) +
                 '  ' +
-                chalk_1.default.gray('Enter ') +
-                chalk_1.default.gray('Confirm') +
-                '  ' +
-                chalk_1.default.gray('Esc ') +
-                chalk_1.default.gray('Cancel');
+                chalk_1.default.bold.white('Enter ') + chalk_1.default.gray('Confirm');
         }
     }
-    output.push('  ' + statusLine);
+    // Pad status line to terminal width to clear any leftover characters
+    const statusLineFull = '  ' + statusLine;
+    const statusPadding = Math.max(0, terminalWidth - utils_1.VersionUtils.getVisualLength(statusLineFull));
+    output.push(statusLineFull + ' '.repeat(statusPadding));
     output.push('');
     // Render visible items
     if (renderableItems && renderableItems.length > 0) {

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

@@ -21,13 +21,17 @@ class FilterManager {
     getFilterQuery() {
         return this.state.filterQuery;
     }
-    enterFilterMode() {
+    enterFilterMode(preserveQuery = false) {
         this.state.filterMode = true;
-        this.state.filterQuery = '';
+        if (!preserveQuery) {
+            this.state.filterQuery = '';
+        }
     }
-    exitFilterMode() {
+    exitFilterMode(clearQuery = false) {
         this.state.filterMode = false;
-        this.state.filterQuery = '';
+        if (clearQuery) {
+            this.state.filterQuery = '';
+        }
     }
     updateFilterQuery(query) {
         this.state.filterQuery = query;

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

@@ -161,12 +161,12 @@ class StateManager {
         this.renderState.forceFullRender = true;
     }
     // Filter delegation
-    enterFilterMode() {
-        this.filterManager.enterFilterMode();
+    enterFilterMode(preserveQuery = false) {
+        this.filterManager.enterFilterMode(preserveQuery);
         // Use incremental render for search mode toggle (no blink)
     }
-    exitFilterMode() {
-        this.filterManager.exitFilterMode();
+    exitFilterMode(clearQuery = false) {
+        this.filterManager.exitFilterMode(clearQuery);
         this.navigationManager.setCurrentRow(0);
         this.navigationManager.setScrollOffset(0);
         // Use incremental render for search mode toggle (no blink)

package/dist/ui/themes-colors.js

@@ -89,6 +89,39 @@ const themeColorDefinitions = {
         text: '#ABB2BF',
         textSecondary: '#5C6370',
     },
+    gruvbox: {
+        bg: '#282828',
+        primary: '#83A598',
+        secondary: '#D3869B',
+        success: '#B8BB26',
+        warning: '#FABD2F',
+        error: '#FB4934',
+        border: '#504945',
+        text: '#EBDBB2',
+        textSecondary: '#A89984',
+    },
+    solarized: {
+        bg: '#002B36',
+        primary: '#268BD2',
+        secondary: '#D33682',
+        success: '#859900',
+        warning: '#B58900',
+        error: '#DC322F',
+        border: '#073642',
+        text: '#839496',
+        textSecondary: '#657B83',
+    },
+    github: {
+        bg: '#0D1117',
+        primary: '#58A6FF',
+        secondary: '#BC8CFF',
+        success: '#3FB950',
+        warning: '#D29922',
+        error: '#F85149',
+        border: '#30363D',
+        text: '#C9D1D9',
+        textSecondary: '#8B949E',
+    },
 };
 // Helper to apply color - handles both hex and named colors
 function applyColor(color, text) {

package/dist/ui/themes.js

@@ -13,6 +13,9 @@ const themesMetadata = {
     monokai: 'Monokai',
     tokyonight: 'Tokyo Night',
     onedark: 'One Dark',
+    gruvbox: 'Gruvbox',
+    solarized: 'Solarized',
+    github: 'GitHub',
 };
 // Theme definitions
 exports.themes = Object.entries(themesMetadata).reduce((acc, [key, name]) => {

package/dist/ui/utils/cursor.js

@@ -1,9 +1,9 @@
 "use strict";
 /**
- * Cursor utility functions for terminal control
+ * Cursor and terminal utility functions
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CursorUtils = void 0;
+exports.ConsoleUtils = exports.CursorUtils = void 0;
 exports.CursorUtils = {
     /**
      * Hide the cursor in the terminal
@@ -29,5 +29,37 @@ exports.CursorUtils = {
     clearToEndOfScreen() {
         process.stdout.write('\x1b[J');
     },
+    /**
+     * Clean up terminal state - restore cursor and disable raw mode.
+     * Used when exiting interactive mode.
+     */
+    cleanup() {
+        exports.CursorUtils.show();
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+    },
+};
+/**
+ * Console utilities for progress display and line clearing
+ */
+exports.ConsoleUtils = {
+    /**
+     * Default line width for clearing progress messages
+     */
+    LINE_WIDTH: 80,
+    /**
+     * Show a progress message on the current line (overwrites previous content)
+     */
+    showProgress(message) {
+        process.stdout.write(`\r${' '.repeat(exports.ConsoleUtils.LINE_WIDTH)}\r${message}`);
+    },
+    /**
+     * Clear the current progress line
+     */
+    clearProgress() {
+        process.stdout.write('\r' + ' '.repeat(exports.ConsoleUtils.LINE_WIDTH) + '\r');
+    },
 };
 //# sourceMappingURL=cursor.js.map

package/dist/ui/utils/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CursorUtils = exports.VersionUtils = void 0;
+exports.ConsoleUtils = exports.CursorUtils = exports.VersionUtils = void 0;
 var version_1 = require("./version");
 Object.defineProperty(exports, "VersionUtils", { enumerable: true, get: function () { return version_1.VersionUtils; } });
 var cursor_1 = require("./cursor");
 Object.defineProperty(exports, "CursorUtils", { enumerable: true, get: function () { return cursor_1.CursorUtils; } });
+Object.defineProperty(exports, "ConsoleUtils", { enumerable: true, get: function () { return cursor_1.ConsoleUtils; } });
 //# sourceMappingURL=index.js.map

package/dist/ui/utils/version.js

@@ -5,6 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionUtils = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+/**
+ * ANSI escape code pattern for stripping terminal colors
+ */
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
 class VersionUtils {
     static applyVersionPrefix(originalSpecifier, targetVersion) {
         // Extract prefix from original specifier (^ or ~)
@@ -13,9 +17,17 @@ class VersionUtils {
         // Return target version with same prefix
         return prefix + targetVersion;
     }
+    /**
+     * Strip ANSI escape codes from a string
+     */
+    static stripAnsi(str) {
+        return str.replace(ANSI_PATTERN, '');
+    }
+    /**
+     * Get the visual length of a string (excluding ANSI codes)
+     */
     static getVisualLength(str) {
-        // Strip ANSI escape codes to get visual length
-        return str.replace(/\u001b\[[0-9;]*m/g, '').length;
+        return VersionUtils.stripAnsi(str).length;
     }
     /**
      * Truncate text with ellipsis in the middle if it exceeds maxLength
@@ -35,7 +47,7 @@ class VersionUtils {
         const startLength = Math.ceil(availableLength / 2);
         const endLength = Math.floor(availableLength / 2);
         // Extract raw text without ANSI codes to calculate positions
-        const rawText = str.replace(/\u001b\[[0-9;]*m/g, '');
+        const rawText = VersionUtils.stripAnsi(str);
         const start = rawText.substring(0, startLength);
         const end = rawText.substring(rawText.length - endLength);
         return start + ellipsis + end;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inup",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "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": {