inup 1.6.6 → 1.6.7

package/dist/{core → features/upgrade}/package-detector.js

@@ -39,12 +39,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageDetector = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const semver = __importStar(require("semver"));
-const utils_1 = require("../utils");
-const services_1 = require("../services");
-const config_1 = require("../config");
-const utils_2 = require("../ui/utils");
-const utils_3 = require("../utils");
-const debug_1 = require("../features/debug");
+const fs_1 = require("../../shared/fs");
+const versions_1 = require("../../shared/versions");
+const pnpm_catalogs_1 = require("../../shared/pnpm-catalogs");
+const npm_registry_1 = require("../../shared/registry/npm-registry");
+const config_1 = require("../../shared/config");
+const terminal_1 = require("../../shared/terminal");
+const debug_logger_1 = require("../../shared/debug-logger");
+const debug_1 = require("../debug");
 class PackageDetector {
     packageJsonPath = null;
     packageJson = null;
@@ -63,9 +65,9 @@ class PackageDetector {
         this.ignorePackages = options?.ignorePackages || [];
         this.maxDepth = options?.maxDepth ?? 10;
         this.adaptive = options?.adaptive ?? true;
-        this.packageJsonPath = (0, utils_1.findPackageJson)(this.cwd);
+        this.packageJsonPath = (0, fs_1.findPackageJson)(this.cwd);
         if (this.packageJsonPath) {
-            this.packageJson = (0, utils_1.readPackageJson)(this.packageJsonPath);
+            this.packageJson = (0, fs_1.readPackageJson)(this.packageJsonPath);
         }
     }
     hasPackageJson() {
@@ -103,7 +105,7 @@ class PackageDetector {
             throw new Error('No package.json found in current directory');
         }
         const t0 = Date.now();
-        utils_3.debugLog.info('PackageDetector', `Starting scan in ${this.cwd}`);
+        debug_logger_1.debugLog.info('PackageDetector', `Starting scan in ${this.cwd}`);
         const prepared = await this.prepareDependencies();
         const initialPayload = {
             allDependencies: prepared.allDependencies,
@@ -119,8 +121,8 @@ class PackageDetector {
         let batchIndex = 0;
         let lastBatchEndAt = Date.now();
         const tFetch = Date.now();
-        utils_3.debugLog.info('PackageDetector', 'fetching version data via npm registry in batches');
-        await (0, services_1.fetchPackageVersions)(prepared.uniquePackages, {
+        debug_logger_1.debugLog.info('PackageDetector', 'fetching version data via npm registry in batches');
+        await (0, npm_registry_1.fetchPackageVersions)(prepared.uniquePackages, {
             currentVersions: prepared.currentVersions,
             batchSize: this.batchSize,
             maxConcurrency: this.maxConcurrency,
@@ -167,11 +169,11 @@ class PackageDetector {
                 });
             },
         });
-        utils_3.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
+        debug_logger_1.debugLog.perf('PackageDetector', `registry fetch (${resolved}/${prepared.uniquePackages.length} resolved)`, tFetch);
         performanceTracker.recordPhaseDuration('registryFetch', Date.now() - tFetch);
         const finalPackages = prepared.uniquePackages.flatMap((packageName) => packageLookup.get(packageName) ?? []);
         const progress = this.createProgressSnapshot(prepared.uniquePackages.length, resolved, failed, false);
-        utils_3.debugLog.perf('PackageDetector', `total scan complete (${finalPackages.filter((p) => p.isOutdated).length} outdated of ${finalPackages.length} deps)`, t0);
+        debug_logger_1.debugLog.perf('PackageDetector', `total scan complete (${finalPackages.filter((p) => p.isOutdated).length} outdated of ${finalPackages.length} deps)`, t0);
         onEvent({
             type: 'complete',
             payload: {
@@ -179,7 +181,7 @@ class PackageDetector {
                 progress,
             },
         });
-        utils_2.ConsoleUtils.clearProgress();
+        terminal_1.ConsoleUtils.clearProgress();
         return finalPackages;
     }
     async prepareDependencies() {
@@ -187,7 +189,7 @@ class PackageDetector {
         this.showProgress('🔍 Scanning repository for package.json files...');
         const tScan = Date.now();
         const allPackageJsonFiles = await this.findPackageJsonFilesWithTimeout(30000);
-        utils_3.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
+        debug_logger_1.debugLog.perf('PackageDetector', `file scan (${allPackageJsonFiles.length} files)`, tScan, {
             files: allPackageJsonFiles,
         });
         performanceTracker.recordPhaseDuration('discovery', Date.now() - tScan);
@@ -195,11 +197,11 @@ class PackageDetector {
         this.showProgress(`🔍 Found ${allPackageJsonFiles.length} package.json file${allPackageJsonFiles.length === 1 ? '' : 's'}`);
         this.showProgress('🔍 Reading dependencies from package.json files...');
         const tDeps = Date.now();
-        const allDepsRaw = await (0, utils_1.collectAllDependenciesAsync)(allPackageJsonFiles, {
+        const allDepsRaw = await (0, fs_1.collectAllDependenciesAsync)(allPackageJsonFiles, {
             includePeerDeps: true,
             includeOptionalDeps: true,
         });
-        utils_3.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
+        debug_logger_1.debugLog.perf('PackageDetector', `dependency collection (${allDepsRaw.length} raw deps)`, tDeps);
         performanceTracker.recordPhaseDuration('depCollection', Date.now() - tDeps);
         performanceTracker.recordCounts({ rawDependencies: allDepsRaw.length });
         this.showProgress('🔍 Identifying unique packages...');
@@ -209,12 +211,50 @@ class PackageDetector {
         let ignoredCount = 0;
         const seenWorkspaceRefs = new Set();
         const seenIgnored = new Set();
-        for (const dep of allDepsRaw) {
+        // pnpm catalogs: `"react": "catalog:"` gets its real range from
+        // pnpm-workspace.yaml. Each catalog entry becomes ONE upgradable dependency
+        // sourced from that file, no matter how many workspace packages reference it.
+        const catalogs = pnpm_catalogs_1.PnpmCatalogs.load(this.cwd);
+        const seenCatalogEntries = new Map();
+        for (const rawDep of allDepsRaw) {
+            let dep = {
+                name: rawDep.name,
+                version: rawDep.version,
+                type: rawDep.type,
+                packageJsonPath: rawDep.packageJsonPath,
+            };
+            if ((0, pnpm_catalogs_1.isCatalogReference)(rawDep.version)) {
+                const resolution = catalogs?.resolve(rawDep.name, rawDep.version) ?? null;
+                if (!resolution) {
+                    debug_logger_1.debugLog.warn('PackageDetector', `skipping unresolvable catalog ref: ${rawDep.name}@${rawDep.version}`);
+                    continue;
+                }
+                const catalogKey = `${resolution.catalog}:${rawDep.name}`;
+                const existing = seenCatalogEntries.get(catalogKey);
+                if (existing) {
+                    // Same catalog entry, another referencing package: remember who uses
+                    // it (for the info modal's Used-by tab) but keep the single entry.
+                    if (!existing.catalogReferencedBy.includes(rawDep.packageJsonPath)) {
+                        existing.catalogReferencedBy.push(rawDep.packageJsonPath);
+                    }
+                    continue;
+                }
+                dep = {
+                    name: rawDep.name,
+                    version: resolution.range,
+                    type: rawDep.type,
+                    packageJsonPath: catalogs.path,
+                    catalog: resolution.catalog,
+                    catalogEntries: catalogs.entriesOf(resolution.catalog),
+                    catalogReferencedBy: [rawDep.packageJsonPath],
+                };
+                seenCatalogEntries.set(catalogKey, dep);
+            }
             if (this.isWorkspaceReference(dep.version)) {
                 const key = `${dep.name}@${dep.version}`;
                 if (!seenWorkspaceRefs.has(key)) {
                     seenWorkspaceRefs.add(key);
-                    utils_3.debugLog.info('PackageDetector', `skipping workspace ref: ${key}`);
+                    debug_logger_1.debugLog.info('PackageDetector', `skipping workspace ref: ${key}`);
                 }
                 continue;
             }
@@ -222,16 +262,11 @@ class PackageDetector {
                 ignoredCount++;
                 if (!seenIgnored.has(dep.name)) {
                     seenIgnored.add(dep.name);
-                    utils_3.debugLog.info('PackageDetector', `ignoring package: ${dep.name}`);
+                    debug_logger_1.debugLog.info('PackageDetector', `ignoring package: ${dep.name}`);
                 }
                 continue;
             }
-            allDependencies.push({
-                name: dep.name,
-                version: dep.version,
-                type: dep.type,
-                packageJsonPath: dep.packageJsonPath,
-            });
+            allDependencies.push(dep);
             uniquePackageNames.add(dep.name);
         }
         if (ignoredCount > 0) {
@@ -246,7 +281,7 @@ class PackageDetector {
                 return 1;
             return a.localeCompare(b);
         });
-        utils_3.debugLog.info('PackageDetector', `${uniquePackages.length} unique packages to check, ${ignoredCount} ignored`);
+        debug_logger_1.debugLog.info('PackageDetector', `${uniquePackages.length} unique packages to check, ${ignoredCount} ignored`);
         performanceTracker.recordPhaseDuration('filter', Date.now() - tFilter);
         performanceTracker.recordCounts({
             uniquePackages: uniquePackages.length,
@@ -274,12 +309,12 @@ class PackageDetector {
                 if (!packageData || packageData.latestVersion === 'unknown') {
                     if (!loggedNoData.has(dep.name)) {
                         loggedNoData.add(dep.name);
-                        utils_3.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — marking unavailable`);
+                        debug_logger_1.debugLog.warn('PackageDetector', `no data returned for ${dep.name} — marking unavailable`);
                     }
                     return this.createFailedPackageInfo(dep);
                 }
                 const { latestVersion, allVersions } = packageData;
-                const closestMinorVersion = (0, utils_1.findClosestMinorVersion)(dep.version, allVersions);
+                const closestMinorVersion = (0, versions_1.findClosestMinorVersion)(dep.version, allVersions);
                 const installedClean = semver.coerce(dep.version)?.version || dep.version;
                 const minorClean = closestMinorVersion
                     ? semver.coerce(closestMinorVersion)?.version || closestMinorVersion
@@ -294,7 +329,7 @@ class PackageDetector {
                     const outdatedKey = `${dep.name}@${dep.version}`;
                     if (!loggedOutdated.has(outdatedKey)) {
                         loggedOutdated.add(outdatedKey);
-                        utils_3.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
+                        debug_logger_1.debugLog.info('PackageDetector', `outdated: ${dep.name} ${dep.version} → range:${closestMinorVersion ?? '-'} latest:${latestVersion}`);
                     }
                 }
                 return {
@@ -304,6 +339,9 @@ class PackageDetector {
                     latestVersion,
                     type: dep.type,
                     packageJsonPath: dep.packageJsonPath,
+                    catalog: dep.catalog,
+                    catalogEntries: dep.catalogEntries,
+                    catalogReferencedBy: dep.catalogReferencedBy,
                     isOutdated,
                     hasRangeUpdate,
                     hasMajorUpdate,
@@ -313,7 +351,7 @@ class PackageDetector {
                 };
             }
             catch (error) {
-                utils_3.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
+                debug_logger_1.debugLog.error('PackageDetector', `error processing ${dep.name}`, error);
                 return this.createFailedPackageInfo(dep);
             }
         });
@@ -326,6 +364,9 @@ class PackageDetector {
             latestVersion: 'unknown',
             type: dep.type,
             packageJsonPath: dep.packageJsonPath,
+            catalog: dep.catalog,
+            catalogEntries: dep.catalogEntries,
+            catalogReferencedBy: dep.catalogReferencedBy,
             isOutdated: false,
             hasRangeUpdate: false,
             hasMajorUpdate: false,
@@ -346,7 +387,7 @@ class PackageDetector {
             let timeoutId;
             try {
                 const files = await Promise.race([
-                    (0, utils_1.findAllPackageJsonFilesAsync)(this.cwd, this.excludePatterns, this.maxDepth, (currentDir, foundCount) => {
+                    (0, fs_1.findAllPackageJsonFilesAsync)(this.cwd, this.excludePatterns, this.maxDepth, (currentDir, foundCount) => {
                         const truncatedDir = currentDir.length > 50 ? '...' + currentDir.slice(-47) : currentDir;
                         this.showProgress(`🔍 Scanning ${truncatedDir} (found ${foundCount})`);
                     }, {
@@ -397,7 +438,7 @@ class PackageDetector {
             version.startsWith('bitbucket:'));
     }
     showProgress(message) {
-        utils_2.ConsoleUtils.showProgress(message);
+        terminal_1.ConsoleUtils.showProgress(message);
     }
     getOutdatedPackagesOnly(packages) {
         return packages.filter((pkg) => pkg.isOutdated);

package/dist/{core → features/upgrade}/upgrader.js

@@ -9,7 +9,9 @@ const nanospinner_1 = require("nanospinner");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const child_process_1 = require("child_process");
-const utils_1 = require("../utils");
+const exec_1 = require("../../shared/exec");
+const fs_2 = require("../../shared/fs");
+const pnpm_catalogs_1 = require("../../shared/pnpm-catalogs");
 class PackageUpgrader {
     packageManager;
     quiet;
@@ -25,15 +27,25 @@ class PackageUpgrader {
             this.log(chalk_1.default.yellow('No packages to upgrade.'));
             return;
         }
+        // Catalog entries live in pnpm-workspace.yaml, not a package.json — they
+        // take the YAML write path below.
+        const catalogChoices = choices.filter((choice) => choice.catalog);
+        const fileChoices = choices.filter((choice) => !choice.catalog);
         // Group choices by package.json path and dependency type
-        const choicesByFileAndType = this.groupChoicesByFileAndType(choices);
+        const choicesByFileAndType = this.groupChoicesByFileAndType(fileChoices);
         for (const [fileAndType, choiceList] of Object.entries(choicesByFileAndType)) {
+            // groupChoicesByFileAndType only creates a group when it has a member.
+            /* v8 ignore start */
             if (choiceList.length === 0)
                 continue;
+            /* v8 ignore stop */
             const [packageJsonPath, type] = fileAndType.split('|');
             this.log(`Processing ${type} in ${packageJsonPath}`);
             await this.upgradeChoiceGroup(choiceList, packageJsonPath, type);
         }
+        if (catalogChoices.length > 0) {
+            await this.upgradeCatalogChoices(catalogChoices);
+        }
         // Count unique packages upgraded
         const uniquePackages = new Set(choices.map((c) => c.name));
         this.log(chalk_1.default.green(`\n✅ Successfully upgraded ${uniquePackages.size} package(s)!`));
@@ -41,18 +53,22 @@ class PackageUpgrader {
         await this.runInstall(choices);
     }
     async runInstall(choices) {
+        // upgradePackages returns early for an empty selection, so this guard only
+        // protects future direct callers.
+        /* v8 ignore start */
         if (choices.length === 0) {
             return;
         }
+        /* v8 ignore stop */
         // Determine the directory to run install in
         // Use workspace root if it exists, otherwise use the directory of the first package.json
         const firstPackageJsonPath = choices[0].packageJsonPath;
         const firstPackageDir = (0, path_1.dirname)(firstPackageJsonPath);
-        const workspaceRoot = (0, utils_1.findWorkspaceRoot)(firstPackageDir, this.packageManager.name);
+        const workspaceRoot = (0, fs_2.findWorkspaceRoot)(firstPackageDir, this.packageManager.name);
         const installDir = workspaceRoot || firstPackageDir;
         // Check if package manager is installed
         try {
-            (0, utils_1.executeCommand)(`${this.packageManager.name} --version`, installDir);
+            (0, exec_1.executeCommand)(`${this.packageManager.name} --version`, installDir);
         }
         catch (error) {
             this.log(chalk_1.default.yellow(`\n⚠️  ${this.packageManager.displayName} is detected but not installed on your system.\n` +
@@ -84,6 +100,53 @@ class PackageUpgrader {
             throw new Error(`${installCommand} exited with code ${result.status}`);
         }
     }
+    /**
+     * Apply catalog upgrades by rewriting the referenced ranges inside
+     * pnpm-workspace.yaml (comment- and format-preserving). One write per file.
+     */
+    async upgradeCatalogChoices(choices) {
+        const choicesByFile = new Map();
+        choices.forEach((choice) => {
+            const group = choicesByFile.get(choice.packageJsonPath) ?? [];
+            group.push(choice);
+            choicesByFile.set(choice.packageJsonPath, group);
+        });
+        for (const [workspaceFilePath, fileChoices] of choicesByFile) {
+            if (!(0, fs_1.existsSync)(workspaceFilePath)) {
+                this.log(chalk_1.default.yellow(`⚠️  Skipping catalog entries in ${workspaceFilePath} - file not found`));
+                continue;
+            }
+            this.log(`Processing catalog entries in ${workspaceFilePath}`);
+            const spinner = this.quiet
+                ? null
+                : (0, nanospinner_1.createSpinner)(`Upgrading catalog entries in ${workspaceFilePath}...`).start();
+            try {
+                (0, pnpm_catalogs_1.writeCatalogUpdates)(workspaceFilePath, fileChoices.map((choice) => ({
+                    catalog: choice.catalog,
+                    name: choice.name,
+                    range: choice.targetVersion,
+                })));
+                const message = `Upgraded ${fileChoices.length} catalog entr${fileChoices.length === 1 ? 'y' : 'ies'} in ${workspaceFilePath}`;
+                if (spinner)
+                    spinner.success({ text: message });
+                else
+                    this.log(chalk_1.default.green(`✔ ${message}`));
+                fileChoices.forEach((choice) => {
+                    const upgradeTypeColor = choice.upgradeType === 'range' ? chalk_1.default.yellow : chalk_1.default.red;
+                    const catalogLabel = choice.catalog === 'default' ? 'catalog' : `catalog:${choice.catalog}`;
+                    this.log(`  ${chalk_1.default.green('✓')} ${chalk_1.default.cyan(choice.name)} (${catalogLabel}) → ${upgradeTypeColor(choice.targetVersion)}`);
+                });
+            }
+            catch (error) {
+                if (spinner)
+                    spinner.error({ text: `Failed to upgrade catalog entries in ${workspaceFilePath}` });
+                else
+                    this.log(chalk_1.default.red(`✖ Failed to upgrade catalog entries in ${workspaceFilePath}`));
+                console.error(chalk_1.default.red(`Error: ${error}`));
+                throw error;
+            }
+        }
+    }
     groupChoicesByFileAndType(choices) {
         const groups = {};
         choices.forEach((choice) => {
@@ -109,11 +172,10 @@ class PackageUpgrader {
         try {
             // Read the current package.json — keep the raw text so we can round-trip its formatting
             const rawContent = (0, fs_1.readFileSync)(packageJsonPath, 'utf-8');
-            const packageJson = (0, utils_1.readPackageJson)(packageJsonPath);
+            const packageJson = (0, fs_2.readPackageJson)(packageJsonPath);
             // Group by upgrade type (range vs latest)
             const rangeChoices = choices.filter((c) => c.upgradeType === 'range');
             const latestChoices = choices.filter((c) => c.upgradeType === 'latest');
-            let modified = false;
             // Upgrade range versions by directly modifying package.json
             if (rangeChoices.length > 0) {
                 if (!packageJson[type]) {
@@ -121,7 +183,6 @@ class PackageUpgrader {
                 }
                 rangeChoices.forEach((choice) => {
                     packageJson[type][choice.name] = choice.targetVersion;
-                    modified = true;
                 });
             }
             // Upgrade to latest versions by directly modifying package.json
@@ -131,17 +192,14 @@ class PackageUpgrader {
                 }
                 latestChoices.forEach((choice) => {
                     packageJson[type][choice.name] = choice.targetVersion;
-                    modified = true;
                 });
             }
             // Write back the modified package.json, preserving the original indentation and
             // trailing-newline style. Skip the write entirely when nothing actually changed.
-            if (modified) {
-                const format = (0, utils_1.detectJsonFormat)(rawContent);
-                const nextContent = JSON.stringify(packageJson, null, format.indent) + (format.trailingNewline ? '\n' : '');
-                if (nextContent !== rawContent) {
-                    (0, fs_1.writeFileSync)(packageJsonPath, nextContent);
-                }
+            const format = (0, fs_2.detectJsonFormat)(rawContent);
+            const nextContent = JSON.stringify(packageJson, null, format.indent) + (format.trailingNewline ? '\n' : '');
+            if (nextContent !== rawContent) {
+                (0, fs_1.writeFileSync)(packageJsonPath, nextContent);
             }
             if (spinner)
                 spinner.success({ text: `Upgraded ${choices.length} ${type} in ${packageDir}` });

package/dist/index.js

@@ -4,6 +4,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpgradeRunner = void 0;
-var core_1 = require("./core");
-Object.defineProperty(exports, "UpgradeRunner", { enumerable: true, get: function () { return core_1.UpgradeRunner; } });
+var upgrade_runner_1 = require("./app/upgrade-runner");
+Object.defineProperty(exports, "UpgradeRunner", { enumerable: true, get: function () { return upgrade_runner_1.UpgradeRunner; } });
 //# sourceMappingURL=index.js.map

package/dist/{config → shared/config}/package-meta.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACKAGE_VERSION = exports.PACKAGE_NAME = void 0;
-const package_json_1 = __importDefault(require("../../package.json"));
+const package_json_1 = __importDefault(require("../../../package.json"));
 exports.PACKAGE_NAME = package_json_1.default.name;
 exports.PACKAGE_VERSION = package_json_1.default.version;
 //# sourceMappingURL=package-meta.js.map

package/dist/{config → shared/config}/project-config.js

@@ -31,10 +31,13 @@ function loadProjectConfig(cwd) {
                 }
             }
         }
-        // Move to parent directory
+        // Move to parent directory. The self-parent check only trips on Windows
+        // drive roots ('C:\'); on POSIX the loop condition exits at '/' first.
         const parentDir = (0, path_1.join)(currentDir, '..');
+        /* v8 ignore start */
         if (parentDir === currentDir)
             break;
+        /* v8 ignore stop */
         currentDir = parentDir;
     }
     return {};

package/dist/{utils/config.js → shared/config/user-config.js}

@@ -7,14 +7,14 @@ exports.configManager = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const env_paths_1 = __importDefault(require("env-paths"));
-const config_1 = require("../config");
+const package_meta_1 = require("./package-meta");
 class ConfigManager {
     configDir;
     configPath;
     constructor() {
         // Use env-paths for cross-platform config directory support
         // Mac/Linux: ~/.config/inup, Windows: %APPDATA%/inup
-        const paths = (0, env_paths_1.default)(config_1.PACKAGE_NAME);
+        const paths = (0, env_paths_1.default)(package_meta_1.PACKAGE_NAME);
         this.configDir = paths.config;
         this.configPath = (0, path_1.join)(this.configDir, 'config.json');
     }
@@ -66,4 +66,4 @@ class ConfigManager {
 }
 // Export singleton instance
 exports.configManager = new ConfigManager();
-//# sourceMappingURL=config.js.map
+//# sourceMappingURL=user-config.js.map

package/dist/{ui/modal/package-info-sections.js → shared/fs/index.js}

@@ -14,6 +14,7 @@ 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("./package-info-sections/sections"), exports);
-__exportStar(require("./package-info-sections/release-notes"), exports);
-//# sourceMappingURL=package-info-sections.js.map
+__exportStar(require("./paths"), exports);
+__exportStar(require("./io"), exports);
+__exportStar(require("./scan"), exports);
+//# sourceMappingURL=index.js.map

package/dist/{utils/filesystem → shared/fs}/paths.js

@@ -4,16 +4,16 @@ exports.findPackageJson = findPackageJson;
 exports.findWorkspaceRoot = findWorkspaceRoot;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const package_manager_detector_1 = require("../../services/package-manager-detector");
+const package_manager_1 = require("../package-manager");
 function findPackageJson(cwd = process.cwd()) {
     const packageJsonPath = (0, path_1.join)(cwd, 'package.json');
     return (0, fs_1.existsSync)(packageJsonPath) ? packageJsonPath : null;
 }
 function findWorkspaceRoot(cwd = process.cwd(), packageManager) {
     if (!packageManager) {
-        const detected = package_manager_detector_1.PackageManagerDetector.detect(cwd);
+        const detected = package_manager_1.PackageManagerDetector.detect(cwd);
         packageManager = detected.name;
     }
-    return package_manager_detector_1.PackageManagerDetector.findWorkspaceRoot(cwd, packageManager);
+    return package_manager_1.PackageManagerDetector.findWorkspaceRoot(cwd, packageManager);
 }
 //# sourceMappingURL=paths.js.map

package/dist/{utils/filesystem → shared/fs}/scan.js

@@ -263,16 +263,19 @@ async function findAllPackageJsonFilesAsync(rootDir = process.cwd(), excludePatt
     }
     function pump() {
         while (activeTasks < concurrency && pending.length > 0 && !failedError) {
+            // Non-null: pending.length > 0 was just checked and nothing runs in between.
             const next = pending.shift();
-            if (!next)
-                break;
             activeTasks++;
             void processDirectory(next.dir, next.depth)
                 .catch((error) => {
+                // First error wins; a second in-flight task rejecting in the same
+                // tick is a race window that cannot be scheduled deterministically.
+                /* v8 ignore start */
                 if (!failedError) {
                     failedError = error;
                     rejectDone?.(error);
                 }
+                /* v8 ignore stop */
             })
                 .finally(() => {
                 activeTasks--;

package/dist/{services → shared}/http/etag-store.js

@@ -1,34 +1,64 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setEtagCacheEnabled = setEtagCacheEnabled;
+exports.setEtagCacheRoot = setEtagCacheRoot;
 exports.readEtag = readEtag;
 exports.writeEtag = writeEtag;
 exports.etagCacheDir = etagCacheDir;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const env_paths_1 = __importDefault(require("env-paths"));
+const config_1 = require("../config");
 /** Bump when the on-disk entry shape changes; old generations are ignored. */
 const SCHEMA = 'v1';
 /** Entries untouched for longer than this are swept on first access. */
 const MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000; // 14 days
 let enabled = true;
 let sweptThisProcess = false;
+let cacheRootOverride = null;
+let resolvedSchemaDir = null;
 /** Allow tests/callers to toggle the store without touching call sites. */
 function setEtagCacheEnabled(value) {
     enabled = value;
 }
+/**
+ * Test hook: point the store at an isolated root instead of the user's real
+ * cache directory (null restores the default). Tests must never wipe or race
+ * on the persistent per-user cache.
+ */
+function setEtagCacheRoot(root) {
+    cacheRootOverride = root;
+    resolvedSchemaDir = null;
+    sweptThisProcess = false;
+}
+/** The root holding one subdirectory per schema generation. */
+function cacheRoot() {
+    // Version data is not project-specific, so it lives in the per-user cache
+    // directory (env-paths, like the config dir), shared across every project the
+    // user scans. It used to live in the OS temp dir, but macOS clears that on
+    // reboot and Linux distros sweep it periodically — throwing the cache away
+    // exactly when it is most useful.
+    return cacheRootOverride ?? (0, node_path_1.join)((0, env_paths_1.default)(config_1.PACKAGE_NAME).cache, 'etag-cache');
+}
 /** Resolve (and lazily create) the cache directory, sweeping stale entries once. */
 function cacheDir() {
-    // Version data is not project-specific, so it lives in the OS temp area, shared
-    // across every project the user scans.
-    const dir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), 'inup', 'etag-cache', SCHEMA);
+    if (resolvedSchemaDir === null) {
+        // The location is process-invariant; derive it once instead of running
+        // env-paths on every cache read/write of the registry hot path.
+        resolvedSchemaDir = (0, node_path_1.join)(cacheRoot(), SCHEMA);
+    }
+    const dir = resolvedSchemaDir;
     if (!(0, node_fs_1.existsSync)(dir)) {
         (0, node_fs_1.mkdirSync)(dir, { recursive: true });
     }
     if (!sweptThisProcess) {
         sweptThisProcess = true;
         sweepStale(dir);
+        sweepOldGenerations(cacheRoot());
     }
     return dir;
 }
@@ -51,6 +81,28 @@ function sweepStale(dir) {
         /* sweeping is optional; never fail a run over it */
     }
 }
+/**
+ * Remove schema generations other than the active one. The cache directory is
+ * persistent (unlike the old tmpdir location, which the OS reclaimed), so after
+ * a SCHEMA bump the previous generation would otherwise live on disk forever.
+ */
+function sweepOldGenerations(root) {
+    try {
+        for (const name of (0, node_fs_1.readdirSync)(root)) {
+            if (name === SCHEMA)
+                continue;
+            try {
+                (0, node_fs_1.rmSync)((0, node_path_1.join)(root, name), { recursive: true, force: true });
+            }
+            catch {
+                /* skip generations we can't remove */
+            }
+        }
+    }
+    catch {
+        /* sweeping is optional; never fail a run over it */
+    }
+}
 /** Stable, filesystem-safe filename for a cache key (the registry path). */
 function fileFor(key) {
     const hash = (0, node_crypto_1.createHash)('sha1').update(key).digest('hex');

package/dist/{utils → shared}/local-env.js

@@ -9,7 +9,7 @@ const path_1 = require("path");
  * 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
+ * `.env.local` is found, so it works regardless of nesting depth (src/shared 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.
  *

package/dist/{services/package-manager-detector.js → shared/package-manager.js}

@@ -176,4 +176,4 @@ class PackageManagerDetector {
     }
 }
 exports.PackageManagerDetector = PackageManagerDetector;
-//# sourceMappingURL=package-manager-detector.js.map
+//# sourceMappingURL=package-manager.js.map