@aiready/pattern-detect 0.17.8 → 0.17.12

package/dist/chunk-XNPID6FU.mjs

@@ -1,391 +0,0 @@
-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
-};