@aiready/pattern-detect 0.17.1 → 0.17.3

package/dist/analyzer-entry/index.js

@@ -472,7 +472,7 @@ async function getSmartDefaults(directory, userOptions) {
     6,
     Math.min(20, 6 + Math.floor(estimatedBlocks / 1e3) * 2)
   );
-  const minSimilarity = Math.min(0.85, 0.5 + estimatedBlocks / 5e3 * 0.3);
+  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(
@@ -632,9 +632,9 @@ async function analyzePatterns(options) {
   return { results, duplicates, files, groups, clusters, config: finalOptions };
 }
 function generateSummary(results) {
-  const allIssues = results.flatMap((r) => r.issues);
+  const allIssues = results.flatMap((r) => r.issues || []);
   const totalTokenCost = results.reduce(
-    (sum, r) => sum + (r.metrics.tokenCost || 0),
+    (sum, r) => sum + (r.metrics?.tokenCost || 0),
     0
   );
   const patternsByType = {

package/dist/analyzer-entry/index.mjs

@@ -2,7 +2,7 @@ import {
   analyzePatterns,
   generateSummary,
   getSmartDefaults
-} from "../chunk-SUUZMLPS.mjs";
+} from "../chunk-K7BO57OO.mjs";
 import "../chunk-NQBYYWHJ.mjs";
 import "../chunk-J2G742QF.mjs";
 export {

package/dist/chunk-K7BO57OO.mjs

@@ -0,0 +1,391 @@
+import {
+  detectDuplicatePatterns
+} from "./chunk-NQBYYWHJ.mjs";
+import {
+  calculateSeverity
+} from "./chunk-J2G742QF.mjs";
+
+// src/grouping.ts
+import { 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
+  );
+}
+
+// src/analyzer.ts
+import { scanFiles, readFileContent, Severity as Severity2, IssueType } 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;
+}
+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("");
+}
+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 scanFiles(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
+  });
+  for (const file of files) {
+    const fileDuplicates = duplicates.filter(
+      (dup) => dup.file1 === file || dup.file2 === file
+    );
+    const issues = fileDuplicates.map((dup) => {
+      const otherFile = dup.file1 === file ? dup.file2 : dup.file1;
+      const severity2 = dup.similarity > 0.95 ? Severity2.Critical : dup.similarity > 0.9 ? Severity2.Major : Severity2.Minor;
+      return {
+        type: IssueType.DuplicatePattern,
+        severity: severity2,
+        message: `${dup.patternType} pattern ${Math.round(dup.similarity * 100)}% similar to ${otherFile} (${dup.tokenCost} tokens wasted)`,
+        location: {
+          file,
+          line: dup.file1 === file ? dup.line1 : dup.line2
+        },
+        suggestion: getRefactoringSuggestion(dup.patternType, dup.similarity)
+      };
+    });
+    let filteredIssues = issues;
+    if (severity !== "all") {
+      const severityMap = {
+        critical: [Severity2.Critical],
+        high: [Severity2.Critical, Severity2.Major],
+        medium: [Severity2.Critical, Severity2.Major, Severity2.Minor]
+      };
+      const allowedSeverities = severityMap[severity] || [Severity2.Critical, Severity2.Major, Severity2.Minor];
+      filteredIssues = issues.filter(
+        (issue) => allowedSeverities.includes(issue.severity)
+      );
+    }
+    const totalTokenCost = fileDuplicates.reduce(
+      (sum, dup) => sum + dup.tokenCost,
+      0
+    );
+    results.push({
+      fileName: file,
+      issues: filteredIssues,
+      metrics: {
+        tokenCost: totalTokenCost,
+        consistencyScore: Math.max(0, 1 - fileDuplicates.length * 0.1)
+      }
+    });
+  }
+  let groups;
+  let clusters;
+  if (groupByFilePair) {
+    groups = groupDuplicatesByFilePair(duplicates);
+  }
+  if (createClusters) {
+    const allClusters = createRefactorClusters(duplicates);
+    clusters = filterClustersByImpact(
+      allClusters,
+      minClusterTokenCost,
+      minClusterFiles
+    );
+  }
+  return { results, duplicates, files, groups, clusters, config: finalOptions };
+}
+function generateSummary(results) {
+  const allIssues = results.flatMap((r) => r.issues || []);
+  const totalTokenCost = results.reduce(
+    (sum, r) => sum + (r.metrics?.tokenCost || 0),
+    0
+  );
+  const patternsByType = {
+    "api-handler": 0,
+    validator: 0,
+    utility: 0,
+    "class-method": 0,
+    component: 0,
+    function: 0,
+    unknown: 0
+  };
+  allIssues.forEach((issue) => {
+    const match = issue.message.match(/^(\S+(?:-\S+)*) pattern/);
+    if (match) {
+      const type = match[1];
+      patternsByType[type] = (patternsByType[type] || 0) + 1;
+    }
+  });
+  const topDuplicates = allIssues.slice(0, 10).map((issue) => {
+    const similarityMatch = issue.message.match(/(\d+)% similar/);
+    const tokenMatch = issue.message.match(/\((\d+) tokens/);
+    const typeMatch = issue.message.match(/^(\S+(?:-\S+)*) pattern/);
+    const fileMatch = issue.message.match(/similar to (.+?) \(/);
+    return {
+      files: [
+        {
+          path: issue.location.file,
+          startLine: issue.location.line,
+          endLine: 0
+        },
+        {
+          path: fileMatch?.[1] || "unknown",
+          startLine: 0,
+          endLine: 0
+        }
+      ],
+      similarity: similarityMatch ? parseInt(similarityMatch[1]) / 100 : 0,
+      confidence: similarityMatch ? parseInt(similarityMatch[1]) / 100 : 0,
+      // Fallback for summary
+      patternType: typeMatch?.[1] || "unknown",
+      tokenCost: tokenMatch ? parseInt(tokenMatch[1]) : 0
+    };
+  });
+  return {
+    totalPatterns: allIssues.length,
+    totalTokenCost,
+    patternsByType,
+    topDuplicates
+  };
+}
+
+export {
+  groupDuplicatesByFilePair,
+  createRefactorClusters,
+  filterClustersByImpact,
+  getSmartDefaults,
+  analyzePatterns,
+  generateSummary
+};

package/dist/cli.js

@@ -26,12 +26,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 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");
 
@@ -468,7 +462,7 @@ async function getSmartDefaults(directory, userOptions) {
     6,
     Math.min(20, 6 + Math.floor(estimatedBlocks / 1e3) * 2)
   );
-  const minSimilarity = Math.min(0.85, 0.5 + estimatedBlocks / 5e3 * 0.3);
+  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(
@@ -628,9 +622,9 @@ async function analyzePatterns(options) {
   return { results, duplicates, files, groups, clusters, config: finalOptions };
 }
 function generateSummary(results) {
-  const allIssues = results.flatMap((r) => r.issues);
+  const allIssues = results.flatMap((r) => r.issues || []);
   const totalTokenCost = results.reduce(
-    (sum, r) => sum + (r.metrics.tokenCost || 0),
+    (sum, r) => sum + (r.metrics?.tokenCost || 0),
     0
   );
   const patternsByType = {
@@ -682,163 +676,14 @@ 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
-        ),
-        duplicates: results.duplicates,
-        // Keep the raw duplicates for score calculation
-        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-action.ts
 var import_chalk2 = __toESM(require("chalk"));
 var import_fs = require("fs");
 var import_path2 = require("path");
-var import_core11 = require("@aiready/core");
+var import_core8 = require("@aiready/core");
 
 // src/config-resolver.ts
-var import_core8 = require("@aiready/core");
+var import_core5 = require("@aiready/core");
 
 // src/constants.ts
 var DEFAULT_MIN_SIMILARITY = 0.4;
@@ -870,7 +715,7 @@ EXAMPLES:
 
 // src/config-resolver.ts
 async function resolvePatternConfig(directory, options) {
-  const fileConfig = await (0, import_core8.loadConfig)(directory);
+  const fileConfig = await (0, import_core5.loadConfig)(directory);
   const defaults = {
     minSimilarity: DEFAULT_MIN_SIMILARITY,
     minLines: DEFAULT_MIN_LINES,
@@ -884,7 +729,7 @@ async function resolvePatternConfig(directory, options) {
     excludePatterns: void 0,
     confidenceThreshold: 0,
     ignoreWhitelist: void 0,
-    minSeverity: import_core8.Severity.Minor,
+    minSeverity: import_core5.Severity.Minor,
     excludeTestFixtures: false,
     excludeTemplates: false,
     includeTests: false,
@@ -895,7 +740,7 @@ async function resolvePatternConfig(directory, options) {
     minClusterFiles: DEFAULT_MIN_CLUSTER_FILES,
     showRawDuplicates: false
   };
-  const mergedConfig = (0, import_core8.mergeConfigWithDefaults)(fileConfig, defaults);
+  const mergedConfig = (0, import_core5.mergeConfigWithDefaults)(fileConfig, defaults);
   const finalOptions = {
     rootDir: directory,
     minSimilarity: options.similarity ? parseFloat(options.similarity) : mergedConfig.minSimilarity,
@@ -937,7 +782,7 @@ async function resolvePatternConfig(directory, options) {
 }
 
 // src/cli-output.ts
-var import_core9 = require("@aiready/core");
+var import_core6 = require("@aiready/core");
 function getPatternIcon(type) {
   const icons = {
     "api-handler": "\u{1F50C}",
@@ -963,7 +808,7 @@ function generateHTMLReport(results, summary) {
     dup.files.map((f) => `<code>${f.path}:${f.startLine}-${f.endLine}</code>`).join("<br>\u2194<br>"),
     dup.tokenCost.toLocaleString()
   ]);
-  return (0, import_core9.generateStandardHtmlReport)(
+  return (0, import_core6.generateStandardHtmlReport)(
     {
       title: "Pattern Detection Report",
       packageName: "pattern-detect",
@@ -980,7 +825,7 @@ function generateHTMLReport(results, summary) {
     [
       {
         title: "Duplicate Patterns",
-        content: (0, import_core9.generateTable)({
+        content: (0, import_core6.generateTable)({
           headers: ["Similarity", "Type", "Locations", "Tokens Wasted"],
           rows: tableRows
         })
@@ -992,9 +837,9 @@ function generateHTMLReport(results, summary) {
 
 // src/terminal-output.ts
 var import_chalk = __toESM(require("chalk"));
-var import_core10 = require("@aiready/core");
+var import_core7 = require("@aiready/core");
 function printAnalysisSummary(resultsLength, totalIssues, totalTokenCost, elapsedTime) {
-  (0, import_core10.printTerminalHeader)("PATTERN ANALYSIS SUMMARY");
+  (0, import_core7.printTerminalHeader)("PATTERN ANALYSIS SUMMARY");
   console.log(import_chalk.default.white(`\u{1F4C1} Files analyzed: ${import_chalk.default.bold(resultsLength)}`));
   console.log(
     import_chalk.default.yellow(
@@ -1011,9 +856,9 @@ function printAnalysisSummary(resultsLength, totalIssues, totalTokenCost, elapse
 function printPatternBreakdown(patternsByType) {
   const sortedTypes = Object.entries(patternsByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
   if (sortedTypes.length > 0) {
-    console.log("\n" + (0, import_core10.getTerminalDivider)());
+    console.log("\n" + (0, import_core7.getTerminalDivider)());
     console.log(import_chalk.default.bold.white("  PATTERNS BY TYPE"));
-    console.log((0, import_core10.getTerminalDivider)() + "\n");
+    console.log((0, import_core7.getTerminalDivider)() + "\n");
     sortedTypes.forEach(([type, count]) => {
       const icon = getPatternIcon(type);
       console.log(
@@ -1024,20 +869,20 @@ function printPatternBreakdown(patternsByType) {
 }
 function printDuplicateGroups(groups, maxResults) {
   if (groups.length === 0) return;
-  console.log("\n" + (0, import_core10.getTerminalDivider)());
+  console.log("\n" + (0, import_core7.getTerminalDivider)());
   console.log(
     import_chalk.default.bold.white(`  \u{1F4E6} DUPLICATE GROUPS (${groups.length} file pairs)`)
   );
-  console.log((0, import_core10.getTerminalDivider)() + "\n");
+  console.log((0, import_core7.getTerminalDivider)() + "\n");
   const topGroups = groups.sort((a, b) => {
-    const bVal = (0, import_core10.getSeverityValue)(b.severity);
-    const aVal = (0, import_core10.getSeverityValue)(a.severity);
+    const bVal = (0, import_core7.getSeverityValue)(b.severity);
+    const aVal = (0, import_core7.getSeverityValue)(a.severity);
     const severityDiff = bVal - aVal;
     if (severityDiff !== 0) return severityDiff;
     return b.totalTokenCost - a.totalTokenCost;
   }).slice(0, maxResults);
   topGroups.forEach((group, idx) => {
-    const severityBadge = (0, import_core10.getSeverityBadge)(group.severity);
+    const severityBadge = (0, import_core7.getSeverityBadge)(group.severity);
     const [file1, file2] = group.filePair.split("::");
     const file1Name = file1.split("/").pop() || file1;
     const file2Name = file2.split("/").pop() || file2;
@@ -1070,13 +915,13 @@ function printDuplicateGroups(groups, maxResults) {
 }
 function printRefactorClusters(clusters) {
   if (clusters.length === 0) return;
-  console.log("\n" + (0, import_core10.getTerminalDivider)());
+  console.log("\n" + (0, import_core7.getTerminalDivider)());
   console.log(
     import_chalk.default.bold.white(`  \u{1F3AF} REFACTOR CLUSTERS (${clusters.length} patterns)`)
   );
-  console.log((0, import_core10.getTerminalDivider)() + "\n");
+  console.log((0, import_core7.getTerminalDivider)() + "\n");
   clusters.sort((a, b) => b.totalTokenCost - a.totalTokenCost).forEach((cluster, idx) => {
-    const severityBadge = (0, import_core10.getSeverityBadge)(cluster.severity);
+    const severityBadge = (0, import_core7.getSeverityBadge)(cluster.severity);
     console.log(`${idx + 1}. ${severityBadge} ${import_chalk.default.bold(cluster.name)}`);
     console.log(
       `   Total tokens: ${import_chalk.default.bold(cluster.totalTokenCost.toLocaleString())} | Avg similarity: ${import_chalk.default.bold(Math.round(cluster.averageSimilarity * 100) + "%")} | Duplicates: ${import_chalk.default.bold(cluster.duplicateCount)}`
@@ -1103,18 +948,18 @@ function printRefactorClusters(clusters) {
 }
 function printRawDuplicates(duplicates, maxResults) {
   if (duplicates.length === 0) return;
-  console.log("\n" + (0, import_core10.getTerminalDivider)());
+  console.log("\n" + (0, import_core7.getTerminalDivider)());
   console.log(import_chalk.default.bold.white("  TOP DUPLICATE PATTERNS"));
-  console.log((0, import_core10.getTerminalDivider)() + "\n");
+  console.log((0, import_core7.getTerminalDivider)() + "\n");
   const topDuplicates = duplicates.sort((a, b) => {
-    const bVal = (0, import_core10.getSeverityValue)(b.severity);
-    const aVal = (0, import_core10.getSeverityValue)(a.severity);
+    const bVal = (0, import_core7.getSeverityValue)(b.severity);
+    const aVal = (0, import_core7.getSeverityValue)(a.severity);
     const severityDiff = bVal - aVal;
     if (severityDiff !== 0) return severityDiff;
     return b.similarity - a.similarity;
   }).slice(0, maxResults);
   topDuplicates.forEach((dup) => {
-    const severityBadge = (0, import_core10.getSeverityBadge)(dup.severity);
+    const severityBadge = (0, import_core7.getSeverityBadge)(dup.severity);
     const file1Name = dup.file1.split("/").pop() || dup.file1;
     const file2Name = dup.file2.split("/").pop() || dup.file2;
     console.log(
@@ -1147,9 +992,9 @@ function printRawDuplicates(duplicates, maxResults) {
 }
 function printCriticalIssues(issues) {
   if (issues.length === 0) return;
-  console.log((0, import_core10.getTerminalDivider)());
+  console.log((0, import_core7.getTerminalDivider)());
   console.log(import_chalk.default.bold.white("  CRITICAL ISSUES (>95% similar)"));
-  console.log((0, import_core10.getTerminalDivider)() + "\n");
+  console.log((0, import_core7.getTerminalDivider)() + "\n");
   issues.slice(0, 5).forEach((issue) => {
     console.log(
       import_chalk.default.red("\u25CF ") + import_chalk.default.white(`${issue.file}:${issue.location.line}`)
@@ -1189,8 +1034,11 @@ async function patternActionHandler(directory, options) {
     );
   }
   const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
-  const summary = generateSummary(results);
-  const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
+  const summary = generateSummary(results || []);
+  const totalIssues = (results || []).reduce(
+    (sum, r) => sum + (r.issues?.length || 0),
+    0
+  );
   if (options.output === "json") {
     handleJsonOutput(options.outputFile, directory, {
       summary,
@@ -1218,7 +1066,7 @@ async function patternActionHandler(directory, options) {
   );
 }
 function handleJsonOutput(outputFile, directory, data) {
-  const outputPath = (0, import_core11.resolveOutputPath)(
+  const outputPath = (0, import_core8.resolveOutputPath)(
     outputFile,
     `pattern-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
     directory
@@ -1231,7 +1079,7 @@ function handleJsonOutput(outputFile, directory, data) {
 }
 function handleHtmlOutput(outputFile, directory, summary, results) {
   const html = generateHTMLReport(summary, results);
-  const outputPath = (0, import_core11.resolveOutputPath)(
+  const outputPath = (0, import_core8.resolveOutputPath)(
     outputFile,
     `pattern-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.html`,
     directory
@@ -1266,7 +1114,7 @@ function renderTerminalOutput(fileCount, totalIssues, summary, elapsedTime, opti
   } else if (totalIssues < 5) {
     printGuidance();
   }
-  console.log((0, import_core11.getTerminalDivider)());
+  console.log((0, import_core8.getTerminalDivider)());
   if (totalIssues > 0) {
     console.log(
       import_chalk2.default.white(
@@ -1278,7 +1126,7 @@ function renderTerminalOutput(fileCount, totalIssues, summary, elapsedTime, opti
   printFooter();
 }
 function resultsToCriticalIssues(summary, duplicates) {
-  return duplicates.filter((d) => (0, import_core11.getSeverityValue)(d.severity) === 4).map((d) => ({
+  return duplicates.filter((d) => (0, import_core8.getSeverityValue)(d.severity) === 4).map((d) => ({
     file: d.file1,
     location: { line: d.line1 },
     message: `${d.patternType} pattern highly similar to ${d.file2}`,

package/dist/cli.mjs

@@ -1,14 +1,12 @@
 #!/usr/bin/env node
-import "./chunk-J5CW6NYY.mjs";
 import {
   analyzePatterns,
   generateSummary
-} from "./chunk-SUUZMLPS.mjs";
+} from "./chunk-K7BO57OO.mjs";
 import "./chunk-NQBYYWHJ.mjs";
 import {
   filterBySeverity
 } from "./chunk-J2G742QF.mjs";
-import "./chunk-WBBO35SC.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -385,8 +383,11 @@ async function patternActionHandler(directory, options) {
     );
   }
   const elapsedTime = ((Date.now() - startTime) / 1e3).toFixed(2);
-  const summary = generateSummary(results);
-  const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
+  const summary = generateSummary(results || []);
+  const totalIssues = (results || []).reduce(
+    (sum, r) => sum + (r.issues?.length || 0),
+    0
+  );
   if (options.output === "json") {
     handleJsonOutput(options.outputFile, directory, {
       summary,

package/dist/index.js

@@ -498,7 +498,7 @@ async function getSmartDefaults(directory, userOptions) {
     6,
     Math.min(20, 6 + Math.floor(estimatedBlocks / 1e3) * 2)
   );
-  const minSimilarity = Math.min(0.85, 0.5 + estimatedBlocks / 5e3 * 0.3);
+  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(
@@ -658,9 +658,9 @@ async function analyzePatterns(options) {
   return { results, duplicates, files, groups, clusters, config: finalOptions };
 }
 function generateSummary(results) {
-  const allIssues = results.flatMap((r) => r.issues);
+  const allIssues = results.flatMap((r) => r.issues || []);
   const totalTokenCost = results.reduce(
-    (sum, r) => sum + (r.metrics.tokenCost || 0),
+    (sum, r) => sum + (r.metrics?.tokenCost || 0),
     0
   );
   const patternsByType = {

package/dist/index.mjs

@@ -1,7 +1,3 @@
-import {
-  PatternDetectProvider,
-  Severity
-} from "./chunk-J5CW6NYY.mjs";
 import {
   analyzePatterns,
   createRefactorClusters,
@@ -9,7 +5,7 @@ import {
   generateSummary,
   getSmartDefaults,
   groupDuplicatesByFilePair
-} from "./chunk-SUUZMLPS.mjs";
+} from "./chunk-K7BO57OO.mjs";
 import {
   detectDuplicatePatterns
 } from "./chunk-NQBYYWHJ.mjs";
@@ -24,6 +20,59 @@ import {
 import {
   calculatePatternScore
 } from "./chunk-WBBO35SC.mjs";
+
+// src/index.ts
+import { ToolRegistry, Severity } from "@aiready/core";
+
+// src/provider.ts
+import {
+  ToolName,
+  SpokeOutputSchema,
+  GLOBAL_SCAN_OPTIONS
+} from "@aiready/core";
+var PatternDetectProvider = {
+  id: ToolName.PatternDetect,
+  alias: ["patterns", "duplicates", "duplication"],
+  async analyze(options) {
+    const results = await analyzePatterns(options);
+    return SpokeOutputSchema.parse({
+      results: results.results,
+      summary: {
+        totalFiles: results.files.length,
+        totalIssues: results.results.reduce(
+          (sum, r) => sum + r.issues.length,
+          0
+        ),
+        duplicates: results.duplicates,
+        // Keep the raw duplicates for score calculation
+        clusters: results.clusters,
+        config: Object.fromEntries(
+          Object.entries(results.config).filter(
+            ([key]) => !GLOBAL_SCAN_OPTIONS.includes(key) || key === "rootDir"
+          )
+        )
+      },
+      metadata: {
+        toolName: 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
+ToolRegistry.register(PatternDetectProvider);
 export {
   CONTEXT_RULES,
   IssueType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/pattern-detect",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "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",
@@ -65,7 +65,7 @@
   "dependencies": {
     "commander": "^14.0.0",
     "chalk": "^5.3.0",
-    "@aiready/core": "0.24.1"
+    "@aiready/core": "0.24.3"
   },
   "devDependencies": {
     "tsup": "^8.3.5",