@aiready/pattern-detect 0.17.8 → 0.17.12

package/dist/analyzer-entry.js

@@ -1,693 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/analyzer-entry.ts
-var analyzer_entry_exports = {};
-__export(analyzer_entry_exports, {
-  analyzePatterns: () => analyzePatterns,
-  generateSummary: () => generateSummary,
-  getSmartDefaults: () => getSmartDefaults
-});
-module.exports = __toCommonJS(analyzer_entry_exports);
-
-// src/analyzer.ts
-var import_core4 = 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
-  {
-    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: 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"
-  },
-  // 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: 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"
-  },
-  // 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: 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"
-  },
-  // 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: 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"
-  },
-  // 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: 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"
-  },
-  // 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: import_core.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: import_core.Severity.Info,
-    reason: "Mock data duplication is expected for comprehensive test coverage",
-    suggestion: "Consider shared factories only for complex mock generation"
-  },
-  // Tool Implementations - Structural Boilerplate
-  {
-    name: "tool-implementations",
-    detect: (file, code) => {
-      const isToolFile = file.includes("/tools/") || file.endsWith(".tool.ts") || code.includes("toolDefinitions");
-      const hasToolStructure = code.includes("execute") && (code.includes("try") || code.includes("catch"));
-      return isToolFile && hasToolStructure;
-    },
-    severity: import_core.Severity.Info,
-    reason: "Tool implementations share structural boilerplate but have distinct business logic",
-    suggestion: "Tool duplication is acceptable for boilerplate interface wrappers"
-  }
-];
-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: 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: import_core.Severity.Major,
-      reason: "Nearly identical code should be consolidated",
-      suggestion: "Move to shared utility file"
-    };
-  } else if (similarity >= 0.85) {
-    return {
-      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: import_core.Severity.Minor,
-      reason: "Moderate similarity detected",
-      suggestion: "Consider extracting shared patterns if code evolves together"
-    };
-  } else {
-    return {
-      severity: import_core.Severity.Minor,
-      reason: "Minor similarity detected",
-      suggestion: "Monitor but refactoring may not be worthwhile"
-    };
-  }
-}
-
-// 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(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-  }
-  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) {
-  return (0, import_core2.extractCodeBlocks)(file, content);
-}
-function calculateSimilarity(a, b) {
-  return (0, import_core2.calculateStringSimilarity)(a, b);
-}
-function calculateConfidence(similarity, tokens, lines) {
-  return (0, import_core2.calculateHeuristicConfidence)(similarity, tokens, lines);
-}
-async function detectDuplicatePatterns(fileContents, options) {
-  const {
-    minSimilarity,
-    minLines,
-    streamResults,
-    onProgress,
-    excludePatterns = [],
-    confidenceThreshold = 0,
-    ignoreWhitelist = []
-  } = options;
-  const allBlocks = [];
-  const excludeRegexes = excludePatterns.map((p) => new RegExp(p, "i"));
-  for (const { file, content } of fileContents) {
-    const blocks = extractBlocks(file, content);
-    for (const b of blocks) {
-      if (b.endLine - b.startLine + 1 < minLines) continue;
-      const isExcluded = excludeRegexes.some((regex) => regex.test(b.code));
-      if (isExcluded) continue;
-      allBlocks.push(b);
-    }
-  }
-  const duplicates = [];
-  const totalBlocks = allBlocks.length;
-  let comparisons = 0;
-  const totalComparisons = totalBlocks * (totalBlocks - 1) / 2;
-  if (onProgress) {
-    onProgress(
-      0,
-      totalComparisons,
-      `Starting duplicate detection on ${totalBlocks} blocks...`
-    );
-  }
-  for (let i = 0; i < allBlocks.length; i++) {
-    if (i % 50 === 0 && i > 0) {
-      await new Promise((resolve) => setImmediate(resolve));
-      if (onProgress) {
-        onProgress(
-          comparisons,
-          totalComparisons,
-          `Analyzing blocks (${i}/${totalBlocks})...`
-        );
-      }
-    }
-    const b1 = allBlocks[i];
-    const isPython1 = b1.file.toLowerCase().endsWith(".py");
-    const norm1 = normalizeCode(b1.code, isPython1);
-    for (let j = i + 1; j < allBlocks.length; j++) {
-      comparisons++;
-      const b2 = allBlocks[j];
-      if (b1.file === b2.file) continue;
-      const isWhitelisted = ignoreWhitelist.some((pattern) => {
-        return b1.file.includes(pattern) && b2.file.includes(pattern) || pattern === `${b1.file}::${b2.file}` || pattern === `${b2.file}::${b1.file}`;
-      });
-      if (isWhitelisted) continue;
-      const isPython2 = b2.file.toLowerCase().endsWith(".py");
-      const norm2 = normalizeCode(b2.code, isPython2);
-      const sim = calculateSimilarity(norm1, norm2);
-      if (sim >= minSimilarity) {
-        const confidence = calculateConfidence(
-          sim,
-          b1.tokens,
-          b1.endLine - b1.startLine + 1
-        );
-        if (confidence < confidenceThreshold) continue;
-        const { severity, reason, suggestion, matchedRule } = calculateSeverity(
-          b1.file,
-          b2.file,
-          b1.code,
-          sim,
-          b1.endLine - b1.startLine + 1
-        );
-        const dup = {
-          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,
-          confidence,
-          patternType: b1.patternType,
-          tokenCost: b1.tokens + b2.tokens,
-          severity,
-          reason,
-          suggestion,
-          matchedRule
-        };
-        duplicates.push(dup);
-        if (streamResults)
-          console.log(
-            `[DUPLICATE] ${dup.file1}:${dup.line1} <-> ${dup.file2}:${dup.line2} (${Math.round(sim * 100)}%, conf: ${Math.round(confidence * 100)}%)`
-          );
-      }
-    }
-  }
-  if (onProgress) {
-    onProgress(
-      totalComparisons,
-      totalComparisons,
-      `Duplicate detection complete. Found ${duplicates.length} patterns.`
-    );
-  }
-  return duplicates.sort((a, b) => b.similarity - a.similarity);
-}
-
-// src/grouping.ts
-var import_core3 = require("@aiready/core");
-var import_path = __toESM(require("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 ((0, import_core3.getSeverityLevel)(currentSev) > (0, import_core3.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 = 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`;
-  }
-  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
-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 (0, import_core4.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 (0, import_core4.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 (0, import_core4.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 ? import_core4.Severity.Critical : dup.similarity > 0.9 ? import_core4.Severity.Major : import_core4.Severity.Minor;
-      return {
-        type: import_core4.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: [import_core4.Severity.Critical],
-        high: [import_core4.Severity.Critical, import_core4.Severity.Major],
-        medium: [import_core4.Severity.Critical, import_core4.Severity.Major, import_core4.Severity.Minor]
-      };
-      const allowedSeverities = severityMap[severity] || [import_core4.Severity.Critical, import_core4.Severity.Major, import_core4.Severity.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
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  analyzePatterns,
-  generateSummary,
-  getSmartDefaults
-});

package/dist/analyzer-entry.mjs

@@ -1,12 +0,0 @@
-import {
-  analyzePatterns,
-  generateSummary,
-  getSmartDefaults
-} from "./chunk-DNZS4ESD.mjs";
-import "./chunk-VGMM3L3O.mjs";
-import "./chunk-I6ETJC7L.mjs";
-export {
-  analyzePatterns,
-  generateSummary,
-  getSmartDefaults
-};