@aiready/pattern-detect 0.17.13 → 0.17.15

package/dist/analyzer-entry/index.js

@@ -166,19 +166,91 @@ var INFRA_RULES = [
   {
     name: "cli-command-definitions",
     detect: (file, code) => {
-      const isCliFile = file.includes("/commands/") || file.includes("/cli/") || file.endsWith(".command.ts");
+      const basename = file.split("/").pop() || "";
+      const isCliFile = file.includes("/commands/") || file.includes("/cli/") || file.endsWith(".command.ts") || basename === "cli.ts" || basename === "cli.js" || basename === "cli.tsx" || basename === "cli-action.ts";
       const hasCommandPattern = (code.includes(".command(") || code.includes("defineCommand")) && (code.includes(".description(") || code.includes(".option(")) && (code.includes(".action(") || code.includes("async"));
       return isCliFile && hasCommandPattern;
     },
     severity: import_core3.Severity.Info,
     reason: "CLI command definitions follow standard Commander.js patterns and are intentionally similar",
     suggestion: "Command boilerplate duplication is acceptable for CLI interfaces"
+  },
+  // DynamoDB Single-Table Design - Standard single-table patterns with prefixed keys
+  {
+    name: "dynamodb-single-table",
+    detect: (file, code) => {
+      const hasDynamoDBPattern = code.includes("docClient") || code.includes("dynamodb") || code.includes("DynamoDB") || code.includes("queryItems") || code.includes("putItem") || code.includes("getItem") || code.includes("updateItem") || code.includes("deleteItem");
+      const hasKeyPrefix = code.includes("userId:") && code.includes("#") || code.includes("pk:") && code.includes("#") || code.includes("Key:") && code.includes("#") || /[A-Z]+#/.test(code);
+      const hasSingleTablePattern = code.includes("KeyConditionExpression") || code.includes("pk =") || code.includes("sk =") || code.includes("userId") && code.includes("timestamp");
+      return hasDynamoDBPattern && (hasKeyPrefix || hasSingleTablePattern);
+    },
+    severity: import_core3.Severity.Info,
+    reason: "DynamoDB single-table design with prefixed keys is a standard pattern for efficient data access",
+    suggestion: "Single-table query patterns are intentionally similar and should not be refactored"
+  },
+  // CLI Main Function Boilerplate - Standard argument parsing patterns
+  {
+    name: "cli-main-boilerplate",
+    detect: (file, code) => {
+      const basename = file.split("/").pop() || "";
+      const isCliFile = file.includes("/cli/") || file.includes("/commands/") || basename.startsWith("cli") || basename.endsWith(".cli.ts") || basename.endsWith(".cli.js");
+      const hasMainFunction = code.includes("function main()") || code.includes("async function main()") || code.includes("const main =") || code.includes("main()");
+      const hasArgParsing = code.includes("process.argv") || code.includes("yargs") || code.includes("commander") || code.includes("minimist") || code.includes(".parse(") || code.includes("args") && code.includes("._");
+      return isCliFile && hasMainFunction && hasArgParsing;
+    },
+    severity: import_core3.Severity.Info,
+    reason: "CLI main functions with argument parsing follow standard boilerplate patterns",
+    suggestion: "CLI argument parsing boilerplate is acceptable and should not be flagged as duplication"
   }
 ];
 
 // src/rules/categories/logic-rules.ts
 var import_core4 = require("@aiready/core");
 var LOGIC_RULES = [
+  // Enum Semantic Difference - Different enum names indicate different semantic meanings
+  {
+    name: "enum-semantic-difference",
+    detect: (file, code) => {
+      const enumRegex = /(?:export\s+)?(?:const\s+)?enum\s+([A-Z][a-zA-Z0-9]*)/g;
+      const enums = [];
+      let match;
+      while ((match = enumRegex.exec(code)) !== null) {
+        enums.push(match[1]);
+      }
+      return enums.length > 0;
+    },
+    severity: import_core4.Severity.Info,
+    reason: "Enums with different names represent different semantic domain concepts, even if they share similar values",
+    suggestion: "Different enums (e.g., EscalationPriority vs HealthSeverity) serve different purposes and should not be merged"
+  },
+  // Enum Value Similarity - Common enum values like LOW, MEDIUM, HIGH are standard
+  {
+    name: "enum-value-similarity",
+    detect: (file, code) => {
+      const hasCommonEnumValues = (code.includes("LOW = 'low'") || code.includes("LOW = 0") || code.includes("LOW = 'LOW'")) && (code.includes("HIGH = 'high'") || code.includes("HIGH = 2") || code.includes("HIGH = 'HIGH'")) && (code.includes("MEDIUM = 'medium'") || code.includes("MEDIUM = 1") || code.includes("MEDIUM = 'MEDIUM'"));
+      const isEnumDefinition = /(?:export\s+)?(?:const\s+)?enum\s+/.test(code) || code.includes("enum ") && code.includes("{") && code.includes("}");
+      return hasCommonEnumValues && isEnumDefinition;
+    },
+    severity: import_core4.Severity.Info,
+    reason: "Common enum values (LOW, MEDIUM, HIGH, CRITICAL) are standard patterns used across different domain enums",
+    suggestion: "Enum value similarity is expected for severity/priority enums and should not be flagged as duplication"
+  },
+  // Re-export / Barrel files - Intentional API surface consolidation
+  {
+    name: "re-export-files",
+    detect: (file, code) => {
+      const isIndexFile = file.endsWith("/index.ts") || file.endsWith("/index.js") || file.endsWith("/index.tsx") || file.endsWith("/index.jsx");
+      const lines = code.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) return false;
+      const reExportLines = lines.filter(
+        (l) => /^export\s+(\{[^}]+\}|\*)\s+from\s+/.test(l.trim()) || /^export\s+\*\s+as\s+\w+\s+from\s+/.test(l.trim())
+      ).length;
+      return isIndexFile && reExportLines > 0 && reExportLines / lines.length > 0.5;
+    },
+    severity: import_core4.Severity.Info,
+    reason: "Barrel/index files intentionally re-export for API surface consolidation",
+    suggestion: "Re-exports in barrel files are expected and not true duplication"
+  },
   // Type Definitions - Duplication for type safety and module independence
   {
     name: "type-definitions",
@@ -192,6 +264,20 @@ var LOGIC_RULES = [
     reason: "Type/interface definitions are intentionally duplicated for module independence",
     suggestion: "Extract to shared types package only if causing maintenance burden"
   },
+  // Cross-Package Type Definitions - Different packages may have similar types
+  {
+    name: "cross-package-types",
+    detect: (file, code) => {
+      const hasTypeDefinition = code.includes("interface ") || code.includes("type ") || code.includes("enum ");
+      const isPackageOrApp = file.includes("/packages/") || file.includes("/apps/") || file.includes("/core/");
+      const packageMatch = file.match(/\/(packages|apps|core)\/([^/]+)\//);
+      const hasPackageStructure = packageMatch !== null;
+      return hasTypeDefinition && isPackageOrApp && hasPackageStructure;
+    },
+    severity: import_core4.Severity.Info,
+    reason: "Types in different packages/modules are often intentionally similar for module independence",
+    suggestion: "Cross-package type duplication is acceptable for decoupled module architecture"
+  },
   // Utility Functions - Small helpers in dedicated utility files
   {
     name: "utility-functions",
@@ -274,6 +360,22 @@ var LOGIC_RULES = [
     severity: import_core4.Severity.Info,
     reason: "Validation functions are inherently similar and often intentionally duplicated for domain clarity",
     suggestion: "Consider extracting to shared validators only if validation logic becomes complex"
+  },
+  // Singleton Getter Pattern - Standard singleton initialization pattern
+  {
+    name: "singleton-getter",
+    detect: (file, code) => {
+      const hasSingletonGetter = /(?:export\s+)?(?:async\s+)?function\s+get[A-Z][a-zA-Z0-9]*\s*\(/.test(
+        code
+      ) || /(?:export\s+)?const\s+get[A-Z][a-zA-Z0-9]*\s*=\s*(?:async\s+)?\(\)\s*=>/.test(
+        code
+      );
+      const hasSingletonPattern = code.includes("if (!") && code.includes("instance") && code.includes(" = ") || code.includes("if (!_") && code.includes(" = new ") || code.includes("if (") && code.includes(" === null") && code.includes(" = new ");
+      return hasSingletonGetter && hasSingletonPattern;
+    },
+    severity: import_core4.Severity.Info,
+    reason: "Singleton getter functions follow standard initialization pattern and are intentionally similar",
+    suggestion: "Singleton getters are boilerplate and acceptable duplication for lazy initialization"
   }
 ];
 
@@ -742,6 +844,22 @@ function getRefactoringSuggestion(patternType, similarity) {
   return baseMessages[patternType] + urgency;
 }
 function generateSummary(results) {
+  if (!Array.isArray(results)) {
+    return {
+      totalPatterns: 0,
+      totalTokenCost: 0,
+      patternsByType: {
+        "api-handler": 0,
+        validator: 0,
+        utility: 0,
+        "class-method": 0,
+        component: 0,
+        function: 0,
+        unknown: 0
+      },
+      topDuplicates: []
+    };
+  }
   const allIssues = results.flatMap((r) => r.issues || []);
   const totalTokenCost = results.reduce(
     (sum, r) => sum + (r.metrics?.tokenCost || 0),

package/dist/analyzer-entry/index.mjs

@@ -2,10 +2,10 @@ import {
   analyzePatterns,
   generateSummary,
   getSmartDefaults
-} from "../chunk-P3BOCGVV.mjs";
-import "../chunk-IPBGVPUX.mjs";
-import "../chunk-2P7BQHGR.mjs";
-import "../chunk-PHJE6A3J.mjs";
+} from "../chunk-WQX7IHAN.mjs";
+import "../chunk-JWP5TCDM.mjs";
+import "../chunk-KDXWIT6W.mjs";
+import "../chunk-G3GZFYRI.mjs";
 export {
   analyzePatterns,
   generateSummary,

package/dist/chunk-3CNHAYOD.mjs

@@ -0,0 +1,499 @@
+import {
+  detectDuplicatePatterns
+} from "./chunk-RH5JPWEC.mjs";
+import {
+  calculateSeverity
+} from "./chunk-UKQFCUQA.mjs";
+
+// src/grouping.ts
+import { Severity, getSeverityLevel } from "@aiready/core";
+import path from "path";
+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
+  );
+}
+function isPureInterfaceDefinition(code) {
+  const trimmed = code.trim();
+  if (!trimmed.startsWith("interface ") && !trimmed.startsWith("type ") && !trimmed.startsWith("export interface ") && !trimmed.startsWith("export type ") && !trimmed.startsWith("enum ") && !trimmed.startsWith("export enum ")) {
+    return false;
+  }
+  if (trimmed.includes("={") || trimmed.includes("=> {") || trimmed.includes("function ") || trimmed.includes("() {") || trimmed.includes(" implements ")) {
+    return false;
+  }
+  if (trimmed.length > 200) return false;
+  return true;
+}
+var BRAND_INDICATORS = [
+  "cyberpunk",
+  "cyber-blue",
+  "cyber-purple",
+  "slate-900",
+  "slate-400",
+  "zinc-",
+  "indigo-",
+  "neon-",
+  "glassmorphism",
+  "backdrop-blur"
+];
+function isBrandSpecificComponent(filePath) {
+  const lower = filePath.toLowerCase();
+  const brandingTerms = ["landing", "clawmore", "platform", "apps/"];
+  for (const term of brandingTerms) {
+    if (lower.includes(term)) return true;
+  }
+  return false;
+}
+function areBrandSpecificVariants(file1, file2, code1, code2) {
+  const f1IsBrand = isBrandSpecificComponent(file1);
+  const f2IsBrand = isBrandSpecificComponent(file2);
+  if (f1IsBrand && f2IsBrand && file1 !== file2) {
+    const hasBrandKeyword = (code) => {
+      const lowerCode = code.toLowerCase();
+      return BRAND_INDICATORS.some((ind) => lowerCode.includes(ind));
+    };
+    const code1Brand = hasBrandKeyword(code1);
+    const code2Brand = hasBrandKeyword(code2);
+    if (code1Brand && code2Brand) {
+      return true;
+    }
+  }
+  return false;
+}
+function filterBrandSpecificVariants(duplicates) {
+  return duplicates.filter((dup) => {
+    if (dup.file1 === dup.file2) return true;
+    const isBrandVariant = areBrandSpecificVariants(
+      dup.file1,
+      dup.file2,
+      dup.code1,
+      dup.code2
+    );
+    if (isBrandVariant) {
+      dup.severity = Severity.Info;
+      dup.suggestion = "Brand-specific themed component variant (intentional)";
+    }
+    const isInterfaceDef = isPureInterfaceDefinition(dup.code1) && isPureInterfaceDefinition(dup.code2);
+    if (isInterfaceDef) {
+      dup.severity = Severity.Info;
+      dup.suggestion = "Pure interface/type definition - intentional for module independence";
+    }
+    return true;
+  });
+}
+
+// src/config.ts
+import { scanFiles } from "@aiready/core";
+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 files = await scanFiles(scanOptions);
+  const fileCount = files.length;
+  const estimatedBlocks = fileCount * 5;
+  const minLines = Math.max(
+    6,
+    Math.min(20, 6 + Math.floor(estimatedBlocks / 1e3) * 2)
+  );
+  const minSimilarity = Math.min(0.75, 0.45 + estimatedBlocks / 1e4 * 0.3);
+  const batchSize = estimatedBlocks > 1e3 ? 200 : 100;
+  const severity = estimatedBlocks > 3e3 ? "high" : "all";
+  const maxCandidatesPerBlock = Math.max(
+    5,
+    Math.min(100, Math.floor(1e6 / estimatedBlocks))
+  );
+  const defaults = {
+    rootDir: directory,
+    minSimilarity,
+    minLines,
+    batchSize,
+    approx: true,
+    minSharedTokens: 10,
+    maxCandidatesPerBlock,
+    streamResults: false,
+    severity,
+    includeTests: false
+  };
+  const result = { ...defaults };
+  for (const key of Object.keys(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}`);
+  if (config.excludePatterns && config.excludePatterns.length > 0) {
+    console.log(`   Exclude patterns: ${config.excludePatterns.length} active`);
+  }
+  if (config.confidenceThreshold && config.confidenceThreshold > 0) {
+    console.log(`   Confidence threshold: ${config.confidenceThreshold}`);
+  }
+  if (config.ignoreWhitelist && config.ignoreWhitelist.length > 0) {
+    console.log(
+      `   Ignore whitelist: ${config.ignoreWhitelist.length} entries`
+    );
+  }
+  console.log("");
+}
+
+// src/summary.ts
+import { Severity as Severity2 } from "@aiready/core";
+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;
+}
+function generateSummary(results) {
+  if (!Array.isArray(results)) {
+    return {
+      totalPatterns: 0,
+      totalTokenCost: 0,
+      patternsByType: {
+        "api-handler": 0,
+        validator: 0,
+        utility: 0,
+        "class-method": 0,
+        component: 0,
+        function: 0,
+        unknown: 0
+      },
+      topDuplicates: []
+    };
+  }
+  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] || "unknown";
+      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
+        },
+        {
+          path: fileMatch?.[1] || "unknown",
+          startLine: 0,
+          endLine: 0
+        }
+      ],
+      similarity: similarityMatch ? parseInt(similarityMatch[1]) / 100 : 0,
+      patternType: typeMatch?.[1] || "unknown",
+      tokenCost: tokenMatch ? parseInt(tokenMatch[1]) : 0
+    };
+  });
+  return {
+    totalPatterns: allIssues.length,
+    totalTokenCost,
+    patternsByType,
+    topDuplicates
+  };
+}
+function filterBySeverity(issues, severity) {
+  if (severity === "all") return issues;
+  const severityMap = {
+    critical: [Severity2.Critical],
+    high: [Severity2.Critical, Severity2.Major],
+    medium: [Severity2.Critical, Severity2.Major, Severity2.Minor]
+  };
+  const allowed = severityMap[severity] || [
+    Severity2.Critical,
+    Severity2.Major,
+    Severity2.Minor
+  ];
+  return issues.filter((issue) => allowed.includes(issue.severity));
+}
+function calculateSeverity2(similarity) {
+  if (similarity > 0.95) return Severity2.Critical;
+  if (similarity > 0.9) return Severity2.Major;
+  return Severity2.Minor;
+}
+
+// src/analyzer.ts
+import { scanFiles as scanFiles2, readFileContent, Severity as Severity3, IssueType } from "@aiready/core";
+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",
+    groupByFilePair = true,
+    createClusters = true,
+    minClusterTokenCost = 1e3,
+    minClusterFiles = 3,
+    excludePatterns = [],
+    confidenceThreshold = 0,
+    ignoreWhitelist = [],
+    ...scanOptions
+  } = finalOptions;
+  const files = await scanFiles2(scanOptions);
+  const estimatedBlocks = files.length * 3;
+  logConfiguration(finalOptions, estimatedBlocks);
+  const results = [];
+  const READ_BATCH_SIZE = 50;
+  const fileContents = [];
+  for (let i = 0; i < files.length; i += READ_BATCH_SIZE) {
+    const batch = files.slice(i, i + READ_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,
+    excludePatterns,
+    confidenceThreshold,
+    ignoreWhitelist,
+    onProgress: options.onProgress
+  });
+  filterBrandSpecificVariants(duplicates);
+  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;
+      let severityLevel;
+      if (dup.severity === "info" || dup.severity === "Info") {
+        severityLevel = Severity3.Info;
+      } else {
+        severityLevel = calculateSeverity2(dup.similarity);
+      }
+      return {
+        type: IssueType.DuplicatePattern,
+        severity: severityLevel,
+        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 filteredIssues = filterBySeverity(issues, severity || "all");
+    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, config: finalOptions };
+}
+
+export {
+  groupDuplicatesByFilePair,
+  createRefactorClusters,
+  filterClustersByImpact,
+  areBrandSpecificVariants,
+  filterBrandSpecificVariants,
+  getSmartDefaults,
+  logConfiguration,
+  generateSummary,
+  filterBySeverity,
+  calculateSeverity2 as calculateSeverity,
+  Severity3 as Severity,
+  analyzePatterns
+};