feat: add concurrency settings

Author: pnodet

Diff for: src/biome.ts

@@ -1,13 +1,12 @@
 import { Biome, Distribution } from "@biomejs/js-api";
+import pLimit from "p-limit";
 import { readFileSync, existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
-import fg from "fast-glob";
-import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { performance } from "node:perf_hooks";
 import type { Configuration, LintResult } from "@biomejs/js-api";
 import type { ESLint } from "eslint";
-import pLimit from "p-limit";
 
 const getSeverity = (severity: LintResult["diagnostics"][0]["severity"]) => {
   switch (severity) {
@@ -130,9 +129,13 @@ const biomeLintFile = async (biome: Biome, filePath: string, fix = true) => {
   return convertBiomeResult(result, filePath, result.content);
 };
 
-const biomeLintFiles = async (biome: Biome, files: string[], fix = true) => {
-  const limit = pLimit(os.cpus().length);
-
+const biomeLintFiles = async (
+  biome: Biome,
+  files: string[],
+  fix = true,
+  concurrency: number = os.cpus().length,
+) => {
+  const limit = pLimit(concurrency);
   const results = await Promise.all(
     files.map((file) =>
       limit(async () => await biomeLintFile(biome, file, fix)),
@@ -222,51 +225,22 @@ const getBiomeConfig = (): Configuration => {
 };
 
 export const lintWithBiome = async (
-  eslint: ESLint,
-  patterns: string[],
+  files: string[],
+  concurrency: number = os.cpus().length,
   fix = true,
   debug = false,
 ) => {
-  const globPatterns = patterns.flatMap((pattern) => {
-    if (!fs.existsSync(pattern)) {
-      return pattern;
-    }
-
-    const stats = fs.lstatSync(pattern);
-
-    if (stats.isDirectory()) {
-      return path.join(pattern, "**/*.{js,jsx,ts,tsx}");
-    }
-
-    if (stats.isFile()) {
-      return pattern;
-    }
-
-    return [];
-  });
-
-  const files = await fg(globPatterns, { dot: true, absolute: true });
+  if (debug) {
+    performance.mark("biome-start");
+  }
 
   const biome = await Biome.create({
     distribution: Distribution.NODE,
   });
 
   biome.applyConfiguration(getBiomeConfig());
 
-  const allFiles: string[] = (
-    await Promise.all(
-      files.map(async (file) => {
-        const isIgnored = await eslint.isPathIgnored(file);
-        return !isIgnored ? file : null;
-      }),
-    )
-  ).filter(Boolean) as string[];
-
-  if (debug) {
-    performance.mark("biome-start");
-  }
-
-  const biomeResults = await biomeLintFiles(biome, allFiles, fix);
+  const biomeResults = await biomeLintFiles(biome, files, fix, concurrency);
 
   if (debug) {
     performance.mark("biome-end");

Diff for: src/eslint.ts

@@ -1,22 +1,35 @@
 import { ESLint } from "eslint";
-import type { Linter } from "eslint";
+import os from "node:os";
 import { performance } from "node:perf_hooks";
+import pLimit from "p-limit";
+import type { Linter } from "eslint";
 
 export const lintWithEslint = async (
   eslint: ESLint,
-  patterns: string[],
+  files: string[],
+  concurrency: number = os.cpus().length,
   fix = true,
   debug = false,
 ) => {
   if (debug) {
     performance.mark("eslint-start");
   }
 
-  const eslintResults = await eslint.lintFiles(patterns);
-
-  if (fix && eslintResults.length > 0) {
-    await ESLint.outputFixes(eslintResults);
-  }
+  const limit = pLimit(concurrency);
+
+  const eslintResults = (
+    await Promise.all(
+      files.map((file) =>
+        limit(async () => {
+          const results = await eslint.lintFiles([file]);
+          if (fix && results.length > 0) {
+            await ESLint.outputFixes(results);
+          }
+          return results;
+        }),
+      ),
+    )
+  ).flat();
 
   if (debug) {
     performance.mark("eslint-end");

Diff for: src/files.ts

@@ -0,0 +1,50 @@
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import fg from "fast-glob";
+import type { ESLint } from "eslint";
+import pLimit from "p-limit";
+
+export const getFilesToLint = async (
+  eslint: ESLint,
+  patterns: string[],
+
+  concurrency: number = os.cpus().length,
+) => {
+  const globPatterns = patterns.flatMap((pattern) => {
+    if (!fs.existsSync(pattern)) {
+      return pattern;
+    }
+
+    const stats = fs.lstatSync(pattern);
+
+    if (stats.isDirectory()) {
+      return path.join(pattern, "**/*.{js,jsx,ts,tsx}");
+    }
+
+    if (stats.isFile()) {
+      return pattern;
+    }
+
+    return [];
+  });
+
+  const files = await fg(globPatterns, { dot: true, absolute: true });
+
+  await eslint.isPathIgnored(files[0]);
+
+  const limit = pLimit(concurrency);
+
+  const results = (
+    await Promise.all(
+      files.map(async (file) =>
+        limit(async () => {
+          const isIgnored = await eslint.isPathIgnored(file);
+          return !isIgnored ? file : null;
+        }),
+      ),
+    )
+  ).filter(Boolean) as string[];
+
+  return results;
+};

Diff for: src/index.ts

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 
 import { ESLint } from "eslint";
+import { getFilesToLint } from "./files";
 import { lintWithBiome } from "./biome";
 import { lintWithEslint, mergeResults, overrideConfig } from "./eslint";
 import pkgJson from "../package.json" assert { type: "json" };
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { performance } from "node:perf_hooks";
+import os from "node:os";
 
 const instance = yargs(hideBin(process.argv))
   .scriptName("@nivalis/linter")
@@ -35,10 +37,16 @@ const instance = yargs(hideBin(process.argv))
           default: false,
           description: "Run in debug mode",
         })
+        .option("concurrency", {
+          type: "number",
+          default: os.cpus().length,
+          description:
+            "Number of concurrent linting processes (default: number of CPU cores)",
+        })
         .help(),
     async (args) => {
       try {
-        const { files: files_, fix, debug } = args;
+        const { files: files_, fix, debug, concurrency } = args;
         const patterns = Array.isArray(files_) ? files_ : [files_];
 
         const eslint = new ESLint({
@@ -48,9 +56,11 @@ const instance = yargs(hideBin(process.argv))
         });
 
         const formatter = await eslint.loadFormatter("stylish");
+        const files = await getFilesToLint(eslint, patterns, concurrency);
+
         const [eslntResults, biomeResults] = await Promise.all([
-          lintWithEslint(eslint, patterns, fix, debug),
-          lintWithBiome(eslint, patterns, fix, debug),
+          lintWithEslint(eslint, files, concurrency, fix, debug),
+          lintWithBiome(files, concurrency, fix, debug),
         ]);
 
         const resultText = await formatter.format(