fix

Author: aidenybai

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

@@ -165,32 +165,38 @@ const resolveWorkspaceDirectories = (rootDirectory: string, pattern: string): st
     );
 };
 
-const findDependencyInfoFromAncestors = (startDirectory: string): DependencyInfo => {
+const isMonorepoRoot = (directory: string): boolean => {
+  if (fs.existsSync(path.join(directory, "pnpm-workspace.yaml"))) return true;
+  const packageJsonPath = path.join(directory, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return false;
+  const packageJson = readPackageJson(packageJsonPath);
+  return Array.isArray(packageJson.workspaces) || Boolean(packageJson.workspaces?.packages);
+};
+
+const findMonorepoRoot = (startDirectory: string): string | null => {
   let currentDirectory = path.dirname(startDirectory);
-  const result: DependencyInfo = { reactVersion: null, framework: "unknown" };
 
   while (currentDirectory !== path.dirname(currentDirectory)) {
-    const packageJsonPath = path.join(currentDirectory, "package.json");
-    if (fs.existsSync(packageJsonPath)) {
-      const packageJson = readPackageJson(packageJsonPath);
-      const info = extractDependencyInfo(packageJson);
+    if (isMonorepoRoot(currentDirectory)) return currentDirectory;
+    currentDirectory = path.dirname(currentDirectory);
+  }
 
-      if (!result.reactVersion && info.reactVersion) {
-        result.reactVersion = info.reactVersion;
-      }
-      if (result.framework === "unknown" && info.framework !== "unknown") {
-        result.framework = info.framework;
-      }
+  return null;
+};
 
-      if (result.reactVersion && result.framework !== "unknown") {
-        return result;
-      }
-    }
+const findDependencyInfoFromMonorepoRoot = (directory: string): DependencyInfo => {
+  const monorepoRoot = findMonorepoRoot(directory);
+  if (!monorepoRoot) return { reactVersion: null, framework: "unknown" };
 
-    currentDirectory = path.dirname(currentDirectory);
-  }
+  const rootPackageJson = readPackageJson(path.join(monorepoRoot, "package.json"));
+  const rootInfo = extractDependencyInfo(rootPackageJson);
+  const workspaceInfo = findReactInWorkspaces(monorepoRoot, rootPackageJson);
 
-  return result;
+  return {
+    reactVersion: rootInfo.reactVersion ?? workspaceInfo.reactVersion,
+    framework:
+      rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceInfo.framework,
+  };
 };
 
 const findReactInWorkspaces = (rootDirectory: string, packageJson: PackageJson): DependencyInfo => {
@@ -334,13 +340,13 @@ export const discoverProject = (directory: string): ProjectInfo => {
     }
   }
 
-  if (!reactVersion || framework === "unknown") {
-    const ancestorInfo = findDependencyInfoFromAncestors(directory);
+  if ((!reactVersion || framework === "unknown") && !isMonorepoRoot(directory)) {
+    const monorepoInfo = findDependencyInfoFromMonorepoRoot(directory);
     if (!reactVersion) {
-      reactVersion = ancestorInfo.reactVersion;
+      reactVersion = monorepoInfo.reactVersion;
     }
     if (framework === "unknown") {
-      framework = ancestorInfo.framework;
+      framework = monorepoInfo.framework;
     }
   }
 

packages/react-doctor/src/utils/prompts.ts

@@ -2,11 +2,13 @@ import { createRequire } from "node:module";
 import basePrompts, { type PromptObject, type Answers } from "prompts";
 import type { PromptMultiselectContext } from "../types.js";
 import { logger } from "./logger.js";
+import { shouldAutoSelectCurrentChoice } from "./should-auto-select-current-choice.js";
 import { shouldSelectAllChoices } from "./should-select-all-choices.js";
 
 const require = createRequire(import.meta.url);
 const PROMPTS_MULTISELECT_MODULE_PATH = "prompts/lib/elements/multiselect";
 let didPatchMultiselectToggleAll = false;
+let didPatchMultiselectSubmit = false;
 
 const onCancel = () => {
   logger.break();
@@ -41,9 +43,25 @@ const patchMultiselectToggleAll = (): void => {
   };
 };
 
+const patchMultiselectSubmit = (): void => {
+  if (didPatchMultiselectSubmit) return;
+  didPatchMultiselectSubmit = true;
+
+  const multiselectPromptConstructor = require(PROMPTS_MULTISELECT_MODULE_PATH);
+  const originalSubmit = multiselectPromptConstructor.prototype.submit;
+
+  multiselectPromptConstructor.prototype.submit = function (this: PromptMultiselectContext): void {
+    if (shouldAutoSelectCurrentChoice(this.value, this.cursor)) {
+      this.value[this.cursor].selected = true;
+    }
+    originalSubmit.call(this);
+  };
+};
+
 export const prompts = <T extends string = string>(
   questions: PromptObject<T> | PromptObject<T>[],
 ): Promise<Answers<T>> => {
   patchMultiselectToggleAll();
+  patchMultiselectSubmit();
   return basePrompts(questions, { onCancel });
 };

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

@@ -57,15 +57,18 @@ const silenced = async <T>(fn: () => Promise<T>): Promise<T> => {
   const originalLog = console.log;
   const originalInfo = console.info;
   const originalWarn = console.warn;
+  const originalError = console.error;
   console.log = () => {};
   console.info = () => {};
   console.warn = () => {};
+  console.error = () => {};
   try {
     return await fn();
   } finally {
     console.log = originalLog;
     console.info = originalInfo;
     console.warn = originalWarn;
+    console.error = originalError;
   }
 };
 
@@ -89,6 +92,15 @@ const findMonorepoRoot = (directory: string): string | null => {
   return null;
 };
 
+const CONFIG_LOADING_ERROR_PATTERN = /Error loading .*\/([a-z-]+)\.config\./;
+
+const extractFailedPluginName = (error: unknown): string | null => {
+  const match = String(error).match(CONFIG_LOADING_ERROR_PATTERN);
+  return match?.[1] ?? null;
+};
+
+const MAX_KNIP_RETRIES = 5;
+
 const runKnipWithOptions = async (
   knipCwd: string,
   workspaceName?: string,
@@ -100,7 +112,22 @@ const runKnipWithOptions = async (
       ...(workspaceName ? { workspace: workspaceName } : {}),
     }),
   );
-  return (await silenced(() => main(options))) as KnipResults;
+
+  const parsedConfig = options.parsedConfig as Record<string, unknown>;
+
+  for (let attempt = 0; attempt <= MAX_KNIP_RETRIES; attempt++) {
+    try {
+      return (await silenced(() => main(options))) as KnipResults;
+    } catch (error) {
+      const failedPlugin = extractFailedPluginName(error);
+      if (!failedPlugin || attempt === MAX_KNIP_RETRIES) {
+        throw error;
+      }
+      parsedConfig[failedPlugin] = false;
+    }
+  }
+
+  throw new Error("Unreachable");
 };
 
 const hasNodeModules = (directory: string): boolean => {

packages/react-doctor/src/utils/should-auto-select-current-choice.ts

@@ -0,0 +1,12 @@
+import type { PromptMultiselectChoiceState } from "../types.js";
+
+export const shouldAutoSelectCurrentChoice = (
+  choiceStates: PromptMultiselectChoiceState[],
+  cursor: number,
+): boolean => {
+  const hasSelection = choiceStates.some((choiceState) => choiceState.selected);
+  if (hasSelection) return false;
+
+  const currentChoice = choiceStates[cursor];
+  return Boolean(currentChoice) && !currentChoice.disabled;
+};

packages/react-doctor/tests/should-auto-select-current-choice.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { shouldAutoSelectCurrentChoice } from "../src/utils/should-auto-select-current-choice.js";
+
+describe("shouldAutoSelectCurrentChoice", () => {
+  it("returns true when nothing is selected and cursor is on an enabled choice", () => {
+    const result = shouldAutoSelectCurrentChoice(
+      [{ selected: false }, { selected: false }, { selected: false }],
+      1,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it("returns false when a choice is already selected", () => {
+    const result = shouldAutoSelectCurrentChoice(
+      [{ selected: true }, { selected: false }, { selected: false }],
+      1,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it("returns false when cursor is on a disabled choice", () => {
+    const result = shouldAutoSelectCurrentChoice(
+      [{ selected: false }, { selected: false, disabled: true }],
+      1,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it("returns false when all choices are disabled and nothing is selected", () => {
+    const result = shouldAutoSelectCurrentChoice([{ disabled: true }, { disabled: true }], 0);
+
+    expect(result).toBe(false);
+  });
+
+  it("returns false when cursor is out of bounds", () => {
+    const result = shouldAutoSelectCurrentChoice([{ selected: false }, { selected: false }], 5);
+
+    expect(result).toBe(false);
+  });
+
+  it("returns false when choice states array is empty", () => {
+    const result = shouldAutoSelectCurrentChoice([], 0);
+
+    expect(result).toBe(false);
+  });
+
+  it("returns true when selected is undefined on all choices", () => {
+    const result = shouldAutoSelectCurrentChoice([{}, {}, {}], 0);
+
+    expect(result).toBe(true);
+  });
+
+  it("returns false when cursor is negative", () => {
+    const result = shouldAutoSelectCurrentChoice([{ selected: false }, { selected: false }], -1);
+
+    expect(result).toBe(false);
+  });
+});