inup 1.5.5 → 1.6.0

package/dist/utils/config.js

@@ -7,11 +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");
 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)('inup');
+        const paths = (0, env_paths_1.default)(config_1.PACKAGE_NAME);
         this.configDir = paths.config;
         this.configPath = (0, path_1.join)(this.configDir, 'config.json');
     }
@@ -51,6 +54,15 @@ class ConfigManager {
         config.theme = theme;
         this.writeConfig(config);
     }
+    getFilters() {
+        const config = this.readConfig();
+        return config.filters ?? null;
+    }
+    setFilters(filters) {
+        const config = this.readConfig();
+        config.filters = filters;
+        this.writeConfig(config);
+    }
 }
 // Export singleton instance
 exports.configManager = new ConfigManager();

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJson = readPackageJson;
+exports.detectJsonFormat = detectJsonFormat;
+exports.readPackageJsonAsync = readPackageJsonAsync;
+exports.collectAllDependencies = collectAllDependencies;
+exports.collectAllDependenciesAsync = collectAllDependenciesAsync;
+const fs_1 = require("fs");
+const fs_2 = require("fs");
+function readPackageJson(path) {
+    try {
+        const content = (0, fs_1.readFileSync)(path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read package.json: ${error}`);
+    }
+}
+/**
+ * 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');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to read package.json: ${error}`);
+    }
+}
+function collectAllDependencies(packageJsonFiles, _options = {}) {
+    const allDeps = [];
+    for (const packageJsonPath of packageJsonFiles) {
+        try {
+            const packageJson = readPackageJson(packageJsonPath);
+            const depTypes = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+            for (const depType of depTypes) {
+                const deps = packageJson[depType];
+                if (deps && typeof deps === 'object') {
+                    for (const [name, version] of Object.entries(deps)) {
+                        allDeps.push({
+                            name,
+                            version: version,
+                            type: depType,
+                            packageJsonPath,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip malformed package.json files
+        }
+    }
+    return allDeps;
+}
+async function collectAllDependenciesAsync(packageJsonFiles, _options = {}) {
+    const packageJsonPromises = packageJsonFiles.map(async (packageJsonPath) => {
+        try {
+            const packageJson = await readPackageJsonAsync(packageJsonPath);
+            return { packageJson, packageJsonPath };
+        }
+        catch {
+            // Skip malformed package.json files
+            return null;
+        }
+    });
+    const results = await Promise.all(packageJsonPromises);
+    const allDeps = [];
+    for (const result of results) {
+        if (!result)
+            continue;
+        const { packageJson, packageJsonPath } = result;
+        const depTypes = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+        for (const depType of depTypes) {
+            const deps = packageJson[depType];
+            if (deps && typeof deps === 'object') {
+                for (const [name, version] of Object.entries(deps)) {
+                    allDeps.push({
+                        name,
+                        version: version,
+                        type: depType,
+                        packageJsonPath,
+                    });
+                }
+            }
+        }
+    }
+    return allDeps;
+}
+//# sourceMappingURL=io.js.map

package/dist/utils/filesystem/paths.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+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);
+        packageManager = detected.name;
+    }
+    return package_manager_detector_1.PackageManagerDetector.findWorkspaceRoot(cwd, packageManager);
+}
+//# sourceMappingURL=paths.js.map

package/dist/utils/filesystem/scan.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAllPackageJsonFiles = findAllPackageJsonFiles;
+exports.findAllPackageJsonFilesAsync = findAllPackageJsonFilesAsync;
+const fs_1 = require("fs");
+const fs_2 = require("fs");
+const path_1 = require("path");
+const SKIP_DIRS = new Set([
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    'out',
+    'lib',
+    'es',
+    'esm',
+    'cjs',
+]);
+/**
+ * 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;
+}
+/**
+ * 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));
+    }
+    function reportProgress(currentDir, force = false) {
+        if (!onProgress)
+            return;
+        const now = Date.now();
+        if (!force && now - lastProgressAt < progressIntervalMs) {
+            return;
+        }
+        lastProgressAt = now;
+        const relativePath = (0, path_1.relative)(rootDir, currentDir) || '.';
+        onProgress(relativePath, packageJsonFiles.length);
+    }
+    function traverseDirectory(dir, depth = 0) {
+        if (depth > maxDepth) {
+            return;
+        }
+        try {
+            // Prevent symlink cycles by tracking visited real paths
+            const realPath = (0, fs_1.realpathSync)(dir);
+            if (visitedPaths.has(realPath)) {
+                return;
+            }
+            visitedPaths.add(realPath);
+            directoriesScanned++;
+            // Report progress every 10 directories or on first scan
+            if (onProgress && (directoriesScanned % 10 === 0 || directoriesScanned === 1)) {
+                reportProgress(dir, true);
+            }
+            const files = (0, fs_1.readdirSync)(dir);
+            for (const file of files) {
+                reportProgress(dir);
+                const fullPath = (0, path_1.join)(dir, file);
+                const relativePath = (0, path_1.relative)(rootDir, fullPath);
+                if (shouldExcludePath(relativePath)) {
+                    continue;
+                }
+                let stat;
+                try {
+                    stat = (0, fs_1.statSync)(fullPath);
+                }
+                catch {
+                    // Skip files/dirs we can't stat (broken symlinks, permission issues)
+                    continue;
+                }
+                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);
+                }
+            }
+        }
+        catch {
+            // Skip directories that can't be read (permission issues, etc.)
+        }
+    }
+    traverseDirectory(rootDir);
+    return packageJsonFiles;
+}
+async function findAllPackageJsonFilesAsync(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress, options = {}) {
+    const packageJsonFiles = [];
+    const visitedPaths = new Set();
+    let directoriesScanned = 0;
+    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));
+    }
+    function reportProgress(currentDir, force = false) {
+        if (!onProgress)
+            return;
+        const now = Date.now();
+        if (!force && now - lastProgressAt < progressIntervalMs) {
+            return;
+        }
+        lastProgressAt = now;
+        const relativePath = (0, path_1.relative)(rootDir, currentDir) || '.';
+        onProgress(relativePath, packageJsonFiles.length);
+    }
+    const pending = [];
+    let activeTasks = 0;
+    let failedError = null;
+    let resolveDone = null;
+    let rejectDone = null;
+    const done = new Promise((resolve, reject) => {
+        resolveDone = resolve;
+        rejectDone = reject;
+    });
+    function finishIfIdle() {
+        if (pending.length === 0 && activeTasks === 0) {
+            resolveDone?.();
+        }
+    }
+    function schedule(dir, depth) {
+        pending.push({ dir, depth });
+        pump();
+    }
+    async function processDirectory(dir, depth) {
+        if (depth > maxDepth) {
+            return;
+        }
+        let realPath;
+        try {
+            realPath = await fs_2.promises.realpath(dir);
+        }
+        catch {
+            return;
+        }
+        if (visitedPaths.has(realPath)) {
+            return;
+        }
+        visitedPaths.add(realPath);
+        directoriesScanned++;
+        if (directoriesScanned % 10 === 0 || directoriesScanned === 1) {
+            reportProgress(dir, true);
+        }
+        let files;
+        try {
+            files = await fs_2.promises.readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const file of files) {
+            reportProgress(dir);
+            const fullPath = (0, path_1.join)(dir, file);
+            const relativePath = (0, path_1.relative)(rootDir, fullPath);
+            if (shouldExcludePath(relativePath)) {
+                continue;
+            }
+            let stat;
+            try {
+                stat = await fs_2.promises.stat(fullPath);
+            }
+            catch {
+                continue;
+            }
+            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);
+            }
+        }
+    }
+    function pump() {
+        while (activeTasks < concurrency && pending.length > 0 && !failedError) {
+            const next = pending.shift();
+            if (!next)
+                break;
+            activeTasks++;
+            void processDirectory(next.dir, next.depth)
+                .catch((error) => {
+                if (!failedError) {
+                    failedError = error;
+                    rejectDone?.(error);
+                }
+            })
+                .finally(() => {
+                activeTasks--;
+                if (failedError) {
+                    return;
+                }
+                pump();
+                finishIfIdle();
+            });
+        }
+    }
+    schedule(rootDir, 0);
+    await done;
+    return packageJsonFiles;
+}
+//# sourceMappingURL=scan.js.map