inup 1.4.0 → 1.4.1

package/README.md

@@ -59,6 +59,15 @@ inup
 
 The tool will scan your entire workspace (including monorepos), find outdated packages, and let you choose which ones to upgrade interactively.
 
+### Interactive Features
+
+- **Search**: Press `/` to search for a specific package by name
+- **Navigate**: Use arrow keys to move between packages
+- **Select Version**: Use `Left` and `Right` arrow keys to cycle through available versions (default, minor, patch, major)
+- **Select All Minor**: Press `m` to select all minor updates
+- **Package Info**: Press `i` to view detailed information about the selected package
+- **Exit Search**: Press `Esc` to exit search mode
+
 ### Command line options
 
 - `-d, --dir <directory>`: Run in a specific directory (default: current directory)

package/dist/{constants.js → config/constants.js}

@@ -3,12 +3,17 @@
  * Constants for npm registry queries and configuration
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORKSPACE_FILES = exports.LOCK_FILES = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = void 0;
+exports.WORKSPACE_FILES = exports.LOCK_FILES = exports.DEFAULT_REGISTRY = exports.REQUEST_TIMEOUT = exports.CACHE_TTL = exports.MAX_CONCURRENT_REQUESTS = exports.JSDELIVR_CDN_URL = exports.NPM_REGISTRY_URL = void 0;
 exports.NPM_REGISTRY_URL = 'https://registry.npmjs.org';
 exports.JSDELIVR_CDN_URL = 'https://cdn.jsdelivr.net/npm';
-exports.MAX_CONCURRENT_REQUESTS = 80;
+exports.MAX_CONCURRENT_REQUESTS = 150;
 exports.CACHE_TTL = 5 * 60 * 1000; // 5 minutes in milliseconds
-exports.REQUEST_TIMEOUT = 30000; // 30 seconds in milliseconds
+exports.REQUEST_TIMEOUT = 60000; // 60 seconds in milliseconds
+/**
+ * Registry selection: 'jsdelivr' for fast CDN lookups, 'npm' for direct npm registry
+ * Set to 'npm' to use npm registry by default instead of jsdelivr
+ */
+exports.DEFAULT_REGISTRY = 'jsdelivr';
 /**
  * Package manager lock files
  */

package/dist/config/index.js

@@ -0,0 +1,18 @@
+"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 __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 });
+__exportStar(require("./constants"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/package-detector.js

@@ -37,6 +37,7 @@ exports.PackageDetector = void 0;
 const semver = __importStar(require("semver"));
 const utils_1 = require("../utils");
 const services_1 = require("../services");
+const config_1 = require("../config");
 class PackageDetector {
     constructor(options) {
         this.packageJsonPath = null;
@@ -80,7 +81,7 @@ class PackageDetector {
             }
         }
         const packageNames = Array.from(uniquePackageNames);
-        // Step 4: Fetch all package data in one call per package using jsdelivr CDN
+        // Step 4: Fetch all package data in one call per package
         // Create a map of package names to their current versions for major version optimization
         const currentVersions = new Map();
         for (const dep of allDeps) {
@@ -89,11 +90,21 @@ class PackageDetector {
                 currentVersions.set(dep.name, dep.version);
             }
         }
-        const allPackageData = 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})`);
-        });
+        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.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})`);
+            });
         try {
             for (const dep of allDeps) {
                 try {

package/dist/interactive-ui.js

@@ -80,15 +80,15 @@ class InteractiveUI {
             // Build label describing which types are shown
             const types = [];
             if (options.includePeerDeps)
-                types.push('Peer Dependencies');
+                types.push('Peer Deps');
             if (options.includeOptionalDeps)
-                types.push('Optional Dependencies');
+                types.push('Optional Deps');
             dependencyTypeLabel = types.join(' & ');
         }
         else {
             // Default: show only regular dependencies and devDependencies
             filteredPackages = outdatedPackages.filter((pkg) => pkg.type === 'dependencies' || pkg.type === 'devDependencies');
-            dependencyTypeLabel = 'Dependencies & Dev Dependencies';
+            dependencyTypeLabel = 'Deps & Dev Deps';
         }
         if (filteredPackages.length === 0) {
             return [];
@@ -186,47 +186,48 @@ class InteractiveUI {
             stateManager.setRenderableItems([]);
             const handleAction = (action) => {
                 const uiState = stateManager.getUIState();
+                const filteredStates = stateManager.getFilteredStates(states);
                 switch (action.type) {
                     case 'navigate_up':
                         if (!uiState.showInfoModal) {
-                            stateManager.navigateUp(states.length);
+                            stateManager.navigateUp(filteredStates.length);
                         }
                         break;
                     case 'navigate_down':
                         if (!uiState.showInfoModal) {
-                            stateManager.navigateDown(states.length);
+                            stateManager.navigateDown(filteredStates.length);
                         }
                         break;
                     case 'select_left':
                         if (!uiState.showInfoModal) {
-                            stateManager.updateSelection(states, 'left');
+                            stateManager.updateSelection(filteredStates, 'left');
                         }
                         break;
                     case 'select_right':
                         if (!uiState.showInfoModal) {
-                            stateManager.updateSelection(states, 'right');
+                            stateManager.updateSelection(filteredStates, 'right');
                         }
                         break;
                     case 'bulk_select_minor':
                         if (!uiState.showInfoModal) {
-                            stateManager.bulkSelectMinor(states);
+                            stateManager.bulkSelectMinor(filteredStates);
                         }
                         break;
                     case 'bulk_select_latest':
                         if (!uiState.showInfoModal) {
-                            stateManager.bulkSelectLatest(states);
+                            stateManager.bulkSelectLatest(filteredStates);
                         }
                         break;
                     case 'bulk_unselect_all':
                         if (!uiState.showInfoModal) {
-                            stateManager.bulkUnselectAll(states);
+                            stateManager.bulkUnselectAll(filteredStates);
                         }
                         break;
                     case 'toggle_info_modal':
                         if (!uiState.showInfoModal) {
                             // Opening modal - load package info asynchronously
                             stateManager.toggleInfoModal();
-                            const currentState = states[uiState.currentRow];
+                            const currentState = filteredStates[uiState.currentRow];
                             stateManager.setModalLoading(true);
                             renderInterface();
                             // Fetch metadata asynchronously
@@ -249,6 +250,20 @@ class InteractiveUI {
                             renderInterface();
                         }
                         break;
+                    case 'enter_filter_mode':
+                        stateManager.enterFilterMode();
+                        break;
+                    case 'exit_filter_mode':
+                        stateManager.exitFilterMode();
+                        break;
+                    case 'filter_input':
+                        stateManager.appendToFilterQuery(action.char);
+                        // Re-calculate filtered states after input
+                        break;
+                    case 'filter_backspace':
+                        stateManager.deleteFromFilterQuery();
+                        // Re-calculate filtered states after backspace
+                        break;
                     case 'resize':
                         const heightChanged = stateManager.updateTerminalHeight(action.height);
                         if (heightChanged) {
@@ -269,6 +284,7 @@ class InteractiveUI {
                 }
             };
             const handleConfirm = (selectedStates) => {
+                ui_1.CursorUtils.show();
                 // Clean up listeners
                 if (process.stdin.setRawMode) {
                     process.stdin.setRawMode(false);
@@ -279,6 +295,7 @@ class InteractiveUI {
                 resolve(selectedStates);
             };
             const handleCancel = () => {
+                ui_1.CursorUtils.show();
                 // Clean up listeners
                 if (process.stdin.setRawMode) {
                     process.stdin.setRawMode(false);
@@ -291,16 +308,17 @@ class InteractiveUI {
             const inputHandler = new ui_1.InputHandler(stateManager, handleAction, handleConfirm, handleCancel);
             const renderInterface = () => {
                 const uiState = stateManager.getUIState();
-                if (uiState.isInitialRender) {
+                const filteredStates = stateManager.getFilteredStates(states);
+                if (uiState.forceFullRender) {
                     console.clear();
+                    ui_1.CursorUtils.hide();
                 }
                 else {
-                    // Move cursor to top and rewrite everything to minimize flicker
-                    process.stdout.write('\x1b[H');
+                    ui_1.CursorUtils.moveToHome();
                 }
                 // If modal is open, render only the modal with header/footer
-                if (uiState.showInfoModal && uiState.infoModalRow >= 0 && uiState.infoModalRow < states.length) {
-                    const selectedState = states[uiState.infoModalRow];
+                if (uiState.showInfoModal && uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
+                    const selectedState = filteredStates[uiState.infoModalRow];
                     const terminalWidth = process.stdout.columns || 80;
                     const terminalHeight = this.getTerminalHeight();
                     // Render header
@@ -323,20 +341,20 @@ class InteractiveUI {
                         modalLines.forEach((line) => console.log(line));
                     }
                     // Clear any remaining lines from previous render
-                    process.stdout.write('\x1b[J');
+                    ui_1.CursorUtils.clearToEndOfScreen();
                     stateManager.markRendered([]);
                 }
                 else {
                     // Normal list view (flat rendering - no grouping)
-                    const lines = this.renderer.renderInterface(states, uiState.currentRow, uiState.scrollOffset, uiState.maxVisibleItems, uiState.isInitialRender, [], // No renderable items - use flat rendering
+                    const lines = this.renderer.renderInterface(filteredStates, uiState.currentRow, uiState.scrollOffset, uiState.maxVisibleItems, uiState.forceFullRender, [], // No renderable items - use flat rendering
                     dependencyTypeLabel, // Show which dependency type we're upgrading
-                    this.packageManager // Pass package manager info for header
-                    );
+                    this.packageManager, // Pass package manager info for header
+                    uiState.filterMode, uiState.filterQuery, states.length);
                     // Print all lines
                     lines.forEach((line) => console.log(line));
                     // Clear any remaining lines from previous render
-                    if (!uiState.isInitialRender) {
-                        process.stdout.write('\x1b[J');
+                    if (!uiState.forceFullRender) {
+                        ui_1.CursorUtils.clearToEndOfScreen();
                     }
                     stateManager.markRendered(lines);
                 }
@@ -387,6 +405,7 @@ class InteractiveUI {
                 if (process.stdin.setRawMode) {
                     process.stdin.setRawMode(true);
                 }
+                ui_1.CursorUtils.hide();
                 process.stdin.resume();
                 process.stdin.on('keypress', (str, key) => inputHandler.handleKeypress(str, key));
             }

package/dist/services/jsdelivr-registry.js

@@ -38,15 +38,16 @@ exports.clearJsdelivrPackageCache = clearJsdelivrPackageCache;
 exports.closeJsdelivrPool = closeJsdelivrPool;
 const undici_1 = require("undici");
 const semver = __importStar(require("semver"));
-const constants_1 = require("../constants");
+const config_1 = require("../config");
 const npm_registry_1 = require("./npm-registry");
 // 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', {
-    connections: constants_1.MAX_CONCURRENT_REQUESTS, // Maximum concurrent connections
+    connections: config_1.MAX_CONCURRENT_REQUESTS, // Maximum concurrent connections
     pipelining: 10, // Enable request pipelining for even better performance
-    keepAliveTimeout: 60000, // Keep connections alive for 60 seconds
-    keepAliveMaxTimeout: 600000, // Maximum keep-alive timeout
+    keepAliveTimeout: config_1.REQUEST_TIMEOUT, // Keep connections alive for 60 seconds
+    keepAliveMaxTimeout: config_1.REQUEST_TIMEOUT, // Maximum keep-alive timeout
+    connectTimeout: config_1.REQUEST_TIMEOUT, // 60 seconds connect timeout
 });
 const packageCache = new Map();
 /**
@@ -58,15 +59,15 @@ const packageCache = new Map();
  */
 async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
     try {
-        const url = `${constants_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
+        const url = `${config_1.JSDELIVR_CDN_URL}/${encodeURIComponent(packageName)}@${versionTag}/package.json`;
         const { statusCode, body } = await (0, undici_1.request)(url, {
             dispatcher: jsdelivrPool,
             method: 'GET',
             headers: {
                 accept: 'application/json',
             },
-            headersTimeout: constants_1.REQUEST_TIMEOUT,
-            bodyTimeout: constants_1.REQUEST_TIMEOUT,
+            headersTimeout: config_1.REQUEST_TIMEOUT,
+            bodyTimeout: config_1.REQUEST_TIMEOUT,
         });
         if (statusCode !== 200) {
             // Consume body to prevent memory leaks
@@ -84,7 +85,7 @@ async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
 }
 /**
  * Fetches package data from jsdelivr CDN with fallback to npm registry.
- * Makes simultaneous requests for @latest and @major version.
+ * Makes simultaneous requests for @latest, @major version, and current version.
  * @param packageName - The npm package name
  * @param currentVersion - The current version to extract major from (optional)
  * @returns Package data with latest version and all versions
@@ -92,26 +93,31 @@ async function fetchPackageJsonFromJsdelivr(packageName, versionTag) {
 async function fetchPackageFromJsdelivr(packageName, currentVersion) {
     // Check cache first
     const cached = packageCache.get(packageName);
-    if (cached && Date.now() - cached.timestamp < constants_1.CACHE_TTL) {
+    if (cached && Date.now() - cached.timestamp < config_1.CACHE_TTL) {
         return cached.data;
     }
     try {
+        // Coerce the current version in case it's a range like ^1.1.5
+        const coercedVersion = currentVersion ? semver.coerce(currentVersion)?.version : null;
         // Determine major version from current version if provided
-        // Need to coerce the version first in case it's a range like ^1.1.5
         const majorVersion = currentVersion
             ? semver.major(semver.coerce(currentVersion) || '0.0.0').toString()
             : null;
-        // Prepare requests: always fetch @latest, and @major if we have a current version
+        // Prepare requests: always fetch @latest, @major if we have a current version, and @currentVersion
         const requests = [
             fetchPackageJsonFromJsdelivr(packageName, 'latest'),
         ];
         if (majorVersion) {
             requests.push(fetchPackageJsonFromJsdelivr(packageName, majorVersion));
         }
+        if (coercedVersion) {
+            requests.push(fetchPackageJsonFromJsdelivr(packageName, coercedVersion));
+        }
         // Execute all requests simultaneously
         const results = await Promise.all(requests);
         const latestResult = results[0];
         const majorResult = results[1];
+        const currentResult = results[2];
         if (!latestResult) {
             // jsdelivr doesn't have this package, fallback to npm registry
             const npmData = await (0, npm_registry_1.getAllPackageData)([packageName]);
@@ -124,40 +130,14 @@ async function fetchPackageFromJsdelivr(packageName, currentVersion) {
             return data;
         }
         const latestVersion = latestResult.version;
-        // If we have a major version result, we can build a minimal version list
-        // This is much faster than fetching all versions from npm
-        if (majorResult) {
-            const allVersions = [latestVersion];
-            // Add the major version result if different from latest
-            if (majorResult.version !== latestVersion) {
-                allVersions.push(majorResult.version);
-            }
-            // Add the current version if it's valid and not already in the list
-            if (currentVersion && semver.valid(currentVersion)) {
-                const coerced = semver.coerce(currentVersion);
-                if (coerced && !allVersions.includes(coerced.version)) {
-                    allVersions.push(coerced.version);
-                }
-            }
-            const result = {
-                latestVersion,
-                allVersions: allVersions.sort(semver.rcompare),
-            };
-            // Cache the result
-            packageCache.set(packageName, {
-                data: result,
-                timestamp: Date.now(),
-            });
-            return result;
-        }
-        // No major version provided, just return latest with minimal version list
         const allVersions = [latestVersion];
-        // Add the current version if it's valid and not already in the list
-        if (currentVersion && semver.valid(currentVersion)) {
-            const coerced = semver.coerce(currentVersion);
-            if (coerced && !allVersions.includes(coerced.version)) {
-                allVersions.push(coerced.version);
-            }
+        // Add the major version result if different from latest
+        if (majorResult && majorResult.version !== latestVersion) {
+            allVersions.push(majorResult.version);
+        }
+        // Add the current version result if different from latest and major
+        if (currentResult && !allVersions.includes(currentResult.version)) {
+            allVersions.push(currentResult.version);
         }
         const result = {
             latestVersion,

package/dist/services/npm-registry.js

@@ -35,65 +35,59 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllPackageData = getAllPackageData;
 exports.clearPackageCache = clearPackageCache;
-exports.closeNpmPool = closeNpmPool;
-const undici_1 = require("undici");
 const semver = __importStar(require("semver"));
-const constants_1 = require("../constants");
-// Create a persistent connection pool for npm registry with optimal settings
-// This enables connection reuse and HTTP/1.1 keep-alive for blazing fast requests
-const npmPool = new undici_1.Pool('https://registry.npmjs.org', {
-    connections: constants_1.MAX_CONCURRENT_REQUESTS, // Maximum concurrent connections
-    pipelining: 10, // Enable request pipelining for even better performance
-    keepAliveTimeout: 60000, // Keep connections alive for 60 seconds
-    keepAliveMaxTimeout: 600000, // Maximum keep-alive timeout
-});
+const config_1 = require("../config");
 const packageCache = new Map();
 /**
- * Fetches package data from npm registry with caching using undici pool.
- * Uses connection pooling and keep-alive for maximum performance.
+ * 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 < constants_1.CACHE_TTL) {
+    if (cached && Date.now() - cached.timestamp < config_1.CACHE_TTL) {
         return cached.data;
     }
     try {
-        const url = `${constants_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
-        const { statusCode, body } = await (0, undici_1.request)(url, {
-            dispatcher: npmPool,
-            method: 'GET',
-            headers: {
-                accept: 'application/vnd.npm.install-v1+json',
-            },
-            headersTimeout: constants_1.REQUEST_TIMEOUT,
-            bodyTimeout: constants_1.REQUEST_TIMEOUT,
-        });
-        if (statusCode !== 200) {
-            // Consume body to prevent memory leaks
-            await body.text();
-            throw new Error(`HTTP ${statusCode}`);
+        const url = `${config_1.NPM_REGISTRY_URL}/${encodeURIComponent(packageName)}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), config_1.REQUEST_TIMEOUT);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/vnd.npm.install-v1+json',
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const text = await response.text();
+            const data = JSON.parse(text);
+            // Extract versions and filter to valid semver (X.Y.Z format, no pre-releases)
+            const allVersions = Object.keys(data.versions || {}).filter((version) => {
+                // Match only X.Y.Z format (no pre-release, no build metadata)
+                return /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version);
+            });
+            // Sort versions to find the latest
+            const sortedVersions = allVersions.sort(semver.rcompare);
+            const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
+            const result = {
+                latestVersion,
+                allVersions,
+            };
+            // Cache the result
+            packageCache.set(packageName, {
+                data: result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+        finally {
+            clearTimeout(timeoutId);
         }
-        const text = await body.text();
-        const data = JSON.parse(text);
-        // Extract versions and filter to valid semver (X.Y.Z format, no pre-releases)
-        const allVersions = Object.keys(data.versions || {}).filter((version) => {
-            // Match only X.Y.Z format (no pre-release, no build metadata)
-            return /^[0-9]+\.[0-9]+\.[0-9]+$/.test(version);
-        });
-        // Sort versions to find the latest
-        const sortedVersions = allVersions.sort(semver.rcompare);
-        const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
-        const result = {
-            latestVersion,
-            allVersions,
-        };
-        // Cache the result
-        packageCache.set(packageName, {
-            data: result,
-            timestamp: Date.now(),
-        });
-        return result;
     }
     catch (error) {
         // Return fallback data for failed packages
@@ -102,7 +96,7 @@ async function fetchPackageFromRegistry(packageName) {
 }
 /**
  * Fetches package version data from npm registry for multiple packages.
- * Uses undici connection pool for blazing fast performance with connection reuse.
+ * Uses native fetch with timeout support for reliable performance.
  * Only returns valid semantic versions (X.Y.Z format, excluding pre-releases).
  */
 async function getAllPackageData(packageNames, onProgress) {
@@ -112,8 +106,8 @@ async function getAllPackageData(packageNames, onProgress) {
     }
     const total = packageNames.length;
     let completedCount = 0;
-    // Fire all requests simultaneously - undici pool handles concurrency internally
-    // No need for p-limit - the pool's connection limit controls concurrency
+    // Fire all requests simultaneously
+    // Concurrency is handled naturally by the event loop with fetch
     const allPromises = packageNames.map(async (packageName) => {
         const data = await fetchPackageFromRegistry(packageName);
         packageData.set(packageName, data);
@@ -136,10 +130,4 @@ async function getAllPackageData(packageNames, onProgress) {
 function clearPackageCache() {
     packageCache.clear();
 }
-/**
- * Close the npm registry connection pool (useful for graceful shutdown)
- */
-async function closeNpmPool() {
-    await npmPool.close();
-}
 //# sourceMappingURL=npm-registry.js.map

package/dist/services/version-checker.js

@@ -37,7 +37,7 @@ exports.checkForUpdate = checkForUpdate;
 exports.checkForUpdateAsync = checkForUpdateAsync;
 const child_process_1 = require("child_process");
 const semver = __importStar(require("semver"));
-const constants_1 = require("../constants");
+const config_1 = require("../config");
 /**
  * Check if the current package version is outdated compared to npm registry
  */
@@ -46,7 +46,7 @@ async function checkForUpdate(packageName, currentVersion) {
         // Use npm view to get the latest version from registry
         const result = (0, child_process_1.execSync)(`npm view ${packageName} version`, {
             encoding: 'utf-8',
-            timeout: constants_1.REQUEST_TIMEOUT,
+            timeout: config_1.REQUEST_TIMEOUT,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         const latestVersion = result.trim();

package/dist/ui/index.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfirmationInputHandler = exports.InputHandler = exports.UIRenderer = exports.StateManager = exports.VersionUtils = void 0;
+exports.ConfirmationInputHandler = exports.InputHandler = exports.UIRenderer = exports.FilterManager = exports.ModalManager = exports.NavigationManager = exports.StateManager = exports.CursorUtils = exports.VersionUtils = void 0;
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "VersionUtils", { enumerable: true, get: function () { return utils_1.VersionUtils; } });
+Object.defineProperty(exports, "CursorUtils", { enumerable: true, get: function () { return utils_1.CursorUtils; } });
 var state_1 = require("./state");
 Object.defineProperty(exports, "StateManager", { enumerable: true, get: function () { return state_1.StateManager; } });
+Object.defineProperty(exports, "NavigationManager", { enumerable: true, get: function () { return state_1.NavigationManager; } });
+Object.defineProperty(exports, "ModalManager", { enumerable: true, get: function () { return state_1.ModalManager; } });
+Object.defineProperty(exports, "FilterManager", { enumerable: true, get: function () { return state_1.FilterManager; } });
 var index_1 = require("./renderer/index");
 Object.defineProperty(exports, "UIRenderer", { enumerable: true, get: function () { return index_1.UIRenderer; } });
 var input_handler_1 = require("./input-handler");