hermex 0.0.1-alpha.0 → 1.0.0

package/dist/cli.js

@@ -3,2694 +3,1307 @@
 
 var commander = require('commander');
 var glob = require('glob');
-var chalk8 = require('chalk');
-var ora6 = require('ora');
-var path = require('path');
-var Table2 = require('cli-table3');
+var ora = require('ora');
+var chalk = require('chalk');
 var core = require('@swc/core');
-var fs5 = require('fs');
-var simpleGit = require('simple-git');
-var tmp = require('tmp');
-var yaml = require('js-yaml');
-var lockfile = require('@yarnpkg/lockfile');
+var fs = require('fs');
+var path = require('path');
+var Table = require('cli-table3');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
-var ora6__default = /*#__PURE__*/_interopDefault(ora6);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
 var path__default = /*#__PURE__*/_interopDefault(path);
-var Table2__default = /*#__PURE__*/_interopDefault(Table2);
-var fs5__default = /*#__PURE__*/_interopDefault(fs5);
-var simpleGit__default = /*#__PURE__*/_interopDefault(simpleGit);
-var tmp__default = /*#__PURE__*/_interopDefault(tmp);
-var yaml__default = /*#__PURE__*/_interopDefault(yaml);
-var lockfile__default = /*#__PURE__*/_interopDefault(lockfile);
+var Table__default = /*#__PURE__*/_interopDefault(Table);
 
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var ReactComponentUsageAnalyzer = class {
-  constructor(libraryName = "@design-system/foundation") {
-    this.libraryName = libraryName;
-    this.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()
-    };
-    this.componentNames = /* @__PURE__ */ new Set();
-    this.allIdentifiers = /* @__PURE__ */ new Set();
-  }
-  analyzeFile(filePath) {
-    console.log(`
-\u{1F4C1} Analyzing: ${filePath}`);
-    try {
-      const code = fs5__default.default.readFileSync(filePath, "utf8");
-      const ast = core.parseSync(code, {
-        syntax: "typescript",
-        tsx: true,
-        decorators: true,
-        dynamicImport: true
-      });
-      this.visitNode(ast);
-      return this.generateReport();
-    } catch (error) {
-      console.error(`\u274C Error parsing ${filePath}:`, error.message);
-      return null;
-    }
-  }
-  visitNode(node, parent = null) {
-    if (!node) return;
-    switch (node.type) {
-      case "Module":
-        node.body.forEach((item) => this.visitNode(item, node));
-        break;
-      case "ImportDeclaration":
-        this.analyzeImport(node);
-        break;
-      case "CallExpression":
-        this.analyzeCallExpression(node, parent);
-        break;
-      case "VariableDeclaration":
-        this.analyzeVariableDeclaration(node);
-        break;
-      case "JSXElement":
-      case "JSXFragment":
-        this.analyzeJSXElement(node, parent);
-        break;
-      case "JSXOpeningElement":
-        this.analyzeJSXOpeningElement(node, parent);
-        break;
-      case "ArrayExpression":
-        this.analyzeArrayExpression(node, parent);
-        break;
-      case "ObjectExpression":
-        this.analyzeObjectExpression(node, parent);
-        break;
-      case "MemberExpression":
-        this.analyzeMemberExpression(node, parent);
-        break;
-      case "ConditionalExpression":
-        this.analyzeConditionalExpression(node, parent);
-        break;
-      case "FunctionDeclaration":
-      case "FunctionExpression":
-      case "ArrowFunctionExpression":
-        this.analyzeFunctionDeclaration(node);
+// src/swc-parser/core/state.ts
+function createState() {
+  const 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()
+  };
+  return {
+    usagePatterns,
+    componentNames: /* @__PURE__ */ new Set(),
+    allIdentifiers: /* @__PURE__ */ new Set()
+  };
+}
+
+// src/swc-parser/patterns/imports.ts
+function analyzeImportDeclaration(node, state) {
+  const source = node.source.value;
+  console.log(`\u{1F4E6} Found import: ${source}`);
+  for (const spec of node.specifiers) {
+    switch (spec.type) {
+      case "ImportDefaultSpecifier":
+        analyzeDefaultImport(spec, source, node, state);
         break;
-      case "ClassDeclaration":
-        this.analyzeClassDeclaration(node);
+      case "ImportNamespaceSpecifier":
+        analyzeNamespaceImport(spec, source, node, state);
         break;
-      default:
-        this.visitChildren(node);
+      case "ImportSpecifier":
+        analyzeNamedImport(spec, source, node, state);
         break;
     }
   }
-  visitChildren(node) {
-    if (!node || typeof node !== "object") return;
-    for (const key in node) {
-      const value = node[key];
-      if (Array.isArray(value)) {
-        value.forEach((child) => this.visitNode(child, node));
-      } else if (value && typeof value === "object" && value.type) {
-        this.visitNode(value, node);
-      }
-    }
-  }
-  analyzeImport(node) {
-    const source = node.source.value;
-    if (!this.isLibraryImport(source)) return;
-    console.log(`\u{1F4E6} Found library import: ${source}`);
-    node.specifiers.forEach((spec) => {
-      var _a, _b, _c, _d;
-      switch (spec.type) {
-        case "ImportDefaultSpecifier":
-          this.usagePatterns.defaultImports.add({
-            name: spec.local.value,
-            source,
-            line: ((_a = node.span) == null ? void 0 : _a.start) || 0
-          });
-          this.componentNames.add(spec.local.value);
-          break;
-        case "ImportNamespaceSpecifier":
-          this.usagePatterns.namespaceImports.add({
-            name: spec.local.value,
-            source,
-            line: ((_b = node.span) == null ? void 0 : _b.start) || 0
-          });
-          this.allIdentifiers.add(spec.local.value);
-          break;
-        case "ImportSpecifier":
-          const importedName = spec.imported ? spec.imported.value : spec.local.value;
-          const localName = spec.local.value;
-          this.usagePatterns.namedImports.add({
-            imported: importedName,
-            local: localName,
-            source,
-            line: ((_c = node.span) == null ? void 0 : _c.start) || 0
-          });
-          if (importedName !== localName) {
-            this.usagePatterns.aliasedImports.set(localName, {
-              original: importedName,
-              source,
-              line: ((_d = node.span) == null ? void 0 : _d.start) || 0
-            });
-          }
-          this.componentNames.add(localName);
-          break;
-      }
+}
+function analyzeDefaultImport(spec, source, node, state) {
+  var _a;
+  const name = spec.local.value;
+  state.usagePatterns.defaultImports.add({
+    name,
+    source,
+    line: ((_a = node.span) == null ? void 0 : _a.start) || 0
+  });
+  state.componentNames.add(name);
+}
+function analyzeNamespaceImport(spec, source, node, state) {
+  var _a;
+  const name = spec.local.value;
+  state.usagePatterns.namespaceImports.add({
+    name,
+    source,
+    line: ((_a = node.span) == null ? void 0 : _a.start) || 0
+  });
+  state.allIdentifiers.add(name);
+}
+function analyzeNamedImport(spec, source, node, state) {
+  var _a, _b;
+  const importedName = spec.imported ? spec.imported.value : spec.local.value;
+  const localName = spec.local.value;
+  state.usagePatterns.namedImports.add({
+    name: importedName,
+    source,
+    line: ((_a = node.span) == null ? void 0 : _a.start) || 0
+  });
+  if (importedName !== localName) {
+    state.usagePatterns.aliasedImports.set(localName, {
+      imported: importedName,
+      local: localName,
+      source,
+      line: ((_b = node.span) == null ? void 0 : _b.start) || 0
     });
   }
-  analyzeCallExpression(node, parent) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
-    if (((_a = node.callee) == null ? void 0 : _a.value) === "lazy" || ((_c = (_b = node.callee) == null ? void 0 : _b.object) == null ? void 0 : _c.value) === "React" && ((_e = (_d = node.callee) == null ? void 0 : _d.property) == null ? void 0 : _e.value) === "lazy") {
-      this.analyzeLazyImport(node);
-    }
-    if (((_f = node.callee) == null ? void 0 : _f.type) === "Import") {
-      this.analyzeDynamicImport(node);
-    }
-    if (this.isHOCPattern(node)) {
-      this.analyzeHOCUsage(node);
-    }
-    if (((_h = (_g = node.callee) == null ? void 0 : _g.object) == null ? void 0 : _h.value) === "React") {
-      if (((_j = (_i = node.callee) == null ? void 0 : _i.property) == null ? void 0 : _j.value) === "memo") {
-        this.analyzeMemoUsage(node);
-      } else if (((_l = (_k = node.callee) == null ? void 0 : _k.property) == null ? void 0 : _l.value) === "forwardRef") {
-        this.analyzeForwardRefUsage(node);
-      }
+  state.componentNames.add(localName);
+}
+
+// src/swc-parser/utils/jsx-helpers.ts
+function getJSXElementName(nameNode) {
+  if (!nameNode) return "";
+  switch (nameNode.type) {
+    case "Identifier":
+      return nameNode.value;
+    case "JSXMemberExpression":
+      return `${getJSXElementName(nameNode.object)}.${nameNode.property.value}`;
+    default:
+      return "";
+  }
+}
+function isMemberExpressionComponent(nameNode, state) {
+  if ((nameNode == null ? void 0 : nameNode.type) === "JSXMemberExpression") {
+    const objectName = getJSXElementName(nameNode.object);
+    return state.allIdentifiers.has(objectName);
+  }
+  return false;
+}
+function extractJSXProps(attributes) {
+  if (!attributes) return [];
+  return attributes.map((attr) => {
+    var _a, _b, _c;
+    if (attr.type === "JSXAttribute") {
+      return {
+        name: ((_a = attr.name) == null ? void 0 : _a.value) || ((_c = (_b = attr.name) == null ? void 0 : _b.name) == null ? void 0 : _c.value),
+        value: extractJSXAttributeValue(attr.value)
+      };
     }
-    if (((_n = (_m = node.callee) == null ? void 0 : _m.property) == null ? void 0 : _n.value) === "createPortal" || ((_o = node.callee) == null ? void 0 : _o.value) === "createPortal") {
-      this.analyzePortalUsage(node);
+    if (attr.type === "SpreadElement") {
+      return {
+        name: "...",
+        value: "[spread]",
+        isSpread: true
+      };
     }
-    this.visitChildren(node);
-  }
-  analyzeLazyImport(node) {
-    var _a, _b, _c, _d, _e, _f;
-    const arg = (_a = node.arguments) == null ? void 0 : _a[0];
-    if ((arg == null ? void 0 : arg.type) === "ArrowFunctionExpression" && ((_b = arg.body) == null ? void 0 : _b.type) === "CallExpression") {
-      const importCall = arg.body;
-      if (((_c = importCall.callee) == null ? void 0 : _c.type) === "Import") {
-        const source = (_e = (_d = importCall.arguments) == null ? void 0 : _d[0]) == null ? void 0 : _e.value;
-        if (this.isLibraryImport(source)) {
-          this.usagePatterns.lazyImports.add({
-            source,
-            line: ((_f = node.span) == null ? void 0 : _f.start) || 0
-          });
-          console.log(`\u{1F504} Found lazy import: ${source}`);
+    return null;
+  }).filter(Boolean);
+}
+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 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 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";
+  }
+}
+
+// src/swc-parser/patterns/props.ts
+function analyzePropsInDetail(attributes, componentName, state) {
+  var _a, _b, _c;
+  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 = ((_a = attr.name) == null ? void 0 : _a.value) || ((_c = (_b = attr.name) == null ? void 0 : _b.name) == null ? void 0 : _c.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);
       }
-    }
-  }
-  analyzeDynamicImport(node) {
-    var _a, _b, _c;
-    const source = (_b = (_a = node.arguments) == null ? void 0 : _a[0]) == null ? void 0 : _b.value;
-    if (this.isLibraryImport(source)) {
-      this.usagePatterns.dynamicImports.add({
-        source,
-        line: ((_c = node.span) == null ? void 0 : _c.start) || 0
+    } 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"
       });
-      console.log(`\u26A1 Found dynamic import: ${source}`);
+      analysis.hasComplexProps = true;
     }
   }
-  analyzeVariableDeclaration(node) {
-    var _a;
-    (_a = node.declarations) == null ? void 0 : _a.forEach((decl) => {
-      var _a2, _b, _c;
-      if (((_a2 = decl.id) == null ? void 0 : _a2.type) === "Identifier") {
-        const varName = decl.id.value;
-        if (decl.init) {
-          const assignment = this.extractAssignmentInfo(decl.init);
-          if (assignment && this.isLibraryComponent(assignment)) {
-            this.usagePatterns.variableAssignments.set(varName, {
-              assignment,
-              line: ((_b = node.span) == null ? void 0 : _b.start) || 0
-            });
-            this.componentNames.add(varName);
-            console.log(`\u{1F4DD} Variable assignment: ${varName} = ${assignment}`);
-          }
-        }
-      }
-      if (((_c = decl.id) == null ? void 0 : _c.type) === "ObjectPattern") {
-        this.analyzeDestructuringPattern(decl.id, decl.init);
+  state.usagePatterns.propsAnalysis.set(componentName, analysis);
+  return analysis;
+}
+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";
       }
-    });
-    this.visitChildren(node);
-  }
-  analyzeDestructuringPattern(pattern, init) {
-    var _a;
-    (_a = pattern.properties) == null ? void 0 : _a.forEach((prop) => {
-      var _a2, _b;
-      if (prop.type === "AssignmentPatternProperty" && ((_a2 = prop.key) == null ? void 0 : _a2.type) === "Identifier") {
-        const propName = prop.key.value;
-        if ((init == null ? void 0 : init.type) === "Identifier" && this.allIdentifiers.has(init.value)) {
-          this.usagePatterns.destructuredUsage.add({
-            property: propName,
-            source: init.value,
-            line: ((_b = pattern.span) == null ? void 0 : _b.start) || 0
+    }
+    default:
+      return "unknown";
+  }
+}
+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;
+}
+
+// src/swc-parser/patterns/jsx.ts
+function analyzeJSXElement(node, state) {
+  if (node.opening) {
+    analyzeJSXOpeningElement(node.opening, state, node);
+  }
+}
+function analyzeJSXOpeningElement(node, state, parent) {
+  var _a;
+  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: ((_a = node.span) == null ? void 0 : _a.start) || 0,
+    context: getUsageContext(parent)
+  };
+  if (!state.usagePatterns.jsxUsage.has(elementName)) {
+    state.usagePatterns.jsxUsage.set(elementName, usage);
+  }
+  console.log(`\u{1F3A8} JSX Usage: <${elementName}>`);
+}
+
+// src/swc-parser/utils/matchers.ts
+function isKnownComponent(name, state) {
+  return state.componentNames.has(name) || state.allIdentifiers.has(name);
+}
+
+// src/swc-parser/patterns/variables.ts
+function analyzeVariableDeclaration(node, state) {
+  var _a, _b, _c;
+  if (!node.declarations) return;
+  for (const decl of node.declarations) {
+    if (((_a = decl.id) == null ? void 0 : _a.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: ((_b = node.span) == null ? void 0 : _b.start) || 0
           });
-          this.componentNames.add(propName);
-          console.log(`\u{1F527} Destructuring: ${propName} from ${init.value}`);
+          state.componentNames.add(varName);
+          console.log(`\u{1F4DD} Variable assignment: ${varName} = ${assignment}`);
         }
       }
-    });
-  }
-  analyzeJSXElement(node, parent) {
-    if (node.opening) {
-      this.analyzeJSXOpeningElement(node.opening, node);
     }
-    this.visitChildren(node);
-  }
-  analyzeJSXOpeningElement(node, parent) {
-    var _a;
-    const elementName = this.getJSXElementName(node.name);
-    if (this.componentNames.has(elementName) || this.isMemberExpressionComponent(node.name)) {
-      const propsAnalysis = this.analyzePropsInDetail(node.attributes);
-      const usage = {
-        component: elementName,
-        props: this.extractJSXProps(node.attributes),
-        propsAnalysis,
-        line: ((_a = node.span) == null ? void 0 : _a.start) || 0,
-        context: this.getUsageContext(parent)
-      };
-      if (!this.usagePatterns.jsxUsage.has(elementName)) {
-        this.usagePatterns.jsxUsage.set(elementName, []);
-      }
-      this.usagePatterns.jsxUsage.get(elementName).push(usage);
-      if (!this.usagePatterns.propsAnalysis.has(elementName)) {
-        this.usagePatterns.propsAnalysis.set(elementName, {
-          namedProps: /* @__PURE__ */ new Set(),
-          spreadProps: 0,
-          totalUsages: 0,
-          complexProps: 0
+    if (((_c = decl.id) == null ? void 0 : _c.type) === "ObjectPattern") {
+      analyzeDestructuringPattern(decl.id, decl.init, state);
+    }
+  }
+}
+function analyzeDestructuringPattern(pattern, init, state) {
+  var _a, _b;
+  if (!pattern.properties) return;
+  for (const prop of pattern.properties) {
+    if (prop.type === "AssignmentPatternProperty" && ((_a = prop.key) == null ? void 0 : _a.type) === "Identifier") {
+      const propName = prop.key.value;
+      if ((init == null ? void 0 : init.type) === "Identifier" && state.allIdentifiers.has(init.value)) {
+        state.usagePatterns.destructuredUsage.add({
+          property: propName,
+          source: init.value,
+          line: ((_b = pattern.span) == null ? void 0 : _b.start) || 0
         });
+        state.componentNames.add(propName);
+        console.log(`\u{1F527} Destructuring: ${propName} from ${init.value}`);
       }
-      const componentPropsStats = this.usagePatterns.propsAnalysis.get(elementName);
-      componentPropsStats.totalUsages++;
-      propsAnalysis.namedProps.forEach(
-        (prop) => componentPropsStats.namedProps.add(prop)
-      );
-      if (propsAnalysis.hasSpread) componentPropsStats.spreadProps++;
-      if (propsAnalysis.hasComplexProps) componentPropsStats.complexProps++;
-      console.log(`\u{1F3A8} JSX Usage: <${elementName}>`);
     }
   }
-  getJSXElementName(nameNode) {
-    if (!nameNode) return "";
-    switch (nameNode.type) {
-      case "Identifier":
-        return nameNode.value;
-      case "JSXMemberExpression":
-        return `${this.getJSXElementName(nameNode.object)}.${nameNode.property.value}`;
-      default:
-        return "";
-    }
+}
+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;
+  }
+}
+
+// src/swc-parser/patterns/conditionals.ts
+function analyzeConditionalExpression(node, state) {
+  var _a, _b, _c;
+  const consequent = ((_a = node.consequent) == null ? void 0 : _a.type) === "Identifier" ? node.consequent.value : null;
+  const alternate = ((_b = node.alternate) == null ? void 0 : _b.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: ((_c = node.span) == null ? void 0 : _c.start) || 0
+    });
+    console.log("\u{1F500} Conditional component usage found");
   }
-  isMemberExpressionComponent(nameNode) {
-    if ((nameNode == null ? void 0 : nameNode.type) === "JSXMemberExpression") {
-      const objectName = this.getJSXElementName(nameNode.object);
-      return this.allIdentifiers.has(objectName);
+}
+
+// src/swc-parser/patterns/collections.ts
+function analyzeArrayExpression(node, state) {
+  var _a, _b, _c;
+  const hasComponents = (_a = node.elements) == null ? void 0 : _a.some((elem) => {
+    if ((elem == null ? void 0 : elem.type) === "Identifier") {
+      return state.componentNames.has(elem.value);
     }
     return false;
+  });
+  if (hasComponents) {
+    state.usagePatterns.arrayMappings.add({
+      components: (_b = node.elements) == null ? void 0 : _b.map((elem) => elem == null ? void 0 : elem.value).filter(Boolean),
+      line: ((_c = node.span) == null ? void 0 : _c.start) || 0
+    });
+    console.log("\u{1F4CB} Array with components found");
   }
-  extractJSXProps(attributes) {
-    if (!attributes) return [];
-    return attributes.map((attr) => {
-      var _a, _b, _c;
-      if (attr.type === "JSXAttribute") {
-        return {
-          name: ((_a = attr.name) == null ? void 0 : _a.value) || ((_c = (_b = attr.name) == null ? void 0 : _b.name) == null ? void 0 : _c.value),
-          value: this.extractJSXAttributeValue(attr.value)
-        };
-      } else if (attr.type === "SpreadElement") {
+}
+function analyzeObjectExpression(node, state) {
+  var _a, _b;
+  const componentProps = (_a = node.properties) == null ? void 0 : _a.filter((prop) => {
+    var _a2;
+    if (prop.type === "KeyValueProperty" && ((_a2 = prop.value) == null ? void 0 : _a2.type) === "Identifier") {
+      return state.componentNames.has(prop.value.value);
+    }
+    return false;
+  });
+  if ((componentProps == null ? void 0 : componentProps.length) > 0) {
+    state.usagePatterns.objectMappings.add({
+      mappings: componentProps.map((prop) => {
+        var _a2, _b2;
         return {
-          name: "...",
-          value: "[spread]",
-          isSpread: true
+          key: ((_a2 = prop.key) == null ? void 0 : _a2.value) || "[computed]",
+          component: (_b2 = prop.value) == null ? void 0 : _b2.value
         };
-      }
-      return null;
-    }).filter(Boolean);
-  }
-  extractJSXAttributeValue(value) {
-    if (!value) return true;
-    switch (value.type) {
-      case "StringLiteral":
-        return value.value;
-      case "JSXExpressionContainer":
-        return this.extractExpressionValue(value.expression);
-      default:
-        return "[complex]";
-    }
-  }
-  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]";
-    }
+      }),
+      line: ((_b = node.span) == null ? void 0 : _b.start) || 0
+    });
+    console.log("\u{1F5FA}\uFE0F  Object mapping with components found");
   }
-  analyzePropsInDetail(attributes) {
-    const analysis = {
-      namedProps: /* @__PURE__ */ new Set(),
-      hasSpread: false,
-      hasComplexProps: false,
-      hasEventHandlers: false,
-      propDetails: []
-    };
-    if (!attributes) return analysis;
-    attributes.forEach((attr) => {
-      var _a, _b, _c;
-      if (attr.type === "JSXAttribute") {
-        const propName = ((_a = attr.name) == null ? void 0 : _a.value) || ((_c = (_b = attr.name) == null ? void 0 : _b.name) == null ? void 0 : _c.value);
-        if (propName) {
-          analysis.namedProps.add(propName);
-          const propDetail = {
-            name: propName,
-            type: this.getPropType(attr.value),
-            isEventHandler: propName.startsWith("on"),
-            isComplex: this.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,
-          warning: "Spread props cannot be statically analyzed"
+}
+
+// src/swc-parser/patterns/lazy-dynamic.ts
+function analyzeLazyImport(node, state) {
+  var _a, _b, _c, _d, _e, _f;
+  const arg = (_a = node.arguments) == null ? void 0 : _a[0];
+  if ((arg == null ? void 0 : arg.type) === "ArrowFunctionExpression" && ((_b = arg.body) == null ? void 0 : _b.type) === "CallExpression") {
+    const importCall = arg.body;
+    if (((_c = importCall.callee) == null ? void 0 : _c.type) === "Import") {
+      const source = (_e = (_d = importCall.arguments) == null ? void 0 : _d[0]) == null ? void 0 : _e.value;
+      if (source) {
+        state.usagePatterns.lazyImports.add({
+          source,
+          line: ((_f = node.span) == null ? void 0 : _f.start) || 0
         });
-        analysis.hasComplexProps = true;
+        console.log(`\u{1F504} Found lazy import: ${source}`);
       }
-    });
-    return analysis;
-  }
-  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";
     }
   }
-  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;
+}
+function analyzeDynamicImport(node, state) {
+  var _a, _b, _c;
+  const source = (_b = (_a = node.arguments) == null ? void 0 : _a[0]) == null ? void 0 : _b.value;
+  if (source) {
+    state.usagePatterns.dynamicImports.add({
+      source,
+      line: ((_c = node.span) == null ? void 0 : _c.start) || 0
+    });
+    console.log(`\u26A1 Found dynamic import: ${source}`);
   }
-  analyzeArrayExpression(node, parent) {
-    var _a, _b, _c;
-    const hasComponents = (_a = node.elements) == null ? void 0 : _a.some((elem) => {
-      if ((elem == null ? void 0 : elem.type) === "Identifier") {
-        return this.componentNames.has(elem.value);
-      }
-      return false;
+}
+
+// src/swc-parser/patterns/advanced.ts
+function analyzeHOCUsage(node, state) {
+  var _a, _b, _c, _d;
+  state.usagePatterns.hocUsage.add({
+    function: ((_a = node.callee) == null ? void 0 : _a.value) || "[unknown]",
+    component: ((_c = (_b = node.arguments) == null ? void 0 : _b[0]) == null ? void 0 : _c.value) || "[unknown]",
+    line: ((_d = node.span) == null ? void 0 : _d.start) || 0
+  });
+  console.log(`\u{1F381} HOC usage found`);
+}
+function analyzeMemoUsage(node, state) {
+  var _a, _b;
+  const component = (_a = node.arguments) == null ? void 0 : _a[0];
+  if ((component == null ? void 0 : component.type) === "Identifier" && state.componentNames.has(component.value)) {
+    state.usagePatterns.memoizedComponents.add({
+      component: component.value,
+      line: ((_b = node.span) == null ? void 0 : _b.start) || 0
     });
-    if (hasComponents) {
-      this.usagePatterns.arrayMappings.add({
-        components: (_b = node.elements) == null ? void 0 : _b.map((elem) => elem == null ? void 0 : elem.value).filter(Boolean),
-        line: ((_c = node.span) == null ? void 0 : _c.start) || 0
-      });
-      console.log(`\u{1F4CB} Array with components found`);
+    console.log(`\u{1F9E0} Memoized component: ${component.value}`);
+  }
+}
+function analyzeForwardRefUsage(node, state) {
+  var _a;
+  state.usagePatterns.forwardedRefs.add({
+    line: ((_a = node.span) == null ? void 0 : _a.start) || 0
+  });
+  console.log("\u2197\uFE0F ForwardRef usage found");
+}
+function analyzePortalUsage(node, state) {
+  var _a;
+  state.usagePatterns.portalUsage.add({
+    line: ((_a = node.span) == null ? void 0 : _a.start) || 0
+  });
+  console.log("\u{1F300} Portal usage found");
+}
+function analyzeMemberExpression(node, state) {
+  var _a, _b;
+  if (((_a = node.object) == null ? void 0 : _a.type) === "Identifier" && state.allIdentifiers.has(node.object.value)) {
+    const namespaceName = node.object.value;
+    const propertyName = (_b = node.property) == null ? void 0 : _b.value;
+    if (propertyName) {
+      state.componentNames.add(propertyName);
+      console.log(`\u{1F517} Namespace access: ${namespaceName}.${propertyName}`);
     }
-    this.visitChildren(node);
-  }
-  analyzeObjectExpression(node, parent) {
-    var _a, _b;
-    const componentProps = (_a = node.properties) == null ? void 0 : _a.filter((prop) => {
-      var _a2;
-      if (prop.type === "KeyValueProperty" && ((_a2 = prop.value) == null ? void 0 : _a2.type) === "Identifier") {
-        return this.componentNames.has(prop.value.value);
+  }
+}
+function isHOCPattern(node, state) {
+  var _a, _b;
+  return ((_a = node.callee) == null ? void 0 : _a.type) === "Identifier" && ((_b = node.arguments) == null ? void 0 : _b.some(
+    (arg) => arg.type === "Identifier" && state.componentNames.has(arg.value)
+  ));
+}
+
+// src/swc-parser/core/visitor.ts
+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 });
+          }
+        }
       }
-      return false;
-    });
-    if ((componentProps == null ? void 0 : componentProps.length) > 0) {
-      this.usagePatterns.objectMappings.add({
-        mappings: componentProps.map((prop) => {
-          var _a2, _b2;
-          return {
-            key: ((_a2 = prop.key) == null ? void 0 : _a2.value) || "[computed]",
-            component: (_b2 = prop.value) == null ? void 0 : _b2.value
-          };
-        }),
-        line: ((_b = node.span) == null ? void 0 : _b.start) || 0
-      });
-      console.log(`\u{1F5FA}\uFE0F  Object mapping with components found`);
-    }
-    this.visitChildren(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;
   }
-  analyzeConditionalExpression(node, parent) {
-    var _a, _b, _c;
-    const consequent = ((_a = node.consequent) == null ? void 0 : _a.type) === "Identifier" ? node.consequent.value : null;
-    const alternate = ((_b = node.alternate) == null ? void 0 : _b.type) === "Identifier" ? node.alternate.value : null;
-    if (consequent && this.componentNames.has(consequent) || alternate && this.componentNames.has(alternate)) {
-      this.usagePatterns.conditionalUsage.add({
-        consequent,
-        alternate,
-        line: ((_c = node.span) == null ? void 0 : _c.start) || 0
-      });
-      console.log(`\u{1F500} Conditional component usage found`);
-    }
-    this.visitChildren(node);
+}
+function analyzeCallExpression(node, state, context) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  if (((_a = node.callee) == null ? void 0 : _a.value) === "lazy" || ((_c = (_b = node.callee) == null ? void 0 : _b.object) == null ? void 0 : _c.value) === "React" && ((_e = (_d = node.callee) == null ? void 0 : _d.property) == null ? void 0 : _e.value) === "lazy") {
+    analyzeLazyImport(node, state);
   }
-  analyzeFunctionDeclaration(node) {
-    var _a, _b, _c;
-    if (this.isHOCFunction(node)) {
-      this.usagePatterns.hocUsage.add({
-        name: ((_a = node.identifier) == null ? void 0 : _a.value) || "[anonymous]",
-        line: ((_b = node.span) == null ? void 0 : _b.start) || 0
-      });
-      console.log(`\u{1F527} HOC function found: ${(_c = node.identifier) == null ? void 0 : _c.value}`);
-    }
-    this.visitChildren(node);
-  }
-  analyzeClassDeclaration(node) {
-    this.visitChildren(node);
-  }
-  isHOCPattern(node) {
-    var _a, _b;
-    return ((_a = node.callee) == null ? void 0 : _a.type) === "Identifier" && ((_b = node.arguments) == null ? void 0 : _b.some(
-      (arg) => arg.type === "Identifier" && this.componentNames.has(arg.value)
-    ));
-  }
-  isHOCFunction(node) {
-    const params = node.params || [];
-    return params.some((param) => {
-      var _a;
-      return ((_a = param.pat) == null ? void 0 : _a.type) === "Identifier";
-    });
+  if (((_f = node.callee) == null ? void 0 : _f.type) === "Import") {
+    analyzeDynamicImport(node, state);
   }
-  analyzeHOCUsage(node) {
-    var _a, _b, _c, _d;
-    this.usagePatterns.hocUsage.add({
-      function: (_a = node.callee) == null ? void 0 : _a.value,
-      component: (_c = (_b = node.arguments) == null ? void 0 : _b[0]) == null ? void 0 : _c.value,
-      line: ((_d = node.span) == null ? void 0 : _d.start) || 0
-    });
+  if (isHOCPattern(node, state)) {
+    analyzeHOCUsage(node, state);
   }
-  analyzeMemoUsage(node) {
-    var _a, _b;
-    const component = (_a = node.arguments) == null ? void 0 : _a[0];
-    if ((component == null ? void 0 : component.type) === "Identifier" && this.componentNames.has(component.value)) {
-      this.usagePatterns.memoizedComponents.add({
-        component: component.value,
-        line: ((_b = node.span) == null ? void 0 : _b.start) || 0
-      });
-      console.log(`\u{1F9E0} Memoized component: ${component.value}`);
+  if (((_h = (_g = node.callee) == null ? void 0 : _g.object) == null ? void 0 : _h.value) === "React") {
+    if (((_j = (_i = node.callee) == null ? void 0 : _i.property) == null ? void 0 : _j.value) === "memo") {
+      analyzeMemoUsage(node, state);
+    } else if (((_l = (_k = node.callee) == null ? void 0 : _k.property) == null ? void 0 : _l.value) === "forwardRef") {
+      analyzeForwardRefUsage(node, state);
     }
   }
-  analyzeForwardRefUsage(node) {
-    var _a;
-    this.usagePatterns.forwardedRefs.add({
-      line: ((_a = node.span) == null ? void 0 : _a.start) || 0
-    });
-    console.log(`\u2197\uFE0F  ForwardRef usage found`);
+  if (((_n = (_m = node.callee) == null ? void 0 : _m.property) == null ? void 0 : _n.value) === "createPortal" || ((_o = node.callee) == null ? void 0 : _o.value) === "createPortal") {
+    analyzePortalUsage(node, state);
   }
-  analyzePortalUsage(node) {
-    var _a;
-    this.usagePatterns.portalUsage.add({
-      line: ((_a = node.span) == null ? void 0 : _a.start) || 0
-    });
-    console.log(`\u{1F300} Portal usage found`);
-  }
-  analyzeMemberExpression(node, parent) {
-    var _a, _b;
-    if (((_a = node.object) == null ? void 0 : _a.type) === "Identifier" && this.allIdentifiers.has(node.object.value)) {
-      const namespaceName = node.object.value;
-      const propertyName = (_b = node.property) == null ? void 0 : _b.value;
-      if (propertyName) {
-        this.componentNames.add(propertyName);
-        console.log(`\u{1F517} Namespace access: ${namespaceName}.${propertyName}`);
+  visitChildren(node, state, context);
+}
+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 });
+        }
       }
-    }
-    this.visitChildren(node);
-  }
-  extractAssignmentInfo(node) {
-    switch (node.type) {
-      case "Identifier":
-        return node.value;
-      case "MemberExpression":
-        return `${this.extractAssignmentInfo(node.object)}.${node.property.value}`;
-      case "ConditionalExpression":
-        return `${this.extractAssignmentInfo(node.consequent)} | ${this.extractAssignmentInfo(node.alternate)}`;
-      default:
-        return null;
+    } else if (value && typeof value === "object" && value.type) {
+      visitNode(value, state, { ...context, parent: node });
     }
   }
-  getUsageContext(parent) {
-    if (!parent) return "unknown";
-    switch (parent.type) {
-      case "JSXElement":
-        return "jsx";
-      case "CallExpression":
-        return "function-call";
-      case "ArrayExpression":
-        return "array";
-      case "ConditionalExpression":
-        return "conditional";
-      default:
-        return "other";
-    }
+}
+
+// src/swc-parser/core/report.ts
+function generateReport(state) {
+  const report = {
+    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()
+  };
+  return report;
+}
+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;
+}
+
+// src/swc-parser/index.ts
+function parseCode(code, options = {}) {
+  const state = createState();
+  const ast = core.parseSync(code, {
+    syntax: "typescript",
+    tsx: true,
+    decorators: true,
+    dynamicImport: true
+  });
+  visitNode(ast, state);
+  const report = generateReport(state);
+  if (options.libraryName) {
+    return filterReportByLibrary(report, options.libraryName);
   }
-  isLibraryImport(source) {
-    return source && (source.startsWith(this.libraryName) || source.includes(this.libraryName));
-  }
-  isLibraryComponent(name) {
-    return this.componentNames.has(name) || this.allIdentifiers.has(name);
-  }
-  generateReport() {
-    const report = {
-      summary: {
-        totalImports: this.usagePatterns.defaultImports.size + this.usagePatterns.namedImports.size + this.usagePatterns.namespaceImports.size,
-        totalComponents: this.componentNames.size,
-        totalUsagePatterns: Object.keys(this.usagePatterns).reduce(
-          (sum, key) => {
-            const pattern = this.usagePatterns[key];
-            if (pattern instanceof Set) return sum + pattern.size;
-            if (pattern instanceof Map) return sum + pattern.size;
-            return sum;
-          },
-          0
+  return report;
+}
+function parseFile(filePath, options = {}) {
+  console.log(`
+\u{1F4C1} Analyzing: ${filePath}`);
+  try {
+    const code = fs__default.default.readFileSync(filePath, "utf8");
+    return parseCode(code, options);
+  } catch (error) {
+    console.error(`\u274C Error parsing ${filePath}:`, error.message);
+    return null;
+  }
+}
+function filterReportByLibrary(report, libraryName) {
+  const isFromLibrary = (source) => source.startsWith(libraryName) || source.includes(libraryName);
+  return {
+    ...report,
+    patterns: {
+      imports: {
+        default: report.patterns.imports.default.filter(
+          (imp) => isFromLibrary(imp.source)
+        ),
+        named: report.patterns.imports.named.filter(
+          (imp) => isFromLibrary(imp.source)
+        ),
+        namespace: report.patterns.imports.namespace.filter(
+          (imp) => isFromLibrary(imp.source)
+        ),
+        aliased: report.patterns.imports.aliased.filter(
+          (imp) => isFromLibrary(imp.source)
         )
       },
-      patterns: {
-        imports: {
-          default: Array.from(this.usagePatterns.defaultImports),
-          named: Array.from(this.usagePatterns.namedImports),
-          namespace: Array.from(this.usagePatterns.namespaceImports),
-          aliased: Array.from(this.usagePatterns.aliasedImports.entries()).map(
-            ([key, value]) => ({
-              alias: key,
-              ...value
-            })
-          )
-        },
-        usage: {
-          jsx: Array.from(this.usagePatterns.jsxUsage.entries()).map(
-            ([component, usages]) => ({
-              component,
-              count: usages.length,
-              usages
-            })
-          ),
-          variables: Array.from(
-            this.usagePatterns.variableAssignments.entries()
-          ).map(([key, value]) => ({
-            variable: key,
-            ...value
-          })),
-          destructuring: Array.from(this.usagePatterns.destructuredUsage),
-          conditional: Array.from(this.usagePatterns.conditionalUsage),
-          arrays: Array.from(this.usagePatterns.arrayMappings),
-          objects: Array.from(this.usagePatterns.objectMappings)
-        },
-        advanced: {
-          lazy: Array.from(this.usagePatterns.lazyImports),
-          dynamic: Array.from(this.usagePatterns.dynamicImports),
-          hoc: Array.from(this.usagePatterns.hocUsage),
-          memo: Array.from(this.usagePatterns.memoizedComponents),
-          forwardRef: Array.from(this.usagePatterns.forwardedRefs),
-          portal: Array.from(this.usagePatterns.portalUsage)
-        },
-        props: Array.from(this.usagePatterns.propsAnalysis.entries()).map(
-          ([component, stats]) => ({
-            component,
-            namedProps: Array.from(stats.namedProps),
-            spreadPropsCount: stats.spreadProps,
-            totalUsages: stats.totalUsages,
-            complexPropsCount: stats.complexProps,
-            spreadWarning: stats.spreadProps > 0 ? `${stats.spreadProps} usage(s) with spread props - cannot analyze statically` : null
-          })
-        )
+      usage: report.patterns.usage,
+      advanced: {
+        lazy: report.patterns.advanced.lazy.filter(
+          (imp) => isFromLibrary(imp.source)
+        ),
+        dynamic: report.patterns.advanced.dynamic.filter(
+          (imp) => isFromLibrary(imp.source)
+        ),
+        hoc: report.patterns.advanced.hoc,
+        memo: report.patterns.advanced.memo,
+        forwardRef: report.patterns.advanced.forwardRef,
+        portal: report.patterns.advanced.portal
       },
-      components: Array.from(this.componentNames).sort()
-    };
-    return report;
-  }
-  printReport(report) {
-    console.log("\n" + "=".repeat(80));
-    console.log("\u{1F4CA} REACT COMPONENT USAGE ANALYSIS REPORT");
-    console.log("=".repeat(80));
-    console.log(`
-\u{1F4C8} SUMMARY:`);
-    console.log(`   Total Imports: ${report.summary.totalImports}`);
-    console.log(`   Components Found: ${report.summary.totalComponents}`);
-    console.log(`   Usage Patterns: ${report.summary.totalUsagePatterns}`);
-    console.log(`
-\u{1F4E6} IMPORT PATTERNS:`);
-    if (report.patterns.imports.default.length > 0) {
-      console.log(
-        `   Default Imports (${report.patterns.imports.default.length}):`
-      );
-      report.patterns.imports.default.forEach((imp) => {
-        console.log(`     - ${imp.name} from "${imp.source}"`);
-      });
-    }
-    if (report.patterns.imports.named.length > 0) {
-      console.log(
-        `   Named Imports (${report.patterns.imports.named.length}):`
-      );
-      report.patterns.imports.named.forEach((imp) => {
-        console.log(
-          `     - {${imp.imported}${imp.imported !== imp.local ? ` as ${imp.local}` : ""}} from "${imp.source}"`
-        );
-      });
+      props: report.patterns.props
     }
-    if (report.patterns.imports.namespace.length > 0) {
-      console.log(
-        `   Namespace Imports (${report.patterns.imports.namespace.length}):`
-      );
-      report.patterns.imports.namespace.forEach((imp) => {
-        console.log(`     - * as ${imp.name} from "${imp.source}"`);
-      });
+  };
+}
+
+// src/utils/aggregator.ts
+function aggregateReports(reports) {
+  const componentUsageMap = /* @__PURE__ */ new Map();
+  let totalImports = 0;
+  let totalUsagePatterns = 0;
+  const patternCountMap = /* @__PURE__ */ new Map();
+  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);
+        componentUsageMap.set(key, {
+          name: jsx.component,
+          source,
+          count: 1,
+          files: /* @__PURE__ */ new Set()
+        });
+      }
     }
-    if (report.patterns.imports.aliased.length > 0) {
+    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);
+  return {
+    filesAnalyzed: reports.length,
+    totalImports,
+    totalComponents: componentUsageMap.size,
+    totalUsagePatterns,
+    patternCounts,
+    componentUsage: componentUsageMap,
+    topComponents,
+    allComponents,
+    reports
+  };
+}
+function findComponentSource(componentName, report) {
+  const namedImport = report.patterns.imports.named.find(
+    (imp) => imp.name === componentName
+  );
+  if (namedImport) return namedImport.source;
+  const defaultImport = report.patterns.imports.default.find(
+    (imp) => imp.name === componentName
+  );
+  if (defaultImport) return defaultImport.source;
+  const aliasedImport = report.patterns.imports.aliased.find(
+    (imp) => imp.local === componentName
+  );
+  if (aliasedImport) return aliasedImport.source;
+  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) {
+  const displayNames = {
+    "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"
+  };
+  return displayNames[patternType] || patternType;
+}
+function printVerbose(filePath, report) {
+  const relativePath = path__default.default.relative(process.cwd(), filePath);
+  console.log(chalk__default.default.gray(`[VERBOSE] Analyzing: ${relativePath}`));
+  for (const jsx of report.patterns.usage.jsx) {
+    console.log(chalk__default.default.gray(`[VERBOSE] Found JSX Usage: <${jsx.component}>`));
+  }
+  for (const imp of report.patterns.imports.named) {
+    console.log(
+      chalk__default.default.gray(`[VERBOSE] Found import: ${imp.name} from ${imp.source}`)
+    );
+  }
+  for (const imp of report.patterns.imports.default) {
+    console.log(
+      chalk__default.default.gray(
+        `[VERBOSE] Found default import: ${imp.name} from ${imp.source}`
+      )
+    );
+  }
+  for (const imp of report.patterns.imports.namespace) {
+    console.log(
+      chalk__default.default.gray(
+        `[VERBOSE] Found namespace import: ${imp.name} from ${imp.source}`
+      )
+    );
+  }
+  for (const imp of report.patterns.imports.aliased) {
+    console.log(
+      chalk__default.default.gray(
+        `[VERBOSE] Found aliased import: ${imp.imported} as ${imp.local} from ${imp.source}`
+      )
+    );
+  }
+  for (const obj of report.patterns.usage.objects) {
+    for (const mapping of obj.mappings) {
       console.log(
-        `   Aliased Imports (${report.patterns.imports.aliased.length}):`
+        chalk__default.default.gray(
+          `[VERBOSE] Found Object mapping with Component: ${mapping.component}`
+        )
       );
-      report.patterns.imports.aliased.forEach((imp) => {
-        console.log(
-          `     - ${imp.alias} (originally ${imp.original}) from "${imp.source}"`
-        );
-      });
     }
-    console.log(`
-\u{1F3A8} JSX USAGE PATTERNS:`);
-    report.patterns.usage.jsx.forEach((usage) => {
-      console.log(
-        `   Component: ${usage.component} (used ${usage.count} times)`
-      );
-      usage.usages.slice(0, 3).forEach((use, idx) => {
-        const props = use.props.length > 0 ? ` with ${use.props.length} props` : "";
-        console.log(
-          `     ${idx + 1}. <${usage.component}${props}> (line ~${use.line})`
-        );
-      });
-      if (usage.usages.length > 3) {
-        console.log(`     ... and ${usage.usages.length - 3} more`);
-      }
-    });
-    if (report.patterns.usage.variables.length > 0) {
-      console.log(`
-\u{1F4DD} VARIABLE ASSIGNMENTS:`);
-      report.patterns.usage.variables.forEach((variable) => {
-        console.log(`   ${variable.variable} = ${variable.assignment}`);
-      });
-    }
-    if (report.patterns.advanced.lazy.length > 0) {
-      console.log(`
-\u{1F504} LAZY LOADING:`);
-      report.patterns.advanced.lazy.forEach((lazy) => {
-        console.log(`   - Lazy import from "${lazy.source}"`);
-      });
-    }
-    if (report.patterns.advanced.dynamic.length > 0) {
-      console.log(`
-\u26A1 DYNAMIC IMPORTS:`);
-      report.patterns.advanced.dynamic.forEach((dynamic) => {
-        console.log(`   - Dynamic import from "${dynamic.source}"`);
-      });
-    }
-    if (report.patterns.usage.conditional.length > 0) {
-      console.log(`
-\u{1F500} CONDITIONAL USAGE:`);
-      report.patterns.usage.conditional.forEach((cond) => {
-        console.log(
-          `   - ${cond.consequent || "null"} ? ${cond.alternate || "null"}`
-        );
-      });
-    }
-    console.log(`
-\u{1F9E9} COMPONENTS IDENTIFIED:`);
-    report.components.forEach((comp) => {
-      console.log(`   - ${comp}`);
-    });
-    console.log("\n" + "=".repeat(80));
-  }
-};
-var FocusedUsageAnalyzer = class extends ReactComponentUsageAnalyzer {
-  constructor(libraryName = "@design-system/foundation") {
-    super(libraryName);
-    this.patternMap = /* @__PURE__ */ new Map();
-    this.componentFrequency = /* @__PURE__ */ new Map();
-    this.usageComplexity = /* @__PURE__ */ new Map();
-  }
-  analyzePatterns() {
-    const patterns = {
-      "Direct Import & Usage": {
-        weight: 1,
-        description: "Simple import and direct JSX usage",
-        examples: ['import Button from "lib"; <Button />']
-      },
-      "Named Import with Alias": {
-        weight: 2,
-        description: "Named import with renaming",
-        examples: ['import { Button as MyButton } from "lib"; <MyButton />']
-      },
-      "Namespace Import": {
-        weight: 2,
-        description: "Import entire namespace",
-        examples: ['import * as Lib from "lib"; <Lib.Button />']
-      },
-      "Variable Assignment": {
-        weight: 3,
-        description: "Assigning components to variables",
-        examples: ["const MyButton = Button; <MyButton />"]
-      },
-      "Conditional Assignment": {
-        weight: 4,
-        description: "Conditional component selection",
-        examples: ["const Comp = condition ? Button : Input; <Comp />"]
-      },
-      "Object Mapping": {
-        weight: 5,
-        description: "Components stored in objects",
-        examples: ["const map = {btn: Button}; <map.btn />"]
-      },
-      "Array Mapping": {
-        weight: 5,
-        description: "Components in arrays",
-        examples: ["[Button, Input].map(Comp => <Comp />)"]
-      },
-      "Dynamic Mapping": {
-        weight: 6,
-        description: "Runtime component selection",
-        examples: ["components[type]"]
-      },
-      "HOC Wrapping": {
-        weight: 7,
-        description: "Higher-order component patterns",
-        examples: ["withProps(Button)"]
-      },
-      "Lazy Loading": {
-        weight: 6,
-        description: "Lazy-loaded components",
-        examples: ['lazy(() => import("lib/Button"))']
-      },
-      "Dynamic Import": {
-        weight: 7,
-        description: "Runtime dynamic imports",
-        examples: ['await import("lib/Button")']
-      },
-      "Destructuring Usage": {
-        weight: 4,
-        description: "Destructured from objects",
-        examples: ["const {Button} = Foundation; <Button />"]
-      },
-      "Memoized Components": {
-        weight: 5,
-        description: "React.memo wrapped components",
-        examples: ["memo(Button)"]
-      },
-      "Forward Ref": {
-        weight: 6,
-        description: "forwardRef wrapped components",
-        examples: ["forwardRef((props, ref) => <Button ref={ref} />)"]
-      },
-      "Portal Usage": {
-        weight: 8,
-        description: "Components rendered in portals",
-        examples: ["createPortal(<Button />, document.body)"]
-      },
-      "Context Integration": {
-        weight: 7,
-        description: "Components from React context",
-        examples: ["const {Button} = useContext(ThemeContext)"]
-      }
-    };
-    return patterns;
-  }
-  classifyUsage(report) {
-    const patterns = this.analyzePatterns();
-    const foundPatterns = /* @__PURE__ */ new Map();
-    if (report.patterns.imports.default.length > 0) {
-      foundPatterns.set("Direct Import & Usage", {
-        count: report.patterns.imports.default.length,
-        complexity: 1,
-        examples: report.patterns.imports.default.slice(0, 3)
-      });
-    }
-    if (report.patterns.imports.aliased.length > 0) {
-      foundPatterns.set("Named Import with Alias", {
-        count: report.patterns.imports.aliased.length,
-        complexity: 2,
-        examples: report.patterns.imports.aliased.slice(0, 3)
-      });
-    }
-    if (report.patterns.imports.namespace.length > 0) {
-      foundPatterns.set("Namespace Import", {
-        count: report.patterns.imports.namespace.length,
-        complexity: 2,
-        examples: report.patterns.imports.namespace.slice(0, 3)
-      });
-    }
-    if (report.patterns.usage.variables.length > 0) {
-      foundPatterns.set("Variable Assignment", {
-        count: report.patterns.usage.variables.length,
-        complexity: 3,
-        examples: report.patterns.usage.variables.slice(0, 3)
-      });
-    }
-    if (report.patterns.usage.conditional.length > 0) {
-      foundPatterns.set("Conditional Assignment", {
-        count: report.patterns.usage.conditional.length,
-        complexity: 4,
-        examples: report.patterns.usage.conditional.slice(0, 3)
-      });
-    }
-    if (report.patterns.usage.objects.length > 0) {
-      foundPatterns.set("Object Mapping", {
-        count: report.patterns.usage.objects.length,
-        complexity: 5,
-        examples: report.patterns.usage.objects.slice(0, 3)
-      });
-    }
-    if (report.patterns.usage.arrays.length > 0) {
-      foundPatterns.set("Array Mapping", {
-        count: report.patterns.usage.arrays.length,
-        complexity: 5,
-        examples: report.patterns.usage.arrays.slice(0, 3)
-      });
-    }
-    if (report.patterns.advanced.lazy.length > 0) {
-      foundPatterns.set("Lazy Loading", {
-        count: report.patterns.advanced.lazy.length,
-        complexity: 6,
-        examples: report.patterns.advanced.lazy.slice(0, 3)
-      });
-    }
-    if (report.patterns.advanced.dynamic.length > 0) {
-      foundPatterns.set("Dynamic Import", {
-        count: report.patterns.advanced.dynamic.length,
-        complexity: 7,
-        examples: report.patterns.advanced.dynamic.slice(0, 3)
-      });
-    }
-    if (report.patterns.usage.destructuring.length > 0) {
-      foundPatterns.set("Destructuring Usage", {
-        count: report.patterns.usage.destructuring.length,
-        complexity: 4,
-        examples: report.patterns.usage.destructuring.slice(0, 3)
-      });
-    }
-    if (report.patterns.advanced.memo.length > 0) {
-      foundPatterns.set("Memoized Components", {
-        count: report.patterns.advanced.memo.length,
-        complexity: 5,
-        examples: report.patterns.advanced.memo.slice(0, 3)
-      });
-    }
-    if (report.patterns.advanced.forwardRef.length > 0) {
-      foundPatterns.set("Forward Ref", {
-        count: report.patterns.advanced.forwardRef.length,
-        complexity: 6,
-        examples: report.patterns.advanced.forwardRef.slice(0, 3)
-      });
-    }
-    if (report.patterns.advanced.portal.length > 0) {
-      foundPatterns.set("Portal Usage", {
-        count: report.patterns.advanced.portal.length,
-        complexity: 8,
-        examples: report.patterns.advanced.portal.slice(0, 3)
-      });
-    }
-    return { patterns, foundPatterns };
-  }
-  generateComplexityScore(foundPatterns) {
-    let totalScore = 0;
-    let maxPossibleScore = 0;
-    foundPatterns.forEach((data, patternName) => {
-      const weight = data.complexity;
-      const score = weight * data.count;
-      totalScore += score;
-      maxPossibleScore += weight * 10;
-    });
-    return {
-      score: totalScore,
-      maxPossible: maxPossibleScore,
-      percentage: Math.round(
-        totalScore / Math.max(maxPossibleScore, 1) * 100
-      ),
-      level: this.getComplexityLevel(totalScore)
-    };
-  }
-  getComplexityLevel(score) {
-    if (score <= 10) return "Simple";
-    if (score <= 30) return "Moderate";
-    if (score <= 60) return "Complex";
-    if (score <= 100) return "Very Complex";
-    return "Extremely Complex";
-  }
-  generateRecommendations(foundPatterns, complexity) {
-    const recommendations = [];
-    if (foundPatterns.has("Dynamic Import") || foundPatterns.has("Portal Usage")) {
-      recommendations.push({
-        type: "Performance",
-        priority: "High",
-        message: "Consider code splitting strategies for dynamic imports",
-        action: "Implement lazy loading boundaries"
-      });
-    }
-    if (foundPatterns.has("Object Mapping") || foundPatterns.has("Array Mapping")) {
-      recommendations.push({
-        type: "Maintainability",
-        priority: "Medium",
-        message: "Component mappings can be hard to track",
-        action: "Consider using TypeScript for better type safety"
-      });
-    }
-    if (complexity.level === "Extremely Complex") {
-      recommendations.push({
-        type: "Architecture",
-        priority: "High",
-        message: "High complexity detected in component usage",
-        action: "Consider refactoring to simpler patterns"
-      });
-    }
-    if (foundPatterns.size > 8) {
-      recommendations.push({
-        type: "Consistency",
-        priority: "Medium",
-        message: "Many different usage patterns found",
-        action: "Standardize on 2-3 primary patterns"
-      });
-    }
-    return recommendations;
-  }
-  printFocusedReport(report) {
-    const { patterns, foundPatterns } = this.classifyUsage(report);
-    const complexity = this.generateComplexityScore(foundPatterns);
-    const recommendations = this.generateRecommendations(
-      foundPatterns,
-      complexity
-    );
-    console.log("\n" + "\u{1F3AF}".repeat(40));
-    console.log("\u{1F3AF} FOCUSED COMPONENT USAGE ANALYSIS");
-    console.log("\u{1F3AF}".repeat(40));
-    console.log(`
-\u{1F4CA} COMPLEXITY ANALYSIS:`);
+  }
+  for (const cond of report.patterns.usage.conditional) {
     console.log(
-      `   Overall Score: ${complexity.score}/${complexity.maxPossible}`
+      chalk__default.default.gray(`[VERBOSE] Found Conditional usage: ${cond.consequent}`)
     );
+  }
+  for (const arr of report.patterns.usage.arrays) {
     console.log(
-      `   Complexity Level: ${complexity.level} (${complexity.percentage}%)`
+      chalk__default.default.gray(
+        `[VERBOSE] Found Array mapping with components: ${arr.components.join(", ")}`
+      )
     );
+  }
+  for (const variable of report.patterns.usage.variables) {
     console.log(
-      `
-\u{1F50D} PATTERNS DETECTED (${foundPatterns.size} of ${Object.keys(patterns).length}):`
-    );
-    const sortedPatterns = Array.from(foundPatterns.entries()).sort(
-      (a, b) => b[1].complexity - a[1].complexity
+      chalk__default.default.gray(
+        `[VERBOSE] Found Variable assignment: ${variable.variable} = ${variable.assignment}`
+      )
     );
-    sortedPatterns.forEach(([patternName, data]) => {
-      const patternInfo = patterns[patternName];
-      console.log(
-        `
-   ${this.getComplexityIcon(data.complexity)} ${patternName}:`
-      );
-      console.log(`     Complexity: ${data.complexity}/10`);
-      console.log(`     Instances: ${data.count}`);
-      console.log(`     Description: ${patternInfo.description}`);
-      if (data.examples.length > 0) {
-        console.log(
-          `     Examples: ${JSON.stringify(data.examples[0], null, "       ").slice(0, 100)}...`
-        );
-      }
-    });
-    console.log(`
-\u{1F4C8} COMPONENT FREQUENCY:`);
-    report.patterns.usage.jsx.forEach((usage) => {
-      console.log(`   ${usage.component}: ${usage.count} uses`);
-    });
-    if (recommendations.length > 0) {
-      console.log(`
-\u{1F4A1} RECOMMENDATIONS:`);
-      recommendations.forEach((rec, idx) => {
-        console.log(`   ${idx + 1}. [${rec.priority}] ${rec.type}:`);
-        console.log(`      Issue: ${rec.message}`);
-        console.log(`      Action: ${rec.action}`);
-      });
-    }
-    console.log(`
-\u{1F4CB} PATTERN COVERAGE:`);
-    Object.keys(patterns).forEach((patternName) => {
-      const found = foundPatterns.has(patternName);
-      console.log(`   ${found ? "\u2705" : "\u274C"} ${patternName}`);
-    });
-    console.log(`
-\u{1F3AF} USAGE DENSITY:`);
-    const density = foundPatterns.size / Object.keys(patterns).length * 100;
-    console.log(`   Pattern Coverage: ${Math.round(density)}%`);
+  }
+  for (const destructure of report.patterns.usage.destructuring) {
     console.log(
-      `   Usage Intensity: ${this.getUsageIntensity(complexity.score)}`
+      chalk__default.default.gray(
+        `[VERBOSE] Found Destructuring: ${destructure.property} from ${destructure.source}`
+      )
     );
-    return { foundPatterns, complexity, recommendations };
-  }
-  getComplexityIcon(complexity) {
-    if (complexity <= 2) return "\u{1F7E2}";
-    if (complexity <= 4) return "\u{1F7E1}";
-    if (complexity <= 6) return "\u{1F7E0}";
-    return "\u{1F534}";
-  }
-  getUsageIntensity(score) {
-    if (score <= 10) return "Light";
-    if (score <= 30) return "Moderate";
-    if (score <= 60) return "Heavy";
-    return "Intensive";
-  }
-  analyzeMultipleFiles(filePatterns) {
-    const allReports = [];
-    const combinedAnalysis = {
-      totalFiles: 0,
-      totalComponents: /* @__PURE__ */ new Set(),
-      patternFrequency: /* @__PURE__ */ new Map(),
-      complexityDistribution: []
-    };
-    filePatterns.forEach((pattern) => {
-      const files = this.findMatchingFiles(pattern);
-      files.forEach((file) => {
-        console.log(`
-\u{1F4C1} Analyzing: ${file}`);
-        const report = this.analyzeFile(file);
-        if (report) {
-          allReports.push({ file, report });
-          combinedAnalysis.totalFiles++;
-          report.components.forEach(
-            (comp) => combinedAnalysis.totalComponents.add(comp)
-          );
-          const { foundPatterns, complexity } = this.classifyUsage(report);
-          combinedAnalysis.complexityDistribution.push({
-            file,
-            score: complexity.score,
-            level: complexity.level
-          });
-          foundPatterns.forEach((data, pattern2) => {
-            const current = combinedAnalysis.patternFrequency.get(pattern2) || 0;
-            combinedAnalysis.patternFrequency.set(pattern2, current + 1);
-          });
-        }
-      });
-    });
-    return { allReports, combinedAnalysis };
-  }
-  findMatchingFiles(pattern) {
-    const glob5 = __require("glob");
-    try {
-      return glob5.sync(pattern);
-    } catch (e) {
-      console.warn(`Warning: Could not process pattern ${pattern}`);
-      return [];
-    }
   }
-};
-async function findFiles(pattern, ignorePatterns, maxFiles) {
-  const allFiles = await glob.glob(pattern, {
-    ignore: ignorePatterns || [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**"
-    ],
-    nodir: true,
-    absolute: true,
-    // Only match React/JS/TS files
-    matchBase: true
-  });
-  const reactFiles = allFiles.filter((file) => {
-    var _a;
-    const ext = (_a = file.split(".").pop()) == null ? void 0 : _a.toLowerCase();
-    return ["tsx", "jsx", "ts", "js"].includes(ext || "");
-  });
-  return maxFiles ? reactFiles.slice(0, maxFiles) : reactFiles;
-}
-function generateReportFilename(commandType, extension = "json") {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return `${commandType}-report-${timestamp}.${extension}`;
-}
-function addReportMetadata(data, commandType, additionalMetadata = {}) {
-  return {
-    ...data,
-    metadata: {
-      ...data.metadata,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      commandType,
-      ...additionalMetadata
-    }
-  };
-}
-function saveReport(options) {
-  const { data, commandType, outputPath, format = "both" } = options;
-  if (format === "console") {
-    return "";
-  }
-  const filename = outputPath || generateReportFilename(commandType);
-  const reportsDir = path__default.default.join(process.cwd(), "reports-outputs");
-  if (!fs5__default.default.existsSync(reportsDir)) {
-    fs5__default.default.mkdirSync(reportsDir, { recursive: true });
-  }
-  const finalPath = path__default.default.isAbsolute(filename) ? filename : path__default.default.join(reportsDir, filename);
-  const reportWithMetadata = addReportMetadata(data, commandType);
-  fs5__default.default.writeFileSync(finalPath, JSON.stringify(reportWithMetadata, null, 2));
-  console.log(chalk8__default.default.blue(`
-\u{1F4C4} JSON report saved to: ${finalPath}`));
-  return finalPath;
-}
-function getRankEmoji(rank) {
-  switch (rank) {
-    case 1:
-      return "\u{1F947}";
-    case 2:
-      return "\u{1F948}";
-    case 3:
-      return "\u{1F949}";
-    default:
-      return "\u{1F4CD}";
+  for (const lazy of report.patterns.advanced.lazy) {
+    console.log(chalk__default.default.gray(`[VERBOSE] Found Lazy import: ${lazy.source}`));
   }
-}
-
-// src/commands/analyze.ts
-async function analyzeCommand(pattern, options) {
-  const spinner = ora6__default.default("Finding files to analyze...").start();
-  try {
-    const files = await findFiles(pattern, options.ignore, options.maxFiles);
-    if (files.length === 0) {
-      spinner.fail(chalk8__default.default.red("No files found matching pattern: " + pattern));
-      return;
-    }
-    spinner.succeed(chalk8__default.default.green(`Found ${files.length} files to analyze`));
-    spinner.start("Analyzing files...");
-    const analyzer = options.complexity ? new FocusedUsageAnalyzer(options.library) : new ReactComponentUsageAnalyzer(options.library);
-    const aggregatedReport = {
-      metadata: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        commandType: "analyze",
-        library: options.library,
-        pattern,
-        filesAnalyzed: 0,
-        filesWithErrors: 0,
-        totalFiles: files.length
-      },
-      files: [],
-      aggregated: {
-        allComponents: /* @__PURE__ */ new Set(),
-        totalImports: 0,
-        totalUsagePatterns: 0,
-        patternFrequency: {},
-        componentFrequency: {},
-        fileComplexity: [],
-        errors: []
-      }
-    };
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i];
-      spinner.text = `Analyzing files... (${i + 1}/${files.length}) ${path__default.default.basename(file)}`;
-      try {
-        const report = analyzer.analyzeFile(file);
-        if (report) {
-          aggregatedReport.metadata.filesAnalyzed++;
-          const fileResult = {
-            path: file,
-            components: report.components,
-            summary: report.summary,
-            patterns: report.patterns
-          };
-          if (options.complexity) {
-            const analysis = analyzer.classifyUsage(report);
-            const complexity = analyzer.generateComplexityScore(
-              analysis.foundPatterns
-            );
-            fileResult.complexity = complexity;
-            aggregatedReport.aggregated.fileComplexity.push({
-              file,
-              score: complexity.score,
-              level: complexity.level
-            });
-          }
-          aggregatedReport.files.push(fileResult);
-          report.components.forEach(
-            (comp) => aggregatedReport.aggregated.allComponents.add(comp)
-          );
-          aggregatedReport.aggregated.totalImports += report.summary.totalImports;
-          aggregatedReport.aggregated.totalUsagePatterns += report.summary.totalUsagePatterns;
-          report.patterns.usage.jsx.forEach((usage) => {
-            aggregatedReport.aggregated.componentFrequency[usage.component] = (aggregatedReport.aggregated.componentFrequency[usage.component] || 0) + usage.count;
-          });
-          Object.keys(report.patterns).forEach((category) => {
-            Object.keys(report.patterns[category]).forEach((patternType) => {
-              const pattern2 = report.patterns[category][patternType];
-              const count = Array.isArray(pattern2) ? pattern2.length : 0;
-              if (count > 0) {
-                const key = `${category}.${patternType}`;
-                aggregatedReport.aggregated.patternFrequency[key] = (aggregatedReport.aggregated.patternFrequency[key] || 0) + count;
-              }
-            });
-          });
-        }
-      } catch (error) {
-        aggregatedReport.metadata.filesWithErrors++;
-        aggregatedReport.aggregated.errors.push({
-          file,
-          error: error.message
-        });
-      }
-    }
-    aggregatedReport.aggregated.allComponents = Array.from(
-      aggregatedReport.aggregated.allComponents
+  for (const dynamic of report.patterns.advanced.dynamic) {
+    console.log(
+      chalk__default.default.gray(`[VERBOSE] Found Dynamic import: ${dynamic.source}`)
     );
-    spinner.succeed(
-      chalk8__default.default.green(
-        `Analysis complete! Analyzed ${aggregatedReport.metadata.filesAnalyzed} files`
-      )
+  }
+  for (const hoc of report.patterns.advanced.hoc) {
+    console.log(
+      chalk__default.default.gray(`[VERBOSE] Found HOC: ${hoc.function}(${hoc.component})`)
     );
-    if (options.format === "json" || options.format === "both") {
-      saveReport({
-        data: aggregatedReport,
-        commandType: "analyze",
-        outputPath: options.output,
-        format: options.format
-      });
-    }
-    if (options.format === "console" || options.format === "both") {
-      printAggregatedReport(aggregatedReport, options);
-    }
-  } catch (error) {
-    spinner.fail(chalk8__default.default.red("Analysis failed: " + error.message));
-    console.error(error);
   }
-}
-function printAggregatedReport(report, options) {
-  console.log("\n" + chalk8__default.default.bold.blue("\u2550".repeat(80)));
-  console.log(chalk8__default.default.bold.blue("  \u{1F4CA} AGGREGATED ANALYSIS REPORT"));
-  console.log(chalk8__default.default.bold.blue("\u2550".repeat(80)));
-  console.log(chalk8__default.default.bold("\n\u{1F4C8} SUMMARY:"));
-  console.log(`  Library: ${chalk8__default.default.cyan(report.metadata.library)}`);
-  console.log(
-    `  Files Analyzed: ${chalk8__default.default.green(report.metadata.filesAnalyzed)} / ${report.metadata.totalFiles}`
-  );
-  if (report.metadata.filesWithErrors > 0) {
+  for (const memo of report.patterns.advanced.memo) {
     console.log(
-      `  Files with Errors: ${chalk8__default.default.red(report.metadata.filesWithErrors)}`
+      chalk__default.default.gray(`[VERBOSE] Found Memoized component: ${memo.component}`)
     );
   }
+  if (report.patterns.advanced.forwardRef.length > 0) {
+    console.log(chalk__default.default.gray(`[VERBOSE] Found Forward Ref usage`));
+  }
+  if (report.patterns.advanced.portal.length > 0) {
+    console.log(chalk__default.default.gray(`[VERBOSE] Found Portal usage`));
+  }
+  console.log(chalk__default.default.gray(`[VERBOSE] ${"\u2500".repeat(80)}`));
+}
+function printSummary(aggregated, elapsedTimeSeconds) {
   console.log(
-    `  Total Components: ${chalk8__default.default.yellow(report.aggregated.allComponents.length)}`
+    chalk__default.default.green(
+      `[SUMMARY] Analysis completed successfully in ${elapsedTimeSeconds.toFixed(1)}s`
+    )
   );
   console.log(
-    `  Total Imports: ${chalk8__default.default.yellow(report.aggregated.totalImports)}`
+    chalk__default.default.green(
+      `[SUMMARY] Files analyzed: ${aggregated.filesAnalyzed.toLocaleString()}`
+    )
   );
   console.log(
-    `  Total Usage Patterns: ${chalk8__default.default.yellow(report.aggregated.totalUsagePatterns)}`
+    chalk__default.default.green(
+      `[SUMMARY] Total imports: ${aggregated.totalImports.toLocaleString()}`
+    )
   );
-  if (!options.summaryOnly) {
-    console.log(chalk8__default.default.bold("\n\u{1F3AF} TOP COMPONENTS:"));
-    const topComponents = Object.entries(report.aggregated.componentFrequency).sort((a, b) => b[1] - a[1]).slice(0, 10);
-    topComponents.forEach(([comp, count], index) => {
-      const rank = index + 1;
-      const emoji = getRankEmoji(rank);
-      console.log(
-        `  ${emoji} ${rank}. ${chalk8__default.default.cyan(comp)}: ${chalk8__default.default.yellow(count)} uses`
-      );
-    });
-    console.log(chalk8__default.default.bold("\n\u{1F50D} PATTERN FREQUENCY:"));
-    const topPatterns = Object.entries(report.aggregated.patternFrequency).sort((a, b) => b[1] - a[1]).slice(0, 10);
-    topPatterns.forEach(([pattern, count], index) => {
-      console.log(`  ${index + 1}. ${pattern}: ${chalk8__default.default.yellow(count)}`);
-    });
-    if (report.aggregated.fileComplexity.length > 0) {
-      console.log(chalk8__default.default.bold("\n\u{1F4CA} COMPLEXITY ANALYSIS:"));
-      const avgComplexity = report.aggregated.fileComplexity.reduce(
-        (sum, f) => sum + f.score,
-        0
-      ) / report.aggregated.fileComplexity.length;
+  console.log(
+    chalk__default.default.green(
+      `[SUMMARY] Total components: ${aggregated.totalComponents.toLocaleString()}`
+    )
+  );
+}
+function printDetails(aggregated) {
+  console.log(
+    chalk__default.default.cyan(
+      `[DETAILS] Total usage patterns: ${aggregated.totalUsagePatterns.toLocaleString()}`
+    )
+  );
+  for (const pattern of aggregated.patternCounts) {
+    if (pattern.count > 0) {
       console.log(
-        `  Average Complexity: ${chalk8__default.default.yellow(avgComplexity.toFixed(2))}`
+        chalk__default.default.cyan(
+          `[DETAILS] ${pattern.displayName}: ${pattern.count.toLocaleString()}`
+        )
       );
-      const mostComplex = report.aggregated.fileComplexity.sort((a, b) => b.score - a.score).slice(0, 5);
-      console.log(chalk8__default.default.bold("\n  Most Complex Files:"));
-      mostComplex.forEach((file, index) => {
-        console.log(
-          `  ${index + 1}. ${path__default.default.basename(file.file)}: ${chalk8__default.default.yellow(file.score)} (${file.level})`
-        );
-      });
     }
   }
-  if (report.aggregated.errors.length > 0) {
-    console.log(chalk8__default.default.bold.red("\n\u26A0\uFE0F  ERRORS:"));
-    report.aggregated.errors.slice(0, 5).forEach((error) => {
-      console.log(
-        `  ${chalk8__default.default.red("\u2717")} ${path__default.default.basename(error.file)}: ${error.error}`
-      );
-    });
-    if (report.aggregated.errors.length > 5) {
-      console.log(
-        `  ... and ${report.aggregated.errors.length - 5} more errors`
-      );
-    }
+}
+function renderBarChart(data, options = {}) {
+  const {
+    maxWidth = 50,
+    showValues = true,
+    barChar = "\u2588",
+    emptyChar = "\u2591"
+  } = options;
+  if (data.length === 0) {
+    console.log(chalk__default.default.gray("  No data to display"));
+    return;
+  }
+  const maxValue = Math.max(...data.map((d) => d.value));
+  if (maxValue === 0) {
+    console.log(chalk__default.default.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__default.default.green(barChar.repeat(barLength)) + chalk__default.default.gray(emptyChar.repeat(emptyLength));
+    const valueStr = showValues ? ` ${item.value.toLocaleString()}` : "";
+    console.log(`${paddedLabel} ${bar}${valueStr}
+`);
   }
-  console.log("\n" + chalk8__default.default.bold.blue("\u2550".repeat(80)) + "\n");
 }
-async function compareCommand(pattern, options) {
-  const spinner = ora6__default.default("Finding files to analyze...").start();
-  try {
-    const files = await findFiles(pattern, [], 1e3);
-    if (files.length === 0) {
-      spinner.fail(chalk8__default.default.red("No files found matching pattern: " + pattern));
-      return;
-    }
-    spinner.succeed(chalk8__default.default.green(`Found ${files.length} files`));
-    const comparisonResults = {
-      metadata: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        commandType: "compare",
-        pattern,
-        filesAnalyzed: files.length,
-        libraries: options.libraries
-      },
-      libraries: []
-    };
-    for (const library of options.libraries) {
-      spinner.start(`Analyzing ${library}...`);
-      const analyzer = new FocusedUsageAnalyzer(library);
-      let componentsFound = 0;
-      let usagePatterns = 0;
-      const components = /* @__PURE__ */ new Set();
-      for (const file of files) {
-        try {
-          const report = analyzer.analyzeFile(file);
-          if (report) {
-            componentsFound += report.summary.totalComponents;
-            usagePatterns += report.summary.totalUsagePatterns;
-            report.components.forEach((comp) => components.add(comp));
-          }
-        } catch (error) {
-        }
-      }
-      const libraryResult = {
-        name: library,
-        componentsFound: components.size,
-        totalUsagePatterns: usagePatterns,
-        topComponents: Array.from(components).slice(0, 10)
-      };
-      comparisonResults.libraries.push(libraryResult);
-      spinner.succeed(
-        chalk8__default.default.green(`${library}: ${components.size} components found`)
-      );
-    }
-    comparisonResults.libraries.sort(
-      (a, b) => b.componentsFound - a.componentsFound
-    );
-    if (options.format === "json" || options.format === "both") {
-      saveReport({
-        data: comparisonResults,
-        commandType: "compare",
-        outputPath: options.output,
-        format: options.format
-      });
-    }
-    if (options.format === "console" || options.format === "both") {
-      printComparisonReport(comparisonResults);
-    }
-  } catch (error) {
-    spinner.fail(chalk8__default.default.red("Comparison failed: " + error.message));
-    console.error(error);
+
+// src/utils/print-top-components.ts
+function printTopComponents(aggregated, mode, topN = 10) {
+  const topComponents = aggregated.topComponents.slice(0, topN);
+  if (mode === "log") {
+    printTopComponentsLog(topComponents);
+  } else if (mode === "table") {
+    printTopComponentsTable(topComponents);
+  } else if (mode === "chart") {
+    printTopComponentsChart(topComponents);
   }
 }
-function printComparisonReport(results) {
-  console.log("\n" + chalk8__default.default.bold.blue("\u2550".repeat(60)));
-  console.log(chalk8__default.default.bold.blue("  \u{1F4CA} LIBRARY COMPARISON REPORT"));
-  console.log(chalk8__default.default.bold.blue("\u2550".repeat(60)));
-  console.log(chalk8__default.default.bold("\n\u{1F3C6} RESULTS:"));
-  results.libraries.forEach((lib, index) => {
-    const rank = index + 1;
-    const emoji = getRankEmoji(rank);
+function printTopComponentsLog(components) {
+  console.log(chalk__default.default.yellow.bold(`
+\u{1F3C6} Top Components
+`));
+  if (components.length === 0) {
+    console.log(chalk__default.default.gray("  No components found"));
+    return;
+  }
+  components.forEach((comp, idx) => {
+    const rank = idx + 1;
+    const emoji = rank === 1 ? "\u{1F947}" : rank === 2 ? "\u{1F948}" : rank === 3 ? "\u{1F949}" : "  ";
+    const sourceStr = comp.source !== "unknown" ? ` from ${comp.source}` : "";
     console.log(
-      `  ${emoji} ${rank}. ${chalk8__default.default.cyan(lib.name)}: ${chalk8__default.default.yellow(lib.componentsFound)} components, ${chalk8__default.default.yellow(lib.totalUsagePatterns)} usage patterns`
-    );
-  });
-  console.log("\n" + chalk8__default.default.bold.blue("\u2550".repeat(60)) + "\n");
-}
-function parseGitHubUrl(url) {
-  if (/^[\w-]+\/[\w-]+$/.test(url)) {
-    const [owner, repo] = url.split("/");
-    return {
-      owner,
-      repo: repo.replace(".git", ""),
-      url: `https://github.com/${owner}/${repo}`,
-      shorthand: url
-    };
-  }
-  const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2],
-      url,
-      shorthand: `${httpsMatch[1]}/${httpsMatch[2]}`
-    };
-  }
-  throw new Error(
-    `Invalid GitHub URL: ${url}. Expected format: https://github.com/owner/repo or owner/repo`
-  );
-}
-function createTempDir() {
-  return new Promise((resolve, reject) => {
-    tmp__default.default.dir(
-      { unsafeCleanup: true, prefix: "react-analyzer-" },
-      (err, dirPath, cleanup) => {
-        if (err) reject(err);
-        resolve({ path: dirPath, cleanup });
-      }
+      chalk__default.default.yellow(
+        `[TOP-COMPONENTS] ${emoji} ${rank}. ${comp.name}${sourceStr}: ${comp.count} uses`
+      )
     );
   });
 }
-async function cloneRepository(repoUrl, targetDir, options = {}) {
-  const { branch = "main", depth = 1 } = options;
-  const repoInfo = parseGitHubUrl(repoUrl);
-  const localPath = path__default.default.join(targetDir, `${repoInfo.owner}-${repoInfo.repo}`);
-  const git = simpleGit__default.default();
-  const cloneOptions = [
-    "--depth",
-    depth.toString(),
-    "--branch",
-    branch,
-    "--single-branch"
-  ];
-  try {
-    await git.clone(repoInfo.url, localPath, cloneOptions);
-    return {
-      ...repoInfo,
-      localPath,
-      branch,
-      success: true
-    };
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("not found") && branch === "main") {
-      try {
-        const fallbackOptions = [
-          "--depth",
-          "1",
-          "--branch",
-          "master",
-          "--single-branch"
-        ];
-        await git.clone(repoInfo.url, localPath, fallbackOptions);
-        return {
-          ...repoInfo,
-          localPath,
-          branch: "master",
-          success: true
-        };
-      } catch (retryError) {
-        throw retryError;
-      }
-    }
-    throw error;
-  }
-}
-async function cloneRepositories(repoUrls, targetDir, options = {}) {
-  const spinner = ora6__default.default("Cloning repositories...").start();
-  const clonedRepos = [];
-  const errors = [];
-  for (const repoUrl of repoUrls) {
-    try {
-      spinner.text = `Cloning ${repoUrl}...`;
-      const repoInfo = await cloneRepository(repoUrl, targetDir, options);
-      clonedRepos.push(repoInfo);
-      spinner.succeed(
-        chalk8__default.default.green(
-          `\u2713 Cloned ${repoInfo.shorthand} (${repoInfo.branch} branch)`
-        )
-      );
-      spinner.start();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push({
-        url: repoUrl,
-        error: message
-      });
-      spinner.fail(chalk8__default.default.red(`\u2717 Failed to clone ${repoUrl}: ${message}`));
-      spinner.start();
+function printTopComponentsTable(components) {
+  console.log(chalk__default.default.yellow(`[TOP-COMPONENTS] TABLE`));
+  if (components.length === 0) {
+    console.log(chalk__default.default.gray("  No components found"));
+    return;
+  }
+  const table = new Table__default.default({
+    head: ["Rank", "Component", "Source", "Count"],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
     }
-  }
-  spinner.stop();
-  if (clonedRepos.length === 0) {
-    throw new Error("No repositories were successfully cloned");
-  }
-  console.log(
-    chalk8__default.default.green(
-      `
-Successfully cloned ${clonedRepos.length} of ${repoUrls.length} repositories
-`
-    )
-  );
-  return { clonedRepos, errors };
-}
-async function findFilesInRepo(repo, pattern = "**/*.{tsx,jsx,ts,js}") {
-  if (!repo.localPath) {
-    throw new Error("Repository localPath is not defined");
-  }
-  const normalizedPath = repo.localPath.replace(/\\/g, "/");
-  const searchPattern = `${normalizedPath}/${pattern}`;
-  const files = await glob.glob(searchPattern, {
-    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
-    nodir: true,
-    windowsPathsNoEscape: true
   });
-  return files;
+  components.forEach((comp, idx) => {
+    const rank = idx + 1;
+    const emoji = rank === 1 ? "\u{1F947}" : rank === 2 ? "\u{1F948}" : rank === 3 ? "\u{1F949}" : `${rank}.`;
+    table.push([emoji, comp.name, comp.source, comp.count.toString()]);
+  });
+  console.log(table.toString());
 }
-async function findFilesInRepos(repos, pattern = "**/*.{tsx,jsx,ts,js}") {
-  const filesByRepo = {};
-  for (const repo of repos) {
-    const files = await findFilesInRepo(repo, pattern);
-    filesByRepo[repo.shorthand] = {
-      repo,
-      files,
-      count: files.length
-    };
-  }
-  return filesByRepo;
+function printTopComponentsChart(components) {
+  console.log(chalk__default.default.yellow(`[TOP-COMPONENTS] CHART`));
+  if (components.length === 0) {
+    console.log(chalk__default.default.gray("  No components found"));
+    return;
+  }
+  const data = components.map((comp) => ({
+    label: comp.name,
+    value: comp.count
+  }));
+  renderBarChart(data, { maxWidth: 50 });
 }
-async function getRepoStats(repoPath) {
-  try {
-    const packageJsonPath = path__default.default.join(repoPath, "package.json");
-    let packageJson = null;
-    if (fs5__default.default.existsSync(packageJsonPath)) {
-      packageJson = JSON.parse(fs5__default.default.readFileSync(packageJsonPath, "utf8"));
-    }
-    const normalizedPath = repoPath.replace(/\\/g, "/");
-    const files = await glob.glob(`${normalizedPath}/**/*.{tsx,jsx,ts,js}`, {
-      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
-      nodir: true,
-      windowsPathsNoEscape: true
-    });
-    const fileTypes = {
-      tsx: 0,
-      jsx: 0,
-      ts: 0,
-      js: 0
-    };
-    files.forEach((file) => {
-      const ext = path__default.default.extname(file).slice(1);
-      if (fileTypes.hasOwnProperty(ext)) {
-        fileTypes[ext]++;
-      }
-    });
-    return {
-      packageJson,
-      name: (packageJson == null ? void 0 : packageJson.name) || "unknown",
-      version: (packageJson == null ? void 0 : packageJson.version) || "unknown",
-      dependencies: (packageJson == null ? void 0 : packageJson.dependencies) || {},
-      devDependencies: (packageJson == null ? void 0 : packageJson.devDependencies) || {},
-      totalFiles: files.length,
-      fileTypes
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      error: message,
-      name: "unknown",
-      version: "unknown",
-      dependencies: {},
-      devDependencies: {},
-      totalFiles: 0,
-      fileTypes: { tsx: 0, jsx: 0, ts: 0, js: 0 }
-    };
+function printComponentsUsage(aggregated, mode) {
+  const components = aggregated.topComponents;
+  if (mode === "table") {
+    printComponentsUsageTable(components);
+  } else if (mode === "chart") {
+    printComponentsUsageChart(components);
   }
 }
-function generateCombinedReport(analysisResults) {
-  const combined = {
-    totalComponents: [],
-    totalImports: [],
-    componentsByRepo: {},
-    componentFrequency: {},
-    importFrequency: {},
-    repoSummaries: []
-  };
-  const totalComponentsSet = /* @__PURE__ */ new Set();
-  const totalImportsSet = /* @__PURE__ */ new Set();
-  Object.entries(analysisResults.repositories).forEach(
-    ([repoName, repoData]) => {
-      repoData.analysis.components.forEach(
-        (comp) => totalComponentsSet.add(comp)
-      );
-      Object.keys(repoData.analysis.imports).forEach(
-        (imp) => totalImportsSet.add(imp)
-      );
-      combined.componentsByRepo[repoName] = repoData.analysis.components;
-      Object.entries(repoData.analysis.componentUsage).forEach(
-        ([comp, count]) => {
-          combined.componentFrequency[comp] = (combined.componentFrequency[comp] || 0) + count;
-        }
-      );
-      Object.entries(repoData.analysis.imports).forEach(([imp, data]) => {
-        combined.importFrequency[imp] = (combined.importFrequency[imp] || 0) + data.count;
-      });
-      combined.repoSummaries.push({
-        name: repoName,
-        components: repoData.analysis.components.length,
-        files: repoData.files.length,
-        errors: repoData.analysis.errors.length,
-        topComponents: Object.entries(repoData.analysis.componentUsage).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([comp, count]) => ({ component: comp, uses: count }))
-      });
-    }
-  );
-  combined.totalComponents = Array.from(totalComponentsSet);
-  combined.totalImports = Array.from(totalImportsSet);
-  return combined;
-}
-function cleanupTempDir(cleanup, tmpDir, keepRepos = false) {
-  if (!keepRepos && cleanup) {
-    try {
-      cleanup();
-      console.log(chalk8__default.default.gray("\n\u{1F9F9} Cleaned up temporary directory"));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(chalk8__default.default.yellow(`Warning: Failed to cleanup: ${message}`));
-    }
-  } else if (keepRepos && tmpDir) {
-    console.log(chalk8__default.default.blue(`
-\u{1F4C1} Repositories kept in: ${tmpDir}`));
+function printComponentsUsageTable(components) {
+  console.log(chalk__default.default.magenta.bold(`
+\u269B\uFE0F Components Usage
+`));
+  if (components.length === 0) {
+    console.log(chalk__default.default.gray("  No components found"));
+    return;
   }
-}
-function parsePackageLock(lockFilePath) {
-  try {
-    const content = fs5__default.default.readFileSync(lockFilePath, "utf8");
-    const lockData = JSON.parse(content);
-    const versions = {};
-    if (lockData.packages) {
-      Object.entries(lockData.packages).forEach(
-        ([pkgPath, pkgData]) => {
-          if (!pkgPath || pkgPath === "") return;
-          const pkgName = pkgPath.replace(/^node_modules\//, "");
-          if (pkgData.version) {
-            versions[pkgName] = pkgData.version;
-          }
-        }
-      );
-    }
-    if (lockData.dependencies && Object.keys(versions).length === 0) {
-      let extractVersions = function(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);
+  const table = new Table__default.default({
+    head: ["Component", "Source", "Version", "Count"],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
     }
-    return versions;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`Warning: Could not parse package-lock.json: ${message}`);
-    return {};
-  }
+  });
+  components.forEach((comp) => {
+    table.push([comp.name, comp.source, "0.0.0", comp.count.toString()]);
+  });
+  console.log(table.toString());
 }
-function parseYarnLock(lockFilePath) {
-  try {
-    const content = fs5__default.default.readFileSync(lockFilePath, "utf8");
-    const parsed = lockfile__default.default.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 {};
-  }
+function printComponentsUsageChart(components) {
+  console.log(chalk__default.default.magenta.bold(`
+\u269B\uFE0F Components Usage
+`));
+  if (components.length === 0) {
+    console.log(chalk__default.default.gray("  No components found"));
+    return;
+  }
+  const data = components.map((comp) => ({
+    label: comp.name,
+    value: comp.count
+  }));
+  renderBarChart(data, { maxWidth: 50 });
 }
-function parsePnpmLock(lockFilePath) {
-  try {
-    const content = fs5__default.default.readFileSync(lockFilePath, "utf8");
-    const lockData = yaml__default.default.load(content);
-    const versions = {};
-    if (lockData.importers) {
-      const rootImporter = lockData.importers["."];
-      if (rootImporter) {
-        if (rootImporter.dependencies) {
-          Object.entries(rootImporter.dependencies).forEach(
-            ([name, data]) => {
-              if (typeof data === "object" && data.version) {
-                versions[name] = data.version;
-              }
-            }
-          );
-        }
-        if (rootImporter.devDependencies) {
-          Object.entries(rootImporter.devDependencies).forEach(
-            ([name, data]) => {
-              if (typeof data === "object" && data.version) {
-                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 {};
+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 findAndParseLockfile(projectPath) {
-  const lockfiles = [
-    {
-      name: "package-lock.json",
-      parser: parsePackageLock,
-      type: "npm"
-    },
-    { name: "yarn.lock", parser: parseYarnLock, type: "yarn" },
-    { name: "pnpm-lock.yaml", parser: parsePnpmLock, type: "pnpm" }
-  ];
-  for (const { name, parser, type } of lockfiles) {
-    const lockfilePath = path__default.default.join(projectPath, name);
-    if (fs5__default.default.existsSync(lockfilePath)) {
-      const versions = parser(lockfilePath);
-      return {
-        versions,
-        lockfileType: type,
-        lockfilePath,
-        found: true
-      };
-    }
+function printPatternsTable(patterns) {
+  console.log(chalk__default.default.blue.bold(`
+\u{1F50D} Code Patterns
+`));
+  if (patterns.length === 0) {
+    console.log(chalk__default.default.gray("  No patterns found"));
+    return;
   }
-  return {
-    versions: {},
-    lockfileType: null,
-    lockfilePath: null,
-    found: false
-  };
-}
-function readFile(filePath) {
-  return fs5__default.default.readFileSync(filePath, "utf8");
+  const table = new Table__default.default({
+    head: ["Pattern", "Count"],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    }
+  });
+  patterns.forEach((pattern) => {
+    table.push([pattern.displayName, pattern.count.toString()]);
+  });
+  console.log(table.toString());
 }
-function readJsonFile(filePath) {
-  const content = readFile(filePath);
-  return JSON.parse(content);
+function printPatternsChart(patterns) {
+  console.log(chalk__default.default.blue(`[PATTERNS] CHART`));
+  if (patterns.length === 0) {
+    console.log(chalk__default.default.gray("  No patterns found"));
+    return;
+  }
+  const data = patterns.map((pattern) => ({
+    label: pattern.displayName,
+    value: pattern.count
+  }));
+  renderBarChart(data, { maxWidth: 50 });
 }
 
-// src/github-analysis.ts
-async function analyzeGitHubRepositories(repoUrls, analyzer, options = {}) {
-  const {
-    branch = "main",
-    pattern = "**/*.{tsx,jsx,ts,js}",
-    depth = 1,
-    keepRepos = false
-  } = options;
-  console.log(chalk8__default.default.bold.cyan("\n\u{1F50D} GitHub Repository Analysis\n"));
-  console.log(chalk8__default.default.gray(`Repositories to analyze: ${repoUrls.length}`));
-  console.log(chalk8__default.default.gray(`Pattern: ${pattern}`));
-  console.log(chalk8__default.default.gray(`Branch: ${branch}
-`));
-  const { path: tmpDir, cleanup } = await createTempDir();
-  try {
-    const { clonedRepos, errors: cloneErrors } = await cloneRepositories(
-      repoUrls,
-      tmpDir,
-      { branch, depth }
-    );
-    console.log(chalk8__default.default.bold("\n\u{1F4C1} Finding files in repositories...\n"));
-    const filesByRepo = await findFilesInRepos(clonedRepos, pattern);
-    Object.entries(filesByRepo).forEach(([repoName, data]) => {
-      console.log(`  ${chalk8__default.default.cyan(repoName)}: ${data.count} files`);
-    });
-    console.log(chalk8__default.default.bold("\n\u{1F4CA} Gathering repository statistics...\n"));
-    const repoStats = {};
-    const lockfileData = {};
-    for (const repo of clonedRepos) {
-      if (!repo.localPath) continue;
-      const stats = await getRepoStats(repo.localPath);
-      repoStats[repo.shorthand] = stats;
-      const lockfileInfo = findAndParseLockfile(repo.localPath);
-      lockfileData[repo.shorthand] = lockfileInfo;
-      console.log(
-        `  ${chalk8__default.default.cyan(repo.shorthand)}: ${stats.name}@${stats.version} (${stats.totalFiles} files)`
-      );
-      if (lockfileInfo.found) {
-        console.log(
-          chalk8__default.default.gray(
-            `    Lockfile: ${lockfileInfo.lockfileType} (${Object.keys(lockfileInfo.versions).length} packages)`
-          )
-        );
-      }
-    }
-    console.log(chalk8__default.default.bold("\n\u{1F52C} Analyzing repositories...\n"));
-    const results = {};
-    const spinner = ora6__default.default("Analyzing...").start();
-    for (const [repoName, repoData] of Object.entries(filesByRepo)) {
-      spinner.text = `Analyzing ${repoName}...`;
-      const repoResults = {
-        files: repoData.files,
-        stats: repoStats[repoName],
-        lockfile: lockfileData[repoName],
-        analysis: {
-          components: [],
-          imports: {},
-          componentUsage: {},
-          errors: []
-        }
-      };
-      const componentsSet = /* @__PURE__ */ new Set();
-      const componentUsageTemp = /* @__PURE__ */ new Map();
-      const importsTemp = /* @__PURE__ */ new Map();
-      for (const file of repoData.files) {
-        try {
-          const report = analyzer.analyzeFile(file);
-          if (report) {
-            report.components.forEach((comp) => componentsSet.add(comp));
-            report.patterns.usage.jsx.forEach((usage) => {
-              const existing = componentUsageTemp.get(usage.component);
-              if (!existing) {
-                componentUsageTemp.set(usage.component, {
-                  count: usage.count,
-                  files: /* @__PURE__ */ new Set([file])
-                });
-              } else {
-                existing.count += usage.count;
-                existing.files.add(file);
-              }
-            });
-            [
-              ...report.patterns.imports.default,
-              ...report.patterns.imports.named
-            ].forEach((imp) => {
-              const name = imp.name || imp.local || "";
-              const source = imp.source || imp.from;
-              const existing = importsTemp.get(name);
-              if (!existing) {
-                importsTemp.set(name, {
-                  count: 1,
-                  files: /* @__PURE__ */ new Set([file]),
-                  source
-                });
-              } else {
-                existing.count++;
-                existing.files.add(file);
-              }
-            });
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          repoResults.analysis.errors.push({
-            file,
-            error: message
-          });
-        }
-      }
-      repoResults.analysis.components = Array.from(componentsSet);
-      componentUsageTemp.forEach((value, key) => {
-        repoResults.analysis.componentUsage[key] = {
-          count: value.count,
-          files: Array.from(value.files)
-        };
-      });
-      importsTemp.forEach((value, key) => {
-        repoResults.analysis.imports[key] = {
-          count: value.count,
-          files: Array.from(value.files),
-          source: value.source
-        };
-      });
-      results[repoName] = repoResults;
-      spinner.succeed(
-        chalk8__default.default.green(
-          `\u2713 Analyzed ${repoName}: ${repoResults.analysis.components.length} components found`
-        )
-      );
-      spinner.start();
-    }
-    spinner.stop();
-    const analysisResults = {
-      repositories: results,
-      metadata: {
-        analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        totalRepositories: clonedRepos.length,
-        failedClones: cloneErrors.length,
-        pattern,
-        branch,
-        repoStats,
-        lockfiles: lockfileData
-      },
-      cloneErrors
-    };
-    cleanupTempDir(cleanup, tmpDir, keepRepos);
-    return analysisResults;
-  } catch (error) {
-    cleanupTempDir(cleanup, tmpDir, false);
-    throw error;
-  }
-}
-function loadRepositoriesFromConfig(configPath) {
-  try {
-    const config = readJsonFile(configPath);
-    return config.repositories || [];
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to load config file: ${message}`);
-  }
+// src/commands/scan.ts
+function registerScanCommand(program2) {
+  program2.command("scan").description("Scan and analyze local files").argument(
+    "[pattern]",
+    "Glob pattern for files to analyze (defaults to current directory recursively)",
+    "**/*.{tsx,jsx,ts,js}"
+  ).option(
+    "--verbose",
+    "Show detailed file-by-file analysis with every pattern found",
+    false
+  ).option("--summary [mode]", "Show summary stats (log, false)", "log").option("--details", "Show detailed pattern counts").option(
+    "--top-components [mode]",
+    "Show top components (log, table, chart)",
+    "log"
+  ).option(
+    "--components-usage [mode]",
+    "Show components table/chart (table, chart)",
+    "table"
+  ).option(
+    "--patterns [mode]",
+    "Show patterns table/chart (table, chart)",
+    "table"
+  ).action(async (pattern, options) => {
+    const normalizedOptions = normalizeOptions(options);
+    await executeScan(pattern, normalizedOptions);
+  });
 }
-function createGitHubAnalysisReport(analysisResults, libraryName) {
-  const combined = generateCombinedReport(analysisResults);
-  const enhancedComponentFrequency = {};
-  Object.entries(analysisResults.repositories).forEach(
-    ([repoName, repoData]) => {
-      var _a;
-      const lockfileData = repoData.lockfile || {};
-      const version = (_a = lockfileData.versions) == null ? void 0 : _a[libraryName];
-      Object.entries(repoData.analysis.componentUsage).forEach(
-        ([component, usage]) => {
-          const key = version ? `${component} from ${libraryName}@${version}` : `${component} from ${libraryName}`;
-          if (!enhancedComponentFrequency[key]) {
-            enhancedComponentFrequency[key] = {
-              component,
-              library: libraryName,
-              version: version || "unknown",
-              count: 0,
-              repos: []
-            };
-          }
-          enhancedComponentFrequency[key].count += usage.count || 0;
-          enhancedComponentFrequency[key].repos.push({
-            name: repoName,
-            count: usage.count || 0
-          });
-        }
-      );
-    }
-  );
+function normalizeOptions(options) {
   return {
-    metadata: {
-      ...analysisResults.metadata,
-      library: libraryName,
-      repositories: Object.keys(analysisResults.repositories)
-    },
-    combined: {
-      ...combined,
-      enhancedComponentFrequency
-    },
-    repositories: analysisResults.repositories,
-    cloneErrors: analysisResults.cloneErrors
+    verbose: options.verbose || false,
+    summary: options.summary === false || options.summary === "false" ? false : "log",
+    details: options.details || false,
+    topComponents: options.topComponents || "log",
+    componentsUsage: options.componentsUsage || "table",
+    patterns: options.patterns || "table",
+    output: options.output
   };
 }
-function formatGitHubReport(report, options = {}) {
-  const { metadata, combined, repositories } = report;
-  console.log(chalk8__default.default.bold.cyan("\n" + "=".repeat(80)));
-  console.log(chalk8__default.default.bold.cyan("  \u{1F680} GITHUB REPOSITORIES ANALYSIS REPORT"));
-  console.log(chalk8__default.default.bold.cyan("=".repeat(80) + "\n"));
-  console.log(chalk8__default.default.bold("\u{1F4C8} SUMMARY:"));
-  console.log(chalk8__default.default.gray(`  Library: ${chalk8__default.default.cyan(metadata.library)}`));
-  console.log(
-    chalk8__default.default.gray(`  Repositories Analyzed: ${metadata.repositories.length}`)
-  );
-  console.log(
-    chalk8__default.default.gray(`  Total Components Found: ${combined.totalComponents.length}`)
-  );
-  console.log(
-    chalk8__default.default.gray(`  Total Imports Found: ${combined.totalImports.length}`)
-  );
-  const topComponents = Object.entries(combined.componentFrequency).sort((a, b) => b[1] - a[1]).slice(0, 10);
-  if (topComponents.length > 0) {
-    console.log(chalk8__default.default.bold("\n\u{1F3C6} TOP COMPONENTS (Across All Repos):"));
-    topComponents.forEach(([comp, count], idx) => {
-      const rank = idx + 1;
-      const emoji = rank === 1 ? "\u{1F947}" : rank === 2 ? "\u{1F948}" : rank === 3 ? "\u{1F949}" : "  ";
-      console.log(
-        `  ${emoji} ${rank}. ${chalk8__default.default.green(comp)}: ${chalk8__default.default.yellow(count)} uses`
-      );
-    });
-  }
-  if (combined.repoSummaries && combined.repoSummaries.length > 0) {
-    console.log(chalk8__default.default.bold("\n\u{1F4E6} REPOSITORY SUMMARIES:\n"));
-    combined.repoSummaries.forEach((summary, idx) => {
-      console.log(`  ${chalk8__default.default.bold(idx + 1 + ".")} ${chalk8__default.default.cyan(summary.name)}`);
-      console.log(`     Components: ${summary.components}`);
-      console.log(`     Files: ${summary.files}`);
-      if (summary.topComponents && summary.topComponents.length > 0) {
-        console.log(`     Top Components:`);
-        summary.topComponents.slice(0, 3).forEach((comp) => {
-          console.log(`       - ${comp.component}: ${comp.uses} uses`);
-        });
-      }
-      console.log("");
-    });
-  }
-  console.log(chalk8__default.default.bold("\u{1F50D} COMPONENT DISTRIBUTION:"));
-  Object.entries(combined.componentsByRepo).forEach(([repo, components]) => {
-    console.log(
-      `  ${chalk8__default.default.cyan(repo)}: ${components.length} unique components`
-    );
-  });
-  console.log(chalk8__default.default.bold.cyan("\n" + "=".repeat(80)));
-  console.log(chalk8__default.default.bold("\n\u{1F4A1} TIPS:"));
-  console.log("  \u2022 Use --keep-repos to inspect cloned repositories locally");
-  console.log("  \u2022 Use --branch <name> to analyze different branches");
-  console.log("  \u2022 Use --pattern to customize which files to analyze");
-  console.log("  \u2022 Use --config <file> to load repositories from JSON file");
-  console.log("  \u2022 JSON report contains detailed per-repo analysis");
-  console.log(chalk8__default.default.bold("\n\u{1F4DD} CONFIG FILE FORMAT:"));
-  console.log(
-    chalk8__default.default.gray(`  {
-    "repositories": [
-      "owner/repo1",
-      "owner/repo2",
-      "https://github.com/owner/repo3"
-    ]
-  }`)
-  );
-  console.log("");
-}
-
-// src/commands/github.ts
-async function githubCommand(repos, options) {
-  const spinner = ora6__default.default("Initializing GitHub analyzer...").start();
+async function executeScan(pattern, options) {
+  const startTime = Date.now();
+  const spinner = ora__default.default("Finding files...").start();
   try {
-    let repoList = repos || [];
-    if (options.config) {
-      spinner.text = `Loading repositories from ${options.config}...`;
-      try {
-        repoList = loadRepositoriesFromConfig(options.config);
-        spinner.succeed(
-          chalk8__default.default.green(`Loaded ${repoList.length} repositories from config`)
-        );
-        spinner.start();
-      } catch (error) {
-        spinner.fail(chalk8__default.default.red(`Failed to load config file: ${error.message}`));
-        process.exit(1);
-      }
-    }
-    if (repoList.length === 0) {
-      spinner.fail(
-        chalk8__default.default.red(
-          "No repositories specified. Use arguments or --config <file>"
-        )
-      );
-      console.log(
-        chalk8__default.default.yellow("\nExample: node cli.js github owner/repo1 owner/repo2")
-      );
-      console.log(chalk8__default.default.yellow("Or: node cli.js github --config repos.json"));
-      process.exit(1);
-    }
-    spinner.succeed(chalk8__default.default.green("GitHub analyzer initialized"));
-    const analyzer = options.complexity ? new FocusedUsageAnalyzer(options.library) : new ReactComponentUsageAnalyzer(options.library);
-    const results = await analyzeGitHubRepositories(repoList, analyzer, {
-      branch: options.branch,
-      pattern: options.pattern,
-      depth: parseInt(options.depth || "1"),
-      keepRepos: options.keepRepos
+    const files = await glob.glob(pattern, {
+      ignore: ["node_modules/**", "dist/**", "build/**", ".git/**"],
+      absolute: true
     });
-    const fullReport = createGitHubAnalysisReport(results, options.library);
-    fullReport.metadata = {
-      ...fullReport.metadata,
-      commandType: "github",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (options.format === "json" || options.format === "both") {
-      saveReport({
-        data: fullReport,
-        commandType: "github",
-        outputPath: options.output,
-        format: options.format
-      });
-    }
-    if (options.format === "console" || options.format === "both") {
-      formatGitHubReport(fullReport, options);
-    }
-  } catch (error) {
-    spinner.fail(chalk8__default.default.red("GitHub analysis failed: " + error.message));
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-// src/cli.ts
-var program = new commander.Command();
-program.name("react-usage-analyzer").description("Analyze React component usage patterns in your codebase").version("1.0.0");
-program.command("analyze").description(
-  "Analyze component usage patterns in files matching a glob pattern"
-).argument(
-  "<pattern>",
-  'Glob pattern for files to analyze (e.g., "src/**/*.tsx")'
-).option(
-  "-l, --library <name>",
-  "Library name to analyze (e.g., @mui/material)",
-  "@design-system/foundation"
-).option(
-  "-o, --output <file>",
-  "Output file path for JSON report (defaults to timestamped filename)"
-).option(
-  "-f, --format <type>",
-  "Output format: json, console, or both",
-  "both"
-).option("-c, --complexity", "Include complexity analysis", false).option(
-  "-s, --summary-only",
-  "Show only summary, not detailed patterns",
-  false
-).option(
-  "--ignore <patterns...>",
-  'Glob patterns to ignore (e.g., "**/*.test.tsx")',
-  []
-).option("--max-files <number>", "Maximum number of files to analyze", "1000").action(async (pattern, options) => {
-  await analyzeCommand(pattern, options);
-});
-program.command("compare").description("Compare usage patterns across multiple libraries").argument("<pattern>", "Glob pattern for files to analyze").option("-l, --libraries <names...>", "Library names to compare", [
-  "@mui/material",
-  "antd",
-  "@chakra-ui/react"
-]).option(
-  "-o, --output <file>",
-  "Output file path for comparison report (defaults to timestamped filename)"
-).option(
-  "-f, --format <type>",
-  "Output format: json, console, or both",
-  "both"
-).action(async (pattern, options) => {
-  await compareCommand(pattern, options);
-});
-program.command("summary").description("Generate a quick summary of component usage").argument("<pattern>", "Glob pattern for files to analyze").option(
-  "-l, --library <name>",
-  "Library name to analyze",
-  "@design-system/foundation"
-).option("--top <number>", "Number of top components to show", "10").action(async (pattern, options) => {
-  await summaryCommand(pattern, options);
-});
-program.command("patterns").description("List all detected usage patterns").argument("<pattern>", "Glob pattern for files to analyze").option(
-  "-l, --library <name>",
-  "Library name to analyze",
-  "@design-system/foundation"
-).option("--sort <by>", "Sort by: frequency, complexity, or name", "frequency").action(async (pattern, options) => {
-  await patternsCommand(pattern, options);
-});
-program.command("stats").description("Show detailed statistics about component usage").argument("<pattern>", "Glob pattern for files to analyze").option(
-  "-l, --library <name>",
-  "Library name to analyze",
-  "@design-system/foundation"
-).option("--chart", "Show ASCII charts", false).action(async (pattern, options) => {
-  await statsCommand(pattern, options);
-});
-program.command("table").description("Show components and imports in table format").argument("<pattern>", "Glob pattern for files to analyze").option(
-  "-l, --library <name>",
-  "Library name to analyze",
-  "@design-system/foundation"
-).option("-s, --sort <by>", "Sort by: uses, name, files, or props", "uses").option("-t, --top <number>", "Number of top items to show", "20").option("--props", "Show props analysis", false).action(async (pattern, options) => {
-  await tableCommand(pattern, options);
-});
-program.command("github").description("Analyze GitHub repositories").argument(
-  "[repos...]",
-  "GitHub repository URLs or owner/repo format (or use --config)"
-).option(
-  "-l, --library <name>",
-  "Library name to analyze",
-  "@design-system/foundation"
-).option("-b, --branch <name>", "Branch to analyze", "main").option(
-  "-p, --pattern <glob>",
-  "File pattern to analyze",
-  "**/*.{tsx,jsx,ts,js}"
-).option(
-  "-o, --output <file>",
-  "Output JSON file (defaults to timestamped filename)"
-).option(
-  "-f, --format <type>",
-  "Output format: json, console, or both",
-  "both"
-).option("--keep-repos", "Keep cloned repositories after analysis", false).option("--depth <number>", "Clone depth", "1").option("-c, --complexity", "Include complexity analysis", false).option("--config <file>", "Path to config file with repository list").action(async (repos, options) => {
-  await githubCommand(repos, options);
-});
-async function summaryCommand(pattern, options) {
-  const spinner = ora6__default.default("Generating summary...").start();
-  try {
-    const files = await findFiles2(pattern, [], 1e3);
     if (files.length === 0) {
-      spinner.fail(chalk8__default.default.red("No files found"));
+      spinner.fail(chalk__default.default.red(`No files found matching pattern: ${pattern}`));
       return;
     }
-    const analyzer = new ReactComponentUsageAnalyzer(options.library);
-    const componentUsage = {};
-    let totalFiles = 0;
-    for (const file of files) {
-      try {
-        const report = analyzer.analyzeFile(file);
-        if (report) {
-          totalFiles++;
-          report.patterns.usage.jsx.forEach((usage) => {
-            if (!componentUsage[usage.component]) {
-              componentUsage[usage.component] = { count: 0, files: /* @__PURE__ */ new Set() };
-            }
-            componentUsage[usage.component].count += usage.count;
-            componentUsage[usage.component].files.add(file);
-          });
-        }
-      } catch (error) {
+    spinner.succeed(chalk__default.default.green(`Found ${files.length} files`));
+    spinner.start("Analyzing files...");
+    const reports = [];
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (!options.verbose) {
+        spinner.text = `Analyzing files... (${i + 1}/${files.length})`;
       }
-    }
-    spinner.succeed(chalk8__default.default.green("Summary generated"));
-    console.log(chalk8__default.default.bold("\n\u{1F4CA} COMPONENT USAGE SUMMARY\n"));
-    console.log(chalk8__default.default.gray(`Library: ${options.library}`));
-    console.log(chalk8__default.default.gray(`Files analyzed: ${totalFiles}
-`));
-    const topN = parseInt(options.top);
-    const sorted = Object.entries(componentUsage).map(([comp, data]) => ({
-      comp,
-      count: data.count,
-      files: data.files.size
-    })).sort((a, b) => b.count - a.count).slice(0, topN);
-    console.log(chalk8__default.default.bold(`Top ${topN} Components:`));
-    sorted.forEach((item, index) => {
-      const rank = index + 1;
-      const emoji = rank === 1 ? "\u{1F947}" : rank === 2 ? "\u{1F948}" : rank === 3 ? "\u{1F949}" : "  ";
-      console.log(
-        `${emoji} ${rank}. ${chalk8__default.default.cyan(item.comp)}: ${chalk8__default.default.yellow(item.count)} uses in ${chalk8__default.default.green(item.files)} files`
-      );
-    });
-  } catch (error) {
-    spinner.fail(chalk8__default.default.red("Summary failed: " + error.message));
-  }
-}
-async function patternsCommand(pattern, options) {
-  const spinner = ora6__default.default("Analyzing patterns...").start();
-  try {
-    const files = await findFiles2(pattern, [], 1e3);
-    if (files.length === 0) {
-      spinner.fail(chalk8__default.default.red("No files found"));
-      return;
-    }
-    const analyzer = new FocusedUsageAnalyzer(options.library);
-    const patternStats = {};
-    for (const file of files) {
       try {
-        const report = analyzer.analyzeFile(file);
+        const report = parseFile(file);
         if (report) {
-          const analysis = analyzer.classifyUsage(report);
-          analysis.foundPatterns.forEach((data, patternName) => {
-            if (!patternStats[patternName]) {
-              patternStats[patternName] = {
-                count: 0,
-                complexity: data.complexity,
-                files: /* @__PURE__ */ new Set()
-              };
-            }
-            patternStats[patternName].count += data.count;
-            patternStats[patternName].files.add(file);
-          });
+          reports.push(report);
+          if (options.verbose) {
+            spinner.stop();
+            printVerbose(file, report);
+            spinner.start();
+          }
         }
       } catch (error) {
+        spinner.stop();
+        console.error(chalk__default.default.red(`Error analyzing ${file}: ${error.message}`));
+        spinner.start();
       }
     }
-    spinner.succeed(chalk8__default.default.green("Pattern analysis complete"));
-    console.log(chalk8__default.default.bold("\n\u{1F50D} USAGE PATTERNS DETECTED\n"));
-    let sorted = Object.entries(patternStats);
-    if (options.sort === "complexity") {
-      sorted = sorted.sort((a, b) => b[1].complexity - a[1].complexity);
-    } else if (options.sort === "frequency") {
-      sorted = sorted.sort((a, b) => b[1].count - a[1].count);
-    } else {
-      sorted = sorted.sort((a, b) => a[0].localeCompare(b[0]));
+    spinner.succeed(
+      chalk__default.default.green(`Analysis complete! Analyzed ${reports.length} files`)
+    );
+    const elapsedTime = (Date.now() - startTime) / 1e3;
+    const aggregated = aggregateReports(reports);
+    console.log("");
+    if (options.summary) {
+      printSummary(aggregated, elapsedTime);
     }
-    sorted.forEach(([name, stats]) => {
-      const icon = getComplexityIcon(stats.complexity);
-      console.log(`${icon} ${chalk8__default.default.bold(name)}`);
-      console.log(`   Complexity: ${stats.complexity}/10`);
-      console.log(`   Instances: ${chalk8__default.default.yellow(stats.count)}`);
-      console.log(`   Files: ${chalk8__default.default.green(stats.files.size)}`);
+    if (options.details) {
       console.log("");
-    });
-  } catch (error) {
-    spinner.fail(chalk8__default.default.red("Pattern analysis failed: " + error.message));
-  }
-}
-async function statsCommand(pattern, options) {
-  const spinner = ora6__default.default("Generating statistics...").start();
-  try {
-    const files = await findFiles2(pattern, [], 1e3);
-    if (files.length === 0) {
-      spinner.fail(chalk8__default.default.red("No files found"));
-      return;
-    }
-    const analyzer = new FocusedUsageAnalyzer(options.library);
-    const stats = {
-      totalFiles: files.length,
-      analyzedFiles: 0,
-      totalComponents: /* @__PURE__ */ new Set(),
-      totalPatterns: 0,
-      complexityDistribution: {
-        Simple: 0,
-        Moderate: 0,
-        Complex: 0,
-        "Very Complex": 0,
-        "Extremely Complex": 0
-      },
-      avgComplexity: 0,
-      topComponents: {},
-      topPatterns: {}
-    };
-    let totalComplexityScore = 0;
-    for (const file of files) {
-      try {
-        const report = analyzer.analyzeFile(file);
-        if (report) {
-          stats.analyzedFiles++;
-          report.components.forEach((comp) => stats.totalComponents.add(comp));
-          stats.totalPatterns += report.summary.totalUsagePatterns;
-          const analysis = analyzer.classifyUsage(report);
-          const complexity = analyzer.generateComplexityScore(
-            analysis.foundPatterns
-          );
-          stats.complexityDistribution[complexity.level]++;
-          totalComplexityScore += complexity.score;
-          report.patterns.usage.jsx.forEach((usage) => {
-            stats.topComponents[usage.component] = (stats.topComponents[usage.component] || 0) + usage.count;
-          });
-          analysis.foundPatterns.forEach((data, patternName) => {
-            stats.topPatterns[patternName] = (stats.topPatterns[patternName] || 0) + data.count;
-          });
-        }
-      } catch (error) {
-      }
+      printDetails(aggregated);
     }
-    stats.avgComplexity = stats.analyzedFiles > 0 ? totalComplexityScore / stats.analyzedFiles : 0;
-    stats.totalComponents = stats.totalComponents.size;
-    spinner.succeed(chalk8__default.default.green("Statistics generated"));
-    console.log(chalk8__default.default.bold("\n\u{1F4C8} DETAILED STATISTICS\n"));
-    console.log(chalk8__default.default.cyan("Overview:"));
-    console.log(`  Total Files: ${stats.totalFiles}`);
-    console.log(`  Analyzed Files: ${chalk8__default.default.green(stats.analyzedFiles)}`);
-    console.log(`  Unique Components: ${chalk8__default.default.yellow(stats.totalComponents)}`);
-    console.log(`  Total Patterns: ${chalk8__default.default.yellow(stats.totalPatterns)}`);
-    console.log(
-      `  Average Complexity: ${chalk8__default.default.yellow(stats.avgComplexity.toFixed(2))}`
-    );
-    console.log(chalk8__default.default.cyan("\nComplexity Distribution:"));
-    Object.entries(stats.complexityDistribution).forEach(([level, count]) => {
-      if (count > 0) {
-        const percentage = (count / stats.analyzedFiles * 100).toFixed(1);
-        const bar = options.chart ? createBar(count, stats.analyzedFiles, 30) : "";
-        console.log(
-          `  ${level.padEnd(20)} ${count.toString().padStart(4)} (${percentage}%) ${bar}`
-        );
-      }
-    });
-    console.log(chalk8__default.default.cyan("\nTop 5 Components:"));
-    Object.entries(stats.topComponents).sort((a, b) => b[1] - a[1]).slice(0, 5).forEach(([comp, count], index) => {
-      console.log(
-        `  ${index + 1}. ${comp.padEnd(30)} ${chalk8__default.default.yellow(count)} uses`
-      );
-    });
-    console.log(chalk8__default.default.cyan("\nTop 5 Patterns:"));
-    Object.entries(stats.topPatterns).sort((a, b) => b[1] - a[1]).slice(0, 5).forEach(([pattern2, count], index) => {
-      console.log(
-        `  ${index + 1}. ${pattern2.padEnd(30)} ${chalk8__default.default.yellow(count)} instances`
-      );
-    });
-  } catch (error) {
-    spinner.fail(chalk8__default.default.red("Stats generation failed: " + error.message));
-  }
-}
-async function tableCommand(pattern, options) {
-  const spinner = ora6__default.default("Generating table...").start();
-  try {
-    const files = await findFiles2(pattern, [], 1e3);
-    if (files.length === 0) {
-      spinner.fail(chalk8__default.default.red("No files found"));
-      return;
+    if (options.topComponents) {
+      console.log("");
+      printTopComponents(aggregated, options.topComponents);
     }
-    const analyzer = new ReactComponentUsageAnalyzer(options.library);
-    const componentData = {};
-    const importData = {};
-    for (const file of files) {
-      try {
-        const report = analyzer.analyzeFile(file);
-        if (report) {
-          report.patterns.usage.jsx.forEach((usage) => {
-            if (!componentData[usage.component]) {
-              componentData[usage.component] = {
-                uses: 0,
-                files: /* @__PURE__ */ new Set(),
-                props: /* @__PURE__ */ new Set(),
-                spreadProps: 0,
-                propsDetails: []
-              };
-            }
-            componentData[usage.component].uses += usage.count;
-            componentData[usage.component].files.add(file);
-            usage.usages.forEach((u) => {
-              if (u.propsAnalysis) {
-                u.propsAnalysis.namedProps.forEach(
-                  (prop) => componentData[usage.component].props.add(prop)
-                );
-                if (u.propsAnalysis.hasSpread) {
-                  componentData[usage.component].spreadProps++;
-                }
-              }
-            });
-          });
-          [
-            ...report.patterns.imports.default,
-            ...report.patterns.imports.named
-          ].forEach((imp) => {
-            const name = imp.name || imp.local;
-            if (!importData[name]) {
-              importData[name] = {
-                files: /* @__PURE__ */ new Set(),
-                type: imp.imported ? "named" : "default"
-              };
-            }
-            importData[name].files.add(file);
-          });
-        }
-      } catch (error) {
-      }
+    if (options.componentsUsage) {
+      console.log("");
+      printComponentsUsage(aggregated, options.componentsUsage);
     }
-    spinner.succeed(chalk8__default.default.green("Table generated"));
-    Object.keys(componentData).forEach((key) => {
-      componentData[key].filesCount = componentData[key].files.size;
-      componentData[key].propsCount = componentData[key].props.size;
-      componentData[key].propsList = Array.from(componentData[key].props);
-    });
-    Object.keys(importData).forEach((key) => {
-      importData[key].filesCount = importData[key].files.size;
-    });
-    const sortedComponents = Object.entries(componentData).sort((a, b) => {
-      switch (options.sort) {
-        case "name":
-          return a[0].localeCompare(b[0]);
-        case "files":
-          return b[1].filesCount - a[1].filesCount;
-        case "props":
-          return b[1].propsCount - a[1].propsCount;
-        case "uses":
-        default:
-          return b[1].uses - a[1].uses;
-      }
-    }).slice(0, parseInt(options.top));
-    const sortedImports = Object.entries(importData).sort((a, b) => {
-      if (options.sort === "name") {
-        return a[0].localeCompare(b[0]);
-      }
-      return b[1].filesCount - a[1].filesCount;
-    }).slice(0, parseInt(options.top));
-    console.log(chalk8__default.default.bold("\n\u{1F4CA} COMPONENT USAGE TABLE\n"));
-    const componentTable = new Table2__default.default({
-      head: [
-        chalk8__default.default.cyan("Component"),
-        chalk8__default.default.cyan("Uses"),
-        chalk8__default.default.cyan("Files"),
-        ...options.props ? [chalk8__default.default.cyan("Props"), chalk8__default.default.cyan("Spread")] : []
-      ],
-      colWidths: [30, 10, 10, ...options.props ? [40, 10] : []],
-      style: { head: [], border: [] }
-    });
-    sortedComponents.forEach(([component, data]) => {
-      const row = [
-        component,
-        chalk8__default.default.yellow(data.uses),
-        chalk8__default.default.green(data.filesCount)
-      ];
-      if (options.props) {
-        const propsDisplay = data.propsCount > 0 ? data.propsList.slice(0, 5).join(", ") + (data.propsCount > 5 ? "..." : "") : "-";
-        const spreadDisplay = data.spreadProps > 0 ? chalk8__default.default.red(`\u26A0 ${data.spreadProps}`) : chalk8__default.default.gray("0");
-        row.push(propsDisplay, spreadDisplay);
-      }
-      componentTable.push(row);
-    });
-    console.log(componentTable.toString());
-    console.log(chalk8__default.default.bold("\n\u{1F4E6} IMPORTS TABLE\n"));
-    const importTable = new Table2__default.default({
-      head: [chalk8__default.default.cyan("Import"), chalk8__default.default.cyan("Type"), chalk8__default.default.cyan("Files")],
-      colWidths: [30, 15, 10],
-      style: { head: [], border: [] }
-    });
-    sortedImports.forEach(([name, data]) => {
-      importTable.push([
-        name,
-        data.type === "named" ? chalk8__default.default.blue("named") : chalk8__default.default.green("default"),
-        chalk8__default.default.yellow(data.filesCount)
-      ]);
-    });
-    console.log(importTable.toString());
-    if (options.props) {
-      console.log(chalk8__default.default.bold("\n\u{1F527} PROPS ANALYSIS\n"));
-      sortedComponents.forEach(([component, data]) => {
-        if (data.propsCount > 0 || data.spreadProps > 0) {
-          console.log(chalk8__default.default.cyan(`${component}:`));
-          console.log(`  Props: ${data.propsList.join(", ")}`);
-          if (data.spreadProps > 0) {
-            console.log(
-              chalk8__default.default.yellow(
-                `  \u26A0 Warning: ${data.spreadProps} usage(s) with spread props (cannot analyze statically)`
-              )
-            );
-          }
-          console.log("");
-        }
-      });
+    if (options.patterns) {
+      console.log("");
+      printPatterns(aggregated, options.patterns);
     }
-    console.log(chalk8__default.default.bold("\u{1F4C8} SUMMARY"));
-    console.log(`  Total Components: ${Object.keys(componentData).length}`);
-    console.log(`  Total Imports: ${Object.keys(importData).length}`);
-    console.log(`  Files Analyzed: ${files.length}`);
-    console.log(`  Sort: ${options.sort}`);
   } catch (error) {
-    spinner.fail(chalk8__default.default.red("Table generation failed: " + error.message));
+    spinner.fail(chalk__default.default.red("Analysis failed: " + error.message));
+    console.error(error);
+    process.exit(1);
   }
 }
-async function findFiles2(pattern, ignorePatterns, maxFiles) {
-  const allFiles = await glob.glob(pattern, {
-    ignore: ["node_modules/**", "dist/**", "build/**", ...ignorePatterns],
-    nodir: true,
-    absolute: false,
-    // Support all React file types
-    matchBase: false
-  });
-  const reactFiles = allFiles.filter((file) => {
-    const ext = path__default.default.extname(file).toLowerCase();
-    return [".tsx", ".jsx", ".ts", ".js"].includes(ext);
-  });
-  return reactFiles.slice(0, maxFiles);
-}
-function getComplexityIcon(complexity) {
-  if (complexity <= 2) return chalk8__default.default.green("\u{1F7E2}");
-  if (complexity <= 4) return chalk8__default.default.yellow("\u{1F7E1}");
-  if (complexity <= 6) return chalk8__default.default.hex("#FFA500")("\u{1F7E0}");
-  return chalk8__default.default.red("\u{1F534}");
-}
-function createBar(value, max, width) {
-  const filled = Math.round(value / max * width);
-  const empty = width - filled;
-  return chalk8__default.default.green("\u2588".repeat(filled)) + chalk8__default.default.gray("\u2591".repeat(empty));
-}
+
+// package.json
+var package_default = {
+  version: "1.0.0-beta.1"};
+
+// src/cli.ts
+var program = new commander.Command();
+program.name("hermex").description("Analyze React component usage patterns in your codebase").version(package_default.version);
+registerScanCommand(program);
 program.parse(process.argv);
-if (process.argv.length < 3) {
-  program.help();
-}
+
+exports.program = program;
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map