react-doctor 0.0.36 → 0.0.39

package/README.md

@@ -69,6 +69,8 @@ Supports Claude Code, Codex, GitHub Copilot, Gemini CLI, Cursor, OpenCode, Facto
 | `project`      |         | Workspace project(s) to scan (comma-separated)                    |
 | `diff`         |         | Base branch for diff mode. Only changed files are scanned         |
 | `github-token` |         | When set on `pull_request` events, posts findings as a PR comment |
+| `fail-on`      | `error` | Exit with error code on diagnostics: `error`, `warning`, `none`   |
+| `offline`      | `false` | Skip sending diagnostics to the react.doctor API                  |
 | `node-version` | `20`    | Node.js version to use                                            |
 
 The action outputs a `score` (0–100) you can use in subsequent steps.
@@ -90,6 +92,14 @@ Options:
   -h, --help        display help for command
 ```
 
+## Browser API
+
+Import `react-doctor/browser` to run the same **diagnostics merge, config-based filtering, timing, and scoring pipeline** as `react-doctor/api`’s `diagnose`, but with **caller-supplied** inputs: `project` metadata, a virtual `projectFiles` map (contents keyed by paths relative to `rootDirectory`) for ignore/suppression resolution, and a `runOxlint` callback that performs linting in your environment (for example a Web Worker with oxlint).
+
+Git history, real filesystem discovery, knip, the CLI, staged-file detection, and interactive prompts are **not** available in the browser bundle; treat those as Node-only or supply equivalents yourself. `react-doctor/worker` re-exports the same browser-facing modules for worker targets.
+
+If you call **`diagnoseCore`** yourself in the browser, pass **`calculateDiagnosticsScore`** from this package (re-exported as **`calculateScore`** on `react-doctor/browser`) so the bundle never pulls in Node-only proxy code.
+
 ## Configuration
 
 Create a `react-doctor.config.json` in your project root to customize behavior:
@@ -119,14 +129,18 @@ If both exist, `react-doctor.config.json` takes precedence.
 
 ### Config options
 
-| Key            | Type                | Default | Description                                                                                                                         |
-| -------------- | ------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------- |
-| `ignore.rules` | `string[]`          | `[]`    | Rules to suppress, using the `plugin/rule` format shown in diagnostic output (e.g. `react/no-danger`, `knip/exports`, `knip/types`) |
-| `ignore.files` | `string[]`          | `[]`    | File paths to exclude, supports glob patterns (`src/generated/**`, `**/*.test.tsx`)                                                 |
-| `lint`         | `boolean`           | `true`  | Enable/disable lint checks (same as `--no-lint`)                                                                                    |
-| `deadCode`     | `boolean`           | `true`  | Enable/disable dead code detection (same as `--no-dead-code`)                                                                       |
-| `verbose`      | `boolean`           | `false` | Show file details per rule (same as `--verbose`)                                                                                    |
-| `diff`         | `boolean \| string` | —       | Force diff mode (`true`) or pin a base branch (`"main"`). Set to `false` to disable auto-detection.                                 |
+| Key               | Type                             | Default  | Description                                                                                                                         |
+| ----------------- | -------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore.rules`    | `string[]`                       | `[]`     | Rules to suppress, using the `plugin/rule` format shown in diagnostic output (e.g. `react/no-danger`, `knip/exports`, `knip/types`) |
+| `ignore.files`    | `string[]`                       | `[]`     | File paths to exclude, supports glob patterns (`src/generated/**`, `**/*.test.tsx`)                                                 |
+| `lint`            | `boolean`                        | `true`   | Enable/disable lint checks (same as `--no-lint`)                                                                                    |
+| `deadCode`        | `boolean`                        | `true`   | Enable/disable dead code detection (same as `--no-dead-code`)                                                                       |
+| `verbose`         | `boolean`                        | `false`  | Show file details per rule (same as `--verbose`)                                                                                    |
+| `diff`            | `boolean \| string`              | —        | Force diff mode (`true`) or pin a base branch (`"main"`). Set to `false` to disable auto-detection.                                 |
+| `failOn`          | `"error" \| "warning" \| "none"` | `"none"` | Exit with error code on diagnostics of the given severity or above                                                                  |
+| `customRulesOnly` | `boolean`                        | `false`  | Disable built-in react/jsx-a11y/compiler rules, keeping only `react-doctor/*` plugin rules                                          |
+| `share`           | `boolean`                        | `true`   | Show the share-your-results URL after scanning                                                                                      |
+| `textComponents`  | `string[]`                       | `[]`     | React Native only. Component names whose children should not trigger `rn-no-raw-text` (e.g. `["MyText", "Label.Bold"]`)             |
 
 CLI flags always override config values.
 

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+import { _ as ScoreResult, a as diagnoseBrowser, c as diagnoseCore, d as diagnose, f as calculateScore, g as ReactDoctorConfig, h as ProjectInfo, i as DiagnoseBrowserInput, l as BrowserDiagnoseInput, m as Diagnostic, n as ProcessBrowserDiagnosticsResult, o as DiagnoseCoreOptions, p as calculateScoreLocally, r as processBrowserDiagnostics, s as DiagnoseCoreResult, t as ProcessBrowserDiagnosticsInput, u as BrowserDiagnoseResult } from "./process-browser-diagnostics-Cahx3_oy.js";
+export { type BrowserDiagnoseInput, type BrowserDiagnoseResult, type DiagnoseBrowserInput, type DiagnoseCoreOptions, type DiagnoseCoreResult, type Diagnostic, type ProcessBrowserDiagnosticsInput, type ProcessBrowserDiagnosticsResult, type ProjectInfo, type ReactDoctorConfig, type ScoreResult, calculateScore, calculateScoreLocally, diagnose, diagnoseBrowser, diagnoseCore, processBrowserDiagnostics };

package/dist/browser.js

@@ -0,0 +1,3 @@
+import { a as calculateScore, i as diagnose, n as diagnoseBrowser, o as calculateScoreLocally, r as diagnoseCore, t as processBrowserDiagnostics } from "./process-browser-diagnostics-DpaZeYLI.js";
+
+export { calculateScore, calculateScoreLocally, diagnose, diagnoseBrowser, diagnoseCore, processBrowserDiagnostics };

package/dist/cli.js

@@ -309,55 +309,7 @@ const IGNORED_DIRECTORIES = new Set([
 ]);
 
 //#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
+//#region src/core/calculate-score-locally.ts
 const getScoreLabel = (score) => {
 	if (score >= SCORE_GOOD_THRESHOLD) return "Great";
 	if (score >= SCORE_OK_THRESHOLD) return "Needs work";
@@ -388,20 +340,90 @@ const calculateScoreLocally = (diagnostics) => {
 		label: getScoreLabel(score)
 	};
 };
-const calculateScore = async (diagnostics) => {
+
+//#endregion
+//#region src/core/try-score-from-api.ts
+const parseScoreResult = (value) => {
+	if (typeof value !== "object" || value === null) return null;
+	if (!("score" in value) || !("label" in value)) return null;
+	const scoreValue = Reflect.get(value, "score");
+	const labelValue = Reflect.get(value, "label");
+	if (typeof scoreValue !== "number" || typeof labelValue !== "string") return null;
+	return {
+		score: scoreValue,
+		label: labelValue
+	};
+};
+const tryScoreFromApi = async (diagnostics, fetchImplementation) => {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
 	try {
-		const response = await proxyFetch(SCORE_API_URL, {
+		const response = await fetchImplementation(SCORE_API_URL, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ diagnostics })
+			body: JSON.stringify({ diagnostics }),
+			signal: controller.signal
 		});
-		if (!response.ok) return calculateScoreLocally(diagnostics);
-		return await response.json();
+		if (!response.ok) return null;
+		return parseScoreResult(await response.json());
 	} catch {
-		return calculateScoreLocally(diagnostics);
+		return null;
+	} finally {
+		clearTimeout(timeoutId);
 	}
 };
 
+//#endregion
+//#region src/utils/proxy-fetch.ts
+const getGlobalProcess = () => {
+	const candidate = globalThis.process;
+	return candidate?.versions?.node ? candidate : void 0;
+};
+const readEnvProxy = () => {
+	const proc = getGlobalProcess();
+	if (!proc?.env) return void 0;
+	return proc.env.HTTPS_PROXY ?? proc.env.https_proxy ?? proc.env.HTTP_PROXY ?? proc.env.http_proxy;
+};
+let isProxyUrlResolved = false;
+let resolvedProxyUrl;
+const getProxyUrl = () => {
+	if (isProxyUrlResolved) return resolvedProxyUrl;
+	isProxyUrlResolved = true;
+	resolvedProxyUrl = readEnvProxy();
+	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-node.ts
+const calculateScore = async (diagnostics) => {
+	const apiScore = await tryScoreFromApi(diagnostics, proxyFetch);
+	if (apiScore) return apiScore;
+	return calculateScoreLocally(diagnostics);
+};
+
 //#endregion
 //#region src/utils/colorize-by-score.ts
 const colorizeByScore = (text, score) => {
@@ -481,6 +503,19 @@ const checkReducedMotion = (rootDirectory) => {
 	}
 };
 
+//#endregion
+//#region src/utils/read-file-lines-node.ts
+const createNodeReadFileLinesSync = (rootDirectory) => {
+	return (filePath) => {
+		const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(rootDirectory, filePath);
+		try {
+			return fs.readFileSync(absolutePath, "utf-8").split("\n");
+		} catch {
+			return null;
+		}
+	};
+};
+
 //#endregion
 //#region src/utils/match-glob-pattern.ts
 const REGEX_SPECIAL_CHARACTERS = /[.+^${}()|[\]\\]/g;
@@ -526,23 +561,22 @@ const isFileIgnoredByPatterns = (filePath, rootDirectory, patterns) => {
 
 //#endregion
 //#region src/utils/filter-diagnostics.ts
+const resolveCandidateReadPath = (rootDirectory, filePath) => {
+	const normalizedFile = filePath.replace(/\\/g, "/");
+	if (normalizedFile.startsWith("/") || /^[a-zA-Z]:\//.test(normalizedFile) || /^[a-zA-Z]:\\/.test(filePath)) return filePath;
+	return `${rootDirectory.replace(/\\/g, "/").replace(/\/$/, "")}/${normalizedFile.replace(/^\.\//, "")}`;
+};
 const OPENING_TAG_PATTERN = /<([A-Z][\w.]*)/;
 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 createFileLinesCache = (rootDirectory) => {
+const createFileLinesCache = (rootDirectory, readFileLinesSync) => {
 	const cache = /* @__PURE__ */ new Map();
 	return (filePath) => {
 		const cached = cache.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");
-			cache.set(filePath, lines);
-			return lines;
-		} catch {
-			cache.set(filePath, null);
-			return null;
-		}
+		const lines = readFileLinesSync(resolveCandidateReadPath(rootDirectory, filePath));
+		cache.set(filePath, lines);
+		return lines;
 	};
 };
 const isInsideTextComponent = (lines, diagnosticLine, textComponentNames) => {
@@ -559,12 +593,12 @@ const isRuleSuppressed = (commentRules, ruleId) => {
 	if (!commentRules?.trim()) return true;
 	return commentRules.split(/[,\s]+/).some((rule) => rule.trim() === ruleId);
 };
-const filterIgnoredDiagnostics = (diagnostics, config, rootDirectory) => {
+const filterIgnoredDiagnostics = (diagnostics, config, rootDirectory, readFileLinesSync) => {
 	const ignoredRules = new Set(Array.isArray(config.ignore?.rules) ? config.ignore.rules : []);
 	const ignoredFilePatterns = compileIgnoredFilePatterns(config);
 	const textComponentNames = new Set(Array.isArray(config.textComponents) ? config.textComponents : []);
 	const hasTextComponents = textComponentNames.size > 0;
-	const getFileLines = createFileLinesCache(rootDirectory);
+	const getFileLines = createFileLinesCache(rootDirectory, readFileLinesSync);
 	return diagnostics.filter((diagnostic) => {
 		const ruleIdentifier = `${diagnostic.plugin}/${diagnostic.rule}`;
 		if (ignoredRules.has(ruleIdentifier)) return false;
@@ -576,8 +610,8 @@ const filterIgnoredDiagnostics = (diagnostics, config, rootDirectory) => {
 		return true;
 	});
 };
-const filterInlineSuppressions = (diagnostics, rootDirectory) => {
-	const getFileLines = createFileLinesCache(rootDirectory);
+const filterInlineSuppressions = (diagnostics, rootDirectory, readFileLinesSync) => {
+	const getFileLines = createFileLinesCache(rootDirectory, readFileLinesSync);
 	return diagnostics.filter((diagnostic) => {
 		if (diagnostic.line <= 0) return true;
 		const lines = getFileLines(diagnostic.filePath);
@@ -600,15 +634,24 @@ const filterInlineSuppressions = (diagnostics, rootDirectory) => {
 };
 
 //#endregion
-//#region src/utils/combine-diagnostics.ts
+//#region src/utils/merge-and-filter-diagnostics.ts
+const mergeAndFilterDiagnostics = (mergedDiagnostics, directory, userConfig, readFileLinesSync) => {
+	return filterInlineSuppressions(userConfig ? filterIgnoredDiagnostics(mergedDiagnostics, userConfig, directory, readFileLinesSync) : mergedDiagnostics, directory, readFileLinesSync);
+};
+
+//#endregion
+//#region src/utils/jsx-include-paths.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 merged = [
+
+//#endregion
+//#region src/utils/combine-diagnostics.ts
+const combineDiagnostics = (lintDiagnostics, deadCodeDiagnostics, directory, isDiffMode, userConfig, readFileLinesSync = createNodeReadFileLinesSync(directory), includeEnvironmentChecks = true) => {
+	const extraDiagnostics = isDiffMode || !includeEnvironmentChecks ? [] : checkReducedMotion(directory);
+	return mergeAndFilterDiagnostics([
 		...lintDiagnostics,
 		...deadCodeDiagnostics,
-		...isDiffMode ? [] : checkReducedMotion(directory)
-	];
-	return filterInlineSuppressions(userConfig ? filterIgnoredDiagnostics(merged, userConfig, directory) : merged, directory);
+		...extraDiagnostics
+	], directory, userConfig, readFileLinesSync);
 };
 
 //#endregion
@@ -1253,6 +1296,20 @@ const resolveLintIncludePaths = (rootDirectory, userConfig) => {
 	});
 };
 
+//#endregion
+//#region src/utils/collect-unused-file-paths.ts
+const collectUnusedFilePaths = (filesIssues) => {
+	if (filesIssues instanceof Set) return [...filesIssues];
+	if (Array.isArray(filesIssues)) return filesIssues.filter((entry) => typeof entry === "string");
+	if (!isPlainObject(filesIssues)) return [];
+	const unusedFilePaths = [];
+	for (const innerValue of Object.values(filesIssues)) {
+		if (!isPlainObject(innerValue)) continue;
+		for (const issue of Object.values(innerValue)) if (isPlainObject(issue) && typeof issue.filePath === "string") unusedFilePaths.push(issue.filePath);
+	}
+	return unusedFilePaths;
+};
+
 //#endregion
 //#region src/utils/run-knip.ts
 const KNIP_CATEGORY_MAP = {
@@ -1350,8 +1407,8 @@ const runKnip = async (rootDirectory) => {
 	} else knipResult = await runKnipWithOptions(rootDirectory);
 	const { issues } = knipResult;
 	const diagnostics = [];
-	for (const unusedFile of issues.files) diagnostics.push({
-		filePath: path.relative(rootDirectory, unusedFile),
+	for (const unusedFilePath of collectUnusedFilePaths(issues.files)) diagnostics.push({
+		filePath: path.relative(rootDirectory, unusedFilePath),
 		plugin: "knip",
 		rule: "files",
 		severity: KNIP_SEVERITY_MAP["files"],
@@ -1984,10 +2041,8 @@ const printDiagnostics = (diagnostics, isVerbose) => {
 		if (firstDiagnostic.help) logger.dim(indentMultilineText(firstDiagnostic.help, "    "));
 		if (isVerbose) {
 			const fileLines = buildFileLineMap(ruleDiagnostics);
-			for (const [filePath, lines] of fileLines) {
-				const lineLabel = lines.length > 0 ? `: ${lines.join(", ")}` : "";
-				logger.dim(`    ${filePath}${lineLabel}`);
-			}
+			for (const [filePath, lines] of fileLines) if (lines.length > 0) for (const line of lines) logger.dim(`  ${filePath}:${line}`);
+			else logger.dim(`  ${filePath}`);
 		}
 		logger.break();
 	}
@@ -2009,10 +2064,8 @@ const formatRuleSummary = (ruleKey, ruleDiagnostics) => {
 	];
 	if (firstDiagnostic.help) sections.push("", `Suggestion: ${firstDiagnostic.help}`);
 	sections.push("", "Files:");
-	for (const [filePath, lines] of fileLines) {
-		const lineLabel = lines.length > 0 ? `: ${lines.join(", ")}` : "";
-		sections.push(`  ${filePath}${lineLabel}`);
-	}
+	for (const [filePath, lines] of fileLines) if (lines.length > 0) for (const line of lines) sections.push(`  ${filePath}:${line}`);
+	else sections.push(`  ${filePath}`);
 	return sections.join("\n") + "\n";
 };
 const writeDiagnosticsDirectory = (diagnostics) => {
@@ -2512,7 +2565,7 @@ const promptProjectSelection = async (workspacePackages, rootDirectory) => {
 
 //#endregion
 //#region src/cli.ts
-const VERSION = "0.0.36";
+const VERSION = "0.0.39";
 const VALID_FAIL_ON_LEVELS = new Set([
 	"error",
 	"warning",