@vibgrate/cli 1.0.20 → 1.0.21

package/dist/{baseline-7KBX56UU.js → baseline-7WI3SI6H.js}

@@ -1,8 +1,8 @@
 import {
   baselineCommand,
   runBaseline
-} from "./chunk-YWBGG2KK.js";
-import "./chunk-T6WMUKLV.js";
+} from "./chunk-74QSNBZA.js";
+import "./chunk-L6R5WSCC.js";
 export {
   baselineCommand,
   runBaseline

package/dist/{chunk-YWBGG2KK.js → chunk-74QSNBZA.js}

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

package/dist/{chunk-VXZT34Y5.js → chunk-GN3IWKSY.js}

@@ -11,6 +11,7 @@ function formatMarkdown(artifact) {
   const scannedMeta = [artifact.timestamp];
   if (artifact.durationMs !== void 0) scannedMeta.push(`${(artifact.durationMs / 1e3).toFixed(1)}s`);
   if (artifact.filesScanned !== void 0) scannedMeta.push(`${artifact.filesScanned} files`);
+  if (artifact.treeSummary) scannedMeta.push(`${artifact.treeSummary.totalFiles.toLocaleString()} workspace files \xB7 ${artifact.treeSummary.totalDirs.toLocaleString()} dirs`);
   lines.push(`| **Scanned** | ${scannedMeta.join(" \xB7 ")} |`);
   if (artifact.vcs) {
     lines.push(`| **VCS** | ${artifact.vcs.type} |`);

package/dist/{chunk-T6WMUKLV.js → chunk-L6R5WSCC.js}

@@ -69,19 +69,22 @@ var FileCache = class _FileCache {
    * Consumers that need additional filtering (e.g. SOURCE_EXTENSIONS,
    * SKIP_EXTENSIONS) do so on the returned entries — no separate walk.
    */
-  walkDir(rootDir) {
+  walkDir(rootDir, onProgress) {
     const cached = this.walkCache.get(rootDir);
     if (cached) return cached;
-    const promise = this._doWalk(rootDir);
+    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) {
+  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 extraSkip = _FileCache.EXTRA_SKIP;
     async function walk(dir) {
@@ -101,11 +104,19 @@ var FileCache = class _FileCache {
           subWalks.push(sem.run(() => walk(absPath)));
         } else if (e.isFile()) {
           results.push({ absPath, relPath, name: e.name, isFile: true, isDirectory: false });
+          foundCount++;
+          if (onProgress && foundCount - lastReported >= REPORT_INTERVAL) {
+            lastReported = foundCount;
+            onProgress(foundCount);
+          }
         }
       }
       await Promise.all(subWalks);
     }
     await sem.run(() => walk(rootDir));
+    if (onProgress && foundCount !== lastReported) {
+      onProgress(foundCount);
+    }
     return results;
   }
   /**
@@ -185,6 +196,35 @@ var FileCache = class _FileCache {
     return this.jsonCache.size;
   }
 };
+async function quickTreeCount(rootDir) {
+  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"]);
+  async function count(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const subs = [];
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name) || extraSkip.has(e.name)) continue;
+        totalDirs++;
+        subs.push(sem.run(() => count(path.join(dir, e.name))));
+      } else if (e.isFile()) {
+        totalFiles++;
+      }
+    }
+    await Promise.all(subs);
+  }
+  await sem.run(() => count(rootDir));
+  return { totalFiles, totalDirs };
+}
 async function findFiles(rootDir, predicate) {
   const results = [];
   const cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length || 4;
@@ -323,12 +363,12 @@ function eolScore(projects) {
 }
 function computeDriftScore(projects) {
   const rs = runtimeScore(projects);
-  const fs6 = frameworkScore(projects);
+  const fs7 = frameworkScore(projects);
   const ds = dependencyScore(projects);
   const es = eolScore(projects);
   const components = [
     { score: rs, weight: 0.25 },
-    { score: fs6, weight: 0.25 },
+    { score: fs7, weight: 0.25 },
     { score: ds, weight: 0.3 },
     { score: es, weight: 0.2 }
   ];
@@ -339,7 +379,7 @@ function computeDriftScore(projects) {
       riskLevel: "low",
       components: {
         runtimeScore: Math.round(rs ?? 100),
-        frameworkScore: Math.round(fs6 ?? 100),
+        frameworkScore: Math.round(fs7 ?? 100),
         dependencyScore: Math.round(ds ?? 100),
         eolScore: Math.round(es ?? 100)
       }
@@ -357,7 +397,7 @@ function computeDriftScore(projects) {
   else riskLevel = "high";
   const measured = [];
   if (rs !== null) measured.push("runtime");
-  if (fs6 !== null) measured.push("framework");
+  if (fs7 !== null) measured.push("framework");
   if (ds !== null) measured.push("dependency");
   if (es !== null) measured.push("eol");
   return {
@@ -365,7 +405,7 @@ function computeDriftScore(projects) {
     riskLevel,
     components: {
       runtimeScore: Math.round(rs ?? 100),
-      frameworkScore: Math.round(fs6 ?? 100),
+      frameworkScore: Math.round(fs7 ?? 100),
       dependencyScore: Math.round(ds ?? 100),
       eolScore: Math.round(es ?? 100)
     },
@@ -565,6 +605,10 @@ function formatText(artifact) {
   if (artifact.filesScanned !== void 0) {
     scannedParts.push(`${artifact.filesScanned} file${artifact.filesScanned !== 1 ? "s" : ""} scanned`);
   }
+  if (artifact.treeSummary) {
+    scannedParts.push(`${artifact.treeSummary.totalFiles.toLocaleString()} workspace files`);
+    scannedParts.push(`${artifact.treeSummary.totalDirs.toLocaleString()} dirs`);
+  }
   lines.push(chalk.dim(`  ${scannedParts.join(" \xB7 ")}`));
   lines.push("");
   return lines.join("\n");
@@ -1302,7 +1346,7 @@ var pushCommand = new Command2("push").description("Push scan results to Vibgrat
 });
 
 // src/commands/scan.ts
-import * as path15 from "path";
+import * as path16 from "path";
 import { Command as Command3 } from "commander";
 import chalk5 from "chalk";
 
@@ -2079,26 +2123,49 @@ var ScanProgress = class {
   startTime = Date.now();
   isTTY;
   rootDir = "";
+  /** Estimated total scan duration in ms (from history or live calculation) */
+  estimatedTotalMs = null;
+  /** Per-step estimated durations from history */
+  stepEstimates = /* @__PURE__ */ new Map();
+  /** Per-step actual start times for timing */
+  stepStartTimes = /* @__PURE__ */ new Map();
+  /** Per-step recorded durations (completed steps) */
+  stepTimings = [];
   constructor(rootDir) {
     this.isTTY = process.stderr.isTTY ?? false;
     this.rootDir = rootDir;
   }
-  /** Register all steps up front */
+  /** Set the estimated total duration from scan history */
+  setEstimatedTotal(estimatedMs) {
+    this.estimatedTotalMs = estimatedMs;
+  }
+  /** Set per-step estimated durations from scan history */
+  setStepEstimates(estimates) {
+    this.stepEstimates = estimates;
+  }
+  /** Get completed step timings for persisting to history */
+  getStepTimings() {
+    return [...this.stepTimings];
+  }
+  /** Register all steps up front, optionally with weights */
   setSteps(steps) {
-    this.steps = steps.map((s) => ({ ...s, status: "pending" }));
+    this.steps = steps.map((s) => ({ ...s, status: "pending", weight: s.weight ?? 1 }));
     if (this.isTTY) {
       this.startSpinner();
     }
     this.render();
   }
-  /** Mark a step as active (currently running) */
-  startStep(id) {
+  /** Mark a step as active (currently running), optionally with expected total */
+  startStep(id, subTotal) {
     const step = this.steps.find((s) => s.id === id);
     if (step) {
       step.status = "active";
       step.detail = void 0;
       step.count = void 0;
+      step.subProgress = 0;
+      step.subTotal = subTotal;
     }
+    this.stepStartTimes.set(id, Date.now());
     this.render();
   }
   /** Mark a step as completed */
@@ -2109,6 +2176,10 @@ var ScanProgress = class {
       step.detail = detail;
       step.count = count;
     }
+    const started = this.stepStartTimes.get(id);
+    if (started) {
+      this.stepTimings.push({ id, durationMs: Date.now() - started });
+    }
     this.render();
   }
   /** Mark a step as skipped */
@@ -2120,6 +2191,15 @@ var ScanProgress = class {
     }
     this.render();
   }
+  /** Update sub-step progress for the active step (files processed, etc.) */
+  updateStepProgress(id, current, total) {
+    const step = this.steps.find((s) => s.id === id);
+    if (step) {
+      step.subProgress = current;
+      if (total !== void 0) step.subTotal = total;
+    }
+    this.render();
+  }
   /** Update live stats */
   updateStats(partial) {
     Object.assign(this.stats, partial);
@@ -2153,10 +2233,10 @@ var ScanProgress = class {
     if (this.isTTY) {
       this.clearLines();
     }
-    const elapsed = ((Date.now() - this.startTime) / 1e3).toFixed(1);
+    const elapsed = this.formatElapsed(Date.now() - this.startTime);
     const doneCount = this.steps.filter((s) => s.status === "done").length;
     process.stderr.write(
-      chalk4.dim(`  \u2714 ${doneCount} scanners completed in ${elapsed}s
+      chalk4.dim(`  \u2714 ${doneCount} scanners completed in ${elapsed}
 
 `)
     );
@@ -2190,14 +2270,32 @@ var ScanProgress = class {
     lines.push(`  ${ROBOT[2]}`);
     lines.push(`  ${ROBOT[3]}  ${chalk4.dim(this.rootDir)}`);
     lines.push("");
-    const totalSteps = this.steps.length;
-    const doneSteps = this.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
-    const pct = totalSteps > 0 ? Math.round(doneSteps / totalSteps * 100) : 0;
+    const totalWeight = this.steps.reduce((sum, s) => sum + (s.weight ?? 1), 0);
+    let completedWeight = 0;
+    for (const step of this.steps) {
+      const w = step.weight ?? 1;
+      if (step.status === "done" || step.status === "skipped") {
+        completedWeight += w;
+      } else if (step.status === "active" && step.subTotal && step.subTotal > 0 && step.subProgress !== void 0) {
+        completedWeight += w * Math.min(step.subProgress / step.subTotal, 0.99);
+      } else if (step.status === "active") {
+        const stepStart = this.stepStartTimes.get(step.id);
+        const estimate = this.stepEstimates.get(step.id);
+        if (stepStart && estimate && estimate > 0) {
+          const stepElapsed = Date.now() - stepStart;
+          completedWeight += w * Math.min(stepElapsed / estimate, 0.95);
+        }
+      }
+    }
+    const pct = totalWeight > 0 ? Math.min(Math.round(completedWeight / totalWeight * 100), 99) : 0;
     const barWidth = 30;
-    const filled = Math.round(doneSteps / Math.max(totalSteps, 1) * barWidth);
-    const bar = chalk4.greenBright("\u2501".repeat(filled)) + chalk4.dim("\u254C".repeat(barWidth - filled));
-    const elapsed = ((Date.now() - this.startTime) / 1e3).toFixed(1);
-    lines.push(`  ${bar} ${chalk4.bold.white(`${pct}%`)} ${chalk4.dim(`${elapsed}s`)}`);
+    const filled = Math.round(completedWeight / Math.max(totalWeight, 1) * barWidth);
+    const bar = chalk4.greenBright("\u2501".repeat(Math.min(filled, barWidth))) + chalk4.dim("\u254C".repeat(Math.max(barWidth - filled, 0)));
+    const elapsedMs = Date.now() - this.startTime;
+    const elapsedStr = this.formatElapsed(elapsedMs);
+    const etaStr = this.computeEtaString(elapsedMs, completedWeight, totalWeight);
+    const treePart = this.stats.treeSummary ? chalk4.dim(` \xB7 ${this.stats.treeSummary.totalFiles.toLocaleString()} files \xB7 ${this.stats.treeSummary.totalDirs.toLocaleString()} dirs`) : "";
+    lines.push(`  ${bar} ${chalk4.bold.white(`${pct}%`)} ${chalk4.dim(elapsedStr)}${etaStr}${treePart}`);
     lines.push("");
     for (const step of this.steps) {
       lines.push(this.renderStep(step));
@@ -2222,6 +2320,9 @@ var ScanProgress = class {
       case "active":
         icon = chalk4.cyan(spinner);
         label = chalk4.bold.white(step.label);
+        if (step.subTotal && step.subTotal > 0 && step.subProgress !== void 0 && step.subProgress > 0) {
+          detail = chalk4.dim(` \xB7 ${step.subProgress.toLocaleString()} / ${step.subTotal.toLocaleString()}`);
+        }
         break;
       case "skipped":
         icon = chalk4.dim("\u25CC");
@@ -2275,10 +2376,141 @@ var ScanProgress = class {
       }
     }
   }
+  // ── Time formatting helpers ──
+  /**
+   * Format elapsed time:
+   * - Under 90s → "12.3s"
+   * - 90s and above → "1m 30s"
+   */
+  formatElapsed(ms) {
+    const totalSecs = ms / 1e3;
+    if (totalSecs < 90) {
+      return `${totalSecs.toFixed(1)}s`;
+    }
+    const mins = Math.floor(totalSecs / 60);
+    const secs = Math.floor(totalSecs % 60);
+    return `${mins}m ${secs.toString().padStart(2, "0")}s`;
+  }
+  /**
+   * Compute an ETA string for the progress bar.
+   *
+   * Uses two sources blended together:
+   * 1. **Historical estimate** from `estimatedTotalMs` (if available)
+   * 2. **Live rate** — extrapolated from `elapsedMs` and `completedWeight`
+   *
+   * Returns empty string if not enough data yet (< 3% progress or < 2s elapsed).
+   */
+  computeEtaString(elapsedMs, completedWeight, totalWeight) {
+    if (totalWeight === 0 || elapsedMs < 2e3) return "";
+    const fraction = completedWeight / totalWeight;
+    if (fraction < 0.03) {
+      if (this.estimatedTotalMs !== null && this.estimatedTotalMs > 0) {
+        const remaining = Math.max(0, this.estimatedTotalMs - elapsedMs);
+        if (remaining > 1e3) {
+          return chalk4.dim(` \xB7 ~${this.formatElapsed(remaining)} left`);
+        }
+      }
+      return "";
+    }
+    const liveRemaining = elapsedMs / fraction * (1 - fraction);
+    let remainingMs;
+    if (this.estimatedTotalMs !== null && this.estimatedTotalMs > 0) {
+      const histRemaining = Math.max(0, this.estimatedTotalMs - elapsedMs);
+      const histWeight = Math.max(0.1, 1 - fraction);
+      remainingMs = histRemaining * histWeight + liveRemaining * (1 - histWeight);
+    } else {
+      remainingMs = liveRemaining;
+    }
+    if (remainingMs < 1500) return "";
+    return chalk4.dim(` \xB7 ~${this.formatElapsed(remainingMs)} left`);
+  }
 };
 
-// src/scanners/platform-matrix.ts
+// src/ui/scan-history.ts
+import * as fs4 from "fs/promises";
 import * as path8 from "path";
+var HISTORY_FILENAME = "scan_history.json";
+var MAX_RECORDS = 10;
+async function loadScanHistory(rootDir) {
+  const filePath = path8.join(rootDir, ".vibgrate", HISTORY_FILENAME);
+  try {
+    const txt = await fs4.readFile(filePath, "utf8");
+    const data = JSON.parse(txt);
+    if (data.version === 1 && Array.isArray(data.records)) {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveScanHistory(rootDir, record) {
+  const dir = path8.join(rootDir, ".vibgrate");
+  const filePath = path8.join(dir, HISTORY_FILENAME);
+  let history;
+  const existing = await loadScanHistory(rootDir);
+  if (existing) {
+    history = existing;
+    history.records.push(record);
+    if (history.records.length > MAX_RECORDS) {
+      history.records = history.records.slice(-MAX_RECORDS);
+    }
+  } else {
+    history = { version: 1, records: [record] };
+  }
+  try {
+    await fs4.mkdir(dir, { recursive: true });
+    await fs4.writeFile(filePath, JSON.stringify(history, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+function estimateTotalDuration(history, currentFileCount) {
+  if (!history || history.records.length === 0) return null;
+  const similar = history.records.filter((r) => {
+    if (r.totalFiles === 0 || currentFileCount === 0) return false;
+    const ratio = currentFileCount / r.totalFiles;
+    return ratio >= 0.33 && ratio <= 3;
+  });
+  if (similar.length > 0) {
+    let weightedSum = 0;
+    let weightTotal = 0;
+    for (let i = 0; i < similar.length; i++) {
+      const rec = similar[i];
+      const weight = i + 1;
+      const scale = currentFileCount / rec.totalFiles;
+      weightedSum += rec.totalDurationMs * scale * weight;
+      weightTotal += weight;
+    }
+    return Math.round(weightedSum / weightTotal);
+  }
+  const last = history.records[history.records.length - 1];
+  if (last.totalFiles > 0 && currentFileCount > 0) {
+    const scale = currentFileCount / last.totalFiles;
+    return Math.round(last.totalDurationMs * scale);
+  }
+  return last.totalDurationMs;
+}
+function estimateStepDurations(history, currentFileCount) {
+  const result = /* @__PURE__ */ new Map();
+  if (!history || history.records.length === 0) return result;
+  let best = null;
+  for (let i = history.records.length - 1; i >= 0; i--) {
+    const rec = history.records[i];
+    if (rec.steps.length > 0) {
+      best = rec;
+      break;
+    }
+  }
+  if (!best) return result;
+  const scale = best.totalFiles > 0 && currentFileCount > 0 ? currentFileCount / best.totalFiles : 1;
+  for (const step of best.steps) {
+    result.set(step.id, Math.round(step.durationMs * scale));
+  }
+  return result;
+}
+
+// src/scanners/platform-matrix.ts
+import * as path9 from "path";
 var NATIVE_MODULE_PACKAGES = /* @__PURE__ */ new Set([
   // Image / media processing
   "sharp",
@@ -2558,7 +2790,7 @@ async function scanPlatformMatrix(rootDir, cache) {
   }
   result.dockerBaseImages = [...baseImages].sort();
   for (const file of [".nvmrc", ".node-version", ".tool-versions"]) {
-    const exists = cache ? await cache.pathExists(path8.join(rootDir, file)) : await pathExists(path8.join(rootDir, file));
+    const exists = cache ? await cache.pathExists(path9.join(rootDir, file)) : await pathExists(path9.join(rootDir, file));
     if (exists) {
       result.nodeVersionFiles.push(file);
     }
@@ -2635,7 +2867,7 @@ function scanDependencyRisk(projects) {
 }
 
 // src/scanners/dependency-graph.ts
-import * as path9 from "path";
+import * as path10 from "path";
 function parsePnpmLock(content) {
   const entries = [];
   const regex = /^\s+\/?(@?[^@\s][^@\s]*?)@(\d+\.\d+\.\d+[^:\s]*)\s*:/gm;
@@ -2694,9 +2926,9 @@ async function scanDependencyGraph(rootDir, cache) {
     phantomDependencies: []
   };
   let entries = [];
-  const pnpmLock = path9.join(rootDir, "pnpm-lock.yaml");
-  const npmLock = path9.join(rootDir, "package-lock.json");
-  const yarnLock = path9.join(rootDir, "yarn.lock");
+  const pnpmLock = path10.join(rootDir, "pnpm-lock.yaml");
+  const npmLock = path10.join(rootDir, "package-lock.json");
+  const yarnLock = path10.join(rootDir, "yarn.lock");
   const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
   const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
   if (await _pathExists(pnpmLock)) {
@@ -2743,7 +2975,7 @@ async function scanDependencyGraph(rootDir, cache) {
   for (const pjPath of pkgFiles) {
     try {
       const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
-      const relPath = path9.relative(rootDir, pjPath);
+      const relPath = path10.relative(rootDir, pjPath);
       for (const section of ["dependencies", "devDependencies"]) {
         const deps = pj[section];
         if (!deps) continue;
@@ -3089,7 +3321,7 @@ function scanToolingInventory(projects) {
 }
 
 // src/scanners/build-deploy.ts
-import * as path10 from "path";
+import * as path11 from "path";
 var CI_FILES = {
   ".github/workflows": "github-actions",
   ".gitlab-ci.yml": "gitlab-ci",
@@ -3142,17 +3374,17 @@ async function scanBuildDeploy(rootDir, cache) {
   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);
+    const fullPath = path11.join(rootDir, file);
     if (await _pathExists(fullPath)) {
       ciSystems.add(system);
     }
   }
-  const ghWorkflowDir = path10.join(rootDir, ".github", "workflows");
+  const ghWorkflowDir = path11.join(rootDir, ".github", "workflows");
   if (await _pathExists(ghWorkflowDir)) {
     try {
       if (cache) {
         const entries = await cache.walkDir(rootDir);
-        const ghPrefix = path10.relative(rootDir, ghWorkflowDir) + path10.sep;
+        const ghPrefix = path11.relative(rootDir, ghWorkflowDir) + path11.sep;
         result.ciWorkflowCount = entries.filter(
           (e) => e.isFile && e.relPath.startsWith(ghPrefix) && (e.name.endsWith(".yml") || e.name.endsWith(".yaml"))
         ).length;
@@ -3203,11 +3435,11 @@ async function scanBuildDeploy(rootDir, cache) {
     (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(path11.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(path11.join(rootDir, file))) releaseTools.add(tool);
   }
   const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   for (const pjPath of pkgFiles) {
@@ -3232,19 +3464,19 @@ async function scanBuildDeploy(rootDir, cache) {
   };
   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(path11.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(path11.join(rootDir, file))) monoTools.add(tool);
   }
   result.monorepoTools = [...monoTools].sort();
   return result;
 }
 
 // src/scanners/ts-modernity.ts
-import * as path11 from "path";
+import * as path12 from "path";
 async function scanTsModernity(rootDir, cache) {
   const result = {
     typescriptVersion: null,
@@ -3282,7 +3514,7 @@ async function scanTsModernity(rootDir, cache) {
   if (hasEsm && hasCjs) result.moduleType = "mixed";
   else if (hasEsm) result.moduleType = "esm";
   else if (hasCjs) result.moduleType = "cjs";
-  let tsConfigPath = path11.join(rootDir, "tsconfig.json");
+  let tsConfigPath = path12.join(rootDir, "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");
@@ -3628,8 +3860,8 @@ function scanBreakingChangeExposure(projects) {
 }
 
 // src/scanners/file-hotspots.ts
-import * as fs4 from "fs/promises";
-import * as path12 from "path";
+import * as fs5 from "fs/promises";
+import * as path13 from "path";
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -3672,13 +3904,13 @@ async function scanFileHotspots(rootDir, cache) {
     const entries = await cache.walkDir(rootDir);
     for (const entry of entries) {
       if (!entry.isFile) continue;
-      const ext = path12.extname(entry.name).toLowerCase();
+      const ext = path13.extname(entry.name).toLowerCase();
       if (SKIP_EXTENSIONS.has(ext)) continue;
-      const depth = entry.relPath.split(path12.sep).length - 1;
+      const depth = entry.relPath.split(path13.sep).length - 1;
       if (depth > maxDepth) maxDepth = depth;
       extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
       try {
-        const stat3 = await fs4.stat(entry.absPath);
+        const stat3 = await fs5.stat(entry.absPath);
         allFiles.push({
           path: entry.relPath,
           bytes: stat3.size
@@ -3691,7 +3923,7 @@ async function scanFileHotspots(rootDir, cache) {
       if (depth > maxDepth) maxDepth = depth;
       let entries;
       try {
-        const dirents = await fs4.readdir(dir, { withFileTypes: true });
+        const dirents = await fs5.readdir(dir, { withFileTypes: true });
         entries = dirents.map((d) => ({
           name: d.name,
           isDirectory: d.isDirectory(),
@@ -3703,15 +3935,15 @@ async function scanFileHotspots(rootDir, cache) {
       for (const e of entries) {
         if (e.isDirectory) {
           if (SKIP_DIRS2.has(e.name)) continue;
-          await walk(path12.join(dir, e.name), depth + 1);
+          await walk(path13.join(dir, e.name), depth + 1);
         } else if (e.isFile) {
-          const ext = path12.extname(e.name).toLowerCase();
+          const ext = path13.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));
+            const stat3 = await fs5.stat(path13.join(dir, e.name));
             allFiles.push({
-              path: path12.relative(rootDir, path12.join(dir, e.name)),
+              path: path13.relative(rootDir, path13.join(dir, e.name)),
               bytes: stat3.size
             });
           } catch {
@@ -3734,7 +3966,7 @@ async function scanFileHotspots(rootDir, cache) {
 }
 
 // src/scanners/security-posture.ts
-import * as path13 from "path";
+import * as path14 from "path";
 var LOCKFILES = {
   "pnpm-lock.yaml": "pnpm",
   "package-lock.json": "npm",
@@ -3755,14 +3987,14 @@ async function scanSecurityPosture(rootDir, cache) {
   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(path14.join(rootDir, file))) {
       foundLockfiles.push(type);
     }
   }
   result.lockfilePresent = foundLockfiles.length > 0;
   result.multipleLockfileTypes = foundLockfiles.length > 1;
   result.lockfileTypes = foundLockfiles.sort();
-  const gitignorePath = path13.join(rootDir, ".gitignore");
+  const gitignorePath = path14.join(rootDir, ".gitignore");
   if (await _pathExists(gitignorePath)) {
     try {
       const content = await _readTextFile(gitignorePath);
@@ -3777,7 +4009,7 @@ async function scanSecurityPosture(rootDir, cache) {
     }
   }
   for (const envFile of [".env", ".env.local", ".env.development", ".env.production"]) {
-    if (await _pathExists(path13.join(rootDir, envFile))) {
+    if (await _pathExists(path14.join(rootDir, envFile))) {
       if (!result.gitignoreCoversEnv) {
         result.envFilesTracked = true;
         break;
@@ -4202,8 +4434,8 @@ function scanServiceDependencies(projects) {
 }
 
 // src/scanners/architecture.ts
-import * as path14 from "path";
-import * as fs5 from "fs/promises";
+import * as path15 from "path";
+import * as fs6 from "fs/promises";
 var ARCHETYPE_SIGNALS = [
   // Meta-frameworks (highest priority — they imply routing patterns)
   { packages: ["next", "@next/core"], archetype: "nextjs", weight: 10 },
@@ -4501,9 +4733,9 @@ async function walkSourceFiles(rootDir, cache) {
     const entries = await cache.walkDir(rootDir);
     return entries.filter((e) => {
       if (!e.isFile) return false;
-      const name = path14.basename(e.absPath);
+      const name = path15.basename(e.absPath);
       if (name.startsWith(".") && name !== ".") return false;
-      const ext = path14.extname(name);
+      const ext = path15.extname(name);
       return SOURCE_EXTENSIONS.has(ext);
     }).map((e) => e.relPath);
   }
@@ -4511,21 +4743,21 @@ async function walkSourceFiles(rootDir, cache) {
   async function walk(dir) {
     let entries;
     try {
-      entries = await fs5.readdir(dir, { withFileTypes: true });
+      entries = await fs6.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".") continue;
-      const fullPath = path14.join(dir, entry.name);
+      const fullPath = path15.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!IGNORE_DIRS.has(entry.name)) {
           await walk(fullPath);
         }
       } else if (entry.isFile()) {
-        const ext = path14.extname(entry.name);
+        const ext = path15.extname(entry.name);
         if (SOURCE_EXTENSIONS.has(ext)) {
-          files.push(path14.relative(rootDir, fullPath));
+          files.push(path15.relative(rootDir, fullPath));
         }
       }
     }
@@ -4549,7 +4781,7 @@ function classifyFile(filePath, archetype) {
     }
   }
   if (!bestMatch || bestMatch.confidence < 0.7) {
-    const baseName = path14.basename(filePath, path14.extname(filePath));
+    const baseName = path15.basename(filePath, path15.extname(filePath));
     const cleanBase = baseName.replace(/\.(test|spec)$/, "");
     for (const rule of SUFFIX_RULES) {
       if (cleanBase.endsWith(rule.suffix)) {
@@ -4745,9 +4977,11 @@ async function runScan(rootDir, opts) {
   const progress = new ScanProgress(rootDir);
   const steps = [
     { id: "config", label: "Loading configuration" },
+    { id: "discovery", label: "Discovering workspace", weight: 3 },
     { id: "vcs", label: "Detecting version control" },
-    { id: "node", label: "Scanning Node projects" },
-    { id: "dotnet", label: "Scanning .NET projects" },
+    { id: "walk", label: "Indexing files", weight: 8 },
+    { id: "node", label: "Scanning Node projects", weight: 4 },
+    { id: "dotnet", label: "Scanning .NET projects", weight: 2 },
     ...scanners !== false ? [
       ...scanners?.platformMatrix?.enabled !== false ? [{ id: "platform", label: "Platform matrix" }] : [],
       ...scanners?.toolingInventory?.enabled !== false ? [{ id: "tooling", label: "Tooling inventory" }] : [],
@@ -4766,10 +5000,26 @@ async function runScan(rootDir, opts) {
   ];
   progress.setSteps(steps);
   progress.completeStep("config", "loaded");
+  progress.startStep("discovery");
+  const treeCount = await quickTreeCount(rootDir);
+  progress.updateStats({ treeSummary: treeCount });
+  progress.completeStep(
+    "discovery",
+    `${treeCount.totalFiles.toLocaleString()} files \xB7 ${treeCount.totalDirs.toLocaleString()} dirs`
+  );
+  const scanHistory = await loadScanHistory(rootDir);
+  const estimatedTotal = estimateTotalDuration(scanHistory, treeCount.totalFiles);
+  progress.setEstimatedTotal(estimatedTotal);
+  progress.setStepEstimates(estimateStepDurations(scanHistory, treeCount.totalFiles));
   progress.startStep("vcs");
   const vcs = await detectVcs(rootDir);
   const vcsDetail = vcs.type !== "unknown" ? `${vcs.type}${vcs.branch ? ` ${vcs.branch}` : ""}${vcs.shortSha ? ` @ ${vcs.shortSha}` : ""}` : "none detected";
   progress.completeStep("vcs", vcsDetail);
+  progress.startStep("walk", treeCount.totalFiles);
+  await fileCache.walkDir(rootDir, (found) => {
+    progress.updateStepProgress("walk", found, treeCount.totalFiles);
+  });
+  progress.completeStep("walk", `${treeCount.totalFiles.toLocaleString()} files indexed`);
   progress.startStep("node");
   const nodeProjects = await scanNodeProjects(rootDir, npmCache, fileCache);
   for (const p of nodeProjects) {
@@ -4966,17 +5216,18 @@ async function runScan(rootDir, opts) {
     schemaVersion: "1.0",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     vibgrateVersion: VERSION,
-    rootPath: path15.basename(rootDir),
+    rootPath: path16.basename(rootDir),
     ...vcs.type !== "unknown" ? { vcs } : {},
     projects: allProjects,
     drift,
     findings,
     ...Object.keys(extended).length > 0 ? { extended } : {},
     durationMs,
-    filesScanned
+    filesScanned,
+    treeSummary: treeCount
   };
   if (opts.baseline) {
-    const baselinePath = path15.resolve(opts.baseline);
+    const baselinePath = path16.resolve(opts.baseline);
     if (await pathExists(baselinePath)) {
       try {
         const baseline = await readJsonFile(baselinePath);
@@ -4987,15 +5238,22 @@ async function runScan(rootDir, opts) {
       }
     }
   }
-  const vibgrateDir = path15.join(rootDir, ".vibgrate");
+  const vibgrateDir = path16.join(rootDir, ".vibgrate");
   await ensureDir(vibgrateDir);
-  await writeJsonFile(path15.join(vibgrateDir, "scan_result.json"), artifact);
+  await writeJsonFile(path16.join(vibgrateDir, "scan_result.json"), artifact);
+  await saveScanHistory(rootDir, {
+    timestamp: artifact.timestamp,
+    totalDurationMs: durationMs,
+    totalFiles: treeCount.totalFiles,
+    totalDirs: treeCount.totalDirs,
+    steps: progress.getStepTimings()
+  });
   for (const project of allProjects) {
     if (project.drift && project.path) {
-      const projectDir = path15.resolve(rootDir, project.path);
-      const projectVibgrateDir = path15.join(projectDir, ".vibgrate");
+      const projectDir = path16.resolve(rootDir, project.path);
+      const projectVibgrateDir = path16.join(projectDir, ".vibgrate");
       await ensureDir(projectVibgrateDir);
-      await writeJsonFile(path15.join(projectVibgrateDir, "project_score.json"), {
+      await writeJsonFile(path16.join(projectVibgrateDir, "project_score.json"), {
         projectId: project.projectId,
         name: project.name,
         type: project.type,
@@ -5012,7 +5270,7 @@ async function runScan(rootDir, opts) {
   if (opts.format === "json") {
     const jsonStr = JSON.stringify(artifact, null, 2);
     if (opts.out) {
-      await writeTextFile(path15.resolve(opts.out), jsonStr);
+      await writeTextFile(path16.resolve(opts.out), jsonStr);
       console.log(chalk5.green("\u2714") + ` JSON written to ${opts.out}`);
     } else {
       console.log(jsonStr);
@@ -5021,7 +5279,7 @@ async function runScan(rootDir, opts) {
     const sarif = formatSarif(artifact);
     const sarifStr = JSON.stringify(sarif, null, 2);
     if (opts.out) {
-      await writeTextFile(path15.resolve(opts.out), sarifStr);
+      await writeTextFile(path16.resolve(opts.out), sarifStr);
       console.log(chalk5.green("\u2714") + ` SARIF written to ${opts.out}`);
     } else {
       console.log(sarifStr);
@@ -5030,7 +5288,7 @@ async function runScan(rootDir, opts) {
     const text = formatText(artifact);
     console.log(text);
     if (opts.out) {
-      await writeTextFile(path15.resolve(opts.out), text);
+      await writeTextFile(path16.resolve(opts.out), text);
     }
   }
   return artifact;
@@ -5089,7 +5347,7 @@ async function autoPush(artifact, rootDir, opts) {
   }
 }
 var scanCommand = new Command3("scan").description("Scan a project for upgrade drift").argument("[path]", "Path to scan", ".").option("--out <file>", "Output file path").option("--format <format>", "Output format (text|json|sarif)", "text").option("--fail-on <level>", "Fail on warn or error").option("--baseline <file>", "Compare against baseline").option("--changed-only", "Only scan changed files").option("--concurrency <n>", "Max concurrent npm calls", "8").option("--push", "Auto-push results to Vibgrate API after scan").option("--dsn <dsn>", "DSN token for push (or use VIBGRATE_DSN env)").option("--region <region>", "Override data residency region for push (us, eu)").option("--strict", "Fail on push errors").action(async (targetPath, opts) => {
-  const rootDir = path15.resolve(targetPath);
+  const rootDir = path16.resolve(targetPath);
   if (!await pathExists(rootDir)) {
     console.error(chalk5.red(`Path does not exist: ${rootDir}`));
     process.exit(1);

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   formatMarkdown
-} from "./chunk-VXZT34Y5.js";
+} from "./chunk-GN3IWKSY.js";
 import {
   baselineCommand
-} from "./chunk-YWBGG2KK.js";
+} from "./chunk-74QSNBZA.js";
 import {
   VERSION,
   dsnCommand,
@@ -15,7 +15,7 @@ import {
   readJsonFile,
   scanCommand,
   writeDefaultConfig
-} from "./chunk-T6WMUKLV.js";
+} from "./chunk-L6R5WSCC.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-7KBX56UU.js");
+    const { runBaseline } = await import("./baseline-7WI3SI6H.js");
     await runBaseline(rootDir);
   }
   console.log("");

package/dist/index.d.ts

@@ -64,6 +64,12 @@ interface VcsInfo {
     shortSha?: string;
     branch?: string;
 }
+interface TreeCount {
+    /** Total files discovered (excluding skipped dirs like node_modules, .git, dist) */
+    totalFiles: number;
+    /** Total subdirectories discovered (excluding skipped dirs) */
+    totalDirs: number;
+}
 interface ScanArtifact {
     schemaVersion: '1.0';
     timestamp: string;
@@ -80,6 +86,8 @@ interface ScanArtifact {
     durationMs?: number;
     /** Number of manifest/config files scanned */
     filesScanned?: number;
+    /** Workspace tree summary (file & directory counts from discovery) */
+    treeSummary?: TreeCount;
 }
 interface ScanOptions {
     out?: string;

package/dist/index.js

@@ -1,13 +1,13 @@
 import {
   formatMarkdown
-} from "./chunk-VXZT34Y5.js";
+} from "./chunk-GN3IWKSY.js";
 import {
   computeDriftScore,
   formatSarif,
   formatText,
   generateFindings,
   runScan
-} from "./chunk-T6WMUKLV.js";
+} from "./chunk-L6R5WSCC.js";
 export {
   computeDriftScore,
   formatMarkdown,

package/package.json

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