@vibgrate/cli 2026.618.2 → 2026.623.2

package/dist/chunk-C7LU6YIL.js

@@ -1,813 +0,0 @@
-// ../vibgrate-core/dist/chunk-R3UFC4G6.js
-import { execFile } from "child_process";
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path2 from "path";
-import { promisify } from "util";
-import * as path from "path";
-var Semaphore = class {
-  available;
-  queue = [];
-  constructor(max) {
-    this.available = max;
-  }
-  async run(fn) {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-  acquire() {
-    if (this.available > 0) {
-      this.available--;
-      return Promise.resolve();
-    }
-    return new Promise((resolve2) => this.queue.push(resolve2));
-  }
-  release() {
-    const next = this.queue.shift();
-    if (next) next();
-    else this.available++;
-  }
-};
-function parseExcludePatterns(input) {
-  if (input === void 0) return [];
-  const raw = Array.isArray(input) ? input : [input];
-  const out = [];
-  for (const entry of raw) {
-    for (const part of entry.split(/[,;]/)) {
-      const trimmed = part.trim();
-      if (trimmed) out.push(trimmed);
-    }
-  }
-  return [...new Set(out)];
-}
-function compileGlobs(patterns) {
-  if (patterns.length === 0) return null;
-  const matchers = patterns.map((p) => compileOne(normalise(p)));
-  return (relPath) => {
-    const norm = normalise(relPath);
-    return matchers.some((m) => m(norm));
-  };
-}
-function normalise(p) {
-  return p.split(path.sep).join("/").replace(/\/+$/, "");
-}
-function compileOne(pattern) {
-  if (!pattern.includes("/") && !hasGlobChars(pattern)) {
-    const prefix = pattern + "/";
-    return (p) => p === pattern || p.startsWith(prefix);
-  }
-  const re = globToRegex(pattern);
-  return (p) => re.test(p);
-}
-function hasGlobChars(s) {
-  return /[*?[\]{}]/.test(s);
-}
-function globToRegex(pattern) {
-  let i = 0;
-  let re = "^";
-  const len = pattern.length;
-  while (i < len) {
-    const ch = pattern[i];
-    if (ch === "*") {
-      if (pattern[i + 1] === "*") {
-        i += 2;
-        if (pattern[i] === "/") {
-          i++;
-          re += "(?:.+/)?";
-        } else {
-          re += ".*";
-        }
-      } else {
-        i++;
-        re += "[^/]*";
-      }
-    } else if (ch === "?") {
-      i++;
-      re += "[^/]";
-    } else if (ch === "[") {
-      const start = i;
-      i++;
-      while (i < len && pattern[i] !== "]") i++;
-      i++;
-      re += pattern.slice(start, i);
-    } else if (ch === "{") {
-      i++;
-      const alternatives = [];
-      let current = "";
-      while (i < len && pattern[i] !== "}") {
-        if (pattern[i] === ",") {
-          alternatives.push(current);
-          current = "";
-        } else {
-          current += pattern[i];
-        }
-        i++;
-      }
-      alternatives.push(current);
-      i++;
-      re += "(?:" + alternatives.map(escapeRegex).join("|") + ")";
-    } else {
-      re += escapeRegex(ch);
-      i++;
-    }
-  }
-  re += "$";
-  return new RegExp(re);
-}
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var execFileAsync = promisify(execFile);
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  // Vendored third-party dependency trees (Go vendor/, PHP composer,
-  // Rails vendor/) — their manifests are not the repo's own projects and
-  // their runtimes/dependencies must not produce drift findings.
-  "vendor",
-  ".git",
-  ".vibgrate",
-  ".wrangler",
-  ".next",
-  "dist",
-  "build",
-  "out",
-  ".turbo",
-  ".cache",
-  "coverage",
-  "bin",
-  "obj",
-  ".vs",
-  "TestResults"
-]);
-var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
-  // Fonts
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".otf",
-  ".eot",
-  // Images & vector
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".ico",
-  ".bmp",
-  ".tiff",
-  ".tif",
-  ".webp",
-  ".avif",
-  ".svg",
-  ".heic",
-  ".heif",
-  ".jfif",
-  ".psd",
-  ".ai",
-  ".eps",
-  ".raw",
-  ".cr2",
-  ".nef",
-  ".dng",
-  // Video
-  ".mp4",
-  ".webm",
-  ".avi",
-  ".mov",
-  ".mkv",
-  ".wmv",
-  ".flv",
-  ".m4v",
-  ".mpg",
-  ".mpeg",
-  ".3gp",
-  ".ogv",
-  // Audio
-  ".mp3",
-  ".wav",
-  ".ogg",
-  ".flac",
-  ".aac",
-  ".wma",
-  ".m4a",
-  ".opus",
-  ".aiff",
-  ".mid",
-  ".midi",
-  // Archives
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".7z",
-  ".rar",
-  // Compiled / binary
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".o",
-  ".a",
-  ".class",
-  ".pyc",
-  ".pdb",
-  // Source maps & lockfiles (large, not useful for drift analysis)
-  ".map"
-]);
-var EXTRA_SKIP_DIRS = /* @__PURE__ */ new Set([".nuxt", ".output", ".svelte-kit"]);
-var SOURCE_EXCLUDE_FILES = /* @__PURE__ */ new Set([
-  "pnpm-lock.yaml",
-  "package-lock.json",
-  "npm-shrinkwrap.json",
-  "yarn.lock",
-  "bun.lockb",
-  "bun.lock",
-  "gemfile.lock",
-  "poetry.lock",
-  "pipfile.lock",
-  "composer.lock",
-  "cargo.lock",
-  "packages.lock.json",
-  "go.sum",
-  "gradle.lockfile",
-  "deno.lock",
-  "flake.lock"
-]);
-var TEXT_CACHE_MAX_BYTES = 1048576;
-var FileCache = class _FileCache {
-  /** Directory walk results keyed by rootDir */
-  walkCache = /* @__PURE__ */ new Map();
-  /** File content keyed by absolute path (only files ≤ TEXT_CACHE_MAX_BYTES) */
-  textCache = /* @__PURE__ */ new Map();
-  /** Parsed JSON keyed by absolute path */
-  jsonCache = /* @__PURE__ */ new Map();
-  /** pathExists keyed by absolute path */
-  existsCache = /* @__PURE__ */ new Map();
-  /** User-configured exclude predicate (compiled from glob patterns) */
-  excludePredicate = null;
-  /** Directories that were auto-skipped because they were stuck */
-  _stuckPaths = [];
-  /** Files skipped because they exceed maxFileSizeToScan */
-  _skippedLargeFiles = [];
-  /** Maximum file size (bytes) we will read. 0 = unlimited. */
-  _maxFileSize = 0;
-  /** Per-project / per-directory scan timeout in ms. */
-  _projectScanTimeout = 18e4;
-  /** Whether we have already shown the "increase projectScanTimeout" hint */
-  _timeoutHintShown = false;
-  /** Root dir for relative-path computation (set by the first walkDir call) */
-  _rootDir = null;
-  /** Cached tree summary captured during the shared walk */
-  walkSummary = /* @__PURE__ */ new Map();
-  /** Fast lookup for exact filename (e.g. package.json) */
-  fileNameIndex = /* @__PURE__ */ new Map();
-  /** Per-file byte size keyed by absolute path (memoised so nested projects don't re-stat) */
-  sizeCache = /* @__PURE__ */ new Map();
-  /** Concurrency limiter for size stats */
-  sizeSem = new Semaphore(64);
-  /** Set exclude patterns from config (call once before the walk) */
-  setExcludePatterns(patterns) {
-    this.excludePredicate = compileGlobs(patterns);
-  }
-  /** Set the maximum file size in bytes that readTextFile / readJsonFile will process */
-  setMaxFileSize(bytes) {
-    this._maxFileSize = bytes;
-  }
-  /** Set the per-project scan timeout (milliseconds). Scanners use this
-   *  instead of a hard-coded constant so the user can override it via config. */
-  setProjectScanTimeout(ms) {
-    this._projectScanTimeout = ms;
-  }
-  /** Current per-project scan timeout in milliseconds */
-  get projectScanTimeout() {
-    return this._projectScanTimeout;
-  }
-  /** Record a path that timed out or was stuck during scanning */
-  addStuckPath(relPath) {
-    this._stuckPaths.push(relPath);
-  }
-  /**
-   * Returns true the first time it is called, false thereafter.
-   * Used by scanners to print the "increase projectScanTimeout" hint
-   * only once per scan run.
-   */
-  shouldShowTimeoutHint() {
-    if (this._timeoutHintShown) return false;
-    this._timeoutHintShown = true;
-    return true;
-  }
-  /** Get all paths that were auto-skipped due to being stuck (dirs + scanner files) */
-  get stuckPaths() {
-    return this._stuckPaths;
-  }
-  /** @deprecated Use stuckPaths instead */
-  get stuckDirs() {
-    return this._stuckPaths;
-  }
-  /** Get files that were skipped because they exceeded maxFileSizeToScan */
-  get skippedLargeFiles() {
-    return this._skippedLargeFiles;
-  }
-  // ── Directory walking ──
-  /**
-   * Walk the directory tree from `rootDir` once, skipping SKIP_DIRS plus
-   * common framework output dirs (.nuxt, .output, .svelte-kit).
-   *
-   * The result is memoised so every scanner filters the same array.
-   * Consumers that need additional filtering (e.g. SOURCE_EXTENSIONS,
-   * SKIP_EXTENSIONS) do so on the returned entries — no separate walk.
-   */
-  walkDir(rootDir, onProgress) {
-    this._rootDir = rootDir;
-    const cached = this.walkCache.get(rootDir);
-    if (cached) return cached;
-    const promise = this._doWalk(rootDir, onProgress);
-    this.walkCache.set(rootDir, promise);
-    return promise;
-  }
-  /** Return tree summary from the cached walk, if available. */
-  getWalkSummary(rootDir) {
-    return this.walkSummary.get(rootDir);
-  }
-  /** Additional dirs skipped only by the cached walk (framework outputs) */
-  static EXTRA_SKIP = EXTRA_SKIP_DIRS;
-  async _doWalk(rootDir, onProgress) {
-    const results = [];
-    const cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length || 4;
-    const maxConcurrentReads = Math.max(8, Math.min(64, cores * 4));
-    let foundCount = 0;
-    let lastReported = 0;
-    const REPORT_INTERVAL = 50;
-    const sem = new Semaphore(maxConcurrentReads);
-    const STUCK_TIMEOUT_MS = this._projectScanTimeout;
-    const extraSkip = _FileCache.EXTRA_SKIP;
-    const isExcluded = this.excludePredicate;
-    const stuckDirs = this._stuckPaths;
-    async function walk(dir) {
-      const relDir = path2.relative(rootDir, dir);
-      if (onProgress) {
-        onProgress(foundCount, relDir || ".");
-      }
-      let entries;
-      try {
-        entries = await sem.run(async () => {
-          const readPromise = fs.readdir(dir, { withFileTypes: true });
-          let stuckTimer;
-          const result = await Promise.race([
-            readPromise.then((e) => ({ ok: true, entries: e })),
-            new Promise((resolve2) => {
-              stuckTimer = setTimeout(() => resolve2({ ok: false }), STUCK_TIMEOUT_MS);
-              stuckTimer.unref();
-            })
-          ]);
-          clearTimeout(stuckTimer);
-          if (!result.ok) {
-            stuckDirs.push(relDir || dir);
-            return null;
-          }
-          return result.entries;
-        });
-      } catch {
-        return;
-      }
-      if (!entries) return;
-      const subWalks = [];
-      for (const e of entries) {
-        const absPath = path2.join(dir, e.name);
-        const relPath = path2.relative(rootDir, absPath);
-        if (isExcluded && isExcluded(relPath)) continue;
-        if (e.isDirectory()) {
-          if (SKIP_DIRS.has(e.name) || extraSkip.has(e.name)) continue;
-          results.push({ absPath, relPath, name: e.name, isFile: false, isDirectory: true });
-          subWalks.push(walk(absPath));
-        } else if (e.isFile()) {
-          const ext = path2.extname(e.name).toLowerCase();
-          if (SKIP_EXTENSIONS.has(ext)) continue;
-          results.push({ absPath, relPath, name: e.name, isFile: true, isDirectory: false });
-          foundCount++;
-          if (onProgress && foundCount - lastReported >= REPORT_INTERVAL) {
-            lastReported = foundCount;
-            onProgress(foundCount, relPath);
-          }
-        }
-      }
-      await Promise.all(subWalks);
-    }
-    await walk(rootDir);
-    let totalDirs = 0;
-    const rootNameIndex = /* @__PURE__ */ new Map();
-    for (const entry of results) {
-      if (entry.isDirectory) totalDirs++;
-      if (!entry.isFile) continue;
-      const bucket = rootNameIndex.get(entry.name);
-      if (bucket) {
-        bucket.push(entry.absPath);
-      } else {
-        rootNameIndex.set(entry.name, [entry.absPath]);
-      }
-    }
-    this.walkSummary.set(rootDir, { totalFiles: foundCount, totalDirs });
-    this.fileNameIndex.set(rootDir, rootNameIndex);
-    if (onProgress && foundCount !== lastReported) {
-      onProgress(foundCount, "");
-    }
-    return results;
-  }
-  /**
-   * Find files matching a predicate from the cached walk.
-   * Returns absolute paths (same contract as the standalone `findFiles`).
-   */
-  async findFiles(rootDir, predicate) {
-    const entries = await this.walkDir(rootDir);
-    return entries.filter((e) => e.isFile && predicate(e.name)).map((e) => e.absPath);
-  }
-  async findPackageJsonFiles(rootDir) {
-    await this.walkDir(rootDir);
-    return this.fileNameIndex.get(rootDir)?.get("package.json") ?? [];
-  }
-  async findCsprojFiles(rootDir) {
-    const entries = await this.walkDir(rootDir);
-    return entries.filter((e) => e.isFile && e.name.endsWith(".csproj")).map((e) => e.absPath);
-  }
-  async findSolutionFiles(rootDir) {
-    const entries = await this.walkDir(rootDir);
-    return entries.filter((e) => e.isFile && e.name.endsWith(".sln")).map((e) => e.absPath);
-  }
-  /**
-   * Count files under a given directory using the cached walk data.
-   * Avoids a redundant recursive readdir that can be slow on large
-   * project trees (the main cause of per-project timeout hits).
-   * Falls back to the standalone `countFilesInDir` if the walk hasn't
-   * been populated yet.
-   */
-  async countFilesUnder(rootDir, dir) {
-    const entries = this.walkCache.get(rootDir);
-    if (!entries) {
-      return countFilesInDir(dir);
-    }
-    const resolved = await entries;
-    const prefix = dir.endsWith(path2.sep) ? dir : dir + path2.sep;
-    let count = 0;
-    for (const e of resolved) {
-      if (!e.isFile) continue;
-      if (e.absPath === dir || e.absPath.startsWith(prefix)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  /** Stat a single file's byte size, memoised and concurrency-limited. */
-  statSize(absPath) {
-    const cached = this.sizeCache.get(absPath);
-    if (cached) return cached;
-    const promise = this.sizeSem.run(async () => {
-      try {
-        const stat2 = await fs.stat(absPath);
-        return stat2.size;
-      } catch {
-        return 0;
-      }
-    });
-    this.sizeCache.set(absPath, promise);
-    return promise;
-  }
-  /**
-   * Sum the byte size of every file under `dir` using the cached walk.
-   * Mirrors {@link countFilesUnder}; per-file stats are memoised so nested
-   * project trees are never stat-ed twice. Falls back to a standalone walk
-   * when the cache has not been populated yet.
-   */
-  async bytesUnder(rootDir, dir) {
-    const entries = this.walkCache.get(rootDir);
-    if (!entries) {
-      return bytesInDir(dir);
-    }
-    const resolved = await entries;
-    const prefix = dir.endsWith(path2.sep) ? dir : dir + path2.sep;
-    const sizes = await Promise.all(
-      resolved.filter((e) => e.isFile && (e.absPath === dir || e.absPath.startsWith(prefix))).map((e) => this.statSize(e.absPath))
-    );
-    return sizes.reduce((total, size) => total + size, 0);
-  }
-  /**
-   * Source-only file count and byte size under `dir`, used for billing
-   * classification. Identical to {@link countFilesUnder} / {@link bytesUnder}
-   * but additionally excludes lockfiles and generated dependency manifests
-   * (see {@link SOURCE_EXCLUDE_FILES}); vendored and build-output directories
-   * are already excluded by the shared walk. Walks the cached entries once so
-   * the count and size stay consistent. Falls back to the standalone walks
-   * when the cache has not been populated yet.
-   */
-  async sourceMetricsUnder(rootDir, dir) {
-    const entries = this.walkCache.get(rootDir);
-    if (!entries) {
-      const [fileCount, sizeBytes] = await Promise.all([countFilesInDir(dir), bytesInDir(dir)]);
-      return { fileCount, sizeBytes };
-    }
-    const resolved = await entries;
-    const prefix = dir.endsWith(path2.sep) ? dir : dir + path2.sep;
-    const sourceFiles = resolved.filter(
-      (e) => e.isFile && (e.absPath === dir || e.absPath.startsWith(prefix)) && !SOURCE_EXCLUDE_FILES.has(e.name.toLowerCase())
-    );
-    const sizes = await Promise.all(sourceFiles.map((e) => this.statSize(e.absPath)));
-    return {
-      fileCount: sourceFiles.length,
-      sizeBytes: sizes.reduce((total, size) => total + size, 0)
-    };
-  }
-  // ── File content reading ──
-  /**
-   * Read a text file. Files ≤ 1 MB are cached so subsequent calls from
-   * different scanners return the same string. Files > 1 MB (lockfiles,
-   * large generated files) are read directly and never retained.
-   *
-   * If maxFileSizeToScan is set and the file exceeds it, the file is
-   * recorded as skipped and an empty string is returned.
-   */
-  readTextFile(filePath) {
-    const abs = path2.resolve(filePath);
-    const cached = this.textCache.get(abs);
-    if (cached) return cached;
-    const maxSize = this._maxFileSize;
-    const skippedLarge = this._skippedLargeFiles;
-    const rootDir = this._rootDir;
-    const promise = (async () => {
-      if (maxSize > 0) {
-        try {
-          const stat2 = await fs.stat(abs);
-          if (stat2.size > maxSize) {
-            const rel = rootDir ? path2.relative(rootDir, abs) : abs;
-            skippedLarge.push(rel);
-            this.textCache.delete(abs);
-            return "";
-          }
-        } catch {
-        }
-      }
-      const content = await fs.readFile(abs, "utf8");
-      if (content.length > TEXT_CACHE_MAX_BYTES) {
-        this.textCache.delete(abs);
-      }
-      return content;
-    })();
-    this.textCache.set(abs, promise);
-    return promise;
-  }
-  /**
-   * Read and parse a JSON file. The parsed object is cached; the raw
-   * text is evicted immediately so we never hold both representations.
-   */
-  readJsonFile(filePath) {
-    const abs = path2.resolve(filePath);
-    const cached = this.jsonCache.get(abs);
-    if (cached) return cached;
-    const promise = this.readTextFile(abs).then((txt) => {
-      this.textCache.delete(abs);
-      return JSON.parse(stripBom(txt));
-    });
-    this.jsonCache.set(abs, promise);
-    return promise;
-  }
-  // ── Existence checks ──
-  pathExists(p) {
-    const abs = path2.resolve(p);
-    const cached = this.existsCache.get(abs);
-    if (cached) return cached;
-    const promise = fs.access(abs).then(() => true, () => false);
-    this.existsCache.set(abs, promise);
-    return promise;
-  }
-  // ── Lifecycle ──
-  /** Release all cached data. Call after the scan completes. */
-  clear() {
-    this.walkCache.clear();
-    this.walkSummary.clear();
-    this.fileNameIndex.clear();
-    this.textCache.clear();
-    this.jsonCache.clear();
-    this.existsCache.clear();
-    this.sizeCache.clear();
-  }
-  /** Number of file content entries currently held */
-  get textCacheSize() {
-    return this.textCache.size;
-  }
-  /** Number of parsed JSON entries currently held */
-  get jsonCacheSize() {
-    return this.jsonCache.size;
-  }
-};
-async function quickTreeCount(rootDir, excludePatterns) {
-  const native = await quickTreeCountWithRipgrep(rootDir, excludePatterns);
-  if (native) return native;
-  let totalFiles = 0;
-  let totalDirs = 0;
-  const cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length || 4;
-  const maxConcurrent = Math.max(8, Math.min(128, cores * 8));
-  const sem = new Semaphore(maxConcurrent);
-  const extraSkip = EXTRA_SKIP_DIRS;
-  const isExcluded = excludePatterns ? compileGlobs(excludePatterns) : null;
-  async function count(dir) {
-    let entries;
-    try {
-      entries = await sem.run(() => fs.readdir(dir, { withFileTypes: true }));
-    } catch {
-      return;
-    }
-    const subs = [];
-    for (const e of entries) {
-      const relPath = path2.relative(rootDir, path2.join(dir, e.name));
-      if (isExcluded && isExcluded(relPath)) continue;
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name) || extraSkip.has(e.name)) continue;
-        totalDirs++;
-        subs.push(count(path2.join(dir, e.name)));
-      } else if (e.isFile()) {
-        const ext = path2.extname(e.name).toLowerCase();
-        if (!SKIP_EXTENSIONS.has(ext)) totalFiles++;
-      }
-    }
-    await Promise.all(subs);
-  }
-  await count(rootDir);
-  return { totalFiles, totalDirs };
-}
-function normalizeGlobForRipgrep(pattern) {
-  return pattern.replace(/\\/g, "/");
-}
-async function quickTreeCountWithRipgrep(rootDir, excludePatterns) {
-  const args = ["--files", "--hidden", "--no-ignore", "--null"];
-  for (const dir of SKIP_DIRS) {
-    args.push("-g", `!**/${dir}/**`);
-  }
-  for (const dir of EXTRA_SKIP_DIRS) {
-    args.push("-g", `!**/${dir}/**`);
-  }
-  for (const ext of SKIP_EXTENSIONS) {
-    args.push("-g", `!**/*${ext}`);
-  }
-  for (const pattern of excludePatterns ?? []) {
-    const trimmed = pattern.trim();
-    if (!trimmed) continue;
-    args.push("-g", `!${normalizeGlobForRipgrep(trimmed)}`);
-  }
-  try {
-    const { stdout } = await execFileAsync("rg", args, { cwd: rootDir, maxBuffer: 64 * 1024 * 1024, encoding: "utf8" });
-    if (!stdout) return { totalFiles: 0, totalDirs: 0 };
-    const files = stdout.split("\0").filter(Boolean);
-    const dirs = /* @__PURE__ */ new Set();
-    for (const file of files) {
-      const dir = path2.dirname(file);
-      if (dir && dir !== ".") dirs.add(dir);
-    }
-    return { totalFiles: files.length, totalDirs: dirs.size };
-  } catch {
-    return null;
-  }
-}
-async function countFilesInDir(dir, recursive = true) {
-  let count = 0;
-  const extraSkip = /* @__PURE__ */ new Set(["obj", "bin", "Debug", "Release", "TestResults"]);
-  async function walk(currentDir) {
-    let entries;
-    try {
-      entries = await fs.readdir(currentDir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    const subs = [];
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (!recursive) continue;
-        if (SKIP_DIRS.has(e.name) || extraSkip.has(e.name)) continue;
-        subs.push(walk(path2.join(currentDir, e.name)));
-      } else if (e.isFile()) {
-        const ext = path2.extname(e.name).toLowerCase();
-        if (!SKIP_EXTENSIONS.has(ext)) count++;
-      }
-    }
-    await Promise.all(subs);
-  }
-  await walk(dir);
-  return count;
-}
-async function bytesInDir(dir, recursive = true) {
-  let bytes = 0;
-  const extraSkip = /* @__PURE__ */ new Set(["obj", "bin", "Debug", "Release", "TestResults"]);
-  async function walk(currentDir) {
-    let entries;
-    try {
-      entries = await fs.readdir(currentDir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    const subs = [];
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (!recursive) continue;
-        if (SKIP_DIRS.has(e.name) || extraSkip.has(e.name)) continue;
-        subs.push(walk(path2.join(currentDir, e.name)));
-      } else if (e.isFile()) {
-        const ext = path2.extname(e.name).toLowerCase();
-        if (SKIP_EXTENSIONS.has(ext)) continue;
-        try {
-          const stat2 = await fs.stat(path2.join(currentDir, e.name));
-          bytes += stat2.size;
-        } catch {
-        }
-      }
-    }
-    await Promise.all(subs);
-  }
-  await walk(dir);
-  return bytes;
-}
-async function findFiles(rootDir, predicate) {
-  const results = [];
-  const cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length || 4;
-  const maxConcurrentReads = Math.max(8, Math.min(64, cores * 4));
-  const readDirSemaphore = new Semaphore(maxConcurrentReads);
-  async function walk(dir) {
-    let entries;
-    try {
-      entries = await readDirSemaphore.run(() => fs.readdir(dir, { withFileTypes: true }));
-    } catch {
-      return;
-    }
-    const subDirectoryWalks = [];
-    for (const e of entries) {
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name)) continue;
-        subDirectoryWalks.push(walk(path2.join(dir, e.name)));
-      } else if (e.isFile() && predicate(e.name)) {
-        const ext = path2.extname(e.name).toLowerCase();
-        if (!SKIP_EXTENSIONS.has(ext)) results.push(path2.join(dir, e.name));
-      }
-    }
-    await Promise.all(subDirectoryWalks);
-  }
-  await walk(rootDir);
-  return results;
-}
-async function findPackageJsonFiles(rootDir) {
-  return findFiles(rootDir, (name) => name === "package.json");
-}
-async function findSolutionFiles(rootDir) {
-  return findFiles(rootDir, (name) => name.endsWith(".sln"));
-}
-async function findCsprojFiles(rootDir) {
-  return findFiles(rootDir, (name) => name.endsWith(".csproj"));
-}
-function stripBom(text) {
-  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-}
-async function readJsonFile(filePath) {
-  const txt = await fs.readFile(filePath, "utf8");
-  return JSON.parse(stripBom(txt));
-}
-async function readTextFile(filePath) {
-  return fs.readFile(filePath, "utf8");
-}
-async function pathExists(p) {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureDir(dir) {
-  await fs.mkdir(dir, { recursive: true });
-}
-async function writeJsonFile(filePath, data) {
-  await ensureDir(path2.dirname(filePath));
-  await fs.writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf8");
-}
-async function writeTextFile(filePath, content) {
-  await ensureDir(path2.dirname(filePath));
-  await fs.writeFile(filePath, content, "utf8");
-}
-
-export {
-  Semaphore,
-  parseExcludePatterns,
-  FileCache,
-  quickTreeCount,
-  normalizeGlobForRipgrep,
-  countFilesInDir,
-  bytesInDir,
-  findFiles,
-  findPackageJsonFiles,
-  findSolutionFiles,
-  findCsprojFiles,
-  stripBom,
-  readJsonFile,
-  readTextFile,
-  pathExists,
-  ensureDir,
-  writeJsonFile,
-  writeTextFile
-};