hermex 0.0.1-alpha.0

package/dist/cli.js

@@ -0,0 +1,2696 @@
+#!/usr/bin/env node
+'use strict';
+
+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 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');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
+var ora6__default = /*#__PURE__*/_interopDefault(ora6);
+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 __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);
+        break;
+      case "ClassDeclaration":
+        this.analyzeClassDeclaration(node);
+        break;
+      default:
+        this.visitChildren(node);
+        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;
+      }
+    });
+  }
+  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);
+      }
+    }
+    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);
+    }
+    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}`);
+        }
+      }
+    }
+  }
+  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
+      });
+      console.log(`\u26A1 Found dynamic import: ${source}`);
+    }
+  }
+  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);
+      }
+    });
+    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
+          });
+          this.componentNames.add(propName);
+          console.log(`\u{1F527} Destructuring: ${propName} from ${init.value}`);
+        }
+      }
+    });
+  }
+  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
+        });
+      }
+      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 "";
+    }
+  }
+  isMemberExpressionComponent(nameNode) {
+    if ((nameNode == null ? void 0 : nameNode.type) === "JSXMemberExpression") {
+      const objectName = this.getJSXElementName(nameNode.object);
+      return this.allIdentifiers.has(objectName);
+    }
+    return false;
+  }
+  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") {
+        return {
+          name: "...",
+          value: "[spread]",
+          isSpread: true
+        };
+      }
+      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]";
+    }
+  }
+  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"
+        });
+        analysis.hasComplexProps = true;
+      }
+    });
+    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;
+  }
+  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;
+    });
+    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`);
+    }
+    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);
+      }
+      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);
+  }
+  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);
+  }
+  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";
+    });
+  }
+  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
+    });
+  }
+  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}`);
+    }
+  }
+  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`);
+  }
+  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}`);
+      }
+    }
+    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;
+    }
+  }
+  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";
+    }
+  }
+  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
+        )
+      },
+      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
+          })
+        )
+      },
+      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}"`
+        );
+      });
+    }
+    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}"`);
+      });
+    }
+    if (report.patterns.imports.aliased.length > 0) {
+      console.log(
+        `   Aliased Imports (${report.patterns.imports.aliased.length}):`
+      );
+      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:`);
+    console.log(
+      `   Overall Score: ${complexity.score}/${complexity.maxPossible}`
+    );
+    console.log(
+      `   Complexity Level: ${complexity.level} (${complexity.percentage}%)`
+    );
+    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
+    );
+    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)}%`);
+    console.log(
+      `   Usage Intensity: ${this.getUsageIntensity(complexity.score)}`
+    );
+    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}";
+  }
+}
+
+// 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
+    );
+    spinner.succeed(
+      chalk8__default.default.green(
+        `Analysis complete! Analyzed ${aggregatedReport.metadata.filesAnalyzed} files`
+      )
+    );
+    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) {
+    console.log(
+      `  Files with Errors: ${chalk8__default.default.red(report.metadata.filesWithErrors)}`
+    );
+  }
+  console.log(
+    `  Total Components: ${chalk8__default.default.yellow(report.aggregated.allComponents.length)}`
+  );
+  console.log(
+    `  Total Imports: ${chalk8__default.default.yellow(report.aggregated.totalImports)}`
+  );
+  console.log(
+    `  Total Usage Patterns: ${chalk8__default.default.yellow(report.aggregated.totalUsagePatterns)}`
+  );
+  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(
+        `  Average Complexity: ${chalk8__default.default.yellow(avgComplexity.toFixed(2))}`
+      );
+      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`
+      );
+    }
+  }
+  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);
+  }
+}
+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);
+    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 });
+      }
+    );
+  });
+}
+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();
+    }
+  }
+  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;
+}
+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;
+}
+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 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 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);
+    }
+    return versions;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: Could not parse package-lock.json: ${message}`);
+    return {};
+  }
+}
+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 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 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
+      };
+    }
+  }
+  return {
+    versions: {},
+    lockfileType: null,
+    lockfilePath: null,
+    found: false
+  };
+}
+function readFile(filePath) {
+  return fs5__default.default.readFileSync(filePath, "utf8");
+}
+function readJsonFile(filePath) {
+  const content = readFile(filePath);
+  return JSON.parse(content);
+}
+
+// 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}`);
+  }
+}
+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
+          });
+        }
+      );
+    }
+  );
+  return {
+    metadata: {
+      ...analysisResults.metadata,
+      library: libraryName,
+      repositories: Object.keys(analysisResults.repositories)
+    },
+    combined: {
+      ...combined,
+      enhancedComponentFrequency
+    },
+    repositories: analysisResults.repositories,
+    cloneErrors: analysisResults.cloneErrors
+  };
+}
+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();
+  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 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"));
+      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(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);
+        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);
+          });
+        }
+      } catch (error) {
+      }
+    }
+    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]));
+    }
+    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)}`);
+      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) {
+      }
+    }
+    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;
+    }
+    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) {
+      }
+    }
+    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("");
+        }
+      });
+    }
+    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));
+  }
+}
+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));
+}
+program.parse(process.argv);
+if (process.argv.length < 3) {
+  program.help();
+}
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map