@vibgrate/cli 1.0.40 → 1.0.42

package/dist/baseline-FDWMBM2O.js

@@ -0,0 +1,10 @@
+import {
+  baselineCommand,
+  runBaseline
+} from "./chunk-LO66M6OC.js";
+import "./chunk-YFJC5JSQ.js";
+import "./chunk-RNVZIZNL.js";
+export {
+  baselineCommand,
+  runBaseline
+};

package/dist/{chunk-LBZR6G43.js → chunk-LO66M6OC.js}

@@ -1,7 +1,9 @@
 import {
-  runScan,
+  runScan
+} from "./chunk-YFJC5JSQ.js";
+import {
   writeJsonFile
-} from "./chunk-NU7IIHIG.js";
+} from "./chunk-RNVZIZNL.js";
 
 // src/commands/baseline.ts
 import * as path from "path";

package/dist/chunk-RNVZIZNL.js

@@ -0,0 +1,569 @@
+// src/utils/fs.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path2 from "path";
+
+// src/utils/semaphore.ts
+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++;
+  }
+};
+
+// src/utils/glob.ts
+import * as path from "path";
+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, "\\$&");
+}
+
+// src/utils/fs.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".vibgrate",
+  ".wrangler",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".cache",
+  "coverage",
+  "bin",
+  "obj",
+  ".vs",
+  "packages",
+  "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 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 (>60s) */
+  _stuckPaths = [];
+  /** Files skipped because they exceed maxFileSizeToScan */
+  _skippedLargeFiles = [];
+  /** Maximum file size (bytes) we will read. 0 = unlimited. */
+  _maxFileSize = 0;
+  /** Root dir for relative-path computation (set by the first walkDir call) */
+  _rootDir = null;
+  /** 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;
+  }
+  /** Record a path that timed out or was stuck during scanning */
+  addStuckPath(relPath) {
+    this._stuckPaths.push(relPath);
+  }
+  /** 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;
+  }
+  /** Additional dirs skipped only by the cached walk (framework outputs) */
+  static EXTRA_SKIP = /* @__PURE__ */ new Set([".nuxt", ".output", ".svelte-kit"]);
+  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 = 6e4;
+    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 });
+          const result = await Promise.race([
+            readPromise.then((e) => ({ ok: true, entries: e })),
+            new Promise(
+              (resolve2) => setTimeout(() => resolve2({ ok: false }), STUCK_TIMEOUT_MS)
+            )
+          ]);
+          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);
+    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) {
+    return this.findFiles(rootDir, (name) => name === "package.json");
+  }
+  async findCsprojFiles(rootDir) {
+    return this.findFiles(rootDir, (name) => name.endsWith(".csproj"));
+  }
+  async findSolutionFiles(rootDir) {
+    return this.findFiles(rootDir, (name) => name.endsWith(".sln"));
+  }
+  // ── 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(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.textCache.clear();
+    this.jsonCache.clear();
+    this.existsCache.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) {
+  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 = /* @__PURE__ */ new Set([".nuxt", ".output", ".svelte-kit"]);
+  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 };
+}
+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 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"));
+}
+async function readJsonFile(filePath) {
+  const txt = await fs.readFile(filePath, "utf8");
+  return JSON.parse(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,
+  FileCache,
+  quickTreeCount,
+  countFilesInDir,
+  findFiles,
+  findPackageJsonFiles,
+  findSolutionFiles,
+  findCsprojFiles,
+  readJsonFile,
+  readTextFile,
+  pathExists,
+  ensureDir,
+  writeJsonFile,
+  writeTextFile
+};