@aiready/pattern-detect 0.14.17 → 0.14.21

package/dist/cli.js

@@ -27,8 +27,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // src/index.ts
+var import_core7 = require("@aiready/core");
+
+// src/provider.ts
 var import_core6 = require("@aiready/core");
 
+// src/analyzer.ts
+var import_core4 = require("@aiready/core");
+
 // src/detector.ts
 var import_core2 = require("@aiready/core");
 
@@ -517,153 +523,7 @@ function filterClustersByImpact(clusters, minTokenCost = 1e3, minFiles = 3) {
   );
 }
 
-// src/scoring.ts
-var import_core4 = require("@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: import_core4.ToolName.PatternDetect,
-      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 = { ...import_core4.DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = (0, import_core4.calculateMonthlyCost)(totalTokenCost, cfg);
-  const issues = duplicates.map((d) => ({
-    severity: d.severity === "critical" ? "critical" : d.severity === "major" ? "major" : "minor"
-  }));
-  const productivityImpact = (0, import_core4.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/provider.ts
-var import_core5 = require("@aiready/core");
-var PatternDetectProvider = {
-  id: import_core5.ToolName.PatternDetect,
-  alias: ["patterns", "duplicates", "duplication"],
-  async analyze(options) {
-    const results = await analyzePatterns(options);
-    return import_core5.SpokeOutputSchema.parse({
-      results: results.results,
-      summary: {
-        totalFiles: results.files.length,
-        totalIssues: results.results.reduce(
-          (sum, r) => sum + r.issues.length,
-          0
-        ),
-        clusters: results.clusters,
-        config: Object.fromEntries(
-          Object.entries(results.config).filter(
-            ([key]) => !import_core5.GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
-          )
-        )
-      },
-      metadata: {
-        toolName: import_core5.ToolName.PatternDetect,
-        version: "0.12.5",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    });
-  },
-  score(output, options) {
-    const duplicates = output.summary.duplicates || [];
-    const totalFiles = output.summary.totalFiles || output.results.length;
-    return calculatePatternScore(
-      duplicates,
-      totalFiles,
-      options.costConfig
-    );
-  },
-  defaultWeight: 22
-};
-
-// src/index.ts
-import_core6.ToolRegistry.register(PatternDetectProvider);
+// src/analyzer.ts
 function getRefactoringSuggestion(patternType, similarity) {
   const baseMessages = {
     "api-handler": "Extract common middleware or create a base handler class",
@@ -697,8 +557,7 @@ async function getSmartDefaults(directory, userOptions) {
     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 files = await (0, import_core4.scanFiles)(scanOptions);
   const fileCount = files.length;
   const estimatedBlocks = fileCount * 5;
   const minLines = Math.max(
@@ -764,19 +623,18 @@ async function analyzePatterns(options) {
     minClusterFiles = 3,
     ...scanOptions
   } = finalOptions;
-  const { scanFiles: scanFiles2 } = await import("@aiready/core");
-  const files = await scanFiles2(scanOptions);
+  const files = await (0, import_core4.scanFiles)(scanOptions);
   const estimatedBlocks = files.length * 3;
   logConfiguration(finalOptions, estimatedBlocks);
   const results = [];
-  const BATCH_SIZE = 50;
+  const READ_BATCH_SIZE = 50;
   const fileContents = [];
-  for (let i = 0; i < files.length; i += BATCH_SIZE) {
-    const batch = files.slice(i, i + BATCH_SIZE);
+  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 (0, import_core6.readFileContent)(file)
+        content: await (0, import_core4.readFileContent)(file)
       }))
     );
     fileContents.push(...batchContents);
@@ -797,9 +655,9 @@ async function analyzePatterns(options) {
     );
     const issues = fileDuplicates.map((dup) => {
       const otherFile = dup.file1 === file ? dup.file2 : dup.file1;
-      const severity2 = dup.similarity > 0.95 ? import_core6.Severity.Critical : dup.similarity > 0.9 ? import_core6.Severity.Major : import_core6.Severity.Minor;
+      const severity2 = dup.similarity > 0.95 ? import_core4.Severity.Critical : dup.similarity > 0.9 ? import_core4.Severity.Major : import_core4.Severity.Minor;
       return {
-        type: import_core6.IssueType.DuplicatePattern,
+        type: import_core4.IssueType.DuplicatePattern,
         severity: severity2,
         message: `${dup.patternType} pattern ${Math.round(dup.similarity * 100)}% similar to ${otherFile} (${dup.tokenCost} tokens wasted)`,
         location: {
@@ -812,11 +670,11 @@ async function analyzePatterns(options) {
     let filteredIssues = issues;
     if (severity !== "all") {
       const severityMap = {
-        critical: [import_core6.Severity.Critical],
-        high: [import_core6.Severity.Critical, import_core6.Severity.Major],
-        medium: [import_core6.Severity.Critical, import_core6.Severity.Major, import_core6.Severity.Minor]
+        critical: [import_core4.Severity.Critical],
+        high: [import_core4.Severity.Critical, import_core4.Severity.Major],
+        medium: [import_core4.Severity.Critical, import_core4.Severity.Major, import_core4.Severity.Minor]
       };
-      const allowedSeverities = severityMap[severity] || [import_core6.Severity.Critical, import_core6.Severity.Major, import_core6.Severity.Minor];
+      const allowedSeverities = severityMap[severity] || [import_core4.Severity.Critical, import_core4.Severity.Major, import_core4.Severity.Minor];
       filteredIssues = issues.filter(
         (issue) => allowedSeverities.includes(issue.severity)
       );
@@ -882,14 +740,11 @@ function generateSummary(results) {
           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,
@@ -905,11 +760,158 @@ function generateSummary(results) {
   };
 }
 
+// src/scoring.ts
+var import_core5 = require("@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: import_core5.ToolName.PatternDetect,
+      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 = { ...import_core5.DEFAULT_COST_CONFIG, ...costConfig };
+  const estimatedMonthlyCost = (0, import_core5.calculateMonthlyCost)(totalTokenCost, cfg);
+  const issues = duplicates.map((d) => ({
+    severity: d.severity === "critical" ? "critical" : d.severity === "major" ? "major" : "minor"
+  }));
+  const productivityImpact = (0, import_core5.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/provider.ts
+var PatternDetectProvider = {
+  id: import_core6.ToolName.PatternDetect,
+  alias: ["patterns", "duplicates", "duplication"],
+  async analyze(options) {
+    const results = await analyzePatterns(options);
+    return import_core6.SpokeOutputSchema.parse({
+      results: results.results,
+      summary: {
+        totalFiles: results.files.length,
+        totalIssues: results.results.reduce(
+          (sum, r) => sum + r.issues.length,
+          0
+        ),
+        clusters: results.clusters,
+        config: Object.fromEntries(
+          Object.entries(results.config).filter(
+            ([key]) => !import_core6.GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
+          )
+        )
+      },
+      metadata: {
+        toolName: import_core6.ToolName.PatternDetect,
+        version: "0.12.5",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  },
+  score(output, options) {
+    const duplicates = output.summary.duplicates || [];
+    const totalFiles = output.summary.totalFiles || output.results.length;
+    return calculatePatternScore(
+      duplicates,
+      totalFiles,
+      options.costConfig
+    );
+  },
+  defaultWeight: 22
+};
+
+// src/index.ts
+import_core7.ToolRegistry.register(PatternDetectProvider);
+
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
 var import_fs = require("fs");
 var import_path2 = require("path");
-var import_core7 = require("@aiready/core");
+var import_core8 = require("@aiready/core");
 var program = new import_commander.Command();
 program.name("aiready-patterns").description("Detect duplicate patterns in your codebase").version("0.1.0").addHelpText(
   "after",
@@ -963,7 +965,7 @@ program.name("aiready-patterns").description("Detect duplicate patterns in your
 ).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 startTime = Date.now();
-  const config = await (0, import_core7.loadConfig)(directory);
+  const config = await (0, import_core8.loadConfig)(directory);
   const defaults = {
     minSimilarity: 0.4,
     minLines: 5,
@@ -974,7 +976,7 @@ program.name("aiready-patterns").description("Detect duplicate patterns in your
     streamResults: true,
     include: void 0,
     exclude: void 0,
-    minSeverity: import_core7.Severity.Minor,
+    minSeverity: import_core8.Severity.Minor,
     excludeTestFixtures: false,
     excludeTemplates: false,
     includeTests: false,
@@ -985,7 +987,7 @@ program.name("aiready-patterns").description("Detect duplicate patterns in your
     minClusterFiles: 3,
     showRawDuplicates: false
   };
-  const mergedConfig = (0, import_core7.mergeConfigWithDefaults)(config, defaults);
+  const mergedConfig = (0, import_core8.mergeConfigWithDefaults)(config, defaults);
   const finalOptions = {
     rootDir: directory,
     minSimilarity: options.similarity ? parseFloat(options.similarity) : mergedConfig.minSimilarity,
@@ -1057,7 +1059,7 @@ program.name("aiready-patterns").description("Detect duplicate patterns in your
       clusters: clusters || [],
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const outputPath = (0, import_core7.resolveOutputPath)(
+    const outputPath = (0, import_core8.resolveOutputPath)(
       options.outputFile,
       `pattern-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
       directory
@@ -1073,7 +1075,7 @@ program.name("aiready-patterns").description("Detect duplicate patterns in your
   }
   if (options.output === "html") {
     const html = generateHTMLReport(summary, results);
-    const outputPath = (0, import_core7.resolveOutputPath)(
+    const outputPath = (0, import_core8.resolveOutputPath)(
       options.outputFile,
       `pattern-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.html`,
       directory
@@ -1403,10 +1405,10 @@ function generateHTMLReport(summary, results) {
 }
 program.parse();
 function getSeverityValue(s) {
-  if (s === import_core7.Severity.Critical || s === "critical") return 4;
-  if (s === import_core7.Severity.Major || s === "major") return 3;
-  if (s === import_core7.Severity.Minor || s === "minor") return 2;
-  if (s === import_core7.Severity.Info || s === "info") return 1;
+  if (s === import_core8.Severity.Critical || s === "critical") return 4;
+  if (s === import_core8.Severity.Major || s === "major") return 3;
+  if (s === import_core8.Severity.Minor || s === "minor") return 2;
+  if (s === import_core8.Severity.Info || s === "info") return 1;
   return 0;
 }
 function getSeverityBadge(severity) {

package/dist/cli.mjs

@@ -3,7 +3,7 @@ import {
   analyzePatterns,
   filterBySeverity,
   generateSummary
-} from "./chunk-6YUGU4P4.mjs";
+} from "./chunk-H4ADJYOG.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.d.mts

@@ -1,6 +1,11 @@
-import { Severity, CostConfig, ToolScoringOutput, ToolProvider, ScanOptions, AnalysisResult } from '@aiready/core';
+import { ToolProvider, Severity, ScanOptions, AnalysisResult, CostConfig, ToolScoringOutput } from '@aiready/core';
 export { Severity } from '@aiready/core';
 
+/**
+ * Pattern Detection Tool Provider
+ */
+declare const PatternDetectProvider: ToolProvider;
+
 type PatternType = 'api-handler' | 'validator' | 'utility' | 'class-method' | 'component' | 'function' | 'unknown';
 interface DuplicatePattern {
     file1: string;
@@ -68,45 +73,19 @@ interface RefactorCluster {
     reason?: string;
     suggestion?: string;
 }
-
 /**
- * Calculate AI Readiness Score for pattern duplication (0-100)
- *
- * Based on:
- * - Number of duplicates per file
- * - Token waste per file
- * - High-impact duplicates (>1000 tokens or >70% similarity)
- *
- * Includes business value metrics:
- * - Estimated monthly cost of token waste
- * - Estimated developer hours to fix
+ * Group raw duplicates by file pairs to reduce noise
  */
-declare function calculatePatternScore(duplicates: DuplicatePattern[], totalFilesAnalyzed: number, costConfig?: Partial<CostConfig>): ToolScoringOutput;
-
+declare function groupDuplicatesByFilePair(duplicates: DuplicatePattern[]): DuplicateGroup[];
 /**
- * Pattern Detection Tool Provider
+ * Create clusters of highly related files (refactor targets)
+ * Uses a simple connected components algorithm
  */
-declare const PatternDetectProvider: ToolProvider;
-
+declare function createRefactorClusters(duplicates: DuplicatePattern[]): RefactorCluster[];
 /**
- * Calculate severity based on context rules and code characteristics
- */
-declare function calculateSeverity(file1: string, file2: string, code: string, similarity: number, linesOfCode: number): {
-    severity: Severity;
-    reason?: string;
-    suggestion?: string;
-    matchedRule?: string;
-};
-/**
- * Get a human-readable severity label with emoji
+ * Filter clusters by impact threshold
  */
-declare function getSeverityLabel(severity: Severity): string;
-/**
- * Filter duplicates by minimum severity threshold
- */
-declare function filterBySeverity<T extends {
-    severity: Severity;
-}>(duplicates: T[], minSeverity: Severity): T[];
+declare function filterClustersByImpact(clusters: RefactorCluster[], minTokenCost?: number, minFiles?: number): RefactorCluster[];
 
 interface PatternDetectOptions extends ScanOptions {
     minSimilarity?: number;
@@ -152,9 +131,60 @@ declare function analyzePatterns(options: PatternDetectOptions): Promise<{
     clusters?: RefactorCluster[];
     config: PatternDetectOptions;
 }>;
+declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+
+/**
+ * Calculate AI Readiness Score for pattern duplication (0-100)
+ *
+ * Based on:
+ * - Number of duplicates per file
+ * - Token waste per file
+ * - High-impact duplicates (>1000 tokens or >70% similarity)
+ *
+ * Includes business value metrics:
+ * - Estimated monthly cost of token waste
+ * - Estimated developer hours to fix
+ */
+declare function calculatePatternScore(duplicates: DuplicatePattern[], totalFilesAnalyzed: number, costConfig?: Partial<CostConfig>): ToolScoringOutput;
+
 /**
- * Generate a summary of pattern analysis
+ * Context-aware severity detection for duplicate patterns
+ * Identifies intentional duplication patterns and adjusts severity accordingly
  */
-declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+interface ContextRule {
+    name: string;
+    detect: (file: string, code: string) => boolean;
+    severity: Severity;
+    reason: string;
+    suggestion?: string;
+}
+/**
+ * Context rules for detecting intentional or acceptable duplication patterns
+ * Rules are checked in order - first match wins
+ */
+declare const CONTEXT_RULES: ContextRule[];
+/**
+ * Calculate severity based on context rules and code characteristics
+ */
+declare function calculateSeverity(file1: string, file2: string, code: string, similarity: number, linesOfCode: number): {
+    severity: Severity;
+    reason?: string;
+    suggestion?: string;
+    matchedRule?: string;
+};
+/**
+ * Get a human-readable severity label with emoji
+ */
+declare function getSeverityLabel(severity: Severity): string;
+/**
+ * Filter duplicates by minimum severity threshold
+ */
+declare function filterBySeverity<T extends {
+    severity: Severity;
+}>(duplicates: T[], minSeverity: Severity): T[];
+/**
+ * Get severity threshold for filtering
+ */
+declare function getSeverityThreshold(severity: Severity): number;
 
-export { type DuplicateGroup, type DuplicatePattern, type PatternDetectOptions, PatternDetectProvider, type PatternSummary, type PatternType, type RefactorCluster, analyzePatterns, calculatePatternScore, calculateSeverity, detectDuplicatePatterns, filterBySeverity, generateSummary, getSeverityLabel, getSmartDefaults };
+export { CONTEXT_RULES, type ContextRule, type DuplicateGroup, type DuplicatePattern, type PatternDetectOptions, PatternDetectProvider, type PatternSummary, type PatternType, type RefactorCluster, analyzePatterns, calculatePatternScore, calculateSeverity, createRefactorClusters, detectDuplicatePatterns, filterBySeverity, filterClustersByImpact, generateSummary, getSeverityLabel, getSeverityThreshold, getSmartDefaults, groupDuplicatesByFilePair };