react-doctor 0.0.2 → 0.0.4

package/dist/cli.js

@@ -0,0 +1,983 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import path, { join } from "node:path";
+import { Command } from "commander";
+import pc from "picocolors";
+import { randomUUID } from "node:crypto";
+import fs, { mkdirSync, writeFileSync } from "node:fs";
+import os, { tmpdir } from "node:os";
+import { performance } from "node:perf_hooks";
+import { execSync, spawn, spawnSync } from "node:child_process";
+import { main } from "knip";
+import { createOptions } from "knip/session";
+import { fileURLToPath } from "node:url";
+import ora from "ora";
+import basePrompts from "prompts";
+
+//#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 = {
+	error(...args) {
+		console.log(highlighter.error(args.join(" ")));
+	},
+	warn(...args) {
+		console.log(highlighter.warn(args.join(" ")));
+	},
+	info(...args) {
+		console.log(highlighter.info(args.join(" ")));
+	},
+	success(...args) {
+		console.log(highlighter.success(args.join(" ")));
+	},
+	dim(...args) {
+		console.log(highlighter.dim(args.join(" ")));
+	},
+	log(...args) {
+		console.log(args.join(" "));
+	},
+	break() {
+		console.log("");
+	}
+};
+
+//#endregion
+//#region src/utils/handle-error.ts
+const handleError = (error) => {
+	logger.break();
+	logger.error("Something went wrong. Please check the error below for more details.");
+	logger.error("If the problem persists, please open an issue on GitHub.");
+	logger.error("");
+	if (error instanceof Error) logger.error(error.message);
+	logger.break();
+	process.exit(1);
+};
+
+//#endregion
+//#region src/constants.ts
+const SOURCE_FILE_PATTERN = /\.(tsx?|jsx?)$/;
+const JSX_FILE_PATTERN = /\.(tsx|jsx)$/;
+const SEPARATOR_LENGTH_CHARS = 62;
+const ERROR_PREVIEW_LENGTH_CHARS = 200;
+
+//#endregion
+//#region src/utils/read-package-json.ts
+const readPackageJson = (packageJsonPath) => JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+
+//#endregion
+//#region src/utils/discover-project.ts
+const REACT_COMPILER_PACKAGES = new Set([
+	"babel-plugin-react-compiler",
+	"react-compiler-runtime",
+	"eslint-plugin-react-compiler"
+]);
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.cjs"
+];
+const BABEL_CONFIG_FILENAMES = [
+	".babelrc",
+	".babelrc.json",
+	"babel.config.js",
+	"babel.config.json",
+	"babel.config.cjs",
+	"babel.config.mjs"
+];
+const VITE_CONFIG_FILENAMES = [
+	"vite.config.js",
+	"vite.config.ts",
+	"vite.config.mjs",
+	"vite.config.cjs"
+];
+const REACT_COMPILER_CONFIG_PATTERN = /react-compiler|reactCompiler/;
+const FRAMEWORK_PACKAGES = {
+	next: "nextjs",
+	vite: "vite",
+	"react-scripts": "cra",
+	"@remix-run/react": "remix",
+	gatsby: "gatsby"
+};
+const FRAMEWORK_DISPLAY_NAMES = {
+	nextjs: "Next.js",
+	vite: "Vite",
+	cra: "Create React App",
+	remix: "Remix",
+	gatsby: "Gatsby",
+	unknown: "React"
+};
+const formatFrameworkName = (framework) => FRAMEWORK_DISPLAY_NAMES[framework];
+const countSourceFiles = (rootDirectory) => {
+	const result = spawnSync("git", [
+		"ls-files",
+		"--cached",
+		"--others",
+		"--exclude-standard"
+	], {
+		cwd: rootDirectory,
+		encoding: "utf-8"
+	});
+	if (result.error || result.status !== 0) return 0;
+	return result.stdout.split("\n").filter((filePath) => filePath.length > 0 && SOURCE_FILE_PATTERN.test(filePath)).length;
+};
+const collectAllDependencies = (packageJson) => ({
+	...packageJson.dependencies,
+	...packageJson.devDependencies
+});
+const detectFramework = (dependencies) => {
+	for (const [packageName, frameworkName] of Object.entries(FRAMEWORK_PACKAGES)) if (dependencies[packageName]) return frameworkName;
+	return "unknown";
+};
+const extractDependencyInfo = (packageJson) => {
+	const allDependencies = collectAllDependencies(packageJson);
+	return {
+		reactVersion: allDependencies.react ?? null,
+		framework: detectFramework(allDependencies)
+	};
+};
+const parsePnpmWorkspacePatterns = (rootDirectory) => {
+	const workspacePath = path.join(rootDirectory, "pnpm-workspace.yaml");
+	if (!fs.existsSync(workspacePath)) return [];
+	const content = fs.readFileSync(workspacePath, "utf-8");
+	const patterns = [];
+	let insidePackagesBlock = false;
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed === "packages:") {
+			insidePackagesBlock = true;
+			continue;
+		}
+		if (insidePackagesBlock && trimmed.startsWith("-")) patterns.push(trimmed.replace(/^-\s*/, "").replace(/["']/g, ""));
+		else if (insidePackagesBlock && trimmed.length > 0 && !trimmed.startsWith("#")) insidePackagesBlock = false;
+	}
+	return patterns;
+};
+const getWorkspacePatterns = (rootDirectory, packageJson) => {
+	const pnpmPatterns = parsePnpmWorkspacePatterns(rootDirectory);
+	if (pnpmPatterns.length > 0) return pnpmPatterns;
+	if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
+	if (packageJson.workspaces?.packages) return packageJson.workspaces.packages;
+	return [];
+};
+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];
+		return [];
+	}
+	const baseDirectory = path.join(rootDirectory, cleanPattern.slice(0, cleanPattern.indexOf("*")));
+	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 findDependencyInfoFromAncestors = (startDirectory) => {
+	let currentDirectory = path.dirname(startDirectory);
+	const result = {
+		reactVersion: null,
+		framework: "unknown"
+	};
+	while (currentDirectory !== path.dirname(currentDirectory)) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) {
+			const info = extractDependencyInfo(readPackageJson(packageJsonPath));
+			if (!result.reactVersion && info.reactVersion) result.reactVersion = info.reactVersion;
+			if (result.framework === "unknown" && info.framework !== "unknown") result.framework = info.framework;
+			if (result.reactVersion && result.framework !== "unknown") return result;
+		}
+		currentDirectory = path.dirname(currentDirectory);
+	}
+	return result;
+};
+const findReactInWorkspaces = (rootDirectory, packageJson) => {
+	const patterns = getWorkspacePatterns(rootDirectory, packageJson);
+	const result = {
+		reactVersion: null,
+		framework: "unknown"
+	};
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			const info = extractDependencyInfo(readPackageJson(path.join(workspaceDirectory, "package.json")));
+			if (info.reactVersion && !result.reactVersion) result.reactVersion = info.reactVersion;
+			if (info.framework !== "unknown" && result.framework === "unknown") result.framework = info.framework;
+			if (result.reactVersion && result.framework !== "unknown") return result;
+		}
+	}
+	return result;
+};
+const hasReactDependency = (packageJson) => {
+	const allDependencies = collectAllDependencies(packageJson);
+	return Object.keys(allDependencies).some((packageName) => packageName === "next" || packageName.includes("react"));
+};
+const listWorkspacePackages = (rootDirectory) => {
+	const packageJsonPath = path.join(rootDirectory, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return [];
+	const patterns = getWorkspacePatterns(rootDirectory, readPackageJson(packageJsonPath));
+	if (patterns.length === 0) return [];
+	const packages = [];
+	for (const pattern of patterns) {
+		const directories = resolveWorkspaceDirectories(rootDirectory, pattern);
+		for (const workspaceDirectory of directories) {
+			const workspacePackageJson = readPackageJson(path.join(workspaceDirectory, "package.json"));
+			if (!hasReactDependency(workspacePackageJson)) continue;
+			const name = workspacePackageJson.name ?? path.basename(workspaceDirectory);
+			packages.push({
+				name,
+				directory: workspaceDirectory
+			});
+		}
+	}
+	return packages;
+};
+const hasCompilerPackage = (packageJson) => {
+	const allDependencies = collectAllDependencies(packageJson);
+	return Object.keys(allDependencies).some((packageName) => REACT_COMPILER_PACKAGES.has(packageName));
+};
+const fileContainsPattern = (filePath, pattern) => {
+	if (!fs.existsSync(filePath)) return false;
+	const content = fs.readFileSync(filePath, "utf-8");
+	return pattern.test(content);
+};
+const hasCompilerInConfigFiles = (directory, filenames) => filenames.some((filename) => fileContainsPattern(path.join(directory, filename), REACT_COMPILER_CONFIG_PATTERN));
+const detectReactCompiler = (directory, packageJson) => {
+	if (hasCompilerPackage(packageJson)) return true;
+	if (hasCompilerInConfigFiles(directory, NEXT_CONFIG_FILENAMES)) return true;
+	if (hasCompilerInConfigFiles(directory, BABEL_CONFIG_FILENAMES)) return true;
+	if (hasCompilerInConfigFiles(directory, VITE_CONFIG_FILENAMES)) return true;
+	let ancestorDirectory = path.dirname(directory);
+	while (ancestorDirectory !== path.dirname(ancestorDirectory)) {
+		const ancestorPackagePath = path.join(ancestorDirectory, "package.json");
+		if (fs.existsSync(ancestorPackagePath)) {
+			if (hasCompilerPackage(readPackageJson(ancestorPackagePath))) return true;
+		}
+		ancestorDirectory = path.dirname(ancestorDirectory);
+	}
+	return false;
+};
+const discoverProject = (directory) => {
+	const packageJsonPath = path.join(directory, "package.json");
+	if (!fs.existsSync(packageJsonPath)) throw new Error(`No package.json found in ${directory}`);
+	const packageJson = readPackageJson(packageJsonPath);
+	let { reactVersion, framework } = extractDependencyInfo(packageJson);
+	if (!reactVersion || framework === "unknown") {
+		const workspaceInfo = findReactInWorkspaces(directory, packageJson);
+		if (!reactVersion && workspaceInfo.reactVersion) reactVersion = workspaceInfo.reactVersion;
+		if (framework === "unknown" && workspaceInfo.framework !== "unknown") framework = workspaceInfo.framework;
+	}
+	if (!reactVersion || framework === "unknown") {
+		const ancestorInfo = findDependencyInfoFromAncestors(directory);
+		if (!reactVersion) reactVersion = ancestorInfo.reactVersion;
+		if (framework === "unknown") framework = ancestorInfo.framework;
+	}
+	const hasTypeScript = fs.existsSync(path.join(directory, "tsconfig.json"));
+	const sourceFileCount = countSourceFiles(directory);
+	const hasReactCompiler = detectReactCompiler(directory, packageJson);
+	return {
+		rootDirectory: directory,
+		reactVersion,
+		framework,
+		hasTypeScript,
+		hasReactCompiler,
+		sourceFileCount
+	};
+};
+
+//#endregion
+//#region src/utils/group-by.ts
+const groupBy = (items, keyFn) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = keyFn(item);
+		const existing = groups.get(key) ?? [];
+		existing.push(item);
+		groups.set(key, existing);
+	}
+	return groups;
+};
+
+//#endregion
+//#region src/plugin/constants.ts
+const MOTION_LIBRARY_PACKAGES = new Set(["framer-motion", "motion"]);
+
+//#endregion
+//#region src/utils/check-reduced-motion.ts
+const REDUCED_MOTION_GREP_PATTERN = "prefers-reduced-motion|useReducedMotion";
+const REDUCED_MOTION_FILE_GLOBS = "\"*.ts\" \"*.tsx\" \"*.js\" \"*.jsx\" \"*.css\" \"*.scss\"";
+const checkReducedMotion = (rootDirectory) => {
+	const packageJsonPath = path.join(rootDirectory, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return [];
+	const packageJson = readPackageJson(packageJsonPath);
+	const allDependencies = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	if (!Object.keys(allDependencies).some((packageName) => MOTION_LIBRARY_PACKAGES.has(packageName))) return [];
+	try {
+		execSync(`git grep -ql -E "${REDUCED_MOTION_GREP_PATTERN}" -- ${REDUCED_MOTION_FILE_GLOBS}`, {
+			cwd: rootDirectory,
+			stdio: "pipe"
+		});
+		return [];
+	} catch {
+		return [{
+			filePath: "package.json",
+			plugin: "react-doctor",
+			rule: "require-reduced-motion",
+			severity: "error",
+			message: "Project uses a motion library but has no prefers-reduced-motion handling — required for accessibility (WCAG 2.3.3)",
+			help: "Add `useReducedMotion()` from your animation library, or a `@media (prefers-reduced-motion: reduce)` CSS query",
+			line: 0,
+			column: 0,
+			category: "Accessibility"
+		}];
+	}
+};
+
+//#endregion
+//#region src/utils/run-knip.ts
+const KNIP_CATEGORY_MAP = {
+	files: "Dead Code",
+	exports: "Dead Code",
+	types: "Dead Code",
+	duplicates: "Dead Code"
+};
+const KNIP_MESSAGE_MAP = {
+	files: "Unused file",
+	exports: "Unused export",
+	types: "Unused type",
+	duplicates: "Duplicate export"
+};
+const KNIP_SEVERITY_MAP = {
+	files: "warning",
+	exports: "warning",
+	types: "warning",
+	duplicates: "warning"
+};
+const collectIssueRecords = (records, issueType, rootDirectory) => {
+	const diagnostics = [];
+	for (const issues of Object.values(records)) for (const issue of Object.values(issues)) diagnostics.push({
+		filePath: path.relative(rootDirectory, issue.filePath),
+		plugin: "knip",
+		rule: issueType,
+		severity: KNIP_SEVERITY_MAP[issueType] ?? "warning",
+		message: `${KNIP_MESSAGE_MAP[issueType]}: ${issue.symbol}`,
+		help: "",
+		line: 0,
+		column: 0,
+		category: KNIP_CATEGORY_MAP[issueType] ?? "Dead Code"
+	});
+	return diagnostics;
+};
+const silenced = async (fn) => {
+	const originalLog = console.log;
+	const originalInfo = console.info;
+	const originalWarn = console.warn;
+	console.log = () => {};
+	console.info = () => {};
+	console.warn = () => {};
+	try {
+		return await fn();
+	} finally {
+		console.log = originalLog;
+		console.info = originalInfo;
+		console.warn = originalWarn;
+	}
+};
+const runKnip = async (rootDirectory) => {
+	const options = await silenced(() => createOptions({
+		cwd: rootDirectory,
+		isShowProgress: false
+	}));
+	const { issues } = await silenced(() => main(options));
+	const diagnostics = [];
+	for (const unusedFile of issues.files) diagnostics.push({
+		filePath: path.relative(rootDirectory, unusedFile),
+		plugin: "knip",
+		rule: "files",
+		severity: KNIP_SEVERITY_MAP["files"],
+		message: KNIP_MESSAGE_MAP["files"],
+		help: "This file is not imported by any other file in the project.",
+		line: 0,
+		column: 0,
+		category: KNIP_CATEGORY_MAP["files"]
+	});
+	for (const issueType of [
+		"exports",
+		"types",
+		"duplicates"
+	]) diagnostics.push(...collectIssueRecords(issues[issueType], issueType, rootDirectory));
+	return diagnostics;
+};
+
+//#endregion
+//#region src/oxlint-config.ts
+const esmRequire$1 = createRequire(import.meta.url);
+const NEXTJS_RULES = {
+	"react-doctor/nextjs-no-img-element": "warn",
+	"react-doctor/nextjs-async-client-component": "error",
+	"react-doctor/nextjs-no-a-element": "warn",
+	"react-doctor/nextjs-no-use-search-params-without-suspense": "error",
+	"react-doctor/nextjs-no-client-fetch-for-server-data": "warn",
+	"react-doctor/nextjs-missing-metadata": "warn",
+	"react-doctor/nextjs-no-client-side-redirect": "warn",
+	"react-doctor/nextjs-no-css-link": "warn",
+	"react-doctor/nextjs-no-polyfill-script": "warn",
+	"react-doctor/nextjs-no-head-import": "error"
+};
+const REACT_COMPILER_RULES = {
+	"react-hooks-js/set-state-in-render": "error",
+	"react-hooks-js/immutability": "error",
+	"react-hooks-js/refs": "error",
+	"react-hooks-js/purity": "error",
+	"react-hooks-js/hooks": "error",
+	"react-hooks-js/set-state-in-effect": "error",
+	"react-hooks-js/globals": "error",
+	"react-hooks-js/error-boundaries": "error",
+	"react-hooks-js/preserve-manual-memoization": "error",
+	"react-hooks-js/unsupported-syntax": "error",
+	"react-hooks-js/component-hook-factories": "error",
+	"react-hooks-js/static-components": "error",
+	"react-hooks-js/use-memo": "error",
+	"react-hooks-js/void-use-memo": "error",
+	"react-hooks-js/incompatible-library": "error",
+	"react-hooks-js/todo": "error"
+};
+const REACT_PERF_RULES = {
+	"react-perf/jsx-no-new-object-as-prop": "warn",
+	"react-perf/jsx-no-new-array-as-prop": "warn",
+	"react-perf/jsx-no-new-function-as-prop": "warn",
+	"react-perf/jsx-no-jsx-as-prop": "warn"
+};
+const createOxlintConfig = ({ pluginPath, framework, hasReactCompiler }) => ({
+	categories: {
+		correctness: "off",
+		suspicious: "off",
+		pedantic: "off",
+		perf: "off",
+		restriction: "off",
+		style: "off",
+		nursery: "off"
+	},
+	plugins: [
+		"react",
+		"jsx-a11y",
+		...hasReactCompiler ? [] : ["react-perf"]
+	],
+	jsPlugins: [...hasReactCompiler ? [{
+		name: "react-hooks-js",
+		specifier: esmRequire$1.resolve("eslint-plugin-react-hooks")
+	}] : [], pluginPath],
+	rules: {
+		"react/rules-of-hooks": "error",
+		"react/no-direct-mutation-state": "error",
+		"react/jsx-no-duplicate-props": "error",
+		"react/jsx-key": "error",
+		"react/no-children-prop": "warn",
+		"react/no-danger": "warn",
+		"react/jsx-no-script-url": "error",
+		"react/no-render-return-value": "warn",
+		"react/no-string-refs": "warn",
+		"react/no-unescaped-entities": "warn",
+		"react/no-is-mounted": "warn",
+		"react/require-render-return": "error",
+		"react/no-unknown-property": "warn",
+		"jsx-a11y/alt-text": "error",
+		"jsx-a11y/anchor-is-valid": "warn",
+		"jsx-a11y/click-events-have-key-events": "warn",
+		"jsx-a11y/no-static-element-interactions": "warn",
+		"jsx-a11y/no-noninteractive-element-interactions": "warn",
+		"jsx-a11y/role-has-required-aria-props": "error",
+		"jsx-a11y/no-autofocus": "warn",
+		"jsx-a11y/heading-has-content": "warn",
+		"jsx-a11y/html-has-lang": "warn",
+		"jsx-a11y/no-redundant-roles": "warn",
+		"jsx-a11y/scope": "warn",
+		"jsx-a11y/tabindex-no-positive": "warn",
+		"jsx-a11y/label-has-associated-control": "warn",
+		"jsx-a11y/no-distracting-elements": "error",
+		"jsx-a11y/iframe-has-title": "warn",
+		...hasReactCompiler ? REACT_COMPILER_RULES : REACT_PERF_RULES,
+		"react-doctor/no-derived-state-effect": "error",
+		"react-doctor/no-fetch-in-effect": "error",
+		"react-doctor/no-cascading-set-state": "warn",
+		"react-doctor/no-effect-event-handler": "warn",
+		"react-doctor/no-derived-useState": "warn",
+		"react-doctor/prefer-useReducer": "warn",
+		"react-doctor/rerender-lazy-state-init": "warn",
+		"react-doctor/rerender-functional-setstate": "warn",
+		"react-doctor/rerender-dependencies": "error",
+		"react-doctor/no-generic-handler-names": "warn",
+		"react-doctor/no-giant-component": "warn",
+		"react-doctor/no-render-in-render": "warn",
+		"react-doctor/no-nested-component-definition": "error",
+		"react-doctor/no-usememo-simple-expression": "warn",
+		"react-doctor/no-layout-property-animation": "error",
+		"react-doctor/rerender-memo-with-default-value": "warn",
+		"react-doctor/rendering-animate-svg-wrapper": "warn",
+		"react-doctor/rendering-usetransition-loading": "warn",
+		"react-doctor/rendering-hydration-no-flicker": "warn",
+		"react-doctor/no-transition-all": "warn",
+		"react-doctor/no-global-css-variable-animation": "error",
+		"react-doctor/no-large-animated-blur": "warn",
+		"react-doctor/no-scale-from-zero": "warn",
+		"react-doctor/no-permanent-will-change": "warn",
+		"react-doctor/no-secrets-in-client-code": "error",
+		"react-doctor/no-barrel-import": "warn",
+		"react-doctor/no-full-lodash-import": "warn",
+		"react-doctor/no-moment": "warn",
+		"react-doctor/prefer-dynamic-import": "warn",
+		"react-doctor/use-lazy-motion": "warn",
+		"react-doctor/no-undeferred-third-party": "warn",
+		"react-doctor/no-array-index-as-key": "warn",
+		"react-doctor/rendering-conditional-render": "warn",
+		"react-doctor/no-prevent-default": "warn",
+		"react-doctor/server-auth-actions": "error",
+		"react-doctor/server-after-nonblocking": "warn",
+		"react-doctor/client-passive-event-listeners": "warn",
+		"react-doctor/async-parallel": "warn",
+		...framework === "nextjs" ? NEXTJS_RULES : {}
+	}
+});
+
+//#endregion
+//#region src/utils/run-oxlint.ts
+const esmRequire = createRequire(import.meta.url);
+const PLUGIN_CATEGORY_MAP = {
+	react: "Correctness",
+	"react-hooks": "Correctness",
+	"react-hooks-js": "React Compiler",
+	"react-perf": "Performance",
+	"jsx-a11y": "Accessibility"
+};
+const RULE_CATEGORY_MAP = {
+	"react-doctor/no-derived-state-effect": "State & Effects",
+	"react-doctor/no-fetch-in-effect": "State & Effects",
+	"react-doctor/no-cascading-set-state": "State & Effects",
+	"react-doctor/no-effect-event-handler": "State & Effects",
+	"react-doctor/no-derived-useState": "State & Effects",
+	"react-doctor/prefer-useReducer": "State & Effects",
+	"react-doctor/rerender-lazy-state-init": "Performance",
+	"react-doctor/rerender-functional-setstate": "Performance",
+	"react-doctor/rerender-dependencies": "State & Effects",
+	"react-doctor/no-generic-handler-names": "Architecture",
+	"react-doctor/no-giant-component": "Architecture",
+	"react-doctor/no-render-in-render": "Architecture",
+	"react-doctor/no-nested-component-definition": "Correctness",
+	"react-doctor/no-usememo-simple-expression": "Performance",
+	"react-doctor/no-layout-property-animation": "Performance",
+	"react-doctor/rerender-memo-with-default-value": "Performance",
+	"react-doctor/rendering-animate-svg-wrapper": "Performance",
+	"react-doctor/rendering-usetransition-loading": "Performance",
+	"react-doctor/rendering-hydration-no-flicker": "Performance",
+	"react-doctor/no-transition-all": "Performance",
+	"react-doctor/no-global-css-variable-animation": "Performance",
+	"react-doctor/no-large-animated-blur": "Performance",
+	"react-doctor/no-scale-from-zero": "Performance",
+	"react-doctor/no-permanent-will-change": "Performance",
+	"react-doctor/no-secrets-in-client-code": "Security",
+	"react-doctor/no-barrel-import": "Bundle Size",
+	"react-doctor/no-full-lodash-import": "Bundle Size",
+	"react-doctor/no-moment": "Bundle Size",
+	"react-doctor/prefer-dynamic-import": "Bundle Size",
+	"react-doctor/use-lazy-motion": "Bundle Size",
+	"react-doctor/no-undeferred-third-party": "Bundle Size",
+	"react-doctor/no-array-index-as-key": "Correctness",
+	"react-doctor/rendering-conditional-render": "Correctness",
+	"react-doctor/no-prevent-default": "Correctness",
+	"react-doctor/nextjs-no-img-element": "Next.js",
+	"react-doctor/nextjs-async-client-component": "Next.js",
+	"react-doctor/nextjs-no-a-element": "Next.js",
+	"react-doctor/nextjs-no-use-search-params-without-suspense": "Next.js",
+	"react-doctor/nextjs-no-client-fetch-for-server-data": "Next.js",
+	"react-doctor/nextjs-missing-metadata": "Next.js",
+	"react-doctor/nextjs-no-client-side-redirect": "Next.js",
+	"react-doctor/nextjs-no-redirect-in-try-catch": "Next.js",
+	"react-doctor/nextjs-image-missing-sizes": "Next.js",
+	"react-doctor/nextjs-no-native-script": "Next.js",
+	"react-doctor/nextjs-inline-script-missing-id": "Next.js",
+	"react-doctor/nextjs-no-font-link": "Next.js",
+	"react-doctor/nextjs-no-css-link": "Next.js",
+	"react-doctor/nextjs-no-polyfill-script": "Next.js",
+	"react-doctor/nextjs-no-head-import": "Next.js",
+	"react-doctor/server-auth-actions": "Server",
+	"react-doctor/server-after-nonblocking": "Server",
+	"react-doctor/client-passive-event-listeners": "Performance",
+	"react-doctor/async-parallel": "Performance"
+};
+const RULE_HELP_MAP = {
+	"no-derived-state-effect": "Compute during render: `const derived = computeFrom(dep1, dep2)` — no useEffect needed",
+	"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",
+	"no-derived-useState": "Remove useState and compute the value inline: `const value = transform(propName)`",
+	"prefer-useReducer": "Group related state: `const [state, dispatch] = useReducer(reducer, { field1, field2, ... })`",
+	"rerender-lazy-state-init": "Wrap in an arrow function so it only runs once: `useState(() => expensiveComputation())`",
+	"rerender-functional-setstate": "Use the callback form: `setState(prev => prev + 1)` to always read the latest value",
+	"rerender-dependencies": "Extract to a useMemo, useRef, or module-level constant so the reference is stable",
+	"no-generic-handler-names": "Rename to describe the action: e.g. `handleSubmit` → `saveUserProfile`, `handleClick` → `toggleSidebar`",
+	"no-giant-component": "Extract logical sections into focused components: `<UserHeader />`, `<UserActions />`, etc.",
+	"no-render-in-render": "Extract to a named component: `const ListItem = ({ item }) => <div>{item.name}</div>`",
+	"no-nested-component-definition": "Move to a separate file or to module scope above the parent component",
+	"no-usememo-simple-expression": "Remove useMemo — property access, math, and ternaries are already cheap without memoization",
+	"no-layout-property-animation": "Use `transform: translateX()` or `scale()` instead — they run on the compositor and skip layout/paint",
+	"rerender-memo-with-default-value": "Move to module scope: `const EMPTY_ITEMS: Item[] = []` then use as the default value",
+	"rendering-animate-svg-wrapper": "Wrap the SVG: `<motion.div animate={...}><svg>...</svg></motion.div>`",
+	"rendering-usetransition-loading": "Replace with `const [isPending, startTransition] = useTransition()` — avoids a re-render for the loading state",
+	"rendering-hydration-no-flicker": "Use `useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)` or add `suppressHydrationWarning` to the element",
+	"no-transition-all": "List specific properties: `transition: \"opacity 200ms, transform 200ms\"` — or in Tailwind use `transition-colors`, `transition-opacity`, or `transition-transform`",
+	"no-global-css-variable-animation": "Set the variable on the nearest element instead of a parent, or use `@property` with `inherits: false` to prevent cascade. Better yet, use targeted `element.style.transform` updates",
+	"no-large-animated-blur": "Keep blur radius under 10px, or apply blur to a smaller element. Large blurs multiply GPU memory usage with layer size",
+	"no-scale-from-zero": "Use `initial={{ scale: 0.95, opacity: 0 }}` — elements should deflate like a balloon, not vanish into a point",
+	"no-permanent-will-change": "Add will-change on animation start (`onMouseEnter`) and remove on end (`onAnimationEnd`). Permanent promotion wastes GPU memory and can degrade performance",
+	"no-secrets-in-client-code": "Move to server-side `process.env.SECRET_NAME`. Only `NEXT_PUBLIC_*` vars are safe for the client (and should not contain secrets)",
+	"no-barrel-import": "Import from the direct path: `import { Button } from './components/Button'` instead of `./components`",
+	"no-full-lodash-import": "Import the specific function: `import debounce from 'lodash/debounce'` — saves ~70kb",
+	"no-moment": "Replace with `import { format } from 'date-fns'` (tree-shakeable) or `import dayjs from 'dayjs'` (2kb)",
+	"prefer-dynamic-import": "Use `const Component = dynamic(() => import('library'), { ssr: false })` from next/dynamic or React.lazy()",
+	"use-lazy-motion": "Use `import { LazyMotion, m } from \"framer-motion\"` with `domAnimation` features — saves ~30kb",
+	"no-undeferred-third-party": "Use `next/script` with `strategy=\"lazyOnload\"` or add the `defer` attribute",
+	"no-array-index-as-key": "Use a stable unique identifier: `key={item.id}` or `key={item.slug}` — index keys break on reorder/filter",
+	"rendering-conditional-render": "Change to `{items.length > 0 && <List />}` or use a ternary: `{items.length ? <List /> : null}`",
+	"no-prevent-default": "Use `<form action={serverAction}>` (works without JS) or `<button>` instead of `<a>` with preventDefault",
+	"nextjs-no-img-element": "`import Image from 'next/image'` — provides automatic WebP/AVIF, lazy loading, and responsive srcset",
+	"nextjs-async-client-component": "Fetch data in a parent Server Component and pass it as props, or use useQuery/useSWR in the client component",
+	"nextjs-no-a-element": "`import Link from 'next/link'` — enables client-side navigation, prefetching, and preserves scroll position",
+	"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-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",
+	"nextjs-inline-script-missing-id": "Add `id=\"descriptive-name\"` so Next.js can track, deduplicate, and re-execute the script correctly",
+	"nextjs-no-font-link": "`import { Inter } from \"next/font/google\"` — self-hosted, zero layout shift, no render-blocking requests",
+	"nextjs-no-css-link": "Import CSS directly: `import './styles.css'` or use CSS Modules: `import styles from './Button.module.css'`",
+	"nextjs-no-polyfill-script": "Next.js includes polyfills for fetch, Promise, Object.assign, Array.from, and 50+ others automatically",
+	"nextjs-no-head-import": "Use the Metadata API instead: `export const metadata = { title: '...' }` or `export async function generateMetadata()`",
+	"server-auth-actions": "Add `const session = await auth()` at the top and throw/redirect if unauthorized before any data access",
+	"server-after-nonblocking": "`import { after } from 'next/server'` then wrap: `after(() => analytics.track(...))` — response isn't blocked",
+	"client-passive-event-listeners": "Add `{ passive: true }` as the third argument: `addEventListener('scroll', handler, { passive: true })`",
+	"async-parallel": "Use `const [a, b] = await Promise.all([fetchA(), fetchB()])` to run independent operations concurrently"
+};
+const FILEPATH_WITH_LOCATION_PATTERN = /\S+\.\w+:\d+:\d+[\s\S]*$/;
+const REACT_COMPILER_MESSAGE = "React Compiler can't optimize this code";
+const cleanDiagnosticMessage = (message, help, plugin, rule) => {
+	if (plugin === "react-hooks-js") return {
+		message: REACT_COMPILER_MESSAGE,
+		help: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || help
+	};
+	return {
+		message: message.replace(FILEPATH_WITH_LOCATION_PATTERN, "").trim() || message,
+		help: help || RULE_HELP_MAP[rule] || ""
+	};
+};
+const parseRuleCode = (code) => {
+	const match = code.match(/^(.+)\((.+)\)$/);
+	if (!match) return {
+		plugin: "unknown",
+		rule: code
+	};
+	return {
+		plugin: match[1].replace(/^eslint-plugin-/, ""),
+		rule: match[2]
+	};
+};
+const resolveOxlintBinary = () => {
+	const oxlintMainPath = esmRequire.resolve("oxlint");
+	const oxlintPackageDirectory = path.resolve(path.dirname(oxlintMainPath), "..");
+	return path.join(oxlintPackageDirectory, "bin", "oxlint");
+};
+const resolvePluginPath = () => {
+	const currentDirectory = path.dirname(fileURLToPath(import.meta.url));
+	return path.join(currentDirectory, "react-doctor-plugin.js");
+};
+const resolveDiagnosticCategory = (plugin, rule) => {
+	return RULE_CATEGORY_MAP[`${plugin}/${rule}`] ?? PLUGIN_CATEGORY_MAP[plugin] ?? "Other";
+};
+const runOxlint = async (rootDirectory, hasTypeScript, framework, hasReactCompiler) => {
+	const configPath = path.join(os.tmpdir(), `react-doctor-oxlintrc-${process.pid}.json`);
+	const config = createOxlintConfig({
+		pluginPath: resolvePluginPath(),
+		framework,
+		hasReactCompiler
+	});
+	try {
+		fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+		const args = [
+			resolveOxlintBinary(),
+			"-c",
+			configPath,
+			"--format",
+			"json"
+		];
+		if (hasTypeScript) args.push("--tsconfig", "./tsconfig.json");
+		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)}`);
+		}
+		return output.diagnostics.filter((diagnostic) => 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)
+			};
+		});
+	} finally {
+		if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+	}
+};
+
+//#endregion
+//#region src/utils/spinner.ts
+const spinner = (text) => ora({ text });
+
+//#endregion
+//#region src/scan.ts
+const SEVERITY_ORDER = {
+	error: 0,
+	warning: 1
+};
+const sortBySeverity = (diagnosticGroups) => diagnosticGroups.toSorted(([, diagnosticsA], [, diagnosticsB]) => {
+	return SEVERITY_ORDER[diagnosticsA[0].severity] - SEVERITY_ORDER[diagnosticsB[0].severity];
+});
+const collectAffectedFiles = (diagnostics) => {
+	const files = /* @__PURE__ */ new Set();
+	for (const diagnostic of diagnostics) files.add(diagnostic.filePath);
+	return files;
+};
+const printDiagnostics = (diagnostics) => {
+	const sortedRuleGroups = sortBySeverity([...groupBy(diagnostics, (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`).entries()]);
+	for (const [, ruleDiagnostics] of sortedRuleGroups) {
+		const firstDiagnostic = ruleDiagnostics[0];
+		const icon = firstDiagnostic.severity === "error" ? highlighter.error("✗") : highlighter.warn("⚠");
+		const count = ruleDiagnostics.length;
+		const countLabel = count > 1 ? ` (${count})` : "";
+		logger.log(`  ${icon} ${firstDiagnostic.message}${countLabel}`);
+		if (firstDiagnostic.help) logger.dim(`    ${firstDiagnostic.help}`);
+		const fileLines = /* @__PURE__ */ new Map();
+		for (const diagnostic of ruleDiagnostics) {
+			const lines = fileLines.get(diagnostic.filePath) ?? [];
+			if (diagnostic.line > 0) lines.push(diagnostic.line);
+			fileLines.set(diagnostic.filePath, lines);
+		}
+		for (const [filePath, lines] of fileLines) {
+			const lineLabel = lines.length > 0 ? `: ${lines.join(", ")}` : "";
+			logger.dim(`    ${filePath}${lineLabel}`);
+		}
+		logger.break();
+	}
+};
+const formatElapsedTime = (elapsedMilliseconds) => {
+	if (elapsedMilliseconds < 1e3) return `${Math.round(elapsedMilliseconds)}ms`;
+	return `${(elapsedMilliseconds / 1e3).toFixed(1)}s`;
+};
+const formatRuleSummary = (ruleKey, ruleDiagnostics) => {
+	const firstDiagnostic = ruleDiagnostics[0];
+	const fileLines = /* @__PURE__ */ new Map();
+	for (const diagnostic of ruleDiagnostics) {
+		const lines = fileLines.get(diagnostic.filePath) ?? [];
+		if (diagnostic.line > 0) lines.push(diagnostic.line);
+		fileLines.set(diagnostic.filePath, lines);
+	}
+	const sections = [
+		`Rule: ${ruleKey}`,
+		`Severity: ${firstDiagnostic.severity}`,
+		`Category: ${firstDiagnostic.category}`,
+		`Count: ${ruleDiagnostics.length}`,
+		"",
+		firstDiagnostic.message
+	];
+	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}`);
+	}
+	return sections.join("\n") + "\n";
+};
+const writeDiagnosticsDirectory = (diagnostics) => {
+	const outputDirectory = join(tmpdir(), `react-doctor-${randomUUID()}`);
+	mkdirSync(outputDirectory);
+	const sortedRuleGroups = sortBySeverity([...groupBy(diagnostics, (diagnostic) => `${diagnostic.plugin}/${diagnostic.rule}`).entries()]);
+	for (const [ruleKey, ruleDiagnostics] of sortedRuleGroups) writeFileSync(join(outputDirectory, ruleKey.replace(/\//g, "--") + ".txt"), formatRuleSummary(ruleKey, ruleDiagnostics));
+	writeFileSync(join(outputDirectory, "diagnostics.json"), JSON.stringify(diagnostics, null, 2));
+	return outputDirectory;
+};
+const printSummary = (diagnostics, 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);
+	logger.log("─".repeat(SEPARATOR_LENGTH_CHARS));
+	logger.break();
+	const parts = [];
+	if (errorCount > 0) parts.push(highlighter.error(`${errorCount} error${errorCount === 1 ? "" : "s"}`));
+	if (warningCount > 0) parts.push(highlighter.warn(`${warningCount} warning${warningCount === 1 ? "" : "s"}`));
+	parts.push(highlighter.dim(`across ${affectedFileCount} file${affectedFileCount === 1 ? "" : "s"}`));
+	parts.push(highlighter.dim(`in ${elapsed}`));
+	logger.log(parts.join("  "));
+	const diagnosticsDirectory = writeDiagnosticsDirectory(diagnostics);
+	logger.break();
+	logger.dim(`Full diagnostics written to ${diagnosticsDirectory}`);
+};
+const scan = async (directory, options) => {
+	const startTime = performance.now();
+	const projectInfo = discoverProject(directory);
+	if (!projectInfo.reactVersion) throw new Error("No React dependency found in package.json");
+	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."}`);
+	completeStep(`Found ${highlighter.info(`${projectInfo.sourceFileCount}`)} source files.`);
+	logger.break();
+	const diagnostics = [];
+	if (options.lint) {
+		const lintSpinner = spinner("Running lint checks...").start();
+		diagnostics.push(...await runOxlint(directory, projectInfo.hasTypeScript, projectInfo.framework, projectInfo.hasReactCompiler));
+		lintSpinner.succeed("Running lint checks.");
+	}
+	if (options.deadCode) {
+		const deadCodeSpinner = spinner("Detecting dead code...").start();
+		diagnostics.push(...await runKnip(directory));
+		deadCodeSpinner.succeed("Detecting dead code.");
+	}
+	diagnostics.push(...checkReducedMotion(directory));
+	const elapsedMilliseconds = performance.now() - startTime;
+	if (diagnostics.length === 0) {
+		logger.success("No issues found!");
+		return;
+	}
+	printDiagnostics(diagnostics);
+	printSummary(diagnostics, elapsedMilliseconds);
+};
+
+//#endregion
+//#region src/utils/prompts.ts
+const onCancel = () => {
+	logger.break();
+	logger.log("Cancelled.");
+	logger.break();
+	process.exit(0);
+};
+const prompts = (questions) => {
+	return basePrompts(questions, { onCancel });
+};
+
+//#endregion
+//#region src/utils/select-projects.ts
+const selectProjects = async (rootDirectory, projectFlag) => {
+	const workspacePackages = listWorkspacePackages(rootDirectory);
+	if (workspacePackages.length === 0) return [rootDirectory];
+	if (projectFlag) return resolveProjectFlag(projectFlag, workspacePackages);
+	return promptProjectSelection(workspacePackages, rootDirectory);
+};
+const resolveProjectFlag = (projectFlag, workspacePackages) => {
+	const requestedNames = projectFlag.split(",").map((name) => name.trim());
+	const resolvedDirectories = [];
+	for (const requestedName of requestedNames) {
+		const matched = workspacePackages.find((workspacePackage) => workspacePackage.name === requestedName || path.basename(workspacePackage.directory) === requestedName);
+		if (!matched) {
+			const availableNames = workspacePackages.map((workspacePackage) => workspacePackage.name).join(", ");
+			throw new Error(`Project "${requestedName}" not found. Available: ${availableNames}`);
+		}
+		resolvedDirectories.push(matched.directory);
+	}
+	return resolvedDirectories;
+};
+const promptProjectSelection = async (workspacePackages, rootDirectory) => {
+	const { selectedDirectories } = await prompts({
+		type: "multiselect",
+		name: "selectedDirectories",
+		message: "Select projects to scan",
+		choices: workspacePackages.map((workspacePackage) => ({
+			title: workspacePackage.name,
+			description: path.relative(rootDirectory, workspacePackage.directory),
+			value: workspacePackage.directory
+		})),
+		min: 1
+	});
+	return selectedDirectories;
+};
+
+//#endregion
+//#region src/cli.ts
+const VERSION = "0.0.4";
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+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("--no-lint", "skip linting").option("--no-dead-code", "skip dead code detection").option("--project <name>", "select workspace project (comma-separated for multiple)").action(async (directory, flags) => {
+	try {
+		const resolvedDirectory = path.resolve(directory);
+		logger.log(`react-doctor v${VERSION}`);
+		logger.break();
+		const scanOptions = {
+			lint: flags.lint,
+			deadCode: flags.deadCode
+		};
+		const projectDirectories = await selectProjects(resolvedDirectory, flags.project);
+		for (const projectDirectory of projectDirectories) {
+			logger.dim(`Scanning ${projectDirectory}...`);
+			logger.break();
+			await scan(projectDirectory, scanOptions);
+			logger.break();
+		}
+	} catch (error) {
+		handleError(error);
+	}
+}).addHelpText("after", `
+${highlighter.dim("Learn more:")}
+  ${highlighter.info("https://github.com/aidenybai/react-doctor")}
+`);
+const main$1 = async () => {
+	await program.parseAsync();
+};
+main$1();
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.js.map