inup 1.4.0

package/dist/ui/utils.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionUtils = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class VersionUtils {
+    static applyVersionPrefix(originalSpecifier, targetVersion) {
+        // Extract prefix from original specifier (^ or ~)
+        const prefixMatch = originalSpecifier.match(/^([^\d]+)/);
+        const prefix = prefixMatch ? prefixMatch[1] : '';
+        // Return target version with same prefix
+        return prefix + targetVersion;
+    }
+    static getVisualLength(str) {
+        // Strip ANSI escape codes to get visual length
+        return str.replace(/\u001b\[[0-9;]*m/g, '').length;
+    }
+    static formatVersionDiff(current, target, colorFn) {
+        if (current === target) {
+            return chalk_1.default.white(target);
+        }
+        // Parse semantic versions into parts
+        const currentParts = current.split('.').map((part) => parseInt(part) || 0);
+        const targetParts = target.split('.').map((part) => parseInt(part) || 0);
+        // Find the first differing version segment (major, minor, or patch)
+        let firstDiffSegment = -1;
+        const maxLength = Math.max(currentParts.length, targetParts.length);
+        for (let i = 0; i < maxLength; i++) {
+            const currentPart = currentParts[i] || 0;
+            const targetPart = targetParts[i] || 0;
+            if (currentPart !== targetPart) {
+                firstDiffSegment = i;
+                break;
+            }
+        }
+        if (firstDiffSegment === -1) {
+            // Versions are identical (shouldn't happen due to guard above, but just in case)
+            return chalk_1.default.white(target);
+        }
+        // Build the result with proper coloring
+        const result = [];
+        for (let i = 0; i < maxLength; i++) {
+            const targetPart = targetParts[i] || 0;
+            const partStr = targetPart.toString();
+            if (i < firstDiffSegment) {
+                // Unchanged segment - keep white
+                result.push(partStr);
+            }
+            else {
+                // Changed segment or later - apply color
+                result.push(colorFn(partStr));
+            }
+            // Add dot separator if not the last part
+            if (i < maxLength - 1) {
+                // Color the dot the same as the following part
+                const nextPartColor = i + 1 < firstDiffSegment ? chalk_1.default.white : colorFn;
+                result.push(nextPartColor('.'));
+            }
+        }
+        return result.join('');
+    }
+}
+exports.VersionUtils = VersionUtils;
+//# sourceMappingURL=utils.js.map

package/dist/utils/exec.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = executeCommand;
+exports.executeCommandAsync = executeCommandAsync;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Execute a command synchronously
+ */
+function executeCommand(command, cwd) {
+    try {
+        return (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            cwd: cwd,
+        });
+    }
+    catch (error) {
+        throw new Error(`Command failed: ${command}\n${error}`);
+    }
+}
+/**
+ * Execute a command asynchronously
+ */
+async function executeCommandAsync(command) {
+    try {
+        const { stdout, stderr } = await execAsync(command, { encoding: 'utf-8' });
+        if (stderr && !stdout) {
+            throw new Error(stderr);
+        }
+        return stdout;
+    }
+    catch (error) {
+        throw new Error(`Command failed: ${command}\n${error}`);
+    }
+}
+//# sourceMappingURL=exec.js.map

package/dist/utils/filesystem.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPackageJson = findPackageJson;
+exports.findWorkspaceRoot = findWorkspaceRoot;
+exports.readPackageJson = readPackageJson;
+exports.readPackageJsonAsync = readPackageJsonAsync;
+exports.collectAllDependencies = collectAllDependencies;
+exports.collectAllDependenciesAsync = collectAllDependenciesAsync;
+exports.findAllPackageJsonFiles = findAllPackageJsonFiles;
+const fs_1 = require("fs");
+const fs_2 = require("fs");
+const path_1 = require("path");
+const package_manager_detector_1 = require("../services/package-manager-detector");
+/**
+ * Find package.json in the current working directory
+ */
+function findPackageJson(cwd = process.cwd()) {
+    const packageJsonPath = (0, path_1.join)(cwd, 'package.json');
+    return (0, fs_1.existsSync)(packageJsonPath) ? packageJsonPath : null;
+}
+/**
+ * Find the workspace root by detecting package manager and checking for workspace configuration
+ * @param cwd - Current working directory
+ * @param packageManager - Optional package manager to use (will auto-detect if not provided)
+ */
+function findWorkspaceRoot(cwd = process.cwd(), packageManager) {
+    // Auto-detect if not provided
+    if (!packageManager) {
+        const detected = package_manager_detector_1.PackageManagerDetector.detect(cwd);
+        packageManager = detected.name;
+    }
+    return package_manager_detector_1.PackageManagerDetector.findWorkspaceRoot(cwd, packageManager);
+}
+/**
+ * Read and parse a package.json file
+ */
+function readPackageJson(path) {
+    try {
+        const content = (0, fs_1.readFileSync)(path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read package.json: ${error}`);
+    }
+}
+/**
+ * Read and parse a package.json file asynchronously
+ */
+async function readPackageJsonAsync(path) {
+    try {
+        const content = await fs_2.promises.readFile(path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read package.json: ${error}`);
+    }
+}
+/**
+ * Collects all dependencies from multiple package.json files.
+ * Always includes regular dependencies and devDependencies.
+ * Optionally includes peer and optional dependencies based on flags.
+ */
+function collectAllDependencies(packageJsonFiles, options = {}) {
+    const { includePeerDeps = false, includeOptionalDeps = false } = options;
+    const allDeps = [];
+    for (const packageJsonPath of packageJsonFiles) {
+        try {
+            const packageJson = readPackageJson(packageJsonPath);
+            const depTypes = ['dependencies', 'devDependencies'];
+            if (includeOptionalDeps) {
+                depTypes.push('optionalDependencies');
+            }
+            if (includePeerDeps) {
+                depTypes.push('peerDependencies');
+            }
+            for (const depType of depTypes) {
+                const deps = packageJson[depType];
+                if (deps && typeof deps === 'object') {
+                    for (const [name, version] of Object.entries(deps)) {
+                        allDeps.push({
+                            name,
+                            version: version,
+                            type: depType,
+                            packageJsonPath,
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip malformed package.json files
+        }
+    }
+    return allDeps;
+}
+/**
+ * Collects all dependencies from multiple package.json files asynchronously.
+ * Reads all package.json files in parallel for better performance.
+ * Always includes regular dependencies and devDependencies.
+ * Optionally includes peer and optional dependencies based on flags.
+ */
+async function collectAllDependenciesAsync(packageJsonFiles, options = {}) {
+    const { includePeerDeps = false, includeOptionalDeps = false } = options;
+    // Read all package.json files in parallel
+    const packageJsonPromises = packageJsonFiles.map(async (packageJsonPath) => {
+        try {
+            const packageJson = await readPackageJsonAsync(packageJsonPath);
+            return { packageJson, packageJsonPath };
+        }
+        catch (error) {
+            // Skip malformed package.json files
+            return null;
+        }
+    });
+    const results = await Promise.all(packageJsonPromises);
+    // Collect dependencies from all successfully read package.json files
+    const allDeps = [];
+    for (const result of results) {
+        if (!result)
+            continue;
+        const { packageJson, packageJsonPath } = result;
+        const depTypes = ['dependencies', 'devDependencies'];
+        if (includeOptionalDeps) {
+            depTypes.push('optionalDependencies');
+        }
+        if (includePeerDeps) {
+            depTypes.push('peerDependencies');
+        }
+        for (const depType of depTypes) {
+            const deps = packageJson[depType];
+            if (deps && typeof deps === 'object') {
+                for (const [name, version] of Object.entries(deps)) {
+                    allDeps.push({
+                        name,
+                        version: version,
+                        type: depType,
+                        packageJsonPath,
+                    });
+                }
+            }
+        }
+    }
+    return allDeps;
+}
+/**
+ * Find all package.json files recursively
+ */
+function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress) {
+    const packageJsonFiles = [];
+    const visitedPaths = new Set();
+    let directoriesScanned = 0;
+    // 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 traverseDirectory(dir, depth = 0) {
+        // Prevent infinite recursion with depth limit
+        if (depth > maxDepth) {
+            return;
+        }
+        try {
+            // Prevent symlink cycles by tracking visited real paths
+            const realPath = (0, fs_1.realpathSync)(dir);
+            if (visitedPaths.has(realPath)) {
+                return;
+            }
+            visitedPaths.add(realPath);
+            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);
+            }
+            const files = (0, fs_1.readdirSync)(dir);
+            for (const file of files) {
+                const fullPath = (0, path_1.join)(dir, file);
+                const relativePath = (0, path_1.relative)(rootDir, fullPath);
+                // Skip if path matches exclude patterns
+                if (shouldExcludePath(relativePath)) {
+                    continue;
+                }
+                let stat;
+                try {
+                    stat = (0, fs_1.statSync)(fullPath);
+                }
+                catch {
+                    // 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)) {
+                    traverseDirectory(fullPath, depth + 1);
+                }
+                else if (file === 'package.json' && stat.isFile()) {
+                    packageJsonFiles.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories that can't be read (permission issues, etc.)
+        }
+    }
+    traverseDirectory(rootDir);
+    return packageJsonFiles;
+}
+//# sourceMappingURL=filesystem.js.map

package/dist/utils/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Shared utilities
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectAllDependenciesAsync = exports.readPackageJsonAsync = void 0;
+__exportStar(require("./filesystem"), exports);
+__exportStar(require("./exec"), exports);
+__exportStar(require("./version"), exports);
+// Re-export async functions for convenience
+var filesystem_1 = require("./filesystem");
+Object.defineProperty(exports, "readPackageJsonAsync", { enumerable: true, get: function () { return filesystem_1.readPackageJsonAsync; } });
+Object.defineProperty(exports, "collectAllDependenciesAsync", { enumerable: true, get: function () { return filesystem_1.collectAllDependenciesAsync; } });
+//# sourceMappingURL=index.js.map

package/dist/utils/version.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVersionOutdated = isVersionOutdated;
+exports.getOptimizedRangeVersion = getOptimizedRangeVersion;
+exports.findClosestMinorVersion = findClosestMinorVersion;
+const semver = __importStar(require("semver"));
+/**
+ * Checks if a version is outdated compared to the latest version.
+ * Handles version prefixes (^, ~, >=, etc.) by coercing them to valid semver.
+ */
+function isVersionOutdated(current, latest) {
+    try {
+        // Remove version prefixes like ^, ~, >=, etc.
+        const cleanCurrent = semver.coerce(current)?.version || current;
+        const cleanLatest = semver.coerce(latest)?.version || latest;
+        return semver.gt(cleanLatest, cleanCurrent);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the optimized range version for a package
+ */
+function getOptimizedRangeVersion(packageName, currentRange, allVersions, latestVersion) {
+    try {
+        // Find the highest version that satisfies the current range
+        const satisfyingVersions = allVersions.filter((version) => {
+            try {
+                return semver.satisfies(version, currentRange);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (satisfyingVersions.length === 0) {
+            return latestVersion;
+        }
+        // Return the highest satisfying version
+        return satisfyingVersions.sort(semver.rcompare)[0];
+    }
+    catch {
+        return latestVersion;
+    }
+}
+/**
+ * Find the closest minor version (same major, higher minor) that satisfies the current range
+ * Falls back to patch updates if no minor updates are available
+ */
+function findClosestMinorVersion(installedVersion, allVersions) {
+    try {
+        const coercedInstalled = semver.coerce(installedVersion);
+        if (!coercedInstalled) {
+            return null;
+        }
+        const installedMajor = semver.major(coercedInstalled);
+        const installedMinor = semver.minor(coercedInstalled);
+        let bestMinorVersion = null;
+        let bestMinorValue = -1;
+        // Single pass to find best minor version in same major
+        for (const version of allVersions) {
+            try {
+                const major = semver.major(version);
+                const minor = semver.minor(version);
+                if (major === installedMajor && minor > installedMinor && minor > bestMinorValue) {
+                    bestMinorValue = minor;
+                    bestMinorVersion = version;
+                }
+            }
+            catch {
+                // Skip invalid versions
+            }
+        }
+        if (bestMinorVersion) {
+            return bestMinorVersion;
+        }
+        // Fallback: find highest patch that satisfies current range
+        let bestVersion = null;
+        for (const version of allVersions) {
+            try {
+                if (semver.satisfies(version, installedVersion) && semver.gt(version, coercedInstalled)) {
+                    if (!bestVersion || semver.gt(version, bestVersion)) {
+                        bestVersion = version;
+                    }
+                }
+            }
+            catch {
+                // Skip invalid versions
+            }
+        }
+        return bestVersion;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=version.js.map

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "inup",
+  "version": "1.4.0",
+  "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": {
+    "inup": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "prepare": "pnpm build",
+    "link": "pnpm build && pnpm link --global",
+    "version:patch": "pnpm version patch && git push && git push --tags",
+    "version:minor": "pnpm version minor && git push && git push --tags",
+    "version:major": "pnpm version major && git push && git push --tags",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts",
+    "demo:record": "bash docs/demo/record-demo.sh",
+    "demo:setup": "cd docs/demo-project && pnpm install"
+  },
+  "author": "Donfear",
+  "keywords": [
+    "npm",
+    "yarn",
+    "pnpm",
+    "bun",
+    "upgrade",
+    "interactive",
+    "cli",
+    "package-manager",
+    "dependency-management",
+    "yarn-upgrade-interactive",
+    "monorepo",
+    "workspace",
+    "batch-upgrade"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/donfear/inup#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/donfear/inup.git"
+  },
+  "bugs": {
+    "url": "https://github.com/donfear/inup/issues"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/keypress": "^2.0.30",
+    "@types/node": "^24.10.1",
+    "@types/semver": "^7.7.1",
+    "prettier": "^3.8.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "inquirer": "^13.2.1",
+    "keypress": "^0.2.1",
+    "nanospinner": "^1.2.2",
+    "semver": "^7.7.3",
+    "undici": "^7.19.1"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316"
+}