inup 1.4.12 → 1.5.1

package/dist/ui/utils/terminal-input.js

@@ -0,0 +1,125 @@
+"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.TerminalInput = void 0;
+const readline = __importStar(require("node:readline"));
+const ESCAPE_CODE_TIMEOUT_MS = 25;
+exports.TerminalInput = {
+    startKeypressSession(onKeypress) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            escapeCodeTimeout: ESCAPE_CODE_TIMEOUT_MS,
+            terminal: true,
+        });
+        readline.emitKeypressEvents(process.stdin, rl);
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.on('keypress', onKeypress);
+        return {
+            close: () => {
+                process.stdin.off('keypress', onKeypress);
+                rl.close();
+                if (process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.pause();
+            },
+        };
+    },
+    promptForConfirmation(prompt, defaultValue = true) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true,
+            });
+            const finish = (value) => {
+                rl.close();
+                resolve(value);
+            };
+            rl.question(prompt, (answer) => {
+                const normalizedAnswer = answer.trim().toLowerCase();
+                if (normalizedAnswer === '') {
+                    finish(defaultValue);
+                    return;
+                }
+                finish(normalizedAnswer === 'y' || normalizedAnswer === 'yes');
+            });
+            rl.on('SIGINT', () => finish(false));
+        });
+    },
+    promptForImmediateConfirmation(prompt, defaultValue = true) {
+        return new Promise((resolve) => {
+            process.stdout.write(prompt);
+            let cleanup = () => { };
+            const finish = (value) => {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(value);
+            };
+            try {
+                const session = exports.TerminalInput.startKeypressSession((str, key) => {
+                    const normalized = str.trim().toLowerCase();
+                    if (key.name === 'return' || key.name === 'enter') {
+                        finish(defaultValue);
+                        return;
+                    }
+                    if (normalized === 'y') {
+                        finish(true);
+                        return;
+                    }
+                    if (normalized === 'n') {
+                        finish(false);
+                        return;
+                    }
+                    if (key.ctrl && key.name === 'c') {
+                        finish(false);
+                    }
+                });
+                cleanup = () => {
+                    session.close();
+                };
+            }
+            catch {
+                exports.TerminalInput.promptForConfirmation(prompt, defaultValue)
+                    .then(resolve)
+                    .catch(() => resolve(false));
+            }
+        });
+    },
+};
+//# sourceMappingURL=terminal-input.js.map

package/dist/ui/utils/text.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.getVisualLength = getVisualLength;
+exports.truncatePlainText = truncatePlainText;
+exports.wrapPlainText = wrapPlainText;
+const version_1 = require("./version");
+function stripAnsi(text) {
+    return version_1.VersionUtils.stripAnsi(text);
+}
+function getVisualLength(text) {
+    const cleaned = stripAnsi(text);
+    const SegmenterCtor = Intl.Segmenter;
+    let length = 0;
+    const segments = SegmenterCtor
+        ? SegmenterCtor.prototype.segment.call(new SegmenterCtor(undefined, { granularity: 'grapheme' }), cleaned)
+        : cleaned;
+    for (const item of segments) {
+        const segment = typeof item === 'string' ? item : item.segment;
+        if (/\p{Extended_Pictographic}/u.test(segment) || segment.includes('\uFE0F')) {
+            length += 2;
+        }
+        else {
+            for (const char of segment) {
+                const codePoint = char.codePointAt(0) ?? 0;
+                if ((codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+                    (codePoint >= 0x0300 && codePoint <= 0x036f)) {
+                    continue;
+                }
+                length += 1;
+            }
+        }
+    }
+    return length;
+}
+function truncatePlainText(text, maxWidth) {
+    if (maxWidth <= 0) {
+        return '';
+    }
+    if (getVisualLength(text) <= maxWidth) {
+        return text;
+    }
+    if (maxWidth <= 3) {
+        return '.'.repeat(maxWidth);
+    }
+    return text.substring(0, maxWidth - 3) + '...';
+}
+function wrapPlainText(text, maxWidth) {
+    if (!text) {
+        return [];
+    }
+    if (maxWidth <= 0 || getVisualLength(text) <= maxWidth) {
+        return [text];
+    }
+    const lines = [];
+    let current = '';
+    const words = text.split(' ');
+    for (const word of words) {
+        const candidate = (current + ' ' + word).trim();
+        if (getVisualLength(candidate) > maxWidth) {
+            if (current) {
+                lines.push(current);
+            }
+            current = word;
+        }
+        else {
+            current = current ? `${current} ${word}` : word;
+        }
+    }
+    if (current) {
+        lines.push(current);
+    }
+    return lines;
+}
+//# sourceMappingURL=text.js.map

package/dist/ui/utils/version.js

@@ -8,7 +8,8 @@ const chalk_1 = __importDefault(require("chalk"));
 /**
  * ANSI escape code pattern for stripping terminal colors
  */
-const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+const ANSI_PATTERN = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+const OSC8_PATTERN = /\u001b]8;;.*?(?:\u0007|\u001b\\)|\u001b]8;;(?:\u0007|\u001b\\)/g;
 class VersionUtils {
     static applyVersionPrefix(originalSpecifier, targetVersion) {
         // Extract prefix from original specifier (^ or ~)
@@ -21,7 +22,7 @@ class VersionUtils {
      * Strip ANSI escape codes from a string
      */
     static stripAnsi(str) {
-        return str.replace(ANSI_PATTERN, '');
+        return str.replace(OSC8_PATTERN, '').replace(ANSI_PATTERN, '');
     }
     /**
      * Get the visual length of a string (excluding ANSI codes)

package/dist/utils/git.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitWorkingTreeState = getGitWorkingTreeState;
+const child_process_1 = require("child_process");
+/**
+ * Detect whether cwd is a git work tree and whether it has local changes.
+ * Fail soft if git is unavailable or cwd is not a repository.
+ */
+function getGitWorkingTreeState(cwd) {
+    try {
+        const isInsideWorkTree = (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (isInsideWorkTree !== 'true') {
+            return { isRepo: false, isDirty: false };
+        }
+        const status = (0, child_process_1.execSync)('git status --porcelain', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return {
+            isRepo: true,
+            isDirty: status.trim().length > 0,
+        };
+    }
+    catch {
+        return { isRepo: false, isDirty: false };
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/utils/index.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectAllDependenciesAsync = exports.readPackageJsonAsync = void 0;
 __exportStar(require("./filesystem"), exports);
 __exportStar(require("./exec"), exports);
+__exportStar(require("./git"), exports);
 __exportStar(require("./version"), exports);
 __exportStar(require("./debug-logger"), exports);
 // Re-export async functions for convenience

package/package.json

@@ -1,26 +1,33 @@
 {
   "name": "inup",
-  "version": "1.4.12",
-  "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.",
+  "version": "1.5.1",
+  "description": "Interactive dependency upgrader for npm, yarn, pnpm & bun. Zero-config, monorepo-ready. Upgrade-interactive for every package manager.",
   "main": "dist/index.js",
   "bin": {
     "inup": "./dist/cli.js"
   },
   "author": "Donfear",
   "keywords": [
+    "upgrade-interactive",
+    "interactive",
+    "dependency-management",
+    "outdated",
+    "upgrade",
+    "update",
     "npm",
     "yarn",
     "pnpm",
     "bun",
-    "upgrade",
-    "interactive",
-    "cli",
-    "package-manager",
-    "dependency-management",
-    "yarn-upgrade-interactive",
     "monorepo",
     "workspace",
-    "batch-upgrade"
+    "cli",
+    "vulnerability",
+    "audit",
+    "changelog",
+    "package-manager",
+    "dependencies",
+    "semver",
+    "ncu"
   ],
   "license": "MIT",
   "homepage": "https://github.com/donfear/inup#readme",
@@ -36,24 +43,20 @@
     "README.md"
   ],
   "devDependencies": {
-    "@types/inquirer": "^9.0.9",
-    "@types/keypress.js": "^2.1.3",
-    "@types/node": "^24.12.0",
+    "@types/node": "^24.12.2",
     "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^4.1.0",
-    "prettier": "^3.8.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.0"
+    "@vitest/coverage-v8": "^4.1.4",
+    "prettier": "^3.8.2",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
   },
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "env-paths": "^4.0.0",
-    "inquirer": "^13.3.2",
-    "keypress": "^0.2.1",
     "nanospinner": "^1.2.2",
     "semver": "^7.7.4",
-    "undici": "^7.24.4"
+    "undici": "^8.1.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/dist/services/changelog-fetcher.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.changelogFetcher = exports.ChangelogFetcher = void 0;
-const constants_1 = require("../config/constants");
-const jsdelivr_registry_1 = require("./jsdelivr-registry");
-/**
- * Fetches package metadata from npm registry
- * Includes description, repository info, and basic metadata
- */
-class ChangelogFetcher {
-    constructor() {
-        this.cache = new Map();
-        this.failureCache = new Set(); // Track packages that failed to fetch
-        this.inFlight = new Map();
-    }
-    getCacheKey(packageName, version) {
-        return `${packageName}@${version?.trim() || 'latest'}`;
-    }
-    /**
-     * Fetch package metadata from npm registry
-     * Uses a cached approach to avoid repeated requests
-     */
-    async fetchPackageMetadata(packageName, version) {
-        const cacheKey = this.getCacheKey(packageName, version);
-        // Check if we already have this in cache
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey);
-        }
-        // Check if we already failed to fetch this
-        if (this.failureCache.has(cacheKey)) {
-            return null;
-        }
-        const inFlight = this.inFlight.get(cacheKey);
-        if (inFlight) {
-            return await inFlight;
-        }
-        const lookupPromise = this.fetchAndCachePackageMetadata(packageName, version).finally(() => {
-            this.inFlight.delete(cacheKey);
-        });
-        this.inFlight.set(cacheKey, lookupPromise);
-        return await lookupPromise;
-    }
-    async fetchAndCachePackageMetadata(packageName, version) {
-        const cacheKey = this.getCacheKey(packageName, version);
-        try {
-            const response = await this.fetchPackageManifest(packageName, version);
-            if (!response) {
-                this.failureCache.add(cacheKey);
-                return null;
-            }
-            const repository = response.repository;
-            const bugs = response.bugs;
-            const keywords = Array.isArray(response.keywords) ? response.keywords : [];
-            const author = typeof response.author === 'object' && response.author !== null
-                ? (response.author.name ?? response.author)
-                : response.author;
-            const repositoryUrl = this.extractRepositoryUrl(repository?.url || '');
-            const npmUrl = `https://www.npmjs.com/package/${encodeURIComponent(packageName)}`;
-            const issuesUrl = repositoryUrl ? `${repositoryUrl}/issues` : undefined;
-            const metadata = {
-                description: typeof response.description === 'string' && response.description
-                    ? response.description
-                    : 'No description available',
-                homepage: typeof response.homepage === 'string' ? response.homepage : undefined,
-                repository,
-                bugs,
-                keywords,
-                author: typeof author === 'string' ? author : undefined,
-                license: typeof response.license === 'string' ? response.license : undefined,
-                repositoryUrl,
-                npmUrl,
-                issuesUrl,
-            };
-            // Try to extract release notes/changelog info
-            if (repositoryUrl) {
-                metadata.releaseNotes = `${repositoryUrl}/releases`;
-            }
-            // Try to get weekly download count
-            try {
-                const downloadsData = await this.fetchDownloadStats(packageName);
-                if (downloadsData) {
-                    metadata.weeklyDownloads = downloadsData.downloads;
-                }
-            }
-            catch {
-                // Ignore download stats errors - optional data
-            }
-            this.cache.set(cacheKey, metadata);
-            return metadata;
-        }
-        catch {
-            // Cache the failure to avoid retrying
-            this.failureCache.add(cacheKey);
-            return null;
-        }
-    }
-    /**
-     * Fetch metadata from a lightweight manifest endpoint.
-     */
-    async fetchPackageManifest(packageName, version) {
-        try {
-            const normalizedVersion = version?.trim();
-            if (normalizedVersion) {
-                const jsdelivrManifest = await (0, jsdelivr_registry_1.fetchExactPackageManifest)(packageName, normalizedVersion);
-                if (jsdelivrManifest) {
-                    return jsdelivrManifest;
-                }
-            }
-            const npmPath = normalizedVersion ? normalizedVersion : 'latest';
-            const response = await fetch(`${constants_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}/${encodeURIComponent(npmPath)}`, {
-                method: 'GET',
-                headers: {
-                    accept: 'application/json',
-                },
-            });
-            if (!response.ok) {
-                return null;
-            }
-            return (await response.json());
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Extract GitHub URL from repository URL for easier access to releases
-     */
-    extractRepositoryUrl(repoUrl) {
-        if (!repoUrl)
-            return '';
-        // Handle various repository URL formats
-        // git+https://github.com/user/repo.git -> https://github.com/user/repo/releases
-        // https://github.com/user/repo.git -> https://github.com/user/repo/releases
-        // github:user/repo -> https://github.com/user/repo/releases
-        let cleanUrl = repoUrl
-            .replace(/^git\+/, '') // Remove git+ prefix
-            .replace(/\.git$/, '') // Remove .git suffix
-            .replace(/^github:/, 'https://github.com/'); // Convert github: format
-        // Ensure it's a proper URL
-        if (!cleanUrl.startsWith('http')) {
-            cleanUrl = 'https://github.com/' + cleanUrl;
-        }
-        return cleanUrl;
-    }
-    /**
-     * Fetch weekly download statistics from npm
-     */
-    async fetchDownloadStats(packageName) {
-        try {
-            const response = await fetch(`https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`, {
-                method: 'GET',
-                headers: {
-                    accept: 'application/json',
-                },
-            });
-            if (!response.ok) {
-                return null;
-            }
-            const data = (await response.json());
-            return {
-                downloads: data.downloads || 0,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Get repository release URL for a package
-     */
-    getRepositoryReleaseUrl(packageName, version) {
-        const metadata = this.cache.get(this.getCacheKey(packageName, version)) ??
-            this.cache.get(this.getCacheKey(packageName)) ??
-            this.cache.get(packageName);
-        if (!metadata || !metadata.releaseNotes) {
-            return null;
-        }
-        return `${metadata.releaseNotes}/releases/tag/v${version}`;
-    }
-    /**
-     * Cache package metadata directly (used by utils to avoid duplicate fetches)
-     */
-    cacheMetadata(packageName, rawData) {
-        const repositoryUrl = this.extractRepositoryUrl(rawData.repository?.url || '');
-        const npmUrl = `https://www.npmjs.com/package/${encodeURIComponent(packageName)}`;
-        const issuesUrl = repositoryUrl ? `${repositoryUrl}/issues` : undefined;
-        const metadata = {
-            description: rawData.description || 'No description available',
-            homepage: rawData.homepage,
-            repository: rawData.repository,
-            bugs: rawData.bugs,
-            keywords: rawData.keywords || [],
-            author: rawData.author?.name || rawData.author,
-            license: rawData.license,
-            repositoryUrl,
-            npmUrl,
-            issuesUrl,
-        };
-        if (repositoryUrl) {
-            metadata.releaseNotes = `${repositoryUrl}/releases`;
-        }
-        this.cache.set(packageName, metadata);
-    }
-    /**
-     * Clear the cache (useful for testing)
-     */
-    clearCache() {
-        this.cache.clear();
-        this.failureCache.clear();
-        this.inFlight.clear();
-    }
-}
-exports.ChangelogFetcher = ChangelogFetcher;
-exports.changelogFetcher = new ChangelogFetcher();
-//# sourceMappingURL=changelog-fetcher.js.map