@aiready/pattern-detect 0.12.2 → 0.12.5

package/dist/index.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,157 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/extractors/python-extractor.ts
-var python_extractor_exports = {};
-__export(python_extractor_exports, {
-  calculatePythonSimilarity: () => calculatePythonSimilarity,
-  detectPythonAntiPatterns: () => detectPythonAntiPatterns,
-  extractPythonPatterns: () => extractPythonPatterns
-});
-async function extractPythonPatterns(files) {
-  const patterns = [];
-  const parser = (0, import_core.getParser)("dummy.py");
-  if (!parser) {
-    console.warn("Python parser not available");
-    return patterns;
-  }
-  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
-  for (const file of pythonFiles) {
-    try {
-      const fs = await import("fs");
-      const code = await fs.promises.readFile(file, "utf-8");
-      const result = parser.parse(code, file);
-      for (const exp of result.exports) {
-        if (exp.type === "function") {
-          patterns.push({
-            file,
-            name: exp.name,
-            type: "function",
-            startLine: exp.loc?.start.line || 0,
-            endLine: exp.loc?.end.line || 0,
-            imports: exp.imports || [],
-            dependencies: exp.dependencies || [],
-            signature: generatePythonSignature(exp),
-            language: "python"
-          });
-        } else if (exp.type === "class") {
-          patterns.push({
-            file,
-            name: exp.name,
-            type: "class",
-            startLine: exp.loc?.start.line || 0,
-            endLine: exp.loc?.end.line || 0,
-            imports: exp.imports || [],
-            dependencies: exp.dependencies || [],
-            signature: `class ${exp.name}`,
-            language: "python"
-          });
-        }
-      }
-    } catch (error) {
-      console.warn(`Failed to extract patterns from ${file}:`, error);
-    }
-  }
-  return patterns;
-}
-function generatePythonSignature(exp) {
-  const params = exp.parameters?.join(", ") || "";
-  return `def ${exp.name}(${params})`;
-}
-function calculatePythonSimilarity(pattern1, pattern2) {
-  let similarity = 0;
-  let factors = 0;
-  const nameSimilarity = calculateNameSimilarity(pattern1.name, pattern2.name);
-  similarity += nameSimilarity * 0.3;
-  factors += 0.3;
-  const importSimilarity = calculateImportSimilarity(
-    pattern1.imports || [],
-    pattern2.imports || []
-  );
-  similarity += importSimilarity * 0.4;
-  factors += 0.4;
-  if (pattern1.type === pattern2.type) {
-    similarity += 0.1;
-  }
-  factors += 0.1;
-  const sigSimilarity = calculateSignatureSimilarity(
-    pattern1.signature,
-    pattern2.signature
-  );
-  similarity += sigSimilarity * 0.2;
-  factors += 0.2;
-  return factors > 0 ? similarity / factors : 0;
-}
-function calculateNameSimilarity(name1, name2) {
-  if (name1 === name2) return 1;
-  const clean1 = name1.replace(
-    /^(get|set|is|has|create|delete|update|fetch)_?/,
-    ""
-  );
-  const clean2 = name2.replace(
-    /^(get|set|is|has|create|delete|update|fetch)_?/,
-    ""
-  );
-  if (clean1 === clean2) return 0.9;
-  if (clean1.includes(clean2) || clean2.includes(clean1)) {
-    return 0.7;
-  }
-  const set1 = new Set(clean1.split("_"));
-  const set2 = new Set(clean2.split("_"));
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
-function calculateImportSimilarity(imports1, imports2) {
-  if (imports1.length === 0 && imports2.length === 0) return 1;
-  if (imports1.length === 0 || imports2.length === 0) return 0;
-  const set1 = new Set(imports1);
-  const set2 = new Set(imports2);
-  const intersection = new Set([...set1].filter((x) => set2.has(x)));
-  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-  return intersection.size / union.size;
-}
-function calculateSignatureSimilarity(sig1, sig2) {
-  if (sig1 === sig2) return 1;
-  const params1 = (sig1.match(/\([^)]*\)/)?.[0] || "").split(",").filter(Boolean).length;
-  const params2 = (sig2.match(/\([^)]*\)/)?.[0] || "").split(",").filter(Boolean).length;
-  if (params1 === params2) return 0.8;
-  if (Math.abs(params1 - params2) === 1) return 0.5;
-  return 0;
-}
-function detectPythonAntiPatterns(patterns) {
-  const antiPatterns = [];
-  const nameGroups = /* @__PURE__ */ new Map();
-  for (const pattern of patterns) {
-    const baseName = pattern.name.replace(
-      /^(get|set|create|delete|update)_/,
-      ""
-    );
-    if (!nameGroups.has(baseName)) {
-      nameGroups.set(baseName, []);
-    }
-    nameGroups.get(baseName).push(pattern);
-  }
-  for (const [baseName, group] of nameGroups) {
-    if (group.length >= 3) {
-      antiPatterns.push(
-        `Found ${group.length} functions with similar names (${baseName}): Consider consolidating`
-      );
-    }
-  }
-  return antiPatterns;
-}
-var import_core;
-var init_python_extractor = __esm({
-  "src/extractors/python-extractor.ts"() {
-    "use strict";
-    import_core = require("@aiready/core");
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Severity: () => import_core5.Severity,
   analyzePatterns: () => analyzePatterns,
   calculatePatternScore: () => calculatePatternScore,
   calculateSeverity: () => calculateSeverity,
@@ -191,12 +41,13 @@ __export(index_exports, {
   getSmartDefaults: () => getSmartDefaults
 });
 module.exports = __toCommonJS(index_exports);
-var import_core4 = require("@aiready/core");
+var import_core5 = require("@aiready/core");
 
 // src/detector.ts
 var import_core2 = require("@aiready/core");
 
 // src/context-rules.ts
+var import_core = require("@aiready/core");
 var CONTEXT_RULES = [
   // Test Fixtures - Intentional duplication for test isolation
   {
@@ -206,7 +57,7 @@ var CONTEXT_RULES = [
       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",
+    severity: import_core.Severity.Info,
     reason: "Test fixture duplication is intentional for test isolation",
     suggestion: "Consider if shared test setup would improve maintainability without coupling tests"
   },
@@ -218,7 +69,7 @@ var CONTEXT_RULES = [
       const hasTemplateContent = (code.includes("return") || code.includes("export")) && (code.includes("html") || code.includes("subject") || code.includes("body"));
       return isTemplate && hasTemplateContent;
     },
-    severity: "minor",
+    severity: import_core.Severity.Minor,
     reason: "Template duplication may be intentional for maintainability and branding consistency",
     suggestion: "Extract shared structure only if templates become hard to maintain"
   },
@@ -230,7 +81,7 @@ var CONTEXT_RULES = [
       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",
+    severity: import_core.Severity.Minor,
     reason: "E2E test duplication ensures test independence and reduces coupling",
     suggestion: "Consider page object pattern only if duplication causes maintenance issues"
   },
@@ -240,7 +91,7 @@ var CONTEXT_RULES = [
     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",
+    severity: import_core.Severity.Minor,
     reason: "Configuration files often have similar structure by design",
     suggestion: "Consider shared config base only if configurations become hard to maintain"
   },
@@ -252,7 +103,7 @@ var CONTEXT_RULES = [
       const hasTypeDefinitions = code.includes("interface ") || code.includes("type ") || code.includes("enum ");
       return isTypeFile && hasTypeDefinitions;
     },
-    severity: "info",
+    severity: import_core.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"
   },
@@ -262,7 +113,7 @@ var CONTEXT_RULES = [
     detect: (file) => {
       return file.includes("/migrations/") || file.includes("/migrate/") || file.includes(".migration.");
     },
-    severity: "info",
+    severity: import_core.Severity.Info,
     reason: "Migration scripts are typically one-off and intentionally similar",
     suggestion: "Duplication is acceptable for migration scripts"
   },
@@ -274,7 +125,7 @@ var CONTEXT_RULES = [
       const hasMockData = code.includes("mock") || code.includes("Mock") || code.includes("fixture") || code.includes("stub") || code.includes("export const");
       return isMockFile && hasMockData;
     },
-    severity: "info",
+    severity: import_core.Severity.Info,
     reason: "Mock data duplication is expected for comprehensive test coverage",
     suggestion: "Consider shared factories only for complex mock generation"
   }
@@ -292,31 +143,31 @@ function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
   }
   if (similarity >= 0.95 && linesOfCode >= 30) {
     return {
-      severity: "critical",
+      severity: import_core.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",
+      severity: import_core.Severity.Major,
       reason: "Nearly identical code should be consolidated",
       suggestion: "Move to shared utility file"
     };
   } else if (similarity >= 0.85) {
     return {
-      severity: "major",
+      severity: import_core.Severity.Major,
       reason: "High similarity indicates significant duplication",
       suggestion: "Extract common logic to shared function"
     };
   } else if (similarity >= 0.7) {
     return {
-      severity: "minor",
+      severity: import_core.Severity.Minor,
       reason: "Moderate similarity detected",
       suggestion: "Consider extracting shared patterns if code evolves together"
     };
   } else {
     return {
-      severity: "minor",
+      severity: import_core.Severity.Minor,
       reason: "Minor similarity detected",
       suggestion: "Monitor but refactoring may not be worthwhile"
     };
@@ -324,15 +175,20 @@ function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
 }
 function getSeverityLabel(severity) {
   const labels = {
-    critical: "\u{1F534} CRITICAL",
-    major: "\u{1F7E1} MAJOR",
-    minor: "\u{1F535} MINOR",
-    info: "\u2139\uFE0F  INFO"
+    [import_core.Severity.Critical]: "\u{1F534} CRITICAL",
+    [import_core.Severity.Major]: "\u{1F7E1} MAJOR",
+    [import_core.Severity.Minor]: "\u{1F535} MINOR",
+    [import_core.Severity.Info]: "\u2139\uFE0F  INFO"
   };
   return labels[severity];
 }
 function filterBySeverity(duplicates, minSeverity) {
-  const severityOrder = ["info", "minor", "major", "critical"];
+  const severityOrder = [
+    import_core.Severity.Info,
+    import_core.Severity.Minor,
+    import_core.Severity.Major,
+    import_core.Severity.Critical
+  ];
   const minIndex = severityOrder.indexOf(minSeverity);
   if (minIndex === -1) return duplicates;
   return duplicates.filter((dup) => {
@@ -341,261 +197,129 @@ function filterBySeverity(duplicates, minSeverity) {
   });
 }
 
-// src/core/extractor.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";
+// src/detector.ts
+function normalizeCode(code) {
+  return code.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/['"`]/g, '"').replace(/\s+/g, " ").trim().toLowerCase();
 }
-function extractCodeBlocks(content, minLines) {
-  const lines = content.split("\n");
+function extractBlocks(file, content) {
   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--;
+  const lines = content.split("\n");
+  const blockRegex = /^\s*(?:export\s+)?(?:async\s+)?(function|class|const|interface|type)\s+([a-zA-Z0-9_]+)|^\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 {
+      type = "handler";
+      name = match[3];
     }
-    if (inFunction) {
-      currentBlock.push(line);
+    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 (inFunction && braceDepth === 0 && currentBlock.length >= minLines) {
-      const blockContent = currentBlock.join("\n").trim();
-      if (blockContent) {
-        const loc = currentBlock.filter(
-          (l) => l.trim() && !l.trim().startsWith("//")
-        ).length;
-        blocks.push({
-          content: blockContent,
-          startLine: blockStart + 1,
-          endLine: i + 1,
-          patternType: categorizePattern(blockContent),
-          linesOfCode: loc
-        });
+    if (endLine === -1) {
+      const remaining = content.slice(match.index);
+      const nextLineMatch = remaining.indexOf("\n");
+      if (nextLineMatch !== -1) {
+        endLine = startLine;
+      } else {
+        endLine = lines.length;
       }
-      currentBlock = [];
-      inFunction = false;
-    } else if (inFunction && braceDepth === 0) {
-      currentBlock = [];
-      inFunction = false;
     }
+    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;
 }
-
-// src/core/normalizer.ts
-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();
-}
-var 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"
-]);
-function 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()));
-}
-
-// src/core/similarity.ts
-function jaccardSimilarity(tokens1, tokens2) {
-  const set1 = new Set(tokens1);
-  const set2 = new Set(tokens2);
-  if (set1.size === 0 && set2.size === 0) return 0;
-  let intersection = 0;
-  for (const token of set1) {
-    if (set2.has(token)) intersection++;
+function inferPatternType(keyword, name) {
+  const n = name.toLowerCase();
+  if (keyword === "handler" || n.includes("handler") || n.includes("controller") || n.startsWith("app.")) {
+    return "api-handler";
   }
-  const union = set1.size + set2.size - intersection;
-  return union === 0 ? 0 : intersection / union;
+  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";
 }
-
-// src/core/approx-engine.ts
-var ApproxEngine = class {
-  constructor(allBlocks, blockTokens) {
-    this.invertedIndex = /* @__PURE__ */ new Map();
-    this.allBlocks = allBlocks;
-    this.blockTokens = blockTokens;
-    this.buildIndex();
-  }
-  buildIndex() {
-    for (let i = 0; i < this.blockTokens.length; i++) {
-      for (const tok of this.blockTokens[i]) {
-        let arr = this.invertedIndex.get(tok);
-        if (!arr) {
-          arr = [];
-          this.invertedIndex.set(tok, arr);
-        }
-        arr.push(i);
-      }
-    }
-  }
-  findCandidates(blockIdx, minSharedTokens, maxCandidates) {
-    const block1 = this.allBlocks[blockIdx];
-    const block1Tokens = this.blockTokens[blockIdx];
-    const counts = /* @__PURE__ */ new Map();
-    const rareTokens = block1Tokens.filter((tok) => {
-      const freq = this.invertedIndex.get(tok)?.length || 0;
-      return freq < this.allBlocks.length * 0.1;
-    });
-    for (const tok of rareTokens) {
-      const ids = this.invertedIndex.get(tok);
-      if (!ids) continue;
-      for (const j of ids) {
-        if (j <= blockIdx) continue;
-        if (this.allBlocks[j].file === block1.file) continue;
-        counts.set(j, (counts.get(j) || 0) + 1);
-      }
-    }
-    return Array.from(counts.entries()).filter(([j, shared]) => {
-      const block2Size = this.blockTokens[j].length;
-      const minSize = Math.min(block1Tokens.length, block2Size);
-      return shared >= minSharedTokens && shared / minSize >= 0.3;
-    }).sort((a, b) => b[1] - a[1]).slice(0, maxCandidates).map(([j, shared]) => ({ j, shared }));
-  }
-};
-
-// src/detector.ts
-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 && block.content && block.content.trim().length > 0
-    ).map((block) => ({
-      ...block,
-      file: file.file,
-      normalized: normalizeCode(block.content),
-      tokenCost: block.content ? (0, import_core2.estimateTokens)(block.content) : 0
-    }))
-  );
-  const pythonFiles = files.filter((f) => f.file.endsWith(".py"));
-  if (pythonFiles.length > 0) {
-    const { extractPythonPatterns: extractPythonPatterns2 } = await Promise.resolve().then(() => (init_python_extractor(), python_extractor_exports));
-    const pythonPatterns = await extractPythonPatterns2(
-      pythonFiles.map((f) => f.file)
-    );
+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;
+}
+async function detectDuplicatePatterns(fileContents, options) {
+  const { minSimilarity, minLines, streamResults } = options;
+  const allBlocks = [];
+  for (const { file, content } of fileContents) {
+    const blocks = extractBlocks(file, content);
     allBlocks.push(
-      ...pythonPatterns.map((p) => ({
-        content: p.code,
-        startLine: p.startLine,
-        endLine: p.endLine,
-        file: p.file,
-        normalized: normalizeCode(p.code),
-        patternType: p.type,
-        tokenCost: p.code ? (0, import_core2.estimateTokens)(p.code) : 0,
-        linesOfCode: p.endLine - p.startLine + 1
-      }))
+      ...blocks.filter((b) => b.endLine - b.startLine + 1 >= minLines)
     );
   }
-  const blockTokens = allBlocks.map((b) => tokenize(b.normalized));
-  const engine = approx ? new ApproxEngine(allBlocks, blockTokens) : null;
-  let comparisonsProcessed = 0;
-  const startTime = Date.now();
+  const duplicates = [];
   for (let i = 0; i < allBlocks.length; i++) {
-    if (maxComparisons && comparisonsProcessed >= maxComparisons) break;
-    if (i % batchSize === 0 && i > 0) {
-      if (options.onProgress) {
-        options.onProgress(i, allBlocks.length, "Analyzing patterns");
-      } else {
-        const elapsed = (Date.now() - startTime) / 1e3;
-        console.log(
-          `   Processed ${i}/${allBlocks.length} blocks (${elapsed.toFixed(1)}s, ${duplicates.length} duplicates)`
-        );
-      }
-      await new Promise((r) => setImmediate((resolve) => r(resolve)));
-    }
-    const block1 = allBlocks[i];
-    const candidates = engine ? engine.findCandidates(i, minSharedTokens, maxCandidatesPerBlock) : allBlocks.slice(i + 1).map((_, idx) => ({ j: i + 1 + idx, shared: 0 }));
-    for (const { j } of candidates) {
-      if (!approx && comparisonsProcessed >= maxComparisons) break;
-      comparisonsProcessed++;
-      const block2 = allBlocks[j];
-      if (block1.file === block2.file) continue;
-      const sim = jaccardSimilarity(blockTokens[i], blockTokens[j]);
+    for (let j = i + 1; j < allBlocks.length; j++) {
+      const b1 = allBlocks[i];
+      const b2 = allBlocks[j];
+      if (b1.file === b2.file) continue;
+      const norm1 = normalizeCode(b1.code);
+      const norm2 = normalizeCode(b2.code);
+      const sim = calculateSimilarity(norm1, norm2);
       if (sim >= minSimilarity) {
-        const severity = calculateSeverity(
-          block1.file,
-          block2.file,
-          block1.content,
+        const { severity, reason, suggestion, matchedRule } = calculateSeverity(
+          b1.file,
+          b2.file,
+          b1.code,
           sim,
-          block1.linesOfCode
+          b1.endLine - b1.startLine + 1
         );
         const dup = {
-          file1: block1.file,
-          file2: block2.file,
-          line1: block1.startLine,
-          line2: block2.startLine,
-          endLine1: block1.endLine,
-          endLine2: block2.endLine,
+          file1: b1.file,
+          line1: b1.startLine,
+          endLine1: b1.endLine,
+          file2: b2.file,
+          line2: b2.startLine,
+          endLine2: b2.endLine,
+          code1: b1.code,
+          code2: b2.code,
           similarity: sim,
-          snippet: block1.content.substring(0, 200),
-          patternType: block1.patternType,
-          tokenCost: block1.tokenCost,
-          linesOfCode: block1.linesOfCode,
-          severity: severity.severity,
-          reason: severity.reason,
-          suggestion: severity.suggestion
+          patternType: b1.patternType,
+          tokenCost: b1.tokens + b2.tokens,
+          severity,
+          reason,
+          suggestion,
+          matchedRule
         };
         duplicates.push(dup);
         if (streamResults)
@@ -605,281 +329,138 @@ async function detectDuplicatePatterns(files, options) {
       }
     }
   }
-  return duplicates;
+  return duplicates.sort((a, b) => b.similarity - a.similarity);
 }
 
 // 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;
+var import_core3 = require("@aiready/core");
+var import_path = __toESM(require("path"));
+function getSeverityLevel(s) {
+  if (s === import_core3.Severity.Critical || s === "critical") return 4;
+  if (s === import_core3.Severity.Major || s === "major") return 3;
+  if (s === import_core3.Severity.Minor || s === "minor") return 2;
+  if (s === import_core3.Severity.Info || s === "info") return 1;
+  return 0;
 }
 function groupDuplicatesByFilePair(duplicates) {
   const groups = /* @__PURE__ */ new Map();
   for (const dup of duplicates) {
-    const key = normalizeFilePair(dup.file1, dup.file2);
+    const files = [dup.file1, dup.file2].sort();
+    const key = files.join("::");
     if (!groups.has(key)) {
-      groups.set(key, []);
+      groups.set(key, {
+        filePair: key,
+        severity: dup.severity,
+        occurrences: 0,
+        totalTokenCost: 0,
+        averageSimilarity: 0,
+        patternTypes: /* @__PURE__ */ new Set(),
+        lineRanges: []
+      });
     }
-    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
+    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 }
     });
-  }
-  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);
+    const currentSev = dup.severity;
+    if (getSeverityLevel(currentSev) > getSeverityLevel(group.severity)) {
+      group.severity = currentSev;
     }
   }
-  return result;
+  return Array.from(groups.values()).map((g) => ({
+    ...g,
+    averageSimilarity: g.averageSimilarity / g.occurrences
+  }));
 }
 function createRefactorClusters(duplicates) {
-  const clusters = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
   for (const dup of duplicates) {
-    const clusterId = identifyCluster(dup);
-    if (!clusters.has(clusterId)) {
-      clusters.set(clusterId, []);
+    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);
+        }
+      }
     }
-    clusters.get(clusterId).push(dup);
+    components.push(component);
   }
-  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,
+  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,
-      duplicateCount: clusterDups.length,
-      suggestion: clusterInfo.suggestion,
-      reason: clusterInfo.reason
+      averageSimilarity: avgSimilarity,
+      reason,
+      suggestion
     });
   }
-  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;
+  return clusters;
 }
-function getMostCommonPatternType(duplicates) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const dup of duplicates) {
-    counts.set(dup.patternType, (counts.get(dup.patternType) || 0) + 1);
+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 = import_path.default.dirname(first).split(import_path.default.sep).pop();
+  if (dirName && dirName !== "." && dirName !== "..") {
+    return `${dirName.charAt(0).toUpperCase() + dirName.slice(1)} Domain Group`;
   }
-  let mostCommon = "unknown";
-  let maxCount = 0;
-  for (const [type, count] of counts.entries()) {
-    if (count > maxCount) {
-      maxCount = count;
-      mostCommon = type;
-    }
-  }
-  return mostCommon;
+  return "Shared Pattern Group";
 }
-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) {
+function filterClustersByImpact(clusters, minTokenCost = 1e3, minFiles = 3) {
   return clusters.filter(
-    (cluster) => cluster.totalTokenCost >= minTokenCost || cluster.files.length >= minFileCount
+    (c) => c.totalTokenCost >= minTokenCost && c.files.length >= minFiles
   );
 }
 
 // src/scoring.ts
-var import_core3 = require("@aiready/core");
+var import_core4 = require("@aiready/core");
 function calculatePatternScore(duplicates, totalFilesAnalyzed, costConfig) {
   const totalDuplicates = duplicates.length;
   const totalTokenCost = duplicates.reduce((sum, d) => sum + d.tokenCost, 0);
@@ -957,12 +538,12 @@ function calculatePatternScore(duplicates, totalFilesAnalyzed, costConfig) {
       priority: totalTokenCost > 1e4 ? "high" : "medium"
     });
   }
-  const cfg = { ...import_core3.DEFAULT_COST_CONFIG, ...costConfig };
-  const estimatedMonthlyCost = (0, import_core3.calculateMonthlyCost)(totalTokenCost, cfg);
+  const cfg = { ...import_core4.DEFAULT_COST_CONFIG, ...costConfig };
+  const estimatedMonthlyCost = (0, import_core4.calculateMonthlyCost)(totalTokenCost, cfg);
   const issues = duplicates.map((d) => ({
     severity: d.severity === "critical" ? "critical" : d.severity === "major" ? "major" : "minor"
   }));
-  const productivityImpact = (0, import_core3.calculateProductivityImpact)(issues);
+  const productivityImpact = (0, import_core4.calculateProductivityImpact)(issues);
   return {
     toolName: "pattern-detect",
     score: finalScore,
@@ -1098,7 +679,7 @@ async function analyzePatterns(options) {
     const batchContents = await Promise.all(
       batch.map(async (file) => ({
         file,
-        content: await (0, import_core4.readFileContent)(file)
+        content: await (0, import_core5.readFileContent)(file)
       }))
     );
     fileContents.push(...batchContents);
@@ -1119,9 +700,9 @@ async function analyzePatterns(options) {
     );
     const issues = fileDuplicates.map((dup) => {
       const otherFile = dup.file1 === file ? dup.file2 : dup.file1;
-      const severity2 = dup.similarity > 0.95 ? "critical" : dup.similarity > 0.9 ? "major" : "minor";
+      const severity2 = dup.similarity > 0.95 ? import_core5.Severity.Critical : dup.similarity > 0.9 ? import_core5.Severity.Major : import_core5.Severity.Minor;
       return {
-        type: "duplicate-pattern",
+        type: import_core5.IssueType.DuplicatePattern,
         severity: severity2,
         message: `${dup.patternType} pattern ${Math.round(dup.similarity * 100)}% similar to ${otherFile} (${dup.tokenCost} tokens wasted)`,
         location: {
@@ -1134,11 +715,11 @@ async function analyzePatterns(options) {
     let filteredIssues = issues;
     if (severity !== "all") {
       const severityMap = {
-        critical: ["critical"],
-        high: ["critical", "major"],
-        medium: ["critical", "major", "minor"]
+        critical: [import_core5.Severity.Critical],
+        high: [import_core5.Severity.Critical, import_core5.Severity.Major],
+        medium: [import_core5.Severity.Critical, import_core5.Severity.Major, import_core5.Severity.Minor]
       };
-      const allowedSeverities = severityMap[severity] || ["critical", "major", "minor"];
+      const allowedSeverities = severityMap[severity] || [import_core5.Severity.Critical, import_core5.Severity.Major, import_core5.Severity.Minor];
       filteredIssues = issues.filter(
         (issue) => allowedSeverities.includes(issue.severity)
       );
@@ -1228,6 +809,7 @@ function generateSummary(results) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Severity,
   analyzePatterns,
   calculatePatternScore,
   calculateSeverity,