hermex 1.3.0-beta.4 → 2.0.0-beta.10

package/dist/cli.mjs

@@ -1,1410 +1,1747 @@
 #!/usr/bin/env node
-import { Command } from "commander";
-import ora from "ora";
+import { Command, Option } from "commander";
 import chalk from "chalk";
-import { parseSync } from "@swc/core";
+import Table from "cli-table3";
 import fs, { existsSync, readFileSync } from "node:fs";
-import path, { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import path, { dirname, join, resolve } from "node:path";
+import { z } from "zod";
+import { parseSync } from "@swc/core";
 import micromatch from "micromatch";
 import { glob, globSync } from "glob";
 import fs$1 from "fs";
 import path$1 from "path";
 import semver from "semver";
-import Table from "cli-table3";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { load } from "js-yaml";
 import lockfile from "@yarnpkg/lockfile";
-import { z } from "zod";
-//#region src/swc-parser/core/state.ts
-function createState() {
-	return {
-		usagePatterns: {
-			namedImports: /* @__PURE__ */ new Set(),
-			namespaceImports: /* @__PURE__ */ new Set(),
-			defaultImports: /* @__PURE__ */ new Set(),
-			aliasedImports: /* @__PURE__ */ new Map(),
-			variableAssignments: /* @__PURE__ */ new Map(),
-			lazyImports: /* @__PURE__ */ new Set(),
-			dynamicImports: /* @__PURE__ */ new Set(),
-			conditionalUsage: /* @__PURE__ */ new Set(),
-			arrayMappings: /* @__PURE__ */ new Set(),
-			objectMappings: /* @__PURE__ */ new Set(),
-			hocUsage: /* @__PURE__ */ new Set(),
-			forwardedRefs: /* @__PURE__ */ new Set(),
-			memoizedComponents: /* @__PURE__ */ new Set(),
-			portalUsage: /* @__PURE__ */ new Set(),
-			jsxUsage: /* @__PURE__ */ new Map(),
-			destructuredUsage: /* @__PURE__ */ new Set(),
-			propsAnalysis: /* @__PURE__ */ new Map()
-		},
-		componentNames: /* @__PURE__ */ new Set(),
-		allIdentifiers: /* @__PURE__ */ new Set()
-	};
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import ora from "ora";
+//#region src/utils/format-utils.ts
+/**
+* Format a number with thousand separators
+* @param num - Number to format
+* @returns Formatted string (e.g., 1,234,567)
+*/
+function formatCount(num) {
+	return num.toLocaleString();
 }
-//#endregion
-//#region src/swc-parser/patterns/imports.ts
 /**
-* Analyzes import declarations and tracks all types:
-* - Default imports
-* - Named imports
-* - Namespace imports
-* - Aliased imports
+* Format how far an upgrade candidate is past its age threshold
+* @returns Formatted string (e.g., "40 days overdue", "1 day overdue")
 */
-function analyzeImportDeclaration(node, state) {
-	const source = node.source.value;
-	for (const spec of node.specifiers) switch (spec.type) {
-		case "ImportDefaultSpecifier":
-			analyzeDefaultImport(spec, source, node, state);
-			break;
-		case "ImportNamespaceSpecifier":
-			analyzeNamespaceImport(spec, source, node, state);
-			break;
-		case "ImportSpecifier":
-			analyzeNamedImport(spec, source, node, state);
-			break;
-	}
+function formatDaysOverdue(releasedDaysAgo, thresholdDays) {
+	const overdue = releasedDaysAgo - thresholdDays;
+	return `${overdue} day${overdue === 1 ? "" : "s"} overdue`;
 }
-function analyzeDefaultImport(spec, source, node, state) {
-	const name = spec.local.value;
-	state.usagePatterns.defaultImports.add({
-		name,
-		source,
-		line: node.span?.start || 0
+/**
+* Format how long until an upgrade candidate breaches its age threshold
+* @returns Formatted string (e.g., "12 days remaining", "1 day remaining")
+*/
+function formatDaysRemaining(daysRemaining) {
+	return `${daysRemaining} day${daysRemaining === 1 ? "" : "s"} remaining`;
+}
+/**
+* Join a list of items, showing only the first `limit` and summarizing the rest
+* @returns Formatted string (e.g., "a, b and 3 other files", "a, b and 1 other file")
+*/
+function formatTruncatedList(items, noun, limit = 2) {
+	const shown = items.slice(0, limit).join(", ");
+	const rest = items.length - limit;
+	if (rest <= 0) return shown;
+	return `${shown} and ${rest} other ${noun}${rest === 1 ? "" : "s"}`;
+}
+//#endregion
+//#region src/utils/print-summary.ts
+function printHeader$4() {
+	console.log(chalk.green.bold("\n📊 Summary\n"));
+}
+function printSummary(aggregated) {
+	printHeader$4();
+	const table = new Table({
+		head: ["Metric", "Count"],
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
 	});
-	state.componentNames.add(name);
+	const externalComponents = aggregated.topComponents.filter((comp) => comp.source !== "unknown" && comp.source !== "local").length;
+	const totalExternalUsage = aggregated.packageDistribution.reduce((sum, pkg) => sum + pkg.usageCount, 0);
+	table.push(["Files Analyzed", formatCount(aggregated.filesAnalyzed)], ["External Packages", formatCount(aggregated.packageDistribution.length)], ["External Components", formatCount(externalComponents)], ["Total Usages", formatCount(totalExternalUsage)]);
+	console.log(table.toString());
 }
-function analyzeNamespaceImport(spec, source, node, state) {
-	const name = spec.local.value;
-	state.usagePatterns.namespaceImports.add({
-		name,
-		source,
-		line: node.span?.start || 0
+//#endregion
+//#region src/utils/print-details.ts
+function printHeader$3() {
+	console.log(chalk.cyan.bold("\n📋 Details\n"));
+}
+function printDetails(aggregated) {
+	printHeader$3();
+	console.log(chalk.cyan(`  Total usage patterns: ${formatCount(aggregated.totalUsagePatterns)}`));
+	for (const pattern of aggregated.patternCounts) if (pattern.count > 0) console.log(chalk.cyan(`  ${pattern.displayName}: ${formatCount(pattern.count)}`));
+}
+//#endregion
+//#region src/utils/chart-renderer.ts
+function renderBarChart(data, options = {}) {
+	const { maxWidth = 50, showValues = true, barChar = "█", emptyChar = "░" } = options;
+	if (data.length === 0) {
+		console.log(chalk.gray("  No data to display"));
+		return;
+	}
+	const maxValue = Math.max(...data.map((d) => d.value));
+	if (maxValue === 0) {
+		console.log(chalk.gray("  All values are zero"));
+		return;
+	}
+	const maxLabelLength = Math.max(...data.map((d) => d.label.length));
+	for (const item of data) {
+		const percentage = item.value / maxValue;
+		const barLength = Math.round(percentage * maxWidth);
+		const emptyLength = maxWidth - barLength;
+		const paddedLabel = item.label.padEnd(maxLabelLength, " ");
+		const bar = chalk.green(barChar.repeat(barLength)) + chalk.gray(emptyChar.repeat(emptyLength));
+		const valueStr = showValues ? ` ${formatCount(item.value)}` : "";
+		console.log(`${paddedLabel} ${bar}${valueStr}\n`);
+	}
+}
+//#endregion
+//#region src/utils/print-components.ts
+function printHeader$2() {
+	console.log(chalk.magenta.bold("\n⚛️ Components\n"));
+}
+function printComponents(aggregated, mode) {
+	const components = aggregated.topComponents;
+	if (mode === "table") printComponentsTable(components);
+	else if (mode === "chart") printComponentsChart(components);
+}
+function printComponentsTable(components) {
+	printHeader$2();
+	const externalComponents = components.filter((comp) => comp.source !== "unknown" && comp.source !== "local");
+	if (externalComponents.length === 0) {
+		console.log(chalk.gray("  No external components found"));
+		return;
+	}
+	const table = new Table({
+		head: [
+			"Component",
+			"Package",
+			"Count"
+		],
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
 	});
-	state.allIdentifiers.add(name);
+	externalComponents.forEach((comp) => {
+		table.push([
+			comp.name,
+			comp.source,
+			comp.count.toString()
+		]);
+	});
+	console.log(table.toString());
 }
-function analyzeNamedImport(spec, source, node, state) {
-	const importedName = spec.imported ? spec.imported.value : spec.local.value;
-	const localName = spec.local.value;
-	state.usagePatterns.namedImports.add({
-		name: importedName,
-		source,
-		line: node.span?.start || 0
+function printComponentsChart(components) {
+	printHeader$2();
+	const externalComponents = components.filter((comp) => comp.source !== "unknown" && comp.source !== "local");
+	if (externalComponents.length === 0) {
+		console.log(chalk.gray("  No external components found"));
+		return;
+	}
+	renderBarChart(externalComponents.map((comp) => ({
+		label: comp.name,
+		value: comp.count
+	})), { maxWidth: 50 });
+}
+//#endregion
+//#region src/utils/print-patterns.ts
+function printHeader$1() {
+	console.log(chalk.blue.bold("\n🔍 Code Patterns\n"));
+}
+function printPatterns(aggregated, mode) {
+	const patterns = aggregated.patternCounts.filter((p) => p.count > 0);
+	if (mode === "table") printPatternsTable(patterns);
+	else if (mode === "chart") printPatternsChart(patterns);
+}
+function printPatternsTable(patterns) {
+	printHeader$1();
+	if (patterns.length === 0) {
+		console.log(chalk.gray("  No patterns found"));
+		return;
+	}
+	const table = new Table({
+		head: ["Pattern", "Count"],
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
 	});
-	if (importedName !== localName) state.usagePatterns.aliasedImports.set(localName, {
-		imported: importedName,
-		local: localName,
-		source,
-		line: node.span?.start || 0
+	patterns.forEach((pattern) => {
+		table.push([pattern.displayName, pattern.count.toString()]);
 	});
-	state.componentNames.add(localName);
+	console.log(table.toString());
+	const totalPatterns = patterns.reduce((sum, p) => sum + p.count, 0);
+	console.log(chalk.gray(`\nTotal: ${totalPatterns} patterns detected`));
+}
+function printPatternsChart(patterns) {
+	printHeader$1();
+	if (patterns.length === 0) {
+		console.log(chalk.gray("  No patterns found"));
+		return;
+	}
+	renderBarChart(patterns.map((pattern) => ({
+		label: pattern.displayName,
+		value: pattern.count
+	})), { maxWidth: 50 });
 }
 //#endregion
-//#region src/swc-parser/utils/jsx-helpers.ts
+//#region src/utils/severity-format.ts
+const ICONS = {
+	error: "🔴",
+	warn: "🟡",
+	info: "🔵",
+	success: "🟢"
+};
+const COLORS = {
+	error: chalk.red,
+	warn: chalk.yellow,
+	info: chalk.blue,
+	success: chalk.green
+};
+/** Colored-circle glyph for a severity — carries meaning without relying on ANSI color. */
+function severityIcon(severity) {
+	return ICONS[severity];
+}
+/** chalk color function for a severity, for text that needs coloring. */
+function severityColor(severity) {
+	return COLORS[severity];
+}
+function formatViolationLine(opts) {
+	return `  ${opts.icon}  ${opts.label.padEnd(14)} ${opts.description}`;
+}
 /**
-* Extracts the name from a JSX element (handles identifiers and member expressions)
+* Resolves an explicit color-on/off override from CLI flags or the NO_COLOR
+* convention (https://no-color.org). Returns `undefined` when there's no
+* explicit signal, meaning chalk's own auto-detection should be left alone
+* (including its GitHub-Actions-aware detection of non-TTY streams).
 */
-function getJSXElementName(nameNode) {
-	if (!nameNode) return "";
-	switch (nameNode.type) {
-		case "Identifier": return nameNode.value;
-		case "JSXMemberExpression": return `${getJSXElementName(nameNode.object)}.${nameNode.property.value}`;
-		default: return "";
-	}
+function resolveColorLevel(opts) {
+	if (opts.colorFlag === false) return 0;
+	if (opts.colorFlag === true) return 1;
+	if (opts.noColorEnv !== void 0) return 0;
+}
+const ANSI_ESCAPE_PATTERN = /\x1b\[[0-9;]*m/g;
+function stripAnsiWrites(stream) {
+	const originalWrite = stream.write.bind(stream);
+	stream.write = ((chunk, ...rest) => {
+		return originalWrite(typeof chunk === "string" ? chunk.replace(ANSI_ESCAPE_PATTERN, "") : chunk, ...rest);
+	});
 }
 /**
-* Checks if a JSX member expression is a known component
+* Beyond setting chalk's own level, this strips ANSI codes at the stream
+* boundary when color is explicitly disabled. hermex also prints through
+* cli-table3 and ora (whose spinner symbols come from log-symbols/yoctocolors)
+* — neither shares hermex's chalk instance or honors chalk.level, so mutating
+* chalk alone can't make NO_COLOR/--no-color hold for their output too.
 */
-function isMemberExpressionComponent(nameNode, state) {
-	if (nameNode?.type === "JSXMemberExpression") {
-		const objectName = getJSXElementName(nameNode.object);
-		return state.allIdentifiers.has(objectName);
+function applyColorLevel(level) {
+	if (level === void 0) return;
+	chalk.level = level;
+	if (level === 0) {
+		stripAnsiWrites(process.stdout);
+		stripAnsiWrites(process.stderr);
 	}
-	return false;
 }
-/**
-* Extracts props from JSX attributes
-*/
-function extractJSXProps(attributes) {
-	if (!attributes) return [];
-	return attributes.map((attr) => {
-		if (attr.type === "JSXAttribute") return {
-			name: attr.name?.value || attr.name?.name?.value,
-			value: extractJSXAttributeValue(attr.value)
-		};
-		if (attr.type === "SpreadElement") return {
-			name: "...",
-			value: "[spread]",
-			isSpread: true
-		};
-		return null;
-	}).filter(Boolean);
+//#endregion
+//#region src/utils/print-packages.ts
+function printHeader() {
+	console.log(chalk.blueBright.bold("\n📦 Packages\n"));
 }
-/**
-* Extracts value from JSX attribute
-*/
-function extractJSXAttributeValue(value) {
-	if (!value) return true;
-	switch (value.type) {
-		case "StringLiteral": return value.value;
-		case "JSXExpressionContainer": return extractExpressionValue(value.expression);
-		default: return "[complex]";
-	}
+function formatPackageName(pkg, banned) {
+	let prefix = "";
+	if (pkg.releaseAge?.deprecated) prefix += severityColor("error")("[DEPRECATED] ");
+	if (banned) prefix += banned.severity === "error" ? severityColor("error")("[BANNED] ") : severityColor("warn")("[RESTRICTED] ");
+	else if (pkg.internal) prefix += severityColor("warn")("[int] ");
+	return prefix + pkg.packageName;
 }
-/**
-* Extracts a readable value from an expression
-*/
-function extractExpressionValue(expr) {
-	if (!expr) return "[unknown]";
-	switch (expr.type) {
-		case "StringLiteral":
-		case "NumericLiteral":
-		case "BooleanLiteral": return expr.value;
-		case "Identifier": return `{${expr.value}}`;
-		case "ArrowFunctionExpression":
-		case "FunctionExpression": return "[function]";
-		case "ObjectExpression": return "[object]";
-		case "ArrayExpression": return "[array]";
-		default: return "[expression]";
+function formatUpgradeCell(releaseAge) {
+	if (!releaseAge) return "";
+	const { worstLevel, upgrades, severity, pendingUpgrade } = releaseAge;
+	if (!worstLevel) {
+		if (pendingUpgrade) return `${severityIcon("info")} ${pendingUpgrade.semverBump} ${pendingUpgrade.version} (${formatDaysRemaining(pendingUpgrade.daysRemaining)})`;
+		return severityIcon("success");
 	}
+	const top = upgrades[0];
+	if (!top) return severityIcon("success");
+	const suffix = severity === "warn" ? chalk.gray(" [not enforced]") : "";
+	const overdue = formatDaysOverdue(top.releasedDaysAgo, top.thresholdDays);
+	if (worstLevel === "mandatory_upgrade") return `${severityIcon(severity === "warn" ? "warn" : "error")} ${top.semverBump} ${top.version} (${overdue})${suffix}`;
+	return `${severityIcon("warn")} ${top.semverBump} ${top.version} (${overdue})${suffix}`;
 }
-/**
-* Determines the context where a component is being used
-*/
-function getUsageContext(parent) {
-	if (!parent) return "direct";
-	switch (parent.type) {
-		case "ConditionalExpression": return "conditional";
-		case "ArrayExpression": return "array";
-		case "ObjectExpression": return "object";
-		case "CallExpression": return "hoc";
-		case "VariableDeclarator": return "variable";
-		default: return "jsx";
-	}
+function getBannedViolation(pkg, violations) {
+	return violations.find((v) => v.packageName === pkg.packageName);
 }
-//#endregion
-//#region src/swc-parser/patterns/props.ts
-/**
-* Analyzes props in detail for a component
-*/
-function analyzePropsInDetail(attributes, componentName, state) {
-	const analysis = {
-		namedProps: [],
-		hasSpread: false,
-		hasComplexProps: false,
-		hasEventHandlers: false,
-		propDetails: []
-	};
-	if (!attributes) return analysis;
-	for (const attr of attributes) if (attr.type === "JSXAttribute") {
-		const propName = attr.name?.value || attr.name?.name?.value;
-		if (propName) {
-			analysis.namedProps.push(propName);
-			const propDetail = {
-				name: propName,
-				type: getPropType(attr.value),
-				isEventHandler: propName.startsWith("on"),
-				isComplex: isComplexProp(attr.value)
-			};
-			if (propDetail.isEventHandler) analysis.hasEventHandlers = true;
-			if (propDetail.isComplex) analysis.hasComplexProps = true;
-			analysis.propDetails.push(propDetail);
-		}
-	} else if (attr.type === "SpreadElement") {
-		analysis.hasSpread = true;
-		analysis.propDetails.push({
-			name: "...",
-			type: "spread",
-			isSpread: true,
-			isComplex: true,
-			isEventHandler: false,
-			warning: "Spread props cannot be statically analyzed"
-		});
-		analysis.hasComplexProps = true;
-	}
-	state.usagePatterns.propsAnalysis.set(componentName, analysis);
-	return analysis;
+function printPackages(aggregated, mode) {
+	const packages = aggregated.packageDistribution;
+	const violations = aggregated.bannedPackageViolations;
+	if (mode === "table") printPackagesTable(packages, violations);
+	else if (mode === "chart") printPackagesChart(packages, violations);
 }
-/**
-* Determines the type of a prop value
-*/
-function getPropType(value) {
-	if (!value) return "boolean";
-	switch (value.type) {
-		case "StringLiteral": return "string";
-		case "JSXExpressionContainer": {
-			const expr = value.expression;
-			if (!expr) return "unknown";
-			switch (expr.type) {
-				case "NumericLiteral": return "number";
-				case "BooleanLiteral": return "boolean";
-				case "StringLiteral": return "string";
-				case "ArrowFunctionExpression":
-				case "FunctionExpression": return "function";
-				case "ObjectExpression": return "object";
-				case "ArrayExpression": return "array";
-				case "Identifier": return "variable";
-				default: return "expression";
-			}
-		}
-		default: return "unknown";
+function printPackagesTable(packages, violations) {
+	printHeader();
+	if (packages.length === 0) {
+		console.log(chalk.gray("  No packages found"));
+		return;
 	}
+	const hasReleaseAge = packages.some((p) => p.releaseAge !== void 0);
+	const head = [
+		"Package",
+		"Version",
+		"Components",
+		"Usage",
+		"Percentage"
+	];
+	if (hasReleaseAge) head.push("Upgrades");
+	const table = new Table({
+		head,
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
+	});
+	packages.forEach((pkg) => {
+		const versionCell = pkg.hasVersionConflict ? chalk.yellow(`⚠ ${pkg.allVersions.join(", ")} (${pkg.allVersions.length} versions — bundle impact)`) : pkg.version || "N/A";
+		const row = [
+			formatPackageName(pkg, getBannedViolation(pkg, violations)),
+			versionCell,
+			formatCount(pkg.componentCount),
+			formatCount(pkg.usageCount),
+			`${pkg.percentage.toFixed(1)}%`
+		];
+		if (hasReleaseAge) row.push(formatUpgradeCell(pkg.releaseAge));
+		table.push(row);
+	});
+	console.log(table.toString());
+	const totalComponents = packages.reduce((sum, p) => sum + p.componentCount, 0);
+	const totalExternalUsage = packages.reduce((sum, p) => sum + p.usageCount, 0);
+	console.log(chalk.gray(`\nTotal: ${formatCount(packages.length)} packages | ${formatCount(totalComponents)} unique components | ${formatCount(totalExternalUsage)} total usages`));
 }
-/**
-* Checks if a prop value is complex (object, array, call, conditional)
-*/
-function isComplexProp(value) {
-	if (!value) return false;
-	if (value.type === "JSXExpressionContainer") {
-		const expr = value.expression;
-		if (!expr) return false;
-		return expr.type === "ObjectExpression" || expr.type === "ArrayExpression" || expr.type === "CallExpression" || expr.type === "ConditionalExpression";
+function printPackagesChart(packages, violations) {
+	printHeader();
+	if (packages.length === 0) {
+		console.log(chalk.gray("  No packages found"));
+		return;
 	}
-	return false;
+	const maxBarWidth = 40;
+	const maxPercentage = Math.max(...packages.map((p) => p.percentage));
+	const maxLabelLength = Math.max(...packages.map((p) => p.packageName.length + (p.internal ? 6 : 0)));
+	packages.forEach((pkg) => {
+		const barLength = Math.round(pkg.percentage / maxPercentage * maxBarWidth);
+		const emptyLength = maxBarWidth - barLength;
+		const label = formatPackageName(pkg, getBannedViolation(pkg, violations)).padEnd(maxLabelLength, " ");
+		const bar = chalk.green("█".repeat(barLength)) + chalk.gray("░".repeat(emptyLength));
+		console.log(`${label} ${bar} ${chalk.bold(pkg.percentage.toFixed(1) + "%")} (${pkg.usageCount})`);
+	});
 }
 //#endregion
-//#region src/swc-parser/patterns/jsx.ts
-/**
-* Analyzes JSX element usage
-*/
-function analyzeJSXElement(node, state) {
-	if (node.opening) analyzeJSXOpeningElement(node.opening, state, node);
+//#region src/utils/print-versus.ts
+const BAR_WIDTH = 30;
+function renderBar(percentage) {
+	const filled = Math.round(percentage / 100 * BAR_WIDTH);
+	const empty = BAR_WIDTH - filled;
+	return chalk.cyan("█".repeat(filled)) + chalk.gray("░".repeat(empty));
 }
-/**
-* Analyzes JSX opening element and tracks component usage
-*/
-function analyzeJSXOpeningElement(node, state, parent) {
-	const elementName = getJSXElementName(node.name);
-	if (!state.componentNames.has(elementName) && !isMemberExpressionComponent(node.name, state)) return;
-	const propsAnalysis = analyzePropsInDetail(node.attributes, elementName, state);
-	const usage = {
-		component: elementName,
-		props: extractJSXProps(node.attributes).map((p) => p.name),
-		propsAnalysis,
-		line: node.span?.start || 0,
-		context: getUsageContext(parent)
-	};
-	if (!state.usagePatterns.jsxUsage.has(elementName)) state.usagePatterns.jsxUsage.set(elementName, usage);
+function printVersusResult(result) {
+	console.log(chalk.bold(`  ${result.name}`));
+	console.log(chalk.gray(`  ${"─".repeat(50)}`));
+	const maxNameLen = Math.max(...result.entries.map((e) => e.packageName.length));
+	for (const entry of result.entries) {
+		const name = entry.packageName.padEnd(maxNameLen);
+		const bar = renderBar(entry.percentage);
+		const pct = chalk.bold(`${entry.percentage.toFixed(1)}%`);
+		const usage = chalk.gray(`(${entry.count} usages)`);
+		const components = entry.components.length > 0 ? chalk.gray(`  ${formatTruncatedList(entry.components, "component")}`) : "";
+		console.log(`  ${name}  ${bar} ${pct} ${usage}${components}`);
+	}
+	if (result.totalCount === 0) console.log(chalk.gray("  No usage detected for any package in this group."));
+	console.log();
 }
-//#endregion
-//#region src/swc-parser/utils/matchers.ts
-/**
-* Checks if a name is a known component from imports
-*/
-function isKnownComponent(name, state) {
-	return state.componentNames.has(name) || state.allIdentifiers.has(name);
+function printVersus(aggregated) {
+	if (aggregated.versusResults.length === 0) return;
+	console.log(chalk.magentaBright.bold("\n⚖️  Versus\n"));
+	for (const result of aggregated.versusResults) printVersusResult(result);
 }
 //#endregion
-//#region src/swc-parser/patterns/variables.ts
-/**
-* Analyzes variable declarations for component assignments
-*/
-function analyzeVariableDeclaration(node, state) {
-	if (!node.declarations) return;
-	for (const decl of node.declarations) {
-		if (decl.id?.type === "Identifier") {
-			const varName = decl.id.value;
-			if (decl.init) {
-				const assignment = extractAssignmentInfo(decl.init);
-				if (assignment && isKnownComponent(assignment, state)) {
-					state.usagePatterns.variableAssignments.set(varName, {
-						assignment,
-						line: node.span?.start || 0
-					});
-					state.componentNames.add(varName);
-				}
-			}
-		}
-		if (decl.id?.type === "ObjectPattern") analyzeDestructuringPattern(decl.id, decl.init, state);
+//#region src/utils/print-rules.ts
+function formatRuleType(type) {
+	switch (type) {
+		case "detect_files": return "detect_files";
+		case "require_files": return "require_files";
+		case "require_packages": return "require_packages";
+		case "require_scripts": return "require_scripts";
+		case "require_package_fields": return "package_fields";
+		case "forbid_package_fields": return "package_fields";
+		case "engine_version": return "engine_version";
+		case "codeowners": return "codeowners";
 	}
 }
-/**
-* Analyzes destructuring patterns
-*/
-function analyzeDestructuringPattern(pattern, init, state) {
-	if (!pattern.properties) return;
-	for (const prop of pattern.properties) if (prop.type === "AssignmentPatternProperty" && prop.key?.type === "Identifier") {
-		const propName = prop.key.value;
-		if (init?.type === "Identifier" && state.allIdentifiers.has(init.value)) {
-			state.usagePatterns.destructuredUsage.add({
-				property: propName,
-				source: init.value,
-				line: pattern.span?.start || 0
-			});
-			state.componentNames.add(propName);
-		}
+function describeViolation(v) {
+	const patterns = v.patterns.join(", ");
+	const suffix = v.message ? chalk.gray(` — ${v.message}`) : "";
+	if (v.type === "detect_files") return `${patterns} detected (${formatTruncatedList(v.matchedFiles.map((f) => {
+		const parts = f.replace(/\\/g, "/").split("/");
+		return parts[parts.length - 1];
+	}), "file")})${suffix}`;
+	if (v.type === "require_files") return `${patterns} not found${suffix}`;
+	if (v.type === "require_packages") return `${patterns} not installed${suffix}`;
+	if (v.type === "require_scripts") return `script ${patterns} missing in package.json${suffix}`;
+	if (v.type === "require_package_fields") {
+		if (v.fieldPath && v.actualValue !== void 0) return `field ${v.fieldPath} is ${chalk.yellow(v.actualValue)}, does not match required value${suffix}`;
+		return `field ${patterns} missing in package.json${suffix}`;
 	}
-}
-/**
-* Extracts assignment information from various node types
-*/
-function extractAssignmentInfo(node) {
-	switch (node.type) {
-		case "Identifier": return node.value;
-		case "MemberExpression": return `${extractAssignmentInfo(node.object)}.${node.property.value}`;
-		case "ConditionalExpression": return `${extractAssignmentInfo(node.consequent)} | ${extractAssignmentInfo(node.alternate)}`;
-		default: return null;
+	if (v.type === "forbid_package_fields") return `field ${v.fieldPath ?? patterns} is forbidden in package.json${suffix}`;
+	if (v.type === "engine_version") {
+		if (!v.installedRange) return `engines.node not specified (required ${v.requiredRange})${suffix}`;
+		return `engines.node is ${chalk.yellow(v.installedRange)}, required ${chalk.cyan(v.requiredRange)}${suffix}`;
 	}
+	if (v.type === "codeowners") {
+		if (v.matchedFiles.length === 0) return `CODEOWNERS not found (looked in ${patterns})${suffix}`;
+		return `${v.matchedFiles.length} scanned file(s) have no owner: ${formatTruncatedList(v.matchedFiles, "file")}${suffix}`;
+	}
+	return `${patterns} not present${suffix}`;
 }
-//#endregion
-//#region src/swc-parser/patterns/conditionals.ts
-/**
-* Analyzes conditional expressions (ternary operators) with components
-*/
-function analyzeConditionalExpression(node, state) {
-	const consequent = node.consequent?.type === "Identifier" ? node.consequent.value : null;
-	const alternate = node.alternate?.type === "Identifier" ? node.alternate.value : null;
-	if (consequent && state.componentNames.has(consequent) || alternate && state.componentNames.has(alternate)) state.usagePatterns.conditionalUsage.add({
-		consequent: consequent || "",
-		alternate: alternate || "",
-		line: node.span?.start || 0
-	});
-}
-//#endregion
-//#region src/swc-parser/patterns/collections.ts
-/**
-* Analyzes array expressions containing components
-*/
-function analyzeArrayExpression(node, state) {
-	if (node.elements?.some((elem) => {
-		if (elem?.type === "Identifier") return state.componentNames.has(elem.value);
-		return false;
-	})) state.usagePatterns.arrayMappings.add({
-		components: node.elements?.map((elem) => elem?.value).filter(Boolean),
-		line: node.span?.start || 0
-	});
-}
-/**
-* Analyzes object expressions with component mappings
-*/
-function analyzeObjectExpression(node, state) {
-	const componentProps = node.properties?.filter((prop) => {
-		if (prop.type === "KeyValueProperty" && prop.value?.type === "Identifier") return state.componentNames.has(prop.value.value);
-		return false;
-	});
-	if (componentProps?.length > 0) state.usagePatterns.objectMappings.add({
-		mappings: componentProps.map((prop) => ({
-			key: prop.key?.value || "[computed]",
-			component: prop.value?.value
-		})),
-		line: node.span?.start || 0
-	});
+function printRules(aggregated) {
+	const { ruleViolations, bannedPackageViolations } = aggregated;
+	const hasRuleViolations = ruleViolations.length > 0;
+	const hasBannedViolations = bannedPackageViolations.length > 0;
+	if (!hasRuleViolations && !hasBannedViolations) {
+		console.log(chalk.greenBright.bold(`\n${severityIcon("success")} Compliance\n`));
+		console.log(chalk.gray("  All compliance checks passed"));
+		return;
+	}
+	console.log(chalk.blueBright.bold("\n🔍 Compliance\n"));
+	if (hasRuleViolations) for (const v of ruleViolations) console.log(formatViolationLine({
+		icon: severityIcon(v.severity),
+		label: formatRuleType(v.type),
+		description: describeViolation(v)
+	}));
+	if (hasBannedViolations) for (const v of bannedPackageViolations) {
+		const msg = v.message ? chalk.gray(` — ${v.message}`) : "";
+		console.log(formatViolationLine({
+			icon: severityIcon(v.severity),
+			label: "forbid_packages",
+			description: `${v.packageName} is forbidden${msg}`
+		}));
+	}
+	const errorCount = [...ruleViolations.filter((v) => v.severity === "error"), ...bannedPackageViolations.filter((v) => v.severity === "error")].length;
+	const warnCount = [...ruleViolations.filter((v) => v.severity === "warn"), ...bannedPackageViolations.filter((v) => v.severity === "warn")].length;
+	const parts = [];
+	if (errorCount > 0) parts.push(chalk.red(`${errorCount} error${errorCount > 1 ? "s" : ""}`));
+	if (warnCount > 0) parts.push(chalk.yellow(`${warnCount} warning${warnCount > 1 ? "s" : ""}`));
+	console.log(chalk.gray(`\n  ${parts.join(", ")}`));
 }
 //#endregion
-//#region src/swc-parser/patterns/lazy-dynamic.ts
+//#region src/utils/version.ts
+let cachedVersion;
 /**
-* Analyzes React.lazy() imports
+* Walks up from `dir` to find the nearest package.json.
+* Needed because this module's own path differs between the tsdown-bundled
+* single-file `dist/cli.mjs` and the unbundled source used by tests.
 */
-function analyzeLazyImport(node, state) {
-	const arg = node.arguments?.[0];
-	if (arg?.type === "ArrowFunctionExpression" && arg.body?.type === "CallExpression") {
-		const importCall = arg.body;
-		if (importCall.callee?.type === "Import") {
-			const source = importCall.arguments?.[0]?.value;
-			if (source) state.usagePatterns.lazyImports.add({
-				source,
-				line: node.span?.start || 0
-			});
-		}
+function findPackageJson(dir) {
+	let current = dir;
+	while (true) {
+		const candidate = path.join(current, "package.json");
+		if (existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) throw new Error(`Could not locate package.json above ${dir}`);
+		current = parent;
 	}
 }
-/**
-* Analyzes dynamic import() calls
-*/
-function analyzeDynamicImport(node, state) {
-	const source = node.arguments?.[0]?.value;
-	if (source) state.usagePatterns.dynamicImports.add({
-		source,
-		line: node.span?.start || 0
-	});
+function getVersion() {
+	if (cachedVersion) return cachedVersion;
+	const pkgPath = findPackageJson(path.dirname(fileURLToPath(import.meta.url)));
+	cachedVersion = JSON.parse(readFileSync(pkgPath, "utf8")).version;
+	return cachedVersion;
 }
 //#endregion
-//#region src/swc-parser/patterns/advanced.ts
-/**
-* Analyzes Higher-Order Component (HOC) usage
-*/
-function analyzeHOCUsage(node, state) {
-	state.usagePatterns.hocUsage.add({
-		function: node.callee?.value || "[unknown]",
-		component: node.arguments?.[0]?.value || "[unknown]",
-		line: node.span?.start || 0
-	});
-}
-/**
-* Analyzes React.memo() usage
-*/
-function analyzeMemoUsage(node, state) {
-	const component = node.arguments?.[0];
-	if (component?.type === "Identifier" && state.componentNames.has(component.value)) state.usagePatterns.memoizedComponents.add({
-		component: component.value,
-		line: node.span?.start || 0
-	});
-}
-/**
-* Analyzes React.forwardRef() usage
-*/
-function analyzeForwardRefUsage(node, state) {
-	state.usagePatterns.forwardedRefs.add({ line: node.span?.start || 0 });
-}
-/**
-* Analyzes ReactDOM.createPortal() usage
-*/
-function analyzePortalUsage(node, state) {
-	state.usagePatterns.portalUsage.add({ line: node.span?.start || 0 });
-}
-/**
-* Analyzes member expression access (e.g., Foundation.Button)
-*/
-function analyzeMemberExpression(node, state) {
-	if (node.object?.type === "Identifier" && state.allIdentifiers.has(node.object.value)) {
-		const propertyName = node.property?.value;
-		if (propertyName) state.componentNames.add(propertyName);
-	}
-}
-/**
-* Checks if a node represents HOC pattern
-*/
-function isHOCPattern(node, state) {
-	return node.callee?.type === "Identifier" && node.arguments?.some((arg) => arg.type === "Identifier" && state.componentNames.has(arg.value));
+//#region src/utils/print-json.ts
+function printJson(aggregated) {
+	const result = {
+		version: getVersion(),
+		summary: {
+			filesAnalyzed: aggregated.filesAnalyzed,
+			totalImports: aggregated.totalImports,
+			totalComponents: aggregated.totalComponents,
+			totalUsagePatterns: aggregated.totalUsagePatterns
+		},
+		packages: aggregated.packageDistribution,
+		components: aggregated.topComponents.map((c) => ({
+			...c,
+			files: [...c.files]
+		})),
+		patterns: aggregated.patternCounts,
+		versus: aggregated.versusResults,
+		ruleViolations: aggregated.ruleViolations,
+		bannedPackageViolations: aggregated.bannedPackageViolations
+	};
+	process.stdout.write(JSON.stringify(result, null, 2) + "\n");
 }
 //#endregion
-//#region src/swc-parser/core/visitor.ts
-/**
-* Main AST visitor that routes nodes to appropriate pattern analyzers
-*/
-function visitNode(node, state, context = {}) {
-	if (!node) return;
-	switch (node.type) {
-		case "Module":
-			if (node.body) {
-				for (const item of node.body) if (item.type === "ImportDeclaration") visitNode(item, state, context);
-				for (const item of node.body) if (item.type !== "ImportDeclaration") visitNode(item, state, {
-					...context,
-					parent: node
-				});
-			}
-			break;
-		case "ImportDeclaration":
-			analyzeImportDeclaration(node, state);
-			break;
-		case "CallExpression":
-			analyzeCallExpression(node, state, context);
-			break;
-		case "VariableDeclaration":
-			analyzeVariableDeclaration(node, state);
-			visitChildren(node, state, context);
-			break;
-		case "JSXElement":
-		case "JSXFragment":
-			analyzeJSXElement(node, state);
-			visitChildren(node, state, context);
-			break;
-		case "JSXOpeningElement":
-			analyzeJSXOpeningElement(node, state, context.parent);
-			break;
-		case "ArrayExpression":
-			analyzeArrayExpression(node, state);
-			visitChildren(node, state, context);
-			break;
-		case "ObjectExpression":
-			analyzeObjectExpression(node, state);
-			visitChildren(node, state, context);
-			break;
-		case "MemberExpression":
-			analyzeMemberExpression(node, state);
-			visitChildren(node, state, context);
-			break;
-		case "ConditionalExpression":
-			analyzeConditionalExpression(node, state);
-			visitChildren(node, state, context);
+//#region src/config/schema.ts
+const RuleSeveritySchema = z.enum([
+	"error",
+	"warn",
+	"info"
+]);
+const RuleConfigSchema = z.object({
+	severity: RuleSeveritySchema,
+	patterns: z.array(z.string()),
+	message: z.string().optional()
+});
+const RuleConfigOrArraySchema = z.union([RuleConfigSchema, z.array(RuleConfigSchema)]);
+const PackageFieldRuleSchema = RuleConfigSchema.extend({ 
+/** Optional micromatch patterns the field's stringified value must match */
+values: z.array(z.string()).optional() });
+const PackageFieldRuleOrArraySchema = z.union([PackageFieldRuleSchema, z.array(PackageFieldRuleSchema)]);
+const EngineVersionRuleSchema = z.object({
+	severity: RuleSeveritySchema,
+	range: z.string(),
+	message: z.string().optional()
+});
+const CodeownersRuleSchema = z.object({
+	severity: RuleSeveritySchema,
+	message: z.string().optional()
+});
+const ThresholdSchema = z.union([z.number(), z.literal(false)]);
+const HermexConfigSchema = z.object({
+	includes: z.array(z.string()).default(["**/*.{tsx,jsx,ts,js}"]),
+	excludes: z.array(z.string()).default([
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/build/**"
+	]),
+	packages: z.object({
+		internal: z.array(z.string()).default([]),
+		ignore: z.array(z.string()).default([])
+	}).default(() => ({
+		internal: [],
+		ignore: []
+	})),
+	versus: z.array(z.object({
+		name: z.string(),
+		packages: z.array(z.string()).min(2)
+	})).default([]),
+	rules: z.object({
+		detect_files: RuleConfigOrArraySchema.default([]),
+		require_files: RuleConfigOrArraySchema.default([]),
+		forbid_packages: RuleConfigOrArraySchema.default([]),
+		require_packages: RuleConfigOrArraySchema.default([]),
+		require_scripts: RuleConfigOrArraySchema.default([]),
+		require_package_fields: PackageFieldRuleOrArraySchema.default([]),
+		forbid_package_fields: PackageFieldRuleOrArraySchema.default([]),
+		engine_version: z.union([EngineVersionRuleSchema, z.array(EngineVersionRuleSchema)]).optional(),
+		codeowners: CodeownersRuleSchema.optional()
+	}).default(() => ({
+		detect_files: [],
+		require_files: [],
+		forbid_packages: [],
+		require_packages: [],
+		require_scripts: [],
+		require_package_fields: [],
+		forbid_package_fields: []
+	})),
+	output: z.object({
+		summary: z.union([z.literal("log"), z.literal(false)]).default("log"),
+		components: z.union([z.enum(["table", "chart"]), z.literal(false)]).default("table"),
+		packages: z.union([z.enum(["table", "chart"]), z.literal(false)]).default("table"),
+		patterns: z.union([z.enum(["table", "chart"]), z.literal(false)]).default("table"),
+		details: z.boolean().default(false),
+		versus: z.boolean().default(true),
+		rules: z.boolean().default(true),
+		format: z.enum(["human", "json"]).default("human")
+	}).default(() => ({
+		summary: "log",
+		components: "table",
+		packages: "table",
+		patterns: "table",
+		details: false,
+		versus: true,
+		rules: true,
+		format: "human"
+	})),
+	releaseAge: z.object({
+		enabled: z.boolean().default(false),
+		registry: z.string().default("https://registry.npmjs.org"),
+		authToken: z.string().optional(),
+		thresholds: z.object({
+			patch: ThresholdSchema.default(30),
+			minor: ThresholdSchema.default(45),
+			major: ThresholdSchema.default(60)
+		}).default(() => ({
+			patch: 30,
+			minor: 45,
+			major: 60
+		})),
+		enforceOn: z.array(z.string()).default([]),
+		cacheTtlMs: z.number().int().positive().optional(),
+		cacheDisabled: z.boolean().default(false)
+	}).default(() => ({
+		enabled: false,
+		registry: "https://registry.npmjs.org",
+		thresholds: {
+			patch: 30,
+			minor: 45,
+			major: 60
+		},
+		enforceOn: [],
+		cacheDisabled: false
+	}))
+});
+//#endregion
+//#region src/config/loader.ts
+async function loadConfig(cwd, explicitPath) {
+	const configPath = explicitPath ? resolve(explicitPath) : join(cwd, "hermex.config.ts");
+	if (explicitPath && !existsSync(configPath)) throw new Error(`Config file not found: ${configPath}`);
+	if (existsSync(configPath)) {
+		const mod = await import(pathToFileURL(configPath).href);
+		return HermexConfigSchema.parse(mod.default ?? mod);
+	}
+	return HermexConfigSchema.parse({});
+}
+//#endregion
+//#region src/swc-parser/core/state.ts
+function createState() {
+	return {
+		usagePatterns: {
+			namedImports: /* @__PURE__ */ new Set(),
+			namespaceImports: /* @__PURE__ */ new Set(),
+			defaultImports: /* @__PURE__ */ new Set(),
+			aliasedImports: /* @__PURE__ */ new Map(),
+			variableAssignments: /* @__PURE__ */ new Map(),
+			lazyImports: /* @__PURE__ */ new Set(),
+			dynamicImports: /* @__PURE__ */ new Set(),
+			conditionalUsage: /* @__PURE__ */ new Set(),
+			arrayMappings: /* @__PURE__ */ new Set(),
+			objectMappings: /* @__PURE__ */ new Set(),
+			hocUsage: /* @__PURE__ */ new Set(),
+			forwardedRefs: /* @__PURE__ */ new Set(),
+			memoizedComponents: /* @__PURE__ */ new Set(),
+			portalUsage: /* @__PURE__ */ new Set(),
+			jsxUsage: /* @__PURE__ */ new Map(),
+			destructuredUsage: /* @__PURE__ */ new Set(),
+			propsAnalysis: /* @__PURE__ */ new Map()
+		},
+		componentNames: /* @__PURE__ */ new Set(),
+		allIdentifiers: /* @__PURE__ */ new Set()
+	};
+}
+//#endregion
+//#region src/swc-parser/patterns/imports.ts
+/**
+* Analyzes import declarations and tracks all types:
+* - Default imports
+* - Named imports
+* - Namespace imports
+* - Aliased imports
+*/
+function analyzeImportDeclaration(node, state) {
+	const source = node.source.value;
+	for (const spec of node.specifiers) switch (spec.type) {
+		case "ImportDefaultSpecifier":
+			analyzeDefaultImport(spec, source, node, state);
 			break;
-		case "FunctionDeclaration":
-		case "ClassDeclaration":
-		case "ExpressionStatement":
-		case "ReturnStatement":
-		case "VariableDeclarator":
-		case "ArrowFunctionExpression":
-		case "FunctionExpression":
-			visitChildren(node, state, {
-				...context,
-				parent: node
-			});
+		case "ImportNamespaceSpecifier":
+			analyzeNamespaceImport(spec, source, node, state);
 			break;
-		default:
-			visitChildren(node, state, context);
+		case "ImportSpecifier":
+			analyzeNamedImport(spec, source, node, state);
 			break;
 	}
 }
+function analyzeDefaultImport(spec, source, node, state) {
+	const name = spec.local.value;
+	state.usagePatterns.defaultImports.add({
+		name,
+		source,
+		line: node.span?.start || 0
+	});
+	state.componentNames.add(name);
+}
+function analyzeNamespaceImport(spec, source, node, state) {
+	const name = spec.local.value;
+	state.usagePatterns.namespaceImports.add({
+		name,
+		source,
+		line: node.span?.start || 0
+	});
+	state.allIdentifiers.add(name);
+}
+function analyzeNamedImport(spec, source, node, state) {
+	const importedName = spec.imported ? spec.imported.value : spec.local.value;
+	const localName = spec.local.value;
+	state.usagePatterns.namedImports.add({
+		name: importedName,
+		source,
+		line: node.span?.start || 0
+	});
+	if (importedName !== localName) state.usagePatterns.aliasedImports.set(localName, {
+		imported: importedName,
+		local: localName,
+		source,
+		line: node.span?.start || 0
+	});
+	state.componentNames.add(localName);
+}
+//#endregion
+//#region src/swc-parser/utils/jsx-helpers.ts
 /**
-* Analyzes call expressions and routes to specific analyzers
+* Extracts the name from a JSX element (handles identifiers and member expressions)
 */
-function analyzeCallExpression(node, state, context) {
-	if (node.callee?.value === "lazy" || node.callee?.object?.value === "React" && node.callee?.property?.value === "lazy") analyzeLazyImport(node, state);
-	if (node.callee?.type === "Import") analyzeDynamicImport(node, state);
-	if (isHOCPattern(node, state)) analyzeHOCUsage(node, state);
-	if (node.callee?.object?.value === "React") {
-		if (node.callee?.property?.value === "memo") analyzeMemoUsage(node, state);
-		else if (node.callee?.property?.value === "forwardRef") analyzeForwardRefUsage(node, state);
+function getJSXElementName(nameNode) {
+	if (!nameNode) return "";
+	switch (nameNode.type) {
+		case "Identifier": return nameNode.value;
+		case "JSXMemberExpression": return `${getJSXElementName(nameNode.object)}.${nameNode.property.value}`;
+		default: return "";
 	}
-	if (node.callee?.property?.value === "createPortal" || node.callee?.value === "createPortal") analyzePortalUsage(node, state);
-	visitChildren(node, state, context);
 }
 /**
-* Visits all children of a node
+* Checks if a JSX member expression is a known component
 */
-function visitChildren(node, state, context) {
-	if (!node) return;
-	for (const key in node) {
-		const value = node[key];
-		if (Array.isArray(value)) {
-			for (const item of value) if (item && typeof item === "object") visitNode(item, state, {
-				...context,
-				parent: node
-			});
-		} else if (value && typeof value === "object" && value.type) visitNode(value, state, {
-			...context,
-			parent: node
-		});
+function isMemberExpressionComponent(nameNode, state) {
+	if (nameNode?.type === "JSXMemberExpression") {
+		const objectName = getJSXElementName(nameNode.object);
+		return state.allIdentifiers.has(objectName);
 	}
+	return false;
 }
-//#endregion
-//#region src/swc-parser/core/report.ts
 /**
-* Generates a comprehensive usage report from parser state
+* Extracts props from JSX attributes
 */
-function generateReport(state) {
-	return {
-		summary: {
-			totalImports: state.usagePatterns.defaultImports.size + state.usagePatterns.namedImports.size + state.usagePatterns.namespaceImports.size,
-			totalComponents: state.componentNames.size,
-			totalUsagePatterns: calculateTotalPatterns(state)
-		},
-		patterns: {
-			imports: {
-				default: Array.from(state.usagePatterns.defaultImports),
-				named: Array.from(state.usagePatterns.namedImports),
-				namespace: Array.from(state.usagePatterns.namespaceImports),
-				aliased: Array.from(state.usagePatterns.aliasedImports.values())
-			},
-			usage: {
-				jsx: Array.from(state.usagePatterns.jsxUsage.values()),
-				variables: Array.from(state.usagePatterns.variableAssignments.entries()).map(([key, value]) => ({
-					variable: key,
-					assignment: value.assignment
-				})),
-				destructuring: Array.from(state.usagePatterns.destructuredUsage),
-				conditional: Array.from(state.usagePatterns.conditionalUsage),
-				arrays: Array.from(state.usagePatterns.arrayMappings),
-				objects: Array.from(state.usagePatterns.objectMappings)
-			},
-			advanced: {
-				lazy: Array.from(state.usagePatterns.lazyImports),
-				dynamic: Array.from(state.usagePatterns.dynamicImports),
-				hoc: Array.from(state.usagePatterns.hocUsage),
-				memo: Array.from(state.usagePatterns.memoizedComponents),
-				forwardRef: Array.from(state.usagePatterns.forwardedRefs),
-				portal: Array.from(state.usagePatterns.portalUsage)
-			},
-			props: Array.from(state.usagePatterns.propsAnalysis.entries()).map(([component, analysis]) => ({
-				component,
-				analysis
-			}))
-		},
-		components: Array.from(state.componentNames).sort()
-	};
+function extractJSXProps(attributes) {
+	if (!attributes) return [];
+	return attributes.map((attr) => {
+		if (attr.type === "JSXAttribute") return {
+			name: attr.name?.value || attr.name?.name?.value,
+			value: extractJSXAttributeValue(attr.value)
+		};
+		if (attr.type === "SpreadElement") return {
+			name: "...",
+			value: "[spread]",
+			isSpread: true
+		};
+		return null;
+	}).filter(Boolean);
 }
 /**
-* Calculates total number of usage patterns found
+* Extracts value from JSX attribute
 */
-function calculateTotalPatterns(state) {
-	return Object.values(state.usagePatterns).reduce((sum, collection) => {
-		if (collection instanceof Set || collection instanceof Map) return sum + collection.size;
-		return sum;
-	}, 0);
-}
-//#endregion
-//#region src/swc-parser/index.ts
-function swcOptionsForFile(filePath) {
-	const ext = path.extname(filePath).toLowerCase();
-	if (ext === ".ts") return {
-		syntax: "typescript",
-		tsx: false,
-		decorators: true,
-		dynamicImport: true
-	};
-	if (ext === ".tsx") return {
-		syntax: "typescript",
-		tsx: true,
-		decorators: true,
-		dynamicImport: true
-	};
-	if (ext === ".jsx") return {
-		syntax: "ecmascript",
-		jsx: true,
-		decorators: true,
-		importAssertions: true
-	};
-	return {
-		syntax: "ecmascript",
-		jsx: true,
-		decorators: true,
-		importAssertions: true
-	};
+function extractJSXAttributeValue(value) {
+	if (!value) return true;
+	switch (value.type) {
+		case "StringLiteral": return value.value;
+		case "JSXExpressionContainer": return extractExpressionValue(value.expression);
+		default: return "[complex]";
+	}
 }
-function parseCode(code, filePath = "file.tsx") {
-	const state = createState();
-	visitNode(parseSync(code, swcOptionsForFile(filePath)), state);
-	return generateReport(state);
+/**
+* Extracts a readable value from an expression
+*/
+function extractExpressionValue(expr) {
+	if (!expr) return "[unknown]";
+	switch (expr.type) {
+		case "StringLiteral":
+		case "NumericLiteral":
+		case "BooleanLiteral": return expr.value;
+		case "Identifier": return `{${expr.value}}`;
+		case "ArrowFunctionExpression":
+		case "FunctionExpression": return "[function]";
+		case "ObjectExpression": return "[object]";
+		case "ArrayExpression": return "[array]";
+		default: return "[expression]";
+	}
 }
-function parseFile(filePath) {
-	return parseCode(fs.readFileSync(filePath, "utf8"), filePath);
+/**
+* Determines the context where a component is being used
+*/
+function getUsageContext(parent) {
+	if (!parent) return "direct";
+	switch (parent.type) {
+		case "ConditionalExpression": return "conditional";
+		case "ArrayExpression": return "array";
+		case "ObjectExpression": return "object";
+		case "CallExpression": return "hoc";
+		case "VariableDeclarator": return "variable";
+		default: return "jsx";
+	}
 }
 //#endregion
-//#region src/utils/package-distribution.ts
-function resolvePackageFromImportPath(importPath, availablePackages) {
-	if (importPath.startsWith(".") || importPath.startsWith("/")) return "local";
-	const sortedPackages = [...availablePackages].sort((a, b) => b.length - a.length);
-	for (const pkg of sortedPackages) {
-		if (importPath === pkg) return pkg;
-		if (importPath.startsWith(`${pkg}/`)) return pkg;
+//#region src/swc-parser/patterns/props.ts
+/**
+* Analyzes props in detail for a component
+*/
+function analyzePropsInDetail(attributes, componentName, state) {
+	const analysis = {
+		namedProps: [],
+		hasSpread: false,
+		hasComplexProps: false,
+		hasEventHandlers: false,
+		propDetails: []
+	};
+	if (!attributes) return analysis;
+	for (const attr of attributes) if (attr.type === "JSXAttribute") {
+		const propName = attr.name?.value || attr.name?.name?.value;
+		if (propName) {
+			analysis.namedProps.push(propName);
+			const propDetail = {
+				name: propName,
+				type: getPropType(attr.value),
+				isEventHandler: propName.startsWith("on"),
+				isComplex: isComplexProp(attr.value)
+			};
+			if (propDetail.isEventHandler) analysis.hasEventHandlers = true;
+			if (propDetail.isComplex) analysis.hasComplexProps = true;
+			analysis.propDetails.push(propDetail);
+		}
+	} else if (attr.type === "SpreadElement") {
+		analysis.hasSpread = true;
+		analysis.propDetails.push({
+			name: "...",
+			type: "spread",
+			isSpread: true,
+			isComplex: true,
+			isEventHandler: false,
+			warning: "Spread props cannot be statically analyzed"
+		});
+		analysis.hasComplexProps = true;
 	}
-	return "unknown";
-}
-function findComponentSource(componentName, report, availablePackages) {
-	const namedImport = report.patterns.imports.named.find((imp) => imp.name === componentName);
-	if (namedImport) return resolvePackageFromImportPath(namedImport.source, availablePackages);
-	const defaultImport = report.patterns.imports.default.find((imp) => imp.name === componentName);
-	if (defaultImport) return resolvePackageFromImportPath(defaultImport.source, availablePackages);
-	const aliasedImport = report.patterns.imports.aliased.find((imp) => imp.local === componentName);
-	if (aliasedImport) return resolvePackageFromImportPath(aliasedImport.source, availablePackages);
-	return "unknown";
+	state.usagePatterns.propsAnalysis.set(componentName, analysis);
+	return analysis;
 }
-function getPackageVersion(packageName, versions) {
-	if (versions[packageName]) return versions[packageName];
-	if (packageName.includes("/")) {
-		const parts = packageName.split("/");
-		if (packageName.startsWith("@") && parts.length > 2) {
-			const basePackage = `${parts[0]}/${parts[1]}`;
-			if (versions[basePackage]) return versions[basePackage];
-		}
-		if (!packageName.startsWith("@") && parts.length > 1) {
-			if (versions[parts[0]]) return versions[parts[0]];
+/**
+* Determines the type of a prop value
+*/
+function getPropType(value) {
+	if (!value) return "boolean";
+	switch (value.type) {
+		case "StringLiteral": return "string";
+		case "JSXExpressionContainer": {
+			const expr = value.expression;
+			if (!expr) return "unknown";
+			switch (expr.type) {
+				case "NumericLiteral": return "number";
+				case "BooleanLiteral": return "boolean";
+				case "StringLiteral": return "string";
+				case "ArrowFunctionExpression":
+				case "FunctionExpression": return "function";
+				case "ObjectExpression": return "object";
+				case "ArrayExpression": return "array";
+				case "Identifier": return "variable";
+				default: return "expression";
+			}
 		}
+		default: return "unknown";
 	}
-	return null;
 }
-function calculatePackageDistribution(componentUsageMap, versions, config, multiVersions = {}) {
-	const ignorePatterns = config?.packages.ignore ?? [];
-	const internalPatterns = config?.packages.internal ?? [];
-	const packageMap = /* @__PURE__ */ new Map();
-	for (const component of componentUsageMap.values()) {
-		if (component.source === "unknown" || component.source === "local") continue;
-		if (ignorePatterns.length > 0 && micromatch.isMatch(component.source, ignorePatterns)) continue;
-		const existing = packageMap.get(component.source);
-		if (existing) {
-			existing.componentCount++;
-			existing.usageCount += component.count;
-			existing.components.push(component.name);
-		} else {
-			const isInternal = internalPatterns.length > 0 ? micromatch.isMatch(component.source, internalPatterns) : false;
-			const allVersions = multiVersions[component.source] ?? [];
-			const hasVersionConflict = allVersions.length > 1;
-			packageMap.set(component.source, {
-				packageName: component.source,
-				version: getPackageVersion(component.source, versions),
-				componentCount: 1,
-				usageCount: component.count,
-				percentage: 0,
-				components: [component.name],
-				internal: isInternal,
-				hasVersionConflict,
-				allVersions
-			});
-		}
+/**
+* Checks if a prop value is complex (object, array, call, conditional)
+*/
+function isComplexProp(value) {
+	if (!value) return false;
+	if (value.type === "JSXExpressionContainer") {
+		const expr = value.expression;
+		if (!expr) return false;
+		return expr.type === "ObjectExpression" || expr.type === "ArrayExpression" || expr.type === "CallExpression" || expr.type === "ConditionalExpression";
 	}
-	const distribution = Array.from(packageMap.values());
-	const totalExternalUsage = distribution.reduce((sum, pkg) => sum + pkg.usageCount, 0);
-	for (const pkg of distribution) pkg.percentage = totalExternalUsage > 0 ? pkg.usageCount / totalExternalUsage * 100 : 0;
-	return distribution.sort((a, b) => b.usageCount - a.usageCount);
+	return false;
 }
 //#endregion
-//#region src/rules/shared.ts
-function toArray(val) {
-	if (!val) return [];
-	return Array.isArray(val) ? val : [val];
-}
-function findMatches(patterns, repoPath, ignore) {
-	const matches = [];
-	for (const pattern of patterns) {
-		const found = globSync(pattern, {
-			cwd: repoPath,
-			nodir: true,
-			ignore
-		});
-		matches.push(...found.map((f) => f.replace(/\\/g, "/")));
-	}
-	return [...new Set(matches)];
+//#region src/swc-parser/patterns/jsx.ts
+/**
+* Analyzes JSX element usage
+*/
+function analyzeJSXElement(node, state) {
+	if (node.opening) analyzeJSXOpeningElement(node.opening, state, node);
 }
-function readPackageJson(repoPath) {
-	try {
-		const content = fs$1.readFileSync(path$1.join(repoPath, "package.json"), "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return null;
-	}
+/**
+* Analyzes JSX opening element and tracks component usage
+*/
+function analyzeJSXOpeningElement(node, state, parent) {
+	const elementName = getJSXElementName(node.name);
+	if (!state.componentNames.has(elementName) && !isMemberExpressionComponent(node.name, state)) return;
+	const propsAnalysis = analyzePropsInDetail(node.attributes, elementName, state);
+	const usage = {
+		component: elementName,
+		props: extractJSXProps(node.attributes).map((p) => p.name),
+		propsAnalysis,
+		line: node.span?.start || 0,
+		context: getUsageContext(parent)
+	};
+	if (!state.usagePatterns.jsxUsage.has(elementName)) state.usagePatterns.jsxUsage.set(elementName, usage);
 }
 //#endregion
-//#region src/rules/file-rules.ts
-function evaluateFileRules(repoPath, rulesConfig, excludes) {
-	const violations = [];
-	for (const rule of toArray(rulesConfig.forbid_files)) {
-		const matches = findMatches(rule.patterns, repoPath, excludes);
-		if (matches.length > 0) violations.push({
-			type: "forbid_files",
-			severity: rule.severity,
-			patterns: rule.patterns,
-			message: rule.message,
-			matchedFiles: matches
-		});
-	}
-	for (const rule of toArray(rulesConfig.require_files)) if (findMatches(rule.patterns, repoPath, excludes).length === 0) violations.push({
-		type: "require_files",
-		severity: rule.severity,
-		patterns: rule.patterns,
-		message: rule.message,
-		matchedFiles: []
-	});
-	for (const rule of toArray(rulesConfig.allow_files)) if (findMatches(rule.patterns, repoPath, excludes).length === 0) violations.push({
-		type: "allow_files",
-		severity: rule.severity,
-		patterns: rule.patterns,
-		message: rule.message,
-		matchedFiles: []
-	});
-	return violations;
+//#region src/swc-parser/utils/matchers.ts
+/**
+* Checks if a name is a known component from imports
+*/
+function isKnownComponent(name, state) {
+	return state.componentNames.has(name) || state.allIdentifiers.has(name);
 }
 //#endregion
-//#region src/rules/script-rules.ts
-function evaluateScriptRules(repoPath, rulesConfig) {
-	const rules = toArray(rulesConfig.require_scripts);
-	if (rules.length === 0) return [];
-	const pkg = readPackageJson(repoPath);
-	const scriptKeys = Object.keys(pkg?.scripts ?? {});
-	return rules.filter((rule) => !rule.patterns.some((p) => scriptKeys.some((k) => micromatch.isMatch(k, p)))).map((rule) => ({
-		type: "require_scripts",
-		severity: rule.severity,
-		patterns: rule.patterns,
-		message: rule.message,
-		matchedFiles: []
-	}));
+//#region src/swc-parser/patterns/variables.ts
+/**
+* Analyzes variable declarations for component assignments
+*/
+function analyzeVariableDeclaration(node, state) {
+	if (!node.declarations) return;
+	for (const decl of node.declarations) {
+		if (decl.id?.type === "Identifier") {
+			const varName = decl.id.value;
+			if (decl.init) {
+				const assignment = extractAssignmentInfo(decl.init);
+				if (assignment && isKnownComponent(assignment, state)) {
+					state.usagePatterns.variableAssignments.set(varName, {
+						assignment,
+						line: node.span?.start || 0
+					});
+					state.componentNames.add(varName);
+				}
+			}
+		}
+		if (decl.id?.type === "ObjectPattern") analyzeDestructuringPattern(decl.id, decl.init, state);
+	}
 }
-//#endregion
-//#region src/rules/package-field-rules.ts
-function evaluatePackageFieldRules(repoPath, rulesConfig) {
-	const rules = toArray(rulesConfig.require_package_fields);
-	if (rules.length === 0) return [];
-	const pkg = readPackageJson(repoPath);
-	const fieldKeys = pkg ? Object.keys(pkg) : [];
-	return rules.filter((rule) => !rule.patterns.some((p) => fieldKeys.includes(p))).map((rule) => ({
-		type: "require_package_fields",
-		severity: rule.severity,
-		patterns: rule.patterns,
-		message: rule.message,
-		matchedFiles: []
-	}));
+/**
+* Analyzes destructuring patterns
+*/
+function analyzeDestructuringPattern(pattern, init, state) {
+	if (!pattern.properties) return;
+	for (const prop of pattern.properties) if (prop.type === "AssignmentPatternProperty" && prop.key?.type === "Identifier") {
+		const propName = prop.key.value;
+		if (init?.type === "Identifier" && state.allIdentifiers.has(init.value)) {
+			state.usagePatterns.destructuredUsage.add({
+				property: propName,
+				source: init.value,
+				line: pattern.span?.start || 0
+			});
+			state.componentNames.add(propName);
+		}
+	}
+}
+/**
+* Extracts assignment information from various node types
+*/
+function extractAssignmentInfo(node) {
+	switch (node.type) {
+		case "Identifier": return node.value;
+		case "MemberExpression": return `${extractAssignmentInfo(node.object)}.${node.property.value}`;
+		case "ConditionalExpression": return `${extractAssignmentInfo(node.consequent)} | ${extractAssignmentInfo(node.alternate)}`;
+		default: return null;
+	}
 }
 //#endregion
-//#region src/rules/engine-version.ts
-function evaluateEngineVersion(repoPath, rulesConfig) {
-	const rules = toArray(rulesConfig.engine_version);
-	if (rules.length === 0) return [];
-	const nodeRange = (readPackageJson(repoPath)?.engines)?.node;
-	return rules.flatMap((rule) => {
-		if (!nodeRange) return [{
-			type: "engine_version",
-			severity: rule.severity,
-			patterns: [],
-			message: rule.message ?? "engines.node not specified in package.json",
-			matchedFiles: [],
-			requiredRange: rule.range
-		}];
-		const minVer = semver.minVersion(nodeRange);
-		if (!minVer || !semver.satisfies(minVer, rule.range)) return [{
-			type: "engine_version",
-			severity: rule.severity,
-			patterns: [],
-			message: rule.message,
-			matchedFiles: [],
-			installedRange: nodeRange,
-			requiredRange: rule.range
-		}];
-		return [];
+//#region src/swc-parser/patterns/conditionals.ts
+/**
+* Analyzes conditional expressions (ternary operators) with components
+*/
+function analyzeConditionalExpression(node, state) {
+	const consequent = node.consequent?.type === "Identifier" ? node.consequent.value : null;
+	const alternate = node.alternate?.type === "Identifier" ? node.alternate.value : null;
+	if (consequent && state.componentNames.has(consequent) || alternate && state.componentNames.has(alternate)) state.usagePatterns.conditionalUsage.add({
+		consequent: consequent || "",
+		alternate: alternate || "",
+		line: node.span?.start || 0
 	});
 }
 //#endregion
-//#region src/rules/evaluator.ts
-function evaluateRules(repoPath, rulesConfig, excludes) {
-	return [
-		...evaluateFileRules(repoPath, rulesConfig, excludes),
-		...evaluateScriptRules(repoPath, rulesConfig),
-		...evaluatePackageFieldRules(repoPath, rulesConfig),
-		...evaluateEngineVersion(repoPath, rulesConfig)
-	];
+//#region src/swc-parser/patterns/collections.ts
+/**
+* Analyzes array expressions containing components
+*/
+function analyzeArrayExpression(node, state) {
+	if (node.elements?.some((elem) => {
+		if (elem?.expression?.type === "Identifier") return state.componentNames.has(elem.expression.value);
+		return false;
+	})) state.usagePatterns.arrayMappings.add({
+		components: node.elements?.map((elem) => elem?.expression?.value).filter(Boolean),
+		line: node.span?.start || 0
+	});
+}
+/**
+* Analyzes object expressions with component mappings
+*/
+function analyzeObjectExpression(node, state) {
+	const componentProps = node.properties?.filter((prop) => {
+		if (prop.type === "KeyValueProperty" && prop.value?.type === "Identifier") return state.componentNames.has(prop.value.value);
+		return false;
+	});
+	if (componentProps?.length > 0) state.usagePatterns.objectMappings.add({
+		mappings: componentProps.map((prop) => ({
+			key: prop.key?.value || "[computed]",
+			component: prop.value?.value
+		})),
+		line: node.span?.start || 0
+	});
 }
 //#endregion
-//#region src/utils/package-rules.ts
-function detectBannedPackages(distribution, config) {
-	const forbidRules = toArray(config?.rules.forbid_packages);
-	if (forbidRules.length === 0) return [];
-	const violations = [];
-	for (const pkg of distribution) for (const rule of forbidRules) if (micromatch.isMatch(pkg.packageName, rule.patterns)) {
-		violations.push({
-			packageName: pkg.packageName,
-			severity: rule.severity,
-			message: rule.message
-		});
-		break;
+//#region src/swc-parser/patterns/lazy-dynamic.ts
+/**
+* Analyzes React.lazy() imports
+*/
+function analyzeLazyImport(node, state) {
+	const arg = node.arguments?.[0]?.expression;
+	if (arg?.type === "ArrowFunctionExpression" && arg.body?.type === "CallExpression") {
+		const importCall = arg.body;
+		if (importCall.callee?.type === "Import") {
+			const source = importCall.arguments?.[0]?.expression?.value;
+			if (source) state.usagePatterns.lazyImports.add({
+				source,
+				line: node.span?.start || 0
+			});
+		}
 	}
-	return violations;
 }
-function detectRequiredPackages(distribution, versions, config) {
-	const requireRules = toArray(config?.rules.require_packages);
-	if (requireRules.length === 0) return [];
-	const installedNames = /* @__PURE__ */ new Set([...Object.keys(versions), ...distribution.map((p) => p.packageName)]);
-	const violations = [];
-	for (const rule of requireRules) if (!rule.patterns.some((p) => [...installedNames].some((name) => micromatch.isMatch(name, p)))) violations.push({
-		type: "require_packages",
-		severity: rule.severity,
-		patterns: rule.patterns,
-		message: rule.message,
-		matchedFiles: []
+/**
+* Analyzes dynamic import() calls
+*/
+function analyzeDynamicImport(node, state) {
+	const source = node.arguments?.[0]?.expression?.value;
+	if (source) state.usagePatterns.dynamicImports.add({
+		source,
+		line: node.span?.start || 0
 	});
-	return violations;
 }
 //#endregion
-//#region src/utils/pattern-counter.ts
-function countPatterns(report, patternMap) {
-	increment(patternMap, "imports.default", report.patterns.imports.default.length);
-	increment(patternMap, "imports.named", report.patterns.imports.named.length);
-	increment(patternMap, "imports.namespace", report.patterns.imports.namespace.length);
-	increment(patternMap, "imports.aliased", report.patterns.imports.aliased.length);
-	increment(patternMap, "usage.jsx", report.patterns.usage.jsx.length);
-	increment(patternMap, "usage.variables", report.patterns.usage.variables.length);
-	increment(patternMap, "usage.destructuring", report.patterns.usage.destructuring.length);
-	increment(patternMap, "usage.conditional", report.patterns.usage.conditional.length);
-	increment(patternMap, "usage.arrays", report.patterns.usage.arrays.length);
-	increment(patternMap, "usage.objects", report.patterns.usage.objects.length);
-	increment(patternMap, "advanced.lazy", report.patterns.advanced.lazy.length);
-	increment(patternMap, "advanced.dynamic", report.patterns.advanced.dynamic.length);
-	increment(patternMap, "advanced.hoc", report.patterns.advanced.hoc.length);
-	increment(patternMap, "advanced.memo", report.patterns.advanced.memo.length);
-	increment(patternMap, "advanced.forwardRef", report.patterns.advanced.forwardRef.length);
-	increment(patternMap, "advanced.portal", report.patterns.advanced.portal.length);
+//#region src/swc-parser/patterns/advanced.ts
+/**
+* Analyzes Higher-Order Component (HOC) usage
+*/
+function analyzeHOCUsage(node, state) {
+	state.usagePatterns.hocUsage.add({
+		function: node.callee?.value || "[unknown]",
+		component: node.arguments?.[0]?.expression?.value || "[unknown]",
+		line: node.span?.start || 0
+	});
 }
-function increment(map, key, value) {
-	map.set(key, (map.get(key) || 0) + value);
+/**
+* Analyzes React.memo() usage
+*/
+function analyzeMemoUsage(node, state) {
+	const component = node.arguments?.[0]?.expression;
+	if (component?.type === "Identifier" && state.componentNames.has(component.value)) state.usagePatterns.memoizedComponents.add({
+		component: component.value,
+		line: node.span?.start || 0
+	});
 }
-function getPatternDisplayName(patternType) {
-	return {
-		"imports.default": "Default Imports",
-		"imports.named": "Named Imports",
-		"imports.namespace": "Namespace Imports",
-		"imports.aliased": "Aliased Imports",
-		"usage.jsx": "JSX Usage",
-		"usage.variables": "Variable Assignments",
-		"usage.destructuring": "Destructuring",
-		"usage.conditional": "Conditional Usage",
-		"usage.arrays": "Array Mappings",
-		"usage.objects": "Object Mappings",
-		"advanced.lazy": "Lazy Loading",
-		"advanced.dynamic": "Dynamic Imports",
-		"advanced.hoc": "Higher-Order Components",
-		"advanced.memo": "Memoized Components",
-		"advanced.forwardRef": "Forward Refs",
-		"advanced.portal": "Portal Usage"
-	}[patternType] || patternType;
+/**
+* Analyzes React.forwardRef() usage
+*/
+function analyzeForwardRefUsage(node, state) {
+	state.usagePatterns.forwardedRefs.add({ line: node.span?.start || 0 });
 }
-//#endregion
-//#region src/utils/versus.ts
-function toPercentage(count, total) {
-	return total > 0 ? count / total * 100 : 0;
+/**
+* Analyzes ReactDOM.createPortal() usage
+*/
+function analyzePortalUsage(node, state) {
+	state.usagePatterns.portalUsage.add({ line: node.span?.start || 0 });
 }
-function calculateVersusResults(distribution, versusConfigs) {
-	const distMap = new Map(distribution.map((p) => [p.packageName, p]));
-	return versusConfigs.map((vc) => {
-		const entries = vc.packages.map((pkgName) => {
-			const pkg = distMap.get(pkgName);
-			return {
-				packageName: pkgName,
-				count: pkg?.usageCount ?? 0,
-				percentage: 0,
-				components: pkg?.components ?? []
-			};
-		});
-		const totalCount = entries.reduce((sum, e) => sum + e.count, 0);
-		for (const entry of entries) entry.percentage = toPercentage(entry.count, totalCount);
-		entries.sort((a, b) => b.count - a.count);
-		return {
-			name: vc.name,
-			packages: vc.packages,
-			entries,
-			totalCount
-		};
-	});
+/**
+* Analyzes member expression access (e.g., Foundation.Button)
+*/
+function analyzeMemberExpression(node, state) {
+	if (node.object?.type === "Identifier" && state.allIdentifiers.has(node.object.value)) {
+		const propertyName = node.property?.value;
+		if (propertyName) state.componentNames.add(propertyName);
+	}
+}
+/**
+* Checks if a node represents HOC pattern
+*/
+function isHOCPattern(node, state) {
+	return node.callee?.type === "Identifier" && node.arguments?.some((arg) => arg.expression?.type === "Identifier" && state.componentNames.has(arg.expression.value));
 }
 //#endregion
-//#region src/utils/aggregator-core.ts
-function aggregateReports(reports, versions = {}, config, multiVersions = {}) {
-	const componentUsageMap = /* @__PURE__ */ new Map();
-	let totalImports = 0;
-	let totalUsagePatterns = 0;
-	const patternCountMap = /* @__PURE__ */ new Map();
-	const availablePackages = Object.keys(versions);
-	for (const report of reports) {
-		totalImports += report.summary.totalImports;
-		totalUsagePatterns += report.summary.totalUsagePatterns;
-		for (const jsx of report.patterns.usage.jsx) {
-			const key = jsx.component;
-			const existing = componentUsageMap.get(key);
-			if (existing) existing.count++;
-			else {
-				const source = findComponentSource(jsx.component, report, availablePackages);
-				componentUsageMap.set(key, {
-					name: jsx.component,
-					source,
-					count: 1,
-					files: /* @__PURE__ */ new Set()
+//#region src/swc-parser/core/visitor.ts
+/**
+* Main AST visitor that routes nodes to appropriate pattern analyzers
+*/
+function visitNode(node, state, context = {}) {
+	if (!node) return;
+	switch (node.type) {
+		case "Module":
+			if (node.body) {
+				for (const item of node.body) if (item.type === "ImportDeclaration") visitNode(item, state, context);
+				for (const item of node.body) if (item.type !== "ImportDeclaration") visitNode(item, state, {
+					...context,
+					parent: node
 				});
 			}
-		}
-		countPatterns(report, patternCountMap);
+			break;
+		case "ImportDeclaration":
+			analyzeImportDeclaration(node, state);
+			break;
+		case "CallExpression":
+			analyzeCallExpression(node, state, context);
+			break;
+		case "VariableDeclaration":
+			analyzeVariableDeclaration(node, state);
+			visitChildren(node, state, context);
+			break;
+		case "JSXElement":
+		case "JSXFragment":
+			analyzeJSXElement(node, state);
+			visitChildren(node, state, context);
+			break;
+		case "JSXOpeningElement":
+			analyzeJSXOpeningElement(node, state, context.parent);
+			break;
+		case "ArrayExpression":
+			analyzeArrayExpression(node, state);
+			visitChildren(node, state, context);
+			break;
+		case "ObjectExpression":
+			analyzeObjectExpression(node, state);
+			visitChildren(node, state, context);
+			break;
+		case "MemberExpression":
+			analyzeMemberExpression(node, state);
+			visitChildren(node, state, context);
+			break;
+		case "ConditionalExpression":
+			analyzeConditionalExpression(node, state);
+			visitChildren(node, state, context);
+			break;
+		case "FunctionDeclaration":
+		case "ClassDeclaration":
+		case "ExpressionStatement":
+		case "ReturnStatement":
+		case "VariableDeclarator":
+		case "ArrowFunctionExpression":
+		case "FunctionExpression":
+			visitChildren(node, state, {
+				...context,
+				parent: node
+			});
+			break;
+		default:
+			visitChildren(node, state, context);
+			break;
 	}
-	const topComponents = Array.from(componentUsageMap.values()).sort((a, b) => b.count - a.count);
-	const allComponents = Array.from(componentUsageMap.keys()).sort();
-	const patternCounts = Array.from(patternCountMap.entries()).map(([type, count]) => ({
-		patternType: type,
-		displayName: getPatternDisplayName(type),
-		count
-	})).sort((a, b) => b.count - a.count);
-	const packageDistribution = calculatePackageDistribution(componentUsageMap, versions, config, multiVersions);
-	const versusResults = calculateVersusResults(packageDistribution, config?.versus ?? []);
-	const bannedPackageViolations = detectBannedPackages(packageDistribution, config);
-	const requiredPackageViolations = detectRequiredPackages(packageDistribution, versions, config);
+}
+/**
+* Analyzes call expressions and routes to specific analyzers
+*/
+function analyzeCallExpression(node, state, context) {
+	if (node.callee?.value === "lazy" || node.callee?.object?.value === "React" && node.callee?.property?.value === "lazy") analyzeLazyImport(node, state);
+	if (node.callee?.type === "Import") analyzeDynamicImport(node, state);
+	if (isHOCPattern(node, state)) analyzeHOCUsage(node, state);
+	if (node.callee?.object?.value === "React") {
+		if (node.callee?.property?.value === "memo") analyzeMemoUsage(node, state);
+		else if (node.callee?.property?.value === "forwardRef") analyzeForwardRefUsage(node, state);
+	}
+	if (node.callee?.property?.value === "createPortal" || node.callee?.value === "createPortal") analyzePortalUsage(node, state);
+	visitChildren(node, state, context);
+}
+/**
+* Visits all children of a node
+*/
+function visitChildren(node, state, context) {
+	if (!node) return;
+	for (const key in node) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item === "object") visitNode(item, state, {
+				...context,
+				parent: node
+			});
+		} else if (value && typeof value === "object" && value.type) visitNode(value, state, {
+			...context,
+			parent: node
+		});
+	}
+}
+//#endregion
+//#region src/swc-parser/core/report.ts
+/**
+* Generates a comprehensive usage report from parser state
+*/
+function generateReport(state, filePath) {
 	return {
-		filesAnalyzed: reports.length,
-		totalImports,
-		totalComponents: componentUsageMap.size,
-		totalUsagePatterns,
-		patternCounts,
-		componentUsage: componentUsageMap,
-		topComponents,
-		allComponents,
-		packageDistribution,
-		versusResults,
-		ruleViolations: requiredPackageViolations,
-		bannedPackageViolations,
-		reports
+		filePath,
+		summary: {
+			totalImports: state.usagePatterns.defaultImports.size + state.usagePatterns.namedImports.size + state.usagePatterns.namespaceImports.size,
+			totalComponents: state.componentNames.size,
+			totalUsagePatterns: calculateTotalPatterns(state)
+		},
+		patterns: {
+			imports: {
+				default: Array.from(state.usagePatterns.defaultImports),
+				named: Array.from(state.usagePatterns.namedImports),
+				namespace: Array.from(state.usagePatterns.namespaceImports),
+				aliased: Array.from(state.usagePatterns.aliasedImports.values())
+			},
+			usage: {
+				jsx: Array.from(state.usagePatterns.jsxUsage.values()),
+				variables: Array.from(state.usagePatterns.variableAssignments.entries()).map(([key, value]) => ({
+					variable: key,
+					assignment: value.assignment
+				})),
+				destructuring: Array.from(state.usagePatterns.destructuredUsage),
+				conditional: Array.from(state.usagePatterns.conditionalUsage),
+				arrays: Array.from(state.usagePatterns.arrayMappings),
+				objects: Array.from(state.usagePatterns.objectMappings)
+			},
+			advanced: {
+				lazy: Array.from(state.usagePatterns.lazyImports),
+				dynamic: Array.from(state.usagePatterns.dynamicImports),
+				hoc: Array.from(state.usagePatterns.hocUsage),
+				memo: Array.from(state.usagePatterns.memoizedComponents),
+				forwardRef: Array.from(state.usagePatterns.forwardedRefs),
+				portal: Array.from(state.usagePatterns.portalUsage)
+			},
+			props: Array.from(state.usagePatterns.propsAnalysis.entries()).map(([component, analysis]) => ({
+				component,
+				analysis
+			}))
+		},
+		components: Array.from(state.componentNames).sort()
 	};
 }
-//#endregion
-//#region src/utils/format-utils.ts
 /**
-* Format a number with thousand separators
-* @param num - Number to format
-* @returns Formatted string (e.g., 1,234,567)
+* Calculates total number of usage patterns found
 */
-function formatCount(num) {
-	return num.toLocaleString();
+function calculateTotalPatterns(state) {
+	return Object.values(state.usagePatterns).reduce((sum, collection) => {
+		if (collection instanceof Set || collection instanceof Map) return sum + collection.size;
+		return sum;
+	}, 0);
 }
 //#endregion
-//#region src/utils/print-summary.ts
-function printHeader$4() {
-	console.log(chalk.green.bold("\n📊 Summary\n"));
+//#region src/swc-parser/index.ts
+function swcOptionsForFile(filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	if (ext === ".ts") return {
+		syntax: "typescript",
+		tsx: false,
+		decorators: true,
+		dynamicImport: true
+	};
+	if (ext === ".tsx") return {
+		syntax: "typescript",
+		tsx: true,
+		decorators: true,
+		dynamicImport: true
+	};
+	if (ext === ".jsx") return {
+		syntax: "ecmascript",
+		jsx: true,
+		decorators: true,
+		importAssertions: true
+	};
+	return {
+		syntax: "ecmascript",
+		jsx: true,
+		decorators: true,
+		importAssertions: true
+	};
 }
-function printSummary(aggregated) {
-	printHeader$4();
-	const table = new Table({
-		head: ["Metric", "Count"],
-		style: {
-			head: ["cyan"],
-			border: ["gray"]
+function parseCode(code, filePath = "file.tsx") {
+	const state = createState();
+	visitNode(parseSync(code, swcOptionsForFile(filePath)), state);
+	return generateReport(state, filePath);
+}
+function parseFile(filePath) {
+	return parseCode(fs.readFileSync(filePath, "utf8"), filePath);
+}
+//#endregion
+//#region src/utils/package-distribution.ts
+function resolvePackageFromImportPath(importPath, availablePackages) {
+	if (importPath.startsWith(".") || importPath.startsWith("/")) return "local";
+	const sortedPackages = [...availablePackages].sort((a, b) => b.length - a.length);
+	for (const pkg of sortedPackages) {
+		if (importPath === pkg) return pkg;
+		if (importPath.startsWith(`${pkg}/`)) return pkg;
+	}
+	return "unknown";
+}
+function findComponentSource(componentName, report, availablePackages) {
+	const namedImport = report.patterns.imports.named.find((imp) => imp.name === componentName);
+	if (namedImport) return resolvePackageFromImportPath(namedImport.source, availablePackages);
+	const defaultImport = report.patterns.imports.default.find((imp) => imp.name === componentName);
+	if (defaultImport) return resolvePackageFromImportPath(defaultImport.source, availablePackages);
+	const aliasedImport = report.patterns.imports.aliased.find((imp) => imp.local === componentName);
+	if (aliasedImport) return resolvePackageFromImportPath(aliasedImport.source, availablePackages);
+	return "unknown";
+}
+function getPackageVersion(packageName, versions) {
+	if (versions[packageName]) return versions[packageName];
+	if (packageName.includes("/")) {
+		const parts = packageName.split("/");
+		if (packageName.startsWith("@") && parts.length > 2) {
+			const basePackage = `${parts[0]}/${parts[1]}`;
+			if (versions[basePackage]) return versions[basePackage];
+		}
+		if (!packageName.startsWith("@") && parts.length > 1) {
+			if (versions[parts[0]]) return versions[parts[0]];
+		}
+	}
+	return null;
+}
+function calculatePackageDistribution(componentUsageMap, versions, config, multiVersions = {}) {
+	const ignorePatterns = config?.packages.ignore ?? [];
+	const internalPatterns = config?.packages.internal ?? [];
+	const packageMap = /* @__PURE__ */ new Map();
+	for (const component of componentUsageMap.values()) {
+		if (component.source === "unknown" || component.source === "local") continue;
+		if (ignorePatterns.length > 0 && micromatch.isMatch(component.source, ignorePatterns)) continue;
+		const existing = packageMap.get(component.source);
+		if (existing) {
+			existing.componentCount++;
+			existing.usageCount += component.count;
+			existing.components.push(component.name);
+		} else {
+			const isInternal = internalPatterns.length > 0 ? micromatch.isMatch(component.source, internalPatterns) : false;
+			const allVersions = multiVersions[component.source] ?? [];
+			const hasVersionConflict = allVersions.length > 1;
+			packageMap.set(component.source, {
+				packageName: component.source,
+				version: getPackageVersion(component.source, versions),
+				componentCount: 1,
+				usageCount: component.count,
+				percentage: 0,
+				components: [component.name],
+				internal: isInternal,
+				hasVersionConflict,
+				allVersions
+			});
 		}
-	});
-	const externalComponents = aggregated.topComponents.filter((comp) => comp.source !== "unknown" && comp.source !== "local").length;
-	const totalExternalUsage = aggregated.packageDistribution.reduce((sum, pkg) => sum + pkg.usageCount, 0);
-	table.push(["Files Analyzed", formatCount(aggregated.filesAnalyzed)], ["External Packages", formatCount(aggregated.packageDistribution.length)], ["External Components", formatCount(externalComponents)], ["Total Usages", formatCount(totalExternalUsage)]);
-	console.log(table.toString());
+	}
+	const distribution = Array.from(packageMap.values());
+	const totalExternalUsage = distribution.reduce((sum, pkg) => sum + pkg.usageCount, 0);
+	for (const pkg of distribution) pkg.percentage = totalExternalUsage > 0 ? pkg.usageCount / totalExternalUsage * 100 : 0;
+	return distribution.sort((a, b) => b.usageCount - a.usageCount);
 }
 //#endregion
-//#region src/utils/print-details.ts
-function printHeader$3() {
-	console.log(chalk.cyan.bold("\n📋 Details\n"));
-}
-function printDetails(aggregated) {
-	printHeader$3();
-	console.log(chalk.cyan(`  Total usage patterns: ${formatCount(aggregated.totalUsagePatterns)}`));
-	for (const pattern of aggregated.patternCounts) if (pattern.count > 0) console.log(chalk.cyan(`  ${pattern.displayName}: ${formatCount(pattern.count)}`));
+//#region src/rules/shared.ts
+function toArray(val) {
+	if (!val) return [];
+	return Array.isArray(val) ? val : [val];
 }
-//#endregion
-//#region src/utils/chart-renderer.ts
-function renderBarChart(data, options = {}) {
-	const { maxWidth = 50, showValues = true, barChar = "█", emptyChar = "░" } = options;
-	if (data.length === 0) {
-		console.log(chalk.gray("  No data to display"));
-		return;
-	}
-	const maxValue = Math.max(...data.map((d) => d.value));
-	if (maxValue === 0) {
-		console.log(chalk.gray("  All values are zero"));
-		return;
+function findMatches(patterns, repoPath, ignore) {
+	const matches = [];
+	for (const pattern of patterns) {
+		const found = globSync(pattern, {
+			cwd: repoPath,
+			nodir: true,
+			ignore
+		});
+		matches.push(...found.map((f) => f.replace(/\\/g, "/")));
 	}
-	const maxLabelLength = Math.max(...data.map((d) => d.label.length));
-	for (const item of data) {
-		const percentage = item.value / maxValue;
-		const barLength = Math.round(percentage * maxWidth);
-		const emptyLength = maxWidth - barLength;
-		const paddedLabel = item.label.padEnd(maxLabelLength, " ");
-		const bar = chalk.green(barChar.repeat(barLength)) + chalk.gray(emptyChar.repeat(emptyLength));
-		const valueStr = showValues ? ` ${formatCount(item.value)}` : "";
-		console.log(`${paddedLabel} ${bar}${valueStr}\n`);
+	return [...new Set(matches)];
+}
+function readPackageJson(repoPath) {
+	try {
+		const content = fs$1.readFileSync(path$1.join(repoPath, "package.json"), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
 	}
 }
 //#endregion
-//#region src/utils/print-components.ts
-function printHeader$2() {
-	console.log(chalk.magenta.bold("\n⚛️ Components\n"));
-}
-function printComponents(aggregated, mode) {
-	const components = aggregated.topComponents;
-	if (mode === "table") printComponentsTable(components);
-	else if (mode === "chart") printComponentsChart(components);
-}
-function printComponentsTable(components) {
-	printHeader$2();
-	const externalComponents = components.filter((comp) => comp.source !== "unknown" && comp.source !== "local");
-	if (externalComponents.length === 0) {
-		console.log(chalk.gray("  No external components found"));
-		return;
+//#region src/rules/file-rules.ts
+function evaluateFileRules(repoPath, rulesConfig, excludes) {
+	const violations = [];
+	for (const rule of toArray(rulesConfig.detect_files)) {
+		const matches = findMatches(rule.patterns, repoPath, excludes);
+		if (matches.length > 0) violations.push({
+			type: "detect_files",
+			severity: rule.severity,
+			patterns: rule.patterns,
+			message: rule.message,
+			matchedFiles: matches
+		});
 	}
-	const table = new Table({
-		head: [
-			"Component",
-			"Package",
-			"Count"
-		],
-		style: {
-			head: ["cyan"],
-			border: ["gray"]
-		}
-	});
-	externalComponents.forEach((comp) => {
-		table.push([
-			comp.name,
-			comp.source,
-			comp.count.toString()
-		]);
+	for (const rule of toArray(rulesConfig.require_files)) if (findMatches(rule.patterns, repoPath, excludes).length === 0) violations.push({
+		type: "require_files",
+		severity: rule.severity,
+		patterns: rule.patterns,
+		message: rule.message,
+		matchedFiles: []
 	});
-	console.log(table.toString());
+	return violations;
 }
-function printComponentsChart(components) {
-	printHeader$2();
-	const externalComponents = components.filter((comp) => comp.source !== "unknown" && comp.source !== "local");
-	if (externalComponents.length === 0) {
-		console.log(chalk.gray("  No external components found"));
-		return;
-	}
-	renderBarChart(externalComponents.map((comp) => ({
-		label: comp.name,
-		value: comp.count
-	})), { maxWidth: 50 });
+//#endregion
+//#region src/rules/script-rules.ts
+function evaluateScriptRules(repoPath, rulesConfig) {
+	const rules = toArray(rulesConfig.require_scripts);
+	if (rules.length === 0) return [];
+	const pkg = readPackageJson(repoPath);
+	const scriptKeys = Object.keys(pkg?.scripts ?? {});
+	return rules.filter((rule) => !rule.patterns.some((p) => scriptKeys.some((k) => micromatch.isMatch(k, p)))).map((rule) => ({
+		type: "require_scripts",
+		severity: rule.severity,
+		patterns: rule.patterns,
+		message: rule.message,
+		matchedFiles: []
+	}));
 }
 //#endregion
-//#region src/utils/print-patterns.ts
-function printHeader$1() {
-	console.log(chalk.blue.bold("\n🔍 Code Patterns\n"));
+//#region src/rules/package-field-rules.ts
+/** Resolves a dot-path like "engines.node" against the manifest object. */
+function getFieldAtPath(pkg, path) {
+	let current = pkg;
+	for (const key of path.split(".")) {
+		if (current === null || typeof current !== "object" || !(key in current)) return {
+			exists: false,
+			value: void 0
+		};
+		current = current[key];
+	}
+	return {
+		exists: true,
+		value: current
+	};
 }
-function printPatterns(aggregated, mode) {
-	const patterns = aggregated.patternCounts.filter((p) => p.count > 0);
-	if (mode === "table") printPatternsTable(patterns);
-	else if (mode === "chart") printPatternsChart(patterns);
+/** Primitives compare by string form; objects/arrays never match a value pattern. */
+function valueMatches(value, valuePatterns) {
+	if (value === null || typeof value === "object") return false;
+	return micromatch.isMatch(String(value), valuePatterns);
 }
-function printPatternsTable(patterns) {
-	printHeader$1();
-	if (patterns.length === 0) {
-		console.log(chalk.gray("  No patterns found"));
-		return;
-	}
-	const table = new Table({
-		head: ["Pattern", "Count"],
-		style: {
-			head: ["cyan"],
-			border: ["gray"]
+function evaluatePackageFieldRules(repoPath, rulesConfig) {
+	const requireRules = toArray(rulesConfig.require_package_fields);
+	const forbidRules = toArray(rulesConfig.forbid_package_fields);
+	if (requireRules.length === 0 && forbidRules.length === 0) return [];
+	const pkg = readPackageJson(repoPath);
+	const violations = [];
+	for (const rule of requireRules) {
+		const lookups = rule.patterns.map((p) => ({
+			path: p,
+			...getFieldAtPath(pkg, p)
+		}));
+		if (!lookups.some((l) => l.exists && (!rule.values || valueMatches(l.value, rule.values)))) {
+			const mismatch = rule.values ? lookups.find((l) => l.exists) : void 0;
+			violations.push({
+				type: "require_package_fields",
+				severity: rule.severity,
+				patterns: rule.patterns,
+				message: rule.message,
+				matchedFiles: [],
+				fieldPath: mismatch?.path,
+				actualValue: mismatch && typeof mismatch.value !== "object" ? String(mismatch.value) : void 0
+			});
 		}
-	});
-	patterns.forEach((pattern) => {
-		table.push([pattern.displayName, pattern.count.toString()]);
-	});
-	console.log(table.toString());
-	const totalPatterns = patterns.reduce((sum, p) => sum + p.count, 0);
-	console.log(chalk.gray(`\nTotal: ${totalPatterns} patterns detected`));
-}
-function printPatternsChart(patterns) {
-	printHeader$1();
-	if (patterns.length === 0) {
-		console.log(chalk.gray("  No patterns found"));
-		return;
 	}
-	renderBarChart(patterns.map((pattern) => ({
-		label: pattern.displayName,
-		value: pattern.count
-	})), { maxWidth: 50 });
+	for (const rule of forbidRules) for (const pattern of rule.patterns) {
+		const lookup = getFieldAtPath(pkg, pattern);
+		if (lookup.exists && (!rule.values || valueMatches(lookup.value, rule.values))) violations.push({
+			type: "forbid_package_fields",
+			severity: rule.severity,
+			patterns: rule.patterns,
+			message: rule.message,
+			matchedFiles: [],
+			fieldPath: pattern,
+			actualValue: lookup.value !== null && typeof lookup.value !== "object" ? String(lookup.value) : void 0
+		});
+	}
+	return violations;
 }
 //#endregion
-//#region src/utils/print-packages.ts
-function printHeader() {
-	console.log(chalk.blueBright.bold("\n📦 Packages\n"));
-}
-function formatPackageName(pkg, banned) {
-	let prefix = "";
-	if (pkg.releaseAge?.deprecated) prefix += chalk.red("[DEPRECATED] ");
-	if (banned) prefix += banned.severity === "error" ? chalk.red("[BANNED] ") : chalk.yellow("[RESTRICTED] ");
-	else if (pkg.internal) prefix += chalk.yellow("[int] ");
-	return prefix + pkg.packageName;
-}
-function formatUpgradeCell(releaseAge) {
-	if (!releaseAge) return "";
-	const { worstLevel, upgrades } = releaseAge;
-	if (!worstLevel) return chalk.green("✓");
-	const top = upgrades[0];
-	if (!top) return chalk.green("✓");
-	if (worstLevel === "mandatory_upgrade") return chalk.red(`⚠ ${top.semverBump} ${top.version} (${top.releasedDaysAgo}d)`);
-	return chalk.yellow(`↑ ${top.semverBump} ${top.version} (${top.releasedDaysAgo}d)`);
-}
-function getBannedViolation(pkg, violations) {
-	return violations.find((v) => v.packageName === pkg.packageName);
-}
-function printPackages(aggregated, mode) {
-	const packages = aggregated.packageDistribution;
-	const violations = aggregated.bannedPackageViolations;
-	if (mode === "table") printPackagesTable(packages, violations);
-	else if (mode === "chart") printPackagesChart(packages, violations);
-}
-function printPackagesTable(packages, violations) {
-	printHeader();
-	if (packages.length === 0) {
-		console.log(chalk.gray("  No packages found"));
-		return;
-	}
-	const hasReleaseAge = packages.some((p) => p.releaseAge !== void 0);
-	const head = [
-		"Package",
-		"Version",
-		"Components",
-		"Usage",
-		"Percentage"
-	];
-	if (hasReleaseAge) head.push("Upgrades");
-	const table = new Table({
-		head,
-		style: {
-			head: ["cyan"],
-			border: ["gray"]
-		}
-	});
-	packages.forEach((pkg) => {
-		const versionCell = pkg.hasVersionConflict ? chalk.yellow(`⚠ ${pkg.allVersions.join(", ")} (multiple — bundle impact)`) : pkg.version || "N/A";
-		const row = [
-			formatPackageName(pkg, getBannedViolation(pkg, violations)),
-			versionCell,
-			formatCount(pkg.componentCount),
-			formatCount(pkg.usageCount),
-			`${pkg.percentage.toFixed(1)}%`
-		];
-		if (hasReleaseAge) row.push(formatUpgradeCell(pkg.releaseAge));
-		table.push(row);
+//#region src/rules/engine-version.ts
+function evaluateEngineVersion(repoPath, rulesConfig) {
+	const rules = toArray(rulesConfig.engine_version);
+	if (rules.length === 0) return [];
+	const nodeRange = (readPackageJson(repoPath)?.engines)?.node;
+	return rules.flatMap((rule) => {
+		if (!nodeRange) return [{
+			type: "engine_version",
+			severity: rule.severity,
+			patterns: [],
+			message: rule.message ?? "engines.node not specified in package.json",
+			matchedFiles: [],
+			requiredRange: rule.range
+		}];
+		const minVer = semver.minVersion(nodeRange);
+		if (!minVer || !semver.satisfies(minVer, rule.range)) return [{
+			type: "engine_version",
+			severity: rule.severity,
+			patterns: [],
+			message: rule.message,
+			matchedFiles: [],
+			installedRange: nodeRange,
+			requiredRange: rule.range
+		}];
+		return [];
 	});
-	console.log(table.toString());
-	const totalComponents = packages.reduce((sum, p) => sum + p.componentCount, 0);
-	const totalExternalUsage = packages.reduce((sum, p) => sum + p.usageCount, 0);
-	console.log(chalk.gray(`\nTotal: ${formatCount(packages.length)} packages | ${formatCount(totalComponents)} unique components | ${formatCount(totalExternalUsage)} total usages`));
 }
-function printPackagesChart(packages, violations) {
-	printHeader();
-	if (packages.length === 0) {
-		console.log(chalk.gray("  No packages found"));
-		return;
+//#endregion
+//#region src/rules/codeowners.ts
+const CODEOWNERS_LOCATIONS = [
+	".github/CODEOWNERS",
+	"CODEOWNERS",
+	"docs/CODEOWNERS"
+];
+/** First existing location, GitHub search order. Null if none exist. */
+function findCodeownersFile(repoPath) {
+	for (const location of CODEOWNERS_LOCATIONS) {
+		const full = path$1.join(repoPath, location);
+		if (fs$1.existsSync(full)) return full;
 	}
-	const maxBarWidth = 40;
-	const maxPercentage = Math.max(...packages.map((p) => p.percentage));
-	const maxLabelLength = Math.max(...packages.map((p) => p.packageName.length + (p.internal ? 6 : 0)));
-	packages.forEach((pkg) => {
-		const barLength = Math.round(pkg.percentage / maxPercentage * maxBarWidth);
-		const emptyLength = maxBarWidth - barLength;
-		const label = formatPackageName(pkg, getBannedViolation(pkg, violations)).padEnd(maxLabelLength, " ");
-		const bar = chalk.green("█".repeat(barLength)) + chalk.gray("░".repeat(emptyLength));
-		console.log(`${label} ${bar} ${chalk.bold(pkg.percentage.toFixed(1) + "%")} (${pkg.usageCount})`);
-	});
+	return null;
 }
-//#endregion
-//#region src/utils/print-versus.ts
-const BAR_WIDTH = 30;
-function renderBar(percentage) {
-	const filled = Math.round(percentage / 100 * BAR_WIDTH);
-	const empty = BAR_WIDTH - filled;
-	return chalk.cyan("█".repeat(filled)) + chalk.gray("░".repeat(empty));
+/** Parses content into entries; skips blank lines and # comments. */
+function parseCodeowners(content) {
+	const entries = [];
+	for (const rawLine of content.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#")) continue;
+		const tokens = line.split(/\s+/);
+		const pattern = tokens[0];
+		const owners = tokens.slice(1);
+		entries.push({
+			pattern,
+			globs: codeownersPatternToGlobs(pattern),
+			owners
+		});
+	}
+	return entries;
 }
-function formatComponents(components, max = 3) {
-	if (components.length === 0) return "";
-	const shown = components.slice(0, max);
-	const rest = components.length - max;
-	const list = shown.join(", ");
-	return rest > 0 ? `${list} (+${rest} more)` : list;
+/**
+* Translates a CODEOWNERS (gitignore-style) pattern into micromatch glob(s).
+*
+* Rules:
+* - `*` alone matches everything.
+* - A leading `/`, or a `/` anywhere in the middle of the pattern, anchors
+*   the match to the repo root (the leading `/` is stripped once anchored).
+* - A pattern with no anchoring gets a `**\/` prefix so it matches at any depth.
+* - A trailing `/` restricts the match to a directory, so `/**` is appended.
+* - A bare name (no glob characters, no slash at all) also matches as a
+*   directory anywhere, so the `/**` directory variant is added alongside
+*   the plain match.
+*/
+function codeownersPatternToGlobs(pattern) {
+	if (pattern === "*") return ["**"];
+	let p = pattern;
+	const hadLeadingSlash = p.startsWith("/");
+	if (hadLeadingSlash) p = p.slice(1);
+	const hadTrailingSlash = p.endsWith("/") && p.length > 1;
+	if (hadTrailingSlash) p = p.slice(0, -1);
+	const hasInternalSlash = p.includes("/");
+	const anchored = hadLeadingSlash || hasInternalSlash;
+	const hasGlobChars = /[*?[\]{}!()]/.test(p);
+	const isBareName = !anchored && !hasGlobChars && !hadTrailingSlash;
+	const base = anchored ? p : `**/${p}`;
+	const globs = [hadTrailingSlash ? `${base}/**` : base];
+	if (isBareName) globs.push(`${base}/**`);
+	return globs;
+}
+/** Last matching entry wins; owned iff that entry has >= 1 owner. */
+function fileIsOwned(file, entries) {
+	for (let i = entries.length - 1; i >= 0; i--) if (micromatch.isMatch(file, entries[i].globs, { dot: true })) return entries[i].owners.length > 0;
+	return false;
 }
-function printVersusResult(result) {
-	console.log(chalk.bold(`  ${result.name}`));
-	console.log(chalk.gray(`  ${"─".repeat(50)}`));
-	const maxNameLen = Math.max(...result.entries.map((e) => e.packageName.length));
-	for (const entry of result.entries) {
-		const name = entry.packageName.padEnd(maxNameLen);
-		const bar = renderBar(entry.percentage);
-		const pct = chalk.bold(`${entry.percentage.toFixed(1)}%`);
-		const usage = chalk.gray(`(${entry.count} usages)`);
-		const components = entry.components.length > 0 ? chalk.gray(`  ${formatComponents(entry.components)}`) : "";
-		console.log(`  ${name}  ${bar} ${pct} ${usage}${components}`);
-	}
-	if (result.totalCount === 0) console.log(chalk.gray("  No usage detected for any package in this group."));
-	console.log();
+function evaluateCodeowners(repoPath, rulesConfig, scannedFiles) {
+	const rule = rulesConfig.codeowners;
+	if (!rule) return [];
+	const filePath = findCodeownersFile(repoPath);
+	if (!filePath) return [{
+		type: "codeowners",
+		severity: rule.severity,
+		patterns: CODEOWNERS_LOCATIONS,
+		message: rule.message,
+		matchedFiles: []
+	}];
+	const entries = parseCodeowners(fs$1.readFileSync(filePath, "utf-8"));
+	const unowned = scannedFiles.map((f) => (path$1.isAbsolute(f) ? path$1.relative(repoPath, f) : f).replace(/\\/g, "/")).filter((f) => !fileIsOwned(f, entries));
+	if (unowned.length === 0) return [];
+	return [{
+		type: "codeowners",
+		severity: rule.severity,
+		patterns: [path$1.basename(filePath)],
+		message: rule.message,
+		matchedFiles: unowned
+	}];
 }
-function printVersus(aggregated) {
-	if (aggregated.versusResults.length === 0) return;
-	console.log(chalk.magentaBright.bold("\n⚖️  Versus\n"));
-	for (const result of aggregated.versusResults) printVersusResult(result);
+//#endregion
+//#region src/rules/evaluator.ts
+function evaluateRules(repoPath, rulesConfig, excludes, scannedFiles = []) {
+	return [
+		...evaluateFileRules(repoPath, rulesConfig, excludes),
+		...evaluateScriptRules(repoPath, rulesConfig),
+		...evaluatePackageFieldRules(repoPath, rulesConfig),
+		...evaluateEngineVersion(repoPath, rulesConfig),
+		...evaluateCodeowners(repoPath, rulesConfig, scannedFiles)
+	];
 }
 //#endregion
-//#region src/utils/print-rules.ts
-function formatRuleType(type) {
-	switch (type) {
-		case "forbid_files": return "forbid_files";
-		case "require_files": return "require_files";
-		case "allow_files": return "allow_files";
-		case "forbid_packages": return "forbid_packages";
-		case "require_packages": return "require_packages";
-		case "require_scripts": return "require_scripts";
-		case "require_package_fields": return "pkg_fields";
-		case "engine_version": return "engine_version";
+//#region src/utils/package-rules.ts
+function detectBannedPackages(distribution, config) {
+	const forbidRules = toArray(config?.rules.forbid_packages);
+	if (forbidRules.length === 0) return [];
+	const violations = [];
+	for (const pkg of distribution) for (const rule of forbidRules) if (micromatch.isMatch(pkg.packageName, rule.patterns)) {
+		violations.push({
+			packageName: pkg.packageName,
+			severity: rule.severity,
+			message: rule.message
+		});
+		break;
 	}
+	return violations;
 }
-function ruleIcon(violation) {
-	if (violation.severity === "error") return chalk.red("✗");
-	return chalk.yellow("⚠");
+function detectRequiredPackages(distribution, versions, config) {
+	const requireRules = toArray(config?.rules.require_packages);
+	if (requireRules.length === 0) return [];
+	const installedNames = /* @__PURE__ */ new Set([...Object.keys(versions), ...distribution.map((p) => p.packageName)]);
+	const violations = [];
+	for (const rule of requireRules) if (!rule.patterns.some((p) => [...installedNames].some((name) => micromatch.isMatch(name, p)))) violations.push({
+		type: "require_packages",
+		severity: rule.severity,
+		patterns: rule.patterns,
+		message: rule.message,
+		matchedFiles: []
+	});
+	return violations;
 }
-function describeViolation(v) {
-	const patterns = v.patterns.join(", ");
-	const suffix = v.message ? chalk.gray(` — ${v.message}`) : "";
-	if (v.type === "forbid_files") return `${patterns} found (${v.matchedFiles.map((f) => {
-		const parts = f.replace(/\\/g, "/").split("/");
-		return parts[parts.length - 1];
-	}).join(", ")})${suffix}`;
-	if (v.type === "require_files") return `${patterns} not found${suffix}`;
-	if (v.type === "allow_files") return `${patterns} not present${suffix}`;
-	if (v.type === "require_packages") return `${patterns} not installed${suffix}`;
-	if (v.type === "forbid_packages") return `${patterns} is forbidden${suffix}`;
-	if (v.type === "require_scripts") return `script ${patterns} missing in package.json${suffix}`;
-	if (v.type === "require_package_fields") return `field ${patterns} missing in package.json${suffix}`;
-	if (v.type === "engine_version") {
-		if (!v.installedRange) return `engines.node not specified (required ${v.requiredRange})${suffix}`;
-		return `engines.node is ${chalk.yellow(v.installedRange)}, required ${chalk.cyan(v.requiredRange)}${suffix}`;
-	}
-	return `${patterns} not present${suffix}`;
+//#endregion
+//#region src/utils/pattern-counter.ts
+function countPatterns(report, patternMap) {
+	increment(patternMap, "imports.default", report.patterns.imports.default.length);
+	increment(patternMap, "imports.named", report.patterns.imports.named.length);
+	increment(patternMap, "imports.namespace", report.patterns.imports.namespace.length);
+	increment(patternMap, "imports.aliased", report.patterns.imports.aliased.length);
+	increment(patternMap, "usage.jsx", report.patterns.usage.jsx.length);
+	increment(patternMap, "usage.variables", report.patterns.usage.variables.length);
+	increment(patternMap, "usage.destructuring", report.patterns.usage.destructuring.length);
+	increment(patternMap, "usage.conditional", report.patterns.usage.conditional.length);
+	increment(patternMap, "usage.arrays", report.patterns.usage.arrays.length);
+	increment(patternMap, "usage.objects", report.patterns.usage.objects.length);
+	increment(patternMap, "advanced.lazy", report.patterns.advanced.lazy.length);
+	increment(patternMap, "advanced.dynamic", report.patterns.advanced.dynamic.length);
+	increment(patternMap, "advanced.hoc", report.patterns.advanced.hoc.length);
+	increment(patternMap, "advanced.memo", report.patterns.advanced.memo.length);
+	increment(patternMap, "advanced.forwardRef", report.patterns.advanced.forwardRef.length);
+	increment(patternMap, "advanced.portal", report.patterns.advanced.portal.length);
 }
-function printRules(aggregated) {
-	const { ruleViolations, bannedPackageViolations } = aggregated;
-	const hasRuleViolations = ruleViolations.length > 0;
-	const hasBannedViolations = bannedPackageViolations.length > 0;
-	if (!hasRuleViolations && !hasBannedViolations) {
-		console.log(chalk.greenBright.bold("\n✓ Compliance\n"));
-		console.log(chalk.gray("  All compliance checks passed"));
-		return;
-	}
-	console.log(chalk.blueBright.bold("\n🔍 Compliance\n"));
-	if (hasRuleViolations) for (const v of ruleViolations) {
-		const icon = ruleIcon(v);
-		const type = chalk.gray(formatRuleType(v.type).padEnd(14));
-		const severityTag = v.severity === "error" ? chalk.red("[ERROR]") : chalk.yellow("[WARN]");
-		console.log(`  ${icon}  ${type} ${describeViolation(v)}  ${severityTag}`);
-	}
-	if (hasBannedViolations) {
-		if (hasRuleViolations) console.log();
-		for (const v of bannedPackageViolations) {
-			const icon = v.severity === "error" ? chalk.red("✗") : chalk.yellow("⚠");
-			const tag = v.severity === "error" ? chalk.red("[BANNED]") : chalk.yellow("[RESTRICTED]");
-			const msg = v.message ? chalk.gray(` — ${v.message}`) : "";
-			console.log(`  ${icon}  ${tag} ${v.packageName}${msg}`);
+function increment(map, key, value) {
+	map.set(key, (map.get(key) || 0) + value);
+}
+function getPatternDisplayName(patternType) {
+	return {
+		"imports.default": "Default Imports",
+		"imports.named": "Named Imports",
+		"imports.namespace": "Namespace Imports",
+		"imports.aliased": "Aliased Imports",
+		"usage.jsx": "JSX Usage",
+		"usage.variables": "Variable Assignments",
+		"usage.destructuring": "Destructuring",
+		"usage.conditional": "Conditional Usage",
+		"usage.arrays": "Array Mappings",
+		"usage.objects": "Object Mappings",
+		"advanced.lazy": "Lazy Loading",
+		"advanced.dynamic": "Dynamic Imports",
+		"advanced.hoc": "Higher-Order Components",
+		"advanced.memo": "Memoized Components",
+		"advanced.forwardRef": "Forward Refs",
+		"advanced.portal": "Portal Usage"
+	}[patternType] || patternType;
+}
+//#endregion
+//#region src/utils/versus.ts
+function toPercentage(count, total) {
+	return total > 0 ? count / total * 100 : 0;
+}
+function calculateVersusResults(distribution, versusConfigs) {
+	const distMap = new Map(distribution.map((p) => [p.packageName, p]));
+	return versusConfigs.map((vc) => {
+		const entries = vc.packages.map((pkgName) => {
+			const pkg = distMap.get(pkgName);
+			return {
+				packageName: pkgName,
+				count: pkg?.usageCount ?? 0,
+				percentage: 0,
+				components: pkg?.components ?? []
+			};
+		});
+		const totalCount = entries.reduce((sum, e) => sum + e.count, 0);
+		for (const entry of entries) entry.percentage = toPercentage(entry.count, totalCount);
+		entries.sort((a, b) => b.count - a.count);
+		return {
+			name: vc.name,
+			packages: vc.packages,
+			entries,
+			totalCount
+		};
+	});
+}
+//#endregion
+//#region src/utils/aggregator-core.ts
+function aggregateReports(reports, versions = {}, config, multiVersions = {}) {
+	const componentUsageMap = /* @__PURE__ */ new Map();
+	let totalImports = 0;
+	let totalUsagePatterns = 0;
+	const patternCountMap = /* @__PURE__ */ new Map();
+	const availablePackages = Object.keys(versions);
+	for (const report of reports) {
+		totalImports += report.summary.totalImports;
+		totalUsagePatterns += report.summary.totalUsagePatterns;
+		for (const jsx of report.patterns.usage.jsx) {
+			const key = jsx.component;
+			const existing = componentUsageMap.get(key);
+			if (existing) {
+				existing.count++;
+				existing.files.add(report.filePath);
+			} else {
+				const source = findComponentSource(jsx.component, report, availablePackages);
+				componentUsageMap.set(key, {
+					name: jsx.component,
+					source,
+					count: 1,
+					files: /* @__PURE__ */ new Set([report.filePath])
+				});
+			}
 		}
+		countPatterns(report, patternCountMap);
 	}
-	const errorCount = [...ruleViolations.filter((v) => v.severity === "error"), ...bannedPackageViolations.filter((v) => v.severity === "error")].length;
-	const warnCount = [...ruleViolations.filter((v) => v.severity === "warn"), ...bannedPackageViolations.filter((v) => v.severity === "warn")].length;
-	const parts = [];
-	if (errorCount > 0) parts.push(chalk.red(`${errorCount} error${errorCount > 1 ? "s" : ""}`));
-	if (warnCount > 0) parts.push(chalk.yellow(`${warnCount} warning${warnCount > 1 ? "s" : ""}`));
-	console.log(chalk.gray(`\n  ${parts.join(", ")}`));
+	const topComponents = Array.from(componentUsageMap.values()).sort((a, b) => b.count - a.count);
+	const allComponents = Array.from(componentUsageMap.keys()).sort();
+	const patternCounts = Array.from(patternCountMap.entries()).map(([type, count]) => ({
+		patternType: type,
+		displayName: getPatternDisplayName(type),
+		count
+	})).sort((a, b) => b.count - a.count);
+	const packageDistribution = calculatePackageDistribution(componentUsageMap, versions, config, multiVersions);
+	const versusResults = calculateVersusResults(packageDistribution, config?.versus ?? []);
+	const bannedPackageViolations = detectBannedPackages(packageDistribution, config);
+	const requiredPackageViolations = detectRequiredPackages(packageDistribution, versions, config);
+	return {
+		filesAnalyzed: reports.length,
+		totalImports,
+		totalComponents: componentUsageMap.size,
+		totalUsagePatterns,
+		patternCounts,
+		componentUsage: componentUsageMap,
+		topComponents,
+		allComponents,
+		packageDistribution,
+		versusResults,
+		ruleViolations: requiredPackageViolations,
+		bannedPackageViolations,
+		reports
+	};
 }
 //#endregion
 //#region src/utils/print-errors.ts
-function printErrors(errors) {
+function printErrors(errors, isJson) {
 	if (errors.length === 0) return;
-	console.log(chalk.yellow(`\n⚠ ${errors.length} file(s) failed to parse:`));
+	const stream = isJson ? process.stderr : process.stdout;
+	stream.write(chalk.yellow(`\n⚠ ${errors.length} file(s) failed to parse:\n`));
 	for (const { file, message } of errors) {
-		console.log(chalk.yellow(`  ${file}`));
-		console.log(chalk.gray(`    ${message}`));
-	}
-	console.log("");
-}
-//#endregion
-//#region src/utils/version.ts
-let cachedVersion;
-/**
-* Walks up from `dir` to find the nearest package.json.
-* Needed because this module's own path differs between the tsdown-bundled
-* single-file `dist/cli.mjs` and the unbundled source used by tests.
-*/
-function findPackageJson(dir) {
-	let current = dir;
-	while (true) {
-		const candidate = path.join(current, "package.json");
-		if (existsSync(candidate)) return candidate;
-		const parent = path.dirname(current);
-		if (parent === current) throw new Error(`Could not locate package.json above ${dir}`);
-		current = parent;
+		stream.write(chalk.yellow(`  ${file}\n`));
+		stream.write(chalk.gray(`    ${message}\n`));
 	}
-}
-function getVersion() {
-	if (cachedVersion) return cachedVersion;
-	const pkgPath = findPackageJson(path.dirname(fileURLToPath(import.meta.url)));
-	cachedVersion = JSON.parse(readFileSync(pkgPath, "utf8")).version;
-	return cachedVersion;
-}
-//#endregion
-//#region src/utils/print-json.ts
-function printJson(aggregated) {
-	const result = {
-		version: getVersion(),
-		summary: {
-			filesAnalyzed: aggregated.filesAnalyzed,
-			totalImports: aggregated.totalImports,
-			totalComponents: aggregated.totalComponents,
-			totalUsagePatterns: aggregated.totalUsagePatterns
-		},
-		packages: aggregated.packageDistribution,
-		components: aggregated.topComponents.map((c) => ({
-			...c,
-			files: [...c.files]
-		})),
-		patterns: aggregated.patternCounts,
-		versus: aggregated.versusResults,
-		ruleViolations: aggregated.ruleViolations,
-		bannedPackageViolations: aggregated.bannedPackageViolations
-	};
-	process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	stream.write("\n");
 }
 //#endregion
 //#region src/utils/file-utils.ts
@@ -1486,6 +1823,20 @@ var NpmLockfileAdapter = class {
 };
 //#endregion
 //#region src/lock-parser/patterns/pnpm.ts
+function parsePackageKey(rawKey) {
+	const withoutPeerSuffix = (rawKey.startsWith("/") ? rawKey.slice(1) : rawKey).replace(/\(.*\)$/, "");
+	const atMatch = withoutPeerSuffix.match(/^(.+)@(\d+\.\d+\.\d+[^/]*)$/);
+	if (atMatch) return {
+		name: atMatch[1],
+		version: atMatch[2]
+	};
+	const slashMatch = withoutPeerSuffix.match(/^(.+?)\/(\d+\.\d+\.\d+.*)$/);
+	if (slashMatch) return {
+		name: slashMatch[1],
+		version: slashMatch[2]
+	};
+	return null;
+}
 var PnpmLockfileAdapter = class {
 	name = "pnpm";
 	supportedVersions = [
@@ -1530,9 +1881,34 @@ var PnpmLockfileAdapter = class {
 			return {};
 		}
 	}
+	parseMultiVersion(lockFilePath) {
+		try {
+			const lockData = load(fs$1.readFileSync(lockFilePath, "utf8"));
+			const versionSets = {};
+			if (lockData.packages) Object.keys(lockData.packages).forEach((key) => {
+				const parsed = parsePackageKey(key);
+				if (!parsed) return;
+				if (!versionSets[parsed.name]) versionSets[parsed.name] = /* @__PURE__ */ new Set();
+				versionSets[parsed.name].add(parsed.version);
+			});
+			const result = {};
+			for (const [pkg, versions] of Object.entries(versionSets)) result[pkg] = Array.from(versions).sort();
+			return result;
+		} catch {
+			return {};
+		}
+	}
 };
 //#endregion
 //#region src/lock-parser/patterns/yarn.ts
+function extractPackageName(key) {
+	if (key.startsWith("@")) {
+		const match = key.match(/^(@[^@]+\/[^@]+)@/);
+		return match ? match[1] : key;
+	}
+	const match = key.match(/^([^@]+)@/);
+	return match ? match[1] : key;
+}
 var YarnLockfileAdapter = class {
 	name = "yarn";
 	supportedVersions = ["v1", "v2+"];
@@ -1550,15 +1926,8 @@ var YarnLockfileAdapter = class {
 			}
 			const versions = {};
 			Object.entries(parsed.object).forEach(([key, value]) => {
-				let pkgName = key;
-				if (key.startsWith("@")) {
-					const match = key.match(/^(@[^@]+\/[^@]+)@/);
-					if (match) pkgName = match[1];
-				} else {
-					const match = key.match(/^([^@]+)@/);
-					if (match) pkgName = match[1];
-				}
-				if (value.version && (!versions[pkgName] || value.version)) versions[pkgName] = value.version;
+				const pkgName = extractPackageName(key);
+				if (value.version && !versions[pkgName]) versions[pkgName] = value.version;
 			});
 			return versions;
 		} catch (error) {
@@ -1567,6 +1936,25 @@ var YarnLockfileAdapter = class {
 			return {};
 		}
 	}
+	parseMultiVersion(lockFilePath) {
+		try {
+			const content = fs$1.readFileSync(lockFilePath, "utf8");
+			const parsed = lockfile.parse(content);
+			if (parsed.type !== "success") return {};
+			const versionSets = {};
+			Object.entries(parsed.object).forEach(([key, value]) => {
+				if (!value.version) return;
+				const pkgName = extractPackageName(key);
+				if (!versionSets[pkgName]) versionSets[pkgName] = /* @__PURE__ */ new Set();
+				versionSets[pkgName].add(value.version);
+			});
+			const result = {};
+			for (const [pkg, vers] of Object.entries(versionSets)) result[pkg] = Array.from(vers).sort();
+			return result;
+		} catch {
+			return {};
+		}
+	}
 };
 //#endregion
 //#region src/lock-parser/index.ts
@@ -1602,110 +1990,6 @@ function findAndParseLockfile(projectPath) {
 	throw new Error("No supported lockfile found");
 }
 //#endregion
-//#region src/config/schema.ts
-const RuleSeveritySchema = z.enum(["error", "warn"]);
-const RuleConfigSchema = z.object({
-	severity: RuleSeveritySchema,
-	patterns: z.array(z.string()),
-	message: z.string().optional()
-});
-const RuleConfigOrArraySchema = z.union([RuleConfigSchema, z.array(RuleConfigSchema)]);
-const EngineVersionRuleSchema = z.object({
-	severity: RuleSeveritySchema,
-	range: z.string(),
-	message: z.string().optional()
-});
-const ThresholdSchema = z.union([z.number(), z.literal(false)]);
-const HermexConfigSchema = z.object({
-	includes: z.array(z.string()).default(["**/*.{tsx,jsx,ts,js}"]),
-	excludes: z.array(z.string()).default([
-		"**/node_modules/**",
-		"**/dist/**",
-		"**/build/**"
-	]),
-	packages: z.object({
-		internal: z.array(z.string()).default([]),
-		ignore: z.array(z.string()).default([])
-	}).default(() => ({
-		internal: [],
-		ignore: []
-	})),
-	versus: z.array(z.object({
-		name: z.string(),
-		packages: z.array(z.string()).min(2)
-	})).default([]),
-	rules: z.object({
-		forbid_files: RuleConfigOrArraySchema.default([]),
-		require_files: RuleConfigOrArraySchema.default([]),
-		allow_files: RuleConfigOrArraySchema.default([]),
-		forbid_packages: RuleConfigOrArraySchema.default([]),
-		require_packages: RuleConfigOrArraySchema.default([]),
-		require_scripts: RuleConfigOrArraySchema.default([]),
-		require_package_fields: RuleConfigOrArraySchema.default([]),
-		engine_version: z.union([EngineVersionRuleSchema, z.array(EngineVersionRuleSchema)]).optional()
-	}).default(() => ({
-		forbid_files: [],
-		require_files: [],
-		allow_files: [],
-		forbid_packages: [],
-		require_packages: [],
-		require_scripts: [],
-		require_package_fields: []
-	})),
-	output: z.object({
-		summary: z.union([z.literal("log"), z.literal(false)]).default("log"),
-		components: z.union([z.enum(["table", "chart"]), z.literal(false)]).default("table"),
-		packages: z.union([z.enum(["table", "chart"]), z.literal(false)]).default("table"),
-		patterns: z.union([z.enum(["table", "chart"]), z.literal(false)]).default("table"),
-		details: z.boolean().default(false),
-		versus: z.boolean().default(true),
-		rules: z.boolean().default(true),
-		format: z.enum(["human", "json"]).default("human")
-	}).default(() => ({
-		summary: "log",
-		components: "table",
-		packages: "table",
-		patterns: "table",
-		details: false,
-		versus: true,
-		rules: true,
-		format: "human"
-	})),
-	releaseAge: z.object({
-		enabled: z.boolean().default(false),
-		registry: z.string().default("https://registry.npmjs.org"),
-		authToken: z.string().optional(),
-		thresholds: z.object({
-			patch: ThresholdSchema.default(30),
-			minor: ThresholdSchema.default(45),
-			major: ThresholdSchema.default(60)
-		}).default(() => ({
-			patch: 30,
-			minor: 45,
-			major: 60
-		}))
-	}).default(() => ({
-		enabled: false,
-		registry: "https://registry.npmjs.org",
-		thresholds: {
-			patch: 30,
-			minor: 45,
-			major: 60
-		}
-	}))
-});
-//#endregion
-//#region src/config/loader.ts
-async function loadConfig(cwd, explicitPath) {
-	const configPath = explicitPath ? resolve(explicitPath) : join(cwd, "hermex.config.ts");
-	if (explicitPath && !existsSync(configPath)) throw new Error(`Config file not found: ${configPath}`);
-	if (existsSync(configPath)) {
-		const mod = await import(pathToFileURL(configPath).href);
-		return HermexConfigSchema.parse(mod.default ?? mod);
-	}
-	return HermexConfigSchema.parse({});
-}
-//#endregion
 //#region src/npm-registry/client.ts
 async function fetchPackageInfo(name, registryUrl, authToken) {
 	const url = `${registryUrl.replace(/\/$/, "")}/${encodeURIComponent(name).replace("%40", "@")}`;
@@ -1727,6 +2011,53 @@ async function fetchPackageInfo(name, registryUrl, authToken) {
 	}
 }
 //#endregion
+//#region src/npm-registry/cache.ts
+const DEFAULT_TTL_MS = 3600 * 1e3;
+const DEFAULT_CACHE_DIR = join(homedir(), ".hermex", "cache", "npm");
+function cachePathFor(registryUrl, packageName, options) {
+	return join(options?.cacheDir ?? DEFAULT_CACHE_DIR, new URL(registryUrl).host.replace(/:/g, "_"), `${encodeURIComponent(packageName)}.json`);
+}
+async function readCache(registryUrl, packageName, options) {
+	const ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+	try {
+		const raw = await readFile(cachePathFor(registryUrl, packageName, options), "utf8");
+		const entry = JSON.parse(raw);
+		if (entry.registryUrl !== registryUrl || entry.packageName !== packageName) return null;
+		if (Date.now() - entry.cachedAt >= ttlMs) return null;
+		return entry.data;
+	} catch {
+		return null;
+	}
+}
+async function writeCache(registryUrl, packageName, data, options) {
+	const finalPath = cachePathFor(registryUrl, packageName, options);
+	const tmpPath = `${finalPath}.tmp-${randomUUID()}`;
+	try {
+		await mkdir(dirname(finalPath), { recursive: true });
+		await writeFile(tmpPath, JSON.stringify({
+			cachedAt: Date.now(),
+			registryUrl,
+			packageName,
+			data
+		}), "utf8");
+		await rename(tmpPath, finalPath);
+	} catch {
+		try {
+			await unlink(tmpPath);
+		} catch {}
+	}
+}
+async function getPackageInfo(packageName, registryUrl, authToken, options) {
+	const cacheEnabled = !authToken && !options?.disabled;
+	if (cacheEnabled) {
+		const cached = await readCache(registryUrl, packageName, options);
+		if (cached) return cached;
+	}
+	const info = await fetchPackageInfo(packageName, registryUrl, authToken);
+	if (info && cacheEnabled) await writeCache(registryUrl, packageName, info, options);
+	return info;
+}
+//#endregion
 //#region src/npm-registry/enricher.ts
 const CONCURRENCY = 8;
 function daysSince(dateStr) {
@@ -1741,41 +2072,86 @@ function classifyBump(installed, candidate) {
 	if (diff === "major" || diff === "premajor") return "major";
 	return null;
 }
+function pickNewest(versions) {
+	return versions.reduce((a, b) => a.daysAgo < b.daysAgo ? a : b);
+}
 function upgradeLevel(daysAgo, bump, thresholds) {
 	const threshold = thresholds[bump];
 	if (threshold === false || threshold === void 0) return null;
 	if (daysAgo > threshold) return bump === "major" ? "mandatory_upgrade" : "needs_upgrade";
 	return null;
 }
-function computeReleaseAge(installedVersion, timeMap, deprecated, thresholds) {
-	const upgrades = [];
+function computeReleaseAge(installedVersion, timeMap, deprecated, thresholds, distTags, severity) {
+	const byBump = /* @__PURE__ */ new Map();
+	let minCompliantVersion;
+	let minCompliantReleasedDaysAgo;
 	for (const [version, dateStr] of Object.entries(timeMap)) {
 		if (version === "created" || version === "modified") continue;
 		if (!semver.valid(version)) continue;
+		if (semver.prerelease(version)) continue;
 		if (semver.lte(version, installedVersion)) continue;
 		const bump = classifyBump(installedVersion, version);
 		if (!bump) continue;
 		const daysAgo = daysSince(dateStr);
-		const level = upgradeLevel(daysAgo, bump, thresholds);
+		const list = byBump.get(bump) ?? [];
+		list.push({
+			version,
+			daysAgo
+		});
+		byBump.set(bump, list);
+		const threshold = thresholds[bump];
+		if (threshold !== false && threshold !== void 0 && daysAgo <= threshold && (minCompliantReleasedDaysAgo === void 0 || daysAgo > minCompliantReleasedDaysAgo)) {
+			minCompliantVersion = version;
+			minCompliantReleasedDaysAgo = daysAgo;
+		}
+	}
+	const upgrades = [];
+	for (const [bump, versions] of byBump.entries()) {
+		const level = upgradeLevel(Math.max(...versions.map((v) => v.daysAgo)), bump, thresholds);
 		if (!level) continue;
+		const newest = pickNewest(versions);
 		upgrades.push({
-			version,
-			releasedDaysAgo: daysAgo,
+			version: newest.version,
+			releasedDaysAgo: newest.daysAgo,
 			semverBump: bump,
-			level
+			level,
+			thresholdDays: thresholds[bump]
 		});
 	}
-	const worstPerBump = /* @__PURE__ */ new Map();
-	for (const upgrade of upgrades) {
-		const existing = worstPerBump.get(upgrade.semverBump);
-		if (!existing || upgrade.releasedDaysAgo > existing.releasedDaysAgo) worstPerBump.set(upgrade.semverBump, upgrade);
+	const finalUpgrades = upgrades.sort((a, b) => b.releasedDaysAgo - a.releasedDaysAgo);
+	const latestVersion = distTags?.["latest"];
+	const latestEntry = latestVersion ? timeMap[latestVersion] : void 0;
+	const latestReleasedDaysAgo = latestEntry ? daysSince(latestEntry) : void 0;
+	for (const upgrade of finalUpgrades) if (latestVersion && upgrade.version === latestVersion) upgrade.isLatest = true;
+	const worstLevel = finalUpgrades.some((u) => u.level === "mandatory_upgrade") ? "mandatory_upgrade" : finalUpgrades.length > 0 ? "needs_upgrade" : null;
+	let pendingUpgrade;
+	if (worstLevel === null) for (const [bump, versions] of byBump.entries()) {
+		const threshold = thresholds[bump];
+		if (threshold === false || threshold === void 0) continue;
+		const daysRemaining = threshold - Math.max(...versions.map((v) => v.daysAgo));
+		if (daysRemaining <= 0) continue;
+		if (!pendingUpgrade || daysRemaining < pendingUpgrade.daysRemaining) {
+			const newest = pickNewest(versions);
+			pendingUpgrade = {
+				version: newest.version,
+				semverBump: bump,
+				releasedDaysAgo: newest.daysAgo,
+				thresholdDays: threshold,
+				daysRemaining
+			};
+		}
 	}
-	const finalUpgrades = Array.from(worstPerBump.values()).sort((a, b) => b.releasedDaysAgo - a.releasedDaysAgo);
 	return {
 		installedVersion,
 		upgrades: finalUpgrades,
-		worstLevel: finalUpgrades.some((u) => u.level === "mandatory_upgrade") ? "mandatory_upgrade" : finalUpgrades.length > 0 ? "needs_upgrade" : null,
-		deprecated
+		worstLevel,
+		pendingUpgrade,
+		deprecated,
+		latestVersion,
+		latestReleasedDaysAgo,
+		minCompliantVersion,
+		minCompliantReleasedDaysAgo,
+		severity
 	};
 }
 async function enrichWithReleaseAge(packages, config) {
@@ -1784,10 +2160,15 @@ async function enrichWithReleaseAge(packages, config) {
 	const targets = packages.filter((p) => !p.internal && p.version);
 	const enriched = [...packages];
 	let skipped = 0;
+	const envTtl = Number(process.env["HERMEX_REGISTRY_CACHE_TTL_MS"]);
+	const cacheOptions = {
+		ttlMs: Number.isFinite(envTtl) && envTtl > 0 ? envTtl : config.cacheTtlMs,
+		disabled: process.env["HERMEX_REGISTRY_CACHE_DISABLED"] === "1" || config.cacheDisabled === true
+	};
 	for (let i = 0; i < targets.length; i += CONCURRENCY) {
 		const batch = targets.slice(i, i + CONCURRENCY);
 		const results = await Promise.all(batch.map(async (pkg) => {
-			const info = await fetchPackageInfo(pkg.packageName, registryUrl, authToken);
+			const info = await getPackageInfo(pkg.packageName, registryUrl, authToken, cacheOptions);
 			if (!info || !info.time) {
 				skipped++;
 				return {
@@ -1796,9 +2177,10 @@ async function enrichWithReleaseAge(packages, config) {
 				};
 			}
 			const deprecated = info.versions?.[pkg.version]?.deprecated ?? info.deprecated;
+			const severity = config.enforceOn.length === 0 || micromatch.isMatch(pkg.packageName, config.enforceOn) ? "error" : "warn";
 			return {
 				pkg,
-				entry: computeReleaseAge(pkg.version, info.time, typeof deprecated === "string" ? deprecated : void 0, config.thresholds)
+				entry: computeReleaseAge(pkg.version, info.time, typeof deprecated === "string" ? deprecated : void 0, config.thresholds, info["dist-tags"], severity)
 			};
 		}));
 		for (const { pkg, entry } of results) {
@@ -1816,69 +2198,102 @@ async function enrichWithReleaseAge(packages, config) {
 	};
 }
 //#endregion
+//#region src/commands/pipeline.ts
+const DECLARATION_FILE_RE = /\.d\.(ts|mts|cts)$/;
+function isDeclarationFile(filePath) {
+	return DECLARATION_FILE_RE.test(filePath);
+}
+/**
+* Runs the shared parse → aggregate → rules → release-age pipeline used by
+* both `scan` and `comply`. Returns `null` if no files matched (the spinner
+* has already reported the failure); throws on unexpected errors.
+*/
+async function runPipeline(config, spinner, isJson) {
+	const lockfileResult = findAndParseLockfile(process.cwd());
+	spinner.succeed(chalk.blue(`📦 Found ${lockfileResult.lockfileType} lockfile (supports: ${lockfileResult.supportedVersions.join(", ")}) - ${Object.keys(lockfileResult.versions).length} packages`));
+	spinner.start("Finding files...");
+	const files = (await findFiles(config.includes, config.excludes)).filter((f) => !isDeclarationFile(f));
+	if (files.length === 0) {
+		spinner.fail(chalk.red(`No files found matching includes: ${config.includes.join(", ")}`));
+		return null;
+	}
+	spinner.succeed(chalk.green(` Found ${files.length} files`));
+	spinner.start("Analyzing files...");
+	const reports = [];
+	const parseErrors = [];
+	for (let i = 0; i < files.length; i++) {
+		const file = files[i];
+		spinner.text = `Analyzing files... (${i + 1}/${files.length})`;
+		try {
+			const report = parseFile(file);
+			if (report) reports.push(report);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			parseErrors.push({
+				file,
+				message
+			});
+		}
+	}
+	spinner.succeed(chalk.green(`Analysis complete! Analyzed ${reports.length}/${files.length} files`));
+	printErrors(parseErrors, isJson);
+	const aggregated = aggregateReports(reports, lockfileResult.versions, config, lockfileResult.multiVersions);
+	const evaluatorViolations = evaluateRules(process.cwd(), config.rules, config.excludes, files);
+	aggregated.ruleViolations = [...aggregated.ruleViolations, ...evaluatorViolations];
+	if (config.releaseAge.enabled) {
+		spinner.start("Fetching release age from registry...");
+		const { enriched, skipped } = await enrichWithReleaseAge(aggregated.packageDistribution, config.releaseAge);
+		aggregated.packageDistribution = enriched;
+		spinner.succeed(chalk.blue(`📅 Release age fetched${skipped > 0 ? chalk.gray(` (${skipped} packages skipped — registry unreachable or not found)`) : ""}`));
+	}
+	return aggregated;
+}
+//#endregion
+//#region src/commands/command-context.ts
+/**
+* Shared command preamble: routes human-readable chrome (version line,
+* spinner) to stderr when the command emits JSON on stdout.
+*/
+function createCommandContext(config, options = {}) {
+	applyColorLevel(resolveColorLevel({
+		colorFlag: options.color === false ? false : void 0,
+		noColorEnv: process.env["NO_COLOR"]
+	}));
+	const isJson = (options.format ?? config.output.format) === "json";
+	const stream = isJson ? process.stderr : process.stdout;
+	stream.write(chalk.gray(`hermex v${getVersion()}\n`));
+	return {
+		isJson,
+		spinner: ora({
+			text: "Parsing lockfile...",
+			stream
+		}).start()
+	};
+}
+//#endregion
 //#region src/commands/scan.ts
 function registerScanCommand(program) {
-	program.command("scan").description("Scan and analyze local files").option("--config <path>", "Path to hermex config file (overrides CWD discovery)").action(async (options) => {
-		await executeScan(await loadConfig(process.cwd(), options.config));
+	program.command("scan").description("Scan and analyze local files").option("--config <path>", "Path to hermex config file (overrides CWD discovery)").addOption(new Option("--format <format>", "Output format, overrides output.format in the config file").choices(["human", "json"])).option("--no-color", "Disable colored output (see also NO_COLOR env var)").action(async (options) => {
+		await executeScan(await loadConfig(process.cwd(), options.config), {
+			format: options.format,
+			color: options.color
+		});
 	});
 }
-async function executeScan(config) {
-	const startTime = Date.now();
-	const isJson = config.output.format === "json";
-	(isJson ? process.stderr : process.stdout).write(chalk.gray(`hermex v${getVersion()}\n`));
-	const spinner = ora({
-		text: "Parsing lockfile...",
-		stream: isJson ? process.stderr : process.stdout
-	}).start();
+async function executeScan(config, contextOptions = {}) {
+	const { isJson, spinner } = createCommandContext(config, contextOptions);
 	try {
-		const lockfileResult = findAndParseLockfile(process.cwd());
-		spinner.succeed(chalk.blue(`📦 Found ${lockfileResult.lockfileType} lockfile (supports: ${lockfileResult.supportedVersions.join(", ")}) - ${Object.keys(lockfileResult.versions).length} packages`));
-		spinner.start("Finding files...");
-		const files = await findFiles(config.includes, config.excludes);
-		if (files.length === 0) {
-			spinner.fail(chalk.red(`No files found matching includes: ${config.includes.join(", ")}`));
-			return;
-		}
-		spinner.succeed(chalk.green(` Found ${files.length} files`));
-		spinner.start("Analyzing files...");
-		const reports = [];
-		const parseErrors = [];
-		for (let i = 0; i < files.length; i++) {
-			const file = files[i];
-			spinner.text = `Analyzing files... (${i + 1}/${files.length})`;
-			try {
-				const report = parseFile(file);
-				if (report) reports.push(report);
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				parseErrors.push({
-					file,
-					message
-				});
-			}
-		}
-		spinner.succeed(chalk.green(`Analysis complete! Analyzed ${reports.length}/${files.length} files`));
-		printErrors(parseErrors);
-		const elapsedTime = (Date.now() - startTime) / 1e3;
-		const aggregated = aggregateReports(reports, lockfileResult.versions, config, lockfileResult.multiVersions);
-		const evaluatorViolations = evaluateRules(process.cwd(), config.rules, config.excludes);
-		aggregated.ruleViolations = [...aggregated.ruleViolations, ...evaluatorViolations];
-		if (config.releaseAge.enabled) {
-			spinner.start("Fetching release age from registry...");
-			const { enriched, skipped } = await enrichWithReleaseAge(aggregated.packageDistribution, config.releaseAge);
-			aggregated.packageDistribution = enriched;
-			spinner.succeed(chalk.blue(`📅 Release age fetched${skipped > 0 ? chalk.gray(` (${skipped} packages skipped — registry unreachable or not found)`) : ""}`));
-		}
+		const aggregated = await runPipeline(config, spinner, isJson);
+		if (!aggregated) return;
 		if (isJson) printJson(aggregated);
-		else printScanResults(aggregated, config, elapsedTime);
+		else printScanResults(aggregated, config);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		spinner.fail(chalk.red("Analysis failed: " + message));
-		console.error(error);
-		process.exit(1);
+		process.exitCode = 1;
 	}
 }
-function printScanResults(aggregated, config, _elapsedTime) {
+function printScanResults(aggregated, config) {
 	if (config.output.packages) printPackages(aggregated, config.output.packages);
 	if (config.output.versus) printVersus(aggregated);
 	if (config.output.rules) printRules(aggregated);
@@ -1888,10 +2303,81 @@ function printScanResults(aggregated, config, _elapsedTime) {
 	if (config.output.summary) printSummary(aggregated);
 }
 //#endregion
+//#region src/utils/print-compliance.ts
+/**
+* Prints only the bottom-line verdict — the Compliance and Packages sections
+* printed above this already itemize every violation (rule and release-age
+* alike), so repeating them here would just restate the same 🔴 rows.
+*/
+function printComplianceVerdict(result) {
+	const mandatoryCount = result.errorRuleViolations.length + result.errorBannedPackageViolations.length + result.mandatoryReleaseAgeViolations.length;
+	if (result.compliant) {
+		console.log(chalk.greenBright.bold(`\n${severityIcon("success")} COMPLIANT\n`));
+		return;
+	}
+	console.log(chalk.redBright.bold(`\n${severityIcon("error")} NOT COMPLIANT`));
+	console.log(chalk.red(`  ${mandatoryCount} mandatory violation${mandatoryCount > 1 ? "s" : ""} found`));
+	console.log();
+}
+//#endregion
+//#region src/utils/compliance.ts
+/**
+* A package is a mandatory compliance failure only when its releaseAge
+* severity is 'error' (i.e. it's in scope per `releaseAge.enforceOn`) AND
+* its worstLevel is 'mandatory_upgrade' — 'needs_upgrade' (patch/minor) is
+* advisory even for enforced packages, matching the existing "mandatory"
+* vocabulary already used by upgradeLevel().
+*/
+function computeCompliance(aggregated) {
+	const errorRuleViolations = aggregated.ruleViolations.filter((v) => v.severity === "error");
+	const errorBannedPackageViolations = aggregated.bannedPackageViolations.filter((v) => v.severity === "error");
+	const mandatoryReleaseAgeViolations = aggregated.packageDistribution.filter((p) => p.releaseAge?.severity === "error" && p.releaseAge?.worstLevel === "mandatory_upgrade");
+	return {
+		compliant: errorRuleViolations.length === 0 && errorBannedPackageViolations.length === 0 && mandatoryReleaseAgeViolations.length === 0,
+		errorRuleViolations,
+		errorBannedPackageViolations,
+		mandatoryReleaseAgeViolations
+	};
+}
+//#endregion
+//#region src/commands/comply.ts
+function registerComplyCommand(program) {
+	program.command("comply").description("Check compliance with hermex.config.ts rules and release-age policy (exits non-zero if not compliant)").option("--config <path>", "Path to hermex config file (overrides CWD discovery)").addOption(new Option("--format <format>", "Output format, overrides output.format in the config file").choices(["human", "json"])).option("--no-color", "Disable colored output (see also NO_COLOR env var)").action(async (options) => {
+		await executeComply(await loadConfig(process.cwd(), options.config), {
+			format: options.format,
+			color: options.color
+		});
+	});
+}
+async function executeComply(config, contextOptions = {}) {
+	const { isJson, spinner } = createCommandContext(config, contextOptions);
+	try {
+		const aggregated = await runPipeline(config, spinner, isJson);
+		if (!aggregated) {
+			process.exitCode = 2;
+			return;
+		}
+		const compliance = computeCompliance(aggregated);
+		if (isJson) printJson(aggregated);
+		else {
+			printRules(aggregated);
+			if (config.releaseAge.enabled) printPackages(aggregated, "table");
+			if (config.output.versus) printVersus(aggregated);
+			printComplianceVerdict(compliance);
+		}
+		process.exitCode = compliance.compliant ? 0 : 1;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		spinner.fail(chalk.red("Compliance check failed: " + message));
+		process.exitCode = 2;
+	}
+}
+//#endregion
 //#region src/cli.ts
 const program = new Command();
 program.name("hermex").description("Analyze React component usage patterns in your codebase").version(getVersion());
 registerScanCommand(program);
+registerComplyCommand(program);
 program.parse(process.argv);
 //#endregion
 export { program };