oh-my-node-modules 1.2.7 → 1.2.9

package/dist/cli.js

@@ -2809,6 +2809,162 @@ var import_picocolors2 = __toESM(require_picocolors(), 1);
 import { promises as fs2 } from "fs";
 import { join as join2, basename, dirname } from "path";
 
+// node_modules/yocto-queue/index.js
+class Node {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = undefined;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run.bind(undefined, function_, resolve, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+    enqueue(function_, resolve, reject, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
 // src/utils.ts
 import { promises as fs } from "fs";
 import { join } from "path";
@@ -2948,89 +3104,112 @@ async function readPackageJson(projectPath) {
   }
 }
 
-// src/scanner.ts
-async function scanForNodeModules(options, onProgress) {
-  const result = {
-    nodeModules: [],
-    directoriesScanned: 0,
-    errors: []
-  };
-  const visitedPaths = new Set;
-  const pathsToScan = [
-    { path: options.rootPath, depth: 0 }
-  ];
-  let processedCount = 0;
-  let totalEstimate = 1;
-  while (pathsToScan.length > 0) {
-    const { path: currentPath, depth } = pathsToScan.shift();
-    if (visitedPaths.has(currentPath))
-      continue;
-    if (options.maxDepth !== undefined && depth > options.maxDepth)
-      continue;
-    if (shouldExcludePath(currentPath, options.excludePatterns))
-      continue;
-    visitedPaths.add(currentPath);
-    result.directoriesScanned++;
-    try {
-      const entries = await fs2.readdir(currentPath, { withFileTypes: true });
-      const hasNodeModules = entries.some((entry) => entry.isDirectory() && entry.name === "node_modules");
-      if (hasNodeModules) {
-        const nodeModulesPath = join2(currentPath, "node_modules");
-        const info = await analyzeNodeModules(nodeModulesPath, currentPath);
-        if (options.minSizeBytes && info.sizeBytes < options.minSizeBytes) {} else if (options.olderThanDays && getAgeInDays2(info.lastModified) < options.olderThanDays) {} else {
-          result.nodeModules.push(info);
-        }
-      }
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
-          const subPath = join2(currentPath, entry.name);
-          if (!shouldExcludePath(subPath, options.excludePatterns)) {
-            pathsToScan.push({ path: subPath, depth: depth + 1 });
-            totalEstimate++;
-          }
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      result.errors.push(`Error scanning ${currentPath}: ${errorMessage}`);
+// src/native-size.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+var execAsync = promisify(exec);
+async function getSizeWithDu(dirPath) {
+  try {
+    const { stdout } = await execAsync(`du -sb "${dirPath}"`, {
+      timeout: 30000,
+      maxBuffer: 1024 * 1024
+    });
+    const match = stdout.trim().match(/^(\d+)/);
+    if (match) {
+      return parseInt(match[1], 10);
     }
-    processedCount++;
-    if (onProgress) {
-      const progress = Math.min(100, Math.round(processedCount / totalEstimate * 100));
-      onProgress(progress);
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getSizeWithDir(dirPath) {
+  try {
+    const { stdout } = await execAsync(`dir /s "${dirPath}"`, {
+      timeout: 30000,
+      maxBuffer: 1024 * 1024
+    });
+    const lines = stdout.split(`
+`);
+    for (let i = lines.length - 1;i >= 0; i--) {
+      const line = lines[i];
+      const match = line.match(/File\(s\)\s+([\d,]+)\s+bytes?/i);
+      if (match) {
+        const bytesStr = match[1].replace(/,/g, "");
+        return parseInt(bytesStr, 10);
+      }
     }
+    return null;
+  } catch {
+    return null;
   }
-  if (onProgress) {
-    onProgress(100);
+}
+async function countPackagesNative(dirPath) {
+  try {
+    const isWindows = platform() === "win32";
+    if (isWindows) {
+      const { stdout } = await execAsync(`dir /b /ad "${dirPath}" | find /c /v ""`, { timeout: 1e4 });
+      const topLevel = parseInt(stdout.trim(), 10) || 0;
+      return { topLevel, total: topLevel };
+    } else {
+      const { stdout: topLevelOut } = await execAsync(`find "${dirPath}" -maxdepth 1 -type d ! -name ".*" ! -name "node_modules" | wc -l`, { timeout: 1e4 });
+      const topLevel = Math.max(0, parseInt(topLevelOut.trim(), 10) - 1);
+      const { stdout: totalOut } = await execAsync(`find "${dirPath}" -type d ! -path "${dirPath}" ! -name ".*" | wc -l`, { timeout: 1e4 });
+      const total = parseInt(totalOut.trim(), 10);
+      return { topLevel, total };
+    }
+  } catch {
+    return null;
   }
-  return result;
 }
-async function analyzeNodeModules(nodeModulesPath, projectPath) {
-  const stats = await fs2.stat(nodeModulesPath);
-  const { totalSize, packageCount, totalPackageCount } = await calculateDirectorySize(nodeModulesPath);
-  const packageJson = await readPackageJson(projectPath);
-  const projectName = packageJson?.name || basename(projectPath);
-  const projectVersion = packageJson?.version;
-  const sizeCategory = getSizeCategory(totalSize);
-  const ageCategory = getAgeCategory(stats.mtime);
+async function getFastDirectorySize(dirPath) {
+  const isWindows = platform() === "win32";
+  let sizeBytes = null;
+  if (isWindows) {
+    sizeBytes = await getSizeWithDir(dirPath);
+  } else {
+    sizeBytes = await getSizeWithDu(dirPath);
+  }
+  const packageCounts = await countPackagesNative(dirPath);
+  if (sizeBytes !== null && packageCounts !== null) {
+    return {
+      bytes: sizeBytes,
+      packageCount: packageCounts.topLevel,
+      totalPackageCount: packageCounts.total,
+      isNative: true
+    };
+  }
   return {
-    path: nodeModulesPath,
-    projectPath,
-    projectName,
-    projectVersion,
-    sizeBytes: totalSize,
-    sizeFormatted: formatBytes(totalSize),
-    packageCount,
-    totalPackageCount,
-    lastModified: stats.mtime,
-    lastModifiedFormatted: formatRelativeTime(stats.mtime),
-    selected: false,
-    isFavorite: false,
-    ageCategory,
-    sizeCategory
+    bytes: 0,
+    packageCount: 0,
+    totalPackageCount: 0,
+    isNative: false
   };
 }
-async function calculateDirectorySize(dirPath) {
+
+// src/scanner.ts
+var DEFAULT_CONCURRENCY = 5;
+var SIZE_CALCULATION_CONCURRENCY = 3;
+async function findRepoRoot(startPath) {
+  let currentPath = startPath;
+  const root = process.platform === "win32" ? "C:\\" : "/";
+  while (currentPath !== root && currentPath !== dirname(currentPath)) {
+    const gitPath = join2(currentPath, ".git");
+    try {
+      if (await fileExists(gitPath)) {
+        return currentPath;
+      }
+    } catch {}
+    currentPath = dirname(currentPath);
+  }
+  return startPath;
+}
+function getAgeInDays2(date) {
+  const now = new Date;
+  return Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+}
+async function calculateDirectorySizeFallback(dirPath) {
   let totalSize = 0;
   let packageCount = 0;
   let totalPackageCount = 0;
@@ -3067,7 +3246,7 @@ async function calculateDirectorySize(dirPath) {
             pathsToProcess.push(entryPath);
           }
         } catch {}
-      } else if (stats.isSymbolicLink()) {}
+      }
     } catch {}
     if (currentPath === dirPath) {
       isTopLevel = false;
@@ -3075,9 +3254,181 @@ async function calculateDirectorySize(dirPath) {
   }
   return { totalSize, packageCount, totalPackageCount };
 }
-function getAgeInDays2(date) {
-  const now = new Date;
-  return Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+async function calculateSizeWithFallback(dirPath) {
+  const nativeResult = await getFastDirectorySize(dirPath);
+  if (nativeResult.isNative && nativeResult.bytes > 0) {
+    return {
+      totalSize: nativeResult.bytes,
+      packageCount: nativeResult.packageCount,
+      totalPackageCount: nativeResult.totalPackageCount,
+      isNative: true
+    };
+  }
+  const fallbackResult = await calculateDirectorySizeFallback(dirPath);
+  return {
+    ...fallbackResult,
+    isNative: false
+  };
+}
+async function analyzeNodeModules(nodeModulesPath, projectPath, lazy = false) {
+  const stats = await fs2.stat(nodeModulesPath);
+  if (lazy) {
+    const packageJson2 = await readPackageJson(projectPath);
+    const projectName2 = packageJson2?.name || basename(projectPath);
+    const repoPath2 = await findRepoRoot(projectPath);
+    return {
+      path: nodeModulesPath,
+      projectPath,
+      projectName: projectName2,
+      projectVersion: packageJson2?.version,
+      repoPath: repoPath2,
+      sizeBytes: 0,
+      sizeFormatted: "calculating...",
+      packageCount: 0,
+      totalPackageCount: 0,
+      lastModified: stats.mtime,
+      lastModifiedFormatted: formatRelativeTime(stats.mtime),
+      selected: false,
+      isFavorite: false,
+      ageCategory: getAgeCategory(stats.mtime),
+      sizeCategory: "small",
+      isPending: true
+    };
+  }
+  const { totalSize, packageCount, totalPackageCount, isNative } = await calculateSizeWithFallback(nodeModulesPath);
+  const packageJson = await readPackageJson(projectPath);
+  const projectName = packageJson?.name || basename(projectPath);
+  const repoPath = await findRepoRoot(projectPath);
+  const sizeCategory = getSizeCategory(totalSize);
+  const ageCategory = getAgeCategory(stats.mtime);
+  return {
+    path: nodeModulesPath,
+    projectPath,
+    projectName,
+    projectVersion: packageJson?.version,
+    repoPath,
+    sizeBytes: totalSize,
+    sizeFormatted: formatBytes(totalSize),
+    packageCount,
+    totalPackageCount,
+    lastModified: stats.mtime,
+    lastModifiedFormatted: formatRelativeTime(stats.mtime),
+    selected: false,
+    isFavorite: false,
+    ageCategory,
+    sizeCategory,
+    isNativeCalculation: isNative
+  };
+}
+async function updateNodeModulesSize(info) {
+  const { totalSize, packageCount, totalPackageCount, isNative } = await calculateSizeWithFallback(info.path);
+  return {
+    ...info,
+    sizeBytes: totalSize,
+    sizeFormatted: formatBytes(totalSize),
+    packageCount,
+    totalPackageCount,
+    sizeCategory: getSizeCategory(totalSize),
+    isPending: false,
+    isNativeCalculation: isNative
+  };
+}
+async function scanForNodeModules(options, onProgress, lazy = false) {
+  const result = {
+    nodeModules: [],
+    directoriesScanned: 0,
+    errors: []
+  };
+  const visitedPaths = new Set;
+  const pathsToScan = [
+    { path: options.rootPath, depth: 0 }
+  ];
+  const scanLimit = pLimit(DEFAULT_CONCURRENCY);
+  const sizeLimit = pLimit(SIZE_CALCULATION_CONCURRENCY);
+  let processedCount = 0;
+  let totalEstimate = 1;
+  let foundCount = 0;
+  while (pathsToScan.length > 0) {
+    const batch = pathsToScan.splice(0, Math.min(pathsToScan.length, DEFAULT_CONCURRENCY * 2));
+    const scanPromises = batch.map(({ path: currentPath, depth }) => scanLimit(async () => {
+      if (visitedPaths.has(currentPath))
+        return;
+      if (options.maxDepth !== undefined && depth > options.maxDepth)
+        return;
+      if (shouldExcludePath(currentPath, options.excludePatterns))
+        return;
+      visitedPaths.add(currentPath);
+      result.directoriesScanned++;
+      try {
+        const entries = await fs2.readdir(currentPath, { withFileTypes: true });
+        const hasNodeModules = entries.some((entry) => entry.isDirectory() && entry.name === "node_modules");
+        if (hasNodeModules) {
+          const nodeModulesPath = join2(currentPath, "node_modules");
+          const info = await sizeLimit(() => analyzeNodeModules(nodeModulesPath, currentPath, lazy));
+          const passesFilter = (!options.minSizeBytes || info.sizeBytes >= options.minSizeBytes) && (!options.olderThanDays || getAgeInDays2(info.lastModified) >= options.olderThanDays);
+          if (passesFilter || lazy) {
+            result.nodeModules.push(info);
+            foundCount++;
+            if (onProgress) {
+              onProgress(Math.min(100, Math.round(processedCount / totalEstimate * 100)), foundCount);
+            }
+          }
+        }
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+            const subPath = join2(currentPath, entry.name);
+            if (!shouldExcludePath(subPath, options.excludePatterns)) {
+              pathsToScan.push({ path: subPath, depth: depth + 1 });
+              totalEstimate++;
+            }
+          }
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result.errors.push(`Error scanning ${currentPath}: ${errorMessage}`);
+      }
+      processedCount++;
+      if (onProgress) {
+        onProgress(Math.min(100, Math.round(processedCount / totalEstimate * 100)), foundCount);
+      }
+    }));
+    await Promise.all(scanPromises);
+  }
+  if (onProgress) {
+    onProgress(100, foundCount);
+  }
+  return result;
+}
+async function calculatePendingSizes(nodeModules, onProgress) {
+  const pending = nodeModules.filter((nm) => nm.isPending);
+  if (pending.length === 0)
+    return nodeModules;
+  const limit = pLimit(SIZE_CALCULATION_CONCURRENCY);
+  let completed = 0;
+  const total = pending.length;
+  const updatePromises = pending.map((pendingItem) => limit(async () => {
+    try {
+      const updated = await updateNodeModulesSize(pendingItem);
+      completed++;
+      if (onProgress) {
+        onProgress(completed, total);
+      }
+      return updated;
+    } catch (error) {
+      completed++;
+      if (onProgress) {
+        onProgress(completed, total);
+      }
+      return {
+        ...pendingItem,
+        sizeFormatted: "error",
+        isPending: false
+      };
+    }
+  }));
+  const updatedItems = await Promise.all(updatePromises);
+  const updatedMap = new Map(updatedItems.map((item) => [item.path, item]));
+  return nodeModules.map((item) => updatedMap.get(item.path) || item);
 }
 async function loadIgnorePatterns() {
   const patterns = [
@@ -3237,9 +3588,10 @@ function getVersion() {
   }
 }
 function formatItem(item) {
-  const size = import_picocolors2.default.cyan(item.sizeFormatted.padStart(8));
+  const isPending = item.isPending;
+  const size = isPending ? import_picocolors2.default.yellow("  (...)  ") : import_picocolors2.default.cyan(item.sizeFormatted.padStart(8));
   const age = import_picocolors2.default.gray(item.lastModifiedFormatted);
-  const warning = item.sizeCategory === "huge" ? import_picocolors2.default.red(" ⚠") : "";
+  const warning = !isPending && item.sizeCategory === "huge" ? import_picocolors2.default.red(" ⚠") : "";
   return `${size}  ${item.projectName}${warning}  [${age}]`;
 }
 async function interactiveMode(rootPath) {
@@ -3252,13 +3604,28 @@ async function interactiveMode(rootPath) {
       rootPath,
       excludePatterns,
       followSymlinks: false
-    });
+    }, (_progress, found) => {
+      if (found > 0) {
+        s.message(`Scanning... found ${found} node_modules`);
+      }
+    }, true);
     s.stop(`Found ${result.nodeModules.length} node_modules directories`);
     if (result.nodeModules.length === 0) {
       ge(import_picocolors2.default.yellow("No node_modules found."));
       return;
     }
     let items = sortNodeModules(result.nodeModules, "size-desc");
+    console.log(`
+${import_picocolors2.default.gray("Calculating sizes...")}`);
+    console.log(`${import_picocolors2.default.gray("Projects sorted by size:")}
+`);
+    const sizeSpinner = _2();
+    sizeSpinner.start("Calculating directory sizes...");
+    items = await calculatePendingSizes(items, (completed, total) => {
+      sizeSpinner.message(`Calculating sizes... ${completed}/${total}`);
+    });
+    sizeSpinner.stop(`Calculated sizes for ${items.length} directories`);
+    items = sortNodeModules(items, "size-desc");
     const stats = calculateStatistics(items);
     console.log(`
 ${import_picocolors2.default.gray("Total:")} ${import_picocolors2.default.white(stats.totalSizeFormatted)} across ${import_picocolors2.default.white(String(stats.totalProjects))} projects`);
@@ -3417,7 +3784,7 @@ Dry run - no files deleted.`));
   }
 }
 var program2 = new Command;
-program2.name("onm").description("Find and clean up node_modules directories").version(getVersion()).argument("[path]", "Directory to scan", process.cwd()).option("--scan", "quick scan mode (no interactive UI)").option("--auto", "auto-delete mode with filters").option("--min-size <size>", "minimum size in bytes for auto mode").option("--dry-run", "simulate deletion without actually deleting").option("--json", "output as JSON").action(async (path, options) => {
+program2.name("onm").description("Find and clean up node_modules directories").version(getVersion()).argument("<path>", "Directory to scan").option("--scan", "quick scan mode (no interactive UI)").option("--auto", "auto-delete mode with filters").option("--min-size <size>", "minimum size in bytes for auto mode").option("--dry-run", "simulate deletion without actually deleting").option("--json", "output as JSON").action(async (path, options) => {
   if (options.scan) {
     await quickScanMode(path, options.json);
   } else if (options.auto) {

package/dist/index.js

@@ -2,6 +2,162 @@
 import { promises as fs2 } from "fs";
 import { join as join2, basename, dirname } from "path";
 
+// node_modules/yocto-queue/index.js
+class Node {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = undefined;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
+  const queue = new Queue;
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run.bind(undefined, function_, resolve, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+    enqueue(function_, resolve, reject, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
 // src/utils.ts
 import { promises as fs } from "fs";
 import { join } from "path";
@@ -182,89 +338,112 @@ async function readPackageJson(projectPath) {
   }
 }
 
-// src/scanner.ts
-async function scanForNodeModules(options, onProgress) {
-  const result = {
-    nodeModules: [],
-    directoriesScanned: 0,
-    errors: []
-  };
-  const visitedPaths = new Set;
-  const pathsToScan = [
-    { path: options.rootPath, depth: 0 }
-  ];
-  let processedCount = 0;
-  let totalEstimate = 1;
-  while (pathsToScan.length > 0) {
-    const { path: currentPath, depth } = pathsToScan.shift();
-    if (visitedPaths.has(currentPath))
-      continue;
-    if (options.maxDepth !== undefined && depth > options.maxDepth)
-      continue;
-    if (shouldExcludePath(currentPath, options.excludePatterns))
-      continue;
-    visitedPaths.add(currentPath);
-    result.directoriesScanned++;
-    try {
-      const entries = await fs2.readdir(currentPath, { withFileTypes: true });
-      const hasNodeModules = entries.some((entry) => entry.isDirectory() && entry.name === "node_modules");
-      if (hasNodeModules) {
-        const nodeModulesPath = join2(currentPath, "node_modules");
-        const info = await analyzeNodeModules(nodeModulesPath, currentPath);
-        if (options.minSizeBytes && info.sizeBytes < options.minSizeBytes) {} else if (options.olderThanDays && getAgeInDays2(info.lastModified) < options.olderThanDays) {} else {
-          result.nodeModules.push(info);
-        }
-      }
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
-          const subPath = join2(currentPath, entry.name);
-          if (!shouldExcludePath(subPath, options.excludePatterns)) {
-            pathsToScan.push({ path: subPath, depth: depth + 1 });
-            totalEstimate++;
-          }
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      result.errors.push(`Error scanning ${currentPath}: ${errorMessage}`);
+// src/native-size.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+var execAsync = promisify(exec);
+async function getSizeWithDu(dirPath) {
+  try {
+    const { stdout } = await execAsync(`du -sb "${dirPath}"`, {
+      timeout: 30000,
+      maxBuffer: 1024 * 1024
+    });
+    const match = stdout.trim().match(/^(\d+)/);
+    if (match) {
+      return parseInt(match[1], 10);
     }
-    processedCount++;
-    if (onProgress) {
-      const progress = Math.min(100, Math.round(processedCount / totalEstimate * 100));
-      onProgress(progress);
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getSizeWithDir(dirPath) {
+  try {
+    const { stdout } = await execAsync(`dir /s "${dirPath}"`, {
+      timeout: 30000,
+      maxBuffer: 1024 * 1024
+    });
+    const lines = stdout.split(`
+`);
+    for (let i = lines.length - 1;i >= 0; i--) {
+      const line = lines[i];
+      const match = line.match(/File\(s\)\s+([\d,]+)\s+bytes?/i);
+      if (match) {
+        const bytesStr = match[1].replace(/,/g, "");
+        return parseInt(bytesStr, 10);
+      }
     }
+    return null;
+  } catch {
+    return null;
   }
-  if (onProgress) {
-    onProgress(100);
+}
+async function countPackagesNative(dirPath) {
+  try {
+    const isWindows = platform() === "win32";
+    if (isWindows) {
+      const { stdout } = await execAsync(`dir /b /ad "${dirPath}" | find /c /v ""`, { timeout: 1e4 });
+      const topLevel = parseInt(stdout.trim(), 10) || 0;
+      return { topLevel, total: topLevel };
+    } else {
+      const { stdout: topLevelOut } = await execAsync(`find "${dirPath}" -maxdepth 1 -type d ! -name ".*" ! -name "node_modules" | wc -l`, { timeout: 1e4 });
+      const topLevel = Math.max(0, parseInt(topLevelOut.trim(), 10) - 1);
+      const { stdout: totalOut } = await execAsync(`find "${dirPath}" -type d ! -path "${dirPath}" ! -name ".*" | wc -l`, { timeout: 1e4 });
+      const total = parseInt(totalOut.trim(), 10);
+      return { topLevel, total };
+    }
+  } catch {
+    return null;
   }
-  return result;
 }
-async function analyzeNodeModules(nodeModulesPath, projectPath) {
-  const stats = await fs2.stat(nodeModulesPath);
-  const { totalSize, packageCount, totalPackageCount } = await calculateDirectorySize(nodeModulesPath);
-  const packageJson = await readPackageJson(projectPath);
-  const projectName = packageJson?.name || basename(projectPath);
-  const projectVersion = packageJson?.version;
-  const sizeCategory = getSizeCategory(totalSize);
-  const ageCategory = getAgeCategory(stats.mtime);
+async function getFastDirectorySize(dirPath) {
+  const isWindows = platform() === "win32";
+  let sizeBytes = null;
+  if (isWindows) {
+    sizeBytes = await getSizeWithDir(dirPath);
+  } else {
+    sizeBytes = await getSizeWithDu(dirPath);
+  }
+  const packageCounts = await countPackagesNative(dirPath);
+  if (sizeBytes !== null && packageCounts !== null) {
+    return {
+      bytes: sizeBytes,
+      packageCount: packageCounts.topLevel,
+      totalPackageCount: packageCounts.total,
+      isNative: true
+    };
+  }
   return {
-    path: nodeModulesPath,
-    projectPath,
-    projectName,
-    projectVersion,
-    sizeBytes: totalSize,
-    sizeFormatted: formatBytes(totalSize),
-    packageCount,
-    totalPackageCount,
-    lastModified: stats.mtime,
-    lastModifiedFormatted: formatRelativeTime(stats.mtime),
-    selected: false,
-    isFavorite: false,
-    ageCategory,
-    sizeCategory
+    bytes: 0,
+    packageCount: 0,
+    totalPackageCount: 0,
+    isNative: false
   };
 }
-async function calculateDirectorySize(dirPath) {
+
+// src/scanner.ts
+var DEFAULT_CONCURRENCY = 5;
+var SIZE_CALCULATION_CONCURRENCY = 3;
+async function findRepoRoot(startPath) {
+  let currentPath = startPath;
+  const root = process.platform === "win32" ? "C:\\" : "/";
+  while (currentPath !== root && currentPath !== dirname(currentPath)) {
+    const gitPath = join2(currentPath, ".git");
+    try {
+      if (await fileExists(gitPath)) {
+        return currentPath;
+      }
+    } catch {}
+    currentPath = dirname(currentPath);
+  }
+  return startPath;
+}
+function getAgeInDays2(date) {
+  const now = new Date;
+  return Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+}
+async function calculateDirectorySizeFallback(dirPath) {
   let totalSize = 0;
   let packageCount = 0;
   let totalPackageCount = 0;
@@ -301,7 +480,7 @@ async function calculateDirectorySize(dirPath) {
             pathsToProcess.push(entryPath);
           }
         } catch {}
-      } else if (stats.isSymbolicLink()) {}
+      }
     } catch {}
     if (currentPath === dirPath) {
       isTopLevel = false;
@@ -309,9 +488,181 @@ async function calculateDirectorySize(dirPath) {
   }
   return { totalSize, packageCount, totalPackageCount };
 }
-function getAgeInDays2(date) {
-  const now = new Date;
-  return Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+async function calculateSizeWithFallback(dirPath) {
+  const nativeResult = await getFastDirectorySize(dirPath);
+  if (nativeResult.isNative && nativeResult.bytes > 0) {
+    return {
+      totalSize: nativeResult.bytes,
+      packageCount: nativeResult.packageCount,
+      totalPackageCount: nativeResult.totalPackageCount,
+      isNative: true
+    };
+  }
+  const fallbackResult = await calculateDirectorySizeFallback(dirPath);
+  return {
+    ...fallbackResult,
+    isNative: false
+  };
+}
+async function analyzeNodeModules(nodeModulesPath, projectPath, lazy = false) {
+  const stats = await fs2.stat(nodeModulesPath);
+  if (lazy) {
+    const packageJson2 = await readPackageJson(projectPath);
+    const projectName2 = packageJson2?.name || basename(projectPath);
+    const repoPath2 = await findRepoRoot(projectPath);
+    return {
+      path: nodeModulesPath,
+      projectPath,
+      projectName: projectName2,
+      projectVersion: packageJson2?.version,
+      repoPath: repoPath2,
+      sizeBytes: 0,
+      sizeFormatted: "calculating...",
+      packageCount: 0,
+      totalPackageCount: 0,
+      lastModified: stats.mtime,
+      lastModifiedFormatted: formatRelativeTime(stats.mtime),
+      selected: false,
+      isFavorite: false,
+      ageCategory: getAgeCategory(stats.mtime),
+      sizeCategory: "small",
+      isPending: true
+    };
+  }
+  const { totalSize, packageCount, totalPackageCount, isNative } = await calculateSizeWithFallback(nodeModulesPath);
+  const packageJson = await readPackageJson(projectPath);
+  const projectName = packageJson?.name || basename(projectPath);
+  const repoPath = await findRepoRoot(projectPath);
+  const sizeCategory = getSizeCategory(totalSize);
+  const ageCategory = getAgeCategory(stats.mtime);
+  return {
+    path: nodeModulesPath,
+    projectPath,
+    projectName,
+    projectVersion: packageJson?.version,
+    repoPath,
+    sizeBytes: totalSize,
+    sizeFormatted: formatBytes(totalSize),
+    packageCount,
+    totalPackageCount,
+    lastModified: stats.mtime,
+    lastModifiedFormatted: formatRelativeTime(stats.mtime),
+    selected: false,
+    isFavorite: false,
+    ageCategory,
+    sizeCategory,
+    isNativeCalculation: isNative
+  };
+}
+async function updateNodeModulesSize(info) {
+  const { totalSize, packageCount, totalPackageCount, isNative } = await calculateSizeWithFallback(info.path);
+  return {
+    ...info,
+    sizeBytes: totalSize,
+    sizeFormatted: formatBytes(totalSize),
+    packageCount,
+    totalPackageCount,
+    sizeCategory: getSizeCategory(totalSize),
+    isPending: false,
+    isNativeCalculation: isNative
+  };
+}
+async function scanForNodeModules(options, onProgress, lazy = false) {
+  const result = {
+    nodeModules: [],
+    directoriesScanned: 0,
+    errors: []
+  };
+  const visitedPaths = new Set;
+  const pathsToScan = [
+    { path: options.rootPath, depth: 0 }
+  ];
+  const scanLimit = pLimit(DEFAULT_CONCURRENCY);
+  const sizeLimit = pLimit(SIZE_CALCULATION_CONCURRENCY);
+  let processedCount = 0;
+  let totalEstimate = 1;
+  let foundCount = 0;
+  while (pathsToScan.length > 0) {
+    const batch = pathsToScan.splice(0, Math.min(pathsToScan.length, DEFAULT_CONCURRENCY * 2));
+    const scanPromises = batch.map(({ path: currentPath, depth }) => scanLimit(async () => {
+      if (visitedPaths.has(currentPath))
+        return;
+      if (options.maxDepth !== undefined && depth > options.maxDepth)
+        return;
+      if (shouldExcludePath(currentPath, options.excludePatterns))
+        return;
+      visitedPaths.add(currentPath);
+      result.directoriesScanned++;
+      try {
+        const entries = await fs2.readdir(currentPath, { withFileTypes: true });
+        const hasNodeModules = entries.some((entry) => entry.isDirectory() && entry.name === "node_modules");
+        if (hasNodeModules) {
+          const nodeModulesPath = join2(currentPath, "node_modules");
+          const info = await sizeLimit(() => analyzeNodeModules(nodeModulesPath, currentPath, lazy));
+          const passesFilter = (!options.minSizeBytes || info.sizeBytes >= options.minSizeBytes) && (!options.olderThanDays || getAgeInDays2(info.lastModified) >= options.olderThanDays);
+          if (passesFilter || lazy) {
+            result.nodeModules.push(info);
+            foundCount++;
+            if (onProgress) {
+              onProgress(Math.min(100, Math.round(processedCount / totalEstimate * 100)), foundCount);
+            }
+          }
+        }
+        for (const entry of entries) {
+          if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+            const subPath = join2(currentPath, entry.name);
+            if (!shouldExcludePath(subPath, options.excludePatterns)) {
+              pathsToScan.push({ path: subPath, depth: depth + 1 });
+              totalEstimate++;
+            }
+          }
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result.errors.push(`Error scanning ${currentPath}: ${errorMessage}`);
+      }
+      processedCount++;
+      if (onProgress) {
+        onProgress(Math.min(100, Math.round(processedCount / totalEstimate * 100)), foundCount);
+      }
+    }));
+    await Promise.all(scanPromises);
+  }
+  if (onProgress) {
+    onProgress(100, foundCount);
+  }
+  return result;
+}
+async function calculatePendingSizes(nodeModules, onProgress) {
+  const pending = nodeModules.filter((nm) => nm.isPending);
+  if (pending.length === 0)
+    return nodeModules;
+  const limit = pLimit(SIZE_CALCULATION_CONCURRENCY);
+  let completed = 0;
+  const total = pending.length;
+  const updatePromises = pending.map((pendingItem) => limit(async () => {
+    try {
+      const updated = await updateNodeModulesSize(pendingItem);
+      completed++;
+      if (onProgress) {
+        onProgress(completed, total);
+      }
+      return updated;
+    } catch (error) {
+      completed++;
+      if (onProgress) {
+        onProgress(completed, total);
+      }
+      return {
+        ...pendingItem,
+        sizeFormatted: "error",
+        isPending: false
+      };
+    }
+  }));
+  const updatedItems = await Promise.all(updatePromises);
+  const updatedMap = new Map(updatedItems.map((item) => [item.path, item]));
+  return nodeModules.map((item) => updatedMap.get(item.path) || item);
 }
 async function loadIgnorePatterns() {
   const patterns = [
@@ -383,10 +734,12 @@ async function quickScan(rootPath) {
         const projectPath = currentPath;
         const nodeModulesPath = join2(currentPath, "node_modules");
         const packageJson = await readPackageJson(projectPath);
+        const repoPath = await findRepoRoot(projectPath);
         results.push({
           path: nodeModulesPath,
           projectPath,
-          projectName: packageJson?.name || basename(projectPath)
+          projectName: packageJson?.name || basename(projectPath),
+          repoPath
         });
       }
       for (const entry of entries) {
@@ -558,6 +911,7 @@ function invertSelection(nodeModules) {
 // src/index.ts
 var VERSION = "1.0.0";
 export {
+  updateNodeModulesSize,
   toggleSelection,
   sortNodeModules,
   selectBySize,
@@ -580,6 +934,7 @@ export {
   filterNodeModules,
   deleteSelectedNodeModules,
   calculateStatistics,
+  calculatePendingSizes,
   analyzeNodeModules,
   VERSION,
   SIZE_THRESHOLDS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-node-modules",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "Visualize, analyze, and clean up node_modules directories to reclaim disk space",
   "type": "module",
   "main": "./dist/index.js",
@@ -65,6 +65,7 @@
   "dependencies": {
     "@clack/prompts": "^0.8.2",
     "commander": "^14.0.3",
+    "p-limit": "^7.3.0",
     "picocolors": "^1.1.1",
     "zod": "^3.23.8"
   },