hermex 1.1.2 → 1.3.0-beta.1

package/dist/cli.js

@@ -1,1462 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import ora from 'ora';
-import chalk5 from 'chalk';
-import { minimatch } from 'minimatch';
-import { parseSync } from '@swc/core';
-import fs3 from 'fs';
-import Table from 'cli-table3';
-import { glob } from 'glob';
-import path from 'path';
-import yaml from 'js-yaml';
-import lockfile from '@yarnpkg/lockfile';
-
-// src/swc-parser/core/state.ts
-function createState() {
-  const usagePatterns = {
-    directImports: /* @__PURE__ */ new Set(),
-    namedImports: /* @__PURE__ */ new Set(),
-    namespaceImports: /* @__PURE__ */ new Set(),
-    defaultImports: /* @__PURE__ */ new Set(),
-    aliasedImports: /* @__PURE__ */ new Map(),
-    variableAssignments: /* @__PURE__ */ new Map(),
-    componentMappings: /* @__PURE__ */ new Set(),
-    lazyImports: /* @__PURE__ */ new Set(),
-    dynamicImports: /* @__PURE__ */ new Set(),
-    conditionalUsage: /* @__PURE__ */ new Set(),
-    arrayMappings: /* @__PURE__ */ new Set(),
-    objectMappings: /* @__PURE__ */ new Set(),
-    hocUsage: /* @__PURE__ */ new Set(),
-    renderProps: /* @__PURE__ */ new Set(),
-    contextUsage: /* @__PURE__ */ new Set(),
-    forwardedRefs: /* @__PURE__ */ new Set(),
-    memoizedComponents: /* @__PURE__ */ new Set(),
-    portalUsage: /* @__PURE__ */ new Set(),
-    jsxUsage: /* @__PURE__ */ new Map(),
-    destructuredUsage: /* @__PURE__ */ new Set(),
-    propsAnalysis: /* @__PURE__ */ new Map()
-  };
-  return {
-    usagePatterns,
-    componentNames: /* @__PURE__ */ new Set(),
-    allIdentifiers: /* @__PURE__ */ new Set()
-  };
-}
-
-// src/swc-parser/patterns/imports.ts
-function analyzeImportDeclaration(node, state) {
-  const source = node.source.value;
-  for (const spec of node.specifiers) {
-    switch (spec.type) {
-      case "ImportDefaultSpecifier":
-        analyzeDefaultImport(spec, source, node, state);
-        break;
-      case "ImportNamespaceSpecifier":
-        analyzeNamespaceImport(spec, source, node, state);
-        break;
-      case "ImportSpecifier":
-        analyzeNamedImport(spec, source, node, state);
-        break;
-    }
-  }
-}
-function analyzeDefaultImport(spec, source, node, state) {
-  const name = spec.local.value;
-  state.usagePatterns.defaultImports.add({
-    name,
-    source,
-    line: node.span?.start || 0
-  });
-  state.componentNames.add(name);
-}
-function analyzeNamespaceImport(spec, source, node, state) {
-  const name = spec.local.value;
-  state.usagePatterns.namespaceImports.add({
-    name,
-    source,
-    line: node.span?.start || 0
-  });
-  state.allIdentifiers.add(name);
-}
-function analyzeNamedImport(spec, source, node, state) {
-  const importedName = spec.imported ? spec.imported.value : spec.local.value;
-  const localName = spec.local.value;
-  state.usagePatterns.namedImports.add({
-    name: importedName,
-    source,
-    line: node.span?.start || 0
-  });
-  if (importedName !== localName) {
-    state.usagePatterns.aliasedImports.set(localName, {
-      imported: importedName,
-      local: localName,
-      source,
-      line: node.span?.start || 0
-    });
-  }
-  state.componentNames.add(localName);
-}
-
-// src/swc-parser/utils/jsx-helpers.ts
-function getJSXElementName(nameNode) {
-  if (!nameNode) return "";
-  switch (nameNode.type) {
-    case "Identifier":
-      return nameNode.value;
-    case "JSXMemberExpression":
-      return `${getJSXElementName(nameNode.object)}.${nameNode.property.value}`;
-    default:
-      return "";
-  }
-}
-function isMemberExpressionComponent(nameNode, state) {
-  if (nameNode?.type === "JSXMemberExpression") {
-    const objectName = getJSXElementName(nameNode.object);
-    return state.allIdentifiers.has(objectName);
-  }
-  return false;
-}
-function extractJSXProps(attributes) {
-  if (!attributes) return [];
-  return attributes.map((attr) => {
-    if (attr.type === "JSXAttribute") {
-      return {
-        name: attr.name?.value || attr.name?.name?.value,
-        value: extractJSXAttributeValue(attr.value)
-      };
-    }
-    if (attr.type === "SpreadElement") {
-      return {
-        name: "...",
-        value: "[spread]",
-        isSpread: true
-      };
-    }
-    return null;
-  }).filter(Boolean);
-}
-function extractJSXAttributeValue(value) {
-  if (!value) return true;
-  switch (value.type) {
-    case "StringLiteral":
-      return value.value;
-    case "JSXExpressionContainer":
-      return extractExpressionValue(value.expression);
-    default:
-      return "[complex]";
-  }
-}
-function extractExpressionValue(expr) {
-  if (!expr) return "[unknown]";
-  switch (expr.type) {
-    case "StringLiteral":
-    case "NumericLiteral":
-    case "BooleanLiteral":
-      return expr.value;
-    case "Identifier":
-      return `{${expr.value}}`;
-    case "ArrowFunctionExpression":
-    case "FunctionExpression":
-      return "[function]";
-    case "ObjectExpression":
-      return "[object]";
-    case "ArrayExpression":
-      return "[array]";
-    default:
-      return "[expression]";
-  }
-}
-function getUsageContext(parent) {
-  if (!parent) return "direct";
-  switch (parent.type) {
-    case "ConditionalExpression":
-      return "conditional";
-    case "ArrayExpression":
-      return "array";
-    case "ObjectExpression":
-      return "object";
-    case "CallExpression":
-      return "hoc";
-    case "VariableDeclarator":
-      return "variable";
-    default:
-      return "jsx";
-  }
-}
-
-// src/swc-parser/patterns/props.ts
-function analyzePropsInDetail(attributes, componentName, state) {
-  const analysis = {
-    namedProps: [],
-    hasSpread: false,
-    hasComplexProps: false,
-    hasEventHandlers: false,
-    propDetails: []
-  };
-  if (!attributes) return analysis;
-  for (const attr of attributes) {
-    if (attr.type === "JSXAttribute") {
-      const propName = attr.name?.value || attr.name?.name?.value;
-      if (propName) {
-        analysis.namedProps.push(propName);
-        const propDetail = {
-          name: propName,
-          type: getPropType(attr.value),
-          isEventHandler: propName.startsWith("on"),
-          isComplex: isComplexProp(attr.value)
-        };
-        if (propDetail.isEventHandler) {
-          analysis.hasEventHandlers = true;
-        }
-        if (propDetail.isComplex) {
-          analysis.hasComplexProps = true;
-        }
-        analysis.propDetails.push(propDetail);
-      }
-    } else if (attr.type === "SpreadElement") {
-      analysis.hasSpread = true;
-      analysis.propDetails.push({
-        name: "...",
-        type: "spread",
-        isSpread: true,
-        isComplex: true,
-        isEventHandler: false,
-        warning: "Spread props cannot be statically analyzed"
-      });
-      analysis.hasComplexProps = true;
-    }
-  }
-  state.usagePatterns.propsAnalysis.set(componentName, analysis);
-  return analysis;
-}
-function getPropType(value) {
-  if (!value) return "boolean";
-  switch (value.type) {
-    case "StringLiteral":
-      return "string";
-    case "JSXExpressionContainer": {
-      const expr = value.expression;
-      if (!expr) return "unknown";
-      switch (expr.type) {
-        case "NumericLiteral":
-          return "number";
-        case "BooleanLiteral":
-          return "boolean";
-        case "StringLiteral":
-          return "string";
-        case "ArrowFunctionExpression":
-        case "FunctionExpression":
-          return "function";
-        case "ObjectExpression":
-          return "object";
-        case "ArrayExpression":
-          return "array";
-        case "Identifier":
-          return "variable";
-        default:
-          return "expression";
-      }
-    }
-    default:
-      return "unknown";
-  }
-}
-function isComplexProp(value) {
-  if (!value) return false;
-  if (value.type === "JSXExpressionContainer") {
-    const expr = value.expression;
-    if (!expr) return false;
-    return expr.type === "ObjectExpression" || expr.type === "ArrayExpression" || expr.type === "CallExpression" || expr.type === "ConditionalExpression";
-  }
-  return false;
-}
-
-// src/swc-parser/patterns/jsx.ts
-function analyzeJSXElement(node, state) {
-  if (node.opening) {
-    analyzeJSXOpeningElement(node.opening, state, node);
-  }
-}
-function analyzeJSXOpeningElement(node, state, parent) {
-  const elementName = getJSXElementName(node.name);
-  if (!state.componentNames.has(elementName) && !isMemberExpressionComponent(node.name, state)) {
-    return;
-  }
-  const propsAnalysis = analyzePropsInDetail(
-    node.attributes,
-    elementName,
-    state
-  );
-  const usage = {
-    component: elementName,
-    props: extractJSXProps(node.attributes).map((p) => p.name),
-    propsAnalysis,
-    line: node.span?.start || 0,
-    context: getUsageContext(parent)
-  };
-  if (!state.usagePatterns.jsxUsage.has(elementName)) {
-    state.usagePatterns.jsxUsage.set(elementName, usage);
-  }
-}
-
-// src/swc-parser/utils/matchers.ts
-function isKnownComponent(name, state) {
-  return state.componentNames.has(name) || state.allIdentifiers.has(name);
-}
-
-// src/swc-parser/patterns/variables.ts
-function analyzeVariableDeclaration(node, state) {
-  if (!node.declarations) return;
-  for (const decl of node.declarations) {
-    if (decl.id?.type === "Identifier") {
-      const varName = decl.id.value;
-      if (decl.init) {
-        const assignment = extractAssignmentInfo(decl.init);
-        if (assignment && isKnownComponent(assignment, state)) {
-          state.usagePatterns.variableAssignments.set(varName, {
-            assignment,
-            line: node.span?.start || 0
-          });
-          state.componentNames.add(varName);
-        }
-      }
-    }
-    if (decl.id?.type === "ObjectPattern") {
-      analyzeDestructuringPattern(decl.id, decl.init, state);
-    }
-  }
-}
-function analyzeDestructuringPattern(pattern, init, state) {
-  if (!pattern.properties) return;
-  for (const prop of pattern.properties) {
-    if (prop.type === "AssignmentPatternProperty" && prop.key?.type === "Identifier") {
-      const propName = prop.key.value;
-      if (init?.type === "Identifier" && state.allIdentifiers.has(init.value)) {
-        state.usagePatterns.destructuredUsage.add({
-          property: propName,
-          source: init.value,
-          line: pattern.span?.start || 0
-        });
-        state.componentNames.add(propName);
-      }
-    }
-  }
-}
-function extractAssignmentInfo(node) {
-  switch (node.type) {
-    case "Identifier":
-      return node.value;
-    case "MemberExpression":
-      return `${extractAssignmentInfo(node.object)}.${node.property.value}`;
-    case "ConditionalExpression":
-      return `${extractAssignmentInfo(node.consequent)} | ${extractAssignmentInfo(node.alternate)}`;
-    default:
-      return null;
-  }
-}
-
-// src/swc-parser/patterns/conditionals.ts
-function analyzeConditionalExpression(node, state) {
-  const consequent = node.consequent?.type === "Identifier" ? node.consequent.value : null;
-  const alternate = node.alternate?.type === "Identifier" ? node.alternate.value : null;
-  if (consequent && state.componentNames.has(consequent) || alternate && state.componentNames.has(alternate)) {
-    state.usagePatterns.conditionalUsage.add({
-      consequent: consequent || "",
-      alternate: alternate || "",
-      line: node.span?.start || 0
-    });
-  }
-}
-
-// src/swc-parser/patterns/collections.ts
-function analyzeArrayExpression(node, state) {
-  const hasComponents = node.elements?.some((elem) => {
-    if (elem?.type === "Identifier") {
-      return state.componentNames.has(elem.value);
-    }
-    return false;
-  });
-  if (hasComponents) {
-    state.usagePatterns.arrayMappings.add({
-      components: node.elements?.map((elem) => elem?.value).filter(Boolean),
-      line: node.span?.start || 0
-    });
-  }
-}
-function analyzeObjectExpression(node, state) {
-  const componentProps = node.properties?.filter((prop) => {
-    if (prop.type === "KeyValueProperty" && prop.value?.type === "Identifier") {
-      return state.componentNames.has(prop.value.value);
-    }
-    return false;
-  });
-  if (componentProps?.length > 0) {
-    state.usagePatterns.objectMappings.add({
-      mappings: componentProps.map((prop) => ({
-        key: prop.key?.value || "[computed]",
-        component: prop.value?.value
-      })),
-      line: node.span?.start || 0
-    });
-  }
-}
-
-// src/swc-parser/patterns/lazy-dynamic.ts
-function analyzeLazyImport(node, state) {
-  const arg = node.arguments?.[0];
-  if (arg?.type === "ArrowFunctionExpression" && arg.body?.type === "CallExpression") {
-    const importCall = arg.body;
-    if (importCall.callee?.type === "Import") {
-      const source = importCall.arguments?.[0]?.value;
-      if (source) {
-        state.usagePatterns.lazyImports.add({
-          source,
-          line: node.span?.start || 0
-        });
-      }
-    }
-  }
-}
-function analyzeDynamicImport(node, state) {
-  const source = node.arguments?.[0]?.value;
-  if (source) {
-    state.usagePatterns.dynamicImports.add({
-      source,
-      line: node.span?.start || 0
-    });
-  }
-}
-
-// src/swc-parser/patterns/advanced.ts
-function analyzeHOCUsage(node, state) {
-  state.usagePatterns.hocUsage.add({
-    function: node.callee?.value || "[unknown]",
-    component: node.arguments?.[0]?.value || "[unknown]",
-    line: node.span?.start || 0
-  });
-}
-function analyzeMemoUsage(node, state) {
-  const component = node.arguments?.[0];
-  if (component?.type === "Identifier" && state.componentNames.has(component.value)) {
-    state.usagePatterns.memoizedComponents.add({
-      component: component.value,
-      line: node.span?.start || 0
-    });
-  }
-}
-function analyzeForwardRefUsage(node, state) {
-  state.usagePatterns.forwardedRefs.add({
-    line: node.span?.start || 0
-  });
-}
-function analyzePortalUsage(node, state) {
-  state.usagePatterns.portalUsage.add({
-    line: node.span?.start || 0
-  });
-}
-function analyzeMemberExpression(node, state) {
-  if (node.object?.type === "Identifier" && state.allIdentifiers.has(node.object.value)) {
-    const propertyName = node.property?.value;
-    if (propertyName) {
-      state.componentNames.add(propertyName);
-    }
-  }
-}
-function isHOCPattern(node, state) {
-  return node.callee?.type === "Identifier" && node.arguments?.some(
-    (arg) => arg.type === "Identifier" && state.componentNames.has(arg.value)
-  );
-}
-
-// src/swc-parser/core/visitor.ts
-function visitNode(node, state, context = {}) {
-  if (!node) return;
-  switch (node.type) {
-    case "Module":
-      if (node.body) {
-        for (const item of node.body) {
-          if (item.type === "ImportDeclaration") {
-            visitNode(item, state, context);
-          }
-        }
-        for (const item of node.body) {
-          if (item.type !== "ImportDeclaration") {
-            visitNode(item, state, { ...context, parent: node });
-          }
-        }
-      }
-      break;
-    case "ImportDeclaration":
-      analyzeImportDeclaration(node, state);
-      break;
-    case "CallExpression":
-      analyzeCallExpression(node, state, context);
-      break;
-    case "VariableDeclaration":
-      analyzeVariableDeclaration(node, state);
-      visitChildren(node, state, context);
-      break;
-    case "JSXElement":
-    case "JSXFragment":
-      analyzeJSXElement(node, state);
-      visitChildren(node, state, context);
-      break;
-    case "JSXOpeningElement":
-      analyzeJSXOpeningElement(node, state, context.parent);
-      break;
-    case "ArrayExpression":
-      analyzeArrayExpression(node, state);
-      visitChildren(node, state, context);
-      break;
-    case "ObjectExpression":
-      analyzeObjectExpression(node, state);
-      visitChildren(node, state, context);
-      break;
-    case "MemberExpression":
-      analyzeMemberExpression(node, state);
-      visitChildren(node, state, context);
-      break;
-    case "ConditionalExpression":
-      analyzeConditionalExpression(node, state);
-      visitChildren(node, state, context);
-      break;
-    case "FunctionDeclaration":
-    case "ClassDeclaration":
-    case "ExpressionStatement":
-    case "ReturnStatement":
-    case "VariableDeclarator":
-    case "ArrowFunctionExpression":
-    case "FunctionExpression":
-      visitChildren(node, state, { ...context, parent: node });
-      break;
-    default:
-      visitChildren(node, state, context);
-      break;
-  }
-}
-function analyzeCallExpression(node, state, context) {
-  if (node.callee?.value === "lazy" || node.callee?.object?.value === "React" && node.callee?.property?.value === "lazy") {
-    analyzeLazyImport(node, state);
-  }
-  if (node.callee?.type === "Import") {
-    analyzeDynamicImport(node, state);
-  }
-  if (isHOCPattern(node, state)) {
-    analyzeHOCUsage(node, state);
-  }
-  if (node.callee?.object?.value === "React") {
-    if (node.callee?.property?.value === "memo") {
-      analyzeMemoUsage(node, state);
-    } else if (node.callee?.property?.value === "forwardRef") {
-      analyzeForwardRefUsage(node, state);
-    }
-  }
-  if (node.callee?.property?.value === "createPortal" || node.callee?.value === "createPortal") {
-    analyzePortalUsage(node, state);
-  }
-  visitChildren(node, state, context);
-}
-function visitChildren(node, state, context) {
-  if (!node) return;
-  for (const key in node) {
-    const value = node[key];
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item && typeof item === "object") {
-          visitNode(item, state, { ...context, parent: node });
-        }
-      }
-    } else if (value && typeof value === "object" && value.type) {
-      visitNode(value, state, { ...context, parent: node });
-    }
-  }
-}
-
-// src/swc-parser/core/report.ts
-function generateReport(state) {
-  const report = {
-    summary: {
-      totalImports: state.usagePatterns.defaultImports.size + state.usagePatterns.namedImports.size + state.usagePatterns.namespaceImports.size,
-      totalComponents: state.componentNames.size,
-      totalUsagePatterns: calculateTotalPatterns(state)
-    },
-    patterns: {
-      imports: {
-        default: Array.from(state.usagePatterns.defaultImports),
-        named: Array.from(state.usagePatterns.namedImports),
-        namespace: Array.from(state.usagePatterns.namespaceImports),
-        aliased: Array.from(state.usagePatterns.aliasedImports.values())
-      },
-      usage: {
-        jsx: Array.from(state.usagePatterns.jsxUsage.values()),
-        variables: Array.from(
-          state.usagePatterns.variableAssignments.entries()
-        ).map(([key, value]) => ({
-          variable: key,
-          assignment: value.assignment
-        })),
-        destructuring: Array.from(state.usagePatterns.destructuredUsage),
-        conditional: Array.from(state.usagePatterns.conditionalUsage),
-        arrays: Array.from(state.usagePatterns.arrayMappings),
-        objects: Array.from(state.usagePatterns.objectMappings)
-      },
-      advanced: {
-        lazy: Array.from(state.usagePatterns.lazyImports),
-        dynamic: Array.from(state.usagePatterns.dynamicImports),
-        hoc: Array.from(state.usagePatterns.hocUsage),
-        memo: Array.from(state.usagePatterns.memoizedComponents),
-        forwardRef: Array.from(state.usagePatterns.forwardedRefs),
-        portal: Array.from(state.usagePatterns.portalUsage)
-      },
-      props: Array.from(state.usagePatterns.propsAnalysis.entries()).map(
-        ([component, analysis]) => ({
-          component,
-          analysis
-        })
-      )
-    },
-    components: Array.from(state.componentNames).sort()
-  };
-  return report;
-}
-function calculateTotalPatterns(state) {
-  let sum = 0;
-  const patterns = state.usagePatterns;
-  for (const key in patterns) {
-    const pattern = patterns[key];
-    if (pattern instanceof Set) {
-      sum += pattern.size;
-    } else if (pattern instanceof Map) {
-      sum += pattern.size;
-    }
-  }
-  return sum;
-}
-
-// src/swc-parser/index.ts
-function parseCode(code, options = {}) {
-  const state = createState();
-  const ast = parseSync(code, {
-    syntax: "typescript",
-    tsx: true,
-    decorators: true,
-    dynamicImport: true
-  });
-  visitNode(ast, state);
-  const report = generateReport(state);
-  if (options.libraryName) {
-    return filterReportByLibrary(report, options.libraryName);
-  }
-  return report;
-}
-function parseFile(filePath, options = {}) {
-  const code = fs3.readFileSync(filePath, "utf8");
-  return parseCode(code, options);
-}
-function filterReportByLibrary(report, libraryName) {
-  const isFromLibrary = (source) => source.startsWith(libraryName) || source.includes(libraryName);
-  return {
-    ...report,
-    patterns: {
-      imports: {
-        default: report.patterns.imports.default.filter(
-          (imp) => isFromLibrary(imp.source)
-        ),
-        named: report.patterns.imports.named.filter(
-          (imp) => isFromLibrary(imp.source)
-        ),
-        namespace: report.patterns.imports.namespace.filter(
-          (imp) => isFromLibrary(imp.source)
-        ),
-        aliased: report.patterns.imports.aliased.filter(
-          (imp) => isFromLibrary(imp.source)
-        )
-      },
-      usage: report.patterns.usage,
-      advanced: {
-        lazy: report.patterns.advanced.lazy.filter(
-          (imp) => isFromLibrary(imp.source)
-        ),
-        dynamic: report.patterns.advanced.dynamic.filter(
-          (imp) => isFromLibrary(imp.source)
-        ),
-        hoc: report.patterns.advanced.hoc,
-        memo: report.patterns.advanced.memo,
-        forwardRef: report.patterns.advanced.forwardRef,
-        portal: report.patterns.advanced.portal
-      },
-      props: report.patterns.props
-    }
-  };
-}
-
-// src/utils/aggregator.ts
-function aggregateReports(reports, versions = {}) {
-  const componentUsageMap = /* @__PURE__ */ new Map();
-  let totalImports = 0;
-  let totalUsagePatterns = 0;
-  const patternCountMap = /* @__PURE__ */ new Map();
-  const availablePackages = Object.keys(versions);
-  for (const report of reports) {
-    totalImports += report.summary.totalImports;
-    totalUsagePatterns += report.summary.totalUsagePatterns;
-    for (const jsx of report.patterns.usage.jsx) {
-      const key = jsx.component;
-      const existing = componentUsageMap.get(key);
-      if (existing) {
-        existing.count++;
-      } else {
-        const source = findComponentSource(
-          jsx.component,
-          report,
-          availablePackages
-        );
-        componentUsageMap.set(key, {
-          name: jsx.component,
-          source,
-          count: 1,
-          files: /* @__PURE__ */ new Set()
-        });
-      }
-    }
-    countPatterns(report, patternCountMap);
-  }
-  const topComponents = Array.from(componentUsageMap.values()).sort(
-    (a, b) => b.count - a.count
-  );
-  const allComponents = Array.from(componentUsageMap.keys()).sort();
-  const patternCounts = Array.from(patternCountMap.entries()).map(([type, count]) => ({
-    patternType: type,
-    displayName: getPatternDisplayName(type),
-    count
-  })).sort((a, b) => b.count - a.count);
-  const packageDistribution = calculatePackageDistribution(
-    componentUsageMap,
-    versions
-  );
-  return {
-    filesAnalyzed: reports.length,
-    totalImports,
-    totalComponents: componentUsageMap.size,
-    totalUsagePatterns,
-    patternCounts,
-    componentUsage: componentUsageMap,
-    topComponents,
-    allComponents,
-    packageDistribution,
-    reports
-  };
-}
-function resolvePackageFromImportPath(importPath, availablePackages) {
-  if (importPath.startsWith(".") || importPath.startsWith("/")) {
-    console.log("importPath", importPath);
-    return "local";
-  }
-  const sortedPackages = [...availablePackages].sort(
-    (a, b) => b.length - a.length
-  );
-  for (const pkg of sortedPackages) {
-    if (importPath === pkg) {
-      return pkg;
-    }
-    if (importPath.startsWith(`${pkg}/`)) {
-      return pkg;
-    }
-  }
-  return "unknown";
-}
-function findComponentSource(componentName, report, availablePackages) {
-  const namedImport = report.patterns.imports.named.find(
-    (imp) => imp.name === componentName
-  );
-  if (namedImport)
-    return resolvePackageFromImportPath(namedImport.source, availablePackages);
-  const defaultImport = report.patterns.imports.default.find(
-    (imp) => imp.name === componentName
-  );
-  if (defaultImport)
-    return resolvePackageFromImportPath(
-      defaultImport.source,
-      availablePackages
-    );
-  const aliasedImport = report.patterns.imports.aliased.find(
-    (imp) => imp.local === componentName
-  );
-  if (aliasedImport)
-    return resolvePackageFromImportPath(
-      aliasedImport.source,
-      availablePackages
-    );
-  return "unknown";
-}
-function countPatterns(report, patternMap) {
-  increment(
-    patternMap,
-    "imports.default",
-    report.patterns.imports.default.length
-  );
-  increment(patternMap, "imports.named", report.patterns.imports.named.length);
-  increment(
-    patternMap,
-    "imports.namespace",
-    report.patterns.imports.namespace.length
-  );
-  increment(
-    patternMap,
-    "imports.aliased",
-    report.patterns.imports.aliased.length
-  );
-  increment(patternMap, "usage.jsx", report.patterns.usage.jsx.length);
-  increment(
-    patternMap,
-    "usage.variables",
-    report.patterns.usage.variables.length
-  );
-  increment(
-    patternMap,
-    "usage.destructuring",
-    report.patterns.usage.destructuring.length
-  );
-  increment(
-    patternMap,
-    "usage.conditional",
-    report.patterns.usage.conditional.length
-  );
-  increment(patternMap, "usage.arrays", report.patterns.usage.arrays.length);
-  increment(patternMap, "usage.objects", report.patterns.usage.objects.length);
-  increment(patternMap, "advanced.lazy", report.patterns.advanced.lazy.length);
-  increment(
-    patternMap,
-    "advanced.dynamic",
-    report.patterns.advanced.dynamic.length
-  );
-  increment(patternMap, "advanced.hoc", report.patterns.advanced.hoc.length);
-  increment(patternMap, "advanced.memo", report.patterns.advanced.memo.length);
-  increment(
-    patternMap,
-    "advanced.forwardRef",
-    report.patterns.advanced.forwardRef.length
-  );
-  increment(
-    patternMap,
-    "advanced.portal",
-    report.patterns.advanced.portal.length
-  );
-}
-function increment(map, key, value) {
-  map.set(key, (map.get(key) || 0) + value);
-}
-function getPatternDisplayName(patternType) {
-  const displayNames = {
-    "imports.default": "Default Imports",
-    "imports.named": "Named Imports",
-    "imports.namespace": "Namespace Imports",
-    "imports.aliased": "Aliased Imports",
-    "usage.jsx": "JSX Usage",
-    "usage.variables": "Variable Assignments",
-    "usage.destructuring": "Destructuring",
-    "usage.conditional": "Conditional Usage",
-    "usage.arrays": "Array Mappings",
-    "usage.objects": "Object Mappings",
-    "advanced.lazy": "Lazy Loading",
-    "advanced.dynamic": "Dynamic Imports",
-    "advanced.hoc": "Higher-Order Components",
-    "advanced.memo": "Memoized Components",
-    "advanced.forwardRef": "Forward Refs",
-    "advanced.portal": "Portal Usage"
-  };
-  return displayNames[patternType] || patternType;
-}
-function getPackageVersion(packageName, versions) {
-  if (versions[packageName]) {
-    return versions[packageName];
-  }
-  if (packageName.includes("/")) {
-    const parts = packageName.split("/");
-    if (packageName.startsWith("@") && parts.length > 2) {
-      const basePackage = `${parts[0]}/${parts[1]}`;
-      if (versions[basePackage]) {
-        return versions[basePackage];
-      }
-    }
-    if (!packageName.startsWith("@") && parts.length > 1) {
-      const basePackage = parts[0];
-      if (versions[basePackage]) {
-        return versions[basePackage];
-      }
-    }
-  }
-  return null;
-}
-function calculatePackageDistribution(componentUsageMap, versions) {
-  const packageMap = /* @__PURE__ */ new Map();
-  for (const component of componentUsageMap.values()) {
-    if (component.source === "unknown") continue;
-    const existing = packageMap.get(component.source);
-    if (existing) {
-      existing.componentCount++;
-      existing.usageCount += component.count;
-      existing.components.push(component.name);
-    } else {
-      packageMap.set(component.source, {
-        packageName: component.source,
-        version: getPackageVersion(component.source, versions),
-        componentCount: 1,
-        usageCount: component.count,
-        percentage: 0,
-        components: [component.name]
-      });
-    }
-  }
-  const distribution = Array.from(packageMap.values());
-  const totalExternalUsage = distribution.reduce(
-    (sum, pkg) => sum + pkg.usageCount,
-    0
-  );
-  for (const pkg of distribution) {
-    pkg.percentage = totalExternalUsage > 0 ? pkg.usageCount / totalExternalUsage * 100 : 0;
-  }
-  return distribution.sort((a, b) => b.usageCount - a.usageCount);
-}
-
-// src/utils/format-utils.ts
-function formatCount(num) {
-  return num.toLocaleString();
-}
-function formatDuration(seconds) {
-  return `${seconds.toFixed(2)}s`;
-}
-
-// src/utils/print-summary.ts
-function printHeader() {
-  console.log(chalk5.green.bold("\n\u{1F4CA} Summary\n"));
-}
-function printSummary(aggregated) {
-  printHeader();
-  const table = new Table({
-    head: ["Metric", "Count"],
-    style: {
-      head: ["cyan"],
-      border: ["gray"]
-    }
-  });
-  const externalComponents = aggregated.topComponents.filter(
-    (comp) => comp.source !== "unknown" && comp.source !== "local"
-  ).length;
-  const totalExternalUsage = aggregated.packageDistribution.reduce(
-    (sum, pkg) => sum + pkg.usageCount,
-    0
-  );
-  table.push(
-    ["Files Analyzed", formatCount(aggregated.filesAnalyzed)],
-    ["External Packages", formatCount(aggregated.packageDistribution.length)],
-    ["External Components", formatCount(externalComponents)],
-    ["Total Usages", formatCount(totalExternalUsage)]
-  );
-  console.log(table.toString());
-}
-function renderBarChart(data, options = {}) {
-  const {
-    maxWidth = 50,
-    showValues = true,
-    barChar = "\u2588",
-    emptyChar = "\u2591"
-  } = options;
-  if (data.length === 0) {
-    console.log(chalk5.gray("  No data to display"));
-    return;
-  }
-  const maxValue = Math.max(...data.map((d) => d.value));
-  if (maxValue === 0) {
-    console.log(chalk5.gray("  All values are zero"));
-    return;
-  }
-  const maxLabelLength = Math.max(...data.map((d) => d.label.length));
-  for (const item of data) {
-    const percentage = item.value / maxValue;
-    const barLength = Math.round(percentage * maxWidth);
-    const emptyLength = maxWidth - barLength;
-    const paddedLabel = item.label.padEnd(maxLabelLength, " ");
-    const bar = chalk5.green(barChar.repeat(barLength)) + chalk5.gray(emptyChar.repeat(emptyLength));
-    const valueStr = showValues ? ` ${formatCount(item.value)}` : "";
-    console.log(`${paddedLabel} ${bar}${valueStr}
-`);
-  }
-}
-
-// src/utils/print-components.ts
-function printHeader2() {
-  console.log(chalk5.magenta.bold("\n\u269B\uFE0F Components\n"));
-}
-function printComponents(aggregated, mode) {
-  const components = aggregated.topComponents;
-  if (mode === "table") {
-    printComponentsTable(components);
-  } else if (mode === "chart") {
-    printComponentsChart(components);
-  }
-}
-function printComponentsTable(components) {
-  printHeader2();
-  const externalComponents = components.filter(
-    (comp) => comp.source !== "unknown" && comp.source !== "local"
-  );
-  if (externalComponents.length === 0) {
-    console.log(chalk5.gray("  No external components found"));
-    return;
-  }
-  const table = new Table({
-    head: ["Component", "Package", "Count"],
-    style: {
-      head: ["cyan"],
-      border: ["gray"]
-    }
-  });
-  externalComponents.forEach((comp) => {
-    table.push([comp.name, comp.source, comp.count.toString()]);
-  });
-  console.log(table.toString());
-}
-function printComponentsChart(components) {
-  printHeader2();
-  const externalComponents = components.filter(
-    (comp) => comp.source !== "unknown" && comp.source !== "local"
-  );
-  if (externalComponents.length === 0) {
-    console.log(chalk5.gray("  No external components found"));
-    return;
-  }
-  const data = externalComponents.map((comp) => ({
-    label: comp.name,
-    value: comp.count
-  }));
-  renderBarChart(data, { maxWidth: 50 });
-}
-function printHeader3() {
-  console.log(chalk5.blue.bold("\n\u{1F50D} Code Patterns\n"));
-}
-function printPatterns(aggregated, mode) {
-  const patterns = aggregated.patternCounts.filter((p) => p.count > 0);
-  if (mode === "table") {
-    printPatternsTable(patterns);
-  } else if (mode === "chart") {
-    printPatternsChart(patterns);
-  }
-}
-function printPatternsTable(patterns) {
-  printHeader3();
-  if (patterns.length === 0) {
-    console.log(chalk5.gray("  No patterns found"));
-    return;
-  }
-  const table = new Table({
-    head: ["Pattern", "Count"],
-    style: {
-      head: ["cyan"],
-      border: ["gray"]
-    }
-  });
-  patterns.forEach((pattern) => {
-    table.push([pattern.displayName, pattern.count.toString()]);
-  });
-  console.log(table.toString());
-  const totalPatterns = patterns.reduce((sum, p) => sum + p.count, 0);
-  console.log(chalk5.gray(`
-Total: ${totalPatterns} patterns detected`));
-}
-function printPatternsChart(patterns) {
-  printHeader3();
-  if (patterns.length === 0) {
-    console.log(chalk5.gray("  No patterns found"));
-    return;
-  }
-  const data = patterns.map((pattern) => ({
-    label: pattern.displayName,
-    value: pattern.count
-  }));
-  renderBarChart(data, { maxWidth: 50 });
-}
-function printHeader4() {
-  console.log(chalk5.blueBright.bold("\n\u{1F4E6} Packages\n"));
-}
-function printPackages(aggregated, mode) {
-  const packages = aggregated.packageDistribution;
-  if (mode === "table") {
-    printPackagesTable(packages);
-  } else if (mode === "chart") {
-    printPackagesChart(packages);
-  }
-}
-function printPackagesTable(packages) {
-  printHeader4();
-  if (packages.length === 0) {
-    console.log(chalk5.gray("  No packages found"));
-    return;
-  }
-  const table = new Table({
-    head: ["Package", "Version", "Components", "Usage", "Percentage"],
-    style: {
-      head: ["cyan"],
-      border: ["gray"]
-    }
-  });
-  packages.forEach((pkg) => {
-    table.push([
-      pkg.packageName,
-      pkg.version || "N/A",
-      formatCount(pkg.componentCount),
-      formatCount(pkg.usageCount),
-      `${pkg.percentage.toFixed(1)}%`
-    ]);
-  });
-  console.log(table.toString());
-  const totalComponents = packages.reduce(
-    (sum, p) => sum + p.componentCount,
-    0
-  );
-  const totalExternalUsage = packages.reduce((sum, p) => sum + p.usageCount, 0);
-  console.log(
-    chalk5.gray(
-      `
-Total: ${formatCount(packages.length)} packages | ${formatCount(totalComponents)} unique components | ${formatCount(totalExternalUsage)} total usages`
-    )
-  );
-}
-function printPackagesChart(packages) {
-  printHeader4();
-  if (packages.length === 0) {
-    console.log(chalk5.gray("  No packages found"));
-    return;
-  }
-  const maxBarWidth = 40;
-  const maxPercentage = Math.max(...packages.map((p) => p.percentage));
-  const maxLabelLength = Math.max(...packages.map((p) => p.packageName.length));
-  packages.forEach((pkg) => {
-    const barLength = Math.round(
-      pkg.percentage / maxPercentage * maxBarWidth
-    );
-    const emptyLength = maxBarWidth - barLength;
-    const paddedLabel = pkg.packageName.padEnd(maxLabelLength, " ");
-    const bar = chalk5.green("\u2588".repeat(barLength)) + chalk5.gray("\u2591".repeat(emptyLength));
-    console.log(
-      `${paddedLabel} ${bar} ${chalk5.bold(pkg.percentage.toFixed(1) + "%")} (${pkg.usageCount})`
-    );
-  });
-}
-async function findFiles(pattern, ignorePatterns) {
-  const files = await glob(pattern, {
-    ignore: ignorePatterns,
-    nodir: true,
-    absolute: true,
-    windowsPathsNoEscape: true
-  });
-  return files;
-}
-var NpmLockfileAdapter = class {
-  constructor() {
-    this.name = "npm";
-    this.supportedVersions = ["v2", "v3"];
-  }
-  detect(projectPath) {
-    const lockfilePath = path.join(projectPath, "package-lock.json");
-    return fs3.existsSync(lockfilePath) ? lockfilePath : null;
-  }
-  parse(lockFilePath) {
-    try {
-      const content = fs3.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 {};
-    }
-  }
-};
-var PnpmLockfileAdapter = class {
-  constructor() {
-    this.name = "pnpm";
-    this.supportedVersions = ["v5", "v6", "v9"];
-  }
-  detect(projectPath) {
-    const lockfilePath = path.join(projectPath, "pnpm-lock.yaml");
-    return fs3.existsSync(lockfilePath) ? lockfilePath : null;
-  }
-  parse(lockFilePath) {
-    try {
-      const content = fs3.readFileSync(lockFilePath, "utf8");
-      const lockData = yaml.load(content);
-      const versions = {};
-      if (lockData.importers) {
-        const rootImporter = lockData.importers["."];
-        if (rootImporter) {
-          if (rootImporter.dependencies) {
-            for (const [name, data] of Object.entries(
-              rootImporter.dependencies
-            )) {
-              if (typeof data === "object" && data !== null && "version" in data) {
-                versions[name] = data.version;
-              }
-            }
-          }
-          if (rootImporter.devDependencies) {
-            for (const [name, data] of Object.entries(
-              rootImporter.devDependencies
-            )) {
-              if (typeof data === "object" && data !== null && "version" in data) {
-                versions[name] = data.version;
-              }
-            }
-          }
-        }
-      }
-      if (lockData.packages && Object.keys(versions).length === 0) {
-        Object.keys(lockData.packages).forEach((key) => {
-          const match = key.match(/\/(.+?)\/(\d+\.\d+\.\d+.*?)(?:_|$)/);
-          if (match) {
-            const [, pkgName, version] = match;
-            versions[pkgName] = version;
-          }
-        });
-      }
-      if (lockData.dependencies && Object.keys(versions).length === 0) {
-        Object.entries(lockData.dependencies).forEach(
-          ([name, versionSpec]) => {
-            if (typeof versionSpec === "string" && !versionSpec.startsWith("link:")) {
-              versions[name] = versionSpec;
-            } else if (typeof versionSpec === "object" && versionSpec.version) {
-              versions[name] = versionSpec.version;
-            }
-          }
-        );
-      }
-      return versions;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(`Warning: Could not parse pnpm-lock.yaml: ${message}`);
-      return {};
-    }
-  }
-};
-var YarnLockfileAdapter = class {
-  constructor() {
-    this.name = "yarn";
-    this.supportedVersions = ["v1", "v2+"];
-  }
-  detect(projectPath) {
-    const lockfilePath = path.join(projectPath, "yarn.lock");
-    return fs3.existsSync(lockfilePath) ? lockfilePath : null;
-  }
-  parse(lockFilePath) {
-    try {
-      const content = fs3.readFileSync(lockFilePath, "utf8");
-      const parsed = lockfile.parse(content);
-      if (parsed.type !== "success") {
-        console.warn("Warning: Failed to parse yarn.lock");
-        return {};
-      }
-      const versions = {};
-      Object.entries(parsed.object).forEach(([key, value]) => {
-        let pkgName = key;
-        if (key.startsWith("@")) {
-          const match = key.match(/^(@[^@]+\/[^@]+)@/);
-          if (match) {
-            pkgName = match[1];
-          }
-        } else {
-          const match = key.match(/^([^@]+)@/);
-          if (match) {
-            pkgName = match[1];
-          }
-        }
-        if (value.version && (!versions[pkgName] || value.version)) {
-          versions[pkgName] = value.version;
-        }
-      });
-      return versions;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(`Warning: Could not parse yarn.lock: ${message}`);
-      return {};
-    }
-  }
-};
-
-// src/lock-parser/index.ts
-var LOCKFILE_ADAPTERS = [
-  new NpmLockfileAdapter(),
-  new YarnLockfileAdapter(),
-  new PnpmLockfileAdapter()
-];
-function findAndParseLockfile(projectPath) {
-  for (const adapter of LOCKFILE_ADAPTERS) {
-    const lockfilePath = adapter.detect(projectPath);
-    if (lockfilePath) {
-      const versions = adapter.parse(lockfilePath);
-      return {
-        versions,
-        lockfileType: adapter.name,
-        lockfilePath,
-        supportedVersions: adapter.supportedVersions
-      };
-    }
-  }
-  throw new Error("No supported lockfile found");
-}
-
-// src/commands/scan.ts
-function registerScanCommand(program2) {
-  program2.command("scan").description("Scan and analyze local files").argument(
-    "[pattern]",
-    "Glob pattern for files to analyze (defaults to current directory recursively)",
-    "**/*.{tsx,jsx,ts,js}"
-  ).option("--ignore <pattern>", "Glob pattern for files to ignore", [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**"
-  ]).option("--allow-packages <pattern>", "Pattern for what packages to scan", [
-    "**"
-  ]).option(
-    "--ignore-packages <pattern>",
-    "Pattern for what packages to ignore",
-    []
-  ).option("--no-summary", "Hide summary", "table").option(
-    "--components [mode]",
-    "Show components table/chart (table, chart)",
-    "table"
-  ).option("--no-components", "Do not show components").option(
-    "--packages [mode]",
-    "Show packages table/chart (table, chart)",
-    "table"
-  ).option("--no-packages", "Do not show packages").option(
-    "--patterns [mode]",
-    "Show patterns table/chart (table, chart)",
-    "table"
-  ).option("--no-patterns", "Do not show patterns").action(async (pattern, options) => {
-    const normalizedOptions = normalizeOptions(options);
-    await executeScan(pattern, normalizedOptions);
-  });
-}
-function normalizeArray(value) {
-  if (!value) {
-    return [];
-  }
-  return Array.isArray(value) ? value : [value];
-}
-function normalizeOptions(options) {
-  return {
-    verbose: options.verbose || false,
-    summary: options.summary === false || options.summary === "false" ? false : "log",
-    noSummary: options.noSummary || false,
-    components: options.components || "table",
-    packages: options.packages || "table",
-    patterns: options.patterns || "table",
-    ignore: normalizeArray(options.ignore),
-    allowPackages: normalizeArray(options.allowPackages),
-    ignorePackages: normalizeArray(options.ignorePackages)
-  };
-}
-async function executeScan(pattern, options) {
-  const startTime = Date.now();
-  const spinner = ora("Parsing lockfile...").start();
-  try {
-    const lockfileResult = findAndParseLockfile(process.cwd());
-    const allPackages = Object.keys(lockfileResult.versions);
-    const filteredPackages = allPackages.filter((pkg) => {
-      const allowed = options.allowPackages.some((p) => minimatch(pkg, p));
-      const ignored = options.ignorePackages.some((p) => minimatch(pkg, p));
-      return allowed && !ignored;
-    });
-    const filteredVersions = {};
-    for (const pkg of filteredPackages) {
-      filteredVersions[pkg] = lockfileResult.versions[pkg];
-    }
-    spinner.succeed(
-      `Found ${lockfileResult.lockfileType} lockfile (supports: ${lockfileResult.supportedVersions.join(", ")}) - ${filteredPackages.length}/${allPackages.length} packages`
-    );
-    spinner.start("Finding files...");
-    const files = await findFiles(pattern, options.ignore);
-    if (files.length === 0) {
-      spinner.fail(`No files found matching pattern: ${pattern}`);
-      return;
-    }
-    spinner.succeed(chalk5.green(` Found ${files.length} files`));
-    spinner.start("Analyzing files...");
-    const reports = [];
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i];
-      if (!options.verbose) {
-        spinner.text = `Analyzing files... (${i + 1}/${files.length})`;
-      }
-      const report = parseFile(file);
-      if (report) {
-        reports.push(report);
-      }
-    }
-    const elapsedTime = (Date.now() - startTime) / 1e3;
-    const aggregated = aggregateReports(reports, filteredVersions);
-    if (options.packages && !options.noPackages) {
-      printPackages(aggregated, options.packages);
-    }
-    if (options.components && !options.noComponents) {
-      printComponents(aggregated, options.components);
-    }
-    if (options.patterns && !options.noPatterns) {
-      printPatterns(aggregated, options.patterns);
-    }
-    if (options.summary && !options.noSummary) {
-      printSummary(aggregated);
-    }
-    console.log("");
-    spinner.succeed(
-      chalk5.green.bold(
-        ` Analysis complete! Analyzed ${reports.length} files in ${formatDuration(elapsedTime)}
-`
-      )
-    );
-  } catch (error) {
-    spinner.fail(chalk5.red("Analysis failed: " + error.message));
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-// package.json
-var package_default = {
-  version: "1.1.1"};
-
-// src/cli.ts
-var program = new Command();
-program.name("hermex").description("Analyze React component usage patterns in your codebase").version(package_default.version);
-registerScanCommand(program);
-program.parse(process.argv);
-
-export { program };
-//# sourceMappingURL=cli.js.map
-//# sourceMappingURL=cli.js.map