inup 1.4.4 → 1.4.5

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

@@ -44,6 +44,7 @@ class PackageDetector {
         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 +68,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

package/dist/services/index.js

@@ -21,4 +21,5 @@ __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);
 //# sourceMappingURL=index.js.map

package/dist/services/jsdelivr-registry.js

@@ -40,6 +40,7 @@ const undici_1 = require("undici");
 const semver = __importStar(require("semver"));
 const config_1 = require("../config");
 const npm_registry_1 = require("./npm-registry");
+const persistent_cache_1 = require("./persistent-cache");
 // 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', {
@@ -135,15 +136,31 @@ 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);
+        // Try to get from in-memory cache first (fastest)
+        const memoryCached = packageCache.get(packageName);
+        if (memoryCached && Date.now() - memoryCached.timestamp < config_1.CACHE_TTL) {
+            packageData.set(packageName, memoryCached.data);
             completedCount++;
             if (onProgress) {
                 onProgress(packageName, completedCount, total);
             }
-            addToBatch(packageName, cached.data);
+            addToBatch(packageName, memoryCached.data);
+            return;
+        }
+        // Try persistent disk cache (fast, survives restarts)
+        const diskCached = persistent_cache_1.persistentCache.get(packageName);
+        if (diskCached) {
+            // Also populate in-memory cache for subsequent accesses
+            packageCache.set(packageName, {
+                data: diskCached,
+                timestamp: Date.now(),
+            });
+            packageData.set(packageName, diskCached);
+            completedCount++;
+            if (onProgress) {
+                onProgress(packageName, completedCount, total);
+            }
+            addToBatch(packageName, diskCached);
             return;
         }
         try {
@@ -168,10 +185,13 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
                 const result = npmData.get(packageName);
                 if (result) {
                     packageData.set(packageName, result);
+                    // Cache in memory
                     packageCache.set(packageName, {
                         data: result,
                         timestamp: Date.now(),
                     });
+                    // Cache to disk for persistence
+                    persistent_cache_1.persistentCache.set(packageName, result);
                     addToBatch(packageName, result);
                 }
                 completedCount++;
@@ -190,11 +210,13 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
                 latestVersion,
                 allVersions: allVersions.sort(semver.rcompare),
             };
-            // Cache the result
+            // Cache the result in memory
             packageCache.set(packageName, {
                 data: result,
                 timestamp: Date.now(),
             });
+            // Cache to disk for persistence
+            persistent_cache_1.persistentCache.set(packageName, result);
             packageData.set(packageName, result);
             completedCount++;
             if (onProgress) {
@@ -209,10 +231,13 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
                 const result = npmData.get(packageName);
                 if (result) {
                     packageData.set(packageName, result);
+                    // Cache in memory
                     packageCache.set(packageName, {
                         data: result,
                         timestamp: Date.now(),
                     });
+                    // Cache to disk for persistence
+                    persistent_cache_1.persistentCache.set(packageName, result);
                     addToBatch(packageName, result);
                 }
             }
@@ -229,6 +254,8 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
     await Promise.all(packageNames.map(fetchPackageWithFallback));
     // Flush any remaining batch items
     flushBatch();
+    // Flush persistent cache to disk
+    persistent_cache_1.persistentCache.flush();
     // Clear the progress line and show completion time if no custom progress handler
     if (!onProgress) {
         process.stdout.write('\r' + ' '.repeat(80) + '\r');

package/dist/services/npm-registry.js

@@ -37,16 +37,27 @@ exports.getAllPackageData = getAllPackageData;
 exports.clearPackageCache = clearPackageCache;
 const semver = __importStar(require("semver"));
 const config_1 = require("../config");
+const persistent_cache_1 = require("./persistent-cache");
 const packageCache = new Map();
 /**
  * Fetches package data from npm registry with caching using native fetch.
  * Includes timeout support for slow connections.
  */
 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;
+    // Check in-memory cache first (fastest)
+    const memoryCached = packageCache.get(packageName);
+    if (memoryCached && Date.now() - memoryCached.timestamp < config_1.CACHE_TTL) {
+        return memoryCached.data;
+    }
+    // Check persistent disk cache (fast, survives restarts)
+    const diskCached = persistent_cache_1.persistentCache.get(packageName);
+    if (diskCached) {
+        // Also populate in-memory cache for subsequent accesses
+        packageCache.set(packageName, {
+            data: diskCached,
+            timestamp: Date.now(),
+        });
+        return diskCached;
     }
     try {
         const url = `${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
@@ -78,11 +89,13 @@ async function fetchPackageFromRegistry(packageName) {
                 latestVersion,
                 allVersions,
             };
-            // Cache the result
+            // Cache the result in memory
             packageCache.set(packageName, {
                 data: result,
                 timestamp: Date.now(),
             });
+            // Cache to disk for persistence
+            persistent_cache_1.persistentCache.set(packageName, result);
             return result;
         }
         finally {
@@ -118,6 +131,8 @@ async function getAllPackageData(packageNames, onProgress) {
     });
     // Wait for all requests to complete
     await Promise.all(allPromises);
+    // Flush persistent cache to disk
+    persistent_cache_1.persistentCache.flush();
     // Clear the progress line and show completion time if no custom progress handler
     if (!onProgress) {
         process.stdout.write('\r' + ' '.repeat(80) + '\r');

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/package.json

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