inup 1.5.4 → 1.5.6

package/dist/utils/filesystem/io.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJson = readPackageJson;
+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}`);
+    }
+}
+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,205 @@
+"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',
+]);
+function shouldSkipDirectory(name) {
+    return name.startsWith('.') || SKIP_DIRS.has(name);
+}
+function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress) {
+    const packageJsonFiles = [];
+    const visitedPaths = new Set();
+    let directoriesScanned = 0;
+    let lastProgressAt = 0;
+    const progressIntervalMs = 250;
+    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() && !shouldSkipDirectory(file)) {
+                    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 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() && !shouldSkipDirectory(file)) {
+                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

package/dist/utils/filesystem.js

@@ -1,338 +1,20 @@
 "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 });
-exports.findPackageJson = findPackageJson;
-exports.findWorkspaceRoot = findWorkspaceRoot;
-exports.readPackageJson = readPackageJson;
-exports.readPackageJsonAsync = readPackageJsonAsync;
-exports.collectAllDependencies = collectAllDependencies;
-exports.collectAllDependenciesAsync = collectAllDependenciesAsync;
-exports.findAllPackageJsonFiles = findAllPackageJsonFiles;
-exports.findAllPackageJsonFilesAsync = findAllPackageJsonFilesAsync;
-const fs_1 = require("fs");
-const fs_2 = require("fs");
-const path_1 = require("path");
-const package_manager_detector_1 = require("../services/package-manager-detector");
-/**
- * Find package.json in the current working directory
- */
-function findPackageJson(cwd = process.cwd()) {
-    const packageJsonPath = (0, path_1.join)(cwd, 'package.json');
-    return (0, fs_1.existsSync)(packageJsonPath) ? packageJsonPath : null;
-}
-/**
- * Find the workspace root by detecting package manager and checking for workspace configuration
- * @param cwd - Current working directory
- * @param packageManager - Optional package manager to use (will auto-detect if not provided)
- */
-function findWorkspaceRoot(cwd = process.cwd(), packageManager) {
-    // Auto-detect if not provided
-    if (!packageManager) {
-        const detected = package_manager_detector_1.PackageManagerDetector.detect(cwd);
-        packageManager = detected.name;
-    }
-    return package_manager_detector_1.PackageManagerDetector.findWorkspaceRoot(cwd, packageManager);
-}
-/**
- * Read and parse a package.json file
- */
-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}`);
-    }
-}
-/**
- * Read and parse a package.json file asynchronously
- */
-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}`);
-    }
-}
-const SKIP_DIRS = new Set([
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    'out',
-    'lib',
-    'es',
-    'esm',
-    'cjs',
-]);
-function shouldSkipDirectory(name) {
-    return name.startsWith('.') || SKIP_DIRS.has(name);
-}
-/**
- * Collects all dependencies from multiple package.json files.
- * Always includes regular dependencies and devDependencies.
- * Optionally includes peer and optional dependencies based on flags.
- */
-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 (error) {
-            // Skip malformed package.json files
-        }
-    }
-    return allDeps;
-}
-/**
- * Collects all dependencies from multiple package.json files asynchronously.
- * Reads all package.json files in parallel for better performance.
- * Always includes regular dependencies and devDependencies.
- * Optionally includes peer and optional dependencies based on flags.
- */
-async function collectAllDependenciesAsync(packageJsonFiles, options = {}) {
-    // Read all package.json files in parallel
-    const packageJsonPromises = packageJsonFiles.map(async (packageJsonPath) => {
-        try {
-            const packageJson = await readPackageJsonAsync(packageJsonPath);
-            return { packageJson, packageJsonPath };
-        }
-        catch (error) {
-            // Skip malformed package.json files
-            return null;
-        }
-    });
-    const results = await Promise.all(packageJsonPromises);
-    // Collect dependencies from all successfully read package.json files
-    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;
-}
-/**
- * Find all package.json files recursively
- */
-function findAllPackageJsonFiles(rootDir = process.cwd(), excludePatterns = [], maxDepth = 10, onProgress) {
-    const packageJsonFiles = [];
-    const visitedPaths = new Set();
-    let directoriesScanned = 0;
-    let lastProgressAt = 0;
-    const progressIntervalMs = 250;
-    // Compile regex patterns for exclude filtering
-    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) {
-        // Prevent infinite recursion with depth limit
-        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);
-                // Skip if path matches exclude patterns
-                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() && !shouldSkipDirectory(file)) {
-                    traverseDirectory(fullPath, depth + 1);
-                }
-                else if (file === 'package.json' && stat.isFile()) {
-                    packageJsonFiles.push(fullPath);
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories that can't be read (permission issues, etc.)
-        }
-    }
-    traverseDirectory(rootDir);
-    return packageJsonFiles;
-}
-/**
- * Find all package.json files recursively with bounded parallel directory traversal.
- */
-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 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() && !shouldSkipDirectory(file)) {
-                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;
-}
+__exportStar(require("./filesystem/paths"), exports);
+__exportStar(require("./filesystem/io"), exports);
+__exportStar(require("./filesystem/scan"), exports);
 //# sourceMappingURL=filesystem.js.map