@dereekb/dbx-cli 13.11.13 → 13.11.15

package/lint-cache/main.js

@@ -0,0 +1,655 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// packages/dbx-cli/lint-cache/src/main.ts
+import { resolve } from "node:path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// packages/dbx-cli/lint-cache/src/build.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3, relative as relative2 } from "node:path";
+import { randomUUID } from "node:crypto";
+
+// packages/dbx-cli/lint-cache/src/build-many.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// packages/dbx-cli/lint-cache/src/project-lookup.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+var TOP_LEVEL_DIRS = ["apps", "packages", "tools"];
+var SKIP_DIR_NAMES = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".nx", ".angular", ".next"]);
+function findProject(workspaceRoot, projectName) {
+  let result = null;
+  for (const dir of TOP_LEVEL_DIRS) {
+    if (result) break;
+    const base = join(workspaceRoot, dir);
+    if (!existsSync(base)) continue;
+    result = walkForProject(workspaceRoot, base, projectName);
+  }
+  if (!result) {
+    const rootProject = readProjectJson(join(workspaceRoot, "project.json"));
+    if (rootProject?.name === projectName) {
+      result = toProjectInfo(workspaceRoot, workspaceRoot, rootProject);
+    }
+  }
+  return result;
+}
+function walkForProject(workspaceRoot, dir, projectName) {
+  let found = null;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (found) break;
+    if (!e.isDirectory()) continue;
+    if (SKIP_DIR_NAMES.has(e.name) || e.name.startsWith(".")) continue;
+    const childDir = join(dir, e.name);
+    const pjPath = join(childDir, "project.json");
+    if (existsSync(pjPath)) {
+      const pj = readProjectJson(pjPath);
+      if (pj?.name === projectName) {
+        found = toProjectInfo(workspaceRoot, childDir, pj);
+        continue;
+      }
+    }
+    found = walkForProject(workspaceRoot, childDir, projectName);
+  }
+  return found;
+}
+function listProjects(workspaceRoot) {
+  const out = [];
+  for (const dir of TOP_LEVEL_DIRS) {
+    const base = join(workspaceRoot, dir);
+    if (!existsSync(base)) continue;
+    collectProjects(workspaceRoot, base, out);
+  }
+  const rootProject = readProjectJson(join(workspaceRoot, "project.json"));
+  if (rootProject) out.push(toProjectInfo(workspaceRoot, workspaceRoot, rootProject));
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+function collectProjects(workspaceRoot, dir, out) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (SKIP_DIR_NAMES.has(e.name) || e.name.startsWith(".") || e.name === "src") continue;
+    const childDir = join(dir, e.name);
+    const pjPath = join(childDir, "project.json");
+    if (existsSync(pjPath)) {
+      const pj = readProjectJson(pjPath);
+      if (pj) out.push(toProjectInfo(workspaceRoot, childDir, pj));
+    }
+    collectProjects(workspaceRoot, childDir, out);
+  }
+}
+function readProjectJson(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    parsed = null;
+  }
+  return parsed;
+}
+function toProjectInfo(workspaceRoot, projectRoot, pj) {
+  const lintTarget = pj.targets?.["lint"];
+  const lintPatterns = lintTarget?.options?.lintFilePatterns;
+  return {
+    name: pj.name ?? "",
+    projectRoot: relative(workspaceRoot, projectRoot) || ".",
+    absoluteRoot: projectRoot,
+    lintFilePatterns: Array.isArray(lintPatterns) && lintPatterns.length > 0 ? lintPatterns : void 0,
+    hasLintTarget: lintTarget != null
+  };
+}
+
+// packages/dbx-cli/lint-cache/src/build-many.ts
+async function runBuildMany(opts) {
+  const lintable = listProjects(opts.workspaceRoot).filter((p) => p.hasLintTarget);
+  const targets = filterProjects({ projects: lintable, include: opts.include, exclude: opts.exclude });
+  if (!existsSync2(opts.outputDir)) mkdirSync(opts.outputDir, { recursive: true });
+  const results = [];
+  const queue = [...targets];
+  const total = targets.length;
+  let started = 0;
+  const worker = async () => {
+    while (queue.length > 0) {
+      const project = queue.shift();
+      if (!project) return;
+      started += 1;
+      const index = started;
+      opts.onProgress?.({ kind: "start", project: project.name, index, total });
+      try {
+        const { cachePath, cache } = await runBuild({
+          project: project.name,
+          workspaceRoot: opts.workspaceRoot,
+          outputDir: opts.outputDir,
+          nxArgs: opts.nxArgs,
+          fix: opts.fix,
+          updateIndex: false
+        });
+        results.push(projectResultFromCache({ project: project.name, cachePath, cache }));
+        opts.onProgress?.({ kind: "done", project: project.name, index, total, cache });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        results.push({
+          project: project.name,
+          cachePath: void 0,
+          errorCount: void 0,
+          warningCount: void 0,
+          filesWithIssues: void 0,
+          generatedAt: void 0,
+          error: message
+        });
+        opts.onProgress?.({ kind: "error", project: project.name, index, total, error: message });
+        if (!opts.continueOnError) throw e;
+      }
+    }
+  };
+  const pool = Array.from({ length: Math.max(1, opts.concurrency) }, () => worker());
+  await Promise.all(pool);
+  results.sort((a, b) => a.project.localeCompare(b.project));
+  const totalErrors = results.reduce((acc, r) => acc + (r.errorCount ?? 0), 0);
+  const totalWarnings = results.reduce((acc, r) => acc + (r.warningCount ?? 0), 0);
+  const indexPath = join2(opts.outputDir, "index.json");
+  writeFileSync(
+    indexPath,
+    JSON.stringify(
+      {
+        schemaVersion: 1,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        projectCount: results.length,
+        succeeded: results.filter((r) => r.error == null).length,
+        failed: results.filter((r) => r.error != null).length,
+        totalErrors,
+        totalWarnings,
+        projects: results
+      },
+      null,
+      2
+    )
+  );
+  return { indexPath, projects: results, totalErrors, totalWarnings };
+}
+function filterProjects(input) {
+  const includeMatchers = input.include.map(matcherFor);
+  const excludeMatchers = input.exclude.map(matcherFor);
+  return input.projects.filter((p) => {
+    let keep = true;
+    if (includeMatchers.length > 0 && !includeMatchers.some((m) => m(p.name))) keep = false;
+    if (keep && excludeMatchers.some((m) => m(p.name))) keep = false;
+    return keep;
+  });
+}
+function matcherFor(pattern) {
+  let result;
+  if (!pattern.includes("*") && !pattern.includes("?")) {
+    result = (s) => s.includes(pattern);
+  } else {
+    const re = globToRegExp(pattern);
+    result = (s) => re.test(s);
+  }
+  return result;
+}
+function globToRegExp(pattern) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      regex += ".*";
+      i += 1;
+    } else if (ch === "?") {
+      regex += ".";
+      i += 1;
+    } else if (String.raw`.+^$()|[]{}\/`.includes(ch)) {
+      regex += String.raw`\${ch}`;
+      i += 1;
+    } else {
+      regex += ch;
+      i += 1;
+    }
+  }
+  return new RegExp(`^${regex}$`);
+}
+function projectResultFromCache(input) {
+  return {
+    project: input.project,
+    cachePath: input.cachePath,
+    errorCount: input.cache.errorCount,
+    warningCount: input.cache.warningCount,
+    filesWithIssues: input.cache.filesWithIssues,
+    generatedAt: input.cache.generatedAt,
+    error: void 0
+  };
+}
+function patchIndexEntry(input) {
+  const indexPath = join2(input.outputDir, "index.json");
+  let patched = false;
+  if (existsSync2(indexPath)) {
+    const index = JSON.parse(readFileSync2(indexPath, "utf8"));
+    const projects = [...index.projects];
+    const existingIdx = projects.findIndex((p) => p.project === input.entry.project);
+    if (existingIdx >= 0) {
+      projects[existingIdx] = input.entry;
+    } else {
+      projects.push(input.entry);
+      projects.sort((a, b) => a.project.localeCompare(b.project));
+    }
+    const next = {
+      schemaVersion: 1,
+      generatedAt: index.generatedAt,
+      projectCount: projects.length,
+      succeeded: projects.filter((p) => p.error == null).length,
+      failed: projects.filter((p) => p.error != null).length,
+      totalErrors: projects.reduce((acc, r) => acc + (r.errorCount ?? 0), 0),
+      totalWarnings: projects.reduce((acc, r) => acc + (r.warningCount ?? 0), 0),
+      projects
+    };
+    writeFileSync(indexPath, JSON.stringify(next, null, 2));
+    patched = true;
+  }
+  return patched;
+}
+
+// packages/dbx-cli/lint-cache/src/types.ts
+function cacheFileName(projectName) {
+  return `${projectName.replaceAll(/[^A-Za-z0-9._-]/g, "_")}.json`;
+}
+
+// packages/dbx-cli/lint-cache/src/build.ts
+async function runBuild(opts) {
+  const project = findProject(opts.workspaceRoot, opts.project);
+  if (!project) {
+    throw new Error(`project not found in workspace: ${opts.project}`);
+  }
+  if (!existsSync3(opts.outputDir)) mkdirSync2(opts.outputDir, { recursive: true });
+  const tmpFile = join3(opts.outputDir, `.tmp-${randomUUID()}.json`);
+  const tmpFileRel = relative2(opts.workspaceRoot, tmpFile);
+  let raw;
+  try {
+    await spawnNxLint({
+      workspaceRoot: opts.workspaceRoot,
+      project: opts.project,
+      outputFile: tmpFileRel,
+      fix: opts.fix,
+      extraArgs: opts.nxArgs ?? []
+    });
+    if (!existsSync3(tmpFile)) {
+      throw new Error(`nx lint did not write the expected JSON output to ${tmpFile}`);
+    }
+    raw = JSON.parse(readFileSync3(tmpFile, "utf8"));
+  } finally {
+    if (existsSync3(tmpFile)) rmSync(tmpFile, { force: true });
+  }
+  const cache = buildCache({
+    raw,
+    project: opts.project,
+    projectRoot: project.projectRoot,
+    workspaceRoot: opts.workspaceRoot
+  });
+  const cachePath = join3(opts.outputDir, cacheFileName(opts.project));
+  writeFileSync2(cachePath, JSON.stringify(cache, null, 2));
+  if (opts.updateIndex !== false) {
+    patchIndexEntry({
+      outputDir: opts.outputDir,
+      entry: projectResultFromCache({ project: opts.project, cachePath, cache })
+    });
+  }
+  return { cachePath, cache };
+}
+function spawnNxLint(opts) {
+  const fixArgs = opts.fix ? ["--fix"] : [];
+  const args = ["nx", "run", `${opts.project}:lint`, "--format=json", `--output-file=${opts.outputFile}`, "--silent", "--no-cloud", ...fixArgs, ...opts.extraArgs];
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn("npx", args, {
+      cwd: opts.workspaceRoot,
+      env: { ...process.env, FORCE_COLOR: "0" },
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    child.on("error", rejectPromise);
+    child.on("exit", () => {
+      resolvePromise();
+    });
+  });
+}
+function buildCache(input) {
+  const messages = [];
+  const fileSummariesMap = /* @__PURE__ */ new Map();
+  const ruleSummariesMap = /* @__PURE__ */ new Map();
+  let errorCount = 0;
+  let warningCount = 0;
+  let fixableErrorCount = 0;
+  let fixableWarningCount = 0;
+  let filesWithIssues = 0;
+  for (const r of input.raw) {
+    if (r.messages.length === 0) continue;
+    const filePath = relative2(input.workspaceRoot, r.filePath) || r.filePath;
+    filesWithIssues += 1;
+    fileSummariesMap.set(filePath, { errors: r.errorCount, warnings: r.warningCount });
+    errorCount += r.errorCount;
+    warningCount += r.warningCount;
+    fixableErrorCount += r.fixableErrorCount;
+    fixableWarningCount += r.fixableWarningCount;
+    for (const m of r.messages) {
+      const sev = m.severity === 2 ? "error" : "warning";
+      messages.push({
+        filePath,
+        line: m.line ?? 0,
+        column: m.column ?? 0,
+        endLine: m.endLine ?? null,
+        endColumn: m.endColumn ?? null,
+        ruleId: m.ruleId ?? null,
+        severity: sev,
+        message: m.message,
+        fixable: m.fix != null
+      });
+      const ruleKey = m.ruleId ?? "(no-rule)";
+      let entry = ruleSummariesMap.get(ruleKey);
+      if (!entry) {
+        entry = { errors: 0, warnings: 0, files: /* @__PURE__ */ new Set() };
+        ruleSummariesMap.set(ruleKey, entry);
+      }
+      if (sev === "error") entry.errors += 1;
+      else entry.warnings += 1;
+      entry.files.add(filePath);
+    }
+  }
+  const ruleSummaries = Array.from(ruleSummariesMap.entries()).map(([rule, v]) => ({ rule, errors: v.errors, warnings: v.warnings, files: v.files.size })).sort((a, b) => b.errors + b.warnings - (a.errors + a.warnings) || a.rule.localeCompare(b.rule));
+  const fileSummaries = Array.from(fileSummariesMap.entries()).map(([filePath, v]) => ({ filePath, errors: v.errors, warnings: v.warnings })).sort((a, b) => b.errors + b.warnings - (a.errors + a.warnings) || a.filePath.localeCompare(b.filePath));
+  return {
+    schemaVersion: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    project: input.project,
+    projectRoot: input.projectRoot,
+    eslintVersion: "nx-lint-executor",
+    errorCount,
+    warningCount,
+    fixableErrorCount,
+    fixableWarningCount,
+    fileCount: input.raw.length,
+    filesWithIssues,
+    ruleSummaries,
+    fileSummaries,
+    messages
+  };
+}
+
+// packages/dbx-cli/lint-cache/src/format.ts
+function renderResult(format, result) {
+  let output;
+  switch (format) {
+    case "rules":
+      output = renderRules(result);
+      break;
+    case "files":
+      output = renderFiles(result);
+      break;
+    case "messages":
+      output = renderMessages(result);
+      break;
+    case "json":
+      output = JSON.stringify(result.matched, null, 2);
+      break;
+    default:
+      output = renderSummary(result);
+  }
+  return output;
+}
+function renderSummary(r) {
+  const c = r.cache;
+  const lines = [];
+  lines.push(`Project: ${c.project} (${c.projectRoot})`, `Generated: ${c.generatedAt}`, `Totals: ${c.errorCount} errors \xB7 ${c.warningCount} warnings \xB7 ${c.filesWithIssues}/${c.fileCount} files with issues`);
+  const truncatedSuffix = r.truncated ? ` (showing ${r.matched.length})` : "";
+  lines.push(`Matched: ${r.totalMatched} messages${truncatedSuffix}`);
+  if (r.matched.length > 0) {
+    const ruleCounts = aggregateByRule(r.matched);
+    const fileCounts = aggregateByFile(r.matched);
+    lines.push("", "Top rules:");
+    for (const [rule, count] of topEntries(ruleCounts, 10)) {
+      lines.push(`  ${pad(count, 5)}  ${rule}`);
+    }
+    lines.push("", "Top files:");
+    for (const [file, count] of topEntries(fileCounts, 10)) {
+      lines.push(`  ${pad(count, 5)}  ${file}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderRules(r) {
+  const map = /* @__PURE__ */ new Map();
+  for (const m of r.matched) {
+    const rule = m.ruleId ?? "(no-rule)";
+    let entry = map.get(rule);
+    if (!entry) {
+      entry = { errors: 0, warnings: 0, files: /* @__PURE__ */ new Set() };
+      map.set(rule, entry);
+    }
+    if (m.severity === "error") entry.errors += 1;
+    else entry.warnings += 1;
+    entry.files.add(m.filePath);
+  }
+  const sorted = Array.from(map.entries()).sort((a, b) => b[1].errors + b[1].warnings - (a[1].errors + a[1].warnings));
+  const lines = [`Rules (${sorted.length}):`];
+  for (const [rule, v] of sorted) {
+    lines.push(`  ${pad(v.errors + v.warnings, 5)}  ${rule}  (${v.errors} err / ${v.warnings} warn, ${v.files.size} files)`);
+  }
+  return lines.join("\n");
+}
+function renderFiles(r) {
+  const map = /* @__PURE__ */ new Map();
+  for (const m of r.matched) {
+    let entry = map.get(m.filePath);
+    if (!entry) {
+      entry = { errors: 0, warnings: 0 };
+      map.set(m.filePath, entry);
+    }
+    if (m.severity === "error") entry.errors += 1;
+    else entry.warnings += 1;
+  }
+  const sorted = Array.from(map.entries()).sort((a, b) => b[1].errors + b[1].warnings - (a[1].errors + a[1].warnings));
+  const lines = [`Files (${sorted.length}):`];
+  for (const [file, v] of sorted) {
+    lines.push(`  ${pad(v.errors + v.warnings, 5)}  ${file}  (${v.errors} err / ${v.warnings} warn)`);
+  }
+  return lines.join("\n");
+}
+function renderMessages(r) {
+  const truncatedSuffix = r.truncated ? `, showing ${r.matched.length}` : "";
+  const lines = [`Messages (${r.totalMatched}${truncatedSuffix}):`];
+  for (const m of r.matched) {
+    const sev = m.severity === "error" ? "ERR " : "WARN";
+    lines.push(`  ${sev}  ${m.filePath}:${m.line}:${m.column}  [${m.ruleId ?? "(no-rule)"}]  ${m.message}`);
+  }
+  return lines.join("\n");
+}
+function aggregateByRule(messages) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    const key = m.ruleId ?? "(no-rule)";
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function aggregateByFile(messages) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    counts.set(m.filePath, (counts.get(m.filePath) ?? 0) + 1);
+  }
+  return counts;
+}
+function topEntries(counts, n) {
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, n);
+}
+function pad(n, width) {
+  const s = String(n);
+  return s.length >= width ? s : " ".repeat(width - s.length) + s;
+}
+
+// packages/dbx-cli/lint-cache/src/query.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+function runQuery(cachePath, filters) {
+  if (!existsSync4(cachePath)) {
+    throw new Error(`lint cache not found: ${cachePath} \u2014 run \`build\` first`);
+  }
+  const cache = JSON.parse(readFileSync4(cachePath, "utf8"));
+  const ruleSet = filters.rule && filters.rule.length > 0 ? new Set(filters.rule) : null;
+  const fileNeedle = filters.file && filters.file.length > 0 ? filters.file : null;
+  const fileMatcher = fileNeedle && isGlobPattern(fileNeedle) ? globToRegExp2(fileNeedle) : null;
+  const messageNeedle = filters.message && filters.message.length > 0 ? filters.message.toLowerCase() : null;
+  const severity = filters.severity;
+  const matched = [];
+  for (const m of cache.messages) {
+    if (ruleSet && (m.ruleId == null || !ruleSet.has(m.ruleId))) continue;
+    if (severity && m.severity !== severity) continue;
+    if (fileNeedle) {
+      if (fileMatcher) {
+        if (!fileMatcher.test(m.filePath)) continue;
+      } else if (!m.filePath.includes(fileNeedle)) {
+        continue;
+      }
+    }
+    if (messageNeedle && !m.message.toLowerCase().includes(messageNeedle)) continue;
+    matched.push(m);
+  }
+  const totalMatched = matched.length;
+  const truncated = filters.limit != null && totalMatched > filters.limit;
+  const limited = filters.limit == null ? matched : matched.slice(0, filters.limit);
+  return { cache, matched: limited, totalMatched, truncated };
+}
+function isGlobPattern(s) {
+  return s.includes("*") || s.includes("?");
+}
+function globToRegExp2(pattern) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      regex += ".*";
+      i += 2;
+      if (pattern[i] === "/") i += 1;
+    } else if (ch === "*") {
+      regex += "[^/]*";
+      i += 1;
+    } else if (ch === "?") {
+      regex += "[^/]";
+      i += 1;
+    } else if (String.raw`.+^$()|[]{}\/`.includes(ch)) {
+      regex += String.raw`\${ch}`;
+      i += 1;
+    } else {
+      regex += ch;
+      i += 1;
+    }
+  }
+  return new RegExp(`^${regex}$`);
+}
+
+// packages/dbx-cli/lint-cache/src/main.ts
+var FORMAT_CHOICES = ["summary", "rules", "files", "messages", "json"];
+var SEVERITY_CHOICES = ["error", "warning"];
+await yargs(hideBin(process.argv)).scriptName("dbx-cli-lint-cache").usage("$0 <command> [options]").command(
+  "build <project>",
+  "Run ESLint for a project and write the grouped result cache.",
+  (y) => y.positional("project", { type: "string", describe: "Nx project name", demandOption: true }).option("output-dir", { type: "string", default: ".tmp/lint-cache", describe: "Directory the cache file is written into (workspace-relative)." }).option("workspace", { type: "string", describe: "Workspace root (defaults to cwd)." }).option("nx-arg", { type: "array", string: true, describe: "Extra argument passed through to `nx run <project>:lint` (repeatable)." }).option("fix", { type: "boolean", default: false, describe: "Run ESLint with --fix; remaining (non-fixable) issues are still cached." }).option("quiet", { type: "boolean", default: false, describe: "Suppress the post-build summary line." }),
+  async (args) => {
+    const workspaceRoot = resolveWorkspaceRoot(args);
+    const outputDir = resolve(workspaceRoot, args["output-dir"]);
+    const { cachePath, cache } = await runBuild({
+      project: args.project,
+      workspaceRoot,
+      outputDir,
+      nxArgs: args["nx-arg"],
+      fix: args.fix
+    });
+    if (!args.quiet) {
+      console.log(`[wrote] ${cachePath}`);
+      console.log(`Summary: ${cache.errorCount} errors \xB7 ${cache.warningCount} warnings \xB7 ${cache.filesWithIssues}/${cache.fileCount} files with issues${args.fix ? " (after --fix)" : ""}`);
+    }
+  }
+).command(
+  "query <project>",
+  "Filter and display messages from a project's cached lint result.",
+  (y) => y.positional("project", { type: "string", describe: "Nx project name", demandOption: true }).option("cache-dir", { type: "string", default: ".tmp/lint-cache", describe: "Directory the cache file lives in (workspace-relative)." }).option("workspace", { type: "string", describe: "Workspace root (defaults to cwd)." }).option("rule", { type: "array", string: true, describe: "Filter to one or more rule IDs (repeatable). OR-ed." }).option("severity", { choices: SEVERITY_CHOICES, describe: "Filter to errors or warnings only." }).option("file", { type: "string", describe: "Substring filter against the file path; supports * and ** glob chars." }).option("message", { type: "string", describe: "Substring filter against the message text (case-insensitive)." }).option("limit", { type: "number", describe: "Limit the printed messages slice (totalMatched still reflects the full match count)." }).option("format", { choices: FORMAT_CHOICES, default: "summary", describe: "Output format." }),
+  (args) => {
+    const workspaceRoot = resolveWorkspaceRoot(args);
+    const cacheDir = resolve(workspaceRoot, args["cache-dir"]);
+    const cachePath = resolve(cacheDir, cacheFileName(args.project));
+    const result = runQuery(cachePath, {
+      rule: args.rule,
+      severity: args.severity,
+      file: args.file,
+      message: args.message,
+      limit: args.limit
+    });
+    console.log(renderResult(args.format, result));
+  }
+).command(
+  "build-many",
+  "Run ESLint for every project with a lint target (with optional filters) and write per-project caches plus an aggregate index.json.",
+  (y) => y.option("output-dir", { type: "string", default: ".tmp/lint-cache", describe: "Directory the cache files are written into (workspace-relative)." }).option("workspace", { type: "string", describe: "Workspace root (defaults to cwd)." }).option("include", { type: "array", string: true, default: [], describe: "Only build projects whose name matches one of these patterns (substring or *-glob). Repeatable." }).option("exclude", { type: "array", string: true, default: [], describe: "Skip projects whose name matches one of these patterns (substring or *-glob). Repeatable." }).option("concurrency", { type: "number", default: 4, describe: "Number of `nx run <p>:lint` processes to run in parallel." }).option("continue-on-error", { type: "boolean", default: true, describe: "Continue past per-project failures and record them in index.json." }).option("nx-arg", { type: "array", string: true, describe: "Extra argument passed through to each `nx run <project>:lint` (repeatable)." }).option("fix", { type: "boolean", default: false, describe: "Run ESLint with --fix on every targeted project; remaining (non-fixable) issues are still cached." }).option("quiet", { type: "boolean", default: false, describe: "Suppress per-project progress output." }),
+  async (args) => {
+    const workspaceRoot = resolveWorkspaceRoot(args);
+    const outputDir = resolve(workspaceRoot, args["output-dir"]);
+    const include = args.include ?? [];
+    const exclude = args.exclude ?? [];
+    const result = await runBuildMany({
+      workspaceRoot,
+      outputDir,
+      include,
+      exclude,
+      concurrency: args.concurrency,
+      continueOnError: args["continue-on-error"],
+      nxArgs: args["nx-arg"],
+      fix: args.fix,
+      onProgress: args.quiet ? void 0 : printProgress
+    });
+    if (!args.quiet) {
+      const failed = result.projects.filter((p) => p.error != null).length;
+      console.log("");
+      console.log(`[wrote] ${result.indexPath}`);
+      console.log(`Totals: ${result.totalErrors} errors \xB7 ${result.totalWarnings} warnings across ${result.projects.length} projects (${failed} failed).`);
+    }
+  }
+).command(
+  "list-projects",
+  "List Nx projects that build-many would target after applying include/exclude filters.",
+  (y) => y.option("workspace", { type: "string", describe: "Workspace root (defaults to cwd)." }).option("include", { type: "array", string: true, default: [], describe: "Substring or *-glob filter to keep projects. Repeatable." }).option("exclude", { type: "array", string: true, default: [], describe: "Substring or *-glob filter to drop projects. Repeatable." }).option("all", { type: "boolean", default: false, describe: "Include projects that do not declare a lint target." }),
+  (args) => {
+    const workspaceRoot = resolveWorkspaceRoot(args);
+    const include = args.include ?? [];
+    const exclude = args.exclude ?? [];
+    const projects = listProjects(workspaceRoot);
+    const lintable = args.all ? projects : projects.filter((p) => p.hasLintTarget);
+    const filtered = filterProjects({ projects: lintable, include, exclude });
+    for (const p of filtered) {
+      const lintFlag = p.hasLintTarget ? "" : "  (no lint target)";
+      console.log(`${p.name}	${p.projectRoot}${lintFlag}`);
+    }
+    console.log(`# ${filtered.length} project(s) (of ${lintable.length} lintable, ${projects.length} total)`);
+  }
+).demandCommand(1, "Specify a command (build, build-many, query, list-projects).").strict().help().alias("h", "help").parseAsync().catch((e) => {
+  const message = e instanceof Error ? e.message : String(e);
+  console.error(message);
+  process.exit(1);
+});
+function resolveWorkspaceRoot(args) {
+  return resolve(args.workspace ?? process.cwd());
+}
+function printProgress(event) {
+  const tag = `[${event.index}/${event.total}]`;
+  switch (event.kind) {
+    case "start":
+      console.log(`${tag} ${event.project} ...`);
+      break;
+    case "done":
+      console.log(`${tag} ${event.project} \u2192 ${event.cache.errorCount} err / ${event.cache.warningCount} warn (${event.cache.filesWithIssues}/${event.cache.fileCount} files)`);
+      break;
+    case "error":
+      console.error(`${tag} ${event.project} FAILED: ${event.error}`);
+      break;
+  }
+}

package/lint-cache/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@dereekb/dbx-cli-lint-cache",
+  "version": "13.11.15",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "@dereekb/util": "13.11.15",
+    "eslint": "10.4.0",
+    "yargs": "^18.0.0",
+    "@types/yargs": "^17.0.35"
+  }
+}