inup 1.4.3 → 1.4.5

package/README.md

@@ -1,14 +1,14 @@
-# inup
+# 🚀 inup
 
 [![npm version](https://img.shields.io/npm/v/inup?logo=npm&logoColor=%23CB3837&style=for-the-badge&color=crimson)](https://www.npmjs.com/package/inup)
 [![Downloads](https://img.shields.io/npm/dm/inup?style=for-the-badge&color=646CFF&logoColor=white)](https://www.npmjs.com/package/inup)
 [![Total downloads](https://img.shields.io/npm/dt/inup?style=for-the-badge&color=informational)](https://www.npmjs.com/package/inup)
 
-Interactive upgrade for your dependencies. Works with npm, yarn, pnpm, and bun.
+Upgrade your dependencies interactively. Works with npm, yarn, pnpm, and bun.
 
 ![Interactive Upgrade Demo](docs/demo/interactive-upgrade.gif)
 
-## Install
+## 🚀 Usage
 
 ```bash
 npx inup
@@ -20,24 +20,17 @@ Or install globally:
 npm install -g inup
 ```
 
-## Usage
-
-```bash
-npx inup
-```
-
 That's it. The tool scans your project, finds outdated packages, and lets you pick what to upgrade.
 
-## Features
+## 💡 Why inup?
 
-- Auto-detects package manager (npm, yarn, pnpm, bun)
-- Works with monorepos and workspaces
-- Batch upgrades with keyboard shortcuts
-- Search packages with `/`
-- Multiple themes (press `t`)
-- Package info modal (press `i`)
+- **Inclusive by Default**: We load Dev, Peer, and Optional dependencies automatically. No more restarting the tool because you forgot a `--peer` flag.
+- **Live Toggles**: Toggle dependency types (`d`, `p`, `o`) on the fly without exiting.
+- **Zero Config**: Auto-detects your package manager.
+- **Monorepo Ready**: Seamlessly handles workspaces.
+- **Modern UX**: Search with `/`, view package details with `i`, and swap themes with `t`.
 
-## Keyboard Shortcuts
+## ⌨️ Keyboard Shortcuts
 
 - `↑/↓` - Navigate packages
 - `←/→` - Select version (current, patch, minor, major)
@@ -50,18 +43,22 @@ That's it. The tool scans your project, finds outdated packages, and lets you pi
 - `i` - View package info
 - `Enter` - Confirm and upgrade
 
-## Options
+## ⚙️ Options
 
 ```bash
 inup [options]
 
 -d, --dir <path>              Run in specific directory
 -e, --exclude <patterns>      Skip directories (comma-separated regex)
--p, --peer                    Include peer dependencies
--o, --optional                Include optional dependencies
 --package-manager <name>      Force package manager (npm, yarn, pnpm, bun)
 ```
 
-## License
+## 🔒 Privacy
+
+We don't track anything. Ever.
+
+The only network requests made are to the npm registry and jsDelivr CDN to fetch package version data. That's it.
+
+## 📄 License
 
 MIT

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
@@ -88,19 +98,11 @@ class PackageDetector {
             }
         }
         const allPackageData = config_1.DEFAULT_REGISTRY === 'jsdelivr'
-            ? await (0, services_1.getAllPackageDataFromJsdelivr)(packageNames, currentVersions, (currentPackage, completed, total) => {
-                const percentage = Math.round((completed / total) * 100);
-                const truncatedPackage = currentPackage.length > 40
-                    ? currentPackage.substring(0, 37) + '...'
-                    : currentPackage;
-                this.showProgress(`🌐 Fetching ${percentage}% (${truncatedPackage})`);
+            ? await (0, services_1.getAllPackageDataFromJsdelivr)(packageNames, currentVersions, (_currentPackage, completed, total) => {
+                this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
             })
-            : await (0, services_1.getAllPackageData)(packageNames, (currentPackage, completed, total) => {
-                const percentage = Math.round((completed / total) * 100);
-                const truncatedPackage = currentPackage.length > 40
-                    ? currentPackage.substring(0, 37) + '...'
-                    : currentPackage;
-                this.showProgress(`🌐 Fetching ${percentage}% (${truncatedPackage})`);
+            : await (0, services_1.getAllPackageData)(packageNames, (_currentPackage, completed, total) => {
+                this.showProgress(`🌐 Checking versions... (${completed}/${total} packages)`);
             });
         try {
             for (const dep of allDeps) {

package/dist/services/changelog-fetcher.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.changelogFetcher = exports.ChangelogFetcher = void 0;
+const constants_1 = require("../config/constants");
 /**
  * Fetches package metadata from npm registry
  * Includes description, repository info, and basic metadata
@@ -69,12 +70,13 @@ class ChangelogFetcher {
         }
     }
     /**
-     * Fetch data from npm registry
-     * Returns the package data from the registry
+     * Fetch data from jsdelivr CDN
+     * Returns the package data by fetching package.json directly from jsdelivr
      */
     async fetchFromRegistry(packageName) {
         try {
-            const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+            // Fetch package.json directly from jsdelivr CDN (resolves to latest automatically)
+            const response = await fetch(`${constants_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@latest/package.json`, {
                 method: 'GET',
                 headers: {
                     accept: 'application/json',
@@ -83,20 +85,15 @@ class ChangelogFetcher {
             if (!response.ok) {
                 return null;
             }
-            const data = (await response.json());
-            // Get the latest version data
-            const distTags = data['dist-tags'];
-            const latestVersion = distTags?.latest;
-            const versions = data.versions;
-            const latestPackageData = latestVersion ? versions?.[latestVersion] : undefined;
+            const pkgData = (await response.json());
             return {
-                description: data.description,
-                homepage: (data.homepage || latestPackageData?.homepage),
-                repository: (data.repository || latestPackageData?.repository),
-                bugs: (data.bugs || latestPackageData?.bugs),
-                keywords: (data.keywords || []),
-                author: (data.author || latestPackageData?.author),
-                license: (data.license || latestPackageData?.license),
+                description: pkgData.description,
+                homepage: pkgData.homepage,
+                repository: pkgData.repository,
+                bugs: pkgData.bugs,
+                keywords: (pkgData.keywords || []),
+                author: pkgData.author,
+                license: pkgData.license,
             };
         }
         catch {

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', {
@@ -49,6 +50,9 @@ const jsdelivrPool = new undici_1.Pool('https://cdn.jsdelivr.net', {
     keepAliveMaxTimeout: config_1.REQUEST_TIMEOUT, // Maximum keep-alive timeout
     connectTimeout: config_1.REQUEST_TIMEOUT, // 60 seconds connect timeout
 });
+// 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.
@@ -86,32 +90,77 @@ async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
 /**
  * Fetches package version data from jsdelivr CDN for multiple packages.
  * Uses undici connection pool for blazing fast performance with connection reuse.
- * Falls back to npm registry in batches if jsdelivr doesn't have packages.
+ * Falls back to npm registry immediately when jsdelivr fails (interleaved, not sequential).
+ * Supports batched callbacks for progressive UI updates.
  * @param packageNames - Array of package names to fetch
  * @param currentVersions - Optional map of package names to their current versions
  * @param onProgress - Optional progress callback
+ * @param onBatchReady - Optional callback for batch updates (fires every BATCH_SIZE packages or BATCH_TIMEOUT_MS)
  * @returns Map of package names to their version data
  */
-async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onProgress) {
+async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onProgress, onBatchReady) {
     const packageData = new Map();
     if (packageNames.length === 0) {
         return packageData;
     }
     const total = packageNames.length;
     let completedCount = 0;
-    // Track packages that need npm fallback (not found on jsDelivr)
-    const failedPackages = [];
-    // Fire all jsDelivr requests simultaneously - undici pool handles concurrency internally
-    const allPromises = packageNames.map(async (packageName) => {
+    // Batch buffer for progressive updates
+    let batchBuffer = [];
+    let batchTimer = null;
+    // Helper to flush the current batch
+    const flushBatch = () => {
+        if (batchBuffer.length > 0 && onBatchReady) {
+            onBatchReady([...batchBuffer]);
+            batchBuffer = [];
+        }
+        if (batchTimer) {
+            clearTimeout(batchTimer);
+            batchTimer = null;
+        }
+    };
+    // 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);
+            }
+        }
+    };
+    // 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, 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 {
@@ -131,8 +180,24 @@ async function getAllPackageDataFromJsdelivr(packageNames, currentVersions, onPr
             const latestResult = results[0];
             const majorResult = results[1];
             if (!latestResult) {
-                // Package not on jsDelivr, mark for npm fallback
-                failedPackages.push(packageName);
+                // 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);
+                    // 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++;
+                if (onProgress) {
+                    onProgress(packageName, completedCount, total);
+                }
                 return;
             }
             const latestVersion = latestResult.version;
@@ -145,41 +210,52 @@ 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) {
                 onProgress(packageName, completedCount, total);
             }
+            addToBatch(packageName, result);
         }
         catch (error) {
-            // On error, mark for npm fallback
-            failedPackages.push(packageName);
-        }
-    });
-    // Wait for all jsDelivr requests to complete
-    await Promise.all(allPromises);
-    // Batch fetch all failed packages from npm registry in one call
-    if (failedPackages.length > 0) {
-        const npmData = await (0, npm_registry_1.getAllPackageData)(failedPackages, (pkg, completed, npmTotal) => {
+            // 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);
+                    // 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);
+                }
+            }
+            catch (npmError) {
+                // If both fail, just continue
+            }
             completedCount++;
             if (onProgress) {
-                onProgress(pkg, completedCount, total);
+                onProgress(packageName, completedCount, total);
             }
-        });
-        // Merge npm data into results and cache it
-        for (const [packageName, data] of npmData.entries()) {
-            packageData.set(packageName, data);
-            packageCache.set(packageName, {
-                data,
-                timestamp: Date.now(),
-            });
         }
-    }
+    };
+    // 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
+    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.3",
+  "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": {