hermex 1.3.0-beta.3 → 2.0.0-beta.1

package/dist/cli.mjs

@@ -2,540 +2,1038 @@
 import { Command } from "commander";
 import ora from "ora";
 import chalk from "chalk";
-import { parseSync } from "@swc/core";
-import fs, { existsSync } from "node:fs";
+import Table from "cli-table3";
+import fs, { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import path, { 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 { load } from "js-yaml";
 import lockfile from "@yarnpkg/lockfile";
-import { pathToFileURL } from "node:url";
-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()
-	};
-}
-//#endregion
-//#region src/swc-parser/patterns/imports.ts
+//#region src/utils/format-utils.ts
 /**
-* Analyzes import declarations and tracks all types:
-* - Default imports
-* - Named imports
-* - Namespace imports
-* - Aliased imports
+* Format a number with thousand separators
+* @param num - Number to format
+* @returns Formatted string (e.g., 1,234,567)
 */
-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 formatCount(num) {
+	return num.toLocaleString();
 }
-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);
+//#endregion
+//#region src/utils/print-summary.ts
+function printHeader$4() {
+	console.log(chalk.green.bold("\n📊 Summary\n"));
 }
-function analyzeNamespaceImport(spec, source, node, state) {
-	const name = spec.local.value;
-	state.usagePatterns.namespaceImports.add({
-		name,
-		source,
-		line: node.span?.start || 0
+function printSummary(aggregated) {
+	printHeader$4();
+	const table = new Table({
+		head: ["Metric", "Count"],
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
 	});
-	state.allIdentifiers.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 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/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/swc-parser/utils/jsx-helpers.ts
-/**
-* Extracts the name from a JSX element (handles identifiers and member expressions)
-*/
-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 "";
+//#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;
 	}
-}
-/**
-* Checks if a JSX member expression is a known component
-*/
-function isMemberExpressionComponent(nameNode, state) {
-	if (nameNode?.type === "JSXMemberExpression") {
-		const objectName = getJSXElementName(nameNode.object);
-		return state.allIdentifiers.has(objectName);
+	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`);
 	}
-	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-components.ts
+function printHeader$2() {
+	console.log(chalk.magenta.bold("\n⚛️ Components\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 printComponents(aggregated, mode) {
+	const components = aggregated.topComponents;
+	if (mode === "table") printComponentsTable(components);
+	else if (mode === "chart") printComponentsChart(components);
 }
-/**
-* 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 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"]
+		}
+	});
+	externalComponents.forEach((comp) => {
+		table.push([
+			comp.name,
+			comp.source,
+			comp.count.toString()
+		]);
+	});
+	console.log(table.toString());
 }
-/**
-* 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 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/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;
+//#region src/utils/print-patterns.ts
+function printHeader$1() {
+	console.log(chalk.blue.bold("\n🔍 Code Patterns\n"));
 }
-/**
-* 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 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"]
+		}
+	});
+	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`));
 }
-/**
-* 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 printPatternsChart(patterns) {
+	printHeader$1();
+	if (patterns.length === 0) {
+		console.log(chalk.gray("  No patterns found"));
+		return;
 	}
-	return false;
+	renderBarChart(patterns.map((pattern) => ({
+		label: pattern.displayName,
+		value: pattern.count
+	})), { maxWidth: 50 });
 }
 //#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-packages.ts
+function printHeader() {
+	console.log(chalk.blueBright.bold("\n📦 Packages\n"));
 }
-/**
-* 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 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;
 }
-//#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 formatUpgradeCell(releaseAge) {
+	if (!releaseAge) return "";
+	const { worstLevel, upgrades, severity } = releaseAge;
+	if (!worstLevel) return chalk.green("✓");
+	const top = upgrades[0];
+	if (!top) return chalk.green("✓");
+	const suffix = severity === "warn" ? chalk.gray(" [not enforced]") : "";
+	if (worstLevel === "mandatory_upgrade") return (severity === "warn" ? chalk.yellow : chalk.red)(`⚠ ${top.semverBump} ${top.version} (${top.releasedDaysAgo}d)`) + suffix;
+	return chalk.yellow(`↑ ${top.semverBump} ${top.version} (${top.releasedDaysAgo}d)`) + suffix;
 }
-//#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);
-	}
+function getBannedViolation(pkg, violations) {
+	return violations.find((v) => v.packageName === pkg.packageName);
 }
-/**
-* 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 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);
+	});
+	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`));
 }
-/**
-* 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;
+function printPackagesChart(packages, violations) {
+	printHeader();
+	if (packages.length === 0) {
+		console.log(chalk.gray("  No packages found"));
+		return;
 	}
+	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/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
-	});
+//#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 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 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;
 }
-//#endregion
-//#region src/swc-parser/patterns/lazy-dynamic.ts
-/**
-* Analyzes React.lazy() imports
-*/
-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 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();
 }
-/**
-* 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 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/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 });
+//#region src/utils/print-rules.ts
+function formatRuleType(type) {
+	switch (type) {
+		case "detect_files": return "detect_files";
+		case "require_files": return "require_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";
+	}
 }
-/**
-* Analyzes ReactDOM.createPortal() usage
-*/
-function analyzePortalUsage(node, state) {
-	state.usagePatterns.portalUsage.add({ line: node.span?.start || 0 });
+function ruleIcon(violation) {
+	if (violation.severity === "error") return chalk.red("✗");
+	if (violation.severity === "info") return chalk.blue("ℹ");
+	return chalk.yellow("⚠");
 }
-/**
-* 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);
+function describeViolation(v) {
+	const patterns = v.patterns.join(", ");
+	const suffix = v.message ? chalk.gray(` — ${v.message}`) : "";
+	if (v.type === "detect_files") return `${patterns} detected (${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 === "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}`;
 }
-/**
-* 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));
+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]") : v.severity === "info" ? chalk.blue("[INFO]") : 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}`);
+		}
+	}
+	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/core/visitor.ts
+//#region src/utils/version.ts
+let cachedVersion;
 /**
-* Main AST visitor that routes nodes to appropriate pattern analyzers
+* 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 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);
-			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;
+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 call expressions and routes to specific analyzers
+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");
+}
+//#endregion
+//#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 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({
+		detect_files: RuleConfigOrArraySchema.default([]),
+		require_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(() => ({
+		detect_files: [],
+		require_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
+		})),
+		enforceOn: z.array(z.string()).default([])
+	}).default(() => ({
+		enabled: false,
+		registry: "https://registry.npmjs.org",
+		thresholds: {
+			patch: 30,
+			minor: 45,
+			major: 60
+		},
+		enforceOn: []
+	}))
+});
+//#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 "ImportNamespaceSpecifier":
+			analyzeNamespaceImport(spec, source, node, state);
+			break;
+		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
+/**
+* Extracts the name from a JSX element (handles identifiers and member expressions)
+*/
+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 "";
+	}
+}
+/**
+* Checks if a JSX member expression is a known component
+*/
+function isMemberExpressionComponent(nameNode, state) {
+	if (nameNode?.type === "JSXMemberExpression") {
+		const objectName = getJSXElementName(nameNode.object);
+		return state.allIdentifiers.has(objectName);
+	}
+	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);
+}
+/**
+* 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]";
+	}
+}
+/**
+* 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]";
+	}
+}
+/**
+* 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/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;
+}
+/**
+* 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";
+	}
+}
+/**
+* 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";
+	}
+	return false;
+}
+//#endregion
+//#region src/swc-parser/patterns/jsx.ts
+/**
+* Analyzes JSX element usage
+*/
+function analyzeJSXElement(node, state) {
+	if (node.opening) analyzeJSXOpeningElement(node.opening, state, node);
+}
+/**
+* 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/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/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);
+	}
+}
+/**
+* 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/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
+	});
+}
+//#endregion
+//#region src/swc-parser/patterns/lazy-dynamic.ts
+/**
+* Analyzes React.lazy() imports
+*/
+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
+			});
+		}
+	}
+}
+/**
+* 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
+	});
+}
+//#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));
+}
+//#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);
+			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;
+	}
+}
+/**
+* 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);
@@ -645,251 +1143,21 @@ function swcOptionsForFile(filePath) {
 	};
 	return {
 		syntax: "ecmascript",
-		jsx: false,
+		jsx: true,
 		decorators: true,
 		importAssertions: true
 	};
 }
 function parseCode(code, filePath = "file.tsx") {
-	const state = createState();
-	visitNode(parseSync(code, swcOptionsForFile(filePath)), state);
-	return generateReport(state);
-}
-function parseFile(filePath) {
-	return parseCode(fs.readFileSync(filePath, "utf8"), filePath);
-}
-//#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) => path$1.join(repoPath, f)));
-	}
-	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/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;
-}
-//#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/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: []
-	}));
-}
-//#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 [];
-	});
-}
-//#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)
-	];
-}
-//#endregion
-//#region src/utils/aggregator.ts
-function toPercentage(count, total) {
-	return total > 0 ? count / total * 100 : 0;
-}
-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()
-				});
-			}
-		}
-		countPatterns(report, patternCountMap);
-	}
-	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
-	};
-}
-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
-		};
-	});
-}
-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 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;
+	const state = createState();
+	visitNode(parseSync(code, swcOptionsForFile(filePath)), state);
+	return generateReport(state);
+}
+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);
@@ -908,47 +1176,6 @@ function findComponentSource(componentName, report, availablePackages) {
 	if (aliasedImport) return resolvePackageFromImportPath(aliasedImport.source, availablePackages);
 	return "unknown";
 }
-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 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;
-}
 function getPackageVersion(packageName, versions) {
 	if (versions[packageName]) return versions[packageName];
 	if (packageName.includes("/")) {
@@ -998,347 +1225,276 @@ function calculatePackageDistribution(componentUsageMap, versions, config, multi
 	return distribution.sort((a, b) => b.usageCount - a.usageCount);
 }
 //#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)
-*/
-function formatCount(num) {
-	return num.toLocaleString();
-}
-//#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"]
-		}
-	});
-	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());
-}
-//#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);
+//#region src/rules/shared.ts
+function toArray(val) {
+	if (!val) return [];
+	return Array.isArray(val) ? val : [val];
 }
-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;
+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 table = new Table({
-		head: [
-			"Component",
-			"Package",
-			"Count"
-		],
-		style: {
-			head: ["cyan"],
-			border: ["gray"]
-		}
-	});
-	externalComponents.forEach((comp) => {
-		table.push([
-			comp.name,
-			comp.source,
-			comp.count.toString()
-		]);
-	});
-	console.log(table.toString());
+	return [...new Set(matches)];
 }
-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;
+function readPackageJson(repoPath) {
+	try {
+		const content = fs$1.readFileSync(path$1.join(repoPath, "package.json"), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
 	}
-	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;
+//#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: ["Pattern", "Count"],
-		style: {
-			head: ["cyan"],
-			border: ["gray"]
-		}
-	});
-	patterns.forEach((pattern) => {
-		table.push([pattern.displayName, pattern.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());
-	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 });
+	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)`);
+//#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: []
+	}));
 }
-function getBannedViolation(pkg, violations) {
-	return violations.find((v) => v.packageName === pkg.packageName);
+//#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: []
+	}));
 }
-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);
+//#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 [];
+	});
 }
-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"
+//#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)
 	];
-	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);
-	});
-	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/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;
 	}
-	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 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: []
 	});
+	return violations;
 }
 //#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));
-}
-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;
+//#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 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 increment(map, key, value) {
+	map.set(key, (map.get(key) || 0) + value);
 }
-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);
+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/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";
-	}
-}
-function ruleIcon(violation) {
-	if (violation.severity === "error") return chalk.red("✗");
-	return chalk.yellow("⚠");
+//#region src/utils/versus.ts
+function toPercentage(count, total) {
+	return total > 0 ? count / total * 100 : 0;
 }
-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}`;
+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
+		};
+	});
 }
-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}`);
+//#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()
+				});
+			}
 		}
+		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
@@ -1352,28 +1508,6 @@ function printErrors(errors) {
 	console.log("");
 }
 //#endregion
-//#region src/utils/print-json.ts
-function printJson(aggregated) {
-	const result = {
-		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/utils/file-utils.ts
 /**
 * Find files matching a glob pattern
@@ -1382,12 +1516,11 @@ function printJson(aggregated) {
 * @returns Array of file paths
 */
 async function findFiles(pattern, ignorePatterns) {
-	return await glob(pattern, {
+	return (await glob(pattern, {
 		ignore: ignorePatterns,
 		nodir: true,
-		absolute: true,
 		windowsPathsNoEscape: true
-	});
+	})).map((f) => f.replace(/\\/g, "/"));
 }
 //#endregion
 //#region src/lock-parser/patterns/npm.ts
@@ -1570,110 +1703,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", "@")}`;
@@ -1715,8 +1744,10 @@ function upgradeLevel(daysAgo, bump, thresholds) {
 	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;
@@ -1724,26 +1755,45 @@ function computeReleaseAge(installedVersion, timeMap, deprecated, thresholds) {
 		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.patch;
+		if (bump === "patch" && 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 = versions.reduce((a, b) => a.daysAgo < b.daysAgo ? a : b);
 		upgrades.push({
-			version,
-			releasedDaysAgo: daysAgo,
+			version: newest.version,
+			releasedDaysAgo: newest.daysAgo,
 			semverBump: bump,
 			level
 		});
 	}
-	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 = Array.from(worstPerBump.values()).sort((a, b) => b.releasedDaysAgo - a.releasedDaysAgo);
+	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;
 	return {
 		installedVersion,
 		upgrades: finalUpgrades,
 		worstLevel: finalUpgrades.some((u) => u.level === "mandatory_upgrade") ? "mandatory_upgrade" : finalUpgrades.length > 0 ? "needs_upgrade" : null,
-		deprecated
+		deprecated,
+		latestVersion,
+		latestReleasedDaysAgo,
+		minCompliantVersion,
+		minCompliantReleasedDaysAgo,
+		severity
 	};
 }
 async function enrichWithReleaseAge(packages, config) {
@@ -1764,9 +1814,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) {
@@ -1784,6 +1835,53 @@ async function enrichWithReleaseAge(packages, config) {
 	};
 }
 //#endregion
+//#region src/commands/pipeline.ts
+/**
+* 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) {
+	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 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);
+	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)`) : ""}`));
+	}
+	return aggregated;
+}
+//#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) => {
@@ -1791,53 +1889,17 @@ function registerScanCommand(program) {
 	});
 }
 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();
 	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);
+		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));
@@ -1845,7 +1907,7 @@ async function executeScan(config) {
 		process.exit(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);
@@ -1855,13 +1917,85 @@ function printScanResults(aggregated, config, _elapsedTime) {
 	if (config.output.summary) printSummary(aggregated);
 }
 //#endregion
-//#region package.json
-var version = "1.3.0-beta.2";
+//#region src/utils/print-compliance.ts
+function printComplianceVerdict(result) {
+	const mandatoryCount = result.errorRuleViolations.length + result.errorBannedPackageViolations.length + result.mandatoryReleaseAgeViolations.length;
+	if (result.compliant) {
+		console.log(chalk.greenBright.bold("\n✓ COMPLIANT\n"));
+		return;
+	}
+	console.log(chalk.redBright.bold(`\n✗ NOT COMPLIANT`));
+	console.log(chalk.red(`  ${mandatoryCount} mandatory violation${mandatoryCount > 1 ? "s" : ""} found`));
+	if (result.mandatoryReleaseAgeViolations.length > 0) {
+		console.log();
+		for (const pkg of result.mandatoryReleaseAgeViolations) {
+			const top = pkg.releaseAge?.upgrades[0];
+			console.log(chalk.red(`  ✗  releaseAge     ${pkg.packageName} is ${top?.semverBump} version behind (${top?.releasedDaysAgo}d) — mandatory upgrade  [ERROR]`));
+		}
+	}
+	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)").action(async (options) => {
+		await executeComply(await loadConfig(process.cwd(), options.config));
+	});
+}
+async function executeComply(config) {
+	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();
+	try {
+		const aggregated = await runPipeline(config, spinner);
+		if (!aggregated) {
+			process.exitCode = 2;
+			return;
+		}
+		const compliance = computeCompliance(aggregated);
+		if (isJson) printJson(aggregated);
+		else {
+			printRules(aggregated);
+			if (config.releaseAge.enabled) printPackages(aggregated, "table");
+			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));
+		console.error(error);
+		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(version);
+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 };