@aiready/pattern-detect 0.17.8 → 0.17.12

package/dist/chunk-YSDOUNJJ.mjs

@@ -1,1142 +0,0 @@
-// src/index.ts
-import { readFileContent } from "@aiready/core";
-
-// src/detector.ts
-import { estimateTokens } from "@aiready/core";
-
-// src/context-rules.ts
-var CONTEXT_RULES = [
-  // Test Fixtures - Intentional duplication for test isolation
-  {
-    name: "test-fixtures",
-    detect: (file, code) => {
-      const isTestFile = file.includes(".test.") || file.includes(".spec.") || file.includes("__tests__") || file.includes("/test/") || file.includes("/tests/");
-      const hasTestFixtures = code.includes("beforeAll") || code.includes("afterAll") || code.includes("beforeEach") || code.includes("afterEach") || code.includes("setUp") || code.includes("tearDown");
-      return isTestFile && hasTestFixtures;
-    },
-    severity: "info",
-    reason: "Test fixture duplication is intentional for test isolation",
-    suggestion: "Consider if shared test setup would improve maintainability without coupling tests"
-  },
-  // Email/Document Templates - Often intentionally similar for consistency
-  {
-    name: "templates",
-    detect: (file, code) => {
-      const isTemplate = file.includes("/templates/") || file.includes("-template") || file.includes("/email-templates/") || file.includes("/emails/");
-      const hasTemplateContent = (code.includes("return") || code.includes("export")) && (code.includes("html") || code.includes("subject") || code.includes("body"));
-      return isTemplate && hasTemplateContent;
-    },
-    severity: "minor",
-    reason: "Template duplication may be intentional for maintainability and branding consistency",
-    suggestion: "Extract shared structure only if templates become hard to maintain"
-  },
-  // E2E/Integration Test Page Objects - Test independence
-  {
-    name: "e2e-page-objects",
-    detect: (file, code) => {
-      const isE2ETest = file.includes("e2e/") || file.includes("/e2e/") || file.includes(".e2e.") || file.includes("/playwright/") || file.includes("playwright/") || file.includes("/cypress/") || file.includes("cypress/") || file.includes("/integration/") || file.includes("integration/");
-      const hasPageObjectPatterns = code.includes("page.") || code.includes("await page") || code.includes("locator") || code.includes("getBy") || code.includes("selector") || code.includes("click(") || code.includes("fill(");
-      return isE2ETest && hasPageObjectPatterns;
-    },
-    severity: "minor",
-    reason: "E2E test duplication ensures test independence and reduces coupling",
-    suggestion: "Consider page object pattern only if duplication causes maintenance issues"
-  },
-  // Configuration Files - Often necessarily similar by design
-  {
-    name: "config-files",
-    detect: (file) => {
-      return file.endsWith(".config.ts") || file.endsWith(".config.js") || file.includes("jest.config") || file.includes("vite.config") || file.includes("webpack.config") || file.includes("rollup.config") || file.includes("tsconfig");
-    },
-    severity: "minor",
-    reason: "Configuration files often have similar structure by design",
-    suggestion: "Consider shared config base only if configurations become hard to maintain"
-  },
-  // Type Definitions - Duplication for type safety and module independence
-  {
-    name: "type-definitions",
-    detect: (file, code) => {
-      const isTypeFile = file.endsWith(".d.ts") || file.includes("/types/");
-      const hasTypeDefinitions = code.includes("interface ") || code.includes("type ") || code.includes("enum ");
-      return isTypeFile && hasTypeDefinitions;
-    },
-    severity: "info",
-    reason: "Type duplication may be intentional for module independence and type safety",
-    suggestion: "Extract to shared types package only if causing maintenance burden"
-  },
-  // Migration Scripts - One-off scripts that are similar by nature
-  {
-    name: "migration-scripts",
-    detect: (file) => {
-      return file.includes("/migrations/") || file.includes("/migrate/") || file.includes(".migration.");
-    },
-    severity: "info",
-    reason: "Migration scripts are typically one-off and intentionally similar",
-    suggestion: "Duplication is acceptable for migration scripts"
-  },
-  // Mock Data - Test data intentionally duplicated
-  {
-    name: "mock-data",
-    detect: (file, code) => {
-      const isMockFile = file.includes("/mocks/") || file.includes("/__mocks__/") || file.includes("/fixtures/") || file.includes(".mock.") || file.includes(".fixture.");
-      const hasMockData = code.includes("mock") || code.includes("Mock") || code.includes("fixture") || code.includes("stub") || code.includes("export const");
-      return isMockFile && hasMockData;
-    },
-    severity: "info",
-    reason: "Mock data duplication is expected for comprehensive test coverage",
-    suggestion: "Consider shared factories only for complex mock generation"
-  }
-];
-function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
-  for (const rule of CONTEXT_RULES) {
-    if (rule.detect(file1, code) || rule.detect(file2, code)) {
-      return {
-        severity: rule.severity,
-        reason: rule.reason,
-        suggestion: rule.suggestion,
-        matchedRule: rule.name
-      };
-    }
-  }
-  if (similarity >= 0.95 && linesOfCode >= 30) {
-    return {
-      severity: "critical",
-      reason: "Large nearly-identical code blocks waste tokens and create maintenance burden",
-      suggestion: "Extract to shared utility module immediately"
-    };
-  } else if (similarity >= 0.95 && linesOfCode >= 15) {
-    return {
-      severity: "major",
-      reason: "Nearly identical code should be consolidated",
-      suggestion: "Move to shared utility file"
-    };
-  } else if (similarity >= 0.85) {
-    return {
-      severity: "major",
-      reason: "High similarity indicates significant duplication",
-      suggestion: "Extract common logic to shared function"
-    };
-  } else if (similarity >= 0.7) {
-    return {
-      severity: "minor",
-      reason: "Moderate similarity detected",
-      suggestion: "Consider extracting shared patterns if code evolves together"
-    };
-  } else {
-    return {
-      severity: "minor",
-      reason: "Minor similarity detected",
-      suggestion: "Monitor but refactoring may not be worthwhile"
-    };
-  }
-}
-function getSeverityLabel(severity) {
-  const labels = {
-    critical: "\u{1F534} CRITICAL",
-    major: "\u{1F7E1} MAJOR",
-    minor: "\u{1F535} MINOR",
-    info: "\u2139\uFE0F  INFO"
-  };
-  return labels[severity];
-}
-function filterBySeverity(duplicates, minSeverity) {
-  const severityOrder = ["info", "minor", "major", "critical"];
-  const minIndex = severityOrder.indexOf(minSeverity);
-  if (minIndex === -1) return duplicates;
-  return duplicates.filter((dup) => {
-    const dupIndex = severityOrder.indexOf(dup.severity);
-    return dupIndex >= minIndex;
-  });
-}
-
-// src/detector.ts
-function categorizePattern(code) {
-  const lower = code.toLowerCase();
-  if (lower.includes("request") && lower.includes("response") || lower.includes("router.") || lower.includes("app.get") || lower.includes("app.post") || lower.includes("express") || lower.includes("ctx.body")) {
-    return "api-handler";
-  }
-  if (lower.includes("validate") || lower.includes("schema") || lower.includes("zod") || lower.includes("yup") || lower.includes("if") && lower.includes("throw")) {
-    return "validator";
-  }
-  if (lower.includes("return (") || lower.includes("jsx") || lower.includes("component") || lower.includes("props")) {
-    return "component";
-  }
-  if (lower.includes("class ") || lower.includes("this.")) {
-    return "class-method";
-  }
-  if (lower.includes("return ") && !lower.includes("this") && !lower.includes("new ")) {
-    return "utility";
-  }
-  if (lower.includes("function") || lower.includes("=>")) {
-    return "function";
-  }
-  return "unknown";
-}
-function extractCodeBlocks(content, minLines) {
-  const lines = content.split("\n");
-  const blocks = [];
-  let currentBlock = [];
-  let blockStart = 0;
-  let braceDepth = 0;
-  let inFunction = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    if (!inFunction && (trimmed.includes("function ") || trimmed.includes("=>") || trimmed.includes("async ") || /^(export\s+)?(async\s+)?function\s+/.test(trimmed) || /^(export\s+)?const\s+\w+\s*=\s*(async\s*)?\(/.test(trimmed))) {
-      inFunction = true;
-      blockStart = i;
-    }
-    for (const char of line) {
-      if (char === "{") braceDepth++;
-      if (char === "}") braceDepth--;
-    }
-    if (inFunction) {
-      currentBlock.push(line);
-    }
-    if (inFunction && braceDepth === 0 && currentBlock.length >= minLines) {
-      const blockContent = currentBlock.join("\n");
-      const linesOfCode = currentBlock.filter(
-        (l) => l.trim() && !l.trim().startsWith("//")
-      ).length;
-      blocks.push({
-        content: blockContent,
-        startLine: blockStart + 1,
-        endLine: i + 1,
-        patternType: categorizePattern(blockContent),
-        linesOfCode
-      });
-      currentBlock = [];
-      inFunction = false;
-    } else if (inFunction && braceDepth === 0) {
-      currentBlock = [];
-      inFunction = false;
-    }
-  }
-  return blocks;
-}
-function normalizeCode(code) {
-  if (!code) {
-    return "";
-  }
-  return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/"[^"]*"/g, '"STR"').replace(/'[^']*'/g, "'STR'").replace(/`[^`]*`/g, "`STR`").replace(/\b\d+\b/g, "NUM").replace(/\s+/g, " ").trim();
-}
-function jaccardSimilarity(tokens1, tokens2) {
-  const set1 = new Set(tokens1);
-  const set2 = new Set(tokens2);
-  let intersection = 0;
-  for (const token of set1) {
-    if (set2.has(token)) intersection++;
-  }
-  const union = set1.size + set2.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-async function detectDuplicatePatterns(files, options) {
-  const {
-    minSimilarity,
-    minLines,
-    batchSize = 100,
-    approx = true,
-    minSharedTokens = 8,
-    maxCandidatesPerBlock = 100,
-    streamResults = false
-  } = options;
-  const duplicates = [];
-  const maxComparisons = approx ? Infinity : 5e5;
-  const allBlocks = files.flatMap(
-    (file) => extractCodeBlocks(file.content, minLines).filter((block) => block.content && block.content.trim().length > 0).map((block) => ({
-      content: block.content,
-      startLine: block.startLine,
-      endLine: block.endLine,
-      file: file.file,
-      normalized: normalizeCode(block.content),
-      patternType: block.patternType,
-      tokenCost: estimateTokens(block.content),
-      linesOfCode: block.linesOfCode
-    }))
-  );
-  if (!options.onProgress) {
-    console.log(`Extracted ${allBlocks.length} code blocks for analysis`);
-  }
-  const pythonFiles = files.filter((f) => f.file.toLowerCase().endsWith(".py"));
-  if (pythonFiles.length > 0) {
-    const { extractPythonPatterns } = await import("./python-extractor-ELAKYK2W.mjs");
-    const patterns = await extractPythonPatterns(
-      pythonFiles.map((f) => f.file)
-    );
-    const pythonBlocks = patterns.filter((p) => p.code && p.code.trim().length > 0).map((p) => ({
-      content: p.code,
-      startLine: p.startLine,
-      endLine: p.endLine,
-      file: p.file,
-      normalized: normalizeCode(p.code),
-      patternType: p.type,
-      tokenCost: estimateTokens(p.code),
-      linesOfCode: p.endLine - p.startLine + 1
-    }));
-    allBlocks.push(...pythonBlocks);
-    if (!options.onProgress) {
-      console.log(`Added ${pythonBlocks.length} Python patterns`);
-    }
-  }
-  if (!approx && allBlocks.length > 500) {
-    console.log(
-      `\u26A0\uFE0F  Using --no-approx mode with ${allBlocks.length} blocks may be slow (O(B\xB2) complexity).`
-    );
-    console.log(
-      `   Consider using approximate mode (default) for better performance.`
-    );
-  }
-  const stopwords = /* @__PURE__ */ new Set([
-    "return",
-    "const",
-    "let",
-    "var",
-    "function",
-    "class",
-    "new",
-    "if",
-    "else",
-    "for",
-    "while",
-    "async",
-    "await",
-    "try",
-    "catch",
-    "switch",
-    "case",
-    "default",
-    "import",
-    "export",
-    "from",
-    "true",
-    "false",
-    "null",
-    "undefined",
-    "this"
-  ]);
-  const tokenize = (norm) => {
-    const punctuation = "(){}[];.,";
-    const cleaned = norm.split("").map((ch) => punctuation.includes(ch) ? " " : ch).join("");
-    return cleaned.split(/\s+/).filter((t) => t && t.length >= 3 && !stopwords.has(t.toLowerCase()));
-  };
-  const blockTokens = allBlocks.map((b) => tokenize(b.normalized));
-  const invertedIndex = /* @__PURE__ */ new Map();
-  if (approx) {
-    for (let i = 0; i < blockTokens.length; i++) {
-      for (const tok of blockTokens[i]) {
-        let arr = invertedIndex.get(tok);
-        if (!arr) {
-          arr = [];
-          invertedIndex.set(tok, arr);
-        }
-        arr.push(i);
-      }
-    }
-  }
-  const totalComparisons = approx ? void 0 : allBlocks.length * (allBlocks.length - 1) / 2;
-  if (totalComparisons !== void 0) {
-    console.log(
-      `Processing ${totalComparisons.toLocaleString()} comparisons in batches...`
-    );
-  } else {
-    console.log(
-      `Using approximate candidate selection to reduce comparisons...`
-    );
-  }
-  let comparisonsProcessed = 0;
-  let comparisonsBudgetExhausted = false;
-  const startTime = Date.now();
-  for (let i = 0; i < allBlocks.length; i++) {
-    if (maxComparisons && comparisonsProcessed >= maxComparisons) {
-      comparisonsBudgetExhausted = true;
-      break;
-    }
-    if (i % batchSize === 0 && i > 0) {
-      if (options.onProgress) {
-        options.onProgress(i, allBlocks.length, `pattern-detect: analyzing blocks`);
-      } else {
-        const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
-        const duplicatesFound = duplicates.length;
-        if (totalComparisons !== void 0) {
-          const progress = (comparisonsProcessed / totalComparisons * 100).toFixed(1);
-          const remaining = totalComparisons - comparisonsProcessed;
-          const rate = comparisonsProcessed / parseFloat(elapsed);
-          const eta = remaining > 0 ? (remaining / rate).toFixed(0) : 0;
-          console.log(
-            `   ${progress}% (${comparisonsProcessed.toLocaleString()}/${totalComparisons.toLocaleString()} comparisons, ${elapsed}s elapsed, ~${eta}s remaining, ${duplicatesFound} duplicates)`
-          );
-        } else {
-          console.log(
-            `   Processed ${i.toLocaleString()}/${allBlocks.length} blocks (${elapsed}s elapsed, ${duplicatesFound} duplicates)`
-          );
-        }
-      }
-      await new Promise((resolve) => setImmediate(resolve));
-    }
-    const block1 = allBlocks[i];
-    let candidates = null;
-    if (approx) {
-      const counts = /* @__PURE__ */ new Map();
-      const block1Tokens = new Set(blockTokens[i]);
-      const block1Size = block1Tokens.size;
-      const rareTokens = blockTokens[i].filter((tok) => {
-        const blocksWithToken = invertedIndex.get(tok)?.length || 0;
-        return blocksWithToken < allBlocks.length * 0.1;
-      });
-      for (const tok of rareTokens) {
-        const ids = invertedIndex.get(tok);
-        if (!ids) continue;
-        for (const j of ids) {
-          if (j <= i) continue;
-          if (allBlocks[j].file === block1.file) continue;
-          counts.set(j, (counts.get(j) || 0) + 1);
-        }
-      }
-      candidates = Array.from(counts.entries()).filter(([j, shared]) => {
-        const block2Tokens = blockTokens[j];
-        const block2Size = block2Tokens.length;
-        const minSize = Math.min(block1Size, block2Size);
-        const sharedPercentage = shared / minSize;
-        return shared >= minSharedTokens && sharedPercentage >= 0.3;
-      }).sort((a, b) => b[1] - a[1]).slice(0, Math.min(maxCandidatesPerBlock, 5)).map(([j, shared]) => ({ j, shared }));
-    }
-    if (approx && candidates) {
-      for (const { j } of candidates) {
-        if (!approx && maxComparisons !== Infinity && comparisonsProcessed >= maxComparisons) {
-          console.log(
-            `\u26A0\uFE0F  Comparison safety limit reached (${maxComparisons.toLocaleString()} comparisons in --no-approx mode).`
-          );
-          console.log(
-            `   This prevents excessive runtime on large repos. Consider using approximate mode (default) or --min-lines to reduce blocks.`
-          );
-          break;
-        }
-        comparisonsProcessed++;
-        const block2 = allBlocks[j];
-        const similarity = jaccardSimilarity(blockTokens[i], blockTokens[j]);
-        if (similarity >= minSimilarity) {
-          const { severity, reason, suggestion, matchedRule } = calculateSeverity(
-            block1.file,
-            block2.file,
-            block1.content,
-            similarity,
-            block1.linesOfCode
-          );
-          const duplicate = {
-            file1: block1.file,
-            file2: block2.file,
-            line1: block1.startLine,
-            line2: block2.startLine,
-            endLine1: block1.endLine,
-            endLine2: block2.endLine,
-            similarity,
-            snippet: block1.content.split("\n").slice(0, 5).join("\n") + "\n...",
-            patternType: block1.patternType,
-            tokenCost: block1.tokenCost + block2.tokenCost,
-            linesOfCode: block1.linesOfCode,
-            severity,
-            reason,
-            suggestion,
-            matchedRule
-          };
-          duplicates.push(duplicate);
-          if (streamResults) {
-            console.log(
-              `
-   \u2705 Found: ${duplicate.patternType} ${Math.round(similarity * 100)}% similar`
-            );
-            console.log(
-              `      ${duplicate.file1}:${duplicate.line1}-${duplicate.endLine1} \u21D4 ${duplicate.file2}:${duplicate.line2}-${duplicate.endLine2}`
-            );
-            console.log(
-              `      Token cost: ${duplicate.tokenCost.toLocaleString()}`
-            );
-          }
-        }
-      }
-    } else {
-      for (let j = i + 1; j < allBlocks.length; j++) {
-        if (maxComparisons && comparisonsProcessed >= maxComparisons) break;
-        comparisonsProcessed++;
-        const block2 = allBlocks[j];
-        if (block1.file === block2.file) continue;
-        const similarity = jaccardSimilarity(blockTokens[i], blockTokens[j]);
-        if (similarity >= minSimilarity) {
-          const { severity, reason, suggestion, matchedRule } = calculateSeverity(
-            block1.file,
-            block2.file,
-            block1.content,
-            similarity,
-            block1.linesOfCode
-          );
-          const duplicate = {
-            file1: block1.file,
-            file2: block2.file,
-            line1: block1.startLine,
-            line2: block2.startLine,
-            endLine1: block1.endLine,
-            endLine2: block2.endLine,
-            similarity,
-            snippet: block1.content.split("\n").slice(0, 5).join("\n") + "\n...",
-            patternType: block1.patternType,
-            tokenCost: block1.tokenCost + block2.tokenCost,
-            linesOfCode: block1.linesOfCode,
-            severity,
-            reason,
-            suggestion,
-            matchedRule
-          };
-          duplicates.push(duplicate);
-          if (streamResults) {
-            console.log(
-              `
-   \u2705 Found: ${duplicate.patternType} ${Math.round(similarity * 100)}% similar`
-            );
-            console.log(
-              `      ${duplicate.file1}:${duplicate.line1}-${duplicate.endLine1} \u21D4 ${duplicate.file2}:${duplicate.line2}-${duplicate.endLine2}`
-            );
-            console.log(
-              `      Token cost: ${duplicate.tokenCost.toLocaleString()}`
-            );
-          }
-        }
-      }
-    }
-  }
-  if (comparisonsBudgetExhausted) {
-    console.log(
-      `\u26A0\uFE0F  Comparison budget exhausted (${maxComparisons.toLocaleString()} comparisons). Use --max-comparisons to increase.`
-    );
-  }
-  return duplicates.sort(
-    (a, b) => b.similarity - a.similarity || b.tokenCost - a.tokenCost
-  );
-}
-
-// src/grouping.ts
-function normalizeFilePair(file1, file2) {
-  return file1 < file2 ? `${file1}::${file2}` : `${file2}::${file1}`;
-}
-function rangesOverlap(start1, end1, start2, end2, tolerance = 5) {
-  return start1 <= end2 + tolerance && start2 <= end1 + tolerance;
-}
-function groupDuplicatesByFilePair(duplicates) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const dup of duplicates) {
-    const key = normalizeFilePair(dup.file1, dup.file2);
-    if (!groups.has(key)) {
-      groups.set(key, []);
-    }
-    groups.get(key).push(dup);
-  }
-  const result = [];
-  for (const [filePair, groupDups] of groups.entries()) {
-    const deduplicated = deduplicateOverlappingRanges(groupDups);
-    const totalTokenCost = deduplicated.reduce(
-      (sum, d) => sum + d.tokenCost,
-      0
-    );
-    const averageSimilarity = deduplicated.reduce((sum, d) => sum + d.similarity, 0) / deduplicated.length;
-    const maxSimilarity = Math.max(...deduplicated.map((d) => d.similarity));
-    const severity = getHighestSeverity(deduplicated.map((d) => d.severity));
-    const patternType = getMostCommonPatternType(deduplicated);
-    const lineRanges = deduplicated.map((d) => ({
-      file1: { start: d.line1, end: d.endLine1 },
-      file2: { start: d.line2, end: d.endLine2 }
-    }));
-    result.push({
-      filePair,
-      duplicates: deduplicated,
-      totalTokenCost,
-      averageSimilarity,
-      maxSimilarity,
-      severity,
-      patternType,
-      occurrences: deduplicated.length,
-      lineRanges
-    });
-  }
-  return result.sort((a, b) => b.totalTokenCost - a.totalTokenCost);
-}
-function deduplicateOverlappingRanges(duplicates) {
-  if (duplicates.length === 0) return [];
-  const sorted = [...duplicates].sort((a, b) => {
-    if (a.line1 !== b.line1) return a.line1 - b.line1;
-    return b.similarity - a.similarity;
-  });
-  const result = [];
-  let current = null;
-  for (const dup of sorted) {
-    if (!current) {
-      current = dup;
-      result.push(dup);
-      continue;
-    }
-    const overlapsFile1 = rangesOverlap(
-      current.line1,
-      current.endLine1,
-      dup.line1,
-      dup.endLine1
-    );
-    const overlapsFile2 = rangesOverlap(
-      current.line2,
-      current.endLine2,
-      dup.line2,
-      dup.endLine2
-    );
-    if (overlapsFile1 && overlapsFile2) {
-      current = {
-        ...current,
-        endLine1: Math.max(current.endLine1, dup.endLine1),
-        endLine2: Math.max(current.endLine2, dup.endLine2),
-        tokenCost: Math.max(current.tokenCost, dup.tokenCost)
-      };
-      result[result.length - 1] = current;
-    } else {
-      current = dup;
-      result.push(dup);
-    }
-  }
-  return result;
-}
-function createRefactorClusters(duplicates) {
-  const clusters = /* @__PURE__ */ new Map();
-  for (const dup of duplicates) {
-    const clusterId = identifyCluster(dup);
-    if (!clusters.has(clusterId)) {
-      clusters.set(clusterId, []);
-    }
-    clusters.get(clusterId).push(dup);
-  }
-  const result = [];
-  for (const [clusterId, clusterDups] of clusters.entries()) {
-    if (clusterDups.length < 2) continue;
-    const files = getUniqueFiles(clusterDups);
-    const totalTokenCost = clusterDups.reduce((sum, d) => sum + d.tokenCost, 0);
-    const averageSimilarity = clusterDups.reduce((sum, d) => sum + d.similarity, 0) / clusterDups.length;
-    const severity = getHighestSeverity(clusterDups.map((d) => d.severity));
-    const patternType = getMostCommonPatternType(clusterDups);
-    const clusterInfo = getClusterInfo(clusterId, patternType, files.length);
-    result.push({
-      id: clusterId,
-      name: clusterInfo.name,
-      files,
-      patternType,
-      severity,
-      totalTokenCost,
-      averageSimilarity,
-      duplicateCount: clusterDups.length,
-      suggestion: clusterInfo.suggestion,
-      reason: clusterInfo.reason
-    });
-  }
-  return result.sort((a, b) => b.totalTokenCost - a.totalTokenCost);
-}
-function identifyCluster(dup) {
-  const file1 = dup.file1.toLowerCase();
-  const file2 = dup.file2.toLowerCase();
-  if ((file1.includes("/blog/") || file1.startsWith("blog/") || file1.includes("/articles/") || file1.startsWith("articles/")) && (file2.includes("/blog/") || file2.startsWith("blog/") || file2.includes("/articles/") || file2.startsWith("articles/"))) {
-    return "blog-seo-boilerplate";
-  }
-  if ((file1.includes("/components/") || file1.startsWith("components/")) && (file2.includes("/components/") || file2.startsWith("components/")) && dup.patternType === "component") {
-    const component1 = extractComponentName(dup.file1);
-    const component2 = extractComponentName(dup.file2);
-    console.log(
-      `Component check: ${dup.file1} -> ${component1}, ${dup.file2} -> ${component2}`
-    );
-    if (component1 && component2 && areSimilarComponents(component1, component2)) {
-      const category = getComponentCategory(component1);
-      console.log(`Creating cluster: component-${category}`);
-      return `component-${category}`;
-    }
-  }
-  if ((file1.includes("/e2e/") || file1.startsWith("e2e/") || file1.includes(".e2e.")) && (file2.includes("/e2e/") || file2.startsWith("e2e/") || file2.includes(".e2e."))) {
-    return "e2e-test-patterns";
-  }
-  if (dup.patternType === "api-handler") {
-    return "api-handlers";
-  }
-  if (dup.patternType === "validator") {
-    return "validators";
-  }
-  if ((file1.includes("/scripts/") || file1.startsWith("scripts/") || file1.includes("/infra/") || file1.startsWith("infra/")) && (file2.includes("/scripts/") || file2.startsWith("scripts/") || file2.includes("/infra/") || file2.startsWith("infra/"))) {
-    return "infrastructure-scripts";
-  }
-  return `${dup.patternType}-patterns`;
-}
-function extractComponentName(filePath) {
-  const match = filePath.match(/[/\\]?([A-Z][a-zA-Z0-9]*)\.(tsx|jsx|ts|js)$/);
-  return match ? match[1] : null;
-}
-function areSimilarComponents(name1, name2) {
-  const category1 = getComponentCategory(name1);
-  const category2 = getComponentCategory(name2);
-  return category1 === category2;
-}
-function getComponentCategory(name) {
-  name = name.toLowerCase();
-  if (name.includes("button") || name.includes("btn")) return "button";
-  if (name.includes("card")) return "card";
-  if (name.includes("modal") || name.includes("dialog")) return "modal";
-  if (name.includes("form")) return "form";
-  if (name.includes("input") || name.includes("field")) return "input";
-  if (name.includes("table") || name.includes("grid")) return "table";
-  if (name.includes("nav") || name.includes("menu")) return "navigation";
-  if (name.includes("header") || name.includes("footer")) return "layout";
-  return "misc";
-}
-function getUniqueFiles(duplicates) {
-  const files = /* @__PURE__ */ new Set();
-  for (const dup of duplicates) {
-    files.add(dup.file1);
-    files.add(dup.file2);
-  }
-  return Array.from(files).sort();
-}
-function getHighestSeverity(severities) {
-  const order = {
-    critical: 4,
-    major: 3,
-    minor: 2,
-    info: 1
-  };
-  let highest = "info";
-  let highestValue = 0;
-  for (const severity of severities) {
-    if (order[severity] > highestValue) {
-      highestValue = order[severity];
-      highest = severity;
-    }
-  }
-  return highest;
-}
-function getMostCommonPatternType(duplicates) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const dup of duplicates) {
-    counts.set(dup.patternType, (counts.get(dup.patternType) || 0) + 1);
-  }
-  let mostCommon = "unknown";
-  let maxCount = 0;
-  for (const [type, count] of counts.entries()) {
-    if (count > maxCount) {
-      maxCount = count;
-      mostCommon = type;
-    }
-  }
-  return mostCommon;
-}
-function getClusterInfo(clusterId, patternType, fileCount) {
-  const templates = {
-    "blog-seo-boilerplate": {
-      name: `Blog SEO Boilerplate (${fileCount} files)`,
-      suggestion: "Create BlogPageLayout component with SEO schema generator, breadcrumb component, and metadata helpers",
-      reason: "SEO boilerplate duplication increases maintenance burden and schema consistency risk"
-    },
-    "e2e-test-patterns": {
-      name: `E2E Test Patterns (${fileCount} files)`,
-      suggestion: "Extract page object helpers and common test utilities (waitFor, fillForm, etc.)",
-      reason: "Test helper extraction improves maintainability while preserving test independence"
-    },
-    "api-handlers": {
-      name: `API Handler Patterns (${fileCount} files)`,
-      suggestion: "Extract common middleware, error handling, and response formatting",
-      reason: "API handler duplication leads to inconsistent error handling and response formats"
-    },
-    validators: {
-      name: `Validator Patterns (${fileCount} files)`,
-      suggestion: "Consolidate into shared schema validators (Zod/Yup) with reusable rules",
-      reason: "Validator duplication causes inconsistent validation and harder maintenance"
-    },
-    "infrastructure-scripts": {
-      name: `Infrastructure Scripts (${fileCount} files)`,
-      suggestion: "Extract common CLI parsing, file I/O, and error handling utilities",
-      reason: "Script duplication is often acceptable for one-off tasks, but common patterns can be shared"
-    },
-    "component-button": {
-      name: `Button Component Variants (${fileCount} files)`,
-      suggestion: "Create unified Button component with variant props",
-      reason: "Multiple button variants should share base styles and behavior"
-    },
-    "component-card": {
-      name: `Card Component Variants (${fileCount} files)`,
-      suggestion: "Create unified Card component with composition pattern",
-      reason: "Card variants should share layout structure and styling"
-    },
-    "component-modal": {
-      name: `Modal Component Variants (${fileCount} files)`,
-      suggestion: "Create base Modal component with customizable content",
-      reason: "Modal variants should share overlay, animation, and accessibility logic"
-    }
-  };
-  if (templates[clusterId]) {
-    return templates[clusterId];
-  }
-  return {
-    name: `${patternType} Cluster (${fileCount} files)`,
-    suggestion: `Extract common ${patternType} patterns into shared utilities`,
-    reason: `Multiple similar ${patternType} patterns detected across ${fileCount} files`
-  };
-}
-function filterClustersByImpact(clusters, minTokenCost = 1e3, minFileCount = 3) {
-  return clusters.filter(
-    (cluster) => cluster.totalTokenCost >= minTokenCost || cluster.files.length >= minFileCount
-  );
-}
-
-// src/scoring.ts
-import {
-  calculateMonthlyCost,
-  calculateProductivityImpact,
-  DEFAULT_COST_CONFIG
-} from "@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: "pattern-detect",
-      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 = { ...DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = calculateMonthlyCost(totalTokenCost, cfg);
-  const issues = duplicates.map((d) => ({
-    severity: d.severity === "critical" ? "critical" : d.severity === "major" ? "major" : "minor"
-  }));
-  const productivityImpact = 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/index.ts
-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 { scanFiles: scanFiles2 } = await import("@aiready/core");
-  const files = await scanFiles2(scanOptions);
-  const estimatedBlocks = files.length * 3;
-  const maxCandidatesPerBlock = Math.max(
-    3,
-    Math.min(10, Math.floor(3e4 / estimatedBlocks))
-  );
-  const minSimilarity = Math.min(0.75, 0.5 + estimatedBlocks / 1e4 * 0.25);
-  const minLines = Math.max(
-    6,
-    Math.min(12, 6 + Math.floor(estimatedBlocks / 2e3))
-  );
-  const minSharedTokens = Math.max(
-    10,
-    Math.min(20, 10 + Math.floor(estimatedBlocks / 2e3))
-  );
-  const batchSize = estimatedBlocks > 1e3 ? 200 : 100;
-  const severity = estimatedBlocks > 5e3 ? "high" : "all";
-  const defaults = {
-    rootDir: directory,
-    minSimilarity,
-    minLines,
-    batchSize,
-    approx: true,
-    minSharedTokens,
-    maxCandidatesPerBlock,
-    streamResults: false,
-    severity,
-    includeTests: false
-  };
-  const result = { ...defaults };
-  for (const [key, value] of Object.entries(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}`);
-  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",
-    includeTests = false,
-    groupByFilePair = true,
-    createClusters = true,
-    minClusterTokenCost = 1e3,
-    minClusterFiles = 3,
-    ...scanOptions
-  } = finalOptions;
-  const { scanFiles: scanFiles2 } = await import("@aiready/core");
-  const files = await scanFiles2(scanOptions);
-  const estimatedBlocks = files.length * 3;
-  logConfiguration(finalOptions, estimatedBlocks);
-  const results = [];
-  const fileContents = await Promise.all(
-    files.map(async (file) => ({
-      file,
-      content: await readFileContent(file)
-    }))
-  );
-  const duplicates = await detectDuplicatePatterns(fileContents, {
-    minSimilarity,
-    minLines,
-    batchSize,
-    approx,
-    minSharedTokens,
-    maxCandidatesPerBlock,
-    streamResults,
-    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 ? "critical" : dup.similarity > 0.9 ? "major" : "minor";
-      return {
-        type: "duplicate-pattern",
-        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: ["critical"],
-        high: ["critical", "major"],
-        medium: ["critical", "major", "minor"]
-      };
-      const allowedSeverities = severityMap[severity] || ["critical", "major", "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 };
-}
-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
-          // 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,
-      patternType: typeMatch?.[1] || "unknown",
-      tokenCost: tokenMatch ? parseInt(tokenMatch[1]) : 0
-    };
-  });
-  return {
-    totalPatterns: allIssues.length,
-    totalTokenCost,
-    patternsByType,
-    topDuplicates
-  };
-}
-
-export {
-  calculateSeverity,
-  getSeverityLabel,
-  filterBySeverity,
-  detectDuplicatePatterns,
-  calculatePatternScore,
-  getSmartDefaults,
-  analyzePatterns,
-  generateSummary
-};