hermex 1.1.2 → 1.3.0-beta.1

package/dist/cli.mjs

@@ -0,0 +1,1848 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { parseSync } from "@swc/core";
+import fs, { existsSync } from "node:fs";
+import path, { join, resolve } from "node:path";
+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 yaml 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: {
+			directImports: /* @__PURE__ */ new Set(),
+			namedImports: /* @__PURE__ */ new Set(),
+			namespaceImports: /* @__PURE__ */ new Set(),
+			defaultImports: /* @__PURE__ */ new Set(),
+			aliasedImports: /* @__PURE__ */ new Map(),
+			variableAssignments: /* @__PURE__ */ new Map(),
+			componentMappings: /* @__PURE__ */ new Set(),
+			lazyImports: /* @__PURE__ */ new Set(),
+			dynamicImports: /* @__PURE__ */ new Set(),
+			conditionalUsage: /* @__PURE__ */ new Set(),
+			arrayMappings: /* @__PURE__ */ new Set(),
+			objectMappings: /* @__PURE__ */ new Set(),
+			hocUsage: /* @__PURE__ */ new Set(),
+			renderProps: /* @__PURE__ */ new Set(),
+			contextUsage: /* @__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);
+	if (node.callee?.type === "Import") analyzeDynamicImport(node, state);
+	if (isHOCPattern(node, state)) analyzeHOCUsage(node, state);
+	if (node.callee?.object?.value === "React") {
+		if (node.callee?.property?.value === "memo") analyzeMemoUsage(node, state);
+		else if (node.callee?.property?.value === "forwardRef") analyzeForwardRefUsage(node, state);
+	}
+	if (node.callee?.property?.value === "createPortal" || node.callee?.value === "createPortal") analyzePortalUsage(node, state);
+	visitChildren(node, state, context);
+}
+/**
+* Visits all children of a node
+*/
+function visitChildren(node, state, context) {
+	if (!node) return;
+	for (const key in node) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item === "object") visitNode(item, state, {
+				...context,
+				parent: node
+			});
+		} else if (value && typeof value === "object" && value.type) visitNode(value, state, {
+			...context,
+			parent: node
+		});
+	}
+}
+//#endregion
+//#region src/swc-parser/core/report.ts
+/**
+* Generates a comprehensive usage report from parser state
+*/
+function generateReport(state) {
+	return {
+		summary: {
+			totalImports: state.usagePatterns.defaultImports.size + state.usagePatterns.namedImports.size + state.usagePatterns.namespaceImports.size,
+			totalComponents: state.componentNames.size,
+			totalUsagePatterns: calculateTotalPatterns(state)
+		},
+		patterns: {
+			imports: {
+				default: Array.from(state.usagePatterns.defaultImports),
+				named: Array.from(state.usagePatterns.namedImports),
+				namespace: Array.from(state.usagePatterns.namespaceImports),
+				aliased: Array.from(state.usagePatterns.aliasedImports.values())
+			},
+			usage: {
+				jsx: Array.from(state.usagePatterns.jsxUsage.values()),
+				variables: Array.from(state.usagePatterns.variableAssignments.entries()).map(([key, value]) => ({
+					variable: key,
+					assignment: value.assignment
+				})),
+				destructuring: Array.from(state.usagePatterns.destructuredUsage),
+				conditional: Array.from(state.usagePatterns.conditionalUsage),
+				arrays: Array.from(state.usagePatterns.arrayMappings),
+				objects: Array.from(state.usagePatterns.objectMappings)
+			},
+			advanced: {
+				lazy: Array.from(state.usagePatterns.lazyImports),
+				dynamic: Array.from(state.usagePatterns.dynamicImports),
+				hoc: Array.from(state.usagePatterns.hocUsage),
+				memo: Array.from(state.usagePatterns.memoizedComponents),
+				forwardRef: Array.from(state.usagePatterns.forwardedRefs),
+				portal: Array.from(state.usagePatterns.portalUsage)
+			},
+			props: Array.from(state.usagePatterns.propsAnalysis.entries()).map(([component, analysis]) => ({
+				component,
+				analysis
+			}))
+		},
+		components: Array.from(state.componentNames).sort()
+	};
+}
+/**
+* Calculates total number of usage patterns found
+*/
+function calculateTotalPatterns(state) {
+	let sum = 0;
+	const patterns = state.usagePatterns;
+	for (const key in patterns) {
+		const pattern = patterns[key];
+		if (pattern instanceof Set) sum += pattern.size;
+		else if (pattern instanceof Map) sum += pattern.size;
+	}
+	return sum;
+}
+//#endregion
+//#region src/swc-parser/index.ts
+function swcOptionsForFile(filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	if (ext === ".ts") return {
+		syntax: "typescript",
+		tsx: false,
+		decorators: true,
+		dynamicImport: true
+	};
+	if (ext === ".tsx") return {
+		syntax: "typescript",
+		tsx: true,
+		decorators: true,
+		dynamicImport: true
+	};
+	if (ext === ".jsx") return {
+		syntax: "ecmascript",
+		jsx: true,
+		decorators: true,
+		importAssertions: true
+	};
+	return {
+		syntax: "ecmascript",
+		jsx: false,
+		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;
+}
+function resolvePackageFromImportPath(importPath, availablePackages) {
+	if (importPath.startsWith(".") || importPath.startsWith("/")) return "local";
+	const sortedPackages = [...availablePackages].sort((a, b) => b.length - a.length);
+	for (const pkg of sortedPackages) {
+		if (importPath === pkg) return pkg;
+		if (importPath.startsWith(`${pkg}/`)) return pkg;
+	}
+	return "unknown";
+}
+function findComponentSource(componentName, report, availablePackages) {
+	const namedImport = report.patterns.imports.named.find((imp) => imp.name === componentName);
+	if (namedImport) return resolvePackageFromImportPath(namedImport.source, availablePackages);
+	const defaultImport = report.patterns.imports.default.find((imp) => imp.name === componentName);
+	if (defaultImport) return resolvePackageFromImportPath(defaultImport.source, availablePackages);
+	const aliasedImport = report.patterns.imports.aliased.find((imp) => imp.local === componentName);
+	if (aliasedImport) return resolvePackageFromImportPath(aliasedImport.source, availablePackages);
+	return "unknown";
+}
+function 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("/")) {
+		const parts = packageName.split("/");
+		if (packageName.startsWith("@") && parts.length > 2) {
+			const basePackage = `${parts[0]}/${parts[1]}`;
+			if (versions[basePackage]) return versions[basePackage];
+		}
+		if (!packageName.startsWith("@") && parts.length > 1) {
+			if (versions[parts[0]]) return versions[parts[0]];
+		}
+	}
+	return null;
+}
+function calculatePackageDistribution(componentUsageMap, versions, config, multiVersions = {}) {
+	const ignorePatterns = config?.packages.ignore ?? [];
+	const internalPatterns = config?.packages.internal ?? [];
+	const packageMap = /* @__PURE__ */ new Map();
+	for (const component of componentUsageMap.values()) {
+		if (component.source === "unknown" || component.source === "local") continue;
+		if (ignorePatterns.length > 0 && micromatch.isMatch(component.source, ignorePatterns)) continue;
+		const existing = packageMap.get(component.source);
+		if (existing) {
+			existing.componentCount++;
+			existing.usageCount += component.count;
+			existing.components.push(component.name);
+		} else {
+			const isInternal = internalPatterns.length > 0 ? micromatch.isMatch(component.source, internalPatterns) : false;
+			const allVersions = multiVersions[component.source] ?? [];
+			const hasVersionConflict = allVersions.length > 1;
+			packageMap.set(component.source, {
+				packageName: component.source,
+				version: getPackageVersion(component.source, versions),
+				componentCount: 1,
+				usageCount: component.count,
+				percentage: 0,
+				components: [component.name],
+				internal: isInternal,
+				hasVersionConflict,
+				allVersions
+			});
+		}
+	}
+	const distribution = Array.from(packageMap.values());
+	const totalExternalUsage = distribution.reduce((sum, pkg) => sum + pkg.usageCount, 0);
+	for (const pkg of distribution) pkg.percentage = totalExternalUsage > 0 ? pkg.usageCount / totalExternalUsage * 100 : 0;
+	return distribution.sort((a, b) => b.usageCount - a.usageCount);
+}
+//#endregion
+//#region src/utils/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);
+}
+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());
+}
+function printComponentsChart(components) {
+	printHeader$2();
+	const externalComponents = components.filter((comp) => comp.source !== "unknown" && comp.source !== "local");
+	if (externalComponents.length === 0) {
+		console.log(chalk.gray("  No external components found"));
+		return;
+	}
+	renderBarChart(externalComponents.map((comp) => ({
+		label: comp.name,
+		value: comp.count
+	})), { maxWidth: 50 });
+}
+//#endregion
+//#region src/utils/print-patterns.ts
+function printHeader$1() {
+	console.log(chalk.blue.bold("\n🔍 Code Patterns\n"));
+}
+function printPatterns(aggregated, mode) {
+	const patterns = aggregated.patternCounts.filter((p) => p.count > 0);
+	if (mode === "table") printPatternsTable(patterns);
+	else if (mode === "chart") printPatternsChart(patterns);
+}
+function printPatternsTable(patterns) {
+	printHeader$1();
+	if (patterns.length === 0) {
+		console.log(chalk.gray("  No patterns found"));
+		return;
+	}
+	const table = new Table({
+		head: ["Pattern", "Count"],
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
+	});
+	patterns.forEach((pattern) => {
+		table.push([pattern.displayName, pattern.count.toString()]);
+	});
+	console.log(table.toString());
+	const totalPatterns = patterns.reduce((sum, p) => sum + p.count, 0);
+	console.log(chalk.gray(`\nTotal: ${totalPatterns} patterns detected`));
+}
+function printPatternsChart(patterns) {
+	printHeader$1();
+	if (patterns.length === 0) {
+		console.log(chalk.gray("  No patterns found"));
+		return;
+	}
+	renderBarChart(patterns.map((pattern) => ({
+		label: pattern.displayName,
+		value: pattern.count
+	})), { maxWidth: 50 });
+}
+//#endregion
+//#region src/utils/print-packages.ts
+function printHeader() {
+	console.log(chalk.blueBright.bold("\n📦 Packages\n"));
+}
+function formatPackageName(pkg, banned) {
+	let prefix = "";
+	if (pkg.releaseAge?.deprecated) prefix += chalk.red("[DEPRECATED] ");
+	if (banned) prefix += banned.severity === "error" ? chalk.red("[BANNED] ") : chalk.yellow("[RESTRICTED] ");
+	else if (pkg.internal) prefix += chalk.yellow("[int] ");
+	return prefix + pkg.packageName;
+}
+function formatUpgradeCell(releaseAge) {
+	if (!releaseAge) return "";
+	const { worstLevel, upgrades } = releaseAge;
+	if (!worstLevel) return chalk.green("✓");
+	const top = upgrades[0];
+	if (!top) return chalk.green("✓");
+	if (worstLevel === "mandatory_upgrade") return chalk.red(`⚠ ${top.semverBump} ${top.version} (${top.releasedDaysAgo}d)`);
+	return chalk.yellow(`↑ ${top.semverBump} ${top.version} (${top.releasedDaysAgo}d)`);
+}
+function getBannedViolation(pkg, violations) {
+	return violations.find((v) => v.packageName === pkg.packageName);
+}
+function printPackages(aggregated, mode) {
+	const packages = aggregated.packageDistribution;
+	const violations = aggregated.bannedPackageViolations;
+	if (mode === "table") printPackagesTable(packages, violations);
+	else if (mode === "chart") printPackagesChart(packages, violations);
+}
+function printPackagesTable(packages, violations) {
+	printHeader();
+	if (packages.length === 0) {
+		console.log(chalk.gray("  No packages found"));
+		return;
+	}
+	const hasReleaseAge = packages.some((p) => p.releaseAge !== void 0);
+	const head = [
+		"Package",
+		"Version",
+		"Components",
+		"Usage",
+		"Percentage"
+	];
+	if (hasReleaseAge) head.push("Upgrades");
+	const table = new Table({
+		head,
+		style: {
+			head: ["cyan"],
+			border: ["gray"]
+		}
+	});
+	packages.forEach((pkg) => {
+		const versionCell = pkg.hasVersionConflict ? chalk.yellow(`⚠ ${pkg.allVersions.join(", ")} (multiple — bundle impact)`) : pkg.version || "N/A";
+		const row = [
+			formatPackageName(pkg, getBannedViolation(pkg, violations)),
+			versionCell,
+			formatCount(pkg.componentCount),
+			formatCount(pkg.usageCount),
+			`${pkg.percentage.toFixed(1)}%`
+		];
+		if (hasReleaseAge) row.push(formatUpgradeCell(pkg.releaseAge));
+		table.push(row);
+	});
+	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;
+	}
+	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/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;
+}
+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 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/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("⚠");
+}
+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 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}`);
+		}
+	}
+	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/utils/print-errors.ts
+function printErrors(errors) {
+	if (errors.length === 0) return;
+	console.log(chalk.yellow(`\n⚠ ${errors.length} file(s) failed to parse:`));
+	for (const { file, message } of errors) {
+		console.log(chalk.yellow(`  ${file}`));
+		console.log(chalk.gray(`    ${message}`));
+	}
+	console.log("");
+}
+//#endregion
+//#region src/utils/file-utils.ts
+/**
+* Find files matching a glob pattern
+* @param pattern - Glob pattern
+* @param ignorePatterns - Glob pattenrs to ignore
+* @returns Array of file paths
+*/
+async function findFiles(pattern, ignorePatterns) {
+	return await glob(pattern, {
+		ignore: ignorePatterns,
+		nodir: true,
+		absolute: true,
+		windowsPathsNoEscape: true
+	});
+}
+//#endregion
+//#region src/lock-parser/patterns/npm.ts
+function canonicalPackageName(pkgPath) {
+	const idx = pkgPath.lastIndexOf("node_modules/");
+	if (idx === -1) return pkgPath;
+	return pkgPath.slice(idx + 13);
+}
+var NpmLockfileAdapter = class {
+	name = "npm";
+	supportedVersions = ["v2", "v3"];
+	detect(projectPath) {
+		const lockfilePath = path$1.join(projectPath, "package-lock.json");
+		return fs$1.existsSync(lockfilePath) ? lockfilePath : null;
+	}
+	parse(lockFilePath) {
+		try {
+			const content = fs$1.readFileSync(lockFilePath, "utf8");
+			const lockData = JSON.parse(content);
+			const versions = {};
+			if (lockData.packages) Object.entries(lockData.packages).forEach(([pkgPath, pkgData]) => {
+				if (!pkgPath || pkgPath === "") return;
+				if (pkgPath.split("node_modules/").length > 2) return;
+				const pkgName = canonicalPackageName(pkgPath);
+				if (pkgData.version) versions[pkgName] = pkgData.version;
+			});
+			if (lockData.dependencies && Object.keys(versions).length === 0) {
+				function extractVersions(deps, prefix = "") {
+					Object.entries(deps).forEach(([name, data]) => {
+						const fullName = prefix ? `${prefix}/${name}` : name;
+						if (data.version) versions[fullName] = data.version;
+						if (data.dependencies) extractVersions(data.dependencies, fullName);
+					});
+				}
+				extractVersions(lockData.dependencies);
+			}
+			return versions;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`Warning: Could not parse package-lock.json: ${message}`);
+			return {};
+		}
+	}
+	parseMultiVersion(lockFilePath) {
+		try {
+			const content = fs$1.readFileSync(lockFilePath, "utf8");
+			const lockData = JSON.parse(content);
+			const versionSets = {};
+			if (lockData.packages) Object.entries(lockData.packages).forEach(([pkgPath, pkgData]) => {
+				if (!pkgPath || pkgPath === "") return;
+				const pkgName = canonicalPackageName(pkgPath);
+				const version = pkgData.version;
+				if (!version) return;
+				if (!versionSets[pkgName]) versionSets[pkgName] = /* @__PURE__ */ new Set();
+				versionSets[pkgName].add(version);
+			});
+			const result = {};
+			for (const [pkg, versions] of Object.entries(versionSets)) result[pkg] = Array.from(versions).sort();
+			return result;
+		} catch {
+			return {};
+		}
+	}
+};
+//#endregion
+//#region src/lock-parser/patterns/pnpm.ts
+var PnpmLockfileAdapter = class {
+	name = "pnpm";
+	supportedVersions = [
+		"v5",
+		"v6",
+		"v9"
+	];
+	detect(projectPath) {
+		const lockfilePath = path$1.join(projectPath, "pnpm-lock.yaml");
+		return fs$1.existsSync(lockfilePath) ? lockfilePath : null;
+	}
+	parse(lockFilePath) {
+		try {
+			const content = fs$1.readFileSync(lockFilePath, "utf8");
+			const lockData = yaml.load(content);
+			const versions = {};
+			if (lockData.importers) {
+				const rootImporter = lockData.importers["."];
+				if (rootImporter) {
+					if (rootImporter.dependencies) {
+						for (const [name, data] of Object.entries(rootImporter.dependencies)) if (typeof data === "object" && data !== null && "version" in data) versions[name] = data.version;
+					}
+					if (rootImporter.devDependencies) {
+						for (const [name, data] of Object.entries(rootImporter.devDependencies)) if (typeof data === "object" && data !== null && "version" in data) versions[name] = data.version;
+					}
+				}
+			}
+			if (lockData.packages && Object.keys(versions).length === 0) Object.keys(lockData.packages).forEach((key) => {
+				const match = key.match(/\/(.+?)\/(\d+\.\d+\.\d+.*?)(?:_|$)/);
+				if (match) {
+					const [, pkgName, version] = match;
+					versions[pkgName] = version;
+				}
+			});
+			if (lockData.dependencies && Object.keys(versions).length === 0) Object.entries(lockData.dependencies).forEach(([name, versionSpec]) => {
+				if (typeof versionSpec === "string" && !versionSpec.startsWith("link:")) versions[name] = versionSpec;
+				else if (typeof versionSpec === "object" && versionSpec.version) versions[name] = versionSpec.version;
+			});
+			return versions;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`Warning: Could not parse pnpm-lock.yaml: ${message}`);
+			return {};
+		}
+	}
+};
+//#endregion
+//#region src/lock-parser/patterns/yarn.ts
+var YarnLockfileAdapter = class {
+	name = "yarn";
+	supportedVersions = ["v1", "v2+"];
+	detect(projectPath) {
+		const lockfilePath = path$1.join(projectPath, "yarn.lock");
+		return fs$1.existsSync(lockfilePath) ? lockfilePath : null;
+	}
+	parse(lockFilePath) {
+		try {
+			const content = fs$1.readFileSync(lockFilePath, "utf8");
+			const parsed = lockfile.parse(content);
+			if (parsed.type !== "success") {
+				console.warn("Warning: Failed to parse yarn.lock");
+				return {};
+			}
+			const versions = {};
+			Object.entries(parsed.object).forEach(([key, value]) => {
+				let pkgName = key;
+				if (key.startsWith("@")) {
+					const match = key.match(/^(@[^@]+\/[^@]+)@/);
+					if (match) pkgName = match[1];
+				} else {
+					const match = key.match(/^([^@]+)@/);
+					if (match) pkgName = match[1];
+				}
+				if (value.version && (!versions[pkgName] || value.version)) versions[pkgName] = value.version;
+			});
+			return versions;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.warn(`Warning: Could not parse yarn.lock: ${message}`);
+			return {};
+		}
+	}
+};
+//#endregion
+//#region src/lock-parser/index.ts
+const LOCKFILE_ADAPTERS = [
+	new NpmLockfileAdapter(),
+	new YarnLockfileAdapter(),
+	new PnpmLockfileAdapter()
+];
+/**
+* Find and parse the appropriate lockfile in a directory
+* @param projectPath - Path to the project directory
+* @returns Object with versions map and lockfile type
+*/
+function findAndParseLockfile(projectPath) {
+	for (const adapter of LOCKFILE_ADAPTERS) {
+		const lockfilePath = adapter.detect(projectPath);
+		if (lockfilePath) {
+			const versions = adapter.parse(lockfilePath);
+			const multiVersions = adapter.parseMultiVersion ? adapter.parseMultiVersion(lockfilePath) : {};
+			return {
+				versions,
+				multiVersions,
+				versionConflicts: Object.entries(multiVersions).filter(([, vers]) => vers.length > 1).map(([packageName, vers]) => ({
+					packageName,
+					versions: vers
+				})),
+				lockfileType: adapter.name,
+				lockfilePath,
+				supportedVersions: adapter.supportedVersions
+			};
+		}
+	}
+	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)
+	}).default(() => ({
+		summary: "log",
+		components: "table",
+		packages: "table",
+		patterns: "table",
+		details: false,
+		versus: true,
+		rules: true
+	})),
+	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) {
+	const configPath = join(cwd, "hermex.config.ts");
+	if (existsSync(configPath)) {
+		const mod = await import(pathToFileURL(resolve(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", "@")}`;
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), 1e4);
+	try {
+		const headers = { Accept: "application/json" };
+		if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+		const response = await fetch(url, {
+			headers,
+			signal: controller.signal
+		});
+		clearTimeout(timeoutId);
+		if (!response.ok) return null;
+		return await response.json();
+	} catch {
+		clearTimeout(timeoutId);
+		return null;
+	}
+}
+//#endregion
+//#region src/npm-registry/enricher.ts
+const CONCURRENCY = 8;
+function daysSince(dateStr) {
+	const ms = Date.now() - new Date(dateStr).getTime();
+	return Math.floor(ms / (1e3 * 60 * 60 * 24));
+}
+function classifyBump(installed, candidate) {
+	const diff = semver.diff(installed, candidate);
+	if (!diff) return null;
+	if (diff === "patch" || diff === "prepatch") return "patch";
+	if (diff === "minor" || diff === "preminor") return "minor";
+	if (diff === "major" || diff === "premajor") return "major";
+	return null;
+}
+function upgradeLevel(daysAgo, bump, thresholds) {
+	const threshold = thresholds[bump];
+	if (threshold === false || threshold === void 0) return null;
+	if (daysAgo > threshold) return bump === "major" ? "mandatory_upgrade" : "needs_upgrade";
+	return null;
+}
+function computeReleaseAge(installedVersion, timeMap, deprecated, thresholds) {
+	const upgrades = [];
+	for (const [version, dateStr] of Object.entries(timeMap)) {
+		if (version === "created" || version === "modified") continue;
+		if (!semver.valid(version)) continue;
+		if (semver.lte(version, installedVersion)) continue;
+		const bump = classifyBump(installedVersion, version);
+		if (!bump) continue;
+		const daysAgo = daysSince(dateStr);
+		const level = upgradeLevel(daysAgo, bump, thresholds);
+		if (!level) continue;
+		upgrades.push({
+			version,
+			releasedDaysAgo: 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);
+	return {
+		installedVersion,
+		upgrades: finalUpgrades,
+		worstLevel: finalUpgrades.some((u) => u.level === "mandatory_upgrade") ? "mandatory_upgrade" : finalUpgrades.length > 0 ? "needs_upgrade" : null,
+		deprecated
+	};
+}
+async function enrichWithReleaseAge(packages, config) {
+	const registryUrl = config.registry;
+	const targets = packages.filter((p) => !p.internal && p.version);
+	const enriched = [...packages];
+	let skipped = 0;
+	for (let i = 0; i < targets.length; i += CONCURRENCY) {
+		const batch = targets.slice(i, i + CONCURRENCY);
+		const results = await Promise.all(batch.map(async (pkg) => {
+			const info = await fetchPackageInfo(pkg.packageName, registryUrl, config.authToken);
+			if (!info || !info.time) {
+				skipped++;
+				return {
+					pkg,
+					entry: null
+				};
+			}
+			const deprecated = info.versions?.[pkg.version]?.deprecated ?? info.deprecated;
+			return {
+				pkg,
+				entry: computeReleaseAge(pkg.version, info.time, typeof deprecated === "string" ? deprecated : void 0, config.thresholds)
+			};
+		}));
+		for (const { pkg, entry } of results) {
+			if (!entry) continue;
+			const idx = enriched.findIndex((p) => p.packageName === pkg.packageName);
+			if (idx !== -1) enriched[idx] = {
+				...enriched[idx],
+				releaseAge: entry
+			};
+		}
+	}
+	return {
+		enriched,
+		skipped
+	};
+}
+//#endregion
+//#region src/commands/scan.ts
+function registerScanCommand(program) {
+	program.command("scan").description("Scan and analyze local files").action(async () => {
+		await executeScan(await loadConfig(process.cwd()));
+	});
+}
+async function executeScan(config) {
+	const startTime = Date.now();
+	const spinner = ora("Parsing lockfile...").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) {
+				parseErrors.push({
+					file,
+					message: error.message ?? String(error)
+				});
+			}
+		}
+		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)`) : ""}`));
+		}
+		printScanResults(aggregated, config, elapsedTime);
+	} catch (error) {
+		spinner.fail(chalk.red("Analysis failed: " + error.message));
+		console.error(error);
+		process.exit(1);
+	}
+}
+function printScanResults(aggregated, config, _elapsedTime) {
+	if (config.output.packages) printPackages(aggregated, config.output.packages);
+	if (config.output.versus) printVersus(aggregated);
+	if (config.output.rules) printRules(aggregated);
+	if (config.output.details) printDetails(aggregated);
+	if (config.output.components) printComponents(aggregated, config.output.components);
+	if (config.output.patterns) printPatterns(aggregated, config.output.patterns);
+	if (config.output.summary) printSummary(aggregated);
+}
+//#endregion
+//#region package.json
+var version = "1.2.0";
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+function defineConfig(config) {
+	return config;
+}
+program.name("hermex").description("Analyze React component usage patterns in your codebase").version(version);
+registerScanCommand(program);
+program.parse(process.argv);
+//#endregion
+export { defineConfig, program };
+
+//# sourceMappingURL=cli.mjs.map