@aiready/pattern-detect 0.14.17 → 0.14.21

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -30,20 +30,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CONTEXT_RULES: () => CONTEXT_RULES,
   PatternDetectProvider: () => PatternDetectProvider,
-  Severity: () => import_core6.Severity,
+  Severity: () => import_core7.Severity,
   analyzePatterns: () => analyzePatterns,
   calculatePatternScore: () => calculatePatternScore,
   calculateSeverity: () => calculateSeverity,
+  createRefactorClusters: () => createRefactorClusters,
   detectDuplicatePatterns: () => detectDuplicatePatterns,
   filterBySeverity: () => filterBySeverity,
+  filterClustersByImpact: () => filterClustersByImpact,
   generateSummary: () => generateSummary,
   getSeverityLabel: () => getSeverityLabel,
-  getSmartDefaults: () => getSmartDefaults
+  getSeverityThreshold: () => getSeverityThreshold,
+  getSmartDefaults: () => getSmartDefaults,
+  groupDuplicatesByFilePair: () => groupDuplicatesByFilePair
 });
 module.exports = __toCommonJS(index_exports);
+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");
 
@@ -197,6 +208,15 @@ function filterBySeverity(duplicates, minSeverity) {
     return dupIndex >= minIndex;
   });
 }
+function getSeverityThreshold(severity) {
+  const thresholds = {
+    [import_core.Severity.Critical]: 0.95,
+    [import_core.Severity.Major]: 0.85,
+    [import_core.Severity.Minor]: 0.5,
+    [import_core.Severity.Info]: 0
+  };
+  return thresholds[severity] || 0;
+}
 
 // src/detector.ts
 function normalizeCode(code, isPython = false) {
@@ -541,153 +561,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",
@@ -721,8 +595,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(
@@ -788,19 +661,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);
@@ -821,9 +693,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: {
@@ -836,11 +708,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)
       );
@@ -906,14 +778,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,
@@ -928,16 +797,168 @@ function generateSummary(results) {
     topDuplicates
   };
 }
+
+// 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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CONTEXT_RULES,
   PatternDetectProvider,
   Severity,
   analyzePatterns,
   calculatePatternScore,
   calculateSeverity,
+  createRefactorClusters,
   detectDuplicatePatterns,
   filterBySeverity,
+  filterClustersByImpact,
   generateSummary,
   getSeverityLabel,
-  getSmartDefaults
+  getSeverityThreshold,
+  getSmartDefaults,
+  groupDuplicatesByFilePair
 });

package/dist/index.mjs

@@ -1,24 +1,34 @@
 import {
+  CONTEXT_RULES,
   PatternDetectProvider,
   Severity,
   analyzePatterns,
   calculatePatternScore,
   calculateSeverity,
+  createRefactorClusters,
   detectDuplicatePatterns,
   filterBySeverity,
+  filterClustersByImpact,
   generateSummary,
   getSeverityLabel,
-  getSmartDefaults
-} from "./chunk-6YUGU4P4.mjs";
+  getSeverityThreshold,
+  getSmartDefaults,
+  groupDuplicatesByFilePair
+} from "./chunk-H4ADJYOG.mjs";
 export {
+  CONTEXT_RULES,
   PatternDetectProvider,
   Severity,
   analyzePatterns,
   calculatePatternScore,
   calculateSeverity,
+  createRefactorClusters,
   detectDuplicatePatterns,
   filterBySeverity,
+  filterClustersByImpact,
   generateSummary,
   getSeverityLabel,
-  getSmartDefaults
+  getSeverityThreshold,
+  getSmartDefaults,
+  groupDuplicatesByFilePair
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/pattern-detect",
-  "version": "0.14.17",
+  "version": "0.14.21",
   "description": "Semantic duplicate pattern detection for AI-generated code - finds similar implementations that waste AI context tokens",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -45,7 +45,7 @@
   "dependencies": {
     "commander": "^14.0.0",
     "chalk": "^5.3.0",
-    "@aiready/core": "0.21.17"
+    "@aiready/core": "0.21.21"
   },
   "devDependencies": {
     "tsup": "^8.3.5",