@driftless-sh/cli 0.1.48 → 0.1.50

package/dist/index.js

@@ -213387,15 +213387,23 @@ var require_nestjs_extractor = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.extractNestJS = extractNestJS;
+    exports2.extractNestJSWithReport = extractNestJSWithReport;
     var node_path_1 = __importDefault(require("node:path"));
     var node_fs_1 = __importDefault(require("node:fs"));
     var typescript_1 = __importDefault(require_typescript());
-    function discoverFiles(rootPath) {
+    var DEFAULT_MAX_FILE_BYTES = 15e5;
+    function maxFileBytes() {
+      const raw = Number(process.env.DRIFTLESS_MAX_FILE_BYTES);
+      return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_MAX_FILE_BYTES;
+    }
+    function discoverScanFiles(rootPath) {
       const files = [];
+      const skipped = [];
       const srcDir = node_fs_1.default.existsSync(node_path_1.default.join(rootPath, "src")) ? node_path_1.default.join(rootPath, "src") : rootPath;
       if (!node_fs_1.default.existsSync(srcDir))
-        return files;
+        return { files, skipped };
       const SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".next", "build", ".turbo", "coverage"]);
+      const cap = maxFileBytes();
       function walk(dir) {
         const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
@@ -213404,13 +213412,23 @@ var require_nestjs_extractor = __commonJS({
             if (SKIP.has(entry.name))
               continue;
             walk(full);
-          } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".spec.ts") && !entry.name.endsWith(".test.ts")) {
-            files.push(full);
+          } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".spec.ts") && !entry.name.endsWith(".test.ts")) {
+            let size = 0;
+            try {
+              size = node_fs_1.default.statSync(full).size;
+            } catch {
+              continue;
+            }
+            if (size > cap) {
+              skipped.push({ path: node_path_1.default.relative(rootPath, full), bytes: size });
+            } else {
+              files.push(full);
+            }
           }
         }
       }
       walk(srcDir);
-      return files;
+      return { files, skipped };
     }
     function parseFile(filePath, rootPath) {
       const sourceText = node_fs_1.default.readFileSync(filePath, "utf8");
@@ -213880,10 +213898,15 @@ var require_nestjs_extractor = __commonJS({
       return c;
     }
     function extractNestJS(rootPath) {
+      return extractNestJSWithReport(rootPath).components;
+    }
+    function extractNestJSWithReport(rootPath) {
       const components = [];
-      const files = discoverFiles(rootPath).filter((f) => isInSourceDir(node_path_1.default.relative(rootPath, f))).sort();
+      const discovered = discoverScanFiles(rootPath);
+      const files = discovered.files.filter((f) => isInSourceDir(node_path_1.default.relative(rootPath, f))).sort();
+      const skipped = discovered.skipped.filter((s) => isInSourceDir(s.path));
       if (files.length === 0)
-        return components;
+        return { components, skipped };
       const symbolIndex = /* @__PURE__ */ new Map();
       const moduleByDir = /* @__PURE__ */ new Map();
       for (const file of files) {
@@ -214051,7 +214074,7 @@ var require_nestjs_extractor = __commonJS({
           }
         }
       }
-      return components;
+      return { components, skipped };
     }
     function extractModuleRelations(cls, symbolIndex) {
       const meta = cls.moduleMeta;
@@ -214321,12 +214344,222 @@ var require_enricher = __commonJS({
   }
 });
 
+// ../../libs/scanner/dist/coverage.js
+var require_coverage = __commonJS({
+  "../../libs/scanner/dist/coverage.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeCoverage = computeCoverage;
+    exports2.summarizeCoverage = summarizeCoverage;
+    function normalizePath(p) {
+      return p.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+    }
+    function globToRegExp(glob) {
+      const g = normalizePath(glob);
+      let out = "";
+      for (let i = 0; i < g.length; i++) {
+        const c = g[i];
+        if (c === "*") {
+          if (g[i + 1] === "*") {
+            i++;
+            if (g[i + 1] === "/")
+              i++;
+            out += ".*";
+          } else {
+            out += "[^/]*";
+          }
+        } else if (c === "?") {
+          out += "[^/]";
+        } else if ("\\^$+.()|{}[]".includes(c)) {
+          out += "\\" + c;
+        } else {
+          out += c;
+        }
+      }
+      return new RegExp("^" + out + "$");
+    }
+    function matchesPattern(filePath, pattern) {
+      if (!pattern)
+        return false;
+      try {
+        return globToRegExp(pattern).test(normalizePath(filePath));
+      } catch {
+        return false;
+      }
+    }
+    var SENSITIVE = /(auth|admin|billing|payment|credit|invoice|token|secret|webhook|api[-_]?key|password|session)/i;
+    function isHighRisk(c) {
+      if (c.type === "guard")
+        return true;
+      if (c.type === "endpoint") {
+        const guards = c.metadata?.guard_names;
+        if (!guards || guards.length === 0)
+          return true;
+      }
+      const hay = `${c.file_path} ${c.name} ${c.metadata?.path ?? ""}`;
+      return SENSITIVE.test(hay);
+    }
+    var RANK_TO_SPECIFICITY = {
+      4: "file",
+      3: "pattern",
+      2: "repo",
+      1: "weak"
+    };
+    function matchRank(filePath, topic, repoId) {
+      const np = normalizePath(filePath);
+      const files = topic.where_files ?? [];
+      if (files.some((f) => normalizePath(f) === np))
+        return 4;
+      if (matchesPattern(np, topic.pattern))
+        return 3;
+      const repoScoped = !!repoId && !!topic.where_repos && topic.where_repos.includes(repoId);
+      if (repoScoped) {
+        const hasAnchors = files.length > 0 || !!topic.pattern;
+        return hasAnchors ? 2 : 1;
+      }
+      return 0;
+    }
+    function reviewLevel(topic) {
+      if (topic.suggested)
+        return "suggested";
+      if (topic.status === "reviewed")
+        return "reviewed";
+      if (topic.status === "draft")
+        return "draft";
+      return "none";
+    }
+    var STATUS_RANK = {
+      none: 0,
+      suggested: 1,
+      draft: 2,
+      reviewed: 3
+    };
+    function strongerStatus(a, b) {
+      return STATUS_RANK[a] >= STATUS_RANK[b] ? a : b;
+    }
+    function decideAction(best, highRisk, hasStale, hasOrphaned) {
+      if (highRisk && best === "none")
+        return "document-now";
+      if (hasOrphaned)
+        return "reattach-or-remove";
+      if (hasStale)
+        return "refresh-stale";
+      if (best === "none")
+        return "add-topic";
+      if (best === "suggested")
+        return "review-suggested";
+      if (best === "draft")
+        return "promote-draft";
+      return "none";
+    }
+    function computeCoverage(components, topics, opts = {}) {
+      return components.map((c) => {
+        const direct = [];
+        const indirect = [];
+        let bestRank = 0;
+        let best = "none";
+        let hasStale = false;
+        let hasOrphaned = false;
+        for (const t of topics) {
+          const rank = matchRank(c.file_path, t, opts.repoId);
+          if (rank === 0)
+            continue;
+          if (t.stale)
+            hasStale = true;
+          if (t.status === "orphaned")
+            hasOrphaned = true;
+          if (rank >= 4)
+            direct.push(t.slug);
+          else
+            indirect.push(t.slug);
+          if (rank > bestRank)
+            bestRank = rank;
+          best = strongerStatus(best, reviewLevel(t));
+        }
+        const highRisk = isHighRisk(c);
+        const specificity = bestRank === 0 ? "weak" : RANK_TO_SPECIFICITY[bestRank];
+        return {
+          component: `${c.type}:${normalizePath(c.file_path)}:${c.name}:${c.line_number}`,
+          file_path: c.file_path,
+          best_status: best,
+          direct_topics: [...new Set(direct)].sort(),
+          indirect_topics: [...new Set(indirect)].sort(),
+          match_specificity: specificity,
+          has_stale: hasStale,
+          has_orphaned: hasOrphaned,
+          is_high_risk: highRisk,
+          recommended_action: decideAction(best, highRisk, hasStale, hasOrphaned)
+        };
+      });
+    }
+    function summarizeCoverage(rows) {
+      const by_status = { reviewed: 0, draft: 0, suggested: 0, none: 0 };
+      const by_specificity = {
+        component: 0,
+        file: 0,
+        pattern: 0,
+        repo: 0,
+        weak: 0
+      };
+      let covered = 0;
+      let strong = 0;
+      let high_risk_uncovered = 0;
+      let stale_count = 0;
+      let orphaned_count = 0;
+      for (const r of rows) {
+        by_status[r.best_status]++;
+        by_specificity[r.match_specificity]++;
+        if (r.best_status !== "none")
+          covered++;
+        if (r.best_status === "reviewed" && (r.match_specificity === "file" || r.match_specificity === "component")) {
+          strong++;
+        }
+        if (r.is_high_risk && r.best_status === "none")
+          high_risk_uncovered++;
+        if (r.has_stale)
+          stale_count++;
+        if (r.has_orphaned)
+          orphaned_count++;
+      }
+      const total = rows.length;
+      const uncovered = total - covered;
+      const partial = covered - strong;
+      let status;
+      if (total === 0)
+        status = "empty";
+      else if (high_risk_uncovered > 0)
+        status = "critical-gap";
+      else if (uncovered > 0)
+        status = "gap";
+      else if (partial > 0)
+        status = "partial";
+      else
+        status = "covered";
+      return {
+        total,
+        covered,
+        uncovered,
+        by_status,
+        by_specificity,
+        strong,
+        partial,
+        high_risk_uncovered,
+        stale_count,
+        orphaned_count,
+        has_stale: stale_count > 0,
+        has_orphaned: orphaned_count > 0,
+        status
+      };
+    }
+  }
+});
+
 // ../../libs/scanner/dist/index.js
 var require_dist = __commonJS({
   "../../libs/scanner/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.enrichComponents = exports2.extractNestJS = exports2.identifyRepo = void 0;
+    exports2.summarizeCoverage = exports2.computeCoverage = exports2.enrichComponents = exports2.extractNestJSWithReport = exports2.extractNestJS = exports2.identifyRepo = void 0;
     exports2.scanRepo = scanRepo2;
     var identity_1 = require_identity();
     Object.defineProperty(exports2, "identifyRepo", { enumerable: true, get: function() {
@@ -214336,16 +214569,27 @@ var require_dist = __commonJS({
     Object.defineProperty(exports2, "extractNestJS", { enumerable: true, get: function() {
       return nestjs_extractor_1.extractNestJS;
     } });
+    Object.defineProperty(exports2, "extractNestJSWithReport", { enumerable: true, get: function() {
+      return nestjs_extractor_1.extractNestJSWithReport;
+    } });
     var enricher_1 = require_enricher();
     Object.defineProperty(exports2, "enrichComponents", { enumerable: true, get: function() {
       return enricher_1.enrichComponents;
     } });
+    var coverage_1 = require_coverage();
+    Object.defineProperty(exports2, "computeCoverage", { enumerable: true, get: function() {
+      return coverage_1.computeCoverage;
+    } });
+    Object.defineProperty(exports2, "summarizeCoverage", { enumerable: true, get: function() {
+      return coverage_1.summarizeCoverage;
+    } });
     async function scanRepo2(rootPath) {
       const startMs = Date.now();
       const startMem = process.memoryUsage().heapUsed;
       const identity = (0, identity_1.identifyRepo)(rootPath);
-      let components = (0, nestjs_extractor_1.extractNestJS)(rootPath);
-      components = await (0, enricher_1.enrichComponents)(components);
+      const extracted = (0, nestjs_extractor_1.extractNestJSWithReport)(rootPath);
+      const skipped = extracted.skipped;
+      let components = await (0, enricher_1.enrichComponents)(extracted.components);
       const uniqueFiles = new Set(components.map((c) => c.file_path));
       const stats = {
         total_files: uniqueFiles.size,
@@ -214364,7 +214608,8 @@ var require_dist = __commonJS({
         telemetry: {
           duration_ms: durationMs,
           memory_mb: memoryMb,
-          files_parsed: uniqueFiles.size
+          files_parsed: uniqueFiles.size,
+          skipped_files: skipped
         }
       };
     }
@@ -214597,7 +214842,7 @@ async function installSkillCommand() {
 // src/commands/init.ts
 function getVersion() {
   try {
-    return "0.1.48";
+    return "0.1.50";
   } catch {
     return "0.0.0";
   }
@@ -214992,6 +215237,17 @@ async function initCommand(args) {
   } else {
     console.log(`  Scan: ${scanMs}ms`);
   }
+  const skippedFiles = telemetry?.skipped_files ?? [];
+  if (skippedFiles.length > 0) {
+    const mb = (n) => `${(n / 1e6).toFixed(1)} MB`;
+    console.warn(`  \u26A0 ${skippedFiles.length} file(s) skipped \u2014 over the per-file scan cap (not parsed):`);
+    for (const f of skippedFiles.slice(0, 10)) {
+      console.warn(`      ${f.path}  (${mb(f.bytes)})`);
+    }
+    if (skippedFiles.length > 10) console.warn(`      \u2026 and ${skippedFiles.length - 10} more`);
+    console.warn("    Generated/minified/vendored bundles are skipped to avoid OOM.");
+    console.warn("    Override with DRIFTLESS_MAX_FILE_BYTES=<bytes> if a real source file was skipped.");
+  }
   console.log("");
   let repo;
   try {
@@ -216618,8 +216874,8 @@ async function graphCommand(args) {
   const isJSON = args.includes("--json");
   const depthIdx = args.indexOf("--depth");
   const depth = depthIdx !== -1 && args[depthIdx + 1] ? `&depth=${encodeURIComponent(args[depthIdx + 1])}` : "";
-  if (sub !== "file" && sub !== "impact") {
-    console.error('Usage:\n  driftless graph file <path> [--depth N] [--json]\n  driftless graph impact --files "a,b" [--depth N] [--json]');
+  if (sub !== "file" && sub !== "impact" && sub !== "coverage") {
+    console.error('Usage:\n  driftless graph file <path> [--depth N] [--json]\n  driftless graph impact --files "a,b" [--depth N] [--json]\n  driftless graph coverage [--json]');
     process.exit(1);
   }
   const resolution = await resolveRepo();
@@ -216634,6 +216890,34 @@ async function graphCommand(args) {
   const { workspaceSlug, repoId } = resolution;
   const base = `/workspaces/${workspaceSlug}/repos/${repoId}/graph`;
   try {
+    if (sub === "coverage") {
+      const r = await api.get(`/workspaces/${workspaceSlug}/repos/${repoId}/architecture-summary`);
+      const cov = r?.coverage;
+      if (!cov || !cov.summary) {
+        console.error("No coverage in architecture-summary. The API may be on an older build, or run `driftless init` first.");
+        process.exit(1);
+      }
+      if (isJSON) {
+        emitJSON4(cov);
+        process.exit(0);
+      }
+      const s = cov.summary;
+      console.log("\u258C context coverage\n");
+      console.log(`  status     ${s.status}`);
+      console.log(`  components ${s.covered}/${s.total} covered  (strong ${s.strong} \xB7 partial ${s.partial} \xB7 none ${s.uncovered})`);
+      if (s.high_risk_uncovered > 0) console.log(`  \u26A0 high-risk uncovered: ${s.high_risk_uncovered}`);
+      if (s.stale_count > 0 || s.orphaned_count > 0) {
+        console.log(`  flags      stale ${s.stale_count} \xB7 orphaned ${s.orphaned_count}`);
+      }
+      const mods = Object.entries(cov.by_module).sort((a, b) => a[0].localeCompare(b[0]));
+      if (mods.length) {
+        console.log("\n  modules:");
+        for (const [name, m] of mods) {
+          console.log(`    ${name}  \u2014  ${m.status}  (${m.covered}/${m.total})`);
+        }
+      }
+      process.exit(0);
+    }
     if (sub === "file") {
       const path = args[1];
       if (!path || path.startsWith("--")) {
@@ -216713,7 +216997,7 @@ async function graphCommand(args) {
 }
 
 // src/index.ts
-var VERSION = "0.1.48";
+var VERSION = "0.1.50";
 var HELP_TEXT = `Driftless CLI v${VERSION} \u2014 Living repo context for humans and coding agents
 
 Install:  npm install -g @driftless-sh/cli