react-doctor 0.0.26 → 0.0.28

package/dist/cli.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { execSync, spawn, spawnSync } from "node:child_process";
-import fs, { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import fs, { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import os, { homedir, tmpdir } from "node:os";
 import path, { join } from "node:path";
 import { Command } from "commander";
 import { randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import pc from "picocolors";
+import basePrompts from "prompts";
 import { main } from "knip";
 import { createOptions } from "knip/session";
 import { fileURLToPath } from "node:url";
 import ora from "ora";
-import basePrompts from "prompts";
 
 //#region src/constants.ts
 const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?)$/;
@@ -29,18 +29,73 @@ const SCORE_API_URL = "https://www.react.doctor/api/score";
 const ESTIMATE_SCORE_API_URL = "https://www.react.doctor/api/estimate-score";
 const SHARE_BASE_URL = "https://www.react.doctor/share";
 const OPEN_BASE_URL = "https://www.react.doctor/open";
-const INSTALL_SKILL_URL = "https://www.react.doctor/install-skill";
+const FETCH_TIMEOUT_MS = 1e4;
 const GIT_LS_FILES_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+const SPAWN_ARGS_MAX_LENGTH_CHARS = 24e3;
 const OFFLINE_MESSAGE = "You are offline, could not calculate score. Reconnect to calculate.";
 const OFFLINE_FLAG_MESSAGE = "Score not calculated. Remove --offline to calculate score.";
 const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
-
-//#endregion
-//#region src/utils/calculate-score.ts
 const ERROR_RULE_PENALTY = 1.5;
 const WARNING_RULE_PENALTY = .75;
 const ERROR_ESTIMATED_FIX_RATE = .85;
 const WARNING_ESTIMATED_FIX_RATE = .8;
+const MAX_KNIP_RETRIES = 5;
+const OXLINT_NODE_REQUIREMENT = "^20.19.0 || >=22.12.0";
+const OXLINT_RECOMMENDED_NODE_MAJOR = 24;
+const AMI_WEBSITE_URL = "https://ami.dev";
+const AMI_INSTALL_URL = `${AMI_WEBSITE_URL}/install.sh`;
+const AMI_RELEASES_URL = "https://github.com/millionco/ami-releases/releases";
+
+//#endregion
+//#region src/utils/proxy-fetch.ts
+const readNpmConfigValue = (key) => {
+	try {
+		const value = execSync(`npm config get ${key}`, {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		if (value && value !== "null" && value !== "undefined") return value;
+	} catch {}
+};
+const resolveProxyUrl = () => process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy ?? readNpmConfigValue("https-proxy") ?? readNpmConfigValue("proxy");
+let isProxyUrlResolved = false;
+let resolvedProxyUrl;
+const getProxyUrl = () => {
+	if (isProxyUrlResolved) return resolvedProxyUrl;
+	isProxyUrlResolved = true;
+	resolvedProxyUrl = resolveProxyUrl();
+	return resolvedProxyUrl;
+};
+const createProxyDispatcher = async (proxyUrl) => {
+	try {
+		const { ProxyAgent } = await import("undici");
+		return new ProxyAgent(proxyUrl);
+	} catch {
+		return null;
+	}
+};
+const proxyFetch = async (url, init) => {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+	try {
+		const proxyUrl = getProxyUrl();
+		const dispatcher = proxyUrl ? await createProxyDispatcher(proxyUrl) : null;
+		return await fetch(url, {
+			...init,
+			signal: controller.signal,
+			...dispatcher ? { dispatcher } : {}
+		});
+	} finally {
+		clearTimeout(timeoutId);
+	}
+};
+
+//#endregion
+//#region src/utils/calculate-score.ts
 const getScoreLabel = (score) => {
 	if (score >= SCORE_GOOD_THRESHOLD) return "Great";
 	if (score >= SCORE_OK_THRESHOLD) return "Needs work";
@@ -76,7 +131,7 @@ const estimateScoreLocally = (diagnostics) => {
 };
 const calculateScore = async (diagnostics) => {
 	try {
-		const response = await fetch(SCORE_API_URL, {
+		const response = await proxyFetch(SCORE_API_URL, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ diagnostics })
@@ -89,7 +144,7 @@ const calculateScore = async (diagnostics) => {
 };
 const fetchEstimatedScore = async (diagnostics) => {
 	try {
-		const response = await fetch(ESTIMATE_SCORE_API_URL, {
+		const response = await proxyFetch(ESTIMATE_SCORE_API_URL, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ diagnostics })
@@ -101,6 +156,24 @@ const fetchEstimatedScore = async (diagnostics) => {
 	}
 };
 
+//#endregion
+//#region src/utils/highlighter.ts
+const highlighter = {
+	error: pc.red,
+	warn: pc.yellow,
+	info: pc.cyan,
+	success: pc.green,
+	dim: pc.dim
+};
+
+//#endregion
+//#region src/utils/colorize-by-score.ts
+const colorizeByScore = (text, score) => {
+	if (score >= SCORE_GOOD_THRESHOLD) return highlighter.success(text);
+	if (score >= SCORE_OK_THRESHOLD) return highlighter.warn(text);
+	return highlighter.error(text);
+};
+
 //#endregion
 //#region src/plugin/constants.ts
 const MOTION_LIBRARY_PACKAGES = new Set(["framer-motion", "motion"]);
@@ -151,6 +224,79 @@ const checkReducedMotion = (rootDirectory) => {
 	}
 };
 
+//#endregion
+//#region src/utils/match-glob-pattern.ts
+const REGEX_SPECIAL_CHARACTERS = /[.+^${}()|[\]\\]/g;
+const compileGlobPattern = (pattern) => {
+	const normalizedPattern = pattern.replace(/\\/g, "/");
+	let regexSource = "^";
+	let characterIndex = 0;
+	while (characterIndex < normalizedPattern.length) if (normalizedPattern[characterIndex] === "*" && normalizedPattern[characterIndex + 1] === "*") if (normalizedPattern[characterIndex + 2] === "/") {
+		regexSource += "(?:.+/)?";
+		characterIndex += 3;
+	} else {
+		regexSource += ".*";
+		characterIndex += 2;
+	}
+	else if (normalizedPattern[characterIndex] === "*") {
+		regexSource += "[^/]*";
+		characterIndex++;
+	} else if (normalizedPattern[characterIndex] === "?") {
+		regexSource += "[^/]";
+		characterIndex++;
+	} else {
+		regexSource += normalizedPattern[characterIndex].replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
+		characterIndex++;
+	}
+	regexSource += "$";
+	return new RegExp(regexSource);
+};
+
+//#endregion
+//#region src/utils/filter-diagnostics.ts
+const filterIgnoredDiagnostics = (diagnostics, config) => {
+	const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules : []);
+	const ignoredFilePatterns = Array.isArray(config.ignore?.files) ? config.ignore.files.map(compileGlobPattern) : [];
+	if (ignoredRules.size === 0 && ignoredFilePatterns.length === 0) return diagnostics;
+	return diagnostics.filter((diagnostic) => {
+		const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
+		if (ignoredRules.has(ruleIdentifier)) return false;
+		const normalizedPath = diagnostic.filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+		if (ignoredFilePatterns.some((pattern) => pattern.test(normalizedPath))) return false;
+		return true;
+	});
+};
+
+//#endregion
+//#region src/utils/combine-diagnostics.ts
+const computeJsxIncludePaths = (includePaths) => includePaths.length > 0 ? includePaths.filter((filePath) => JSX_FILE_PATTERN.test(filePath)) : void 0;
+const combineDiagnostics = (lintDiagnostics, deadCodeDiagnostics, directory, isDiffMode, userConfig) => {
+	const allDiagnostics = [
+		...lintDiagnostics,
+		...deadCodeDiagnostics,
+		...isDiffMode ? [] : checkReducedMotion(directory)
+	];
+	return userConfig ? filterIgnoredDiagnostics(allDiagnostics, userConfig) : allDiagnostics;
+};
+
+//#endregion
+//#region src/utils/find-monorepo-root.ts
+const isMonorepoRoot = (directory) => {
+	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) => {
+	let currentDirectory = path.dirname(startDirectory);
+	while (currentDirectory !== path.dirname(currentDirectory)) {
+		if (isMonorepoRoot(currentDirectory)) return currentDirectory;
+		currentDirectory = path.dirname(currentDirectory);
+	}
+	return null;
+};
+
 //#endregion
 //#region src/utils/discover-project.ts
 const REACT_COMPILER_PACKAGES = new Set([
@@ -261,27 +407,14 @@ const resolveWorkspaceDirectories = (rootDirectory, pattern) => {
 		if (fs.existsSync(directoryPath) && fs.existsSync(path.join(directoryPath, "package.json"))) return [directoryPath];
 		return [];
 	}
-	const baseDirectory = path.join(rootDirectory, cleanPattern.slice(0, cleanPattern.indexOf("*")));
+	const wildcardIndex = cleanPattern.indexOf("*");
+	const baseDirectory = path.join(rootDirectory, cleanPattern.slice(0, wildcardIndex));
+	const suffixAfterWildcard = cleanPattern.slice(wildcardIndex + 1);
 	if (!fs.existsSync(baseDirectory) || !fs.statSync(baseDirectory).isDirectory()) return [];
-	return fs.readdirSync(baseDirectory).map((entry) => path.join(baseDirectory, entry)).filter((entryPath) => fs.statSync(entryPath).isDirectory() && fs.existsSync(path.join(entryPath, "package.json")));
-};
-const isMonorepoRoot = (directory) => {
-	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$1 = (startDirectory) => {
-	let currentDirectory = path.dirname(startDirectory);
-	while (currentDirectory !== path.dirname(currentDirectory)) {
-		if (isMonorepoRoot(currentDirectory)) return currentDirectory;
-		currentDirectory = path.dirname(currentDirectory);
-	}
-	return null;
+	return fs.readdirSync(baseDirectory).map((entry) => path.join(baseDirectory, entry, suffixAfterWildcard)).filter((entryPath) => fs.existsSync(entryPath) && fs.statSync(entryPath).isDirectory() && fs.existsSync(path.join(entryPath, "package.json")));
 };
 const findDependencyInfoFromMonorepoRoot = (directory) => {
-	const monorepoRoot = findMonorepoRoot$1(directory);
+	const monorepoRoot = findMonorepoRoot(directory);
 	if (!monorepoRoot) return {
 		reactVersion: null,
 		framework: "unknown"
@@ -410,59 +543,6 @@ const discoverProject = (directory) => {
 	};
 };
 
-//#endregion
-//#region src/utils/match-glob-pattern.ts
-const REGEX_SPECIAL_CHARACTERS = /[.+^${}()|[\]\\]/g;
-const compileGlobPattern = (pattern) => {
-	const normalizedPattern = pattern.replace(/\\/g, "/");
-	let regexSource = "^";
-	let characterIndex = 0;
-	while (characterIndex < normalizedPattern.length) if (normalizedPattern[characterIndex] === "*" && normalizedPattern[characterIndex + 1] === "*") if (normalizedPattern[characterIndex + 2] === "/") {
-		regexSource += "(?:.+/)?";
-		characterIndex += 3;
-	} else {
-		regexSource += ".*";
-		characterIndex += 2;
-	}
-	else if (normalizedPattern[characterIndex] === "*") {
-		regexSource += "[^/]*";
-		characterIndex++;
-	} else if (normalizedPattern[characterIndex] === "?") {
-		regexSource += "[^/]";
-		characterIndex++;
-	} else {
-		regexSource += normalizedPattern[characterIndex].replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
-		characterIndex++;
-	}
-	regexSource += "$";
-	return new RegExp(regexSource);
-};
-
-//#endregion
-//#region src/utils/filter-diagnostics.ts
-const filterIgnoredDiagnostics = (diagnostics, config) => {
-	const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules : []);
-	const ignoredFilePatterns = Array.isArray(config.ignore?.files) ? config.ignore.files.map(compileGlobPattern) : [];
-	if (ignoredRules.size === 0 && ignoredFilePatterns.length === 0) return diagnostics;
-	return diagnostics.filter((diagnostic) => {
-		const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
-		if (ignoredRules.has(ruleIdentifier)) return false;
-		const normalizedPath = diagnostic.filePath.replace(/\\/g, "/").replace(/^\.\//, "");
-		if (ignoredFilePatterns.some((pattern) => pattern.test(normalizedPath))) return false;
-		return true;
-	});
-};
-
-//#endregion
-//#region src/utils/highlighter.ts
-const highlighter = {
-	error: pc.red,
-	warn: pc.yellow,
-	info: pc.cyan,
-	success: pc.green,
-	dim: pc.dim
-};
-
 //#endregion
 //#region src/utils/logger.ts
 const logger = {
@@ -563,6 +643,167 @@ const loadConfig = (rootDirectory) => {
 	return null;
 };
 
+//#endregion
+//#region src/utils/should-auto-select-current-choice.ts
+const shouldAutoSelectCurrentChoice = (choiceStates, cursor) => {
+	if (choiceStates.some((choiceState) => choiceState.selected)) return false;
+	const currentChoice = choiceStates[cursor];
+	return Boolean(currentChoice) && !currentChoice.disabled;
+};
+
+//#endregion
+//#region src/utils/should-select-all-choices.ts
+const shouldSelectAllChoices = (choiceStates) => {
+	return choiceStates.filter((choiceState) => !choiceState.disabled).some((choiceState) => choiceState.selected !== true);
+};
+
+//#endregion
+//#region src/utils/prompts.ts
+const require = createRequire(import.meta.url);
+const PROMPTS_MULTISELECT_MODULE_PATH = "prompts/lib/elements/multiselect";
+const PROMPTS_SELECT_MODULE_PATH = "prompts/lib/elements/select";
+let didPatchMultiselectToggleAll = false;
+let didPatchMultiselectSubmit = false;
+let didPatchSelectBanner = false;
+const selectBannerMap = /* @__PURE__ */ new Map();
+const setSelectBanner = (banner, targetIndex) => {
+	selectBannerMap.set(targetIndex, banner);
+};
+const clearSelectBanner = () => {
+	selectBannerMap.clear();
+};
+const onCancel = () => {
+	logger.break();
+	logger.log("Cancelled.");
+	logger.dim("Run `npx react-doctor@latest --fix` to fix issues.");
+	logger.break();
+	process.exit(0);
+};
+const patchMultiselectToggleAll = () => {
+	if (didPatchMultiselectToggleAll) return;
+	didPatchMultiselectToggleAll = true;
+	const multiselectPromptConstructor = require(PROMPTS_MULTISELECT_MODULE_PATH);
+	multiselectPromptConstructor.prototype.toggleAll = function() {
+		const isCurrentChoiceDisabled = Boolean(this.value[this.cursor]?.disabled);
+		if (this.maxChoices !== void 0 || isCurrentChoiceDisabled) {
+			this.bell();
+			return;
+		}
+		const shouldSelectAllEnabledChoices = shouldSelectAllChoices(this.value);
+		for (const choiceState of this.value) {
+			if (choiceState.disabled) continue;
+			choiceState.selected = shouldSelectAllEnabledChoices;
+		}
+		this.render();
+	};
+};
+const patchMultiselectSubmit = () => {
+	if (didPatchMultiselectSubmit) return;
+	didPatchMultiselectSubmit = true;
+	const multiselectPromptConstructor = require(PROMPTS_MULTISELECT_MODULE_PATH);
+	const originalSubmit = multiselectPromptConstructor.prototype.submit;
+	multiselectPromptConstructor.prototype.submit = function() {
+		if (shouldAutoSelectCurrentChoice(this.value, this.cursor)) this.value[this.cursor].selected = true;
+		originalSubmit.call(this);
+	};
+};
+const patchSelectBanner = () => {
+	if (didPatchSelectBanner) return;
+	didPatchSelectBanner = true;
+	const selectConstructor = require(PROMPTS_SELECT_MODULE_PATH);
+	const promptsClear = require("prompts/lib/util/clear");
+	const originalRender = selectConstructor.prototype.render;
+	selectConstructor.prototype.render = function() {
+		originalRender.call(this);
+		const banner = selectBannerMap.get(this.cursor);
+		if (!banner || this.closed || this.done) return;
+		this.out.write(promptsClear(this.outputText, this.out.columns));
+		this.outputText = `${banner}\n\n${this.outputText}`;
+		this.out.write(this.outputText);
+	};
+};
+const prompts = (questions) => {
+	patchMultiselectToggleAll();
+	patchMultiselectSubmit();
+	patchSelectBanner();
+	return basePrompts(questions, { onCancel });
+};
+
+//#endregion
+//#region src/utils/resolve-compatible-node.ts
+const parseNodeVersion = (versionString) => {
+	const [major = 0, minor = 0, patch = 0] = versionString.replace(/^v/, "").trim().split(".").map(Number);
+	return {
+		major,
+		minor,
+		patch
+	};
+};
+const isNodeVersionCompatibleWithOxlint = ({ major, minor }) => {
+	if (major === 20 && minor >= 19) return true;
+	if (major === 22 && minor >= 12) return true;
+	if (major > 22) return true;
+	return false;
+};
+const isCurrentNodeCompatibleWithOxlint = () => isNodeVersionCompatibleWithOxlint(parseNodeVersion(process.version));
+const getNvmDirectory = () => {
+	const envNvmDirectory = process.env.NVM_DIR;
+	if (envNvmDirectory && existsSync(envNvmDirectory)) return envNvmDirectory;
+	const defaultNvmDirectory = path.join(os.homedir(), ".nvm");
+	if (existsSync(defaultNvmDirectory)) return defaultNvmDirectory;
+	return null;
+};
+const isNvmInstalled = () => getNvmDirectory() !== null;
+const findCompatibleNvmBinary = () => {
+	const nvmDirectory = getNvmDirectory();
+	if (!nvmDirectory) return null;
+	const versionsDirectory = path.join(nvmDirectory, "versions", "node");
+	if (!existsSync(versionsDirectory)) return null;
+	const compatibleVersions = readdirSync(versionsDirectory).filter((directoryName) => directoryName.startsWith("v")).map((directoryName) => ({
+		directoryName,
+		...parseNodeVersion(directoryName)
+	})).filter((version) => isNodeVersionCompatibleWithOxlint(version)).sort((versionA, versionB) => versionB.major - versionA.major || versionB.minor - versionA.minor || versionB.patch - versionA.patch);
+	if (compatibleVersions.length === 0) return null;
+	const bestVersion = compatibleVersions[0];
+	const binaryPath = path.join(versionsDirectory, bestVersion.directoryName, "bin", "node");
+	return existsSync(binaryPath) ? binaryPath : null;
+};
+const getNodeVersionFromBinary = (binaryPath) => {
+	try {
+		return execSync(`"${binaryPath}" --version`, { encoding: "utf-8" }).trim();
+	} catch {
+		return null;
+	}
+};
+const installNodeViaNvm = () => {
+	const nvmDirectory = getNvmDirectory();
+	if (!nvmDirectory) return false;
+	const nvmScript = path.join(nvmDirectory, "nvm.sh");
+	if (!existsSync(nvmScript)) return false;
+	try {
+		execSync(`bash -c ". '${nvmScript}' && nvm install ${OXLINT_RECOMMENDED_NODE_MAJOR}"`, { stdio: "inherit" });
+		return findCompatibleNvmBinary() !== null;
+	} catch {
+		return false;
+	}
+};
+const resolveNodeForOxlint = () => {
+	if (isCurrentNodeCompatibleWithOxlint()) return {
+		binaryPath: process.execPath,
+		isCurrentNode: true,
+		version: process.version
+	};
+	const nvmBinaryPath = findCompatibleNvmBinary();
+	if (!nvmBinaryPath) return null;
+	const version = getNodeVersionFromBinary(nvmBinaryPath);
+	if (!version) return null;
+	return {
+		binaryPath: nvmBinaryPath,
+		isCurrentNode: false,
+		version
+	};
+};
+
 //#endregion
 //#region src/utils/run-knip.ts
 const KNIP_CATEGORY_MAP = {
@@ -617,24 +858,10 @@ const silenced = async (fn) => {
 		console.error = originalError;
 	}
 };
-const findMonorepoRoot = (directory) => {
-	let currentDirectory = path.dirname(directory);
-	while (currentDirectory !== path.dirname(currentDirectory)) {
-		if (fs.existsSync(path.join(currentDirectory, "pnpm-workspace.yaml")) || (() => {
-			const packageJsonPath = path.join(currentDirectory, "package.json");
-			if (!fs.existsSync(packageJsonPath)) return false;
-			const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-			return Array.isArray(packageJson.workspaces) || packageJson.workspaces?.packages;
-		})()) return currentDirectory;
-		currentDirectory = path.dirname(currentDirectory);
-	}
-	return null;
-};
 const CONFIG_LOADING_ERROR_PATTERN = /Error loading .*\/([a-z-]+)\.config\./;
 const extractFailedPluginName = (error) => {
 	return String(error).match(CONFIG_LOADING_ERROR_PATTERN)?.[1] ?? null;
 };
-const MAX_KNIP_RETRIES = 5;
 const runKnipWithOptions = async (knipCwd, workspaceName) => {
 	const options = await silenced(() => createOptions({
 		cwd: knipCwd,
@@ -1019,7 +1246,70 @@ const resolvePluginPath = () => {
 const resolveDiagnosticCategory = (plugin, rule) => {
 	return RULE_CATEGORY_MAP[`${plugin}/${rule}`] ?? PLUGIN_CATEGORY_MAP[plugin] ?? "Other";
 };
-const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompiler, includePaths) => {
+const estimateArgsLength = (args) => args.reduce((total, argument) => total + argument.length + 1, 0);
+const batchIncludePaths = (baseArgs, includePaths) => {
+	const baseArgsLength = estimateArgsLength(baseArgs);
+	const batches = [];
+	let currentBatch = [];
+	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, rootDirectory, nodeBinaryPath) => new Promise((resolve, reject) => {
+	const child = spawn(nodeBinaryPath, args, { cwd: rootDirectory });
+	const stdoutBuffers = [];
+	const stderrBuffers = [];
+	child.stdout.on("data", (buffer) => stdoutBuffers.push(buffer));
+	child.stderr.on("data", (buffer) => stderrBuffers.push(buffer));
+	child.on("error", (error) => reject(/* @__PURE__ */ 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(/* @__PURE__ */ new Error(`Failed to run oxlint: ${stderrOutput}`));
+				return;
+			}
+		}
+		resolve(output);
+	});
+});
+const parseOxlintOutput = (stdout) => {
+	if (!stdout) return [];
+	let output;
+	try {
+		output = JSON.parse(stdout);
+	} 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)
+		};
+	});
+};
+const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompiler, includePaths, nodeBinaryPath = process.execPath) => {
 	if (includePaths !== void 0 && includePaths.length === 0) return [];
 	const configPath = path.join(os.tmpdir(), `react-doctor-oxlintrc-${process.pid}.json`);
 	const config = createOxlintConfig({
@@ -1030,58 +1320,21 @@ const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompil
 	const restoreDisableDirectives = neutralizeDisableDirectives(rootDirectory);
 	try {
 		fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-		const args = [
+		const baseArgs = [
 			resolveOxlintBinary(),
 			"-c",
 			configPath,
 			"--format",
 			"json"
 		];
-		if (hasTypeScript) args.push("--tsconfig", "./tsconfig.json");
-		if (includePaths !== void 0) args.push(...includePaths);
-		else args.push(".");
-		const stdout = await new Promise((resolve, reject) => {
-			const child = spawn(process.execPath, args, { cwd: rootDirectory });
-			const stdoutBuffers = [];
-			const stderrBuffers = [];
-			child.stdout.on("data", (buffer) => stdoutBuffers.push(buffer));
-			child.stderr.on("data", (buffer) => stderrBuffers.push(buffer));
-			child.on("error", (error) => reject(/* @__PURE__ */ 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(/* @__PURE__ */ new Error(`Failed to run oxlint: ${stderrOutput}`));
-						return;
-					}
-				}
-				resolve(output);
-			});
-		});
-		if (!stdout) return [];
-		let output;
-		try {
-			output = JSON.parse(stdout);
-		} catch {
-			throw new Error(`Failed to parse oxlint output: ${stdout.slice(0, ERROR_PREVIEW_LENGTH_CHARS)}`);
+		if (hasTypeScript) baseArgs.push("--tsconfig", "./tsconfig.json");
+		const fileBatches = includePaths !== void 0 ? batchIncludePaths(baseArgs, includePaths) : [["."]];
+		const allDiagnostics = [];
+		for (const batch of fileBatches) {
+			const stdout = await spawnOxlint([...baseArgs, ...batch], rootDirectory, nodeBinaryPath);
+			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)) fs.unlinkSync(configPath);
@@ -1189,11 +1442,6 @@ const writeDiagnosticsDirectory = (diagnostics) => {
 	writeFileSync(join(outputDirectory, "diagnostics.json"), JSON.stringify(diagnostics, null, 2));
 	return outputDirectory;
 };
-const colorizeByScore$1 = (text, score) => {
-	if (score >= SCORE_GOOD_THRESHOLD) return highlighter.success(text);
-	if (score >= SCORE_OK_THRESHOLD) return highlighter.warn(text);
-	return highlighter.error(text);
-};
 const buildScoreBarSegments = (score) => {
 	const filledCount = Math.round(score / PERFECT_SCORE * SCORE_BAR_WIDTH_CHARS);
 	const emptyCount = SCORE_BAR_WIDTH_CHARS - filledCount;
@@ -1208,11 +1456,11 @@ const buildPlainScoreBar = (score) => {
 };
 const buildScoreBar = (score) => {
 	const { filledSegment, emptySegment } = buildScoreBarSegments(score);
-	return colorizeByScore$1(filledSegment, score) + highlighter.dim(emptySegment);
+	return colorizeByScore(filledSegment, score) + highlighter.dim(emptySegment);
 };
 const printScoreGauge = (score, label) => {
-	const scoreDisplay = colorizeByScore$1(`${score}`, score);
-	const labelDisplay = colorizeByScore$1(label, score);
+	const scoreDisplay = colorizeByScore(`${score}`, score);
+	const labelDisplay = colorizeByScore(label, score);
 	logger.log(`  ${scoreDisplay} / ${PERFECT_SCORE}  ${labelDisplay}`);
 	logger.break();
 	logger.log(`  ${buildScoreBar(score)}`);
@@ -1226,7 +1474,7 @@ const getDoctorFace = (score) => {
 const printBranding = (score) => {
 	if (score !== void 0) {
 		const [eyes, mouth] = getDoctorFace(score);
-		const colorize = (text) => colorizeByScore$1(text, score);
+		const colorize = (text) => colorizeByScore(text, score);
 		logger.log(colorize("  ┌─────┐"));
 		logger.log(colorize(`  │ ${eyes} │`));
 		logger.log(colorize(`  │ ${mouth} │`));
@@ -1247,53 +1495,56 @@ const buildShareUrl = (diagnostics, scoreResult, projectName) => {
 	if (affectedFileCount > 0) params.set("f", String(affectedFileCount));
 	return `${SHARE_BASE_URL}?${params.toString()}`;
 };
-const printSummary = (diagnostics, elapsedMilliseconds, scoreResult, projectName, totalSourceFileCount, noScoreMessage) => {
+const buildBrandingLines = (scoreResult, noScoreMessage) => {
+	const lines = [];
+	if (scoreResult) {
+		const [eyes, mouth] = getDoctorFace(scoreResult.score);
+		const scoreColorizer = (text) => colorizeByScore(text, scoreResult.score);
+		lines.push(createFramedLine("┌─────┐", scoreColorizer("┌─────┐")));
+		lines.push(createFramedLine(`│ ${eyes} │`, scoreColorizer(`│ ${eyes} │`)));
+		lines.push(createFramedLine(`│ ${mouth} │`, scoreColorizer(`│ ${mouth} │`)));
+		lines.push(createFramedLine("└─────┘", scoreColorizer("└─────┘")));
+		lines.push(createFramedLine("React Doctor (www.react.doctor)", `React Doctor ${highlighter.dim("(www.react.doctor)")}`));
+		lines.push(createFramedLine(""));
+		const scoreLinePlainText = `${scoreResult.score} / ${PERFECT_SCORE}  ${scoreResult.label}`;
+		const scoreLineRenderedText = `${colorizeByScore(String(scoreResult.score), scoreResult.score)} / ${PERFECT_SCORE}  ${colorizeByScore(scoreResult.label, scoreResult.score)}`;
+		lines.push(createFramedLine(scoreLinePlainText, scoreLineRenderedText));
+		lines.push(createFramedLine(""));
+		lines.push(createFramedLine(buildPlainScoreBar(scoreResult.score), buildScoreBar(scoreResult.score)));
+		lines.push(createFramedLine(""));
+	} else {
+		lines.push(createFramedLine("React Doctor (www.react.doctor)", `React Doctor ${highlighter.dim("(www.react.doctor)")}`));
+		lines.push(createFramedLine(""));
+		lines.push(createFramedLine(noScoreMessage, highlighter.dim(noScoreMessage)));
+		lines.push(createFramedLine(""));
+	}
+	return lines;
+};
+const buildCountsSummaryLine = (diagnostics, totalSourceFileCount, elapsedMilliseconds) => {
 	const errorCount = diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
 	const warningCount = diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length;
 	const affectedFileCount = collectAffectedFiles(diagnostics).size;
 	const elapsed = formatElapsedTime(elapsedMilliseconds);
-	const summaryLineParts = [];
-	const summaryLinePartsPlain = [];
+	const plainParts = [];
+	const renderedParts = [];
 	if (errorCount > 0) {
 		const errorText = `✗ ${errorCount} error${errorCount === 1 ? "" : "s"}`;
-		summaryLinePartsPlain.push(errorText);
-		summaryLineParts.push(highlighter.error(errorText));
+		plainParts.push(errorText);
+		renderedParts.push(highlighter.error(errorText));
 	}
 	if (warningCount > 0) {
 		const warningText = `⚠ ${warningCount} warning${warningCount === 1 ? "" : "s"}`;
-		summaryLinePartsPlain.push(warningText);
-		summaryLineParts.push(highlighter.warn(warningText));
+		plainParts.push(warningText);
+		renderedParts.push(highlighter.warn(warningText));
 	}
 	const fileCountText = totalSourceFileCount > 0 ? `across ${affectedFileCount}/${totalSourceFileCount} files` : `across ${affectedFileCount} file${affectedFileCount === 1 ? "" : "s"}`;
 	const elapsedTimeText = `in ${elapsed}`;
-	summaryLinePartsPlain.push(fileCountText);
-	summaryLinePartsPlain.push(elapsedTimeText);
-	summaryLineParts.push(highlighter.dim(fileCountText));
-	summaryLineParts.push(highlighter.dim(elapsedTimeText));
-	const summaryFramedLines = [];
-	if (scoreResult) {
-		const [eyes, mouth] = getDoctorFace(scoreResult.score);
-		const scoreColorizer = (text) => colorizeByScore$1(text, scoreResult.score);
-		summaryFramedLines.push(createFramedLine("┌─────┐", scoreColorizer("┌─────┐")));
-		summaryFramedLines.push(createFramedLine(`│ ${eyes} │`, scoreColorizer(`│ ${eyes} │`)));
-		summaryFramedLines.push(createFramedLine(`│ ${mouth} │`, scoreColorizer(`│ ${mouth} │`)));
-		summaryFramedLines.push(createFramedLine("└─────┘", scoreColorizer("└─────┘")));
-		summaryFramedLines.push(createFramedLine("React Doctor (www.react.doctor)", `React Doctor ${highlighter.dim("(www.react.doctor)")}`));
-		summaryFramedLines.push(createFramedLine(""));
-		const scoreLinePlainText = `${scoreResult.score} / ${PERFECT_SCORE}  ${scoreResult.label}`;
-		const scoreLineRenderedText = `${colorizeByScore$1(String(scoreResult.score), scoreResult.score)} / ${PERFECT_SCORE}  ${colorizeByScore$1(scoreResult.label, scoreResult.score)}`;
-		summaryFramedLines.push(createFramedLine(scoreLinePlainText, scoreLineRenderedText));
-		summaryFramedLines.push(createFramedLine(""));
-		summaryFramedLines.push(createFramedLine(buildPlainScoreBar(scoreResult.score), buildScoreBar(scoreResult.score)));
-		summaryFramedLines.push(createFramedLine(""));
-	} else {
-		summaryFramedLines.push(createFramedLine("React Doctor (www.react.doctor)", `React Doctor ${highlighter.dim("(www.react.doctor)")}`));
-		summaryFramedLines.push(createFramedLine(""));
-		summaryFramedLines.push(createFramedLine(noScoreMessage, highlighter.dim(noScoreMessage)));
-		summaryFramedLines.push(createFramedLine(""));
-	}
-	summaryFramedLines.push(createFramedLine(summaryLinePartsPlain.join("  "), summaryLineParts.join("  ")));
-	printFramedBox(summaryFramedLines);
+	plainParts.push(fileCountText, elapsedTimeText);
+	renderedParts.push(highlighter.dim(fileCountText), highlighter.dim(elapsedTimeText));
+	return createFramedLine(plainParts.join("  "), renderedParts.join("  "));
+};
+const printSummary = (diagnostics, elapsedMilliseconds, scoreResult, projectName, totalSourceFileCount, noScoreMessage) => {
+	printFramedBox([...buildBrandingLines(scoreResult, noScoreMessage), buildCountsSummaryLine(diagnostics, totalSourceFileCount, elapsedMilliseconds)]);
 	try {
 		const diagnosticsDirectory = writeDiagnosticsDirectory(diagnostics);
 		logger.break();
@@ -1305,49 +1556,97 @@ const printSummary = (diagnostics, elapsedMilliseconds, scoreResult, projectName
 	logger.break();
 	logger.dim(`  Share your results: ${highlighter.info(shareUrl)}`);
 };
+const resolveOxlintNode = async (isLintEnabled, isScoreOnly) => {
+	if (!isLintEnabled) return null;
+	const nodeResolution = resolveNodeForOxlint();
+	if (nodeResolution) {
+		if (!nodeResolution.isCurrentNode && !isScoreOnly) {
+			logger.warn(`Node ${process.version} is unsupported by oxlint. Using Node ${nodeResolution.version} from nvm.`);
+			logger.break();
+		}
+		return nodeResolution.binaryPath;
+	}
+	if (isScoreOnly) return null;
+	logger.warn(`Node ${process.version} is not compatible with oxlint (requires ${OXLINT_NODE_REQUIREMENT}). Lint checks will be skipped.`);
+	if (isNvmInstalled() && process.stdin.isTTY) {
+		const { shouldInstallNode } = await prompts({
+			type: "confirm",
+			name: "shouldInstallNode",
+			message: `Install Node ${OXLINT_RECOMMENDED_NODE_MAJOR} via nvm to enable lint checks?`,
+			initial: true
+		});
+		if (shouldInstallNode) {
+			logger.break();
+			const freshResolution = installNodeViaNvm() ? resolveNodeForOxlint() : null;
+			if (freshResolution) {
+				logger.break();
+				logger.success(`Node ${freshResolution.version} installed. Using it for lint checks.`);
+				logger.break();
+				return freshResolution.binaryPath;
+			}
+			logger.break();
+			logger.warn("Failed to install Node via nvm. Skipping lint checks.");
+			logger.break();
+			return null;
+		}
+	} else if (isNvmInstalled()) logger.dim(`  Run: nvm install ${OXLINT_RECOMMENDED_NODE_MAJOR}`);
+	else logger.dim(`  Install nvm (https://github.com/nvm-sh/nvm) and run: nvm install ${OXLINT_RECOMMENDED_NODE_MAJOR}`);
+	logger.break();
+	return null;
+};
+const mergeScanOptions = (inputOptions, userConfig) => ({
+	lint: inputOptions.lint ?? userConfig?.lint ?? true,
+	deadCode: inputOptions.deadCode ?? userConfig?.deadCode ?? true,
+	verbose: inputOptions.verbose ?? userConfig?.verbose ?? false,
+	scoreOnly: inputOptions.scoreOnly ?? false,
+	offline: inputOptions.offline ?? false,
+	includePaths: inputOptions.includePaths ?? []
+});
+const printProjectDetection = (projectInfo, userConfig, isDiffMode, includePaths) => {
+	const frameworkLabel = formatFrameworkName(projectInfo.framework);
+	const languageLabel = projectInfo.hasTypeScript ? "TypeScript" : "JavaScript";
+	const completeStep = (message) => {
+		spinner(message).start().succeed(message);
+	};
+	completeStep(`Detecting framework. Found ${highlighter.info(frameworkLabel)}.`);
+	completeStep(`Detecting React version. Found ${highlighter.info(`React ${projectInfo.reactVersion}`)}.`);
+	completeStep(`Detecting language. Found ${highlighter.info(languageLabel)}.`);
+	completeStep(`Detecting React Compiler. ${projectInfo.hasReactCompiler ? highlighter.info("Found React Compiler.") : "Not found."}`);
+	if (isDiffMode) completeStep(`Scanning ${highlighter.info(`${includePaths.length}`)} changed source files.`);
+	else completeStep(`Found ${highlighter.info(`${projectInfo.sourceFileCount}`)} source files.`);
+	if (userConfig) completeStep(`Loaded ${highlighter.info("react-doctor config")}.`);
+	logger.break();
+};
 const scan = async (directory, inputOptions = {}) => {
 	const startTime = performance.now();
 	const projectInfo = discoverProject(directory);
 	const userConfig = loadConfig(directory);
-	const options = {
-		lint: inputOptions.lint ?? userConfig?.lint ?? true,
-		deadCode: inputOptions.deadCode ?? userConfig?.deadCode ?? true,
-		verbose: inputOptions.verbose ?? userConfig?.verbose ?? false,
-		scoreOnly: inputOptions.scoreOnly ?? false,
-		offline: inputOptions.offline ?? false,
-		includePaths: inputOptions.includePaths
-	};
-	const includePaths = options.includePaths ?? [];
+	const options = mergeScanOptions(inputOptions, userConfig);
+	const { includePaths } = options;
 	const isDiffMode = includePaths.length > 0;
 	if (!projectInfo.reactVersion) throw new Error("No React dependency found in package.json");
-	if (!options.scoreOnly) {
-		const frameworkLabel = formatFrameworkName(projectInfo.framework);
-		const languageLabel = projectInfo.hasTypeScript ? "TypeScript" : "JavaScript";
-		const completeStep = (message) => {
-			spinner(message).start().succeed(message);
-		};
-		completeStep(`Detecting framework. Found ${highlighter.info(frameworkLabel)}.`);
-		completeStep(`Detecting React version. Found ${highlighter.info(`React ${projectInfo.reactVersion}`)}.`);
-		completeStep(`Detecting language. Found ${highlighter.info(languageLabel)}.`);
-		completeStep(`Detecting React Compiler. ${projectInfo.hasReactCompiler ? highlighter.info("Found React Compiler.") : "Not found."}`);
-		if (isDiffMode) completeStep(`Scanning ${highlighter.info(`${includePaths.length}`)} changed source files.`);
-		else completeStep(`Found ${highlighter.info(`${projectInfo.sourceFileCount}`)} source files.`);
-		if (userConfig) completeStep(`Loaded ${highlighter.info("react-doctor config")}.`);
-		logger.break();
-	}
-	const jsxIncludePaths = isDiffMode ? includePaths.filter((filePath) => JSX_FILE_PATTERN.test(filePath)) : void 0;
-	const lintPromise = options.lint ? (async () => {
+	if (!options.scoreOnly) printProjectDetection(projectInfo, userConfig, isDiffMode, includePaths);
+	const jsxIncludePaths = computeJsxIncludePaths(includePaths);
+	let didLintFail = false;
+	let didDeadCodeFail = false;
+	const resolvedNodeBinaryPath = await resolveOxlintNode(options.lint, options.scoreOnly);
+	if (options.lint && !resolvedNodeBinaryPath) didLintFail = true;
+	const lintPromise = resolvedNodeBinaryPath ? (async () => {
 		const lintSpinner = options.scoreOnly ? null : spinner("Running lint checks...").start();
 		try {
-			const lintDiagnostics = await runOxlint(directory, projectInfo.hasTypeScript, projectInfo.framework, projectInfo.hasReactCompiler, jsxIncludePaths);
+			const lintDiagnostics = await runOxlint(directory, projectInfo.hasTypeScript, projectInfo.framework, projectInfo.hasReactCompiler, jsxIncludePaths, resolvedNodeBinaryPath);
 			lintSpinner?.succeed("Running lint checks.");
 			return lintDiagnostics;
 		} catch (error) {
-			lintSpinner?.fail("Lint checks failed (non-fatal, skipping).");
-			if (error instanceof Error) {
-				logger.error(error.message);
-				if (error.stack) logger.dim(error.stack);
-			} else logger.error(String(error));
+			didLintFail = true;
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			if (errorMessage.includes("native binding")) {
+				lintSpinner?.fail(`Lint checks failed — oxlint native binding not found (Node ${process.version}).`);
+				logger.dim(`  Upgrade to Node ${OXLINT_NODE_REQUIREMENT} or run: npx -p oxlint@latest react-doctor@latest`);
+			} else {
+				lintSpinner?.fail("Lint checks failed (non-fatal, skipping).");
+				logger.error(errorMessage);
+			}
 			return [];
 		}
 	})() : Promise.resolve([]);
@@ -1358,19 +1657,19 @@ const scan = async (directory, inputOptions = {}) => {
 			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 [];
 		}
 	})() : Promise.resolve([]);
 	const [lintDiagnostics, deadCodeDiagnostics] = await Promise.all([lintPromise, deadCodePromise]);
-	const allDiagnostics = [
-		...lintDiagnostics,
-		...deadCodeDiagnostics,
-		...isDiffMode ? [] : checkReducedMotion(directory)
-	];
-	const diagnostics = userConfig ? filterIgnoredDiagnostics(allDiagnostics, userConfig) : allDiagnostics;
+	const diagnostics = combineDiagnostics(lintDiagnostics, deadCodeDiagnostics, directory, isDiffMode, userConfig);
 	const elapsedMilliseconds = performance.now() - startTime;
+	const skippedChecks = [];
+	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;
 	if (options.scoreOnly) {
@@ -1378,27 +1677,41 @@ const scan = async (directory, inputOptions = {}) => {
 		else logger.dim(noScoreMessage);
 		return {
 			diagnostics,
-			scoreResult
+			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
+			scoreResult,
+			skippedChecks
 		};
 	}
 	printDiagnostics(diagnostics, options.verbose);
 	const displayedSourceFileCount = isDiffMode ? includePaths.length : projectInfo.sourceFileCount;
 	printSummary(diagnostics, elapsedMilliseconds, scoreResult, projectInfo.projectName, displayedSourceFileCount, noScoreMessage);
+	if (hasSkippedChecks) {
+		const skippedLabel = skippedChecks.join(" and ");
+		logger.break();
+		logger.warn(`  Note: ${skippedLabel} checks failed — score may be incomplete.`);
+	}
 	return {
 		diagnostics,
-		scoreResult
+		scoreResult,
+		skippedChecks
 	};
 };
 
@@ -1496,92 +1809,6 @@ const handleError = (error, options = DEFAULT_HANDLE_ERROR_OPTIONS) => {
 	process.exitCode = 1;
 };
 
-//#endregion
-//#region src/utils/should-auto-select-current-choice.ts
-const shouldAutoSelectCurrentChoice = (choiceStates, cursor) => {
-	if (choiceStates.some((choiceState) => choiceState.selected)) return false;
-	const currentChoice = choiceStates[cursor];
-	return Boolean(currentChoice) && !currentChoice.disabled;
-};
-
-//#endregion
-//#region src/utils/should-select-all-choices.ts
-const shouldSelectAllChoices = (choiceStates) => {
-	return choiceStates.filter((choiceState) => !choiceState.disabled).some((choiceState) => choiceState.selected !== true);
-};
-
-//#endregion
-//#region src/utils/prompts.ts
-const require = createRequire(import.meta.url);
-const PROMPTS_MULTISELECT_MODULE_PATH = "prompts/lib/elements/multiselect";
-const PROMPTS_SELECT_MODULE_PATH = "prompts/lib/elements/select";
-let didPatchMultiselectToggleAll = false;
-let didPatchMultiselectSubmit = false;
-let didPatchSelectBanner = false;
-const selectBannerMap = /* @__PURE__ */ new Map();
-const setSelectBanner = (banner, targetIndex) => {
-	selectBannerMap.set(targetIndex, banner);
-};
-const clearSelectBanner = () => {
-	selectBannerMap.clear();
-};
-const onCancel = () => {
-	logger.break();
-	logger.log("Cancelled.");
-	logger.dim("Run `npx react-doctor@latest --fix` to fix issues.");
-	logger.break();
-	process.exit(0);
-};
-const patchMultiselectToggleAll = () => {
-	if (didPatchMultiselectToggleAll) return;
-	didPatchMultiselectToggleAll = true;
-	const multiselectPromptConstructor = require(PROMPTS_MULTISELECT_MODULE_PATH);
-	multiselectPromptConstructor.prototype.toggleAll = function() {
-		const isCurrentChoiceDisabled = Boolean(this.value[this.cursor]?.disabled);
-		if (this.maxChoices !== void 0 || isCurrentChoiceDisabled) {
-			this.bell();
-			return;
-		}
-		const shouldSelectAllEnabledChoices = shouldSelectAllChoices(this.value);
-		for (const choiceState of this.value) {
-			if (choiceState.disabled) continue;
-			choiceState.selected = shouldSelectAllEnabledChoices;
-		}
-		this.render();
-	};
-};
-const patchMultiselectSubmit = () => {
-	if (didPatchMultiselectSubmit) return;
-	didPatchMultiselectSubmit = true;
-	const multiselectPromptConstructor = require(PROMPTS_MULTISELECT_MODULE_PATH);
-	const originalSubmit = multiselectPromptConstructor.prototype.submit;
-	multiselectPromptConstructor.prototype.submit = function() {
-		if (shouldAutoSelectCurrentChoice(this.value, this.cursor)) this.value[this.cursor].selected = true;
-		originalSubmit.call(this);
-	};
-};
-const patchSelectBanner = () => {
-	if (didPatchSelectBanner) return;
-	didPatchSelectBanner = true;
-	const selectConstructor = require(PROMPTS_SELECT_MODULE_PATH);
-	const promptsClear = require("prompts/lib/util/clear");
-	const originalRender = selectConstructor.prototype.render;
-	selectConstructor.prototype.render = function() {
-		originalRender.call(this);
-		const banner = selectBannerMap.get(this.cursor);
-		if (!banner || this.closed || this.done) return;
-		this.out.write(promptsClear(this.outputText, this.out.columns));
-		this.outputText = `${banner}\n\n${this.outputText}`;
-		this.out.write(this.outputText);
-	};
-};
-const prompts = (questions) => {
-	patchMultiselectToggleAll();
-	patchMultiselectSubmit();
-	patchSelectBanner();
-	return basePrompts(questions, { onCancel });
-};
-
 //#endregion
 //#region src/utils/select-projects.ts
 const selectProjects = async (rootDirectory, projectFlag, skipPrompts) => {
@@ -1632,8 +1859,43 @@ const promptProjectSelection = async (workspacePackages, rootDirectory) => {
 
 //#endregion
 //#region src/utils/skill-prompt.ts
-const CONFIG_DIRECTORY = join(homedir(), ".react-doctor");
+const HOME_DIRECTORY = homedir();
+const CONFIG_DIRECTORY = join(HOME_DIRECTORY, ".react-doctor");
 const CONFIG_FILE = join(CONFIG_DIRECTORY, "config.json");
+const SKILL_NAME = "react-doctor";
+const WINDSURF_MARKER = "# React Doctor";
+const SKILL_DESCRIPTION = "Run after making React changes to catch issues early. Use when reviewing code, finishing a feature, or fixing bugs in a React project.";
+const SKILL_BODY = `Scans your React codebase for security, performance, correctness, and architecture issues. Outputs a 0-100 score with actionable diagnostics.
+
+## Usage
+
+\`\`\`bash
+npx -y react-doctor@latest . --verbose --diff
+\`\`\`
+
+## Workflow
+
+Run after making changes to catch issues early. Fix errors first, then re-run to verify the score improved.`;
+const SKILL_CONTENT = `---
+name: ${SKILL_NAME}
+description: ${SKILL_DESCRIPTION}
+version: 1.0.0
+---
+
+# React Doctor
+
+${SKILL_BODY}
+`;
+const AGENTS_CONTENT = `# React Doctor
+
+${SKILL_DESCRIPTION}
+
+${SKILL_BODY}
+`;
+const CODEX_AGENT_CONFIG = `interface:
+  display_name: "${SKILL_NAME}"
+  short_description: "Diagnose and fix React codebase health issues"
+`;
 const readSkillPromptConfig = () => {
 	try {
 		if (!existsSync(CONFIG_FILE)) return {};
@@ -1644,18 +1906,101 @@ const readSkillPromptConfig = () => {
 };
 const writeSkillPromptConfig = (config) => {
 	try {
-		if (!existsSync(CONFIG_DIRECTORY)) mkdirSync(CONFIG_DIRECTORY, { recursive: true });
+		mkdirSync(CONFIG_DIRECTORY, { recursive: true });
 		writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 	} catch {}
 };
+const writeSkillFiles = (directory) => {
+	mkdirSync(directory, { recursive: true });
+	writeFileSync(join(directory, "SKILL.md"), SKILL_CONTENT);
+	writeFileSync(join(directory, "AGENTS.md"), AGENTS_CONTENT);
+};
+const isCommandAvailable = (command) => {
+	try {
+		execSync(`${process.platform === "win32" ? "where" : "which"} ${command}`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+};
+const SKILL_TARGETS = [
+	{
+		name: "Claude Code",
+		detect: () => existsSync(join(HOME_DIRECTORY, ".claude")),
+		install: () => writeSkillFiles(join(HOME_DIRECTORY, ".claude", "skills", SKILL_NAME))
+	},
+	{
+		name: "Amp Code",
+		detect: () => existsSync(join(HOME_DIRECTORY, ".amp")),
+		install: () => writeSkillFiles(join(HOME_DIRECTORY, ".config", "amp", "skills", SKILL_NAME))
+	},
+	{
+		name: "Cursor",
+		detect: () => existsSync(join(HOME_DIRECTORY, ".cursor")),
+		install: () => writeSkillFiles(join(HOME_DIRECTORY, ".cursor", "skills", SKILL_NAME))
+	},
+	{
+		name: "OpenCode",
+		detect: () => isCommandAvailable("opencode") || existsSync(join(HOME_DIRECTORY, ".config", "opencode")),
+		install: () => writeSkillFiles(join(HOME_DIRECTORY, ".config", "opencode", "skills", SKILL_NAME))
+	},
+	{
+		name: "Windsurf",
+		detect: () => existsSync(join(HOME_DIRECTORY, ".codeium")) || existsSync(join(HOME_DIRECTORY, "Library", "Application Support", "Windsurf")),
+		install: () => {
+			const memoriesDirectory = join(HOME_DIRECTORY, ".codeium", "windsurf", "memories");
+			mkdirSync(memoriesDirectory, { recursive: true });
+			const rulesFile = join(memoriesDirectory, "global_rules.md");
+			if (existsSync(rulesFile)) {
+				if (readFileSync(rulesFile, "utf-8").includes(WINDSURF_MARKER)) return;
+				appendFileSync(rulesFile, `\n${WINDSURF_MARKER}\n\n${SKILL_CONTENT}`);
+			} else writeFileSync(rulesFile, `${WINDSURF_MARKER}\n\n${SKILL_CONTENT}`);
+		}
+	},
+	{
+		name: "Antigravity",
+		detect: () => isCommandAvailable("agy") || existsSync(join(HOME_DIRECTORY, ".gemini", "antigravity")),
+		install: () => writeSkillFiles(join(HOME_DIRECTORY, ".gemini", "antigravity", "skills", SKILL_NAME))
+	},
+	{
+		name: "Gemini CLI",
+		detect: () => isCommandAvailable("gemini") || existsSync(join(HOME_DIRECTORY, ".gemini")),
+		install: () => writeSkillFiles(join(HOME_DIRECTORY, ".gemini", "skills", SKILL_NAME))
+	},
+	{
+		name: "Codex",
+		detect: () => isCommandAvailable("codex") || existsSync(join(HOME_DIRECTORY, ".codex")),
+		install: () => {
+			const skillDirectory = join(HOME_DIRECTORY, ".codex", "skills", SKILL_NAME);
+			writeSkillFiles(skillDirectory);
+			const agentsDirectory = join(skillDirectory, "agents");
+			mkdirSync(agentsDirectory, { recursive: true });
+			writeFileSync(join(agentsDirectory, "openai.yaml"), CODEX_AGENT_CONFIG);
+		}
+	}
+];
 const installSkill = () => {
+	let installedCount = 0;
+	for (const target of SKILL_TARGETS) {
+		if (!target.detect()) continue;
+		try {
+			target.install();
+			logger.log(`  ${highlighter.success("✔")} ${target.name}`);
+			installedCount++;
+		} catch {
+			logger.dim(`  ✗ ${target.name} (failed)`);
+		}
+	}
 	try {
-		execSync(`curl -fsSL ${INSTALL_SKILL_URL} | bash`, { stdio: "inherit" });
+		writeSkillFiles(join(".agents", SKILL_NAME));
+		logger.log(`  ${highlighter.success("✔")} .agents/`);
+		installedCount++;
 	} catch {
-		logger.break();
-		logger.dim("Skill install failed. You can install manually:");
-		logger.dim(`  curl -fsSL ${INSTALL_SKILL_URL} | bash`);
+		logger.dim("  ✗ .agents/ (failed)");
 	}
+	logger.break();
+	if (installedCount === 0) logger.dim("No supported tools detected.");
+	else logger.success("Done! The skill will activate when working on React projects.");
 };
 const maybePromptSkillInstall = async (shouldSkipPrompts) => {
 	const config = readSkillPromptConfig();
@@ -1684,7 +2029,7 @@ const maybePromptSkillInstall = async (shouldSkipPrompts) => {
 
 //#endregion
 //#region src/cli.ts
-const VERSION = "0.0.26";
+const VERSION = "0.0.28";
 const exitWithFixHint = () => {
 	logger.break();
 	logger.log("Cancelled.");
@@ -1694,6 +2039,26 @@ const exitWithFixHint = () => {
 };
 process.on("SIGINT", exitWithFixHint);
 process.on("SIGTERM", exitWithFixHint);
+const AUTOMATED_ENVIRONMENT_VARIABLES = [
+	"CI",
+	"CLAUDECODE",
+	"CURSOR_AGENT",
+	"CODEX_CI",
+	"OPENCODE",
+	"AMP_HOME",
+	"AMI"
+];
+const isAutomatedEnvironment = () => AUTOMATED_ENVIRONMENT_VARIABLES.some((envVariable) => Boolean(process.env[envVariable]));
+const resolveCliScanOptions = (flags, userConfig, programInstance) => {
+	const isCliOverride = (optionName) => programInstance.getOptionValueSource(optionName) === "cli";
+	return {
+		lint: isCliOverride("lint") ? flags.lint : userConfig?.lint ?? flags.lint,
+		deadCode: isCliOverride("deadCode") ? flags.deadCode : userConfig?.deadCode ?? flags.deadCode,
+		verbose: isCliOverride("verbose") ? Boolean(flags.verbose) : userConfig?.verbose ?? false,
+		scoreOnly: flags.score,
+		offline: flags.offline
+	};
+};
 const resolveDiffMode = async (diffInfo, effectiveDiff, shouldSkipPrompts, isScoreOnly) => {
 	if (effectiveDiff !== void 0 && effectiveDiff !== false) {
 		if (diffInfo) return true;
@@ -1725,27 +2090,11 @@ const program = new Command().name("react-doctor").description("Diagnose React c
 			logger.log(`react-doctor v${VERSION}`);
 			logger.break();
 		}
-		const isCliOverride = (optionName) => program.getOptionValueSource(optionName) === "cli";
-		const scanOptions = {
-			lint: isCliOverride("lint") ? flags.lint : userConfig?.lint ?? flags.lint,
-			deadCode: isCliOverride("deadCode") ? flags.deadCode : userConfig?.deadCode ?? flags.deadCode,
-			verbose: isCliOverride("verbose") ? Boolean(flags.verbose) : userConfig?.verbose ?? false,
-			scoreOnly: isScoreOnly,
-			offline: flags.offline
-		};
-		const isAutomatedEnvironment = [
-			process.env.CI,
-			process.env.CLAUDECODE,
-			process.env.CURSOR_AGENT,
-			process.env.CODEX_CI,
-			process.env.OPENCODE,
-			process.env.AMP_HOME,
-			process.env.AMI
-		].some(Boolean);
-		const shouldSkipPrompts = flags.yes || isAutomatedEnvironment || !process.stdin.isTTY;
+		const scanOptions = resolveCliScanOptions(flags, userConfig, program);
+		const shouldSkipPrompts = flags.yes || isAutomatedEnvironment() || !process.stdin.isTTY;
 		const shouldSkipAmiPrompts = shouldSkipPrompts || !flags.ami;
 		const projectDirectories = await selectProjects(resolvedDirectory, flags.project, shouldSkipPrompts);
-		const effectiveDiff = isCliOverride("diff") ? flags.diff : userConfig?.diff;
+		const effectiveDiff = program.getOptionValueSource("diff") === "cli" ? flags.diff : userConfig?.diff;
 		const explicitBaseBranch = typeof effectiveDiff === "string" ? effectiveDiff : void 0;
 		const diffInfo = getDiffInfo(resolvedDirectory, explicitBaseBranch);
 		const isDiffMode = await resolveDiffMode(diffInfo, effectiveDiff, shouldSkipPrompts, isScoreOnly);
@@ -1794,15 +2143,7 @@ const program = new Command().name("react-doctor").description("Diagnose React c
 ${highlighter.dim("Learn more:")}
   ${highlighter.info("https://github.com/millionco/react-doctor")}
 `);
-const AMI_WEBSITE_URL = "https://ami.dev";
-const AMI_INSTALL_URL = `${AMI_WEBSITE_URL}/install.sh`;
-const AMI_RELEASES_URL = "https://github.com/millionco/ami-releases/releases";
-const colorizeByScore = (text, score) => {
-	if (score >= SCORE_GOOD_THRESHOLD) return highlighter.success(text);
-	if (score >= SCORE_OK_THRESHOLD) return highlighter.warn(text);
-	return highlighter.error(text);
-};
-const DEEPLINK_FIX_PROMPT = "Run `npx -y react-doctor@latest .` to diagnose issues, then fix all reported issues one by one. After applying fixes, run it again to verify the results improved.";
+const DEEPLINK_FIX_PROMPT = "/{slash-command:ami:react-doctor}";
 const isAmiInstalled = () => {
 	if (process.platform === "darwin") return existsSync("/Applications/Ami.app") || existsSync(path.join(os.homedir(), "Applications", "Ami.app"));
 	if (process.platform === "win32") {
@@ -1840,6 +2181,7 @@ const buildDeeplinkParams = (directory) => {
 	params.set("prompt", DEEPLINK_FIX_PROMPT);
 	params.set("mode", "agent");
 	params.set("autoSubmit", "true");
+	params.set("source", "react-doctor");
 	return params;
 };
 const buildDeeplink = (directory) => `ami://open-project?${buildDeeplinkParams(directory).toString()}`;
@@ -1911,7 +2253,7 @@ const maybePromptFix = async (directory, diagnostics, estimatedScoreResult) => {
 		name: "fixMethod",
 		message: "Fix issues?",
 		choices: [{
-			title: "Use ami.dev (recommended)",
+			title: "Use Ami (recommended)",
 			description: "Optimized coding agent for React Doctor",
 			value: FIX_METHOD_AMI
 		}, {