fix: apply ignore.files as pre-filter to skip linting ignored files (#110)

Author: Akshay090

packages/react-doctor/src/constants.ts

@@ -53,6 +53,8 @@ export const OXLINT_NODE_REQUIREMENT = "^20.19.0 || >=22.12.0";
 
 export const OXLINT_RECOMMENDED_NODE_MAJOR = 24;
 
+export const IGNORED_DIRECTORIES = new Set(["node_modules", "dist", "build", "coverage"]);
+
 export const AMI_WEBSITE_URL = "https://ami.dev";
 
 export const AMI_INSTALL_URL = `${AMI_WEBSITE_URL}/install.sh`;

packages/react-doctor/src/index.ts

@@ -5,6 +5,7 @@ import { calculateScore } from "./utils/calculate-score.js";
 import { combineDiagnostics, computeJsxIncludePaths } from "./utils/combine-diagnostics.js";
 import { discoverProject } from "./utils/discover-project.js";
 import { loadConfig } from "./utils/load-config.js";
+import { resolveLintIncludePaths } from "./utils/resolve-lint-include-paths.js";
 import { runKnip } from "./utils/run-knip.js";
 import { runOxlint } from "./utils/run-oxlint.js";
 
@@ -44,6 +45,8 @@ export const diagnose = async (
   }
 
   const jsxIncludePaths = computeJsxIncludePaths(includePaths);
+  const lintIncludePaths =
+    jsxIncludePaths ?? resolveLintIncludePaths(resolvedDirectory, userConfig);
 
   const emptyDiagnostics: Diagnostic[] = [];
 
@@ -53,7 +56,7 @@ export const diagnose = async (
         projectInfo.hasTypeScript,
         projectInfo.framework,
         projectInfo.hasReactCompiler,
-        jsxIncludePaths,
+        lintIncludePaths,
       ).catch((error: unknown) => {
         console.error("Lint failed:", error);
         return emptyDiagnostics;

packages/react-doctor/src/scan.ts

@@ -38,6 +38,7 @@ import {
   isNvmInstalled,
   resolveNodeForOxlint,
 } from "./utils/resolve-compatible-node.js";
+import { resolveLintIncludePaths } from "./utils/resolve-lint-include-paths.js";
 import { runKnip } from "./utils/run-knip.js";
 import { runOxlint } from "./utils/run-oxlint.js";
 import { spinner } from "./utils/spinner.js";
@@ -425,6 +426,7 @@ const printProjectDetection = (
   userConfig: ReactDoctorConfig | null,
   isDiffMode: boolean,
   includePaths: string[],
+  lintSourceFileCount?: number,
 ): void => {
   const frameworkLabel = formatFrameworkName(projectInfo.framework);
   const languageLabel = projectInfo.hasTypeScript ? "TypeScript" : "JavaScript";
@@ -445,7 +447,9 @@ const printProjectDetection = (
   if (isDiffMode) {
     completeStep(`Scanning ${highlighter.info(`${includePaths.length}`)} changed source files.`);
   } else {
-    completeStep(`Found ${highlighter.info(`${projectInfo.sourceFileCount}`)} source files.`);
+    completeStep(
+      `Found ${highlighter.info(`${lintSourceFileCount ?? projectInfo.sourceFileCount}`)} source files.`,
+    );
   }
 
   if (userConfig) {
@@ -470,12 +474,14 @@ export const scan = async (
     throw new Error("No React dependency found in package.json");
   }
 
+  const jsxIncludePaths = computeJsxIncludePaths(includePaths);
+  const lintIncludePaths = jsxIncludePaths ?? resolveLintIncludePaths(directory, userConfig);
+  const lintSourceFileCount = lintIncludePaths?.length ?? projectInfo.sourceFileCount;
+
   if (!options.scoreOnly) {
-    printProjectDetection(projectInfo, userConfig, isDiffMode, includePaths);
+    printProjectDetection(projectInfo, userConfig, isDiffMode, includePaths, lintSourceFileCount);
   }
 
-  const jsxIncludePaths = computeJsxIncludePaths(includePaths);
-
   let didLintFail = false;
   let didDeadCodeFail = false;
 
@@ -491,7 +497,7 @@ export const scan = async (
             projectInfo.hasTypeScript,
             projectInfo.framework,
             projectInfo.hasReactCompiler,
-            jsxIncludePaths,
+            lintIncludePaths,
             resolvedNodeBinaryPath,
           );
           lintSpinner?.succeed("Running lint checks.");
@@ -594,7 +600,7 @@ export const scan = async (
 
   printDiagnostics(diagnostics, options.verbose);
 
-  const displayedSourceFileCount = isDiffMode ? includePaths.length : projectInfo.sourceFileCount;
+  const displayedSourceFileCount = isDiffMode ? includePaths.length : lintSourceFileCount;
 
   printSummary(
     diagnostics,

packages/react-doctor/src/utils/combine-diagnostics.ts

@@ -20,6 +20,6 @@ export const combineDiagnostics = (
     ...deadCodeDiagnostics,
     ...(isDiffMode ? [] : checkReducedMotion(directory)),
   ];
-  const filtered = userConfig ? filterIgnoredDiagnostics(merged, userConfig) : merged;
+  const filtered = userConfig ? filterIgnoredDiagnostics(merged, userConfig, directory) : merged;
   return filterInlineSuppressions(filtered, directory);
 };

packages/react-doctor/src/utils/discover-project.ts

@@ -1,7 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { GIT_LS_FILES_MAX_BUFFER_BYTES, SOURCE_FILE_PATTERN } from "../constants.js";
+import {
+  GIT_LS_FILES_MAX_BUFFER_BYTES,
+  IGNORED_DIRECTORIES,
+  SOURCE_FILE_PATTERN,
+} from "../constants.js";
 import type {
   DependencyInfo,
   Framework,
@@ -71,8 +75,6 @@ const FRAMEWORK_DISPLAY_NAMES: Record<Framework, string> = {
 export const formatFrameworkName = (framework: Framework): string =>
   FRAMEWORK_DISPLAY_NAMES[framework];
 
-const IGNORED_DIRECTORIES = new Set(["node_modules", "dist", "build", "coverage"]);
-
 const countSourceFilesViaFilesystem = (rootDirectory: string): number => {
   let count = 0;
   const stack = [rootDirectory];

packages/react-doctor/src/utils/filter-diagnostics.ts

@@ -1,16 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { Diagnostic, ReactDoctorConfig } from "../types.js";
-import { compileGlobPattern } from "./match-glob-pattern.js";
+import { compileIgnoredFilePatterns, isFileIgnoredByPatterns } from "./is-ignored-file.js";
 
 export const filterIgnoredDiagnostics = (
   diagnostics: Diagnostic[],
   config: ReactDoctorConfig,
+  rootDirectory: string,
 ): Diagnostic[] => {
   const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules : []);
-  const ignoredFilePatterns = Array.isArray(config.ignore?.files)
-    ? config.ignore.files.map(compileGlobPattern)
-    : [];
+  const ignoredFilePatterns = compileIgnoredFilePatterns(config);
 
   if (ignoredRules.size === 0 && ignoredFilePatterns.length === 0) {
     return diagnostics;
@@ -22,8 +21,7 @@ export const filterIgnoredDiagnostics = (
       return false;
     }
 
-    const normalizedPath = diagnostic.filePath.replace(/\\/g, "/").replace(/^\.\//, "");
-    if (ignoredFilePatterns.some((pattern) => pattern.test(normalizedPath))) {
+    if (isFileIgnoredByPatterns(diagnostic.filePath, rootDirectory, ignoredFilePatterns)) {
       return false;
     }
 

packages/react-doctor/src/utils/is-ignored-file.ts

@@ -0,0 +1,29 @@
+import type { ReactDoctorConfig } from "../types.js";
+import { compileGlobPattern } from "./match-glob-pattern.js";
+
+const toRelativePath = (filePath: string, rootDirectory: string): string => {
+  const normalizedFilePath = filePath.replace(/\\/g, "/");
+  const normalizedRoot = rootDirectory.replace(/\\/g, "/").replace(/\/$/, "") + "/";
+
+  if (normalizedFilePath.startsWith(normalizedRoot)) {
+    return normalizedFilePath.slice(normalizedRoot.length);
+  }
+
+  return normalizedFilePath.replace(/^\.\//, "");
+};
+
+export const compileIgnoredFilePatterns = (userConfig: ReactDoctorConfig | null): RegExp[] =>
+  Array.isArray(userConfig?.ignore?.files) ? userConfig.ignore.files.map(compileGlobPattern) : [];
+
+export const isFileIgnoredByPatterns = (
+  filePath: string,
+  rootDirectory: string,
+  patterns: RegExp[],
+): boolean => {
+  if (patterns.length === 0) {
+    return false;
+  }
+
+  const relativePath = toRelativePath(filePath, rootDirectory);
+  return patterns.some((pattern) => pattern.test(relativePath));
+};

packages/react-doctor/src/utils/neutralize-disable-directives.ts

@@ -3,14 +3,23 @@ import fs from "node:fs";
 import path from "node:path";
 import { GIT_LS_FILES_MAX_BUFFER_BYTES, SOURCE_FILE_PATTERN } from "../constants.js";
 
-const findFilesWithDisableDirectives = (rootDirectory: string): string[] => {
-  const result = spawnSync("git", ["grep", "-l", "--untracked", "-E", "(eslint|oxlint)-disable"], {
+const findFilesWithDisableDirectives = (
+  rootDirectory: string,
+  includePaths?: string[],
+): string[] => {
+  const grepArgs = ["grep", "-l", "--untracked", "-E", "(eslint|oxlint)-disable"];
+  if (includePaths && includePaths.length > 0) {
+    grepArgs.push("--", ...includePaths);
+  }
+
+  const result = spawnSync("git", grepArgs, {
     cwd: rootDirectory,
     encoding: "utf-8",
     maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES,
   });
 
   if (result.error || result.status === null) return [];
+  if (result.status !== 0 && result.stdout.trim().length === 0) return [];
 
   return result.stdout
     .split("\n")
@@ -22,8 +31,11 @@ const neutralizeContent = (content: string): string =>
     .replaceAll("eslint-disable", "eslint_disable")
     .replaceAll("oxlint-disable", "oxlint_disable");
 
-export const neutralizeDisableDirectives = (rootDirectory: string): (() => void) => {
-  const filePaths = findFilesWithDisableDirectives(rootDirectory);
+export const neutralizeDisableDirectives = (
+  rootDirectory: string,
+  includePaths?: string[],
+): (() => void) => {
+  const filePaths = findFilesWithDisableDirectives(rootDirectory, includePaths);
   const originalContents = new Map<string, string>();
 
   for (const relativePath of filePaths) {

packages/react-doctor/src/utils/resolve-lint-include-paths.ts

@@ -0,0 +1,78 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  GIT_LS_FILES_MAX_BUFFER_BYTES,
+  IGNORED_DIRECTORIES,
+  JSX_FILE_PATTERN,
+  SOURCE_FILE_PATTERN,
+} from "../constants.js";
+import type { ReactDoctorConfig } from "../types.js";
+import { compileIgnoredFilePatterns, isFileIgnoredByPatterns } from "./is-ignored-file.js";
+
+const listSourceFilesViaGit = (rootDirectory: string): string[] | null => {
+  const result = spawnSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+    cwd: rootDirectory,
+    encoding: "utf-8",
+    maxBuffer: GIT_LS_FILES_MAX_BUFFER_BYTES,
+  });
+
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+
+  return result.stdout
+    .split("\n")
+    .filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath));
+};
+
+const listSourceFilesViaFilesystem = (rootDirectory: string): string[] => {
+  const filePaths: string[] = [];
+  const stack = [rootDirectory];
+
+  while (stack.length > 0) {
+    const currentDirectory = stack.pop()!;
+    const entries = fs.readdirSync(currentDirectory, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDirectory, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !IGNORED_DIRECTORIES.has(entry.name)) {
+          stack.push(absolutePath);
+        }
+        continue;
+      }
+
+      if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name)) {
+        filePaths.push(path.relative(rootDirectory, absolutePath).replace(/\\/g, "/"));
+      }
+    }
+  }
+
+  return filePaths;
+};
+
+const listSourceFiles = (rootDirectory: string): string[] =>
+  listSourceFilesViaGit(rootDirectory) ?? listSourceFilesViaFilesystem(rootDirectory);
+
+export const resolveLintIncludePaths = (
+  rootDirectory: string,
+  userConfig: ReactDoctorConfig | null,
+): string[] | undefined => {
+  if (!Array.isArray(userConfig?.ignore?.files) || userConfig.ignore.files.length === 0) {
+    return undefined;
+  }
+
+  const ignoredPatterns = compileIgnoredFilePatterns(userConfig);
+
+  const includedPaths = listSourceFiles(rootDirectory).filter((filePath) => {
+    if (!JSX_FILE_PATTERN.test(filePath)) {
+      return false;
+    }
+
+    return !isFileIgnoredByPatterns(filePath, rootDirectory, ignoredPatterns);
+  });
+
+  return includedPaths;
+};

packages/react-doctor/src/utils/run-oxlint.ts

@@ -396,7 +396,7 @@ export const runOxlint = async (
   const configPath = path.join(os.tmpdir(), `react-doctor-oxlintrc-${process.pid}.json`);
   const pluginPath = resolvePluginPath();
   const config = createOxlintConfig({ pluginPath, framework, hasReactCompiler });
-  const restoreDisableDirectives = neutralizeDisableDirectives(rootDirectory);
+  const restoreDisableDirectives = neutralizeDisableDirectives(rootDirectory, includePaths);
 
   try {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));