@vibgrate/cli 2026.6.5 → 2026.6.5154714

package/dist/baseline-MJNJICDN.js

@@ -0,0 +1,12 @@
+import {
+  baselineCommand,
+  runBaseline
+} from "./chunk-734OP6JR.js";
+import "./chunk-K2D6JXLA.js";
+import "./chunk-74ZJFYEM.js";
+import "./chunk-HAT4W7NZ.js";
+import "./chunk-JSBRDJBE.js";
+export {
+  baselineCommand,
+  runBaseline
+};

package/dist/{chunk-42GW43JE.js → chunk-734OP6JR.js}

@@ -1,8 +1,11 @@
+import {
+  runScan
+} from "./chunk-K2D6JXLA.js";
+
 // src/commands/baseline.ts
 import * as path3 from "path";
 import { Command } from "commander";
 import chalk from "chalk";
-import { runScan } from "@vibgrate/core";
 
 // src/utils/fs.ts
 import { execFile } from "child_process";

package/dist/chunk-HAT4W7NZ.js

@@ -0,0 +1,678 @@
+// ../vibgrate-core/dist/chunk-JQHUH6A3.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 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",
+  ".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 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();
+  /** 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;
+  }
+  // ── 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.walkSummary.clear();
+    this.fileNameIndex.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) {
+  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 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,
+  normalizeGlobForRipgrep,
+  countFilesInDir,
+  findFiles,
+  findPackageJsonFiles,
+  findSolutionFiles,
+  findCsprojFiles,
+  readJsonFile,
+  readTextFile,
+  pathExists,
+  ensureDir,
+  writeJsonFile,
+  writeTextFile
+};