@dereekb/dbx-cli 14.0.0 → 14.0.1

package/lint-cache/main.js

@@ -3,7 +3,7 @@ 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 { resolve as resolve2 } from "node:path";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
@@ -18,9 +18,55 @@ import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, wr
 import { join as join2 } from "node:path";
 
 // packages/dbx-cli/lint-cache/src/project-lookup.ts
+import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
+
+// packages/dbx-cli/lint-cache/src/types.ts
+var LINT_CACHE_LINTERS = ["eslint", "oxlint"];
+var DEFAULT_LINT_CACHE_LINTER = "eslint";
+var LINT_CACHE_LINTER_TARGET_NAMES = {
+  eslint: "lint",
+  oxlint: "oxlint"
+};
+var LINT_CACHE_LINTER_TARGET_IS_INFERRED = {
+  eslint: false,
+  oxlint: true
+};
+function cacheFileName(projectName, linter = DEFAULT_LINT_CACHE_LINTER) {
+  const stem = projectName.replaceAll(/[^A-Za-z0-9._-]/g, "_");
+  return linter === DEFAULT_LINT_CACHE_LINTER ? `${stem}.json` : `${stem}.${linter}.json`;
+}
+function indexFileName(linter = DEFAULT_LINT_CACHE_LINTER) {
+  return linter === DEFAULT_LINT_CACHE_LINTER ? "index.json" : `index.${linter}.json`;
+}
+
+// packages/dbx-cli/lint-cache/src/project-lookup.ts
+var DEFAULT_TARGET_NAME = LINT_CACHE_LINTER_TARGET_NAMES[DEFAULT_LINT_CACHE_LINTER];
 var SKIP_DIR_NAMES = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".nx", ".angular", ".next"]);
+var graphTargetCache = /* @__PURE__ */ new Map();
+function projectNamesWithTarget(workspaceRoot, targetName) {
+  const key = `${workspaceRoot}\0${targetName}`;
+  let cached = graphTargetCache.get(key);
+  if (!cached) {
+    let names;
+    try {
+      const stdout = execFileSync("npx", ["nx", "show", "projects", `--with-target=${targetName}`, "--json"], {
+        cwd: workspaceRoot,
+        encoding: "utf8",
+        env: { ...process.env, FORCE_COLOR: "0" },
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const parsed = JSON.parse(stdout);
+      names = Array.isArray(parsed) ? parsed.filter((n) => typeof n === "string") : [];
+    } catch {
+      names = [];
+    }
+    cached = new Set(names);
+    graphTargetCache.set(key, cached);
+  }
+  return cached;
+}
 function discoverTopLevelDirs(workspaceRoot) {
   let dirs;
   try {
@@ -30,21 +76,22 @@ function discoverTopLevelDirs(workspaceRoot) {
   }
   return dirs;
 }
-function findProject(workspaceRoot, projectName) {
+function findProject(workspaceRoot, projectName, targetName = DEFAULT_TARGET_NAME) {
   let result = null;
   for (const dir of discoverTopLevelDirs(workspaceRoot)) {
     if (result) break;
-    result = walkForProject(workspaceRoot, join(workspaceRoot, dir), projectName);
+    result = walkForProject({ workspaceRoot, dir: join(workspaceRoot, dir), projectName, targetName });
   }
   if (!result) {
     const rootProject = readProjectJson(join(workspaceRoot, "project.json"));
     if (rootProject?.name === projectName) {
-      result = toProjectInfo(workspaceRoot, workspaceRoot, rootProject);
+      result = toProjectInfo({ workspaceRoot, projectRoot: workspaceRoot, pj: rootProject, targetName });
     }
   }
   return result;
 }
-function walkForProject(workspaceRoot, dir, projectName) {
+function walkForProject(input) {
+  const { workspaceRoot, dir, projectName, targetName } = input;
   let found = null;
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const e of entries) {
@@ -56,25 +103,30 @@ function walkForProject(workspaceRoot, dir, projectName) {
     if (existsSync(pjPath)) {
       const pj = readProjectJson(pjPath);
       if (pj?.name === projectName) {
-        found = toProjectInfo(workspaceRoot, childDir, pj);
+        found = toProjectInfo({ workspaceRoot, projectRoot: childDir, pj, targetName });
         continue;
       }
     }
-    found = walkForProject(workspaceRoot, childDir, projectName);
+    found = walkForProject({ workspaceRoot, dir: childDir, projectName, targetName });
   }
   return found;
 }
-function listProjects(workspaceRoot) {
+function listProjects(workspaceRoot, targetName = DEFAULT_TARGET_NAME, options = {}) {
   const out = [];
   for (const dir of discoverTopLevelDirs(workspaceRoot)) {
-    collectProjects(workspaceRoot, join(workspaceRoot, dir), out);
+    collectProjects({ workspaceRoot, dir: join(workspaceRoot, dir), out, targetName });
   }
   const rootProject = readProjectJson(join(workspaceRoot, "project.json"));
-  if (rootProject) out.push(toProjectInfo(workspaceRoot, workspaceRoot, rootProject));
+  if (rootProject) out.push(toProjectInfo({ workspaceRoot, projectRoot: workspaceRoot, pj: rootProject, targetName }));
   out.sort((a, b) => a.name.localeCompare(b.name));
-  return out;
+  return options.resolveInferredTargets ? withInferredTarget(workspaceRoot, targetName, out) : out;
 }
-function collectProjects(workspaceRoot, dir, out) {
+function withInferredTarget(workspaceRoot, targetName, projects) {
+  const names = projectNamesWithTarget(workspaceRoot, targetName);
+  return projects.map((p) => ({ ...p, hasLintTarget: names.has(p.name) }));
+}
+function collectProjects(input) {
+  const { workspaceRoot, dir, out, targetName } = input;
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const e of entries) {
     if (!e.isDirectory()) continue;
@@ -83,9 +135,9 @@ function collectProjects(workspaceRoot, dir, out) {
     const pjPath = join(childDir, "project.json");
     if (existsSync(pjPath)) {
       const pj = readProjectJson(pjPath);
-      if (pj) out.push(toProjectInfo(workspaceRoot, childDir, pj));
+      if (pj) out.push(toProjectInfo({ workspaceRoot, projectRoot: childDir, pj, targetName }));
     }
-    collectProjects(workspaceRoot, childDir, out);
+    collectProjects({ workspaceRoot, dir: childDir, out, targetName });
   }
 }
 function readProjectJson(path) {
@@ -97,8 +149,9 @@ function readProjectJson(path) {
   }
   return parsed;
 }
-function toProjectInfo(workspaceRoot, projectRoot, pj) {
-  const lintTarget = pj.targets?.["lint"];
+function toProjectInfo(input) {
+  const { workspaceRoot, projectRoot, pj, targetName } = input;
+  const lintTarget = pj.targets?.[targetName];
   const lintPatterns = lintTarget?.options?.lintFilePatterns;
   return {
     name: pj.name ?? "",
@@ -111,7 +164,8 @@ function toProjectInfo(workspaceRoot, projectRoot, pj) {
 
 // packages/dbx-cli/lint-cache/src/build-many.ts
 async function runBuildMany(opts) {
-  const lintable = listProjects(opts.workspaceRoot).filter((p) => p.hasLintTarget);
+  const linter = opts.linter ?? DEFAULT_LINT_CACHE_LINTER;
+  const lintable = listProjects(opts.workspaceRoot, LINT_CACHE_LINTER_TARGET_NAMES[linter], { resolveInferredTargets: LINT_CACHE_LINTER_TARGET_IS_INFERRED[linter] }).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 = [];
@@ -132,6 +186,7 @@ async function runBuildMany(opts) {
           outputDir: opts.outputDir,
           nxArgs: opts.nxArgs,
           fix: opts.fix,
+          linter,
           updateIndex: false
         });
         results.push(projectResultFromCache({ project: project.name, cachePath, cache }));
@@ -157,12 +212,13 @@ async function runBuildMany(opts) {
   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");
+  const indexPath = join2(opts.outputDir, indexFileName(linter));
   writeFileSync(
     indexPath,
     JSON.stringify(
       {
         schemaVersion: 1,
+        linter,
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         projectCount: results.length,
         succeeded: results.filter((r) => r.error == null).length,
@@ -230,7 +286,8 @@ function projectResultFromCache(input) {
   };
 }
 function patchIndexEntry(input) {
-  const indexPath = join2(input.outputDir, "index.json");
+  const linter = input.linter ?? DEFAULT_LINT_CACHE_LINTER;
+  const indexPath = join2(input.outputDir, indexFileName(linter));
   let patched = false;
   if (existsSync2(indexPath)) {
     const index = JSON.parse(readFileSync2(indexPath, "utf8"));
@@ -244,6 +301,7 @@ function patchIndexEntry(input) {
     }
     const next = {
       schemaVersion: 1,
+      linter,
       generatedAt: index.generatedAt,
       projectCount: projects.length,
       succeeded: projects.filter((p) => p.error == null).length,
@@ -258,64 +316,161 @@ function patchIndexEntry(input) {
   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/oxlint-result.ts
+import { resolve } from "node:path";
+function extractJsonObject(stdout) {
+  const start = stdout.indexOf("{");
+  if (start < 0) {
+    throw new Error("no JSON object found in oxlint output");
+  }
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let end = -1;
+  for (let i = start; i < stdout.length && end < 0; i += 1) {
+    const ch = stdout[i];
+    if (escaped) {
+      escaped = false;
+    } else if (ch === "\\") {
+      if (inString) escaped = true;
+    } else if (ch === '"') {
+      inString = !inString;
+    } else if (!inString) {
+      if (ch === "{") depth += 1;
+      else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) end = i;
+      }
+    }
+  }
+  if (end < 0) {
+    throw new Error("unterminated JSON object in oxlint output");
+  }
+  return stdout.slice(start, end + 1);
+}
+function oxlintRuleId(code) {
+  let result = null;
+  if (code) {
+    const match = /^(?<plugin>[^()]+)\((?<rule>[^()]+)\)$/.exec(code);
+    if (match?.groups) {
+      const { plugin, rule } = match.groups;
+      result = plugin === "eslint" ? rule : `${plugin}/${rule}`;
+    } else {
+      result = code;
+    }
+  }
+  return result;
+}
+function parseOxlintResult(input) {
+  const raw = JSON.parse(extractJsonObject(input.stdout));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const d of raw.diagnostics ?? []) {
+    const filePath = d.filename == null ? "<unknown>" : resolve(input.cwd, d.filename);
+    const span = d.labels?.[0]?.span;
+    const message = {
+      ruleId: oxlintRuleId(d.code),
+      severity: d.severity === "warning" ? "warning" : "error",
+      message: d.message ?? "",
+      line: span?.line ?? 0,
+      column: span?.column ?? 0,
+      endLine: null,
+      endColumn: null,
+      fixable: false
+    };
+    const existing = byFile.get(filePath);
+    if (existing) existing.push(message);
+    else byFile.set(filePath, [message]);
+  }
+  const files = Array.from(byFile.entries()).map(([filePath, messages]) => ({ filePath, messages })).sort((a, b) => a.filePath.localeCompare(b.filePath));
+  return { files, fileCount: raw.number_of_files ?? files.length };
 }
 
 // packages/dbx-cli/lint-cache/src/build.ts
 async function runBuild(opts) {
-  const project = findProject(opts.workspaceRoot, opts.project);
+  const linter = opts.linter ?? DEFAULT_LINT_CACHE_LINTER;
+  const targetName = LINT_CACHE_LINTER_TARGET_NAMES[linter];
+  const project = findProject(opts.workspaceRoot, opts.project, targetName);
   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;
+  let normalized;
   try {
-    await spawnNxLint({
+    const stdout = await spawnLintTarget({
       workspaceRoot: opts.workspaceRoot,
       project: opts.project,
-      outputFile: tmpFileRel,
+      targetName,
+      outputFile: linter === "eslint" ? tmpFileRel : null,
+      silent: linter === "eslint",
       fix: opts.fix,
       extraArgs: opts.nxArgs ?? []
     });
-    if (!existsSync3(tmpFile)) {
-      throw new Error(`nx lint did not write the expected JSON output to ${tmpFile}`);
+    if (linter === "eslint") {
+      if (!existsSync3(tmpFile)) {
+        throw new Error(`nx run ${opts.project}:${targetName} did not write the expected JSON output to ${tmpFile}`);
+      }
+      normalized = normalizeEslintResult(JSON.parse(readFileSync3(tmpFile, "utf8")));
+    } else {
+      normalized = parseOxlintResult({ stdout, cwd: project.absoluteRoot });
     }
-    raw = JSON.parse(readFileSync3(tmpFile, "utf8"));
   } finally {
     if (existsSync3(tmpFile)) rmSync(tmpFile, { force: true });
   }
   const cache = buildCache({
-    raw,
+    normalized,
+    linter,
+    targetName,
     project: opts.project,
     projectRoot: project.projectRoot,
     workspaceRoot: opts.workspaceRoot
   });
-  const cachePath = join3(opts.outputDir, cacheFileName(opts.project));
+  const cachePath = join3(opts.outputDir, cacheFileName(opts.project, linter));
   writeFileSync2(cachePath, JSON.stringify(cache, null, 2));
   if (opts.updateIndex !== false) {
     patchIndexEntry({
       outputDir: opts.outputDir,
+      linter,
       entry: projectResultFromCache({ project: opts.project, cachePath, cache })
     });
   }
   return { cachePath, cache };
 }
-function spawnNxLint(opts) {
+function normalizeEslintResult(raw) {
+  const files = raw.map((r) => ({
+    filePath: r.filePath,
+    messages: r.messages.map((m) => ({
+      ruleId: m.ruleId ?? null,
+      severity: m.severity === 2 ? "error" : "warning",
+      message: m.message,
+      line: m.line ?? 0,
+      column: m.column ?? 0,
+      endLine: m.endLine ?? null,
+      endColumn: m.endColumn ?? null,
+      fixable: m.fix != null
+    }))
+  }));
+  return { files, fileCount: raw.length };
+}
+function spawnLintTarget(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];
+  const outputFileArgs = opts.outputFile ? [`--output-file=${opts.outputFile}`] : [];
+  const silentArgs = opts.silent ? ["--silent"] : [];
+  const args = ["nx", "run", `${opts.project}:${opts.targetName}`, "--format=json", ...outputFileArgs, ...silentArgs, "--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"]
+      stdio: ["ignore", "pipe", "inherit"]
+    });
+    let stdout = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
     });
     child.on("error", rejectPromise);
     child.on("exit", () => {
-      resolvePromise();
+      resolvePromise(stdout);
     });
   });
 }
@@ -328,27 +483,31 @@ function buildCache(input) {
   let fixableErrorCount = 0;
   let fixableWarningCount = 0;
   let filesWithIssues = 0;
-  for (const r of input.raw) {
+  for (const r of input.normalized.files) {
     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;
+    let fileErrors = 0;
+    let fileWarnings = 0;
     for (const m of r.messages) {
-      const sev = m.severity === 2 ? "error" : "warning";
+      if (m.severity === "error") {
+        fileErrors += 1;
+        if (m.fixable) fixableErrorCount += 1;
+      } else {
+        fileWarnings += 1;
+        if (m.fixable) fixableWarningCount += 1;
+      }
       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,
+        line: m.line,
+        column: m.column,
+        endLine: m.endLine,
+        endColumn: m.endColumn,
+        ruleId: m.ruleId,
+        severity: m.severity,
         message: m.message,
-        fixable: m.fix != null
+        fixable: m.fixable,
+        linter: input.linter
       });
       const ruleKey = m.ruleId ?? "(no-rule)";
       let entry = ruleSummariesMap.get(ruleKey);
@@ -356,24 +515,31 @@ function buildCache(input) {
         entry = { errors: 0, warnings: 0, files: /* @__PURE__ */ new Set() };
         ruleSummariesMap.set(ruleKey, entry);
       }
-      if (sev === "error") entry.errors += 1;
+      if (m.severity === "error") entry.errors += 1;
       else entry.warnings += 1;
       entry.files.add(filePath);
     }
+    fileSummariesMap.set(filePath, { errors: fileErrors, warnings: fileWarnings });
+    errorCount += fileErrors;
+    warningCount += fileWarnings;
   }
   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));
+  const linterVersion = input.linter === "eslint" ? "nx-lint-executor" : "nx-oxlint-target";
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     project: input.project,
     projectRoot: input.projectRoot,
-    eslintVersion: "nx-lint-executor",
+    linter: input.linter,
+    linterVersion,
+    targetName: input.targetName,
+    eslintVersion: linterVersion,
     errorCount,
     warningCount,
     fixableErrorCount,
     fixableWarningCount,
-    fileCount: input.raw.length,
+    fileCount: input.normalized.fileCount,
     filesWithIssues,
     ruleSummaries,
     fileSummaries,
@@ -555,33 +721,35 @@ function globToRegExp2(pattern) {
 // packages/dbx-cli/lint-cache/src/main.ts
 var FORMAT_CHOICES = ["summary", "rules", "files", "messages", "json"];
 var SEVERITY_CHOICES = ["error", "warning"];
+var LINTER_OPTION = { choices: LINT_CACHE_LINTERS, default: DEFAULT_LINT_CACHE_LINTER, describe: "Which lint engine to use: `eslint` (the explicit `lint` target) or `oxlint` (the target inferred by @nx/oxlint)." };
 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." }),
+  "Run the linter 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 the linter with --fix; remaining (non-fixable) issues are still cached." }).option("linter", LINTER_OPTION).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 outputDir = resolve2(workspaceRoot, args["output-dir"]);
     const { cachePath, cache } = await runBuild({
       project: args.project,
       workspaceRoot,
       outputDir,
       nxArgs: args["nx-arg"],
-      fix: args.fix
+      fix: args.fix,
+      linter: args.linter
     });
     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)" : ""}`);
+      console.log(`Summary: [${cache.linter}] ${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." }),
+  (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("linter", LINTER_OPTION).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 cacheDir = resolve2(workspaceRoot, args["cache-dir"]);
+    const cachePath = resolve2(cacheDir, cacheFileName(args.project, args.linter));
     const result = runQuery(cachePath, {
       rule: args.rule,
       severity: args.severity,
@@ -593,11 +761,11 @@ await yargs(hideBin(process.argv)).scriptName("dbx-cli-lint-cache").usage("$0 <c
   }
 ).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." }),
+  "Run the linter for every project with that linter's target (with optional filters) and write per-project caches plus an aggregate index.",
+  (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 the linter with --fix on every targeted project; remaining (non-fixable) issues are still cached." }).option("linter", LINTER_OPTION).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 outputDir = resolve2(workspaceRoot, args["output-dir"]);
     const include = args.include ?? [];
     const exclude = args.exclude ?? [];
     const result = await runBuildMany({
@@ -609,28 +777,30 @@ await yargs(hideBin(process.argv)).scriptName("dbx-cli-lint-cache").usage("$0 <c
       continueOnError: args["continue-on-error"],
       nxArgs: args["nx-arg"],
       fix: args.fix,
+      linter: args.linter,
       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).`);
+      console.log(`Totals: [${args.linter}] ${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." }),
+  (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("linter", LINTER_OPTION).option("all", { type: "boolean", default: false, describe: "Include projects that do not have the selected linter's target." }),
   (args) => {
     const workspaceRoot = resolveWorkspaceRoot(args);
     const include = args.include ?? [];
     const exclude = args.exclude ?? [];
-    const projects = listProjects(workspaceRoot);
+    const linter = args.linter;
+    const projects = listProjects(workspaceRoot, LINT_CACHE_LINTER_TARGET_NAMES[linter], { resolveInferredTargets: LINT_CACHE_LINTER_TARGET_IS_INFERRED[linter] });
     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)";
+      const lintFlag = p.hasLintTarget ? "" : `  (no ${args.linter} target)`;
       console.log(`${p.name}	${p.projectRoot}${lintFlag}`);
     }
     console.log(`# ${filtered.length} project(s) (of ${lintable.length} lintable, ${projects.length} total)`);
@@ -641,7 +811,7 @@ await yargs(hideBin(process.argv)).scriptName("dbx-cli-lint-cache").usage("$0 <c
   process.exit(1);
 });
 function resolveWorkspaceRoot(args) {
-  return resolve(args.workspace ?? process.cwd());
+  return resolve2(args.workspace ?? process.cwd());
 }
 function printProgress(event) {
   const tag = `[${event.index}/${event.total}]`;

package/lint-cache/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/dbx-cli-lint-cache",
-  "version": "14.0.0",
+  "version": "14.0.1",
   "private": true,
   "type": "module",
   "devDependencies": {
@@ -8,7 +8,7 @@
     "eslint": "10.9.1"
   },
   "peerDependencies": {
-    "@dereekb/util": "14.0.0",
+    "@dereekb/util": "14.0.1",
     "yargs": "^18.0.0"
   }
 }

package/manifest-extract/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@dereekb/dbx-cli/manifest-extract",
-  "version": "14.0.0",
+  "version": "14.0.1",
   "type": "module",
   "sideEffects": false,
   "peerDependencies": {
-    "@dereekb/date": "14.0.0",
-    "@dereekb/dbx-cli": "14.0.0",
-    "@dereekb/firebase": "14.0.0",
-    "@dereekb/model": "14.0.0",
-    "@dereekb/nestjs": "14.0.0",
-    "@dereekb/rxjs": "14.0.0",
-    "@dereekb/util": "14.0.0",
+    "@dereekb/date": "14.0.1",
+    "@dereekb/dbx-cli": "14.0.1",
+    "@dereekb/firebase": "14.0.1",
+    "@dereekb/model": "14.0.1",
+    "@dereekb/nestjs": "14.0.1",
+    "@dereekb/rxjs": "14.0.1",
+    "@dereekb/util": "14.0.1",
     "ts-morph": "^28.0.0"
   },
   "exports": {

package/model-test/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dereekb/dbx-cli/model-test",
-  "version": "14.0.0",
+  "version": "14.0.1",
   "type": "module",
   "sideEffects": false,
   "peerDependencies": {
-    "@dereekb/util": "14.0.0",
+    "@dereekb/util": "14.0.1",
     "ts-morph": "^28.0.0"
   },
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/dbx-cli",
-  "version": "14.0.0",
+  "version": "14.0.1",
   "type": "module",
   "sideEffects": false,
   "bin": {
@@ -66,16 +66,16 @@
     }
   },
   "peerDependencies": {
-    "@dereekb/date": "14.0.0",
-    "@dereekb/firebase": "14.0.0",
-    "@dereekb/model": "14.0.0",
-    "@dereekb/nestjs": "14.0.0",
-    "@dereekb/util": "14.0.0",
+    "@dereekb/date": "14.0.1",
+    "@dereekb/firebase": "14.0.1",
+    "@dereekb/model": "14.0.1",
+    "@dereekb/nestjs": "14.0.1",
+    "@dereekb/util": "14.0.1",
     "@nestjs/common": "^12.0.1",
     "arktype": "^2.2.0",
     "firebase": "^12.18.0",
     "jiti": "2.7.0",
-    "prettier": "3.9.6",
+    "oxfmt": "^0.66.0",
     "ts-morph": "^28.0.0",
     "vitest": "4.1.11",
     "yargs": "^18.0.0"