react-doctor 0.0.29 → 0.0.31

package/dist/cli.js

@@ -32,8 +32,7 @@ const OPEN_BASE_URL = "https://www.react.doctor/open";
 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 OFFLINE_MESSAGE = "Score calculated locally (offline mode).";
 const DEFAULT_BRANCH_CANDIDATES = ["main", "master"];
 const ERROR_RULE_PENALTY = 1.5;
 const WARNING_RULE_PENALTY = .75;
@@ -42,6 +41,12 @@ 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 IGNORED_DIRECTORIES = new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"coverage"
+]);
 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";
@@ -129,6 +134,13 @@ const estimateScoreLocally = (diagnostics) => {
 		estimatedLabel: getScoreLabel(estimatedScore)
 	};
 };
+const calculateScoreLocally = (diagnostics) => {
+	const { currentScore, currentLabel } = estimateScoreLocally(diagnostics);
+	return {
+		score: currentScore,
+		label: currentLabel
+	};
+};
 const calculateScore = async (diagnostics) => {
 	try {
 		const response = await proxyFetch(SCORE_API_URL, {
@@ -136,10 +148,10 @@ const calculateScore = async (diagnostics) => {
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ diagnostics })
 		});
-		if (!response.ok) return null;
+		if (!response.ok) return calculateScoreLocally(diagnostics);
 		return await response.json();
 	} catch {
-		return null;
+		return calculateScoreLocally(diagnostics);
 	}
 };
 const fetchEstimatedScore = async (diagnostics) => {
@@ -178,13 +190,33 @@ const colorizeByScore = (text, score) => {
 //#region src/plugin/constants.ts
 const MOTION_LIBRARY_PACKAGES = new Set(["framer-motion", "motion"]);
 
+//#endregion
+//#region src/utils/is-file.ts
+const isFile = (filePath) => {
+	try {
+		return fs.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+};
+
 //#endregion
 //#region src/utils/read-package-json.ts
-const readPackageJson = (packageJsonPath) => JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+const readPackageJson = (packageJsonPath) => {
+	try {
+		return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+	} catch (error) {
+		if (error instanceof Error && "code" in error) {
+			const { code } = error;
+			if (code === "EISDIR" || code === "EACCES") return {};
+		}
+		throw error;
+	}
+};
 
 //#endregion
 //#region src/utils/check-reduced-motion.ts
-const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion";
+const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion|MotionConfig|reducedMotion";
 const REDUCED_MOTION_FILE_GLOBS = "\"*.ts\" \"*.tsx\" \"*.js\" \"*.jsx\" \"*.css\" \"*.scss\"";
 const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 	filePath: "package.json",
@@ -200,7 +232,7 @@ const MISSING_REDUCED_MOTION_DIAGNOSTIC = {
 };
 const checkReducedMotion = (rootDirectory) => {
 	const packageJsonPath = path.join(rootDirectory, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return [];
+	if (!isFile(packageJsonPath)) return [];
 	let hasMotionLibrary = false;
 	try {
 		const packageJson = readPackageJson(packageJsonPath);
@@ -228,7 +260,7 @@ const checkReducedMotion = (rootDirectory) => {
 //#region src/utils/match-glob-pattern.ts
 const REGEX_SPECIAL_CHARACTERS = /[.+^${}()|[\]\\]/g;
 const compileGlobPattern = (pattern) => {
-	const normalizedPattern = pattern.replace(/\\/g, "/");
+	const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\//, "");
 	let regexSource = "^";
 	let characterIndex = 0;
 	while (characterIndex < normalizedPattern.length) if (normalizedPattern[characterIndex] === "*" && normalizedPattern[characterIndex + 1] === "*") if (normalizedPattern[characterIndex + 2] === "/") {
@@ -252,17 +284,72 @@ const compileGlobPattern = (pattern) => {
 	return new RegExp(regexSource);
 };
 
+//#endregion
+//#region src/utils/is-ignored-file.ts
+const toRelativePath = (filePath, rootDirectory) => {
+	const normalizedFilePath = filePath.replace(/\\/g, "/");
+	const normalizedRoot = rootDirectory.replace(/\\/g, "/").replace(/\/$/, "") + "/";
+	if (normalizedFilePath.startsWith(normalizedRoot)) return normalizedFilePath.slice(normalizedRoot.length);
+	return normalizedFilePath.replace(/^\.\//, "");
+};
+const compileIgnoredFilePatterns = (userConfig) => Array.isArray(userConfig?.ignore?.files) ? userConfig.ignore.files.map(compileGlobPattern) : [];
+const isFileIgnoredByPatterns = (filePath, rootDirectory, patterns) => {
+	if (patterns.length === 0) return false;
+	const relativePath = toRelativePath(filePath, rootDirectory);
+	return patterns.some((pattern) => pattern.test(relativePath));
+};
+
 //#endregion
 //#region src/utils/filter-diagnostics.ts
-const filterIgnoredDiagnostics = (diagnostics, config) => {
+const filterIgnoredDiagnostics = (diagnostics, config, rootDirectory) => {
 	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;
 	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;
+		if (isFileIgnoredByPatterns(diagnostic.filePath, rootDirectory, ignoredFilePatterns)) return false;
+		return true;
+	});
+};
+const DISABLE_NEXT_LINE_PATTERN = /\/\/\s*react-doctor-disable-next-line\b(?:\s+(.+))?/;
+const DISABLE_LINE_PATTERN = /\/\/\s*react-doctor-disable-line\b(?:\s+(.+))?/;
+const isRuleSuppressed = (commentRules, ruleId) => {
+	if (!commentRules?.trim()) return true;
+	return commentRules.split(/[,\s]+/).some((rule) => rule.trim() === ruleId);
+};
+const filterInlineSuppressions = (diagnostics, rootDirectory) => {
+	const fileLineCache = /* @__PURE__ */ new Map();
+	const getFileLines = (filePath) => {
+		const cached = fileLineCache.get(filePath);
+		if (cached !== void 0) return cached;
+		const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(rootDirectory, filePath);
+		try {
+			const lines = fs.readFileSync(absolutePath, "utf-8").split("\n");
+			fileLineCache.set(filePath, lines);
+			return lines;
+		} catch {
+			fileLineCache.set(filePath, null);
+			return null;
+		}
+	};
+	return diagnostics.filter((diagnostic) => {
+		if (diagnostic.line <= 0) return true;
+		const lines = getFileLines(diagnostic.filePath);
+		if (!lines) return true;
+		const ruleId = `${diagnostic.plugin}/${diagnostic.rule}`;
+		const currentLine = lines[diagnostic.line - 1];
+		if (currentLine) {
+			const lineMatch = currentLine.match(DISABLE_LINE_PATTERN);
+			if (lineMatch && isRuleSuppressed(lineMatch[1], ruleId)) return false;
+		}
+		if (diagnostic.line >= 2) {
+			const prevLine = lines[diagnostic.line - 2];
+			if (prevLine) {
+				const nextLineMatch = prevLine.match(DISABLE_NEXT_LINE_PATTERN);
+				if (nextLineMatch && isRuleSuppressed(nextLineMatch[1], ruleId)) return false;
+			}
+		}
 		return true;
 	});
 };
@@ -271,21 +358,21 @@ const filterIgnoredDiagnostics = (diagnostics, config) => {
 //#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 = [
+	const merged = [
 		...lintDiagnostics,
 		...deadCodeDiagnostics,
 		...isDiffMode ? [] : checkReducedMotion(directory)
 	];
-	return userConfig ? filterIgnoredDiagnostics(allDiagnostics, userConfig) : allDiagnostics;
+	return filterInlineSuppressions(userConfig ? filterIgnoredDiagnostics(merged, userConfig, directory) : merged, directory);
 };
 
 //#endregion
 //#region src/utils/find-monorepo-root.ts
 const isMonorepoRoot = (directory) => {
-	if (fs.existsSync(path.join(directory, "pnpm-workspace.yaml"))) return true;
-	if (fs.existsSync(path.join(directory, "nx.json"))) return true;
+	if (isFile(path.join(directory, "pnpm-workspace.yaml"))) return true;
+	if (isFile(path.join(directory, "nx.json"))) return true;
 	const packageJsonPath = path.join(directory, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return false;
+	if (!isFile(packageJsonPath)) return false;
 	const packageJson = readPackageJson(packageJsonPath);
 	return Array.isArray(packageJson.workspaces) || Boolean(packageJson.workspaces?.packages);
 };
@@ -298,6 +385,10 @@ const findMonorepoRoot = (startDirectory) => {
 	return null;
 };
 
+//#endregion
+//#region src/utils/is-plain-object.ts
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
 //#endregion
 //#region src/utils/discover-project.ts
 const REACT_COMPILER_PACKAGES = new Set([
@@ -351,12 +442,6 @@ const FRAMEWORK_DISPLAY_NAMES = {
 	unknown: "React"
 };
 const formatFrameworkName = (framework) => FRAMEWORK_DISPLAY_NAMES[framework];
-const IGNORED_DIRECTORIES = new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"coverage"
-]);
 const countSourceFilesViaFilesystem = (rootDirectory) => {
 	let count = 0;
 	const stack = [rootDirectory];
@@ -397,16 +482,129 @@ const detectFramework = (dependencies) => {
 	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
 	return "unknown";
 };
+const isCatalogReference = (version) => version.startsWith("catalog:");
+const extractCatalogName = (version) => {
+	if (!isCatalogReference(version)) return null;
+	const name = version.slice(8).trim();
+	return name.length > 0 ? name : null;
+};
+const resolveVersionFromCatalog = (catalog, packageName) => {
+	const version = catalog[packageName];
+	if (typeof version === "string" && !isCatalogReference(version)) return version;
+	return null;
+};
+const parsePnpmWorkspaceCatalogs = (rootDirectory) => {
+	const workspacePath = path.join(rootDirectory, "pnpm-workspace.yaml");
+	if (!isFile(workspacePath)) return {
+		defaultCatalog: {},
+		namedCatalogs: {}
+	};
+	const content = fs.readFileSync(workspacePath, "utf-8");
+	const defaultCatalog = {};
+	const namedCatalogs = {};
+	let currentSection = "none";
+	let currentCatalogName = "";
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+		const indentLevel = line.search(/\S/);
+		if (indentLevel === 0 && trimmed === "catalog:") {
+			currentSection = "catalog";
+			continue;
+		}
+		if (indentLevel === 0 && trimmed === "catalogs:") {
+			currentSection = "catalogs";
+			continue;
+		}
+		if (indentLevel === 0) {
+			currentSection = "none";
+			continue;
+		}
+		if (currentSection === "catalog" && indentLevel > 0) {
+			const colonIndex = trimmed.indexOf(":");
+			if (colonIndex > 0) {
+				const key = trimmed.slice(0, colonIndex).trim().replace(/["']/g, "");
+				const value = trimmed.slice(colonIndex + 1).trim().replace(/["']/g, "");
+				if (key && value) defaultCatalog[key] = value;
+			}
+			continue;
+		}
+		if (currentSection === "catalogs" && indentLevel > 0) {
+			if (trimmed.endsWith(":") && !trimmed.includes(" ")) {
+				currentCatalogName = trimmed.slice(0, -1).replace(/["']/g, "");
+				currentSection = "named-catalog";
+				namedCatalogs[currentCatalogName] = {};
+				continue;
+			}
+		}
+		if (currentSection === "named-catalog" && indentLevel > 0) {
+			if (indentLevel <= 2 && trimmed.endsWith(":") && !trimmed.includes(" ")) {
+				currentCatalogName = trimmed.slice(0, -1).replace(/["']/g, "");
+				namedCatalogs[currentCatalogName] = {};
+				continue;
+			}
+			const colonIndex = trimmed.indexOf(":");
+			if (colonIndex > 0 && currentCatalogName) {
+				const key = trimmed.slice(0, colonIndex).trim().replace(/["']/g, "");
+				const value = trimmed.slice(colonIndex + 1).trim().replace(/["']/g, "");
+				if (key && value) namedCatalogs[currentCatalogName][key] = value;
+			}
+		}
+	}
+	return {
+		defaultCatalog,
+		namedCatalogs
+	};
+};
+const resolveCatalogVersionFromCollection = (catalogs, packageName, catalogReference) => {
+	if (catalogReference) {
+		const namedCatalog = catalogs.namedCatalogs[catalogReference];
+		if (namedCatalog?.[packageName]) return namedCatalog[packageName];
+	}
+	if (catalogs.defaultCatalog[packageName]) return catalogs.defaultCatalog[packageName];
+	for (const namedCatalog of Object.values(catalogs.namedCatalogs)) if (namedCatalog[packageName]) return namedCatalog[packageName];
+	return null;
+};
+const resolveCatalogVersion = (packageJson, packageName, rootDirectory) => {
+	const rawVersion = collectAllDependencies(packageJson)[packageName];
+	const catalogName = rawVersion ? extractCatalogName(rawVersion) : null;
+	const raw = packageJson;
+	if (isPlainObject(raw.catalog)) {
+		const version = resolveVersionFromCatalog(raw.catalog, packageName);
+		if (version) return version;
+	}
+	if (isPlainObject(raw.catalogs)) {
+		if (catalogName && isPlainObject(raw.catalogs[catalogName])) {
+			const version = resolveVersionFromCatalog(raw.catalogs[catalogName], packageName);
+			if (version) return version;
+		}
+		for (const catalogEntries of Object.values(raw.catalogs)) if (isPlainObject(catalogEntries)) {
+			const version = resolveVersionFromCatalog(catalogEntries, packageName);
+			if (version) return version;
+		}
+	}
+	const workspaces = packageJson.workspaces;
+	if (workspaces && !Array.isArray(workspaces) && isPlainObject(workspaces.catalog)) {
+		const version = resolveVersionFromCatalog(workspaces.catalog, packageName);
+		if (version) return version;
+	}
+	if (rootDirectory) {
+		const pnpmVersion = resolveCatalogVersionFromCollection(parsePnpmWorkspaceCatalogs(rootDirectory), packageName, catalogName);
+		if (pnpmVersion) return pnpmVersion;
+	}
+	return null;
+};
 const extractDependencyInfo = (packageJson) => {
 	const allDependencies = collectAllDependencies(packageJson);
+	const rawVersion = allDependencies.react ?? null;
 	return {
-		reactVersion: allDependencies.react ?? null,
+		reactVersion: rawVersion && !isCatalogReference(rawVersion) ? rawVersion : null,
 		framework: detectFramework(allDependencies)
 	};
 };
 const parsePnpmWorkspacePatterns = (rootDirectory) => {
 	const workspacePath = path.join(rootDirectory, "pnpm-workspace.yaml");
-	if (!fs.existsSync(workspacePath)) return [];
+	if (!isFile(workspacePath)) return [];
 	const content = fs.readFileSync(workspacePath, "utf-8");
 	const patterns = [];
 	let isInsidePackagesBlock = false;
@@ -432,14 +630,14 @@ const resolveWorkspaceDirectories = (rootDirectory, pattern) => {
 	const cleanPattern = pattern.replace(/["']/g, "").replace(/\/\*\*$/, "/*");
 	if (!cleanPattern.includes("*")) {
 		const directoryPath = path.join(rootDirectory, cleanPattern);
-		if (fs.existsSync(directoryPath) && fs.existsSync(path.join(directoryPath, "package.json"))) return [directoryPath];
+		if (fs.existsSync(directoryPath) && isFile(path.join(directoryPath, "package.json"))) return [directoryPath];
 		return [];
 	}
 	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, suffixAfterWildcard)).filter((entryPath) => fs.existsSync(entryPath) && fs.statSync(entryPath).isDirectory() && fs.existsSync(path.join(entryPath, "package.json")));
+	return fs.readdirSync(baseDirectory).map((entry) => path.join(baseDirectory, entry, suffixAfterWildcard)).filter((entryPath) => fs.existsSync(entryPath) && fs.statSync(entryPath).isDirectory() && isFile(path.join(entryPath, "package.json")));
 };
 const findDependencyInfoFromMonorepoRoot = (directory) => {
 	const monorepoRoot = findMonorepoRoot(directory);
@@ -447,11 +645,17 @@ const findDependencyInfoFromMonorepoRoot = (directory) => {
 		reactVersion: null,
 		framework: "unknown"
 	};
-	const rootPackageJson = readPackageJson(path.join(monorepoRoot, "package.json"));
+	const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
+	if (!isFile(monorepoPackageJsonPath)) return {
+		reactVersion: null,
+		framework: "unknown"
+	};
+	const rootPackageJson = readPackageJson(monorepoPackageJsonPath);
 	const rootInfo = extractDependencyInfo(rootPackageJson);
+	const catalogVersion = resolveCatalogVersion(rootPackageJson, "react", monorepoRoot);
 	const workspaceInfo = findReactInWorkspaces(monorepoRoot, rootPackageJson);
 	return {
-		reactVersion: rootInfo.reactVersion ?? workspaceInfo.reactVersion,
+		reactVersion: rootInfo.reactVersion ?? catalogVersion ?? workspaceInfo.reactVersion,
 		framework: rootInfo.framework !== "unknown" ? rootInfo.framework : workspaceInfo.framework
 	};
 };
@@ -485,7 +689,7 @@ const discoverReactSubprojects = (rootDirectory) => {
 	if (!fs.existsSync(rootDirectory) || !fs.statSync(rootDirectory).isDirectory()) return [];
 	const packages = [];
 	const rootPackageJsonPath = path.join(rootDirectory, "package.json");
-	if (fs.existsSync(rootPackageJsonPath)) {
+	if (isFile(rootPackageJsonPath)) {
 		const rootPackageJson = readPackageJson(rootPackageJsonPath);
 		if (hasReactDependency(rootPackageJson)) {
 			const name = rootPackageJson.name ?? path.basename(rootDirectory);
@@ -500,7 +704,7 @@ const discoverReactSubprojects = (rootDirectory) => {
 		if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") continue;
 		const subdirectory = path.join(rootDirectory, entry.name);
 		const packageJsonPath = path.join(subdirectory, "package.json");
-		if (!fs.existsSync(packageJsonPath)) continue;
+		if (!isFile(packageJsonPath)) continue;
 		const packageJson = readPackageJson(packageJsonPath);
 		if (!hasReactDependency(packageJson)) continue;
 		const name = packageJson.name ?? entry.name;
@@ -513,10 +717,18 @@ const discoverReactSubprojects = (rootDirectory) => {
 };
 const listWorkspacePackages = (rootDirectory) => {
 	const packageJsonPath = path.join(rootDirectory, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return [];
-	const patterns = getWorkspacePatterns(rootDirectory, readPackageJson(packageJsonPath));
+	if (!isFile(packageJsonPath)) return [];
+	const packageJson = readPackageJson(packageJsonPath);
+	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
 	if (patterns.length === 0) return [];
 	const packages = [];
+	if (hasReactDependency(packageJson)) {
+		const rootName = packageJson.name ?? path.basename(rootDirectory);
+		packages.push({
+			name: rootName,
+			directory: rootDirectory
+		});
+	}
 	for (const pattern of patterns) {
 		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
 		for (const workspaceDirectory of directories) {
@@ -536,7 +748,7 @@ const hasCompilerPackage = (packageJson) => {
 	return Object.keys(allDependencies).some((packageName) => REACT_COMPILER_PACKAGES.has(packageName));
 };
 const fileContainsPattern = (filePath, pattern) => {
-	if (!fs.existsSync(filePath)) return false;
+	if (!isFile(filePath)) return false;
 	const content = fs.readFileSync(filePath, "utf-8");
 	return pattern.test(content);
 };
@@ -550,7 +762,7 @@ const detectReactCompiler = (directory, packageJson) => {
 	let ancestorDirectory = path.dirname(directory);
 	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
 		const ancestorPackagePath = path.join(ancestorDirectory, "package.json");
-		if (fs.existsSync(ancestorPackagePath)) {
+		if (isFile(ancestorPackagePath)) {
 			if (hasCompilerPackage(readPackageJson(ancestorPackagePath))) return true;
 		}
 		ancestorDirectory = path.dirname(ancestorDirectory);
@@ -559,9 +771,17 @@ const detectReactCompiler = (directory, packageJson) => {
 };
 const discoverProject = (directory) => {
 	const packageJsonPath = path.join(directory, "package.json");
-	if (!fs.existsSync(packageJsonPath)) throw new Error(`No package.json found in ${directory}`);
+	if (!isFile(packageJsonPath)) throw new Error(`No package.json found in ${directory}`);
 	const packageJson = readPackageJson(packageJsonPath);
 	let { reactVersion, framework } = extractDependencyInfo(packageJson);
+	if (!reactVersion) reactVersion = resolveCatalogVersion(packageJson, "react", directory);
+	if (!reactVersion) {
+		const monorepoRoot = findMonorepoRoot(directory);
+		if (monorepoRoot) {
+			const monorepoPackageJsonPath = path.join(monorepoRoot, "package.json");
+			if (isFile(monorepoPackageJsonPath)) reactVersion = resolveCatalogVersion(readPackageJson(monorepoPackageJsonPath), "react", monorepoRoot);
+		}
+	}
 	if (!reactVersion || framework === "unknown") {
 		const workspaceInfo = findReactInWorkspaces(directory, packageJson);
 		if (!reactVersion && workspaceInfo.reactVersion) reactVersion = workspaceInfo.reactVersion;
@@ -661,10 +881,9 @@ const indentMultilineText = (text, linePrefix) => text.split("\n").map((lineText
 //#region src/utils/load-config.ts
 const CONFIG_FILENAME = "react-doctor.config.json";
 const PACKAGE_JSON_CONFIG_KEY = "reactDoctor";
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const loadConfig = (rootDirectory) => {
 	const configFilePath = path.join(rootDirectory, CONFIG_FILENAME);
-	if (fs.existsSync(configFilePath)) try {
+	if (isFile(configFilePath)) try {
 		const fileContent = fs.readFileSync(configFilePath, "utf-8");
 		const parsed = JSON.parse(fileContent);
 		if (isPlainObject(parsed)) return parsed;
@@ -673,7 +892,7 @@ const loadConfig = (rootDirectory) => {
 		console.warn(`Warning: Failed to parse ${CONFIG_FILENAME}: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	const packageJsonPath = path.join(rootDirectory, "package.json");
-	if (fs.existsSync(packageJsonPath)) try {
+	if (isFile(packageJsonPath)) try {
 		const fileContent = fs.readFileSync(packageJsonPath, "utf-8");
 		const embeddedConfig = JSON.parse(fileContent)[PACKAGE_JSON_CONFIG_KEY];
 		if (isPlainObject(embeddedConfig)) return embeddedConfig;
@@ -844,6 +1063,49 @@ const resolveNodeForOxlint = () => {
 	};
 };
 
+//#endregion
+//#region src/utils/resolve-lint-include-paths.ts
+const listSourceFilesViaGit = (rootDirectory) => {
+	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) => {
+	const filePaths = [];
+	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) => listSourceFilesViaGit(rootDirectory) ?? listSourceFilesViaFilesystem(rootDirectory);
+const resolveLintIncludePaths = (rootDirectory, userConfig) => {
+	if (!Array.isArray(userConfig?.ignore?.files) || userConfig.ignore.files.length === 0) return;
+	const ignoredPatterns = compileIgnoredFilePatterns(userConfig);
+	return listSourceFiles(rootDirectory).filter((filePath) => {
+		if (!JSX_FILE_PATTERN.test(filePath)) return false;
+		return !isFileIgnoredByPatterns(filePath, rootDirectory, ignoredPatterns);
+	});
+};
+
 //#endregion
 //#region src/utils/run-knip.ts
 const KNIP_CATEGORY_MAP = {
@@ -932,7 +1194,7 @@ const runKnip = async (rootDirectory) => {
 	let knipResult;
 	if (monorepoRoot) {
 		const packageJsonPath = path.join(rootDirectory, "package.json");
-		const workspaceName = (fs.existsSync(packageJsonPath) ? JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) : {}).name ?? path.basename(rootDirectory);
+		const workspaceName = (isFile(packageJsonPath) ? JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) : {}).name ?? path.basename(rootDirectory);
 		try {
 			knipResult = await runKnipWithOptions(monorepoRoot, workspaceName);
 		} catch {
@@ -1102,24 +1364,27 @@ const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler }) => ({
 
 //#endregion
 //#region src/utils/neutralize-disable-directives.ts
-const findFilesWithDisableDirectives = (rootDirectory) => {
-	const result = spawnSync("git", [
+const findFilesWithDisableDirectives = (rootDirectory, includePaths) => {
+	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").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath));
 };
 const neutralizeContent = (content) => content.replaceAll("eslint-disable", "eslint_disable").replaceAll("oxlint-disable", "oxlint_disable");
-const neutralizeDisableDirectives = (rootDirectory) => {
-	const filePaths = findFilesWithDisableDirectives(rootDirectory);
+const neutralizeDisableDirectives = (rootDirectory, includePaths) => {
+	const filePaths = findFilesWithDisableDirectives(rootDirectory, includePaths);
 	const originalContents = /* @__PURE__ */ new Map();
 	for (const relativePath of filePaths) {
 		const absolutePath = path.join(rootDirectory, relativePath);
@@ -1215,7 +1480,7 @@ const RULE_CATEGORY_MAP = {
 	"react-doctor/rn-no-single-element-style-array": "React Native"
 };
 const RULE_HELP_MAP = {
-	"no-derived-state-effect": "For derived state, compute inline: `const x = fn(dep)`. For state resets on prop change, use a key prop: `<Component key={prop} />`",
+	"no-derived-state-effect": "For derived state, compute inline: `const x = fn(dep)`. For state resets on prop change, use a key prop: `<Component key={prop} />`. See https://react.dev/learn/you-might-not-need-an-effect",
 	"no-fetch-in-effect": "Use `useQuery()` from @tanstack/react-query, `useSWR()`, or fetch in a Server Component instead",
 	"no-cascading-set-state": "Combine into useReducer: `const [state, dispatch] = useReducer(reducer, initialState)`",
 	"no-effect-event-handler": "Move the conditional logic into onClick, onChange, or onSubmit handlers directly",
@@ -1255,7 +1520,7 @@ const RULE_HELP_MAP = {
 	"nextjs-no-use-search-params-without-suspense": "Wrap the component using useSearchParams: `<Suspense fallback={<Skeleton />}><SearchComponent /></Suspense>`",
 	"nextjs-no-client-fetch-for-server-data": "Remove 'use client' and fetch directly in the Server Component — no API round-trip, secrets stay on server",
 	"nextjs-missing-metadata": "Add `export const metadata = { title: '...', description: '...' }` or `export async function generateMetadata()`",
-	"nextjs-no-client-side-redirect": "Use `redirect('/path')` from 'next/navigation' in a Server Component, or handle in middleware",
+	"nextjs-no-client-side-redirect": "Use `redirect('/path')` from 'next/navigation' directly (works in both server and client components), or handle in middleware",
 	"nextjs-no-redirect-in-try-catch": "Move the redirect/notFound call outside the try block, or add `unstable_rethrow(error)` in the catch",
 	"nextjs-image-missing-sizes": "Add sizes for responsive behavior: `sizes=\"(max-width: 768px) 100vw, 50vw\"` matching your layout breakpoints",
 	"nextjs-no-native-script": "`import Script from \"next/script\"` — use `strategy=\"afterInteractive\"` for analytics or `\"lazyOnload\"` for widgets",
@@ -1343,7 +1608,14 @@ const spawnOxlint = (args, rootDirectory, nodeBinaryPath) => new Promise((resolv
 	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", () => {
+	child.on("close", (code, signal) => {
+		if (signal) {
+			const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
+			const hint = signal === "SIGABRT" ? " (out of memory — try scanning fewer files with --diff)" : "";
+			const detail = stderrOutput ? `: ${stderrOutput}` : "";
+			reject(/* @__PURE__ */ new Error(`oxlint was killed by ${signal}${hint}${detail}`));
+			return;
+		}
 		const output = Buffer.concat(stdoutBuffers).toString("utf-8").trim();
 		if (!output) {
 			const stderrOutput = Buffer.concat(stderrBuffers).toString("utf-8").trim();
@@ -1388,7 +1660,7 @@ const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompil
 		framework,
 		hasReactCompiler
 	});
-	const restoreDisableDirectives = neutralizeDisableDirectives(rootDirectory);
+	const restoreDisableDirectives = neutralizeDisableDirectives(rootDirectory, includePaths);
 	try {
 		fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 		const baseArgs = [
@@ -1614,7 +1886,7 @@ const buildCountsSummaryLine = (diagnostics, totalSourceFileCount, elapsedMillis
 	renderedParts.push(highlighter.dim(fileCountText), highlighter.dim(elapsedTimeText));
 	return createFramedLine(plainParts.join("  "), renderedParts.join("  "));
 };
-const printSummary = (diagnostics, elapsedMilliseconds, scoreResult, projectName, totalSourceFileCount, noScoreMessage) => {
+const printSummary = (diagnostics, elapsedMilliseconds, scoreResult, projectName, totalSourceFileCount, noScoreMessage, isOffline) => {
 	printFramedBox([...buildBrandingLines(scoreResult, noScoreMessage), buildCountsSummaryLine(diagnostics, totalSourceFileCount, elapsedMilliseconds)]);
 	try {
 		const diagnosticsDirectory = writeDiagnosticsDirectory(diagnostics);
@@ -1623,9 +1895,11 @@ const printSummary = (diagnostics, elapsedMilliseconds, scoreResult, projectName
 	} catch {
 		logger.break();
 	}
-	const shareUrl = buildShareUrl(diagnostics, scoreResult, projectName);
-	logger.break();
-	logger.dim(`  Share your results: ${highlighter.info(shareUrl)}`);
+	if (!isOffline) {
+		const shareUrl = buildShareUrl(diagnostics, scoreResult, projectName);
+		logger.break();
+		logger.dim(`  Share your results: ${highlighter.info(shareUrl)}`);
+	}
 };
 const resolveOxlintNode = async (isLintEnabled, isScoreOnly) => {
 	if (!isLintEnabled) return null;
@@ -1673,7 +1947,7 @@ const mergeScanOptions = (inputOptions, userConfig) => ({
 	offline: inputOptions.offline ?? false,
 	includePaths: inputOptions.includePaths ?? []
 });
-const printProjectDetection = (projectInfo, userConfig, isDiffMode, includePaths) => {
+const printProjectDetection = (projectInfo, userConfig, isDiffMode, includePaths, lintSourceFileCount) => {
 	const frameworkLabel = formatFrameworkName(projectInfo.framework);
 	const languageLabel = projectInfo.hasTypeScript ? "TypeScript" : "JavaScript";
 	const completeStep = (message) => {
@@ -1684,7 +1958,7 @@ const printProjectDetection = (projectInfo, userConfig, isDiffMode, includePaths
 	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.`);
+	else completeStep(`Found ${highlighter.info(`${lintSourceFileCount ?? projectInfo.sourceFileCount}`)} source files.`);
 	if (userConfig) completeStep(`Loaded ${highlighter.info("react-doctor config")}.`);
 	logger.break();
 };
@@ -1696,8 +1970,9 @@ const scan = async (directory, inputOptions = {}) => {
 	const { includePaths } = options;
 	const isDiffMode = includePaths.length > 0;
 	if (!projectInfo.reactVersion) throw new Error("No React dependency found in package.json");
-	if (!options.scoreOnly) printProjectDetection(projectInfo, userConfig, isDiffMode, includePaths);
-	const jsxIncludePaths = computeJsxIncludePaths(includePaths);
+	const lintIncludePaths = computeJsxIncludePaths(includePaths) ?? resolveLintIncludePaths(directory, userConfig);
+	const lintSourceFileCount = lintIncludePaths?.length ?? projectInfo.sourceFileCount;
+	if (!options.scoreOnly) printProjectDetection(projectInfo, userConfig, isDiffMode, includePaths, lintSourceFileCount);
 	let didLintFail = false;
 	let didDeadCodeFail = false;
 	const resolvedNodeBinaryPath = await resolveOxlintNode(options.lint, options.scoreOnly);
@@ -1705,7 +1980,7 @@ const scan = async (directory, inputOptions = {}) => {
 	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, resolvedNodeBinaryPath);
+			const lintDiagnostics = await runOxlint(directory, projectInfo.hasTypeScript, projectInfo.framework, projectInfo.hasReactCompiler, lintIncludePaths, resolvedNodeBinaryPath);
 			lintSpinner?.succeed("Running lint checks.");
 			return lintDiagnostics;
 		} catch (error) {
@@ -1745,8 +2020,8 @@ const scan = async (directory, inputOptions = {}) => {
 	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;
+	const scoreResult = options.offline ? calculateScoreLocally(diagnostics) : await calculateScore(diagnostics);
+	const noScoreMessage = OFFLINE_MESSAGE;
 	if (options.scoreOnly) {
 		if (scoreResult) logger.log(`${scoreResult.score}`);
 		else logger.dim(noScoreMessage);
@@ -1776,8 +2051,8 @@ const scan = async (directory, inputOptions = {}) => {
 		};
 	}
 	printDiagnostics(diagnostics, options.verbose);
-	const displayedSourceFileCount = isDiffMode ? includePaths.length : projectInfo.sourceFileCount;
-	printSummary(diagnostics, elapsedMilliseconds, scoreResult, projectInfo.projectName, displayedSourceFileCount, noScoreMessage);
+	const displayedSourceFileCount = isDiffMode ? includePaths.length : lintSourceFileCount;
+	printSummary(diagnostics, elapsedMilliseconds, scoreResult, projectInfo.projectName, displayedSourceFileCount, noScoreMessage, options.offline);
 	if (hasSkippedChecks) {
 		const skippedLabel = skippedChecks.join(" and ");
 		logger.break();
@@ -2104,7 +2379,7 @@ const maybePromptSkillInstall = async (shouldSkipPrompts) => {
 
 //#endregion
 //#region src/cli.ts
-const VERSION = "0.0.29";
+const VERSION = "0.0.31";
 const VALID_FAIL_ON_LEVELS = new Set([
 	"error",
 	"warning",
@@ -2157,7 +2432,7 @@ const resolveDiffMode = async (diffInfo, effectiveDiff, shouldSkipPrompts, isSco
 	if (effectiveDiff === false || !diffInfo) return false;
 	const changedSourceFiles = filterSourceFiles(diffInfo.changedFiles);
 	if (changedSourceFiles.length === 0) return false;
-	if (shouldSkipPrompts) return true;
+	if (shouldSkipPrompts) return false;
 	if (isScoreOnly) return false;
 	const { shouldScanChangedOnly } = await prompts({
 		type: "confirm",
@@ -2167,7 +2442,7 @@ const resolveDiffMode = async (diffInfo, effectiveDiff, shouldSkipPrompts, isSco
 	});
 	return Boolean(shouldScanChangedOnly);
 };
-const program = new Command().name("react-doctor").description("Diagnose React codebase health").version(VERSION, "-v, --version", "display the version number").argument("[directory]", "project directory to scan", ".").option("--lint", "enable linting").option("--no-lint", "skip linting").option("--dead-code", "enable dead code detection").option("--no-dead-code", "skip dead code detection").option("--verbose", "show file details per rule").option("--score", "output only the score").option("-y, --yes", "skip prompts, scan all workspace projects").option("--project <name>", "select workspace project (comma-separated for multiple)").option("--diff [base]", "scan only files changed vs base branch").option("--offline", "skip telemetry (anonymous, not stored, only used to calculate score)").option("--no-ami", "skip Ami-related prompts").option("--fail-on <level>", "exit with error code on diagnostics: error, warning, none", "none").option("--fix", "open Ami to auto-fix all issues").action(async (directory, flags) => {
+const program = new Command().name("react-doctor").description("Diagnose React codebase health").version(VERSION, "-v, --version", "display the version number").argument("[directory]", "project directory to scan", ".").option("--lint", "enable linting").option("--no-lint", "skip linting").option("--dead-code", "enable dead code detection").option("--no-dead-code", "skip dead code detection").option("--verbose", "show file details per rule").option("--score", "output only the score").option("-y, --yes", "skip prompts, scan all workspace projects").option("--project <name>", "select workspace project (comma-separated for multiple)").option("--diff [base]", "scan only files changed vs base branch").option("--offline", "skip telemetry (anonymous, not stored, only used to calculate score)").option("--ami", "enable Ami-related prompts").option("--fail-on <level>", "exit with error code on diagnostics: error, warning, none", "none").option("--fix", "open Ami to auto-fix all issues").action(async (directory, flags) => {
 	const isScoreOnly = flags.score;
 	try {
 		const resolvedDirectory = path.resolve(directory);