@aiready/pattern-detect 0.16.19 → 0.16.21

package/dist/index-BwuoiCNm.d.ts

@@ -0,0 +1,119 @@
+import { Severity, ScanOptions, AnalysisResult } from '@aiready/core';
+import { P as PatternType, D as DuplicatePattern } from './types-DU2mmhwb.js';
+
+interface DuplicateGroup {
+    filePair: string;
+    severity: Severity;
+    occurrences: number;
+    totalTokenCost: number;
+    averageSimilarity: number;
+    patternTypes: Set<PatternType>;
+    lineRanges: Array<{
+        file1: {
+            start: number;
+            end: number;
+        };
+        file2: {
+            start: number;
+            end: number;
+        };
+    }>;
+}
+interface RefactorCluster {
+    id: string;
+    name: string;
+    files: string[];
+    severity: Severity;
+    duplicateCount: number;
+    totalTokenCost: number;
+    averageSimilarity: number;
+    reason?: string;
+    suggestion?: string;
+}
+/**
+ * Group raw duplicates by file pairs to reduce noise
+ */
+declare function groupDuplicatesByFilePair(duplicates: DuplicatePattern[]): DuplicateGroup[];
+/**
+ * Create clusters of highly related files (refactor targets)
+ * Uses a simple connected components algorithm
+ * @param duplicates - Array of duplicate patterns to cluster
+ * @returns Array of refactor clusters
+ */
+declare function createRefactorClusters(duplicates: DuplicatePattern[]): RefactorCluster[];
+/**
+ * Filter clusters by impact threshold
+ * @param clusters - Array of refactor clusters to filter
+ * @param minTokenCost - Minimum token cost threshold (default: 1000)
+ * @param minFiles - Minimum number of files in cluster (default: 3)
+ * @returns Filtered array of refactor clusters
+ */
+declare function filterClustersByImpact(clusters: RefactorCluster[], minTokenCost?: number, minFiles?: number): RefactorCluster[];
+
+interface PatternDetectOptions extends ScanOptions {
+    minSimilarity?: number;
+    minLines?: number;
+    batchSize?: number;
+    approx?: boolean;
+    minSharedTokens?: number;
+    maxCandidatesPerBlock?: number;
+    streamResults?: boolean;
+    severity?: string;
+    includeTests?: boolean;
+    useSmartDefaults?: boolean;
+    groupByFilePair?: boolean;
+    createClusters?: boolean;
+    minClusterTokenCost?: number;
+    minClusterFiles?: number;
+    excludePatterns?: string[];
+    confidenceThreshold?: number;
+    ignoreWhitelist?: string[];
+    onProgress?: (processed: number, total: number, message: string) => void;
+}
+interface PatternSummary {
+    totalPatterns: number;
+    totalTokenCost: number;
+    patternsByType: Record<PatternType, number>;
+    topDuplicates: Array<{
+        files: Array<{
+            path: string;
+            startLine: number;
+            endLine: number;
+        }>;
+        similarity: number;
+        patternType: PatternType;
+        tokenCost: number;
+    }>;
+}
+/**
+ * Determine smart defaults based on repository size estimation.
+ *
+ * @param directory - The directory to analyze for size.
+ * @param userOptions - User-provided option overrides.
+ * @returns Promise resolving to optimal detection options.
+ */
+declare function getSmartDefaults(directory: string, userOptions: Partial<PatternDetectOptions>): Promise<PatternDetectOptions>;
+/**
+ * Main entry point for pattern detection analysis.
+ *
+ * @param options - Configuration including rootDir and detection parameters.
+ * @returns Promise resolving to the comprehensive pattern detect report.
+ * @lastUpdated 2026-03-18
+ */
+declare function analyzePatterns(options: PatternDetectOptions): Promise<{
+    results: AnalysisResult[];
+    duplicates: DuplicatePattern[];
+    files: string[];
+    groups?: DuplicateGroup[];
+    clusters?: RefactorCluster[];
+    config: PatternDetectOptions;
+}>;
+/**
+ * Generate a summary of pattern detection results.
+ *
+ * @param results - Array of file-level analysis results.
+ * @returns Consolidated pattern summary object.
+ */
+declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+
+export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, createRefactorClusters as c, getSmartDefaults as d, groupDuplicatesByFilePair as e, filterClustersByImpact as f, generateSummary as g };

package/dist/index-y2uJSngh.d.mts

@@ -0,0 +1,60 @@
+import { Severity } from '@aiready/core';
+
+/**
+ * Context-aware severity detection for duplicate patterns
+ * Identifies intentional duplication patterns and adjusts severity accordingly
+ */
+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
+ *
+ * @param file1 - First file path in the duplicate pair.
+ * @param file2 - Second file path in the duplicate pair.
+ * @param code - Snippet of the duplicated code.
+ * @param similarity - The calculated similarity score (0-1).
+ * @param linesOfCode - Number of lines in the duplicated block.
+ * @returns An object containing the severity level and reasoning.
+ */
+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
+ *
+ * @param severity - The severity level to label.
+ * @returns Formatted label string for UI display.
+ */
+declare function getSeverityLabel(severity: Severity): string;
+/**
+ * Filter duplicates by minimum severity threshold
+ *
+ * @param duplicates - List of items with a severity property.
+ * @param minSeverity - Minimum threshold for inclusion.
+ * @returns Filtered list of items.
+ */
+declare function filterBySeverity<T extends {
+    severity: Severity;
+}>(duplicates: T[], minSeverity: Severity): T[];
+/**
+ * Get numerical similarity threshold associated with a severity level
+ *
+ * @param severity - The severity level to look up.
+ * @returns Minimum similarity value for this severity.
+ */
+declare function getSeverityThreshold(severity: Severity): number;
+
+export { CONTEXT_RULES as C, type ContextRule as a, getSeverityThreshold as b, calculateSeverity as c, filterBySeverity as f, getSeverityLabel as g };

package/dist/index-y2uJSngh.d.ts

@@ -0,0 +1,60 @@
+import { Severity } from '@aiready/core';
+
+/**
+ * Context-aware severity detection for duplicate patterns
+ * Identifies intentional duplication patterns and adjusts severity accordingly
+ */
+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
+ *
+ * @param file1 - First file path in the duplicate pair.
+ * @param file2 - Second file path in the duplicate pair.
+ * @param code - Snippet of the duplicated code.
+ * @param similarity - The calculated similarity score (0-1).
+ * @param linesOfCode - Number of lines in the duplicated block.
+ * @returns An object containing the severity level and reasoning.
+ */
+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
+ *
+ * @param severity - The severity level to label.
+ * @returns Formatted label string for UI display.
+ */
+declare function getSeverityLabel(severity: Severity): string;
+/**
+ * Filter duplicates by minimum severity threshold
+ *
+ * @param duplicates - List of items with a severity property.
+ * @param minSeverity - Minimum threshold for inclusion.
+ * @returns Filtered list of items.
+ */
+declare function filterBySeverity<T extends {
+    severity: Severity;
+}>(duplicates: T[], minSeverity: Severity): T[];
+/**
+ * Get numerical similarity threshold associated with a severity level
+ *
+ * @param severity - The severity level to look up.
+ * @returns Minimum similarity value for this severity.
+ */
+declare function getSeverityThreshold(severity: Severity): number;
+
+export { CONTEXT_RULES as C, type ContextRule as a, getSeverityThreshold as b, calculateSeverity as c, filterBySeverity as f, getSeverityLabel as g };

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 import { ToolProvider } from '@aiready/core';
 export { Severity } from '@aiready/core';
-export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as createRefactorClusters, f as filterClustersByImpact, g as generateSummary, d as getSmartDefaults, e as groupDuplicatesByFilePair } from './analyzer-entry-BVz-HnZd.mjs';
-export { detectDuplicatePatterns } from './detector-entry.mjs';
-export { calculatePatternScore } from './scoring-entry.mjs';
-export { C as CONTEXT_RULES, a as ContextRule, c as calculateSeverity, f as filterBySeverity, g as getSeverityLabel, b as getSeverityThreshold } from './context-rules-entry-y2uJSngh.mjs';
+export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as createRefactorClusters, f as filterClustersByImpact, g as generateSummary, d as getSmartDefaults, e as groupDuplicatesByFilePair } from './index-BVz-HnZd.mjs';
+export { detectDuplicatePatterns } from './detector-entry/index.mjs';
+export { calculatePatternScore } from './scoring-entry/index.mjs';
+export { C as CONTEXT_RULES, a as ContextRule, c as calculateSeverity, f as filterBySeverity, g as getSeverityLabel, b as getSeverityThreshold } from './index-y2uJSngh.mjs';
 export { D as DuplicatePattern, P as PatternType } from './types-DU2mmhwb.mjs';
 
 /**

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { ToolProvider } from '@aiready/core';
 export { Severity } from '@aiready/core';
-export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as createRefactorClusters, f as filterClustersByImpact, g as generateSummary, d as getSmartDefaults, e as groupDuplicatesByFilePair } from './analyzer-entry-BwuoiCNm.js';
-export { detectDuplicatePatterns } from './detector-entry.js';
-export { calculatePatternScore } from './scoring-entry.js';
-export { C as CONTEXT_RULES, a as ContextRule, c as calculateSeverity, f as filterBySeverity, g as getSeverityLabel, b as getSeverityThreshold } from './context-rules-entry-y2uJSngh.js';
+export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as createRefactorClusters, f as filterClustersByImpact, g as generateSummary, d as getSmartDefaults, e as groupDuplicatesByFilePair } from './index-BwuoiCNm.js';
+export { detectDuplicatePatterns } from './detector-entry/index.js';
+export { calculatePatternScore } from './scoring-entry/index.js';
+export { C as CONTEXT_RULES, a as ContextRule, c as calculateSeverity, f as filterBySeverity, g as getSeverityLabel, b as getSeverityThreshold } from './index-y2uJSngh.js';
 export { D as DuplicatePattern, P as PatternType } from './types-DU2mmhwb.js';
 
 /**

package/dist/index.js

@@ -230,144 +230,27 @@ function getSeverityThreshold(severity) {
   return thresholds[severity] || 0;
 }
 
-// src/detector.ts
+// src/core/normalizer.ts
 function normalizeCode(code, isPython = false) {
+  if (!code) return "";
   let normalized = code;
   if (isPython) {
     normalized = normalized.replace(/#.*/g, "");
   } else {
-    normalized = normalized.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    normalized = normalized.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   }
-  return normalized.replace(/['"`]/g, '"').replace(/\s+/g, " ").trim().toLowerCase();
+  return normalized.replace(/"[^"]*"/g, '"STR"').replace(/'[^']*'/g, "'STR'").replace(/`[^`]*`/g, "`STR`").replace(/\b\d+\b/g, "NUM").replace(/\s+/g, " ").trim().toLowerCase();
 }
+
+// src/detector.ts
 function extractBlocks(file, content) {
-  const isPython = file.toLowerCase().endsWith(".py");
-  if (isPython) {
-    return extractBlocksPython(file, content);
-  }
-  const blocks = [];
-  const lines = content.split("\n");
-  const blockRegex = /^\s*(?:export\s+)?(?:async\s+)?(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|readonly\s+|virtual\s+|abstract\s+|override\s+)*(function|class|interface|type|enum|record|struct|void|func|[a-zA-Z0-9_<>[]]+)\s+([a-zA-Z0-9_]+)(?:\s*\(|(?:\s+extends|\s+implements|\s+where)?\s*\{)|^\s*(?:export\s+)?const\s+([a-zA-Z0-9_]+)\s*=\s*[a-zA-Z0-9_.]+\.object\(|^\s*(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 if (match[3]) {
-      type = "const";
-      name = match[3];
-    } else {
-      type = "handler";
-      name = match[4];
-    }
-    let endLine = -1;
-    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 + 1).split("\n").length;
-        break;
-      }
-    }
-    if (endLine === -1) {
-      const remaining = content.slice(match.index);
-      const nextLineMatch = remaining.indexOf("\n");
-      if (nextLineMatch !== -1) {
-        endLine = startLine;
-      } else {
-        endLine = lines.length;
-      }
-    }
-    endLine = Math.max(startLine, endLine);
-    const blockCode = lines.slice(startLine - 1, endLine).join("\n");
-    const tokens = (0, import_core2.estimateTokens)(blockCode);
-    blocks.push({
-      file,
-      startLine,
-      endLine,
-      code: blockCode,
-      tokens,
-      patternType: inferPatternType(type, name)
-    });
-  }
-  return blocks;
-}
-function extractBlocksPython(file, content) {
-  const blocks = [];
-  const lines = content.split("\n");
-  const blockRegex = /^\s*(?:async\s+)?(def|class)\s+([a-zA-Z0-9_]+)/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const startLinePos = content.substring(0, match.index).split("\n").length;
-    const startLineIdx = startLinePos - 1;
-    const initialIndent = lines[startLineIdx].search(/\S/);
-    let endLineIdx = startLineIdx;
-    for (let i = startLineIdx + 1; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.trim().length === 0) {
-        endLineIdx = i;
-        continue;
-      }
-      const currentIndent = line.search(/\S/);
-      if (currentIndent <= initialIndent) {
-        break;
-      }
-      endLineIdx = i;
-    }
-    while (endLineIdx > startLineIdx && lines[endLineIdx].trim().length === 0) {
-      endLineIdx--;
-    }
-    const blockCode = lines.slice(startLineIdx, endLineIdx + 1).join("\n");
-    const tokens = (0, import_core2.estimateTokens)(blockCode);
-    blocks.push({
-      file,
-      startLine: startLinePos,
-      endLine: endLineIdx + 1,
-      code: blockCode,
-      tokens,
-      patternType: inferPatternType(match[1], match[2])
-    });
-  }
-  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";
+  return (0, import_core2.extractCodeBlocks)(file, content);
 }
 function calculateSimilarity(a, b) {
-  if (a === b) return 1;
-  const tokensA = a.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 0);
-  const tokensB = b.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 0);
-  if (tokensA.length === 0 || tokensB.length === 0) return 0;
-  const setA = new Set(tokensA);
-  const setB = new Set(tokensB);
-  const intersection = new Set([...setA].filter((x) => setB.has(x)));
-  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
-  return intersection.size / union.size;
+  return (0, import_core2.calculateStringSimilarity)(a, b);
 }
 function calculateConfidence(similarity, tokens, lines) {
-  let confidence = similarity;
-  if (lines > 20) confidence += 0.05;
-  if (tokens > 200) confidence += 0.05;
-  if (lines < 5) confidence -= 0.1;
-  return Math.max(0, Math.min(1, confidence));
+  return (0, import_core2.calculateHeuristicConfidence)(similarity, tokens, lines);
 }
 async function detectDuplicatePatterns(fileContents, options) {
   const {

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   PatternDetectProvider,
   Severity
-} from "./chunk-UB3CGOQ7.mjs";
+} from "./chunk-6JTVOBJX.mjs";
 import {
   analyzePatterns,
   createRefactorClusters,
@@ -9,10 +9,10 @@ import {
   generateSummary,
   getSmartDefaults,
   groupDuplicatesByFilePair
-} from "./chunk-WMOGJFME.mjs";
+} from "./chunk-DNZS4ESD.mjs";
 import {
   detectDuplicatePatterns
-} from "./chunk-THF4RW63.mjs";
+} from "./chunk-VGMM3L3O.mjs";
 import {
   CONTEXT_RULES,
   calculateSeverity,

package/dist/scoring-entry/index.d.mts

@@ -0,0 +1,23 @@
+import { CostConfig, ToolScoringOutput } from '@aiready/core';
+import { D as DuplicatePattern } from '../types-DU2mmhwb.mjs';
+
+/**
+ * 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
+ *
+ * @param duplicates - Array of detected duplicate patterns.
+ * @param totalFilesAnalyzed - Total count of files scanned.
+ * @param costConfig - Optional configuration for business value calculations.
+ * @returns Standardized scoring output for pattern detection.
+ */
+declare function calculatePatternScore(duplicates: DuplicatePattern[], totalFilesAnalyzed: number, costConfig?: Partial<CostConfig>): ToolScoringOutput;
+
+export { calculatePatternScore };

package/dist/scoring-entry/index.d.ts

@@ -0,0 +1,23 @@
+import { CostConfig, ToolScoringOutput } from '@aiready/core';
+import { D as DuplicatePattern } from '../types-DU2mmhwb.js';
+
+/**
+ * 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
+ *
+ * @param duplicates - Array of detected duplicate patterns.
+ * @param totalFilesAnalyzed - Total count of files scanned.
+ * @param costConfig - Optional configuration for business value calculations.
+ * @returns Standardized scoring output for pattern detection.
+ */
+declare function calculatePatternScore(duplicates: DuplicatePattern[], totalFilesAnalyzed: number, costConfig?: Partial<CostConfig>): ToolScoringOutput;
+
+export { calculatePatternScore };

package/dist/scoring-entry/index.js

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scoring-entry/index.ts
+var scoring_entry_exports = {};
+__export(scoring_entry_exports, {
+  calculatePatternScore: () => calculatePatternScore
+});
+module.exports = __toCommonJS(scoring_entry_exports);
+
+// src/scoring.ts
+var import_core = 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_core.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_core.DEFAULT_COST_CONFIG, ...costConfig };
+  const estimatedMonthlyCost = (0, import_core.calculateMonthlyCost)(totalTokenCost, cfg);
+  const issues = duplicates.map((d) => ({
+    severity: d.severity === "critical" ? "critical" : d.severity === "major" ? "major" : "minor"
+  }));
+  const productivityImpact = (0, import_core.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculatePatternScore
+});

package/dist/scoring-entry/index.mjs

@@ -0,0 +1,6 @@
+import {
+  calculatePatternScore
+} from "../chunk-WBBO35SC.mjs";
+export {
+  calculatePatternScore
+};

package/dist/scoring-entry.d.mts

@@ -1,5 +1,5 @@
 import { CostConfig, ToolScoringOutput } from '@aiready/core';
-import { D as DuplicatePattern } from './types-DU2mmhwb.mjs';
+import { a as DuplicatePattern } from './types-C4lmb2Yh.mjs';
 
 /**
  * Calculate AI Readiness Score for pattern duplication (0-100)

package/dist/scoring-entry.d.ts

@@ -1,5 +1,5 @@
 import { CostConfig, ToolScoringOutput } from '@aiready/core';
-import { D as DuplicatePattern } from './types-DU2mmhwb.js';
+import { a as DuplicatePattern } from './types-C4lmb2Yh.js';
 
 /**
  * Calculate AI Readiness Score for pattern duplication (0-100)