inup 1.5.6 → 1.6.2

package/dist/ui/session/selection-state-builder.js

@@ -85,6 +85,8 @@ function createSelectionStates(packages, getCachedSummary, previousSelections, i
             hasRangeUpdate: pkg.hasRangeUpdate,
             hasMajorUpdate: pkg.hasMajorUpdate,
             type: pkg.type,
+            deprecated: pkg.deprecated,
+            enginesNode: pkg.enginesNode,
             vulnerability: getCachedSummary(pkg.name, pkg.currentVersion, pkg.type),
             allVersions: pkg.allVersions,
         };
@@ -120,13 +122,16 @@ function createPendingSelectionStates(packages, getCachedSummary, previousSelect
         };
     });
 }
-function createUpgradeChoices(selectedStates) {
+function createUpgradeChoices(selectedStates, saveExact = false) {
     const choices = [];
     selectedStates
         .filter((state) => state.loadState === 'ready' && state.selectedOption !== 'none')
         .forEach((state) => {
         const targetVersion = state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion;
-        const targetVersionWithPrefix = (0, utils_1.applyVersionPrefix)(state.currentVersionSpecifier, targetVersion);
+        // Preserve the original range prefix (^/~) by default; --save-exact writes the bare version.
+        const targetVersionWithPrefix = saveExact
+            ? targetVersion
+            : (0, utils_1.applyVersionPrefix)(state.currentVersionSpecifier, targetVersion);
         const pathsToUpdate = state.packageJsonPaths || [state.packageJsonPath];
         pathsToUpdate.forEach((packageJsonPath) => {
             choices.push({

package/dist/ui/themes-colors.js

@@ -182,18 +182,27 @@ function hexToRgb(hex) {
         : { r: 0, g: 0, b: 0 };
 }
 /**
- * Get ANSI escape code to set terminal background color
+ * Get ANSI escape code to set terminal background color.
+ *
+ * Returns an empty string when color output is disabled (`--no-color`/`NO_COLOR`
+ * set `chalk.level` to 0), so the TUI inherits the user's own terminal
+ * background instead of painting over it. This escape is raw (not produced by
+ * chalk), so it must be gated explicitly.
  */
 function getTerminalBgColorCode() {
+    if (chalk_1.default.level === 0) {
+        return '';
+    }
     const hex = getThemeBgColor();
     const rgb = hexToRgb(hex);
     return `\x1b[48;2;${rgb.r};${rgb.g};${rgb.b}m`;
 }
 /**
- * Get ANSI escape code to reset terminal colors
+ * Get ANSI escape code to reset terminal colors. Empty when color is disabled,
+ * so a `--no-color` run emits no escape sequences at all.
  */
 function getTerminalResetCode() {
-    return '\x1b[0m';
+    return chalk_1.default.level === 0 ? '' : '\x1b[0m';
 }
 const BRAND_COLORS = [chalk_1.default.red, chalk_1.default.yellow, chalk_1.default.blue, chalk_1.default.magenta];
 function coloredInupLogo() {

package/dist/ui/utils/cursor.js

@@ -67,16 +67,22 @@ exports.ConsoleUtils = {
      */
     LINE_WIDTH: 80,
     /**
-     * Show a progress message on the current line (overwrites previous content)
+     * Show a progress message on the current line (overwrites previous content).
+     * Written to stderr so stdout stays clean for --json / piped output, and only
+     * when stderr is a TTY — the \r animation is just noise in a redirected log.
      */
     showProgress(message) {
-        process.stdout.write(`\r${' '.repeat(exports.ConsoleUtils.LINE_WIDTH)}\r${message}`);
+        if (!process.stderr.isTTY)
+            return;
+        process.stderr.write(`\r${' '.repeat(exports.ConsoleUtils.LINE_WIDTH)}\r${message}`);
     },
     /**
      * Clear the current progress line
      */
     clearProgress() {
-        process.stdout.write('\r' + ' '.repeat(exports.ConsoleUtils.LINE_WIDTH) + '\r');
+        if (!process.stderr.isTTY)
+            return;
+        process.stderr.write('\r' + ' '.repeat(exports.ConsoleUtils.LINE_WIDTH) + '\r');
     },
 };
 //# sourceMappingURL=cursor.js.map

package/dist/utils/color.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldDisableColor = shouldDisableColor;
+exports.applyColorSetting = applyColorSetting;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Decide whether colored output should be disabled.
+ *
+ * Precedence (highest first):
+ *   1. An explicit `--no-color` flag (`colorFlag === false`) always wins.
+ *   2. `FORCE_COLOR` keeps colors on.
+ *   3. `NO_COLOR` (any non-empty value) disables them — the de-facto standard.
+ *
+ * chalk v5 already honors the env vars on its own, but the explicit flag does
+ * not flow through automatically, so we resolve the final intent here.
+ */
+function shouldDisableColor(colorFlag, env = process.env) {
+    if (colorFlag === false) {
+        return true;
+    }
+    if (env.FORCE_COLOR) {
+        return false;
+    }
+    return Boolean(env.NO_COLOR);
+}
+/**
+ * Apply the resolved color intent to chalk's global level. Call once at startup
+ * before anything renders.
+ */
+function applyColorSetting(colorFlag, env = process.env) {
+    if (shouldDisableColor(colorFlag, env)) {
+        chalk_1.default.level = 0;
+    }
+}
+//# sourceMappingURL=color.js.map

package/dist/utils/debug-logger.js

@@ -5,6 +5,7 @@ exports.enableDebugLogging = enableDebugLogging;
 exports.isDebugEnabled = isDebugEnabled;
 exports.getDebugLogPath = getDebugLogPath;
 const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
 let _enabled = false;
 let _logFile = null;
@@ -18,7 +19,13 @@ function getLogFile() {
     if (!_logFile) {
         const d = new Date();
         const dateStr = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-        _logFile = (0, path_1.join)(`inup-debug-${dateStr}.log`);
+        // Write to the OS temp dir (matches the path advertised in --help), not the
+        // current working directory — a debug log must never litter the user's repo.
+        const dir = (0, path_1.join)((0, os_1.tmpdir)(), 'inup');
+        if (!(0, fs_1.existsSync)(dir)) {
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        }
+        _logFile = (0, path_1.join)(dir, `inup-debug-${dateStr}.log`);
         // Write a header so the file is easy to identify
         (0, fs_1.writeFileSync)(_logFile, `=== inup debug log started at ${timestamp()} ===\n`, { flag: 'a' });
     }

package/dist/utils/engines.js

@@ -0,0 +1,63 @@
+"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.checkNodeEngineCompatibility = checkNodeEngineCompatibility;
+const semver = __importStar(require("semver"));
+/**
+ * Check whether the running Node version satisfies a package's declared
+ * `engines.node` range. Returns a short human-readable warning when it does
+ * not, or `null` when compatible (or when the inputs are unusable).
+ *
+ * Best-effort: an unparseable range is treated as "no opinion" (null) rather
+ * than a false warning.
+ */
+function checkNodeEngineCompatibility(requiredRange, currentNodeVersion = process.versions.node) {
+    if (!requiredRange) {
+        return null;
+    }
+    const range = semver.validRange(requiredRange, { loose: true });
+    if (!range) {
+        return null;
+    }
+    const current = semver.coerce(currentNodeVersion);
+    if (!current) {
+        return null;
+    }
+    if (semver.satisfies(current, range, { includePrerelease: true })) {
+        return null;
+    }
+    return `requires Node ${requiredRange}, you're on ${current.version}`;
+}
+//# sourceMappingURL=engines.js.map

package/dist/utils/filesystem/io.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readPackageJson = readPackageJson;
+exports.detectJsonFormat = detectJsonFormat;
 exports.readPackageJsonAsync = readPackageJsonAsync;
 exports.collectAllDependencies = collectAllDependencies;
 exports.collectAllDependenciesAsync = collectAllDependenciesAsync;
@@ -15,6 +16,21 @@ function readPackageJson(path) {
         throw new Error(`Failed to read package.json: ${error}`);
     }
 }
+/**
+ * Detect the indentation and trailing-newline style of a raw JSON document so a
+ * re-serialized version can preserve the original formatting instead of normalizing it.
+ *
+ * The first indented line's leading whitespace is exactly one indent unit; using it verbatim
+ * as the JSON.stringify indent round-trips tabs, 2-space, and 4-space without branching on type.
+ * Minified/single-line files (no indented line) fall back to 2 spaces, matching prior behavior.
+ */
+function detectJsonFormat(raw) {
+    const match = raw.match(/\n([ \t]+)\S/);
+    return {
+        indent: match ? match[1] : 2,
+        trailingNewline: raw.endsWith('\n'),
+    };
+}
 async function readPackageJsonAsync(path) {
     try {
         const content = await fs_2.promises.readFile(path, 'utf-8');

package/dist/utils/filesystem/scan.js

@@ -16,15 +16,85 @@ const SKIP_DIRS = new Set([
     'esm',
     'cjs',
 ]);
-function shouldSkipDirectory(name) {
-    return name.startsWith('.') || SKIP_DIRS.has(name);
+/**
+ * Skip dirs that are ambiguous source-vs-build directories where a real package may legitimately
+ * live. Only these trigger the "silently skipped a package" warning — node_modules and build-output
+ * dirs (dist/build/coverage/out) routinely contain package.json files and would be pure noise.
+ */
+const WARN_SKIP_DIRS = new Set(['lib', 'es', 'esm', 'cjs']);
+/** Effective skip set: the defaults minus any directory the caller opted back into via `scanDirs`. */
+function buildSkipSet(scanDirs) {
+    if (!scanDirs || scanDirs.length === 0) {
+        return SKIP_DIRS;
+    }
+    const skip = new Set(SKIP_DIRS);
+    for (const dir of scanDirs) {
+        skip.delete(dir);
+    }
+    return skip;
+}
+function classifyDirectory(name, skipSet) {
+    if (name.startsWith('.'))
+        return 'hidden';
+    if (skipSet.has(name))
+        return 'skip-dir';
+    return null;
 }
-function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress) {
+/**
+ * Cheaply decide whether a pruned directory looks like it holds a real package — a package.json
+ * directly inside it, or inside any immediate child (the common `lib/<pkg>/package.json` monorepo
+ * layout). Stays shallow (depth 1) so detecting a skip doesn't re-walk the subtree we just pruned.
+ */
+function prunedDirHoldsPackage(dir) {
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'package.json'))) {
+        return true;
+    }
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir);
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith('.'))
+            continue;
+        const child = (0, path_1.join)(dir, entry);
+        try {
+            if ((0, fs_1.statSync)(child).isDirectory() && (0, fs_1.existsSync)((0, path_1.join)(child, 'package.json'))) {
+                return true;
+            }
+        }
+        catch {
+            // Skip children we can't stat
+        }
+    }
+    return false;
+}
+/**
+ * Decide whether to descend into a directory, and notify when one is pruned by the default skip
+ * list despite containing a package.json (so the caller can surface a "silently skipped" warning).
+ */
+function shouldTraverse(name, fullPath, relativePath, skipSet, onSkippedPackageDir) {
+    const reason = classifyDirectory(name, skipSet);
+    if (reason === null) {
+        return true;
+    }
+    if (reason === 'skip-dir' &&
+        WARN_SKIP_DIRS.has(name) &&
+        onSkippedPackageDir &&
+        prunedDirHoldsPackage(fullPath)) {
+        onSkippedPackageDir(relativePath);
+    }
+    return false;
+}
+function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress, options = {}) {
     const packageJsonFiles = [];
     const visitedPaths = new Set();
     let directoriesScanned = 0;
     let lastProgressAt = 0;
     const progressIntervalMs = 250;
+    const skipSet = buildSkipSet(options.scanDirs);
     const excludeRegexes = excludePatterns.map((pattern) => new RegExp(pattern, 'i'));
     function shouldExcludePath(relativePath) {
         return excludeRegexes.some((regex) => regex.test(relativePath));
@@ -72,8 +142,10 @@ function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [],
                     // Skip files/dirs we can't stat (broken symlinks, permission issues)
                     continue;
                 }
-                if (stat.isDirectory() && !shouldSkipDirectory(file)) {
-                    traverseDirectory(fullPath, depth + 1);
+                if (stat.isDirectory()) {
+                    if (shouldTraverse(file, fullPath, relativePath, skipSet, options.onSkippedPackageDir)) {
+                        traverseDirectory(fullPath, depth + 1);
+                    }
                 }
                 else if (file === 'package.json' && stat.isFile()) {
                     packageJsonFiles.push(fullPath);
@@ -94,6 +166,7 @@ async function findAllPackageJsonFilesAsync(rootDir = process.cwd(), excludePatt
     let lastProgressAt = 0;
     const progressIntervalMs = 250;
     const concurrency = Math.max(1, Math.min(options.concurrency ?? 16, 64));
+    const skipSet = buildSkipSet(options.scanDirs);
     const excludeRegexes = excludePatterns.map((pattern) => new RegExp(pattern, 'i'));
     function shouldExcludePath(relativePath) {
         return excludeRegexes.some((regex) => regex.test(relativePath));
@@ -167,8 +240,10 @@ async function findAllPackageJsonFilesAsync(rootDir = process.cwd(), excludePatt
             catch {
                 continue;
             }
-            if (stat.isDirectory() && !shouldSkipDirectory(file)) {
-                schedule(fullPath, depth + 1);
+            if (stat.isDirectory()) {
+                if (shouldTraverse(file, fullPath, relativePath, skipSet, options.onSkippedPackageDir)) {
+                    schedule(fullPath, depth + 1);
+                }
             }
             else if (file === 'package.json' && stat.isFile()) {
                 packageJsonFiles.push(fullPath);

package/dist/utils/index.js

@@ -23,6 +23,10 @@ __exportStar(require("./exec"), exports);
 __exportStar(require("./git"), exports);
 __exportStar(require("./version"), exports);
 __exportStar(require("./debug-logger"), exports);
+__exportStar(require("./local-env"), exports);
+__exportStar(require("./color"), exports);
+__exportStar(require("./engines"), exports);
+__exportStar(require("./manifest"), exports);
 // Re-export async functions for convenience
 var filesystem_1 = require("./filesystem");
 Object.defineProperty(exports, "readPackageJsonAsync", { enumerable: true, get: function () { return filesystem_1.readPackageJsonAsync; } });

package/dist/utils/local-env.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInupLocalEnv = loadInupLocalEnv;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Loads a gitignored `.env.local` from the inup repo itself (NOT the cwd), so
+ * developer-only toggles can be "set once" and apply to every `inup` run in any
+ * project — without committing anything or touching the shell profile.
+ *
+ * The repo is located by walking UP from this file's own directory until a
+ * `.env.local` is found, so it works regardless of nesting depth (src/utils when
+ * type-stripped, dist/utils when compiled) and resolves the inup repo even when
+ * the binary is linked and invoked from a different project directory.
+ *
+ * Fully optional and best-effort: if the file is absent or unreadable, nothing
+ * happens and the run proceeds exactly as before. Existing process env always
+ * wins, so a one-off `INUP_PERF=0 inup` still overrides the file.
+ */
+const ENV_FILE_NAME = '.env.local';
+/** Walk upward from this file's dir to find the .env.local; null if none. */
+function findEnvFile() {
+    let dir = __dirname;
+    const root = (0, path_1.parse)(dir).root;
+    // Cap the walk so a missing file can never loop unbounded.
+    for (let i = 0; i < 12; i++) {
+        const candidate = (0, path_1.join)(dir, ENV_FILE_NAME);
+        if ((0, fs_1.existsSync)(candidate))
+            return candidate;
+        if (dir === root)
+            break;
+        dir = (0, path_1.dirname)(dir);
+    }
+    return null;
+}
+/** Parse a minimal KEY=VALUE env file. Ignores blanks and `#` comments. */
+function parseEnv(contents) {
+    const out = {};
+    for (const rawLine of contents.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const eq = line.indexOf('=');
+        if (eq === -1)
+            continue;
+        const key = line.slice(0, eq).trim();
+        if (!key)
+            continue;
+        let value = line.slice(eq + 1).trim();
+        // Strip a single layer of matching quotes.
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * Apply `<inup-repo>/.env.local` into process.env. Existing values are never
+ * overwritten (real env / one-off overrides win). Returns the path if loaded.
+ */
+function loadInupLocalEnv() {
+    try {
+        const file = findEnvFile();
+        if (!file)
+            return null;
+        const parsed = parseEnv((0, fs_1.readFileSync)(file, 'utf8'));
+        for (const [key, value] of Object.entries(parsed)) {
+            if (process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+        return file;
+    }
+    catch {
+        // Best-effort: never let a dev convenience break a real run.
+        return null;
+    }
+}
+//# sourceMappingURL=local-env.js.map

package/dist/utils/manifest.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Helpers for reading optional health signals out of an npm version manifest
+ * (the per-version object inside an abbreviated packument, or a full version
+ * document). Both fields are advisory and frequently absent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDeprecatedMessage = normalizeDeprecatedMessage;
+exports.extractEnginesNode = extractEnginesNode;
+/**
+ * npm represents deprecation as either a string message or the boolean `true`.
+ * Normalize both into a displayable message, or `undefined` when not deprecated.
+ */
+function normalizeDeprecatedMessage(value) {
+    if (typeof value === 'string' && value.trim()) {
+        return value;
+    }
+    if (value === true) {
+        return 'This version is deprecated.';
+    }
+    return undefined;
+}
+/**
+ * Extract the `engines.node` range from a manifest's `engines` object, if any.
+ */
+function extractEnginesNode(engines) {
+    if (typeof engines === 'object' && engines !== null) {
+        const node = engines.node;
+        if (typeof node === 'string' && node.trim()) {
+            return node;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=manifest.js.map

package/dist/utils/version.js

@@ -41,6 +41,7 @@ exports.isVersionOutdated = isVersionOutdated;
 exports.getOptimizedRangeVersion = getOptimizedRangeVersion;
 exports.findClosestMinorVersion = findClosestMinorVersion;
 const semver = __importStar(require("semver"));
+const manifest_1 = require("./manifest");
 function extractMajorVersion(version) {
     if (!version)
         return null;
@@ -62,10 +63,16 @@ function versionIdentity(version) {
 }
 function parseVersions(raw) {
     const data = JSON.parse(raw);
-    const allVersions = Object.keys(data.versions || {}).filter((v) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(v));
+    const versions = data.versions || {};
+    const allVersions = Object.keys(versions).filter((v) => /^[0-9]+\.[0-9]+\.[0-9]+$/.test(v));
     const sortedVersions = allVersions.sort(semver.rcompare);
     const latestVersion = sortedVersions.length > 0 ? sortedVersions[0] : 'unknown';
-    return { latestVersion, allVersions };
+    // Surface health signals for the latest version straight from the abbreviated
+    // packument we already fetched — no extra request. Both fields are optional.
+    const latestManifest = versions[latestVersion];
+    const deprecated = (0, manifest_1.normalizeDeprecatedMessage)(latestManifest?.deprecated);
+    const enginesNode = (0, manifest_1.extractEnginesNode)(latestManifest?.engines);
+    return { latestVersion, allVersions, deprecated, enginesNode };
 }
 /**
  * Checks if a version is outdated compared to the latest version.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inup",
-  "version": "1.5.6",
+  "version": "1.6.2",
   "description": "Interactive dependency upgrader for npm, yarn, pnpm & bun. Zero-config, monorepo-ready. Upgrade-interactive for every package manager.",
   "main": "dist/index.js",
   "bin": {
@@ -43,20 +43,20 @@
     "README.md"
   ],
   "devDependencies": {
-    "@types/node": "^24.12.4",
+    "@types/node": "^25.9.4",
     "@types/semver": "^7.7.1",
-    "@vitest/coverage-v8": "^4.1.7",
-    "prettier": "^3.8.3",
+    "@vitest/coverage-v8": "^4.1.9",
+    "prettier": "^3.9.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.9"
   },
   "dependencies": {
     "chalk": "^5.6.2",
-    "commander": "^14.0.3",
+    "commander": "^15.0.0",
     "env-paths": "^4.0.0",
     "nanospinner": "^1.2.2",
-    "semver": "^7.8.1",
-    "undici": "^8.3.0"
+    "semver": "^7.8.5",
+    "undici": "^8.5.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/dist/services/cache-manager.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageCache = exports.CacheManager = void 0;
-const config_1 = require("../config");
-const persistent_cache_1 = require("./persistent-cache");
-// Single TTL policy for both memory and disk.
-class CacheManager {
-    memoryCache = new Map();
-    ttl;
-    constructor(ttl = config_1.CACHE_TTL) {
-        this.ttl = ttl;
-    }
-    /**
-     * Get cached data for a key, checking memory first, then disk.
-     * Returns null if not found or expired.
-     */
-    get(key) {
-        // Check in-memory cache first (fastest)
-        const memoryCached = this.memoryCache.get(key);
-        if (memoryCached && Date.now() - memoryCached.timestamp < this.ttl) {
-            return memoryCached.data;
-        }
-        // Check persistent disk cache (survives restarts)
-        const diskCached = persistent_cache_1.persistentCache.get(key);
-        if (diskCached && Date.now() - diskCached.timestamp < this.ttl) {
-            // Populate in-memory cache for subsequent accesses
-            this.memoryCache.set(key, {
-                data: diskCached,
-                timestamp: diskCached.timestamp,
-            });
-            return diskCached;
-        }
-        return null;
-    }
-    /**
-     * Store data in both memory and disk cache.
-     */
-    set(key, data) {
-        // Cache in memory
-        this.memoryCache.set(key, {
-            data,
-            timestamp: Date.now(),
-        });
-        // Cache to disk for persistence
-        persistent_cache_1.persistentCache.set(key, data);
-    }
-    /**
-     * Get data from cache or fetch it using the provided fetcher function.
-     * This is the main entry point for cache-aside pattern.
-     */
-    async getOrFetch(key, fetcher) {
-        // Try cache first
-        const cached = this.get(key);
-        if (cached) {
-            return cached;
-        }
-        // Fetch fresh data
-        const data = await fetcher();
-        if (data) {
-            this.set(key, data);
-        }
-        return data;
-    }
-    /**
-     * Check if a key exists and is not expired in cache.
-     */
-    has(key) {
-        return this.get(key) !== null;
-    }
-    /**
-     * Clear in-memory cache (useful for testing).
-     */
-    clear() {
-        this.memoryCache.clear();
-    }
-    /**
-     * Flush pending disk cache writes.
-     */
-    flush() {
-        persistent_cache_1.persistentCache.flush();
-    }
-    /**
-     * Get cache statistics.
-     */
-    getStats() {
-        return {
-            memoryEntries: this.memoryCache.size,
-            diskStats: persistent_cache_1.persistentCache.getStats(),
-        };
-    }
-}
-exports.CacheManager = CacheManager;
-// Default package version cache instance
-exports.packageCache = new CacheManager();
-//# sourceMappingURL=cache-manager.js.map