fix

Author: aidenybai

packages/react-doctor/src/constants.ts

@@ -30,6 +30,10 @@ export const FETCH_TIMEOUT_MS = 10_000;
 
 export const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
 
+// HACK: Windows CreateProcessW limits total command-line length to 32,767 chars.
+// Use a conservative threshold to leave room for the executable path and quoting overhead.
+export const SPAWN_ARGS_MAX_LENGTH_CHARS = 24_000;
+
 export const OFFLINE_MESSAGE =
   "You are offline, could not calculate score. Reconnect to calculate.";
 

packages/react-doctor/src/scan.ts

@@ -372,6 +372,9 @@ export const scan = async (
     ? includePaths.filter((filePath) => JSX_FILE_PATTERN.test(filePath))
     : undefined;
 
+  let didLintFail = false;
+  let didDeadCodeFail = false;
+
   const lintPromise = options.lint
     ? (async () => {
         const lintSpinner = options.scoreOnly ? null : spinner("Running lint checks...").start();
@@ -386,6 +389,7 @@ export const scan = async (
           lintSpinner?.succeed("Running lint checks.");
           return lintDiagnostics;
         } catch (error) {
+          didLintFail = true;
           lintSpinner?.fail("Lint checks failed (non-fatal, skipping).");
           if (error instanceof Error) {
             logger.error(error.message);
@@ -411,6 +415,7 @@ export const scan = async (
             deadCodeSpinner?.succeed("Detecting dead code.");
             return knipDiagnostics;
           } catch (error) {
+            didDeadCodeFail = true;
             deadCodeSpinner?.fail("Dead code detection failed (non-fatal, skipping).");
             logger.error(String(error));
             return [];
@@ -430,6 +435,11 @@ export const scan = async (
 
   const elapsedMilliseconds = performance.now() - startTime;
 
+  const skippedChecks: string[] = [];
+  if (didLintFail) skippedChecks.push("lint");
+  if (didDeadCodeFail) skippedChecks.push("dead code");
+  const hasSkippedChecks = skippedChecks.length > 0;
+
   const scoreResult = options.offline ? null : await calculateScore(diagnostics);
   const noScoreMessage = options.offline ? OFFLINE_FLAG_MESSAGE : OFFLINE_MESSAGE;
 
@@ -439,19 +449,29 @@ export const scan = async (
     } else {
       logger.dim(noScoreMessage);
     }
-    return { diagnostics, scoreResult };
+    return { diagnostics, scoreResult, skippedChecks };
   }
 
   if (diagnostics.length === 0) {
-    logger.success("No issues found!");
+    if (hasSkippedChecks) {
+      const skippedLabel = skippedChecks.join(" and ");
+      logger.warn(
+        `No issues detected, but ${skippedLabel} checks failed — results are incomplete.`,
+      );
+    } else {
+      logger.success("No issues found!");
+    }
     logger.break();
-    if (scoreResult) {
+    if (hasSkippedChecks) {
+      printBranding();
+      logger.dim("  Score not shown — some checks could not complete.");
+    } else if (scoreResult) {
       printBranding(scoreResult.score);
       printScoreGauge(scoreResult.score, scoreResult.label);
     } else {
       logger.dim(`  ${noScoreMessage}`);
     }
-    return { diagnostics, scoreResult };
+    return { diagnostics, scoreResult, skippedChecks };
   }
 
   printDiagnostics(diagnostics, options.verbose);
@@ -467,5 +487,11 @@ export const scan = async (
     noScoreMessage,
   );
 
-  return { diagnostics, scoreResult };
+  if (hasSkippedChecks) {
+    const skippedLabel = skippedChecks.join(" and ");
+    logger.break();
+    logger.warn(`  Note: ${skippedLabel} checks failed — score may be incomplete.`);
+  }
+
+  return { diagnostics, scoreResult, skippedChecks };
 };

packages/react-doctor/src/types.ts

@@ -86,6 +86,7 @@ export interface ScoreResult {
 export interface ScanResult {
   diagnostics: Diagnostic[];
   scoreResult: ScoreResult | null;
+  skippedChecks: string[];
 }
 
 export interface EstimatedScoreResult {

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

@@ -4,7 +4,11 @@ import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ERROR_PREVIEW_LENGTH_CHARS, JSX_FILE_PATTERN } from "../constants.js";
+import {
+  ERROR_PREVIEW_LENGTH_CHARS,
+  JSX_FILE_PATTERN,
+  SPAWN_ARGS_MAX_LENGTH_CHARS,
+} from "../constants.js";
 import { createOxlintConfig } from "../oxlint-config.js";
 import type { CleanedDiagnostic, Diagnostic, Framework, OxlintOutput } from "../types.js";
 import { neutralizeDisableDirectives } from "./neutralize-disable-directives.js";
@@ -252,6 +256,93 @@ const resolveDiagnosticCategory = (plugin: string, rule: string): string => {
   return RULE_CATEGORY_MAP[ruleKey] ?? PLUGIN_CATEGORY_MAP[plugin] ?? "Other";
 };
 
+const estimateArgsLength = (args: string[]): number =>
+  args.reduce((total, argument) => total + argument.length + 1, 0);
+
+const batchIncludePaths = (baseArgs: string[], includePaths: string[]): string[][] => {
+  const baseArgsLength = estimateArgsLength(baseArgs);
+  const batches: string[][] = [];
+  let currentBatch: string[] = [];
+  let currentBatchLength = baseArgsLength;
+
+  for (const filePath of includePaths) {
+    const entryLength = filePath.length + 1;
+    if (currentBatch.length > 0 && currentBatchLength + entryLength > SPAWN_ARGS_MAX_LENGTH_CHARS) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentBatchLength = baseArgsLength;
+    }
+    currentBatch.push(filePath);
+    currentBatchLength += entryLength;
+  }
+
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+
+  return batches;
+};
+
+const spawnOxlint = (args: string[], rootDirectory: string): Promise<string> =>
+  new Promise<string>((resolve, reject) => {
+    const child = spawn(process.execPath, args, {
+      cwd: rootDirectory,
+    });
+
+    const stdoutBuffers: Buffer[] = [];
+    const stderrBuffers: Buffer[] = [];
+
+    child.stdout.on("data", (buffer: Buffer) => stdoutBuffers.push(buffer));
+    child.stderr.on("data", (buffer: Buffer) => stderrBuffers.push(buffer));
+
+    child.on("error", (error) => reject(new Error(`Failed to run oxlint: ${error.message}`)));
+    child.on("close", () => {
+      const output = Buffer.concat(stdoutBuffers).toString("utf-8").trim();
+      if (!output) {
+        const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
+        if (stderrOutput) {
+          reject(new Error(`Failed to run oxlint: ${stderrOutput}`));
+          return;
+        }
+      }
+      resolve(output);
+    });
+  });
+
+const parseOxlintOutput = (stdout: string): Diagnostic[] => {
+  if (!stdout) return [];
+
+  let output: OxlintOutput;
+  try {
+    output = JSON.parse(stdout) as OxlintOutput;
+  } catch {
+    throw new Error(
+      `Failed to parse oxlint output: ${stdout.slice(0, ERROR_PREVIEW_LENGTH_CHARS)}`,
+    );
+  }
+
+  return output.diagnostics
+    .filter((diagnostic) => diagnostic.code && JSX_FILE_PATTERN.test(diagnostic.filename))
+    .map((diagnostic) => {
+      const { plugin, rule } = parseRuleCode(diagnostic.code);
+      const primaryLabel = diagnostic.labels[0];
+
+      const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule);
+
+      return {
+        filePath: diagnostic.filename,
+        plugin,
+        rule,
+        severity: diagnostic.severity,
+        message: cleaned.message,
+        help: cleaned.help,
+        line: primaryLabel?.span.line ?? 0,
+        column: primaryLabel?.span.column ?? 0,
+        category: resolveDiagnosticCategory(plugin, rule),
+      };
+    });
+};
+
 export const runOxlint = async (
   rootDirectory: string,
   hasTypeScript: boolean,
@@ -272,76 +363,23 @@ export const runOxlint = async (
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 
     const oxlintBinary = resolveOxlintBinary();
-    const args = [oxlintBinary, "-c", configPath, "--format", "json"];
+    const baseArgs = [oxlintBinary, "-c", configPath, "--format", "json"];
 
     if (hasTypeScript) {
-      args.push("--tsconfig", "./tsconfig.json");
+      baseArgs.push("--tsconfig", "./tsconfig.json");
     }
 
-    if (includePaths !== undefined) {
-      args.push(...includePaths);
-    } else {
-      args.push(".");
-    }
-
-    const stdout = await new Promise<string>((resolve, reject) => {
-      const child = spawn(process.execPath, args, {
-        cwd: rootDirectory,
-      });
-
-      const stdoutBuffers: Buffer[] = [];
-      const stderrBuffers: Buffer[] = [];
-
-      child.stdout.on("data", (buffer: Buffer) => stdoutBuffers.push(buffer));
-      child.stderr.on("data", (buffer: Buffer) => stderrBuffers.push(buffer));
-
-      child.on("error", (error) => reject(new Error(`Failed to run oxlint: ${error.message}`)));
-      child.on("close", () => {
-        const output = Buffer.concat(stdoutBuffers).toString("utf-8").trim();
-        if (!output) {
-          const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
-          if (stderrOutput) {
-            reject(new Error(`Failed to run oxlint: ${stderrOutput}`));
-            return;
-          }
-        }
-        resolve(output);
-      });
-    });
-
-    if (!stdout) {
-      return [];
-    }
+    const fileBatches =
+      includePaths !== undefined ? batchIncludePaths(baseArgs, includePaths) : [["."]];
 
-    let output: OxlintOutput;
-    try {
-      output = JSON.parse(stdout) as OxlintOutput;
-    } catch {
-      throw new Error(
-        `Failed to parse oxlint output: ${stdout.slice(0, ERROR_PREVIEW_LENGTH_CHARS)}`,
-      );
+    const allDiagnostics: Diagnostic[] = [];
+    for (const batch of fileBatches) {
+      const batchArgs = [...baseArgs, ...batch];
+      const stdout = await spawnOxlint(batchArgs, rootDirectory);
+      allDiagnostics.push(...parseOxlintOutput(stdout));
     }
 
-    return output.diagnostics
-      .filter((diagnostic) => diagnostic.code && JSX_FILE_PATTERN.test(diagnostic.filename))
-      .map((diagnostic) => {
-        const { plugin, rule } = parseRuleCode(diagnostic.code);
-        const primaryLabel = diagnostic.labels[0];
-
-        const cleaned = cleanDiagnosticMessage(diagnostic.message, diagnostic.help, plugin, rule);
-
-        return {
-          filePath: diagnostic.filename,
-          plugin,
-          rule,
-          severity: diagnostic.severity,
-          message: cleaned.message,
-          help: cleaned.help,
-          line: primaryLabel?.span.line ?? 0,
-          column: primaryLabel?.span.column ?? 0,
-          category: resolveDiagnosticCategory(plugin, rule),
-        };
-      });
+    return allDiagnostics;
   } finally {
     restoreDisableDirectives();
     if (fs.existsSync(configPath)) {