@aiready/pattern-detect 0.16.19 → 0.16.21

package/dist/chunk-XNPID6FU.mjs

@@ -0,0 +1,391 @@
+import {
+  detectDuplicatePatterns
+} from "./chunk-CMWW24HW.mjs";
+import {
+  calculateSeverity
+} from "./chunk-I6ETJC7L.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.85, 0.5 + estimatedBlocks / 5e3 * 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

@@ -192,144 +192,27 @@ function filterBySeverity(duplicates, minSeverity) {
   });
 }
 
-// src/detector.ts
+// src/core/normalizer.ts
 function normalizeCode(code, isPython = false) {
+  if (!code) return "";
   let normalized = code;
   if (isPython) {
     normalized = normalized.replace(/#.*/g, "");
   } else {
-    normalized = normalized.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    normalized = normalized.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   }
-  return normalized.replace(/['"`]/g, '"').replace(/\s+/g, " ").trim().toLowerCase();
+  return normalized.replace(/"[^"]*"/g, '"STR"').replace(/'[^']*'/g, "'STR'").replace(/`[^`]*`/g, "`STR`").replace(/\b\d+\b/g, "NUM").replace(/\s+/g, " ").trim().toLowerCase();
 }
+
+// src/detector.ts
 function extractBlocks(file, content) {
-  const isPython = file.toLowerCase().endsWith(".py");
-  if (isPython) {
-    return extractBlocksPython(file, content);
-  }
-  const blocks = [];
-  const lines = content.split("\n");
-  const blockRegex = /^\s*(?:export\s+)?(?:async\s+)?(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|readonly\s+|virtual\s+|abstract\s+|override\s+)*(function|class|interface|type|enum|record|struct|void|func|[a-zA-Z0-9_<>[]]+)\s+([a-zA-Z0-9_]+)(?:\s*\(|(?:\s+extends|\s+implements|\s+where)?\s*\{)|^\s*(?:export\s+)?const\s+([a-zA-Z0-9_]+)\s*=\s*[a-zA-Z0-9_.]+\.object\(|^\s*(app\.(?:get|post|put|delete|patch|use))\(/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const startLine = content.substring(0, match.index).split("\n").length;
-    let type;
-    let name;
-    if (match[1]) {
-      type = match[1];
-      name = match[2];
-    } else if (match[3]) {
-      type = "const";
-      name = match[3];
-    } else {
-      type = "handler";
-      name = match[4];
-    }
-    let endLine = -1;
-    let openBraces = 0;
-    let foundStart = false;
-    for (let i = match.index; i < content.length; i++) {
-      if (content[i] === "{") {
-        openBraces++;
-        foundStart = true;
-      } else if (content[i] === "}") {
-        openBraces--;
-      }
-      if (foundStart && openBraces === 0) {
-        endLine = content.substring(0, i + 1).split("\n").length;
-        break;
-      }
-    }
-    if (endLine === -1) {
-      const remaining = content.slice(match.index);
-      const nextLineMatch = remaining.indexOf("\n");
-      if (nextLineMatch !== -1) {
-        endLine = startLine;
-      } else {
-        endLine = lines.length;
-      }
-    }
-    endLine = Math.max(startLine, endLine);
-    const blockCode = lines.slice(startLine - 1, endLine).join("\n");
-    const tokens = (0, import_core2.estimateTokens)(blockCode);
-    blocks.push({
-      file,
-      startLine,
-      endLine,
-      code: blockCode,
-      tokens,
-      patternType: inferPatternType(type, name)
-    });
-  }
-  return blocks;
-}
-function extractBlocksPython(file, content) {
-  const blocks = [];
-  const lines = content.split("\n");
-  const blockRegex = /^\s*(?:async\s+)?(def|class)\s+([a-zA-Z0-9_]+)/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const startLinePos = content.substring(0, match.index).split("\n").length;
-    const startLineIdx = startLinePos - 1;
-    const initialIndent = lines[startLineIdx].search(/\S/);
-    let endLineIdx = startLineIdx;
-    for (let i = startLineIdx + 1; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.trim().length === 0) {
-        endLineIdx = i;
-        continue;
-      }
-      const currentIndent = line.search(/\S/);
-      if (currentIndent <= initialIndent) {
-        break;
-      }
-      endLineIdx = i;
-    }
-    while (endLineIdx > startLineIdx && lines[endLineIdx].trim().length === 0) {
-      endLineIdx--;
-    }
-    const blockCode = lines.slice(startLineIdx, endLineIdx + 1).join("\n");
-    const tokens = (0, import_core2.estimateTokens)(blockCode);
-    blocks.push({
-      file,
-      startLine: startLinePos,
-      endLine: endLineIdx + 1,
-      code: blockCode,
-      tokens,
-      patternType: inferPatternType(match[1], match[2])
-    });
-  }
-  return blocks;
-}
-function inferPatternType(keyword, name) {
-  const n = name.toLowerCase();
-  if (keyword === "handler" || n.includes("handler") || n.includes("controller") || n.startsWith("app.")) {
-    return "api-handler";
-  }
-  if (n.includes("validate") || n.includes("schema")) return "validator";
-  if (n.includes("util") || n.includes("helper")) return "utility";
-  if (keyword === "class") return "class-method";
-  if (n.match(/^[A-Z]/)) return "component";
-  if (keyword === "function") return "function";
-  return "unknown";
+  return (0, import_core2.extractCodeBlocks)(file, content);
 }
 function calculateSimilarity(a, b) {
-  if (a === b) return 1;
-  const tokensA = a.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 0);
-  const tokensB = b.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 0);
-  if (tokensA.length === 0 || tokensB.length === 0) return 0;
-  const setA = new Set(tokensA);
-  const setB = new Set(tokensB);
-  const intersection = new Set([...setA].filter((x) => setB.has(x)));
-  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
-  return intersection.size / union.size;
+  return (0, import_core2.calculateStringSimilarity)(a, b);
 }
 function calculateConfidence(similarity, tokens, lines) {
-  let confidence = similarity;
-  if (lines > 20) confidence += 0.05;
-  if (tokens > 200) confidence += 0.05;
-  if (lines < 5) confidence -= 0.1;
-  return Math.max(0, Math.min(1, confidence));
+  return (0, import_core2.calculateHeuristicConfidence)(similarity, tokens, lines);
 }
 async function detectDuplicatePatterns(fileContents, options) {
   const {
@@ -987,10 +870,14 @@ function generateHTMLReport(results, summary) {
   const { metadata } = data;
   const s = data.summary;
   const head = (0, import_core8.generateReportHead)("AIReady - Pattern Detection Report");
-  const scoreCard = `<div class="stat-card" style="margin-bottom: 2rem;">
-    <div class="stat-label">AI Ready Score (Deduplication)</div>
-    <div class="stat-value">${Math.max(0, 100 - Math.round((s.duplicates?.length || 0) / (s.totalFiles || 1) * 20))}%</div>
-  </div>`;
+  const score = Math.max(
+    0,
+    100 - Math.round((s.duplicates?.length || 0) / (s.totalFiles || 1) * 20)
+  );
+  const scoreCard = (0, import_core8.generateScoreCard)(
+    `${score}%`,
+    "AI Ready Score (Deduplication)"
+  );
   const stats = (0, import_core8.generateStatCards)([
     { value: s.totalFiles, label: "Files Analyzed" },
     { value: s.duplicates?.length || 0, label: "Duplicate Clusters" },
@@ -1189,12 +1076,7 @@ async function patternActionHandler(directory, options) {
 \u2713 HTML report saved to ${outputPath}`));
     return;
   }
-  const terminalWidth = process.stdout.columns || 80;
-  const dividerWidth = Math.min(60, terminalWidth - 2);
-  const divider = "\u2501".repeat(dividerWidth);
-  console.log(import_chalk.default.cyan(divider));
-  console.log(import_chalk.default.bold.white("  PATTERN ANALYSIS SUMMARY"));
-  console.log(import_chalk.default.cyan(divider) + "\n");
+  (0, import_core9.printTerminalHeader)("PATTERN ANALYSIS SUMMARY");
   console.log(import_chalk.default.white(`\u{1F4C1} Files analyzed: ${import_chalk.default.bold(results.length)}`));
   console.log(
     import_chalk.default.yellow(
@@ -1209,9 +1091,9 @@ async function patternActionHandler(directory, options) {
   console.log(import_chalk.default.gray(`\u23F1  Analysis time: ${import_chalk.default.bold(elapsedTime + "s")}`));
   const sortedTypes = Object.entries(summary.patternsByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a);
   if (sortedTypes.length > 0) {
-    console.log(import_chalk.default.cyan("\n" + divider));
+    console.log("\n" + (0, import_core9.getTerminalDivider)());
     console.log(import_chalk.default.bold.white("  PATTERNS BY TYPE"));
-    console.log(import_chalk.default.cyan(divider) + "\n");
+    console.log((0, import_core9.getTerminalDivider)() + "\n");
     sortedTypes.forEach(([type, count]) => {
       const icon = getPatternIcon(type);
       console.log(
@@ -1220,11 +1102,11 @@ async function patternActionHandler(directory, options) {
     });
   }
   if (!finalOptions.showRawDuplicates && groups && groups.length > 0) {
-    console.log(import_chalk.default.cyan("\n" + divider));
+    console.log("\n" + (0, import_core9.getTerminalDivider)());
     console.log(
       import_chalk.default.bold.white(`  \u{1F4E6} DUPLICATE GROUPS (${groups.length} file pairs)`)
     );
-    console.log(import_chalk.default.cyan(divider) + "\n");
+    console.log((0, import_core9.getTerminalDivider)() + "\n");
     const topGroups = groups.sort((a, b) => {
       const bVal = (0, import_core9.getSeverityValue)(b.severity);
       const aVal = (0, import_core9.getSeverityValue)(a.severity);
@@ -1265,11 +1147,11 @@ async function patternActionHandler(directory, options) {
     }
   }
   if (!finalOptions.showRawDuplicates && clusters && clusters.length > 0) {
-    console.log(import_chalk.default.cyan("\n" + divider));
+    console.log("\n" + (0, import_core9.getTerminalDivider)());
     console.log(
       import_chalk.default.bold.white(`  \u{1F3AF} REFACTOR CLUSTERS (${clusters.length} patterns)`)
     );
-    console.log(import_chalk.default.cyan(divider) + "\n");
+    console.log((0, import_core9.getTerminalDivider)() + "\n");
     clusters.sort((a, b) => b.totalTokenCost - a.totalTokenCost).forEach((cluster, idx) => {
       const severityBadge = (0, import_core9.getSeverityBadge)(cluster.severity);
       console.log(`${idx + 1}. ${severityBadge} ${import_chalk.default.bold(cluster.name)}`);
@@ -1297,9 +1179,9 @@ async function patternActionHandler(directory, options) {
     });
   }
   if (totalIssues > 0 && (finalOptions.showRawDuplicates || !groups || groups.length === 0)) {
-    console.log(import_chalk.default.cyan("\n" + divider));
+    console.log("\n" + (0, import_core9.getTerminalDivider)());
     console.log(import_chalk.default.bold.white("  TOP DUPLICATE PATTERNS"));
-    console.log(import_chalk.default.cyan(divider) + "\n");
+    console.log((0, import_core9.getTerminalDivider)() + "\n");
     const topDuplicates = filteredDuplicates.sort((a, b) => {
       const bVal = (0, import_core9.getSeverityValue)(b.severity);
       const aVal = (0, import_core9.getSeverityValue)(a.severity);
@@ -1346,9 +1228,9 @@ async function patternActionHandler(directory, options) {
     (issue) => (0, import_core9.getSeverityValue)(issue.severity) === 4
   );
   if (criticalIssues.length > 0) {
-    console.log(import_chalk.default.cyan(divider));
+    console.log((0, import_core9.getTerminalDivider)());
     console.log(import_chalk.default.bold.white("  CRITICAL ISSUES (>95% similar)"));
-    console.log(import_chalk.default.cyan(divider) + "\n");
+    console.log((0, import_core9.getTerminalDivider)() + "\n");
     criticalIssues.slice(0, 5).forEach((issue) => {
       console.log(
         import_chalk.default.red("\u25CF ") + import_chalk.default.white(`${issue.file}:${issue.location.line}`)
@@ -1385,7 +1267,7 @@ async function patternActionHandler(directory, options) {
     );
     console.log("");
   }
-  console.log(import_chalk.default.cyan(divider));
+  console.log((0, import_core9.getTerminalDivider)());
   if (totalIssues > 0) {
     console.log(
       import_chalk.default.white(