inup 1.4.9 → 1.4.10

package/README.md

@@ -14,6 +14,12 @@ Upgrade your dependencies interactively. Works with npm, yarn, pnpm, and bun.
 npx inup
 ```
 
+Scan deeper package layouts:
+
+```bash
+npx inup --max-depth 15
+```
+
 Or install globally:
 
 ```bash
@@ -50,7 +56,10 @@ inup [options]
 
 -d, --dir <path>              Run in specific directory
 -e, --exclude <patterns>      Skip directories (comma-separated regex)
+-i, --ignore <packages>       Ignore packages (comma-separated, glob supported)
+--max-depth <number>          Maximum scan depth for package discovery (default: 10)
 --package-manager <name>      Force package manager (npm, yarn, pnpm, bun)
+--debug                       Write verbose debug logs
 ```
 
 ## 🔒 Privacy

package/dist/cli.js

@@ -21,12 +21,11 @@ program
     .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('--max-depth <number>', 'maximum directory depth for package.json discovery', '10')
     .option('--package-manager <name>', 'manually specify package manager (npm, yarn, pnpm, bun)')
     .option('--debug', 'write verbose debug log to /tmp/inup-debug-YYYY-MM-DD.log')
     .action(async (options) => {
     console.log(chalk_1.default.bold.blue(`🚀 `) + chalk_1.default.bold.red(`i`) + chalk_1.default.bold.yellow(`n`) + chalk_1.default.bold.blue(`u`) + chalk_1.default.bold.magenta(`p`) + `\n`);
-    // Check for updates in the background (non-blocking)
-    const updateCheckPromise = (0, services_1.checkForUpdateAsync)('inup', packageJson.version);
     const cwd = (0, path_1.resolve)(options.dir);
     if (options.debug || process.env.INUP_DEBUG === '1') {
         (0, utils_1.enableDebugLogging)();
@@ -49,6 +48,14 @@ program
             .filter(Boolean)
         : [];
     const ignorePackages = [...new Set([...cliIgnorePatterns, ...(projectConfig.ignore || [])])];
+    const maxDepth = Number.parseInt(options.maxDepth, 10);
+    if (!Number.isInteger(maxDepth) || maxDepth < 0) {
+        console.error(chalk_1.default.red(`Invalid max depth: ${options.maxDepth}`));
+        console.error(chalk_1.default.yellow('Expected a non-negative integer, for example: --max-depth 10'));
+        process.exit(1);
+    }
+    // Check for updates in the background (non-blocking)
+    const updateCheckPromise = (0, services_1.checkForUpdateAsync)('inup', packageJson.version);
     // Validate package manager if provided
     let packageManager;
     if (options.packageManager) {
@@ -63,6 +70,7 @@ program
     const upgrader = new index_1.UpgradeRunner({
         cwd,
         excludePatterns,
+        maxDepth,
         ignorePackages,
         packageManager,
         debug: options.debug || process.env.INUP_DEBUG === '1',

package/dist/core/package-detector.js

@@ -47,6 +47,7 @@ class PackageDetector {
         this.cwd = options?.cwd || process.cwd();
         this.excludePatterns = options?.excludePatterns || [];
         this.ignorePackages = options?.ignorePackages || [];
+        this.maxDepth = options?.maxDepth ?? 10;
         this.packageJsonPath = (0, utils_1.findPackageJson)(this.cwd);
         if (this.packageJsonPath) {
             this.packageJson = (0, utils_1.readPackageJson)(this.packageJsonPath);
@@ -65,7 +66,7 @@ class PackageDetector {
         // Always check all package.json files recursively with timeout protection
         this.showProgress('🔍 Scanning repository for package.json files...');
         const tScan = Date.now();
-        const allPackageJsonFiles = this.findPackageJsonFilesWithTimeout(30000); // 30 second timeout
+        const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000); // 30 second timeout
         utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
             files: allPackageJsonFiles,
         });
@@ -199,15 +200,29 @@ class PackageDetector {
             throw error;
         }
     }
-    findPackageJsonFilesWithTimeout(timeoutMs) {
-        // Synchronous file search with depth limiting and symlink protection
-        // The timeout parameter is kept for future async implementation
+    async findPackageJsonFilesWithTimeout(timeoutMs) {
         try {
-            return (0, utils_1.findAllPackageJsonFiles)(this.cwd, this.excludePatterns, 10, (currentDir, foundCount) => {
-                // Show scanning progress with current directory and count
-                const truncatedDir = currentDir.length > 50 ? '...' + currentDir.slice(-47) : currentDir;
-                this.showProgress(`🔍 Scanning ${truncatedDir} (found ${foundCount})`);
-            });
+            let timeoutId;
+            try {
+                return await Promise.race([
+                    (0, utils_1.findAllPackageJsonFilesAsync)(this.cwd, this.excludePatterns, this.maxDepth, (currentDir, foundCount) => {
+                        // Show scanning progress with current directory and count
+                        const truncatedDir = currentDir.length > 50 ? '...' + currentDir.slice(-47) : currentDir;
+                        this.showProgress(`🔍 Scanning ${truncatedDir} (found ${foundCount})`);
+                    }),
+                    new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => {
+                            reject(new Error(`Scan timed out after ${timeoutMs}ms`));
+                        }, timeoutMs);
+                        timeoutId.unref?.();
+                    }),
+                ]);
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
         }
         catch (err) {
             throw new Error(`Failed to scan for package.json files: ${err}. Try using --exclude patterns to skip problematic directories.`);

package/dist/utils/filesystem.js

@@ -7,6 +7,7 @@ exports.readPackageJsonAsync = readPackageJsonAsync;
 exports.collectAllDependencies = collectAllDependencies;
 exports.collectAllDependenciesAsync = collectAllDependenciesAsync;
 exports.findAllPackageJsonFiles = findAllPackageJsonFiles;
+exports.findAllPackageJsonFilesAsync = findAllPackageJsonFilesAsync;
 const fs_1 = require("fs");
 const fs_2 = require("fs");
 const path_1 = require("path");
@@ -55,6 +56,20 @@ async function readPackageJsonAsync(path) {
         throw new Error(`Failed to read package.json: ${error}`);
     }
 }
+const SKIP_DIRS = new Set([
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    'out',
+    'lib',
+    'es',
+    'esm',
+    'cjs',
+]);
+function shouldSkipDirectory(name) {
+    return name.startsWith('.') || SKIP_DIRS.has(name);
+}
 /**
  * Collects all dependencies from multiple package.json files.
  * Always includes regular dependencies and devDependencies.
@@ -135,11 +150,24 @@ function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [],
     const packageJsonFiles = [];
     const visitedPaths = new Set();
     let directoriesScanned = 0;
+    let lastProgressAt = 0;
+    const progressIntervalMs = 250;
     // Compile regex patterns for exclude filtering
     const excludeRegexes = excludePatterns.map((pattern) => new RegExp(pattern, 'i'));
     function shouldExcludePath(relativePath) {
         return excludeRegexes.some((regex) => regex.test(relativePath));
     }
+    function reportProgress(currentDir, force = false) {
+        if (!onProgress)
+            return;
+        const now = Date.now();
+        if (!force && now - lastProgressAt < progressIntervalMs) {
+            return;
+        }
+        lastProgressAt = now;
+        const relativePath = (0, path_1.relative)(rootDir, currentDir) || '.';
+        onProgress(relativePath, packageJsonFiles.length);
+    }
     function traverseDirectory(dir, depth = 0) {
         // Prevent infinite recursion with depth limit
         if (depth > maxDepth) {
@@ -155,11 +183,11 @@ function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [],
             directoriesScanned++;
             // Report progress every 10 directories or on first scan
             if (onProgress && (directoriesScanned % 10 === 0 || directoriesScanned === 1)) {
-                const relativePath = (0, path_1.relative)(rootDir, dir) || '.';
-                onProgress(relativePath, packageJsonFiles.length);
+                reportProgress(dir, true);
             }
             const files = (0, fs_1.readdirSync)(dir);
             for (const file of files) {
+                reportProgress(dir);
                 const fullPath = (0, path_1.join)(dir, file);
                 const relativePath = (0, path_1.relative)(rootDir, fullPath);
                 // Skip if path matches exclude patterns
@@ -174,26 +202,7 @@ function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [],
                     // Skip files/dirs we can't stat (broken symlinks, permission issues)
                     continue;
                 }
-                // Skip common build and dependency directories
-                const skipDirs = [
-                    'node_modules',
-                    '.git',
-                    'dist',
-                    'build',
-                    '.next',
-                    'coverage',
-                    '.cache',
-                    'out',
-                    '.output',
-                    '.nuxt',
-                    '.vercel',
-                    '.netlify',
-                    'lib',
-                    'es',
-                    'esm',
-                    'cjs',
-                ];
-                if (stat.isDirectory() && !file.startsWith('.') && !skipDirs.includes(file)) {
+                if (stat.isDirectory() && !shouldSkipDirectory(file)) {
                     traverseDirectory(fullPath, depth + 1);
                 }
                 else if (file === 'package.json' && stat.isFile()) {
@@ -208,4 +217,122 @@ function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [],
     traverseDirectory(rootDir);
     return packageJsonFiles;
 }
+/**
+ * Find all package.json files recursively with bounded parallel directory traversal.
+ */
+async function findAllPackageJsonFilesAsync(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress, options = {}) {
+    const packageJsonFiles = [];
+    const visitedPaths = new Set();
+    let directoriesScanned = 0;
+    let lastProgressAt = 0;
+    const progressIntervalMs = 250;
+    const concurrency = Math.max(1, Math.min(options.concurrency ?? 16, 64));
+    const excludeRegexes = excludePatterns.map((pattern) => new RegExp(pattern, 'i'));
+    function shouldExcludePath(relativePath) {
+        return excludeRegexes.some((regex) => regex.test(relativePath));
+    }
+    function reportProgress(currentDir, force = false) {
+        if (!onProgress)
+            return;
+        const now = Date.now();
+        if (!force && now - lastProgressAt < progressIntervalMs) {
+            return;
+        }
+        lastProgressAt = now;
+        const relativePath = (0, path_1.relative)(rootDir, currentDir) || '.';
+        onProgress(relativePath, packageJsonFiles.length);
+    }
+    const pending = [];
+    let activeTasks = 0;
+    let failedError = null;
+    let resolveDone = null;
+    let rejectDone = null;
+    const done = new Promise((resolve, reject) => {
+        resolveDone = resolve;
+        rejectDone = reject;
+    });
+    function finishIfIdle() {
+        if (pending.length === 0 && activeTasks === 0) {
+            resolveDone?.();
+        }
+    }
+    function schedule(dir, depth) {
+        pending.push({ dir, depth });
+        pump();
+    }
+    async function processDirectory(dir, depth) {
+        if (depth > maxDepth) {
+            return;
+        }
+        let realPath;
+        try {
+            realPath = await fs_2.promises.realpath(dir);
+        }
+        catch {
+            return;
+        }
+        if (visitedPaths.has(realPath)) {
+            return;
+        }
+        visitedPaths.add(realPath);
+        directoriesScanned++;
+        if (directoriesScanned % 10 === 0 || directoriesScanned === 1) {
+            reportProgress(dir, true);
+        }
+        let files;
+        try {
+            files = await fs_2.promises.readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const file of files) {
+            reportProgress(dir);
+            const fullPath = (0, path_1.join)(dir, file);
+            const relativePath = (0, path_1.relative)(rootDir, fullPath);
+            if (shouldExcludePath(relativePath)) {
+                continue;
+            }
+            let stat;
+            try {
+                stat = await fs_2.promises.stat(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory() && !shouldSkipDirectory(file)) {
+                schedule(fullPath, depth + 1);
+            }
+            else if (file === 'package.json' && stat.isFile()) {
+                packageJsonFiles.push(fullPath);
+            }
+        }
+    }
+    function pump() {
+        while (activeTasks < concurrency && pending.length > 0 && !failedError) {
+            const next = pending.shift();
+            if (!next)
+                break;
+            activeTasks++;
+            void processDirectory(next.dir, next.depth)
+                .catch((error) => {
+                if (!failedError) {
+                    failedError = error;
+                    rejectDone?.(error);
+                }
+            })
+                .finally(() => {
+                activeTasks--;
+                if (failedError) {
+                    return;
+                }
+                pump();
+                finishIfIdle();
+            });
+        }
+    }
+    schedule(rootDir, 0);
+    await done;
+    return packageJsonFiles;
+}
 //# sourceMappingURL=filesystem.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inup",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "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": {
@@ -38,12 +38,12 @@
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
     "@types/keypress.js": "^2.1.3",
-    "@types/node": "^24.10.1",
+    "@types/node": "^24.12.0",
     "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.1.0",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.0"
   },
   "dependencies": {
     "chalk": "^5.6.2",