@aiready/pattern-detect 0.17.8 → 0.17.12

package/dist/chunk-TGBZP7SB.mjs

@@ -1,773 +0,0 @@
-// src/index.ts
-import { readFileContent, Severity as Severity4, IssueType } from "@aiready/core";
-
-// src/detector.ts
-import { estimateTokens } from "@aiready/core";
-
-// src/context-rules.ts
-import { Severity } from "@aiready/core";
-var CONTEXT_RULES = [
-  // Test Fixtures - Intentional duplication for test isolation
-  {
-    name: "test-fixtures",
-    detect: (file, code) => {
-      const isTestFile = file.includes(".test.") || file.includes(".spec.") || file.includes("__tests__") || file.includes("/test/") || file.includes("/tests/");
-      const hasTestFixtures = code.includes("beforeAll") || code.includes("afterAll") || code.includes("beforeEach") || code.includes("afterEach") || code.includes("setUp") || code.includes("tearDown");
-      return isTestFile && hasTestFixtures;
-    },
-    severity: Severity.Info,
-    reason: "Test fixture duplication is intentional for test isolation",
-    suggestion: "Consider if shared test setup would improve maintainability without coupling tests"
-  },
-  // Email/Document Templates - Often intentionally similar for consistency
-  {
-    name: "templates",
-    detect: (file, code) => {
-      const isTemplate = file.includes("/templates/") || file.includes("-template") || file.includes("/email-templates/") || file.includes("/emails/");
-      const hasTemplateContent = (code.includes("return") || code.includes("export")) && (code.includes("html") || code.includes("subject") || code.includes("body"));
-      return isTemplate && hasTemplateContent;
-    },
-    severity: Severity.Minor,
-    reason: "Template duplication may be intentional for maintainability and branding consistency",
-    suggestion: "Extract shared structure only if templates become hard to maintain"
-  },
-  // E2E/Integration Test Page Objects - Test independence
-  {
-    name: "e2e-page-objects",
-    detect: (file, code) => {
-      const isE2ETest = file.includes("e2e/") || file.includes("/e2e/") || file.includes(".e2e.") || file.includes("/playwright/") || file.includes("playwright/") || file.includes("/cypress/") || file.includes("cypress/") || file.includes("/integration/") || file.includes("integration/");
-      const hasPageObjectPatterns = code.includes("page.") || code.includes("await page") || code.includes("locator") || code.includes("getBy") || code.includes("selector") || code.includes("click(") || code.includes("fill(");
-      return isE2ETest && hasPageObjectPatterns;
-    },
-    severity: Severity.Minor,
-    reason: "E2E test duplication ensures test independence and reduces coupling",
-    suggestion: "Consider page object pattern only if duplication causes maintenance issues"
-  },
-  // Configuration Files - Often necessarily similar by design
-  {
-    name: "config-files",
-    detect: (file) => {
-      return file.endsWith(".config.ts") || file.endsWith(".config.js") || file.includes("jest.config") || file.includes("vite.config") || file.includes("webpack.config") || file.includes("rollup.config") || file.includes("tsconfig");
-    },
-    severity: Severity.Minor,
-    reason: "Configuration files often have similar structure by design",
-    suggestion: "Consider shared config base only if configurations become hard to maintain"
-  },
-  // Type Definitions - Duplication for type safety and module independence
-  {
-    name: "type-definitions",
-    detect: (file, code) => {
-      const isTypeFile = file.endsWith(".d.ts") || file.includes("/types/");
-      const hasTypeDefinitions = code.includes("interface ") || code.includes("type ") || code.includes("enum ");
-      return isTypeFile && hasTypeDefinitions;
-    },
-    severity: Severity.Info,
-    reason: "Type duplication may be intentional for module independence and type safety",
-    suggestion: "Extract to shared types package only if causing maintenance burden"
-  },
-  // Migration Scripts - One-off scripts that are similar by nature
-  {
-    name: "migration-scripts",
-    detect: (file) => {
-      return file.includes("/migrations/") || file.includes("/migrate/") || file.includes(".migration.");
-    },
-    severity: Severity.Info,
-    reason: "Migration scripts are typically one-off and intentionally similar",
-    suggestion: "Duplication is acceptable for migration scripts"
-  },
-  // Mock Data - Test data intentionally duplicated
-  {
-    name: "mock-data",
-    detect: (file, code) => {
-      const isMockFile = file.includes("/mocks/") || file.includes("/__mocks__/") || file.includes("/fixtures/") || file.includes(".mock.") || file.includes(".fixture.");
-      const hasMockData = code.includes("mock") || code.includes("Mock") || code.includes("fixture") || code.includes("stub") || code.includes("export const");
-      return isMockFile && hasMockData;
-    },
-    severity: Severity.Info,
-    reason: "Mock data duplication is expected for comprehensive test coverage",
-    suggestion: "Consider shared factories only for complex mock generation"
-  }
-];
-function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
-  for (const rule of CONTEXT_RULES) {
-    if (rule.detect(file1, code) || rule.detect(file2, code)) {
-      return {
-        severity: rule.severity,
-        reason: rule.reason,
-        suggestion: rule.suggestion,
-        matchedRule: rule.name
-      };
-    }
-  }
-  if (similarity >= 0.95 && linesOfCode >= 30) {
-    return {
-      severity: Severity.Critical,
-      reason: "Large nearly-identical code blocks waste tokens and create maintenance burden",
-      suggestion: "Extract to shared utility module immediately"
-    };
-  } else if (similarity >= 0.95 && linesOfCode >= 15) {
-    return {
-      severity: Severity.Major,
-      reason: "Nearly identical code should be consolidated",
-      suggestion: "Move to shared utility file"
-    };
-  } else if (similarity >= 0.85) {
-    return {
-      severity: Severity.Major,
-      reason: "High similarity indicates significant duplication",
-      suggestion: "Extract common logic to shared function"
-    };
-  } else if (similarity >= 0.7) {
-    return {
-      severity: Severity.Minor,
-      reason: "Moderate similarity detected",
-      suggestion: "Consider extracting shared patterns if code evolves together"
-    };
-  } else {
-    return {
-      severity: Severity.Minor,
-      reason: "Minor similarity detected",
-      suggestion: "Monitor but refactoring may not be worthwhile"
-    };
-  }
-}
-function getSeverityLabel(severity) {
-  const labels = {
-    [Severity.Critical]: "\u{1F534} CRITICAL",
-    [Severity.Major]: "\u{1F7E1} MAJOR",
-    [Severity.Minor]: "\u{1F535} MINOR",
-    [Severity.Info]: "\u2139\uFE0F  INFO"
-  };
-  return labels[severity];
-}
-function filterBySeverity(duplicates, minSeverity) {
-  const severityOrder = [
-    Severity.Info,
-    Severity.Minor,
-    Severity.Major,
-    Severity.Critical
-  ];
-  const minIndex = severityOrder.indexOf(minSeverity);
-  if (minIndex === -1) return duplicates;
-  return duplicates.filter((dup) => {
-    const dupIndex = severityOrder.indexOf(dup.severity);
-    return dupIndex >= minIndex;
-  });
-}
-
-// src/detector.ts
-function normalizeCode(code) {
-  return code.replace(/\s+/g, " ").replace(/['"]/g, '"').replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").trim();
-}
-function extractBlocks(file, content) {
-  const blocks = [];
-  const lines = content.split("\n");
-  const blockRegex = /(?:export\s+)?(?:async\s+)?(function|class|const|interface|type)\s+([a-zA-Z0-9_]+)|(app\.(?:get|post|put|delete|patch|use))\(/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const startLine = content.substring(0, match.index).split("\n").length;
-    let type;
-    let name;
-    if (match[1]) {
-      type = match[1];
-      name = match[2];
-    } else {
-      type = "handler";
-      name = match[3];
-    }
-    let endLine = startLine + 5;
-    let openBraces = 0;
-    let foundStart = false;
-    for (let i = match.index; i < content.length; i++) {
-      if (content[i] === "{") {
-        openBraces++;
-        foundStart = true;
-      } else if (content[i] === "}") {
-        openBraces--;
-      }
-      if (foundStart && openBraces === 0) {
-        endLine = content.substring(0, i).split("\n").length;
-        break;
-      }
-    }
-    const blockCode = lines.slice(startLine - 1, endLine).join("\n");
-    const tokens = estimateTokens(blockCode);
-    blocks.push({
-      file,
-      startLine,
-      endLine,
-      code: blockCode,
-      tokens,
-      patternType: inferPatternType(type, name)
-    });
-  }
-  return blocks;
-}
-function inferPatternType(keyword, name) {
-  const n = name.toLowerCase();
-  if (keyword === "handler" || n.includes("handler") || n.includes("controller") || n.startsWith("app.")) {
-    return "api-handler";
-  }
-  if (n.includes("validate") || n.includes("schema")) return "validator";
-  if (n.includes("util") || n.includes("helper")) return "utility";
-  if (keyword === "class") return "class-method";
-  if (n.match(/^[A-Z]/)) return "component";
-  if (keyword === "function") return "function";
-  return "unknown";
-}
-function calculateSimilarity(a, b) {
-  if (a === b) return 1;
-  const setA = new Set(a.split(" "));
-  const setB = new Set(b.split(" "));
-  const intersection = new Set([...setA].filter((x) => setB.has(x)));
-  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
-  return intersection.size / union.size;
-}
-async function detectDuplicatePatterns(fileContents, options) {
-  const { minSimilarity, minLines, batchSize, streamResults } = options;
-  const allBlocks = [];
-  for (const { file, content } of fileContents) {
-    const blocks = extractBlocks(file, content);
-    allBlocks.push(...blocks.filter((b) => b.endLine - b.startLine >= minLines));
-  }
-  const duplicates = [];
-  for (let i = 0; i < allBlocks.length; i++) {
-    for (let j = i + 1; j < allBlocks.length; j++) {
-      const b1 = allBlocks[i];
-      const b2 = allBlocks[j];
-      if (b1.file === b2.file) continue;
-      const norm1 = normalizeCode(b1.code);
-      const norm2 = normalizeCode(b2.code);
-      const sim = calculateSimilarity(norm1, norm2);
-      if (sim >= minSimilarity) {
-        const { severity, reason, suggestion, matchedRule } = calculateSeverity(
-          b1.file,
-          b2.file,
-          b1.code,
-          sim,
-          b1.endLine - b1.startLine
-        );
-        const dup = {
-          file1: b1.file,
-          line1: b1.startLine,
-          endLine1: b1.endLine,
-          file2: b2.file,
-          line2: b2.startLine,
-          endLine2: b2.endLine,
-          code1: b1.code,
-          code2: b2.code,
-          similarity: sim,
-          patternType: b1.patternType,
-          tokenCost: b1.tokens + b2.tokens,
-          severity,
-          reason,
-          suggestion,
-          matchedRule
-        };
-        duplicates.push(dup);
-        if (streamResults)
-          console.log(
-            `[DUPLICATE] ${dup.file1}:${dup.line1} <-> ${dup.file2}:${dup.line2} (${Math.round(sim * 100)}%)`
-          );
-      }
-    }
-  }
-  return duplicates;
-}
-
-// src/grouping.ts
-import { Severity as Severity3 } from "@aiready/core";
-import path from "path";
-function getSeverityLevel(s) {
-  const enumMap = {
-    [Severity3.Critical]: 4,
-    [Severity3.Major]: 3,
-    [Severity3.Minor]: 2,
-    [Severity3.Info]: 1
-  };
-  const stringMap = {
-    critical: 4,
-    major: 3,
-    minor: 2,
-    info: 1
-  };
-  if (typeof s === "string") return stringMap[s.toLowerCase()] ?? 0;
-  return enumMap[s] ?? 0;
-}
-function groupDuplicatesByFilePair(duplicates) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const dup of duplicates) {
-    const files = [dup.file1, dup.file2].sort();
-    const key = files.join("::");
-    if (!groups.has(key)) {
-      groups.set(key, {
-        filePair: key,
-        severity: dup.severity,
-        occurrences: 0,
-        totalTokenCost: 0,
-        averageSimilarity: 0,
-        patternTypes: /* @__PURE__ */ new Set(),
-        lineRanges: []
-      });
-    }
-    const group = groups.get(key);
-    group.occurrences++;
-    group.totalTokenCost += dup.tokenCost;
-    group.averageSimilarity += dup.similarity;
-    group.patternTypes.add(dup.patternType);
-    group.lineRanges.push({
-      file1: { start: dup.line1, end: dup.endLine1 },
-      file2: { start: dup.line2, end: dup.endLine2 }
-    });
-    const currentSev = dup.severity;
-    if (getSeverityLevel(currentSev) > getSeverityLevel(group.severity)) {
-      group.severity = currentSev;
-    }
-  }
-  return Array.from(groups.values()).map((g) => ({
-    ...g,
-    averageSimilarity: g.averageSimilarity / g.occurrences
-  }));
-}
-function createRefactorClusters(duplicates) {
-  const adjacency = /* @__PURE__ */ new Map();
-  const visited = /* @__PURE__ */ new Set();
-  const components = [];
-  for (const dup of duplicates) {
-    if (!adjacency.has(dup.file1)) adjacency.set(dup.file1, /* @__PURE__ */ new Set());
-    if (!adjacency.has(dup.file2)) adjacency.set(dup.file2, /* @__PURE__ */ new Set());
-    adjacency.get(dup.file1).add(dup.file2);
-    adjacency.get(dup.file2).add(dup.file1);
-  }
-  for (const file of adjacency.keys()) {
-    if (visited.has(file)) continue;
-    const component = [];
-    const queue = [file];
-    visited.add(file);
-    while (queue.length > 0) {
-      const curr = queue.shift();
-      component.push(curr);
-      for (const neighbor of adjacency.get(curr) || []) {
-        if (!visited.has(neighbor)) {
-          visited.add(neighbor);
-          queue.push(neighbor);
-        }
-      }
-    }
-    components.push(component);
-  }
-  const clusters = [];
-  for (const component of components) {
-    if (component.length < 2) continue;
-    const componentDups = duplicates.filter(
-      (d) => component.includes(d.file1) && component.includes(d.file2)
-    );
-    const totalTokenCost = componentDups.reduce((sum, d) => sum + d.tokenCost, 0);
-    const avgSimilarity = componentDups.reduce((sum, d) => sum + d.similarity, 0) / Math.max(1, componentDups.length);
-    const name = determineClusterName(component);
-    const { severity, reason, suggestion } = calculateSeverity(
-      component[0],
-      component[1],
-      "",
-      // Code not available here
-      avgSimilarity,
-      30
-      // Assume substantial if clustered
-    );
-    clusters.push({
-      id: `cluster-${clusters.length}`,
-      name,
-      files: component,
-      severity,
-      duplicateCount: componentDups.length,
-      totalTokenCost,
-      averageSimilarity: avgSimilarity,
-      reason,
-      suggestion
-    });
-  }
-  return clusters;
-}
-function determineClusterName(files) {
-  if (files.length === 0) return "Unknown Cluster";
-  if (files.some((f) => f.includes("blog"))) return "Blog SEO Boilerplate";
-  if (files.some((f) => f.includes("buttons"))) return "Button Component Variants";
-  if (files.some((f) => f.includes("cards"))) return "Card Component Variants";
-  if (files.some((f) => f.includes("login.test"))) return "E2E Test Patterns";
-  const first = files[0];
-  const dirName = path.dirname(first).split(path.sep).pop();
-  if (dirName && dirName !== "." && dirName !== "..") {
-    return `${dirName.charAt(0).toUpperCase() + dirName.slice(1)} Domain Group`;
-  }
-  return "Shared Pattern Group";
-}
-function filterClustersByImpact(clusters, minTokenCost = 1e3, minFiles = 3) {
-  return clusters.filter(
-    (c) => c.totalTokenCost >= minTokenCost || c.files.length >= minFiles
-  );
-}
-
-// src/scoring.ts
-import {
-  calculateMonthlyCost,
-  calculateProductivityImpact,
-  DEFAULT_COST_CONFIG
-} from "@aiready/core";
-function calculatePatternScore(duplicates, totalFilesAnalyzed, costConfig) {
-  const totalDuplicates = duplicates.length;
-  const totalTokenCost = duplicates.reduce((sum, d) => sum + d.tokenCost, 0);
-  const highImpactDuplicates = duplicates.filter(
-    (d) => d.tokenCost > 1e3 || d.similarity > 0.7
-  ).length;
-  if (totalFilesAnalyzed === 0) {
-    return {
-      toolName: "pattern-detect",
-      score: 100,
-      rawMetrics: {
-        totalDuplicates: 0,
-        totalTokenCost: 0,
-        highImpactDuplicates: 0,
-        totalFilesAnalyzed: 0
-      },
-      factors: [],
-      recommendations: []
-    };
-  }
-  const duplicatesPerFile = totalDuplicates / totalFilesAnalyzed * 100;
-  const tokenWastePerFile = totalTokenCost / totalFilesAnalyzed;
-  const duplicatesPenalty = Math.min(60, duplicatesPerFile * 0.6);
-  const tokenPenalty = Math.min(40, tokenWastePerFile / 125);
-  const highImpactPenalty = highImpactDuplicates > 0 ? Math.min(15, highImpactDuplicates * 2 - 5) : -5;
-  const score = 100 - duplicatesPenalty - tokenPenalty - highImpactPenalty;
-  const finalScore = Math.max(0, Math.min(100, Math.round(score)));
-  const factors = [
-    {
-      name: "Duplication Density",
-      impact: -Math.round(duplicatesPenalty),
-      description: `${duplicatesPerFile.toFixed(1)} duplicates per 100 files`
-    },
-    {
-      name: "Token Waste",
-      impact: -Math.round(tokenPenalty),
-      description: `${Math.round(tokenWastePerFile)} tokens wasted per file`
-    }
-  ];
-  if (highImpactDuplicates > 0) {
-    factors.push({
-      name: "High-Impact Patterns",
-      impact: -Math.round(highImpactPenalty),
-      description: `${highImpactDuplicates} high-impact duplicates (>1000 tokens or >70% similar)`
-    });
-  } else {
-    factors.push({
-      name: "No High-Impact Patterns",
-      impact: 5,
-      description: "No severe duplicates detected"
-    });
-  }
-  const recommendations = [];
-  if (highImpactDuplicates > 0) {
-    const estimatedImpact = Math.min(15, highImpactDuplicates * 3);
-    recommendations.push({
-      action: `Deduplicate ${highImpactDuplicates} high-impact pattern${highImpactDuplicates > 1 ? "s" : ""}`,
-      estimatedImpact,
-      priority: "high"
-    });
-  }
-  if (totalDuplicates > 10 && duplicatesPerFile > 20) {
-    const estimatedImpact = Math.min(10, Math.round(duplicatesPenalty * 0.3));
-    recommendations.push({
-      action: "Extract common patterns into shared utilities",
-      estimatedImpact,
-      priority: "medium"
-    });
-  }
-  if (tokenWastePerFile > 2e3) {
-    const estimatedImpact = Math.min(8, Math.round(tokenPenalty * 0.4));
-    recommendations.push({
-      action: "Consolidate duplicated logic to reduce AI context waste",
-      estimatedImpact,
-      priority: totalTokenCost > 1e4 ? "high" : "medium"
-    });
-  }
-  const cfg = { ...DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = calculateMonthlyCost(totalTokenCost, cfg);
-  const issues = duplicates.map((d) => ({
-    severity: d.severity === "critical" ? "critical" : d.severity === "major" ? "major" : "minor"
-  }));
-  const productivityImpact = calculateProductivityImpact(issues);
-  return {
-    toolName: "pattern-detect",
-    score: finalScore,
-    rawMetrics: {
-      totalDuplicates,
-      totalTokenCost,
-      highImpactDuplicates,
-      totalFilesAnalyzed,
-      duplicatesPerFile: Math.round(duplicatesPerFile * 10) / 10,
-      tokenWastePerFile: Math.round(tokenWastePerFile),
-      // Business value metrics
-      estimatedMonthlyCost,
-      estimatedDeveloperHours: productivityImpact.totalHours
-    },
-    factors,
-    recommendations
-  };
-}
-
-// 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 getSmartDefaults(directory, userOptions) {
-  if (userOptions.useSmartDefaults === false) {
-    return {
-      rootDir: directory,
-      minSimilarity: 0.6,
-      minLines: 8,
-      batchSize: 100,
-      approx: true,
-      minSharedTokens: 12,
-      maxCandidatesPerBlock: 5,
-      streamResults: false,
-      severity: "all",
-      includeTests: false
-    };
-  }
-  const scanOptions = {
-    rootDir: directory,
-    include: userOptions.include || ["**/*.{ts,tsx,js,jsx,py,java}"],
-    exclude: userOptions.exclude
-  };
-  const { scanFiles: scanFiles2 } = await import("@aiready/core");
-  const files = await scanFiles2(scanOptions);
-  const estimatedBlocks = files.length * 3;
-  const maxCandidatesPerBlock = Math.max(
-    3,
-    Math.min(10, Math.floor(3e4 / estimatedBlocks))
-  );
-  const minSimilarity = Math.min(0.75, 0.5 + estimatedBlocks / 1e4 * 0.25);
-  const minLines = Math.max(
-    6,
-    Math.min(12, 6 + Math.floor(estimatedBlocks / 2e3))
-  );
-  const minSharedTokens = Math.max(
-    10,
-    Math.min(20, 10 + Math.floor(estimatedBlocks / 2e3))
-  );
-  const batchSize = estimatedBlocks > 1e3 ? 200 : 100;
-  const severity = estimatedBlocks > 5e3 ? "high" : "all";
-  const defaults = {
-    rootDir: directory,
-    minSimilarity,
-    minLines,
-    batchSize,
-    approx: true,
-    minSharedTokens,
-    maxCandidatesPerBlock,
-    streamResults: false,
-    severity,
-    includeTests: false
-  };
-  const result = { ...defaults };
-  for (const [key, value] of Object.entries(defaults)) {
-    if (key in userOptions && userOptions[key] !== void 0) {
-      result[key] = userOptions[key];
-    }
-  }
-  return result;
-}
-function logConfiguration(config, estimatedBlocks) {
-  if (config.suppressToolConfig) return;
-  console.log("\u{1F4CB} Configuration:");
-  console.log(`   Repository size: ~${estimatedBlocks} code blocks`);
-  console.log(`   Similarity threshold: ${config.minSimilarity}`);
-  console.log(`   Minimum lines: ${config.minLines}`);
-  console.log(`   Approximate mode: ${config.approx ? "enabled" : "disabled"}`);
-  console.log(`   Max candidates per block: ${config.maxCandidatesPerBlock}`);
-  console.log(`   Min shared tokens: ${config.minSharedTokens}`);
-  console.log(`   Severity filter: ${config.severity}`);
-  console.log(`   Include tests: ${config.includeTests}`);
-  console.log("");
-}
-async function analyzePatterns(options) {
-  const smartDefaults = await getSmartDefaults(options.rootDir || ".", options);
-  const finalOptions = { ...smartDefaults, ...options };
-  const {
-    minSimilarity = 0.4,
-    minLines = 5,
-    batchSize = 100,
-    approx = true,
-    minSharedTokens = 8,
-    maxCandidatesPerBlock = 100,
-    streamResults = false,
-    severity = "all",
-    includeTests = false,
-    groupByFilePair = true,
-    createClusters = true,
-    minClusterTokenCost = 1e3,
-    minClusterFiles = 3,
-    ...scanOptions
-  } = finalOptions;
-  const { scanFiles: scanFiles2 } = await import("@aiready/core");
-  const files = await scanFiles2(scanOptions);
-  const estimatedBlocks = files.length * 3;
-  logConfiguration(finalOptions, estimatedBlocks);
-  const results = [];
-  const BATCH_SIZE = 50;
-  const fileContents = [];
-  for (let i = 0; i < files.length; i += BATCH_SIZE) {
-    const batch = files.slice(i, i + BATCH_SIZE);
-    const batchContents = await Promise.all(
-      batch.map(async (file) => ({
-        file,
-        content: await readFileContent(file)
-      }))
-    );
-    fileContents.push(...batchContents);
-  }
-  const duplicates = await detectDuplicatePatterns(fileContents, {
-    minSimilarity,
-    minLines,
-    batchSize,
-    approx,
-    minSharedTokens,
-    maxCandidatesPerBlock,
-    streamResults,
-    onProgress: options.onProgress
-  });
-  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 severity2 = dup.similarity > 0.95 ? Severity4.Critical : dup.similarity > 0.9 ? Severity4.Major : Severity4.Minor;
-      return {
-        type: IssueType.DuplicatePattern,
-        severity: severity2,
-        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)
-      };
-    });
-    let filteredIssues = issues;
-    if (severity !== "all") {
-      const severityMap = {
-        critical: [Severity4.Critical],
-        high: [Severity4.Critical, Severity4.Major],
-        medium: [Severity4.Critical, Severity4.Major, Severity4.Minor]
-      };
-      const allowedSeverities = severityMap[severity] || [Severity4.Critical, Severity4.Major, Severity4.Minor];
-      filteredIssues = issues.filter(
-        (issue) => allowedSeverities.includes(issue.severity)
-      );
-    }
-    const totalTokenCost = fileDuplicates.reduce(
-      (sum, dup) => sum + dup.tokenCost,
-      0
-    );
-    results.push({
-      fileName: file,
-      issues: filteredIssues,
-      metrics: {
-        tokenCost: totalTokenCost,
-        consistencyScore: Math.max(0, 1 - fileDuplicates.length * 0.1)
-      }
-    });
-  }
-  let groups;
-  let clusters;
-  if (groupByFilePair) {
-    groups = groupDuplicatesByFilePair(duplicates);
-  }
-  if (createClusters) {
-    const allClusters = createRefactorClusters(duplicates);
-    clusters = filterClustersByImpact(
-      allClusters,
-      minClusterTokenCost,
-      minClusterFiles
-    );
-  }
-  return { results, duplicates, files, groups, clusters };
-}
-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 {
-      files: [
-        {
-          path: issue.location.file,
-          startLine: issue.location.line,
-          endLine: 0
-          // Not available from Issue
-        },
-        {
-          path: fileMatch?.[1] || "unknown",
-          startLine: 0,
-          // Not available from Issue
-          endLine: 0
-          // Not available from Issue
-        }
-      ],
-      similarity: similarityMatch ? parseInt(similarityMatch[1]) / 100 : 0,
-      patternType: typeMatch?.[1] || "unknown",
-      tokenCost: tokenMatch ? parseInt(tokenMatch[1]) : 0
-    };
-  });
-  return {
-    totalPatterns: allIssues.length,
-    totalTokenCost,
-    patternsByType,
-    topDuplicates
-  };
-}
-
-export {
-  calculateSeverity,
-  getSeverityLabel,
-  filterBySeverity,
-  detectDuplicatePatterns,
-  calculatePatternScore,
-  Severity4 as Severity,
-  getSmartDefaults,
-  analyzePatterns,
-  generateSummary
-};