@vibgrate/cli 1.0.15 → 1.0.17

package/dist/{baseline-M445KUZ4.js → baseline-TJLWFSMH.js}

@@ -1,8 +1,8 @@
 import {
   baselineCommand,
   runBaseline
-} from "./chunk-OPEOSIRY.js";
-import "./chunk-QZV77UWV.js";
+} from "./chunk-XVGUFKAC.js";
+import "./chunk-EVLKMTYE.js";
 export {
   baselineCommand,
   runBaseline

package/dist/{chunk-QZV77UWV.js → chunk-EVLKMTYE.js}

@@ -23,7 +23,7 @@ var Semaphore = class {
       this.available--;
       return Promise.resolve();
     }
-    return new Promise((resolve6) => this.queue.push(resolve6));
+    return new Promise((resolve7) => this.queue.push(resolve7));
   }
   release() {
     const next = this.queue.shift();
@@ -50,6 +50,140 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "packages",
   "TestResults"
 ]);
+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();
+  // ── 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) {
+    const cached = this.walkCache.get(rootDir);
+    if (cached) return cached;
+    const promise = this._doWalk(rootDir);
+    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) {
+    const results = [];
+    const maxConcurrentReads = Math.max(8, Math.min(64, os.availableParallelism() * 4));
+    const sem = new Semaphore(maxConcurrentReads);
+    const extraSkip = _FileCache.EXTRA_SKIP;
+    async function walk(dir) {
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const subWalks = [];
+      for (const e of entries) {
+        const absPath = path.join(dir, e.name);
+        const relPath = path.relative(rootDir, absPath);
+        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(sem.run(() => walk(absPath)));
+        } else if (e.isFile()) {
+          results.push({ absPath, relPath, name: e.name, isFile: true, isDirectory: false });
+        }
+      }
+      await Promise.all(subWalks);
+    }
+    await sem.run(() => walk(rootDir));
+    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.
+   */
+  readTextFile(filePath) {
+    const abs = path.resolve(filePath);
+    const cached = this.textCache.get(abs);
+    if (cached) return cached;
+    const promise = fs.readFile(abs, "utf8").then((content) => {
+      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 = path.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 = path.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 findFiles(rootDir, predicate) {
   const results = [];
   const maxConcurrentReads = Math.max(8, Math.min(64, os.availableParallelism() * 4));
@@ -396,6 +530,9 @@ function formatText(artifact) {
       lines.push("");
     }
   }
+  if (artifact.extended?.architecture) {
+    lines.push(...formatArchitectureDiagram(artifact.extended.architecture));
+  }
   const scoreColor = artifact.drift.score >= 70 ? chalk.green : artifact.drift.score >= 40 ? chalk.yellow : chalk.red;
   lines.push(chalk.bold.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
   lines.push(chalk.bold.cyan("\u2551        Drift Score Summary               \u2551"));
@@ -585,9 +722,6 @@ function formatExtended(ext) {
       lines.push("");
     }
   }
-  if (ext.architecture) {
-    lines.push(...formatArchitectureDiagram(ext.architecture));
-  }
   return lines;
 }
 var LAYER_LABELS = {
@@ -1186,7 +1320,7 @@ function maxStable(versions) {
   return stable.sort(semver.rcompare)[0] ?? null;
 }
 async function npmViewJson(args, cwd) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = spawn("npm", ["view", ...args, "--json"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1203,13 +1337,13 @@ async function npmViewJson(args, cwd) {
       }
       const trimmed = out.trim();
       if (!trimmed) {
-        resolve6(null);
+        resolve7(null);
         return;
       }
       try {
-        resolve6(JSON.parse(trimmed));
+        resolve7(JSON.parse(trimmed));
       } catch {
-        resolve6(trimmed.replace(/^"|"$/g, ""));
+        resolve7(trimmed.replace(/^"|"$/g, ""));
       }
     });
   });
@@ -1345,12 +1479,12 @@ var KNOWN_FRAMEWORKS = {
   "storybook": "Storybook",
   "@storybook/react": "Storybook"
 };
-async function scanNodeProjects(rootDir, npmCache) {
-  const packageJsonFiles = await findPackageJsonFiles(rootDir);
+async function scanNodeProjects(rootDir, npmCache, cache) {
+  const packageJsonFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   const results = [];
   for (const pjPath of packageJsonFiles) {
     try {
-      const scan = await scanOnePackageJson(pjPath, rootDir, npmCache);
+      const scan = await scanOnePackageJson(pjPath, rootDir, npmCache, cache);
       results.push(scan);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -1359,8 +1493,8 @@ async function scanNodeProjects(rootDir, npmCache) {
   }
   return results;
 }
-async function scanOnePackageJson(packageJsonPath, rootDir, npmCache) {
-  const pj = await readJsonFile(packageJsonPath);
+async function scanOnePackageJson(packageJsonPath, rootDir, npmCache, cache) {
+  const pj = cache ? await cache.readJsonFile(packageJsonPath) : await readJsonFile(packageJsonPath);
   const absProjectPath = path4.dirname(packageJsonPath);
   const projectPath = path4.relative(rootDir, absProjectPath) || ".";
   const nodeEngine = pj.engines?.node ?? void 0;
@@ -1687,13 +1821,13 @@ function parseCsproj(xml, filePath) {
     projectName: path5.basename(filePath, ".csproj")
   };
 }
-async function scanDotnetProjects(rootDir) {
-  const csprojFiles = await findCsprojFiles(rootDir);
-  const slnFiles = await findSolutionFiles(rootDir);
+async function scanDotnetProjects(rootDir, cache) {
+  const csprojFiles = cache ? await cache.findCsprojFiles(rootDir) : await findCsprojFiles(rootDir);
+  const slnFiles = cache ? await cache.findSolutionFiles(rootDir) : await findSolutionFiles(rootDir);
   const slnCsprojPaths = /* @__PURE__ */ new Set();
   for (const slnPath of slnFiles) {
     try {
-      const slnContent = await readTextFile(slnPath);
+      const slnContent = cache ? await cache.readTextFile(slnPath) : await readTextFile(slnPath);
       const slnDir = path5.dirname(slnPath);
       const projectRegex = /Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+\.csproj)"/g;
       let match;
@@ -1710,7 +1844,7 @@ async function scanDotnetProjects(rootDir) {
   const results = [];
   for (const csprojPath of allCsprojFiles) {
     try {
-      const scan = await scanOneCsproj(csprojPath, rootDir);
+      const scan = await scanOneCsproj(csprojPath, rootDir, cache);
       results.push(scan);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -1719,8 +1853,8 @@ async function scanDotnetProjects(rootDir) {
   }
   return results;
 }
-async function scanOneCsproj(csprojPath, rootDir) {
-  const xml = await readTextFile(csprojPath);
+async function scanOneCsproj(csprojPath, rootDir, cache) {
+  const xml = cache ? await cache.readTextFile(csprojPath) : await readTextFile(csprojPath);
   const data = parseCsproj(xml, csprojPath);
   const primaryTfm = data.targetFrameworks[0];
   let runtimeMajorsBehind;
@@ -2328,7 +2462,7 @@ var OS_PATTERNS = [
   { pattern: /\bbash\b|#!\/bin\/bash/i, label: "bash-scripts" },
   { pattern: /\\\\/g, label: "backslash-paths" }
 ];
-async function scanPlatformMatrix(rootDir) {
+async function scanPlatformMatrix(rootDir, cache) {
   const result = {
     dotnetTargetFrameworks: [],
     nativeModules: [],
@@ -2336,12 +2470,12 @@ async function scanPlatformMatrix(rootDir) {
     dockerBaseImages: [],
     nodeVersionFiles: []
   };
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   const allDeps = /* @__PURE__ */ new Set();
   const osAssumptions = /* @__PURE__ */ new Set();
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       if (pj.engines?.node && !result.nodeEngines) result.nodeEngines = pj.engines.node;
       if (pj.engines?.npm && !result.npmEngines) result.npmEngines = pj.engines.npm;
       if (pj.engines?.pnpm && !result.pnpmEngines) {
@@ -2377,11 +2511,11 @@ async function scanPlatformMatrix(rootDir) {
   }
   result.nativeModules.sort();
   result.osAssumptions = [...osAssumptions].sort();
-  const csprojFiles = await findFiles(rootDir, (name) => name.endsWith(".csproj"));
+  const csprojFiles = cache ? await cache.findCsprojFiles(rootDir) : await findFiles(rootDir, (name) => name.endsWith(".csproj"));
   const tfms = /* @__PURE__ */ new Set();
   for (const csprojPath of csprojFiles) {
     try {
-      const xml = await readTextFile(csprojPath);
+      const xml = cache ? await cache.readTextFile(csprojPath) : await readTextFile(csprojPath);
       const tfMatch = xml.match(/<TargetFramework>(.*?)<\/TargetFramework>/);
       if (tfMatch?.[1]) tfms.add(tfMatch[1]);
       const tfsMatch = xml.match(/<TargetFrameworks>(.*?)<\/TargetFrameworks>/);
@@ -2394,14 +2528,17 @@ async function scanPlatformMatrix(rootDir) {
     }
   }
   result.dotnetTargetFrameworks = [...tfms].sort();
-  const dockerfiles = await findFiles(
+  const dockerfiles = cache ? await cache.findFiles(
+    rootDir,
+    (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
+  ) : await findFiles(
     rootDir,
     (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
   );
   const baseImages = /* @__PURE__ */ new Set();
   for (const df of dockerfiles) {
     try {
-      const content = await readTextFile(df);
+      const content = cache ? await cache.readTextFile(df) : await readTextFile(df);
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (/^FROM\s+/i.test(trimmed)) {
@@ -2419,7 +2556,8 @@ async function scanPlatformMatrix(rootDir) {
   }
   result.dockerBaseImages = [...baseImages].sort();
   for (const file of [".nvmrc", ".node-version", ".tool-versions"]) {
-    if (await pathExists(path8.join(rootDir, file))) {
+    const exists = cache ? await cache.pathExists(path8.join(rootDir, file)) : await pathExists(path8.join(rootDir, file));
+    if (exists) {
       result.nodeVersionFiles.push(file);
     }
   }
@@ -2545,7 +2683,7 @@ function parseYarnLock(content) {
   }
   return entries;
 }
-async function scanDependencyGraph(rootDir) {
+async function scanDependencyGraph(rootDir, cache) {
   const result = {
     lockfileType: null,
     totalUnique: 0,
@@ -2557,17 +2695,19 @@ async function scanDependencyGraph(rootDir) {
   const pnpmLock = path9.join(rootDir, "pnpm-lock.yaml");
   const npmLock = path9.join(rootDir, "package-lock.json");
   const yarnLock = path9.join(rootDir, "yarn.lock");
-  if (await pathExists(pnpmLock)) {
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
+  if (await _pathExists(pnpmLock)) {
     result.lockfileType = "pnpm";
-    const content = await readTextFile(pnpmLock);
+    const content = await _readTextFile(pnpmLock);
     entries = parsePnpmLock(content);
-  } else if (await pathExists(npmLock)) {
+  } else if (await _pathExists(npmLock)) {
     result.lockfileType = "npm";
-    const content = await readTextFile(npmLock);
+    const content = await _readTextFile(npmLock);
     entries = parseNpmLock(content);
-  } else if (await pathExists(yarnLock)) {
+  } else if (await _pathExists(yarnLock)) {
     result.lockfileType = "yarn";
-    const content = await readTextFile(yarnLock);
+    const content = await _readTextFile(yarnLock);
     entries = parseYarnLock(content);
   }
   if (entries.length === 0) return result;
@@ -2595,12 +2735,12 @@ async function scanDependencyGraph(rootDir) {
   duplicated.sort((a, b) => b.versions.length - a.versions.length || a.name.localeCompare(b.name));
   result.duplicatedPackages = duplicated;
   const lockedNames = new Set(versionMap.keys());
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   const phantoms = /* @__PURE__ */ new Set();
   const phantomDetails = [];
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       const relPath = path9.relative(rootDir, pjPath);
       for (const section of ["dependencies", "devDependencies"]) {
         const deps = pj[section];
@@ -2985,7 +3125,7 @@ var IAC_EXTENSIONS = {
   ".tf": "terraform",
   ".bicep": "bicep"
 };
-async function scanBuildDeploy(rootDir) {
+async function scanBuildDeploy(rootDir, cache) {
   const result = {
     ci: [],
     ciWorkflowCount: 0,
@@ -2995,26 +3135,37 @@ async function scanBuildDeploy(rootDir) {
     packageManagers: [],
     monorepoTools: []
   };
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _findFiles = cache ? (dir, pred) => cache.findFiles(dir, pred) : findFiles;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
   const ciSystems = /* @__PURE__ */ new Set();
   for (const [file, system] of Object.entries(CI_FILES)) {
     const fullPath = path10.join(rootDir, file);
-    if (await pathExists(fullPath)) {
+    if (await _pathExists(fullPath)) {
       ciSystems.add(system);
     }
   }
   const ghWorkflowDir = path10.join(rootDir, ".github", "workflows");
-  if (await pathExists(ghWorkflowDir)) {
+  if (await _pathExists(ghWorkflowDir)) {
     try {
-      const files = await findFiles(
-        ghWorkflowDir,
-        (name) => name.endsWith(".yml") || name.endsWith(".yaml")
-      );
-      result.ciWorkflowCount = files.length;
+      if (cache) {
+        const entries = await cache.walkDir(rootDir);
+        const ghPrefix = path10.relative(rootDir, ghWorkflowDir) + path10.sep;
+        result.ciWorkflowCount = entries.filter(
+          (e) => e.isFile && e.relPath.startsWith(ghPrefix) && (e.name.endsWith(".yml") || e.name.endsWith(".yaml"))
+        ).length;
+      } else {
+        const files = await _findFiles(
+          ghWorkflowDir,
+          (name) => name.endsWith(".yml") || name.endsWith(".yaml")
+        );
+        result.ciWorkflowCount = files.length;
+      }
     } catch {
     }
   }
   result.ci = [...ciSystems].sort();
-  const dockerfiles = await findFiles(
+  const dockerfiles = await _findFiles(
     rootDir,
     (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
   );
@@ -3022,7 +3173,7 @@ async function scanBuildDeploy(rootDir) {
   const baseImages = /* @__PURE__ */ new Set();
   for (const df of dockerfiles) {
     try {
-      const content = await readTextFile(df);
+      const content = await _readTextFile(df);
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (/^FROM\s+/i.test(trimmed)) {
@@ -3042,24 +3193,24 @@ async function scanBuildDeploy(rootDir) {
   result.docker.baseImages = [...baseImages].sort();
   const iacSystems = /* @__PURE__ */ new Set();
   for (const [ext, system] of Object.entries(IAC_EXTENSIONS)) {
-    const files = await findFiles(rootDir, (name) => name.endsWith(ext));
+    const files = await _findFiles(rootDir, (name) => name.endsWith(ext));
     if (files.length > 0) iacSystems.add(system);
   }
-  const cfnFiles = await findFiles(
+  const cfnFiles = await _findFiles(
     rootDir,
     (name) => name.endsWith(".cfn.json") || name.endsWith(".cfn.yaml")
   );
   if (cfnFiles.length > 0) iacSystems.add("cloudformation");
-  if (await pathExists(path10.join(rootDir, "Pulumi.yaml"))) iacSystems.add("pulumi");
+  if (await _pathExists(path10.join(rootDir, "Pulumi.yaml"))) iacSystems.add("pulumi");
   result.iac = [...iacSystems].sort();
   const releaseTools = /* @__PURE__ */ new Set();
   for (const [file, tool] of Object.entries(RELEASE_FILES)) {
-    if (await pathExists(path10.join(rootDir, file))) releaseTools.add(tool);
+    if (await _pathExists(path10.join(rootDir, file))) releaseTools.add(tool);
   }
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       for (const section of ["dependencies", "devDependencies"]) {
         const deps = pj[section];
         if (!deps) continue;
@@ -3079,12 +3230,12 @@ async function scanBuildDeploy(rootDir) {
   };
   const managers = /* @__PURE__ */ new Set();
   for (const [file, manager] of Object.entries(lockfileMap)) {
-    if (await pathExists(path10.join(rootDir, file))) managers.add(manager);
+    if (await _pathExists(path10.join(rootDir, file))) managers.add(manager);
   }
   result.packageManagers = [...managers].sort();
   const monoTools = /* @__PURE__ */ new Set();
   for (const [file, tool] of Object.entries(MONOREPO_FILES)) {
-    if (await pathExists(path10.join(rootDir, file))) monoTools.add(tool);
+    if (await _pathExists(path10.join(rootDir, file))) monoTools.add(tool);
   }
   result.monorepoTools = [...monoTools].sort();
   return result;
@@ -3092,7 +3243,7 @@ async function scanBuildDeploy(rootDir) {
 
 // src/scanners/ts-modernity.ts
 import * as path11 from "path";
-async function scanTsModernity(rootDir) {
+async function scanTsModernity(rootDir, cache) {
   const result = {
     typescriptVersion: null,
     strict: null,
@@ -3104,12 +3255,12 @@ async function scanTsModernity(rootDir) {
     moduleType: null,
     exportsField: false
   };
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   let hasEsm = false;
   let hasCjs = false;
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       if (!result.typescriptVersion) {
         const tsVer = pj.devDependencies?.["typescript"] ?? pj.dependencies?.["typescript"];
         if (tsVer) {
@@ -3130,8 +3281,9 @@ async function scanTsModernity(rootDir) {
   else if (hasEsm) result.moduleType = "esm";
   else if (hasCjs) result.moduleType = "cjs";
   let tsConfigPath = path11.join(rootDir, "tsconfig.json");
-  if (!await pathExists(tsConfigPath)) {
-    const tsConfigs = await findFiles(rootDir, (name) => name === "tsconfig.json");
+  const tsConfigExists = cache ? await cache.pathExists(tsConfigPath) : await pathExists(tsConfigPath);
+  if (!tsConfigExists) {
+    const tsConfigs = cache ? await cache.findFiles(rootDir, (name) => name === "tsconfig.json") : await findFiles(rootDir, (name) => name === "tsconfig.json");
     if (tsConfigs.length > 0) {
       tsConfigPath = tsConfigs[0];
     } else {
@@ -3139,7 +3291,7 @@ async function scanTsModernity(rootDir) {
     }
   }
   try {
-    const raw = await readTextFile(tsConfigPath);
+    const raw = cache ? await cache.readTextFile(tsConfigPath) : await readTextFile(tsConfigPath);
     const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
     const tsConfig = JSON.parse(stripped);
     const co = tsConfig?.compilerOptions;
@@ -3510,43 +3662,63 @@ var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
   ".mp4",
   ".webm"
 ]);
-async function scanFileHotspots(rootDir) {
+async function scanFileHotspots(rootDir, cache) {
   const extensionCounts = {};
   const allFiles = [];
   let maxDepth = 0;
-  async function walk(dir, depth) {
-    if (depth > maxDepth) maxDepth = depth;
-    let entries;
-    try {
-      const dirents = await fs4.readdir(dir, { withFileTypes: true });
-      entries = dirents.map((d) => ({
-        name: d.name,
-        isDirectory: d.isDirectory(),
-        isFile: d.isFile()
-      }));
-    } catch {
-      return;
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    for (const entry of entries) {
+      if (!entry.isFile) continue;
+      const ext = path12.extname(entry.name).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) continue;
+      const depth = entry.relPath.split(path12.sep).length - 1;
+      if (depth > maxDepth) maxDepth = depth;
+      extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
+      try {
+        const stat3 = await fs4.stat(entry.absPath);
+        allFiles.push({
+          path: entry.relPath,
+          bytes: stat3.size
+        });
+      } catch {
+      }
     }
-    for (const e of entries) {
-      if (e.isDirectory) {
-        if (SKIP_DIRS2.has(e.name)) continue;
-        await walk(path12.join(dir, e.name), depth + 1);
-      } else if (e.isFile) {
-        const ext = path12.extname(e.name).toLowerCase();
-        if (SKIP_EXTENSIONS.has(ext)) continue;
-        extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
-        try {
-          const stat3 = await fs4.stat(path12.join(dir, e.name));
-          allFiles.push({
-            path: path12.relative(rootDir, path12.join(dir, e.name)),
-            bytes: stat3.size
-          });
-        } catch {
+  } else {
+    async function walk(dir, depth) {
+      if (depth > maxDepth) maxDepth = depth;
+      let entries;
+      try {
+        const dirents = await fs4.readdir(dir, { withFileTypes: true });
+        entries = dirents.map((d) => ({
+          name: d.name,
+          isDirectory: d.isDirectory(),
+          isFile: d.isFile()
+        }));
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        if (e.isDirectory) {
+          if (SKIP_DIRS2.has(e.name)) continue;
+          await walk(path12.join(dir, e.name), depth + 1);
+        } else if (e.isFile) {
+          const ext = path12.extname(e.name).toLowerCase();
+          if (SKIP_EXTENSIONS.has(ext)) continue;
+          extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
+          try {
+            const stat3 = await fs4.stat(path12.join(dir, e.name));
+            allFiles.push({
+              path: path12.relative(rootDir, path12.join(dir, e.name)),
+              bytes: stat3.size
+            });
+          } catch {
+          }
         }
       }
     }
+    await walk(rootDir, 0);
   }
-  await walk(rootDir, 0);
   allFiles.sort((a, b) => b.bytes - a.bytes);
   const largestFiles = allFiles.slice(0, 20);
   return {
@@ -3568,7 +3740,7 @@ var LOCKFILES = {
   "bun.lockb": "bun",
   "packages.lock.json": "nuget"
 };
-async function scanSecurityPosture(rootDir) {
+async function scanSecurityPosture(rootDir, cache) {
   const result = {
     lockfilePresent: false,
     multipleLockfileTypes: false,
@@ -3577,9 +3749,11 @@ async function scanSecurityPosture(rootDir) {
     envFilesTracked: false,
     lockfileTypes: []
   };
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
   const foundLockfiles = [];
   for (const [file, type] of Object.entries(LOCKFILES)) {
-    if (await pathExists(path13.join(rootDir, file))) {
+    if (await _pathExists(path13.join(rootDir, file))) {
       foundLockfiles.push(type);
     }
   }
@@ -3587,9 +3761,9 @@ async function scanSecurityPosture(rootDir) {
   result.multipleLockfileTypes = foundLockfiles.length > 1;
   result.lockfileTypes = foundLockfiles.sort();
   const gitignorePath = path13.join(rootDir, ".gitignore");
-  if (await pathExists(gitignorePath)) {
+  if (await _pathExists(gitignorePath)) {
     try {
-      const content = await readTextFile(gitignorePath);
+      const content = await _readTextFile(gitignorePath);
       const lines = content.split("\n").map((l) => l.trim());
       result.gitignoreCoversEnv = lines.some(
         (line) => line === ".env" || line === ".env*" || line === ".env.*" || line === ".env.local" || line === "*.env"
@@ -3601,7 +3775,7 @@ async function scanSecurityPosture(rootDir) {
     }
   }
   for (const envFile of [".env", ".env.local", ".env.development", ".env.production"]) {
-    if (await pathExists(path13.join(rootDir, envFile))) {
+    if (await _pathExists(path13.join(rootDir, envFile))) {
       if (!result.gitignoreCoversEnv) {
         result.envFilesTracked = true;
         break;
@@ -4320,7 +4494,17 @@ var PACKAGE_LAYER_MAP = {
 };
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs", ".svelte", ".vue"]);
 var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", ".output", ".svelte-kit", "coverage", ".vibgrate"]);
-async function walkSourceFiles(rootDir) {
+async function walkSourceFiles(rootDir, cache) {
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    return entries.filter((e) => {
+      if (!e.isFile) return false;
+      const name = path14.basename(e.absPath);
+      if (name.startsWith(".") && name !== ".") return false;
+      const ext = path14.extname(name);
+      return SOURCE_EXTENSIONS.has(ext);
+    }).map((e) => e.relPath);
+  }
   const files = [];
   async function walk(dir) {
     let entries;
@@ -4446,9 +4630,9 @@ function mapToolingToLayers(tooling, services, depsByLayer) {
   }
   return { layerTooling, layerServices };
 }
-async function scanArchitecture(rootDir, projects, tooling, services) {
+async function scanArchitecture(rootDir, projects, tooling, services, cache) {
   const { archetype, confidence: archetypeConfidence } = detectArchetype(projects);
-  const sourceFiles = await walkSourceFiles(rootDir);
+  const sourceFiles = await walkSourceFiles(rootDir, cache);
   const classifications = [];
   let unclassified = 0;
   for (const file of sourceFiles) {
@@ -4553,6 +4737,7 @@ async function runScan(rootDir, opts) {
   const config = await loadConfig(rootDir);
   const sem = new Semaphore(opts.concurrency);
   const npmCache = new NpmCache(rootDir, sem);
+  const fileCache = new FileCache();
   const scanners = config.scanners;
   let filesScanned = 0;
   const progress = new ScanProgress(rootDir);
@@ -4584,7 +4769,7 @@ async function runScan(rootDir, opts) {
   const vcsDetail = vcs.type !== "unknown" ? `${vcs.type}${vcs.branch ? ` ${vcs.branch}` : ""}${vcs.shortSha ? ` @ ${vcs.shortSha}` : ""}` : "none detected";
   progress.completeStep("vcs", vcsDetail);
   progress.startStep("node");
-  const nodeProjects = await scanNodeProjects(rootDir, npmCache);
+  const nodeProjects = await scanNodeProjects(rootDir, npmCache, fileCache);
   for (const p of nodeProjects) {
     progress.addDependencies(p.dependencies.length);
     progress.addFrameworks(p.frameworks.length);
@@ -4593,7 +4778,7 @@ async function runScan(rootDir, opts) {
   progress.addProjects(nodeProjects.length);
   progress.completeStep("node", `${nodeProjects.length} project${nodeProjects.length !== 1 ? "s" : ""}`, nodeProjects.length);
   progress.startStep("dotnet");
-  const dotnetProjects = await scanDotnetProjects(rootDir);
+  const dotnetProjects = await scanDotnetProjects(rootDir, fileCache);
   for (const p of dotnetProjects) {
     progress.addDependencies(p.dependencies.length);
     progress.addFrameworks(p.frameworks.length);
@@ -4615,7 +4800,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.platformMatrix?.enabled !== false) {
       progress.startStep("platform");
       scannerTasks.push(
-        scanPlatformMatrix(rootDir).then((result) => {
+        scanPlatformMatrix(rootDir, fileCache).then((result) => {
           extended.platformMatrix = result;
           const nativeCount = result.nativeModules.length;
           const dockerCount = result.dockerBaseImages.length;
@@ -4664,7 +4849,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.securityPosture?.enabled !== false) {
       progress.startStep("security");
       scannerTasks.push(
-        scanSecurityPosture(rootDir).then((result) => {
+        scanSecurityPosture(rootDir, fileCache).then((result) => {
           extended.securityPosture = result;
           const secDetail = result.lockfilePresent ? `lockfile \u2714${result.gitignoreCoversEnv ? " \xB7 .env \u2714" : " \xB7 .env \u2716"}` : "no lockfile";
           progress.completeStep("security", secDetail);
@@ -4674,7 +4859,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.buildDeploy?.enabled !== false) {
       progress.startStep("build");
       scannerTasks.push(
-        scanBuildDeploy(rootDir).then((result) => {
+        scanBuildDeploy(rootDir, fileCache).then((result) => {
           extended.buildDeploy = result;
           const bdParts = [];
           if (result.ci.length > 0) bdParts.push(result.ci.join(", "));
@@ -4686,7 +4871,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.tsModernity?.enabled !== false) {
       progress.startStep("ts");
       scannerTasks.push(
-        scanTsModernity(rootDir).then((result) => {
+        scanTsModernity(rootDir, fileCache).then((result) => {
           extended.tsModernity = result;
           const tsParts = [];
           if (result.typescriptVersion) tsParts.push(`v${result.typescriptVersion}`);
@@ -4699,7 +4884,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.fileHotspots?.enabled !== false) {
       progress.startStep("hotspots");
       scannerTasks.push(
-        scanFileHotspots(rootDir).then((result) => {
+        scanFileHotspots(rootDir, fileCache).then((result) => {
           extended.fileHotspots = result;
           progress.completeStep("hotspots", `${result.totalFiles} files`, result.totalFiles);
         })
@@ -4708,7 +4893,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.dependencyGraph?.enabled !== false) {
       progress.startStep("depgraph");
       scannerTasks.push(
-        scanDependencyGraph(rootDir).then((result) => {
+        scanDependencyGraph(rootDir, fileCache).then((result) => {
           extended.dependencyGraph = result;
           const dgDetail = result.lockfileType ? `${result.lockfileType} \xB7 ${result.totalUnique} unique` : "no lockfile";
           progress.completeStep("depgraph", dgDetail, result.totalUnique);
@@ -4735,7 +4920,8 @@ async function runScan(rootDir, opts) {
         rootDir,
         allProjects,
         extended.toolingInventory,
-        extended.serviceDependencies
+        extended.serviceDependencies,
+        fileCache
       );
       const arch = extended.architecture;
       const layerCount = arch.layers.filter((l) => l.fileCount > 0).length;
@@ -4761,6 +4947,7 @@ async function runScan(rootDir, opts) {
   if (noteCount > 0) findingParts.push(`${noteCount} note${noteCount !== 1 ? "s" : ""}`);
   progress.completeStep("findings", findingParts.join(", ") || "none");
   progress.finish();
+  fileCache.clear();
   if (allProjects.length === 0) {
     console.log(chalk5.yellow("No projects found."));
   }

package/dist/{chunk-OPEOSIRY.js → chunk-XVGUFKAC.js}

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

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-VXZT34Y5.js";
 import {
   baselineCommand
-} from "./chunk-OPEOSIRY.js";
+} from "./chunk-XVGUFKAC.js";
 import {
   VERSION,
   dsnCommand,
@@ -15,7 +15,7 @@ import {
   readJsonFile,
   scanCommand,
   writeDefaultConfig
-} from "./chunk-QZV77UWV.js";
+} from "./chunk-EVLKMTYE.js";
 
 // src/cli.ts
 import { Command as Command4 } from "commander";
@@ -38,7 +38,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk.green("\u2714") + ` Created ${chalk.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import("./baseline-M445KUZ4.js");
+    const { runBaseline } = await import("./baseline-TJLWFSMH.js");
     await runBaseline(rootDir);
   }
   console.log("");

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   formatText,
   generateFindings,
   runScan
-} from "./chunk-QZV77UWV.js";
+} from "./chunk-EVLKMTYE.js";
 export {
   computeDriftScore,
   formatMarkdown,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibgrate/cli",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "CLI for measuring upgrade drift across Node & .NET projects",
   "type": "module",
   "bin": {