@aiready/pattern-detect 0.1.0

package/dist/cli.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/index.ts
+var import_core2 = require("@aiready/core");
+
+// src/detector.ts
+var import_core = require("@aiready/core");
+function categorizePattern(code) {
+  const lower = code.toLowerCase();
+  if (lower.includes("request") && lower.includes("response") || lower.includes("router.") || lower.includes("app.get") || lower.includes("app.post") || lower.includes("express") || lower.includes("ctx.body")) {
+    return "api-handler";
+  }
+  if (lower.includes("validate") || lower.includes("schema") || lower.includes("zod") || lower.includes("yup") || lower.includes("if") && lower.includes("throw")) {
+    return "validator";
+  }
+  if (lower.includes("return (") || lower.includes("jsx") || lower.includes("component") || lower.includes("props")) {
+    return "component";
+  }
+  if (lower.includes("class ") || lower.includes("this.")) {
+    return "class-method";
+  }
+  if (lower.includes("return ") && !lower.includes("this") && !lower.includes("new ")) {
+    return "utility";
+  }
+  if (lower.includes("function") || lower.includes("=>")) {
+    return "function";
+  }
+  return "unknown";
+}
+function extractCodeBlocks(content, minLines) {
+  const lines = content.split("\n");
+  const blocks = [];
+  let currentBlock = [];
+  let blockStart = 0;
+  let braceDepth = 0;
+  let inFunction = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!inFunction && (trimmed.includes("function ") || trimmed.includes("=>") || trimmed.includes("async ") || /^(export\s+)?(async\s+)?function\s+/.test(trimmed) || /^(export\s+)?const\s+\w+\s*=\s*(async\s*)?\(/.test(trimmed))) {
+      inFunction = true;
+      blockStart = i;
+    }
+    for (const char of line) {
+      if (char === "{") braceDepth++;
+      if (char === "}") braceDepth--;
+    }
+    if (inFunction) {
+      currentBlock.push(line);
+    }
+    if (inFunction && braceDepth === 0 && currentBlock.length >= minLines) {
+      const blockContent = currentBlock.join("\n");
+      const linesOfCode = currentBlock.filter(
+        (l) => l.trim() && !l.trim().startsWith("//")
+      ).length;
+      blocks.push({
+        content: blockContent,
+        startLine: blockStart + 1,
+        patternType: categorizePattern(blockContent),
+        linesOfCode
+      });
+      currentBlock = [];
+      inFunction = false;
+    } else if (inFunction && braceDepth === 0) {
+      currentBlock = [];
+      inFunction = false;
+    }
+  }
+  return blocks;
+}
+function normalizeCode(code) {
+  return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/"[^"]*"/g, '"STR"').replace(/'[^']*'/g, "'STR'").replace(/`[^`]*`/g, "`STR`").replace(/\b\d+\b/g, "NUM").replace(/\s+/g, " ").trim();
+}
+function calculateSimilarity(block1, block2) {
+  const norm1 = normalizeCode(block1);
+  const norm2 = normalizeCode(block2);
+  const baseSimilarity = (0, import_core.similarityScore)(norm1, norm2);
+  const tokens1 = norm1.split(/[\s(){}[\];,]+/).filter(Boolean);
+  const tokens2 = norm2.split(/[\s(){}[\];,]+/).filter(Boolean);
+  const tokenSimilarity = (0, import_core.similarityScore)(tokens1.join(" "), tokens2.join(" "));
+  return baseSimilarity * 0.4 + tokenSimilarity * 0.6;
+}
+function detectDuplicatePatterns(files, options) {
+  const { minSimilarity, minLines } = options;
+  const duplicates = [];
+  const allBlocks = files.flatMap(
+    (file) => extractCodeBlocks(file.content, minLines).map((block) => ({
+      ...block,
+      file: file.file,
+      normalized: normalizeCode(block.content),
+      tokenCost: (0, import_core.estimateTokens)(block.content)
+    }))
+  );
+  console.log(`Extracted ${allBlocks.length} code blocks for analysis`);
+  for (let i = 0; i < allBlocks.length; i++) {
+    for (let j = i + 1; j < allBlocks.length; j++) {
+      const block1 = allBlocks[i];
+      const block2 = allBlocks[j];
+      if (block1.file === block2.file) continue;
+      const similarity = calculateSimilarity(block1.content, block2.content);
+      if (similarity >= minSimilarity) {
+        duplicates.push({
+          file1: block1.file,
+          file2: block2.file,
+          line1: block1.startLine,
+          line2: block2.startLine,
+          similarity,
+          snippet: block1.content.split("\n").slice(0, 5).join("\n") + "\n...",
+          patternType: block1.patternType,
+          tokenCost: block1.tokenCost + block2.tokenCost,
+          linesOfCode: block1.linesOfCode
+        });
+      }
+    }
+  }
+  return duplicates.sort(
+    (a, b) => b.similarity - a.similarity || b.tokenCost - a.tokenCost
+  );
+}
+
+// src/index.ts
+function getRefactoringSuggestion(patternType, similarity) {
+  const baseMessages = {
+    "api-handler": "Extract common middleware or create a base handler class",
+    validator: "Consolidate validation logic into shared schema validators (Zod/Yup)",
+    utility: "Move to a shared utilities file and reuse across modules",
+    "class-method": "Consider inheritance or composition to share behavior",
+    component: "Extract shared logic into a custom hook or HOC",
+    function: "Extract into a shared helper function",
+    unknown: "Extract common logic into a reusable module"
+  };
+  const urgency = similarity > 0.95 ? " (CRITICAL: Nearly identical code)" : similarity > 0.9 ? " (HIGH: Very similar, refactor soon)" : "";
+  return baseMessages[patternType] + urgency;
+}
+async function analyzePatterns(options) {
+  const { minSimilarity = 0.85, minLines = 5, ...scanOptions } = options;
+  const files = await (0, import_core2.scanFiles)(scanOptions);
+  const results = [];
+  const fileContents = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await (0, import_core2.readFileContent)(file)
+    }))
+  );
+  const duplicates = detectDuplicatePatterns(fileContents, {
+    minSimilarity,
+    minLines
+  });
+  for (const file of files) {
+    const fileDuplicates = duplicates.filter(
+      (dup) => dup.file1 === file || dup.file2 === file
+    );
+    const issues = fileDuplicates.map((dup) => {
+      const otherFile = dup.file1 === file ? dup.file2 : dup.file1;
+      const severity = dup.similarity > 0.95 ? "critical" : dup.similarity > 0.9 ? "major" : "minor";
+      return {
+        type: "duplicate-pattern",
+        severity,
+        message: `${dup.patternType} pattern ${Math.round(dup.similarity * 100)}% similar to ${otherFile} (${dup.tokenCost} tokens wasted)`,
+        location: {
+          file,
+          line: dup.file1 === file ? dup.line1 : dup.line2
+        },
+        suggestion: getRefactoringSuggestion(dup.patternType, dup.similarity)
+      };
+    });
+    const totalTokenCost = fileDuplicates.reduce(
+      (sum, dup) => sum + dup.tokenCost,
+      0
+    );
+    results.push({
+      fileName: file,
+      issues,
+      metrics: {
+        tokenCost: totalTokenCost,
+        consistencyScore: Math.max(0, 1 - fileDuplicates.length * 0.1)
+      }
+    });
+  }
+  return results;
+}
+function generateSummary(results) {
+  const allIssues = results.flatMap((r) => r.issues);
+  const totalTokenCost = results.reduce(
+    (sum, r) => sum + (r.metrics.tokenCost || 0),
+    0
+  );
+  const patternsByType = {
+    "api-handler": 0,
+    validator: 0,
+    utility: 0,
+    "class-method": 0,
+    component: 0,
+    function: 0,
+    unknown: 0
+  };
+  allIssues.forEach((issue) => {
+    const match = issue.message.match(/^(\S+(?:-\S+)*) pattern/);
+    if (match) {
+      const type = match[1];
+      patternsByType[type] = (patternsByType[type] || 0) + 1;
+    }
+  });
+  const topDuplicates = allIssues.slice(0, 10).map((issue) => {
+    const similarityMatch = issue.message.match(/(\d+)% similar/);
+    const tokenMatch = issue.message.match(/\((\d+) tokens/);
+    const typeMatch = issue.message.match(/^(\S+(?:-\S+)*) pattern/);
+    const fileMatch = issue.message.match(/similar to (.+?) \(/);
+    return {
+      file1: issue.location.file,
+      file2: fileMatch?.[1] || "unknown",
+      similarity: similarityMatch ? parseInt(similarityMatch[1]) / 100 : 0,
+      patternType: typeMatch?.[1] || "unknown",
+      tokenCost: tokenMatch ? parseInt(tokenMatch[1]) : 0
+    };
+  });
+  return {
+    totalPatterns: allIssues.length,
+    totalTokenCost,
+    patternsByType,
+    topDuplicates
+  };
+}
+
+// src/cli.ts
+var import_chalk = __toESM(require("chalk"));
+var import_fs = require("fs");
+var import_path = require("path");
+var program = new import_commander.Command();
+program.name("aiready-patterns").description("Detect duplicate patterns in your codebase").version("0.1.0").argument("<directory>", "Directory to analyze").option("-s, --similarity <number>", "Minimum similarity score (0-1)", "0.85").option("-l, --min-lines <number>", "Minimum lines to consider", "5").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option(
+  "-o, --output <format>",
+  "Output format: console, json, html",
+  "console"
+).option("--output-file <path>", "Output file path (for json/html)").action(async (directory, options) => {
+  console.log(import_chalk.default.blue("\u{1F50D} Analyzing patterns...\n"));
+  const results = await analyzePatterns({
+    rootDir: directory,
+    minSimilarity: parseFloat(options.similarity),
+    minLines: parseInt(options.minLines),
+    include: options.include?.split(","),
+    exclude: options.exclude?.split(",")
+  });
+  const summary = generateSummary(results);
+  const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
+  if (options.output === "json") {
+    const jsonOutput = {
+      summary,
+      results,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (options.outputFile) {
+      (0, import_fs.writeFileSync)(options.outputFile, JSON.stringify(jsonOutput, null, 2));
+      console.log(import_chalk.default.green(`
+\u2713 JSON report saved to ${options.outputFile}`));
+    } else {
+      console.log(JSON.stringify(jsonOutput, null, 2));
+    }
+    return;
+  }
+  if (options.output === "html") {
+    const html = generateHTMLReport(summary, results);
+    const outputPath = options.outputFile || (0, import_path.join)(process.cwd(), "pattern-report.html");
+    (0, import_fs.writeFileSync)(outputPath, html);
+    console.log(import_chalk.default.green(`
+\u2713 HTML report saved to ${outputPath}`));
+    return;
+  }
+  console.log(import_chalk.default.cyan("\u2501".repeat(60)));
+  console.log(import_chalk.default.bold.white("  PATTERN ANALYSIS SUMMARY"));
+  console.log(import_chalk.default.cyan("\u2501".repeat(60)) + "\n");
+  console.log(
+    import_chalk.default.white(`\u{1F4C1} Files analyzed: ${import_chalk.default.bold(results.length)}`)
+  );
+  console.log(
+    import_chalk.default.yellow(`\u26A0  Duplicate patterns found: ${import_chalk.default.bold(totalIssues)}`)
+  );
+  console.log(
+    import_chalk.default.red(
+      `\u{1F4B0} Token cost (wasted): ${import_chalk.default.bold(summary.totalTokenCost.toLocaleString())}`
+    )
+  );
+  console.log(import_chalk.default.cyan("\n\u2501".repeat(60)));
+  console.log(import_chalk.default.bold.white("  PATTERNS BY TYPE"));
+  console.log(import_chalk.default.cyan("\u2501".repeat(60)) + "\n");
+  const sortedTypes = Object.entries(summary.patternsByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
+  sortedTypes.forEach(([type, count]) => {
+    const icon = getPatternIcon(type);
+    console.log(`${icon} ${import_chalk.default.white(type.padEnd(15))} ${import_chalk.default.bold(count)}`);
+  });
+  if (summary.topDuplicates.length > 0) {
+    console.log(import_chalk.default.cyan("\n\u2501".repeat(60)));
+    console.log(import_chalk.default.bold.white("  TOP DUPLICATE PATTERNS"));
+    console.log(import_chalk.default.cyan("\u2501".repeat(60)) + "\n");
+    summary.topDuplicates.slice(0, 10).forEach((dup, idx) => {
+      const severityColor = dup.similarity > 0.95 ? import_chalk.default.red : dup.similarity > 0.9 ? import_chalk.default.yellow : import_chalk.default.blue;
+      console.log(
+        `${import_chalk.default.dim(`${idx + 1}.`)} ${severityColor(
+          `${Math.round(dup.similarity * 100)}%`
+        )} ${getPatternIcon(dup.patternType)} ${import_chalk.default.white(dup.patternType)}`
+      );
+      console.log(
+        `   ${import_chalk.default.dim(dup.file1)}`
+      );
+      console.log(
+        `   ${import_chalk.default.dim("\u2194")} ${import_chalk.default.dim(dup.file2)}`
+      );
+      console.log(
+        `   ${import_chalk.default.red(`${dup.tokenCost.toLocaleString()} tokens wasted`)}
+`
+      );
+    });
+  }
+  const allIssues = results.flatMap(
+    (r) => r.issues.map((issue) => ({ ...issue, file: r.fileName }))
+  );
+  const criticalIssues = allIssues.filter(
+    (issue) => issue.severity === "critical"
+  );
+  if (criticalIssues.length > 0) {
+    console.log(import_chalk.default.cyan("\u2501".repeat(60)));
+    console.log(import_chalk.default.bold.white("  CRITICAL ISSUES (>95% similar)"));
+    console.log(import_chalk.default.cyan("\u2501".repeat(60)) + "\n");
+    criticalIssues.slice(0, 5).forEach((issue) => {
+      console.log(import_chalk.default.red("\u25CF ") + import_chalk.default.white(`${issue.file}:${issue.location.line}`));
+      console.log(`  ${import_chalk.default.dim(issue.message)}`);
+      console.log(`  ${import_chalk.default.green("\u2192")} ${import_chalk.default.italic(issue.suggestion)}
+`);
+    });
+  }
+  console.log(import_chalk.default.cyan("\u2501".repeat(60)));
+  console.log(
+    import_chalk.default.white(
+      `
+\u{1F4A1} Run with ${import_chalk.default.bold("--output json")} or ${import_chalk.default.bold("--output html")} for detailed reports
+`
+    )
+  );
+});
+function getPatternIcon(type) {
+  const icons = {
+    "api-handler": "\u{1F310}",
+    validator: "\u2713",
+    utility: "\u{1F527}",
+    "class-method": "\u{1F4E6}",
+    component: "\u269B\uFE0F",
+    function: "\u0192",
+    unknown: "\u2753"
+  };
+  return icons[type];
+}
+function generateHTMLReport(summary, results) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Pattern Detection Report</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; margin: 40px; background: #f5f5f5; }
+    .container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
+    h1 { color: #333; border-bottom: 3px solid #007acc; padding-bottom: 10px; }
+    .summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin: 30px 0; }
+    .stat-card { background: #f9f9f9; padding: 20px; border-radius: 6px; border-left: 4px solid #007acc; }
+    .stat-value { font-size: 32px; font-weight: bold; color: #007acc; }
+    .stat-label { color: #666; font-size: 14px; text-transform: uppercase; }
+    table { width: 100%; border-collapse: collapse; margin: 20px 0; }
+    th, td { text-align: left; padding: 12px; border-bottom: 1px solid #ddd; }
+    th { background: #f5f5f5; font-weight: 600; }
+    .critical { color: #d32f2f; }
+    .major { color: #f57c00; }
+    .minor { color: #1976d2; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u{1F50D} Pattern Detection Report</h1>
+    <p>Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}</p>
+    
+    <div class="summary">
+      <div class="stat-card">
+        <div class="stat-value">${results.length}</div>
+        <div class="stat-label">Files Analyzed</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-value">${summary.totalPatterns}</div>
+        <div class="stat-label">Duplicate Patterns</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-value">${summary.totalTokenCost.toLocaleString()}</div>
+        <div class="stat-label">Tokens Wasted</div>
+      </div>
+    </div>
+
+    <h2>Top Duplicate Patterns</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>Similarity</th>
+          <th>Type</th>
+          <th>File 1</th>
+          <th>File 2</th>
+          <th>Token Cost</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${summary.topDuplicates.slice(0, 20).map(
+    (dup) => `
+          <tr>
+            <td class="${dup.similarity > 0.95 ? "critical" : dup.similarity > 0.9 ? "major" : "minor"}">${Math.round(dup.similarity * 100)}%</td>
+            <td>${dup.patternType}</td>
+            <td><code>${dup.file1}</code></td>
+            <td><code>${dup.file2}</code></td>
+            <td>${dup.tokenCost.toLocaleString()}</td>
+          </tr>
+        `
+  ).join("")}
+      </tbody>
+    </table>
+  </div>
+</body>
+</html>`;
+}
+program.parse();

package/dist/cli.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import {
+  analyzePatterns,
+  generateSummary
+} from "./chunk-RLWJXASG.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import { writeFileSync } from "fs";
+import { join } from "path";
+var program = new Command();
+program.name("aiready-patterns").description("Detect duplicate patterns in your codebase").version("0.1.0").argument("<directory>", "Directory to analyze").option("-s, --similarity <number>", "Minimum similarity score (0-1)", "0.85").option("-l, --min-lines <number>", "Minimum lines to consider", "5").option("--include <patterns>", "File patterns to include (comma-separated)").option("--exclude <patterns>", "File patterns to exclude (comma-separated)").option(
+  "-o, --output <format>",
+  "Output format: console, json, html",
+  "console"
+).option("--output-file <path>", "Output file path (for json/html)").action(async (directory, options) => {
+  console.log(chalk.blue("\u{1F50D} Analyzing patterns...\n"));
+  const results = await analyzePatterns({
+    rootDir: directory,
+    minSimilarity: parseFloat(options.similarity),
+    minLines: parseInt(options.minLines),
+    include: options.include?.split(","),
+    exclude: options.exclude?.split(",")
+  });
+  const summary = generateSummary(results);
+  const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
+  if (options.output === "json") {
+    const jsonOutput = {
+      summary,
+      results,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (options.outputFile) {
+      writeFileSync(options.outputFile, JSON.stringify(jsonOutput, null, 2));
+      console.log(chalk.green(`
+\u2713 JSON report saved to ${options.outputFile}`));
+    } else {
+      console.log(JSON.stringify(jsonOutput, null, 2));
+    }
+    return;
+  }
+  if (options.output === "html") {
+    const html = generateHTMLReport(summary, results);
+    const outputPath = options.outputFile || join(process.cwd(), "pattern-report.html");
+    writeFileSync(outputPath, html);
+    console.log(chalk.green(`
+\u2713 HTML report saved to ${outputPath}`));
+    return;
+  }
+  console.log(chalk.cyan("\u2501".repeat(60)));
+  console.log(chalk.bold.white("  PATTERN ANALYSIS SUMMARY"));
+  console.log(chalk.cyan("\u2501".repeat(60)) + "\n");
+  console.log(
+    chalk.white(`\u{1F4C1} Files analyzed: ${chalk.bold(results.length)}`)
+  );
+  console.log(
+    chalk.yellow(`\u26A0  Duplicate patterns found: ${chalk.bold(totalIssues)}`)
+  );
+  console.log(
+    chalk.red(
+      `\u{1F4B0} Token cost (wasted): ${chalk.bold(summary.totalTokenCost.toLocaleString())}`
+    )
+  );
+  console.log(chalk.cyan("\n\u2501".repeat(60)));
+  console.log(chalk.bold.white("  PATTERNS BY TYPE"));
+  console.log(chalk.cyan("\u2501".repeat(60)) + "\n");
+  const sortedTypes = Object.entries(summary.patternsByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
+  sortedTypes.forEach(([type, count]) => {
+    const icon = getPatternIcon(type);
+    console.log(`${icon} ${chalk.white(type.padEnd(15))} ${chalk.bold(count)}`);
+  });
+  if (summary.topDuplicates.length > 0) {
+    console.log(chalk.cyan("\n\u2501".repeat(60)));
+    console.log(chalk.bold.white("  TOP DUPLICATE PATTERNS"));
+    console.log(chalk.cyan("\u2501".repeat(60)) + "\n");
+    summary.topDuplicates.slice(0, 10).forEach((dup, idx) => {
+      const severityColor = dup.similarity > 0.95 ? chalk.red : dup.similarity > 0.9 ? chalk.yellow : chalk.blue;
+      console.log(
+        `${chalk.dim(`${idx + 1}.`)} ${severityColor(
+          `${Math.round(dup.similarity * 100)}%`
+        )} ${getPatternIcon(dup.patternType)} ${chalk.white(dup.patternType)}`
+      );
+      console.log(
+        `   ${chalk.dim(dup.file1)}`
+      );
+      console.log(
+        `   ${chalk.dim("\u2194")} ${chalk.dim(dup.file2)}`
+      );
+      console.log(
+        `   ${chalk.red(`${dup.tokenCost.toLocaleString()} tokens wasted`)}
+`
+      );
+    });
+  }
+  const allIssues = results.flatMap(
+    (r) => r.issues.map((issue) => ({ ...issue, file: r.fileName }))
+  );
+  const criticalIssues = allIssues.filter(
+    (issue) => issue.severity === "critical"
+  );
+  if (criticalIssues.length > 0) {
+    console.log(chalk.cyan("\u2501".repeat(60)));
+    console.log(chalk.bold.white("  CRITICAL ISSUES (>95% similar)"));
+    console.log(chalk.cyan("\u2501".repeat(60)) + "\n");
+    criticalIssues.slice(0, 5).forEach((issue) => {
+      console.log(chalk.red("\u25CF ") + chalk.white(`${issue.file}:${issue.location.line}`));
+      console.log(`  ${chalk.dim(issue.message)}`);
+      console.log(`  ${chalk.green("\u2192")} ${chalk.italic(issue.suggestion)}
+`);
+    });
+  }
+  console.log(chalk.cyan("\u2501".repeat(60)));
+  console.log(
+    chalk.white(
+      `
+\u{1F4A1} Run with ${chalk.bold("--output json")} or ${chalk.bold("--output html")} for detailed reports
+`
+    )
+  );
+});
+function getPatternIcon(type) {
+  const icons = {
+    "api-handler": "\u{1F310}",
+    validator: "\u2713",
+    utility: "\u{1F527}",
+    "class-method": "\u{1F4E6}",
+    component: "\u269B\uFE0F",
+    function: "\u0192",
+    unknown: "\u2753"
+  };
+  return icons[type];
+}
+function generateHTMLReport(summary, results) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Pattern Detection Report</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; margin: 40px; background: #f5f5f5; }
+    .container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
+    h1 { color: #333; border-bottom: 3px solid #007acc; padding-bottom: 10px; }
+    .summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin: 30px 0; }
+    .stat-card { background: #f9f9f9; padding: 20px; border-radius: 6px; border-left: 4px solid #007acc; }
+    .stat-value { font-size: 32px; font-weight: bold; color: #007acc; }
+    .stat-label { color: #666; font-size: 14px; text-transform: uppercase; }
+    table { width: 100%; border-collapse: collapse; margin: 20px 0; }
+    th, td { text-align: left; padding: 12px; border-bottom: 1px solid #ddd; }
+    th { background: #f5f5f5; font-weight: 600; }
+    .critical { color: #d32f2f; }
+    .major { color: #f57c00; }
+    .minor { color: #1976d2; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u{1F50D} Pattern Detection Report</h1>
+    <p>Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}</p>
+    
+    <div class="summary">
+      <div class="stat-card">
+        <div class="stat-value">${results.length}</div>
+        <div class="stat-label">Files Analyzed</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-value">${summary.totalPatterns}</div>
+        <div class="stat-label">Duplicate Patterns</div>
+      </div>
+      <div class="stat-card">
+        <div class="stat-value">${summary.totalTokenCost.toLocaleString()}</div>
+        <div class="stat-label">Tokens Wasted</div>
+      </div>
+    </div>
+
+    <h2>Top Duplicate Patterns</h2>
+    <table>
+      <thead>
+        <tr>
+          <th>Similarity</th>
+          <th>Type</th>
+          <th>File 1</th>
+          <th>File 2</th>
+          <th>Token Cost</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${summary.topDuplicates.slice(0, 20).map(
+    (dup) => `
+          <tr>
+            <td class="${dup.similarity > 0.95 ? "critical" : dup.similarity > 0.9 ? "major" : "minor"}">${Math.round(dup.similarity * 100)}%</td>
+            <td>${dup.patternType}</td>
+            <td><code>${dup.file1}</code></td>
+            <td><code>${dup.file2}</code></td>
+            <td>${dup.tokenCost.toLocaleString()}</td>
+          </tr>
+        `
+  ).join("")}
+      </tbody>
+    </table>
+  </div>
+</body>
+</html>`;
+}
+program.parse();