uilint-duplicates 0.2.122 → 0.2.123

package/dist/{chunk-54SLRAFO.js → chunk-BAZQUJDS.js}

@@ -1670,13 +1670,189 @@ function sortDuplicateGroups(groups) {
   });
 }
 
+// src/detection/structural-scorer.ts
+var DEFAULT_STRUCTURAL_WEIGHTS = {
+  props: 0.25,
+  jsx: 0.35,
+  hooks: 0.25,
+  size: 0.15
+};
+function jaccard(a, b) {
+  if (a.length === 0 && b.length === 0) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const setA = new Set(a.map((s) => s.toLowerCase()));
+  const setB = new Set(b.map((s) => s.toLowerCase()));
+  const intersection = new Set([...setA].filter((x) => setB.has(x)));
+  const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+  return intersection.size / union.size;
+}
+function calculateSizeRatio2(linesA, linesB) {
+  if (linesA === 0 && linesB === 0) return 1;
+  if (linesA === 0 || linesB === 0) return 0;
+  const min = Math.min(linesA, linesB);
+  const max = Math.max(linesA, linesB);
+  return min / max;
+}
+function extractFeatures(storedMeta) {
+  const meta = storedMeta.metadata ?? {};
+  return {
+    props: meta.props ?? [],
+    jsxElements: meta.jsxElements ?? [],
+    hooks: meta.hooks ?? [],
+    lines: (storedMeta.endLine ?? 0) - (storedMeta.startLine ?? 0) + 1
+  };
+}
+function calculateStructuralSimilarity(a, b, weights = DEFAULT_STRUCTURAL_WEIGHTS) {
+  const featuresA = extractFeatures(a);
+  const featuresB = extractFeatures(b);
+  const propsOverlap = jaccard(featuresA.props, featuresB.props);
+  const jsxOverlap = jaccard(featuresA.jsxElements, featuresB.jsxElements);
+  const hooksOverlap = jaccard(featuresA.hooks, featuresB.hooks);
+  const sizeRatio = calculateSizeRatio2(featuresA.lines, featuresB.lines);
+  const combined = propsOverlap * weights.props + jsxOverlap * weights.jsx + hooksOverlap * weights.hooks + sizeRatio * weights.size;
+  return {
+    propsOverlap,
+    jsxOverlap,
+    hooksOverlap,
+    sizeRatio,
+    combined
+  };
+}
+function hasHighStructuralSimilarity(a, b, threshold = 0.5) {
+  const score = calculateStructuralSimilarity(a, b);
+  return score.combined >= threshold;
+}
+function findStructurallySimilar(target, candidates, threshold = 0.5, limit = 10) {
+  const results = [];
+  for (const candidate of candidates) {
+    if (candidate.filePath === target.filePath && candidate.startLine === target.startLine) {
+      continue;
+    }
+    const score = calculateStructuralSimilarity(target, candidate);
+    if (score.combined >= threshold) {
+      results.push({ metadata: candidate, score });
+    }
+  }
+  results.sort((a, b) => b.score.combined - a.score.combined);
+  return results.slice(0, limit);
+}
+
+// src/detection/confidence.ts
+var DEFAULT_CONFIDENCE_CONFIG = {
+  highThreshold: 0.9,
+  mediumThreshold: 0.75,
+  lowThreshold: 0.6
+};
+function getConfidenceLevel(score, config = DEFAULT_CONFIDENCE_CONFIG) {
+  if (score >= config.highThreshold) return "high";
+  if (score >= config.mediumThreshold) return "medium";
+  return "low";
+}
+function meetsMinimumThreshold(score, config = DEFAULT_CONFIDENCE_CONFIG) {
+  return score >= config.lowThreshold;
+}
+function getConfidenceResult(score, config = DEFAULT_CONFIDENCE_CONFIG) {
+  const level = getConfidenceLevel(score, config);
+  switch (level) {
+    case "high":
+      return {
+        level,
+        score,
+        description: "High confidence duplicate - likely copy-paste or near-identical implementation",
+        action: "Strongly recommend consolidating into a single reusable component/function",
+        color: "red"
+      };
+    case "medium":
+      return {
+        level,
+        score,
+        description: "Medium confidence - semantically similar code with different implementation details",
+        action: "Review for potential consolidation or shared abstraction",
+        color: "yellow"
+      };
+    case "low":
+      return {
+        level,
+        score,
+        description: "Low confidence - possibly related patterns or partial structural overlap",
+        action: "Optional review - differences may be intentional",
+        color: "green"
+      };
+  }
+}
+function getConfidenceEmoji(level) {
+  switch (level) {
+    case "high":
+      return "\u{1F534}";
+    case "medium":
+      return "\u{1F7E1}";
+    case "low":
+      return "\u{1F7E2}";
+  }
+}
+function getConfidenceAnsiColor(level) {
+  switch (level) {
+    case "high":
+      return "\x1B[31m";
+    // Red
+    case "medium":
+      return "\x1B[33m";
+    // Yellow
+    case "low":
+      return "\x1B[32m";
+  }
+}
+function formatConfidence(result, useEmoji = true, useColor = false) {
+  const percent = Math.round(result.score * 100);
+  const emoji = useEmoji ? getConfidenceEmoji(result.level) + " " : "";
+  const colorStart = useColor ? getConfidenceAnsiColor(result.level) : "";
+  const colorEnd = useColor ? "\x1B[0m" : "";
+  return `${emoji}${colorStart}${percent}% similarity (${result.level} confidence)${colorEnd}`;
+}
+function formatConfidenceVerbose(result) {
+  const lines = [
+    formatConfidence(result),
+    `  ${result.description}`,
+    `  \u2192 ${result.action}`
+  ];
+  return lines.join("\n");
+}
+function compareConfidenceLevels(a, b) {
+  const order = { high: 3, medium: 2, low: 1 };
+  return order[a] - order[b];
+}
+function filterByConfidence(results, minLevel, config = DEFAULT_CONFIDENCE_CONFIG) {
+  const minThreshold = minLevel === "high" ? config.highThreshold : minLevel === "medium" ? config.mediumThreshold : config.lowThreshold;
+  return results.filter((r) => r.score >= minThreshold);
+}
+
 // src/detection/duplicate-finder.ts
+function calculateCombinedSimilarity(semanticScore, metadataA, metadataB) {
+  const structuralResult = calculateStructuralSimilarity(metadataA, metadataB);
+  const structural = structuralResult.combined;
+  const combined = semanticScore * 0.6 + structural * 0.4;
+  return { combined, structural };
+}
+function getConfidenceThreshold(level) {
+  switch (level) {
+    case "high":
+      return 0.9;
+    case "medium":
+      return 0.75;
+    case "low":
+      return 0.6;
+  }
+}
 function findDuplicateGroups(vectorStore, metadataStore, options = {}) {
   const {
-    threshold = 0.85,
+    threshold = 0.75,
+    // Lowered from 0.85
     minGroupSize = 2,
     kind,
-    excludePaths = []
+    excludePaths = [],
+    includeSameFile = true,
+    useStructuralBoost = true,
+    confidenceFilter
   } = options;
   const groups = [];
   const processed = /* @__PURE__ */ new Set();
@@ -1693,7 +1869,8 @@ function findDuplicateGroups(vectorStore, metadataStore, options = {}) {
     if (processed.has(id)) continue;
     const vector = vectorStore.get(id);
     if (!vector) continue;
-    const similar = vectorStore.findSimilar(vector, 50, threshold);
+    const searchThreshold = useStructuralBoost ? threshold * 0.8 : threshold;
+    const similar = vectorStore.findSimilar(vector, 50, searchThreshold);
     let candidates = similar.filter((s) => {
       if (s.id === id) return false;
       if (processed.has(s.id)) return false;
@@ -1702,8 +1879,22 @@ function findDuplicateGroups(vectorStore, metadataStore, options = {}) {
       if (kind && candidateMeta.kind !== kind) return false;
       if (excludePaths.some((p) => candidateMeta.filePath.includes(p)))
         return false;
+      if (!includeSameFile && candidateMeta.filePath === metadata.filePath)
+        return false;
       return true;
     });
+    if (useStructuralBoost) {
+      candidates = candidates.map((c) => {
+        const candidateMeta = metadataStore.get(c.id);
+        if (!candidateMeta) return { ...c, combinedScore: c.score };
+        const { combined, structural } = calculateCombinedSimilarity(
+          c.score,
+          metadata,
+          candidateMeta
+        );
+        return { ...c, combinedScore: combined, structuralScore: structural };
+      }).filter((c) => (c.combinedScore ?? c.score) >= threshold).sort((a, b) => (b.combinedScore ?? b.score) - (a.combinedScore ?? a.score));
+    }
     if (!kind && candidates.length > 0) {
       const sameKindCandidates = candidates.filter((c) => {
         const meta = metadataStore.get(c.id);
@@ -1715,31 +1906,50 @@ function findDuplicateGroups(vectorStore, metadataStore, options = {}) {
     }
     if (candidates.length >= minGroupSize - 1) {
       const members = [
-        { id, metadata, score: 1 }
-        // First member (reference)
+        {
+          id,
+          metadata,
+          score: 1,
+          combinedScore: 1,
+          confidence: "high"
+        }
       ];
       const similarities = [];
       for (const candidate of candidates) {
         const candidateMeta = metadataStore.get(candidate.id);
         if (candidateMeta) {
+          const combinedScore = candidate.combinedScore ?? candidate.score;
+          const structuralScore = candidate.structuralScore;
+          const confidence = getConfidenceLevel(combinedScore);
           members.push({
             id: candidate.id,
             metadata: candidateMeta,
-            score: candidate.score
+            score: candidate.score,
+            combinedScore,
+            structuralScore,
+            confidence
           });
-          similarities.push(candidate.score);
+          similarities.push(combinedScore);
           processed.add(candidate.id);
         }
       }
       processed.add(id);
+      const avgSimilarity = calculateGroupAverageSimilarity(similarities);
+      const groupConfidence = getConfidenceLevel(avgSimilarity);
       groups.push({
         members,
-        avgSimilarity: calculateGroupAverageSimilarity(similarities),
-        kind: metadata.kind
+        avgSimilarity,
+        kind: metadata.kind,
+        confidence: groupConfidence
       });
     }
   }
-  return sortDuplicateGroups(groups);
+  let result = groups;
+  if (confidenceFilter) {
+    const minThreshold = getConfidenceThreshold(confidenceFilter);
+    result = groups.filter((g) => g.avgSimilarity >= minThreshold);
+  }
+  return sortDuplicateGroups(result);
 }
 function findSimilarToLocation(vectorStore, metadataStore, filePath, line, options = {}) {
   const { top = 10, threshold = 0.5 } = options;
@@ -1809,9 +2019,12 @@ async function findDuplicates(options = {}) {
   const vectorStore = indexer.getVectorStore();
   const metadataStore = indexer.getMetadataStore();
   const groups = findDuplicateGroups(vectorStore, metadataStore, {
-    threshold: options.threshold,
+    threshold: options.threshold ?? 0.75,
     minGroupSize: options.minGroupSize,
-    kind: options.kind
+    kind: options.kind,
+    confidenceFilter: options.confidenceLevel,
+    useStructuralBoost: options.useStructuralBoost ?? true,
+    includeSameFile: options.includeSameFile ?? true
   });
   return groups.map((group) => ({
     members: group.members.map((m) => ({
@@ -1823,7 +2036,8 @@ async function findDuplicates(options = {}) {
       score: m.score
     })),
     avgSimilarity: group.avgSimilarity,
-    kind: group.kind
+    kind: group.kind,
+    confidence: group.confidence
   }));
 }
 async function searchSimilar(query, options = {}) {
@@ -1912,6 +2126,373 @@ async function getIndexStats(path = process.cwd()) {
   };
 }
 
+// src/detection/normalizer.ts
+var DEFAULT_NORMALIZATION_OPTIONS = {
+  normalizeIdentifiers: false,
+  normalizeSemantics: true,
+  stripComments: true,
+  normalizeWhitespace: true
+};
+var SEMANTIC_EQUIVALENTS = [
+  // Size-related props
+  [/\b(size|dimension|scale|magnitude)\b/gi, "__SIZE__"],
+  // Variant-related props
+  [/\b(variant|type|kind|style|mode)\b/gi, "__VARIANT__"],
+  // Click/press handlers
+  [/\b(onClick|onPress|onTap|handleClick|handlePress|onSelect)\b/g, "__CLICK_HANDLER__"],
+  // Change handlers
+  [/\b(onChange|onInput|handleChange|handleInput)\b/g, "__CHANGE_HANDLER__"],
+  // Submit handlers
+  [/\b(onSubmit|handleSubmit)\b/g, "__SUBMIT_HANDLER__"],
+  // Loading states
+  [/\b(loading|isLoading|pending|isFetching|isBusy)\b/gi, "__LOADING__"],
+  // Error states
+  [/\b(error|err|errorMsg|errorMessage|failure)\b/gi, "__ERROR__"],
+  // Success states
+  [/\b(success|isSuccess|succeeded|done)\b/gi, "__SUCCESS__"],
+  // Data/items collections
+  [/\b(data|items|list|results|entries|records)\b/gi, "__DATA__"],
+  // Children/content slots
+  [/\b(children|content|body|slot|inner)\b/gi, "__CHILDREN__"],
+  // Label/title text
+  [/\b(label|title|heading|name|text)\b/gi, "__LABEL__"],
+  // Description/message
+  [/\b(description|message|subtitle|detail|info)\b/gi, "__DESCRIPTION__"],
+  // Value/amount
+  [/\b(value|amount|total|count|number)\b/gi, "__VALUE__"],
+  // Disabled state
+  [/\b(disabled|isDisabled|readonly|readOnly)\b/gi, "__DISABLED__"],
+  // Visible/shown state
+  [/\b(visible|isVisible|shown|isShown|open|isOpen)\b/gi, "__VISIBLE__"],
+  // Class names
+  [/\b(className|classes|style|styles)\b/gi, "__CLASSNAME__"]
+];
+function stripComments(code) {
+  let result = code.replace(/\/\/.*$/gm, "");
+  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  return result;
+}
+function normalizeWhitespace(code) {
+  return code.replace(/\s+/g, " ").replace(/\s*([{}\[\]();,:<>])\s*/g, "$1").trim();
+}
+function applySemanticNormalization(code) {
+  let result = code;
+  for (const [pattern, replacement] of SEMANTIC_EQUIVALENTS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function normalizeIdentifiersSimple(code) {
+  const identifierMap = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const identifierPattern = /\b([a-z_$][a-z0-9_$]*)\b/gi;
+  const preserveList = /* @__PURE__ */ new Set([
+    // JavaScript keywords
+    "const",
+    "let",
+    "var",
+    "function",
+    "return",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "default",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "new",
+    "this",
+    "class",
+    "extends",
+    "super",
+    "import",
+    "export",
+    "from",
+    "as",
+    "async",
+    "await",
+    "yield",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "void",
+    "delete",
+    "true",
+    "false",
+    "null",
+    "undefined",
+    // TypeScript keywords
+    "interface",
+    "type",
+    "enum",
+    "implements",
+    "private",
+    "public",
+    "protected",
+    "readonly",
+    "abstract",
+    "declare",
+    "namespace",
+    "module",
+    // React hooks
+    "useState",
+    "useEffect",
+    "useCallback",
+    "useMemo",
+    "useRef",
+    "useContext",
+    "useReducer",
+    "useLayoutEffect",
+    "useImperativeHandle",
+    "useDebugValue",
+    "useDeferredValue",
+    "useTransition",
+    "useId",
+    "useSyncExternalStore",
+    "useInsertionEffect",
+    // React
+    "React",
+    "Component",
+    "Fragment",
+    "Suspense",
+    "memo",
+    "forwardRef",
+    "createContext",
+    "createElement",
+    // Common globals
+    "console",
+    "window",
+    "document",
+    "Math",
+    "Date",
+    "JSON",
+    "Object",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Promise",
+    "Set",
+    "Map",
+    "WeakSet",
+    "WeakMap",
+    "Symbol",
+    "Error",
+    "RegExp",
+    "Intl",
+    "setTimeout",
+    "setInterval",
+    "clearTimeout",
+    "clearInterval",
+    "fetch",
+    "require",
+    // Common type names
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "any",
+    "unknown",
+    "never",
+    "void",
+    // Normalized placeholders (preserve these)
+    "__SIZE__",
+    "__VARIANT__",
+    "__CLICK_HANDLER__",
+    "__CHANGE_HANDLER__",
+    "__SUBMIT_HANDLER__",
+    "__LOADING__",
+    "__ERROR__",
+    "__SUCCESS__",
+    "__DATA__",
+    "__CHILDREN__",
+    "__LABEL__",
+    "__DESCRIPTION__",
+    "__VALUE__",
+    "__DISABLED__",
+    "__VISIBLE__",
+    "__CLASSNAME__"
+  ]);
+  return code.replace(identifierPattern, (match) => {
+    if (preserveList.has(match) || preserveList.has(match.toLowerCase())) {
+      return match;
+    }
+    const key = match.toLowerCase();
+    if (!identifierMap.has(key)) {
+      identifierMap.set(key, `_ID${counter++}_`);
+    }
+    return identifierMap.get(key);
+  });
+}
+function normalizeCode(code, options = DEFAULT_NORMALIZATION_OPTIONS) {
+  let result = code;
+  if (options.stripComments) {
+    result = stripComments(result);
+  }
+  if (options.normalizeSemantics) {
+    result = applySemanticNormalization(result);
+  }
+  if (options.normalizeIdentifiers) {
+    result = normalizeIdentifiersSimple(result);
+  }
+  if (options.normalizeWhitespace) {
+    result = normalizeWhitespace(result);
+  }
+  return result;
+}
+function levenshteinDistance(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previousRow = new Array(b.length + 1);
+  let currentRow = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++) {
+    previousRow[j] = j;
+  }
+  for (let i = 1; i <= a.length; i++) {
+    currentRow[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      currentRow[j] = Math.min(
+        previousRow[j] + 1,
+        // Deletion
+        currentRow[j - 1] + 1,
+        // Insertion
+        previousRow[j - 1] + cost
+        // Substitution
+      );
+    }
+    [previousRow, currentRow] = [currentRow, previousRow];
+  }
+  return previousRow[b.length];
+}
+function calculateNormalizedSimilarity(codeA, codeB, options = { normalizeIdentifiers: true, normalizeSemantics: true }) {
+  const normalizedA = normalizeCode(codeA, options);
+  const normalizedB = normalizeCode(codeB, options);
+  if (normalizedA === normalizedB) {
+    return 1;
+  }
+  const distance = levenshteinDistance(normalizedA, normalizedB);
+  const maxLen = Math.max(normalizedA.length, normalizedB.length);
+  if (maxLen === 0) return 1;
+  return 1 - distance / maxLen;
+}
+function isNearIdentical(codeA, codeB, threshold = 0.95) {
+  return calculateNormalizedSimilarity(codeA, codeB) >= threshold;
+}
+function prepareForEmbedding(code) {
+  return normalizeCode(code, {
+    normalizeIdentifiers: false,
+    normalizeSemantics: true,
+    stripComments: true,
+    normalizeWhitespace: false
+    // Preserve structure for embedding
+  });
+}
+
+// src/detection/combined-scorer.ts
+var DEFAULT_COMBINED_SCORER_OPTIONS = {
+  semanticWeight: 0.5,
+  structuralWeight: 0.3,
+  normalizedWeight: 0.2,
+  includeNormalized: false
+};
+function calculateCombinedScore(semanticScore, metadataA, metadataB, codeA, codeB, options = {}) {
+  const opts = { ...DEFAULT_COMBINED_SCORER_OPTIONS, ...options };
+  const structuralDetails = calculateStructuralSimilarity(metadataA, metadataB);
+  const structural = structuralDetails.combined;
+  let normalized;
+  if (opts.includeNormalized && codeA && codeB) {
+    normalized = calculateNormalizedSimilarity(codeA, codeB);
+  }
+  let final;
+  if (normalized !== void 0) {
+    final = semanticScore * opts.semanticWeight + structural * opts.structuralWeight + normalized * opts.normalizedWeight;
+  } else {
+    const totalWeight = opts.semanticWeight + opts.structuralWeight;
+    const adjustedSemanticWeight = opts.semanticWeight / totalWeight;
+    const adjustedStructuralWeight = opts.structuralWeight / totalWeight;
+    final = semanticScore * adjustedSemanticWeight + structural * adjustedStructuralWeight;
+  }
+  final = applyBoostForHighSignals(final, semanticScore, structural, normalized);
+  final = Math.max(0, Math.min(1, final));
+  const confidence = getConfidenceLevel(final);
+  const confidenceDetails = getConfidenceResult(final);
+  return {
+    final,
+    semantic: semanticScore,
+    structural,
+    structuralDetails,
+    normalized,
+    confidence,
+    confidenceDetails
+  };
+}
+function applyBoostForHighSignals(baseScore, semantic, structural, normalized) {
+  const HIGH_SIGNAL_THRESHOLD = 0.95;
+  const BOOST_FACTOR = 0.1;
+  let boost = 0;
+  if (normalized !== void 0 && normalized >= HIGH_SIGNAL_THRESHOLD) {
+    boost = Math.max(boost, (normalized - HIGH_SIGNAL_THRESHOLD) * 2);
+  }
+  if (semantic >= HIGH_SIGNAL_THRESHOLD) {
+    boost = Math.max(boost, (semantic - HIGH_SIGNAL_THRESHOLD) * 1.5);
+  }
+  if (structural >= HIGH_SIGNAL_THRESHOLD) {
+    boost = Math.max(boost, (structural - HIGH_SIGNAL_THRESHOLD) * 1.5);
+  }
+  return baseScore + boost * BOOST_FACTOR;
+}
+function isPotentialDuplicate(metadataA, metadataB, threshold = 0.3) {
+  const structural = calculateStructuralSimilarity(metadataA, metadataB);
+  return structural.combined >= threshold;
+}
+function calculateQuickScore(metadataA, metadataB) {
+  const structural = calculateStructuralSimilarity(metadataA, metadataB);
+  const confidence = getConfidenceLevel(structural.combined);
+  return { score: structural.combined, confidence };
+}
+function getRecommendedAction(score) {
+  if (score.normalized !== void 0 && score.normalized >= 0.95) {
+    return "These appear to be near-identical. Consolidate into a single implementation.";
+  }
+  if (score.final >= 0.9) {
+    return "High similarity detected. Strongly consider consolidating into a shared component/function.";
+  }
+  if (score.final >= 0.75) {
+    return "Moderate similarity. Review for potential abstraction into a shared utility.";
+  }
+  if (score.structural >= 0.8 && score.semantic < 0.7) {
+    return "Similar structure but different semantics. May be intentionally different implementations.";
+  }
+  if (score.semantic >= 0.8 && score.structural < 0.5) {
+    return "Similar purpose but different structure. Consider if a common abstraction makes sense.";
+  }
+  return "Low similarity. Likely different implementations that happen to share some patterns.";
+}
+function formatCombinedScore(score, verbose = false) {
+  const percent = Math.round(score.final * 100);
+  const lines = [];
+  lines.push(`${percent}% similar (${score.confidence} confidence)`);
+  if (verbose) {
+    lines.push(`  Semantic:   ${Math.round(score.semantic * 100)}%`);
+    lines.push(`  Structural: ${Math.round(score.structural * 100)}%`);
+    if (score.normalized !== void 0) {
+      lines.push(`  Normalized: ${Math.round(score.normalized * 100)}%`);
+    }
+    lines.push(`  \u2192 ${getRecommendedAction(score)}`);
+  }
+  return lines.join("\n");
+}
+
 export {
   chunkFile,
   prepareEmbeddingInput,
@@ -1928,6 +2509,21 @@ export {
   calculateDuplicateScore,
   calculateGroupAverageSimilarity,
   sortDuplicateGroups,
+  jaccard,
+  calculateSizeRatio2,
+  calculateStructuralSimilarity,
+  hasHighStructuralSimilarity,
+  findStructurallySimilar,
+  DEFAULT_CONFIDENCE_CONFIG,
+  getConfidenceLevel,
+  meetsMinimumThreshold,
+  getConfidenceResult,
+  getConfidenceEmoji,
+  getConfidenceAnsiColor,
+  formatConfidence,
+  formatConfidenceVerbose,
+  compareConfidenceLevels,
+  filterByConfidence,
   findDuplicateGroups,
   findSimilarToLocation,
   findSimilarToQuery,
@@ -1937,6 +2533,17 @@ export {
   searchSimilar,
   findSimilarAtLocation,
   hasIndex,
-  getIndexStats
+  getIndexStats,
+  normalizeCode,
+  levenshteinDistance,
+  calculateNormalizedSimilarity,
+  isNearIdentical,
+  prepareForEmbedding,
+  DEFAULT_COMBINED_SCORER_OPTIONS,
+  calculateCombinedScore,
+  isPotentialDuplicate,
+  calculateQuickScore,
+  getRecommendedAction,
+  formatCombinedScore
 };
-//# sourceMappingURL=chunk-54SLRAFO.js.map
+//# sourceMappingURL=chunk-BAZQUJDS.js.map