hermex 1.0.0 → 1.1.0

package/dist/cli.js

@@ -1,22 +1,27 @@
-#!/usr/bin/env node
 'use strict';
 
 var commander = require('commander');
-var glob = require('glob');
 var ora = require('ora');
-var chalk = require('chalk');
+var chalk6 = require('chalk');
 var core = require('@swc/core');
-var fs = require('fs');
-var path = require('path');
+var fs3 = require('fs');
 var Table = require('cli-table3');
+var glob = require('glob');
+var path = require('path');
+var yaml = require('js-yaml');
+var lockfile = require('@yarnpkg/lockfile');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var ora__default = /*#__PURE__*/_interopDefault(ora);
-var chalk__default = /*#__PURE__*/_interopDefault(chalk);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var chalk6__default = /*#__PURE__*/_interopDefault(chalk6);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var Table__default = /*#__PURE__*/_interopDefault(Table);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var yaml__default = /*#__PURE__*/_interopDefault(yaml);
+var lockfile__default = /*#__PURE__*/_interopDefault(lockfile);
+
+// src/cli.ts
 
 // src/swc-parser/core/state.ts
 function createState() {
@@ -699,7 +704,7 @@ function parseFile(filePath, options = {}) {
   console.log(`
 \u{1F4C1} Analyzing: ${filePath}`);
   try {
-    const code = fs__default.default.readFileSync(filePath, "utf8");
+    const code = fs3__default.default.readFileSync(filePath, "utf8");
     return parseCode(code, options);
   } catch (error) {
     console.error(`\u274C Error parsing ${filePath}:`, error.message);
@@ -744,11 +749,12 @@ function filterReportByLibrary(report, libraryName) {
 }
 
 // src/utils/aggregator.ts
-function aggregateReports(reports) {
+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;
@@ -758,7 +764,11 @@ function aggregateReports(reports) {
       if (existing) {
         existing.count++;
       } else {
-        const source = findComponentSource(jsx.component, report);
+        const source = findComponentSource(
+          jsx.component,
+          report,
+          availablePackages
+        );
         componentUsageMap.set(key, {
           name: jsx.component,
           source,
@@ -778,6 +788,10 @@ function aggregateReports(reports) {
     displayName: getPatternDisplayName(type),
     count
   })).sort((a, b) => b.count - a.count);
+  const packageDistribution = calculatePackageDistribution(
+    componentUsageMap,
+    versions
+  );
   return {
     filesAnalyzed: reports.length,
     totalImports,
@@ -787,22 +801,49 @@ function aggregateReports(reports) {
     componentUsage: componentUsageMap,
     topComponents,
     allComponents,
+    packageDistribution,
     reports
   };
 }
-function findComponentSource(componentName, report) {
+function resolvePackageFromImportPath(importPath, availablePackages) {
+  if (importPath.startsWith(".") || importPath.startsWith("/")) {
+    return "local";
+  }
+  const sortedPackages = [...availablePackages].sort(
+    (a, b) => b.length - a.length
+  );
+  for (const pkg of sortedPackages) {
+    if (importPath === pkg) {
+      return pkg;
+    }
+    if (importPath.startsWith(`${pkg}/`)) {
+      return pkg;
+    }
+  }
+  return "unknown";
+}
+function findComponentSource(componentName, report, availablePackages) {
   const namedImport = report.patterns.imports.named.find(
     (imp) => imp.name === componentName
   );
-  if (namedImport) return namedImport.source;
+  if (namedImport)
+    return resolvePackageFromImportPath(namedImport.source, availablePackages);
   const defaultImport = report.patterns.imports.default.find(
     (imp) => imp.name === componentName
   );
-  if (defaultImport) return defaultImport.source;
+  if (defaultImport)
+    return resolvePackageFromImportPath(
+      defaultImport.source,
+      availablePackages
+    );
   const aliasedImport = report.patterns.imports.aliased.find(
     (imp) => imp.local === componentName
   );
-  if (aliasedImport) return aliasedImport.source;
+  if (aliasedImport)
+    return resolvePackageFromImportPath(
+      aliasedImport.source,
+      availablePackages
+    );
   return "unknown";
 }
 function countPatterns(report, patternMap) {
@@ -883,132 +924,115 @@ function getPatternDisplayName(patternType) {
   };
   return displayNames[patternType] || patternType;
 }
-function printVerbose(filePath, report) {
-  const relativePath = path__default.default.relative(process.cwd(), filePath);
-  console.log(chalk__default.default.gray(`[VERBOSE] Analyzing: ${relativePath}`));
-  for (const jsx of report.patterns.usage.jsx) {
-    console.log(chalk__default.default.gray(`[VERBOSE] Found JSX Usage: <${jsx.component}>`));
-  }
-  for (const imp of report.patterns.imports.named) {
-    console.log(
-      chalk__default.default.gray(`[VERBOSE] Found import: ${imp.name} from ${imp.source}`)
-    );
-  }
-  for (const imp of report.patterns.imports.default) {
-    console.log(
-      chalk__default.default.gray(
-        `[VERBOSE] Found default import: ${imp.name} from ${imp.source}`
-      )
-    );
-  }
-  for (const imp of report.patterns.imports.namespace) {
-    console.log(
-      chalk__default.default.gray(
-        `[VERBOSE] Found namespace import: ${imp.name} from ${imp.source}`
-      )
-    );
-  }
-  for (const imp of report.patterns.imports.aliased) {
-    console.log(
-      chalk__default.default.gray(
-        `[VERBOSE] Found aliased import: ${imp.imported} as ${imp.local} from ${imp.source}`
-      )
-    );
-  }
-  for (const obj of report.patterns.usage.objects) {
-    for (const mapping of obj.mappings) {
-      console.log(
-        chalk__default.default.gray(
-          `[VERBOSE] Found Object mapping with Component: ${mapping.component}`
-        )
-      );
+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];
+      }
     }
   }
-  for (const cond of report.patterns.usage.conditional) {
-    console.log(
-      chalk__default.default.gray(`[VERBOSE] Found Conditional usage: ${cond.consequent}`)
-    );
-  }
-  for (const arr of report.patterns.usage.arrays) {
-    console.log(
-      chalk__default.default.gray(
-        `[VERBOSE] Found Array mapping with components: ${arr.components.join(", ")}`
-      )
-    );
-  }
-  for (const variable of report.patterns.usage.variables) {
-    console.log(
-      chalk__default.default.gray(
-        `[VERBOSE] Found Variable assignment: ${variable.variable} = ${variable.assignment}`
-      )
-    );
-  }
-  for (const destructure of report.patterns.usage.destructuring) {
-    console.log(
-      chalk__default.default.gray(
-        `[VERBOSE] Found Destructuring: ${destructure.property} from ${destructure.source}`
-      )
-    );
-  }
-  for (const lazy of report.patterns.advanced.lazy) {
-    console.log(chalk__default.default.gray(`[VERBOSE] Found Lazy import: ${lazy.source}`));
-  }
-  for (const dynamic of report.patterns.advanced.dynamic) {
-    console.log(
-      chalk__default.default.gray(`[VERBOSE] Found Dynamic import: ${dynamic.source}`)
-    );
-  }
-  for (const hoc of report.patterns.advanced.hoc) {
-    console.log(
-      chalk__default.default.gray(`[VERBOSE] Found HOC: ${hoc.function}(${hoc.component})`)
-    );
-  }
-  for (const memo of report.patterns.advanced.memo) {
-    console.log(
-      chalk__default.default.gray(`[VERBOSE] Found Memoized component: ${memo.component}`)
-    );
-  }
-  if (report.patterns.advanced.forwardRef.length > 0) {
-    console.log(chalk__default.default.gray(`[VERBOSE] Found Forward Ref usage`));
+  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]
+      });
+    }
   }
-  if (report.patterns.advanced.portal.length > 0) {
-    console.log(chalk__default.default.gray(`[VERBOSE] Found Portal usage`));
+  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;
   }
-  console.log(chalk__default.default.gray(`[VERBOSE] ${"\u2500".repeat(80)}`));
+  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(1)}s`;
+}
+
+// src/utils/print-summary.ts
+function printHeader() {
+  console.log(chalk6__default.default.green.bold("\n\u{1F4CA} Summary\n"));
 }
 function printSummary(aggregated, elapsedTimeSeconds) {
   console.log(
-    chalk__default.default.green(
-      `[SUMMARY] Analysis completed successfully in ${elapsedTimeSeconds.toFixed(1)}s`
-    )
-  );
-  console.log(
-    chalk__default.default.green(
-      `[SUMMARY] Files analyzed: ${aggregated.filesAnalyzed.toLocaleString()}`
+    chalk6__default.default.green(
+      `Analysis completed successfully in ${formatDuration(elapsedTimeSeconds)}
+`
     )
   );
-  console.log(
-    chalk__default.default.green(
-      `[SUMMARY] Total imports: ${aggregated.totalImports.toLocaleString()}`
-    )
+  printHeader();
+  const table = new Table__default.default({
+    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
   );
-  console.log(
-    chalk__default.default.green(
-      `[SUMMARY] Total components: ${aggregated.totalComponents.toLocaleString()}`
-    )
+  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 printHeader2() {
+  console.log(chalk6__default.default.cyan.bold("\n\u{1F4CB} Details\n"));
 }
 function printDetails(aggregated) {
+  printHeader2();
   console.log(
-    chalk__default.default.cyan(
-      `[DETAILS] Total usage patterns: ${aggregated.totalUsagePatterns.toLocaleString()}`
+    chalk6__default.default.cyan(
+      `  Total usage patterns: ${aggregated.totalUsagePatterns.toLocaleString()}`
     )
   );
   for (const pattern of aggregated.patternCounts) {
     if (pattern.count > 0) {
       console.log(
-        chalk__default.default.cyan(
-          `[DETAILS] ${pattern.displayName}: ${pattern.count.toLocaleString()}`
+        chalk6__default.default.cyan(
+          `  ${pattern.displayName}: ${pattern.count.toLocaleString()}`
         )
       );
     }
@@ -1022,12 +1046,12 @@ function renderBarChart(data, options = {}) {
     emptyChar = "\u2591"
   } = options;
   if (data.length === 0) {
-    console.log(chalk__default.default.gray("  No data to display"));
+    console.log(chalk6__default.default.gray("  No data to display"));
     return;
   }
   const maxValue = Math.max(...data.map((d) => d.value));
   if (maxValue === 0) {
-    console.log(chalk__default.default.gray("  All values are zero"));
+    console.log(chalk6__default.default.gray("  All values are zero"));
     return;
   }
   const maxLabelLength = Math.max(...data.map((d) => d.label.length));
@@ -1036,156 +1060,357 @@ function renderBarChart(data, options = {}) {
     const barLength = Math.round(percentage * maxWidth);
     const emptyLength = maxWidth - barLength;
     const paddedLabel = item.label.padEnd(maxLabelLength, " ");
-    const bar = chalk__default.default.green(barChar.repeat(barLength)) + chalk__default.default.gray(emptyChar.repeat(emptyLength));
+    const bar = chalk6__default.default.green(barChar.repeat(barLength)) + chalk6__default.default.gray(emptyChar.repeat(emptyLength));
     const valueStr = showValues ? ` ${item.value.toLocaleString()}` : "";
     console.log(`${paddedLabel} ${bar}${valueStr}
 `);
   }
 }
 
-// src/utils/print-top-components.ts
-function printTopComponents(aggregated, mode, topN = 10) {
-  const topComponents = aggregated.topComponents.slice(0, topN);
-  if (mode === "log") {
-    printTopComponentsLog(topComponents);
-  } else if (mode === "table") {
-    printTopComponentsTable(topComponents);
-  } else if (mode === "chart") {
-    printTopComponentsChart(topComponents);
-  }
+// src/utils/print-components.ts
+function printHeader3() {
+  console.log(chalk6__default.default.magenta.bold("\n\u269B\uFE0F Components\n"));
 }
-function printTopComponentsLog(components) {
-  console.log(chalk__default.default.yellow.bold(`
-\u{1F3C6} Top Components
-`));
-  if (components.length === 0) {
-    console.log(chalk__default.default.gray("  No components found"));
-    return;
+function printComponents(aggregated, mode) {
+  const components = aggregated.topComponents;
+  if (mode === "table") {
+    printComponentsTable(components);
+  } else if (mode === "chart") {
+    printComponentsChart(components);
   }
-  components.forEach((comp, idx) => {
-    const rank = idx + 1;
-    const emoji = rank === 1 ? "\u{1F947}" : rank === 2 ? "\u{1F948}" : rank === 3 ? "\u{1F949}" : "  ";
-    const sourceStr = comp.source !== "unknown" ? ` from ${comp.source}` : "";
-    console.log(
-      chalk__default.default.yellow(
-        `[TOP-COMPONENTS] ${emoji} ${rank}. ${comp.name}${sourceStr}: ${comp.count} uses`
-      )
-    );
-  });
 }
-function printTopComponentsTable(components) {
-  console.log(chalk__default.default.yellow(`[TOP-COMPONENTS] TABLE`));
-  if (components.length === 0) {
-    console.log(chalk__default.default.gray("  No components found"));
+function printComponentsTable(components) {
+  printHeader3();
+  const externalComponents = components.filter(
+    (comp) => comp.source !== "unknown" && comp.source !== "local"
+  );
+  if (externalComponents.length === 0) {
+    console.log(chalk6__default.default.gray("  No external components found"));
     return;
   }
   const table = new Table__default.default({
-    head: ["Rank", "Component", "Source", "Count"],
+    head: ["Component", "Package", "Count"],
     style: {
       head: ["cyan"],
       border: ["gray"]
     }
   });
-  components.forEach((comp, idx) => {
-    const rank = idx + 1;
-    const emoji = rank === 1 ? "\u{1F947}" : rank === 2 ? "\u{1F948}" : rank === 3 ? "\u{1F949}" : `${rank}.`;
-    table.push([emoji, comp.name, comp.source, comp.count.toString()]);
+  externalComponents.forEach((comp) => {
+    table.push([comp.name, comp.source, comp.count.toString()]);
   });
   console.log(table.toString());
 }
-function printTopComponentsChart(components) {
-  console.log(chalk__default.default.yellow(`[TOP-COMPONENTS] CHART`));
-  if (components.length === 0) {
-    console.log(chalk__default.default.gray("  No components found"));
+function printComponentsChart(components) {
+  printHeader3();
+  const externalComponents = components.filter(
+    (comp) => comp.source !== "unknown" && comp.source !== "local"
+  );
+  if (externalComponents.length === 0) {
+    console.log(chalk6__default.default.gray("  No external components found"));
     return;
   }
-  const data = components.map((comp) => ({
+  const data = externalComponents.map((comp) => ({
     label: comp.name,
     value: comp.count
   }));
   renderBarChart(data, { maxWidth: 50 });
 }
-function printComponentsUsage(aggregated, mode) {
-  const components = aggregated.topComponents;
+function printHeader4() {
+  console.log(chalk6__default.default.blue.bold("\n\u{1F50D} Code Patterns\n"));
+}
+function printPatterns(aggregated, mode) {
+  const patterns = aggregated.patternCounts.filter((p) => p.count > 0);
   if (mode === "table") {
-    printComponentsUsageTable(components);
+    printPatternsTable(patterns);
   } else if (mode === "chart") {
-    printComponentsUsageChart(components);
+    printPatternsChart(patterns);
   }
 }
-function printComponentsUsageTable(components) {
-  console.log(chalk__default.default.magenta.bold(`
-\u269B\uFE0F Components Usage
-`));
-  if (components.length === 0) {
-    console.log(chalk__default.default.gray("  No components found"));
+function printPatternsTable(patterns) {
+  printHeader4();
+  if (patterns.length === 0) {
+    console.log(chalk6__default.default.gray("  No patterns found"));
     return;
   }
   const table = new Table__default.default({
-    head: ["Component", "Source", "Version", "Count"],
+    head: ["Pattern", "Count"],
     style: {
       head: ["cyan"],
       border: ["gray"]
     }
   });
-  components.forEach((comp) => {
-    table.push([comp.name, comp.source, "0.0.0", comp.count.toString()]);
+  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(chalk6__default.default.gray(`
+Total: ${totalPatterns} patterns detected`));
 }
-function printComponentsUsageChart(components) {
-  console.log(chalk__default.default.magenta.bold(`
-\u269B\uFE0F Components Usage
-`));
-  if (components.length === 0) {
-    console.log(chalk__default.default.gray("  No components found"));
+function printPatternsChart(patterns) {
+  printHeader4();
+  if (patterns.length === 0) {
+    console.log(chalk6__default.default.gray("  No patterns found"));
     return;
   }
-  const data = components.map((comp) => ({
-    label: comp.name,
-    value: comp.count
+  const data = patterns.map((pattern) => ({
+    label: pattern.displayName,
+    value: pattern.count
   }));
   renderBarChart(data, { maxWidth: 50 });
 }
-function printPatterns(aggregated, mode) {
-  const patterns = aggregated.patternCounts.filter((p) => p.count > 0);
+function printHeader5() {
+  console.log(chalk6__default.default.blueBright.bold("\n\u{1F4E6} Packages\n"));
+}
+function printPackages(aggregated, mode) {
+  const packages = aggregated.packageDistribution;
   if (mode === "table") {
-    printPatternsTable(patterns);
+    printPackagesTable(packages);
   } else if (mode === "chart") {
-    printPatternsChart(patterns);
+    printPackagesChart(packages);
   }
 }
-function printPatternsTable(patterns) {
-  console.log(chalk__default.default.blue.bold(`
-\u{1F50D} Code Patterns
-`));
-  if (patterns.length === 0) {
-    console.log(chalk__default.default.gray("  No patterns found"));
+function printPackagesTable(packages) {
+  printHeader5();
+  if (packages.length === 0) {
+    console.log(chalk6__default.default.gray("  No packages found"));
     return;
   }
   const table = new Table__default.default({
-    head: ["Pattern", "Count"],
+    head: ["Package", "Version", "Components", "Usage", "Percentage"],
     style: {
       head: ["cyan"],
       border: ["gray"]
     }
   });
-  patterns.forEach((pattern) => {
-    table.push([pattern.displayName, pattern.count.toString()]);
+  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(
+    chalk6__default.default.gray(
+      `
+Total: ${formatCount(packages.length)} packages | ${formatCount(totalComponents)} unique components | ${formatCount(totalExternalUsage)} total usages`
+    )
+  );
 }
-function printPatternsChart(patterns) {
-  console.log(chalk__default.default.blue(`[PATTERNS] CHART`));
-  if (patterns.length === 0) {
-    console.log(chalk__default.default.gray("  No patterns found"));
+function printPackagesChart(packages) {
+  printHeader5();
+  if (packages.length === 0) {
+    console.log(chalk6__default.default.gray("  No packages found"));
     return;
   }
-  const data = patterns.map((pattern) => ({
-    label: pattern.displayName,
-    value: pattern.count
-  }));
-  renderBarChart(data, { maxWidth: 50 });
+  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 = chalk6__default.default.green("\u2588".repeat(barLength)) + chalk6__default.default.gray("\u2591".repeat(emptyLength));
+    console.log(
+      `${paddedLabel} ${bar} ${chalk6__default.default.bold(pkg.percentage.toFixed(1) + "%")} (${pkg.usageCount})`
+    );
+  });
+}
+async function findFiles(pattern, ignorePatterns) {
+  const files = await glob.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__default.default.join(projectPath, "package-lock.json");
+    return fs3__default.default.existsSync(lockfilePath) ? lockfilePath : null;
+  }
+  parse(lockFilePath) {
+    try {
+      const content = fs3__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 {};
+    }
+  }
+};
+var PnpmLockfileAdapter = class {
+  constructor() {
+    this.name = "pnpm";
+    this.supportedVersions = ["v5", "v6", "v9"];
+  }
+  detect(projectPath) {
+    const lockfilePath = path__default.default.join(projectPath, "pnpm-lock.yaml");
+    return fs3__default.default.existsSync(lockfilePath) ? lockfilePath : null;
+  }
+  parse(lockFilePath) {
+    try {
+      const content = fs3__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) {
+            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__default.default.join(projectPath, "yarn.lock");
+    return fs3__default.default.existsSync(lockfilePath) ? lockfilePath : null;
+  }
+  parse(lockFilePath) {
+    try {
+      const content = fs3__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 {};
+    }
+  }
+};
+
+// 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
@@ -1194,51 +1419,70 @@ function registerScanCommand(program2) {
     "[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>",
+    "Glob pattern for what packages to scan",
+    "ALL"
+    // TO FIX
   ).option(
-    "--verbose",
-    "Show detailed file-by-file analysis with every pattern found",
-    false
-  ).option("--summary [mode]", "Show summary stats (log, false)", "log").option("--details", "Show detailed pattern counts").option(
-    "--top-components [mode]",
-    "Show top components (log, table, chart)",
-    "log"
-  ).option(
-    "--components-usage [mode]",
+    "--ignore-packages <pattern>",
+    "Glob pattern for what packages to ignore",
+    []
+  ).option("--summary [mode]", "Show summary stats (log, false)", "log").option("--no-summary", "Do not show summary stats").option("--details", "Show detailed pattern counts").option(
+    "--components [mode]",
     "Show components table/chart (table, chart)",
     "table"
-  ).option(
+  ).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"
-  ).action(async (pattern, options) => {
+  ).option("--no-patterns", "Do not show patterns").action(async (pattern, options) => {
     const normalizedOptions = normalizeOptions(options);
     await executeScan(pattern, normalizedOptions);
   });
 }
+function normalizeIgnorePatterns(ignore) {
+  if (!ignore) {
+    return [];
+  }
+  return Array.isArray(ignore) ? ignore : [ignore];
+}
 function normalizeOptions(options) {
   return {
     verbose: options.verbose || false,
     summary: options.summary === false || options.summary === "false" ? false : "log",
     details: options.details || false,
-    topComponents: options.topComponents || "log",
-    componentsUsage: options.componentsUsage || "table",
+    components: options.components || "table",
+    packages: options.packages || "table",
     patterns: options.patterns || "table",
-    output: options.output
+    ignore: normalizeIgnorePatterns(options.ignore)
   };
 }
 async function executeScan(pattern, options) {
   const startTime = Date.now();
-  const spinner = ora__default.default("Finding files...").start();
+  const spinner = ora__default.default("Parsing lockfile...").start();
   try {
-    const files = await glob.glob(pattern, {
-      ignore: ["node_modules/**", "dist/**", "build/**", ".git/**"],
-      absolute: true
-    });
+    const lockfileResult = findAndParseLockfile(process.cwd());
+    spinner.succeed(
+      chalk6__default.default.blue(
+        `\u{1F4E6} Found ${lockfileResult.lockfileType} lockfile (supports: ${lockfileResult.supportedVersions.join(", ")}) - ${Object.keys(lockfileResult.versions).length} packages`
+      )
+    );
+    spinner.start("Finding files...");
+    const files = await findFiles(pattern, options.ignore);
     if (files.length === 0) {
-      spinner.fail(chalk__default.default.red(`No files found matching pattern: ${pattern}`));
+      spinner.fail("TEST");
       return;
     }
-    spinner.succeed(chalk__default.default.green(`Found ${files.length} files`));
+    spinner.succeed(chalk6__default.default.green(` Found ${files.length} files`));
     spinner.start("Analyzing files...");
     const reports = [];
     for (let i = 0; i < files.length; i++) {
@@ -1250,45 +1494,35 @@ async function executeScan(pattern, options) {
         const report = parseFile(file);
         if (report) {
           reports.push(report);
-          if (options.verbose) {
-            spinner.stop();
-            printVerbose(file, report);
-            spinner.start();
-          }
         }
       } catch (error) {
         spinner.stop();
-        console.error(chalk__default.default.red(`Error analyzing ${file}: ${error.message}`));
+        console.error(chalk6__default.default.red(`Error analyzing ${file}: ${error.message}`));
         spinner.start();
       }
     }
     spinner.succeed(
-      chalk__default.default.green(`Analysis complete! Analyzed ${reports.length} files`)
+      chalk6__default.default.green(`Analysis complete! Analyzed ${reports.length} files`)
     );
     const elapsedTime = (Date.now() - startTime) / 1e3;
-    const aggregated = aggregateReports(reports);
-    console.log("");
-    if (options.summary) {
-      printSummary(aggregated, elapsedTime);
+    const aggregated = aggregateReports(reports, lockfileResult.versions);
+    if (options.packages) {
+      printPackages(aggregated, options.packages);
     }
     if (options.details) {
-      console.log("");
       printDetails(aggregated);
     }
-    if (options.topComponents) {
-      console.log("");
-      printTopComponents(aggregated, options.topComponents);
-    }
-    if (options.componentsUsage) {
-      console.log("");
-      printComponentsUsage(aggregated, options.componentsUsage);
+    if (options.components) {
+      printComponents(aggregated, options.components);
     }
     if (options.patterns) {
-      console.log("");
       printPatterns(aggregated, options.patterns);
     }
+    if (options.summary) {
+      printSummary(aggregated, elapsedTime);
+    }
   } catch (error) {
-    spinner.fail(chalk__default.default.red("Analysis failed: " + error.message));
+    spinner.fail(chalk6__default.default.red("Analysis failed: " + error.message));
     console.error(error);
     process.exit(1);
   }
@@ -1296,7 +1530,7 @@ async function executeScan(pattern, options) {
 
 // package.json
 var package_default = {
-  version: "1.0.0-beta.1"};
+  version: "1.0.0"};
 
 // src/cli.ts
 var program = new commander.Command();