uilint-duplicates 0.2.122 → 0.2.124

package/dist/index.d.ts

@@ -510,12 +510,18 @@ interface IndexOptions {
 interface FindDuplicatesOptions$1 {
     /** Path to search (defaults to current directory) */
     path?: string;
-    /** Minimum similarity threshold (0-1). Default: 0.85 */
+    /** Minimum similarity threshold (0-1). Default: 0.75 */
     threshold?: number;
     /** Minimum group size. Default: 2 */
     minGroupSize?: number;
     /** Filter by kind: component, hook, function */
     kind?: ChunkKind;
+    /** Minimum confidence level: "high", "medium", "low". Default: "low" */
+    confidenceLevel?: "high" | "medium" | "low";
+    /** Use structural similarity boost. Default: true */
+    useStructuralBoost?: boolean;
+    /** Include duplicates within the same file. Default: true */
+    includeSameFile?: boolean;
 }
 interface SearchOptions {
     /** Path to search (defaults to current directory) */
@@ -556,6 +562,8 @@ interface DuplicateGroup$1 {
     avgSimilarity: number;
     /** The kind of code in this group */
     kind: ChunkKind;
+    /** Confidence level for this group */
+    confidence: "high" | "medium" | "low";
 }
 interface SearchResult {
     /** File path */
@@ -607,10 +615,101 @@ declare function getIndexStats(path?: string): Promise<{
     lastUpdated: string | null;
 }>;
 
+/**
+ * Confidence Level System
+ *
+ * Provides confidence levels for duplicate detection results
+ * to help users prioritize which duplicates to address.
+ *
+ * Confidence levels:
+ * - HIGH: Likely copy-paste or near-identical implementation. Should consolidate.
+ * - MEDIUM: Semantically similar code. Worth reviewing for potential abstraction.
+ * - LOW: Possibly related patterns. Optional to review.
+ */
+type ConfidenceLevel = "high" | "medium" | "low";
+interface ConfidenceConfig {
+    /** Threshold for high confidence (default: 0.90) */
+    highThreshold: number;
+    /** Threshold for medium confidence (default: 0.75) */
+    mediumThreshold: number;
+    /** Threshold for low confidence / minimum reporting (default: 0.60) */
+    lowThreshold: number;
+}
+declare const DEFAULT_CONFIDENCE_CONFIG: ConfidenceConfig;
+interface ConfidenceResult {
+    /** The confidence level */
+    level: ConfidenceLevel;
+    /** The raw similarity score (0-1) */
+    score: number;
+    /** Human-readable description of what this confidence level means */
+    description: string;
+    /** Recommended action for the user */
+    action: string;
+    /** Color for CLI/UI display */
+    color: "red" | "yellow" | "green";
+}
+/**
+ * Determine confidence level from a similarity score.
+ *
+ * @param score Similarity score between 0 and 1
+ * @param config Optional custom threshold configuration
+ * @returns The confidence level
+ */
+declare function getConfidenceLevel(score: number, config?: ConfidenceConfig): ConfidenceLevel;
+/**
+ * Check if a score meets the minimum threshold for reporting.
+ *
+ * @param score Similarity score
+ * @param config Optional custom threshold configuration
+ * @returns True if the score should be reported
+ */
+declare function meetsMinimumThreshold(score: number, config?: ConfidenceConfig): boolean;
+/**
+ * Get detailed confidence result with actionable guidance.
+ *
+ * @param score Similarity score between 0 and 1
+ * @param config Optional custom threshold configuration
+ * @returns Full confidence result with guidance
+ */
+declare function getConfidenceResult(score: number, config?: ConfidenceConfig): ConfidenceResult;
+/**
+ * Get emoji indicator for confidence level (for CLI output).
+ */
+declare function getConfidenceEmoji(level: ConfidenceLevel): string;
+/**
+ * Get ANSI color code for confidence level (for CLI output).
+ */
+declare function getConfidenceAnsiColor(level: ConfidenceLevel): string;
+/**
+ * Format confidence for display in CLI.
+ *
+ * @param result Confidence result to format
+ * @param useEmoji Whether to include emoji (default: true)
+ * @param useColor Whether to include ANSI colors (default: false)
+ * @returns Formatted string
+ */
+declare function formatConfidence(result: ConfidenceResult, useEmoji?: boolean, useColor?: boolean): string;
+/**
+ * Format confidence with full details for verbose output.
+ */
+declare function formatConfidenceVerbose(result: ConfidenceResult): string;
+/**
+ * Compare two confidence levels.
+ * Returns: -1 if a < b, 0 if equal, 1 if a > b
+ */
+declare function compareConfidenceLevels(a: ConfidenceLevel, b: ConfidenceLevel): number;
+/**
+ * Filter results by minimum confidence level.
+ */
+declare function filterByConfidence<T extends {
+    score: number;
+}>(results: T[], minLevel: ConfidenceLevel, config?: ConfidenceConfig): T[];
+
 /**
  * Duplicate Finder
  *
  * Finds groups of semantically similar code chunks using the vector index.
+ * Enhanced with structural similarity scoring and confidence levels.
  */
 
 interface DuplicateMember {
@@ -618,8 +717,14 @@ interface DuplicateMember {
     id: string;
     /** Chunk metadata */
     metadata: StoredChunkMetadata;
-    /** Similarity score to the group centroid/first member */
+    /** Similarity score to the group centroid/first member (semantic only) */
     score: number;
+    /** Combined score (semantic + structural) */
+    combinedScore?: number;
+    /** Structural similarity score */
+    structuralScore?: number;
+    /** Confidence level for this match */
+    confidence?: ConfidenceLevel;
 }
 interface DuplicateGroup {
     /** Members of the duplicate group */
@@ -628,9 +733,11 @@ interface DuplicateGroup {
     avgSimilarity: number;
     /** The kind of code in this group (component, hook, function) */
     kind: ChunkKind;
+    /** Overall confidence level for the group */
+    confidence: ConfidenceLevel;
 }
 interface FindDuplicatesOptions {
-    /** Minimum cosine similarity threshold (0-1). Default: 0.85 */
+    /** Minimum cosine similarity threshold (0-1). Default: 0.75 (lowered from 0.85) */
     threshold?: number;
     /** Minimum group size. Default: 2 */
     minGroupSize?: number;
@@ -638,6 +745,12 @@ interface FindDuplicatesOptions {
     kind?: ChunkKind;
     /** Exclude specific file paths */
     excludePaths?: string[];
+    /** Include duplicates within the same file. Default: true */
+    includeSameFile?: boolean;
+    /** Use structural similarity to boost scores. Default: true */
+    useStructuralBoost?: boolean;
+    /** Filter results by minimum confidence level */
+    confidenceFilter?: ConfidenceLevel;
 }
 /**
  * Find groups of semantically similar code.
@@ -645,9 +758,10 @@ interface FindDuplicatesOptions {
  * Algorithm:
  * 1. Iterate through all chunks
  * 2. For each unprocessed chunk, find similar chunks above threshold
- * 3. Group similar chunks together
- * 4. Mark all grouped chunks as processed
- * 5. Sort groups by size and similarity
+ * 3. Calculate combined score (semantic + structural)
+ * 4. Group similar chunks together
+ * 5. Assign confidence levels
+ * 6. Sort groups by size and similarity
  */
 declare function findDuplicateGroups(vectorStore: VectorStore, metadataStore: MetadataStore, options?: FindDuplicatesOptions): DuplicateGroup[];
 /**
@@ -684,7 +798,7 @@ interface DuplicateScore {
  * Calculate the size ratio between two code chunks.
  * Returns a value between 0 and 1 where 1 means identical size.
  */
-declare function calculateSizeRatio(chunk1: StoredChunkMetadata, chunk2: StoredChunkMetadata): number;
+declare function calculateSizeRatio$1(chunk1: StoredChunkMetadata, chunk2: StoredChunkMetadata): number;
 /**
  * Calculate a combined duplicate score.
  */
@@ -702,6 +816,228 @@ declare function sortDuplicateGroups<T extends {
     members: unknown[];
 }>(groups: T[]): T[];
 
+/**
+ * Structural Similarity Scorer
+ *
+ * Calculates similarity based on code structure (props, hooks, JSX elements)
+ * independent of semantic embeddings. This complements embedding-based
+ * similarity by catching cases where code structure is similar but
+ * variable/prop names differ.
+ */
+
+interface StructuralScore {
+    /** Jaccard similarity of prop names (0-1) */
+    propsOverlap: number;
+    /** Jaccard similarity of JSX elements (0-1) */
+    jsxOverlap: number;
+    /** Jaccard similarity of hooks used (0-1) */
+    hooksOverlap: number;
+    /** Line count ratio (0-1, 1 = same size) */
+    sizeRatio: number;
+    /** Combined weighted score (0-1) */
+    combined: number;
+}
+interface StructuralScorerWeights {
+    /** Weight for props overlap (default: 0.25) */
+    props: number;
+    /** Weight for JSX elements overlap (default: 0.35) */
+    jsx: number;
+    /** Weight for hooks overlap (default: 0.25) */
+    hooks: number;
+    /** Weight for size similarity (default: 0.15) */
+    size: number;
+}
+/**
+ * Calculate Jaccard similarity between two sets of strings.
+ * Returns 1 if both sets are empty (vacuously similar).
+ */
+declare function jaccard(a: string[], b: string[]): number;
+/**
+ * Calculate size ratio between two code chunks.
+ * Returns a value between 0 and 1, where 1 means identical size.
+ */
+declare function calculateSizeRatio(linesA: number, linesB: number): number;
+/**
+ * Calculate structural similarity between two chunks.
+ *
+ * This function compares the structural features of two code chunks:
+ * - Props/parameters they accept
+ * - JSX elements they render
+ * - Hooks they use
+ * - Relative size
+ *
+ * @param a First chunk metadata
+ * @param b Second chunk metadata
+ * @param weights Optional custom weights for each feature
+ * @returns Structural similarity score with component breakdowns
+ */
+declare function calculateStructuralSimilarity(a: StoredChunkMetadata, b: StoredChunkMetadata, weights?: StructuralScorerWeights): StructuralScore;
+/**
+ * Quick check if two chunks have high structural similarity.
+ * Useful for fast pre-filtering before expensive embedding comparison.
+ *
+ * @param a First chunk metadata
+ * @param b Second chunk metadata
+ * @param threshold Minimum combined score to consider similar (default: 0.5)
+ */
+declare function hasHighStructuralSimilarity(a: StoredChunkMetadata, b: StoredChunkMetadata, threshold?: number): boolean;
+/**
+ * Find structurally similar chunks from a list.
+ * Returns chunks sorted by structural similarity (highest first).
+ *
+ * @param target The chunk to compare against
+ * @param candidates List of candidate chunks to compare
+ * @param threshold Minimum similarity threshold
+ * @param limit Maximum number of results to return
+ */
+declare function findStructurallySimilar(target: StoredChunkMetadata, candidates: StoredChunkMetadata[], threshold?: number, limit?: number): Array<{
+    metadata: StoredChunkMetadata;
+    score: StructuralScore;
+}>;
+
+/**
+ * Code Normalizer
+ *
+ * Normalizes code before comparison to improve duplicate detection:
+ * 1. Replaces identifiers with canonical placeholders (for near-identical detection)
+ * 2. Normalizes semantic equivalents (size/dimension, onClick/onPress)
+ * 3. Strips comments and normalizes whitespace
+ *
+ * This is particularly useful for detecting utility functions that are
+ * copy-pasted with only variable name changes.
+ */
+interface NormalizationOptions {
+    /** Replace all local identifiers with placeholders (aggressive) */
+    normalizeIdentifiers?: boolean;
+    /** Normalize semantic equivalents like size/dimension */
+    normalizeSemantics?: boolean;
+    /** Strip comments from code */
+    stripComments?: boolean;
+    /** Normalize whitespace to single spaces */
+    normalizeWhitespace?: boolean;
+}
+/**
+ * Normalize code for comparison.
+ *
+ * @param code The source code to normalize
+ * @param options Normalization options
+ * @returns Normalized code string
+ */
+declare function normalizeCode(code: string, options?: NormalizationOptions): string;
+/**
+ * Calculate Levenshtein distance between two strings.
+ * Used for fuzzy matching of normalized code.
+ */
+declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Calculate normalized similarity between two code snippets.
+ * Returns 1.0 for identical normalized code, lower for differences.
+ *
+ * @param codeA First code snippet
+ * @param codeB Second code snippet
+ * @param options Normalization options
+ * @returns Similarity score between 0 and 1
+ */
+declare function calculateNormalizedSimilarity(codeA: string, codeB: string, options?: NormalizationOptions): number;
+/**
+ * Quick check if two code snippets are near-identical after normalization.
+ *
+ * @param codeA First code snippet
+ * @param codeB Second code snippet
+ * @param threshold Minimum similarity to consider near-identical (default: 0.95)
+ * @returns True if the code is near-identical
+ */
+declare function isNearIdentical(codeA: string, codeB: string, threshold?: number): boolean;
+/**
+ * Prepare code for embedding by applying light normalization.
+ * This is less aggressive than full normalization and is meant
+ * to improve embedding quality without losing semantic meaning.
+ *
+ * @param code The source code
+ * @returns Lightly normalized code for embedding
+ */
+declare function prepareForEmbedding(code: string): string;
+
+/**
+ * Combined Scorer
+ *
+ * Combines multiple similarity signals into a final score:
+ * - Semantic similarity (from embeddings)
+ * - Structural similarity (from metadata: props, JSX, hooks)
+ * - Normalized similarity (from AST normalization - optional, expensive)
+ *
+ * The combined approach catches more duplicates than embedding alone:
+ * - Structural catches same-structure/different-names cases
+ * - Normalization catches copy-paste with renamed variables
+ * - Semantic catches conceptually similar but differently structured code
+ */
+
+interface CombinedScore {
+    /** Final combined score (0-1) */
+    final: number;
+    /** Semantic embedding similarity (0-1) */
+    semantic: number;
+    /** Structural metadata similarity (0-1) */
+    structural: number;
+    /** Detailed structural breakdown */
+    structuralDetails: StructuralScore;
+    /** Normalized code similarity (0-1, only if computed) */
+    normalized?: number;
+    /** Confidence level based on final score */
+    confidence: ConfidenceLevel;
+    /** Detailed confidence result */
+    confidenceDetails: ConfidenceResult;
+}
+interface CombinedScorerOptions {
+    /** Weight for semantic similarity (default: 0.5) */
+    semanticWeight?: number;
+    /** Weight for structural similarity (default: 0.3) */
+    structuralWeight?: number;
+    /** Weight for normalized similarity (default: 0.2) */
+    normalizedWeight?: number;
+    /** Whether to compute normalized similarity (expensive) */
+    includeNormalized?: boolean;
+}
+declare const DEFAULT_COMBINED_SCORER_OPTIONS: Required<CombinedScorerOptions>;
+/**
+ * Calculate combined similarity score using multiple signals.
+ *
+ * @param semanticScore Embedding-based similarity score (0-1)
+ * @param metadataA Metadata for first chunk
+ * @param metadataB Metadata for second chunk
+ * @param codeA Source code of first chunk (optional, needed for normalization)
+ * @param codeB Source code of second chunk (optional, needed for normalization)
+ * @param options Scoring options
+ * @returns Combined score with all components
+ */
+declare function calculateCombinedScore(semanticScore: number, metadataA: StoredChunkMetadata, metadataB: StoredChunkMetadata, codeA?: string, codeB?: string, options?: CombinedScorerOptions): CombinedScore;
+/**
+ * Quick pre-filter check using only structural similarity.
+ * Use this to avoid expensive embedding comparisons for obviously dissimilar code.
+ *
+ * @param metadataA First chunk metadata
+ * @param metadataB Second chunk metadata
+ * @param threshold Minimum structural similarity to consider (default: 0.3)
+ * @returns True if chunks are potentially similar enough to warrant full comparison
+ */
+declare function isPotentialDuplicate(metadataA: StoredChunkMetadata, metadataB: StoredChunkMetadata, threshold?: number): boolean;
+/**
+ * Calculate quick similarity using only structural features.
+ * Useful when embedding scores are not available.
+ */
+declare function calculateQuickScore(metadataA: StoredChunkMetadata, metadataB: StoredChunkMetadata): {
+    score: number;
+    confidence: ConfidenceLevel;
+};
+/**
+ * Determine the best action based on combined score.
+ */
+declare function getRecommendedAction(score: CombinedScore): string;
+/**
+ * Format combined score for display.
+ */
+declare function formatCombinedScore(score: CombinedScore, verbose?: boolean): string;
+
 /**
  * File Tracker
  *
@@ -780,4 +1116,4 @@ declare class FileTracker {
     };
 }
 
-export { type ChunkKind, type ChunkMetadata, type ChunkingOptions, type CodeChunk, type DuplicateGroup$1 as DuplicateGroup, type DuplicateGroupMember, type DuplicateMember, type DuplicateScore, type EmbeddingOptions, type EmbeddingResult, type FileChange, type FileHashEntry, FileTracker, type FindDuplicatesOptions$1 as FindDuplicatesOptions, type HashStore, IncrementalIndexer, type IndexManifest, type IndexOptions, type IndexUpdateResult, type IndexerOptions, type DuplicateGroup as InternalDuplicateGroup, type FindDuplicatesOptions as InternalFindDuplicatesOptions, MetadataStore, OllamaEmbeddingClient, type SearchOptions, type SearchResult, type SimilarLocationOptions, type SimilarityResult, type StoredChunkMetadata, VectorStore, type VectorStoreOptions, calculateDuplicateScore, calculateGroupAverageSimilarity, calculateSizeRatio, chunkFile, clearIndexerCache, createIndexer, findDuplicateGroups, findDuplicates, findSimilarAtLocation, findSimilarToLocation, findSimilarToQuery, getIndexStats, getOllamaEmbeddingClient, hasIndex, hashContent, hashContentSync, indexDirectory, prepareEmbeddingInput, searchSimilar, sortDuplicateGroups };
+export { type ChunkKind, type ChunkMetadata, type ChunkingOptions, type CodeChunk, type CombinedScore, type CombinedScorerOptions, type ConfidenceConfig, type ConfidenceLevel, type ConfidenceResult, DEFAULT_COMBINED_SCORER_OPTIONS, DEFAULT_CONFIDENCE_CONFIG, type DuplicateGroup$1 as DuplicateGroup, type DuplicateGroupMember, type DuplicateMember, type DuplicateScore, type EmbeddingOptions, type EmbeddingResult, type FileChange, type FileHashEntry, FileTracker, type FindDuplicatesOptions$1 as FindDuplicatesOptions, type HashStore, IncrementalIndexer, type IndexManifest, type IndexOptions, type IndexUpdateResult, type IndexerOptions, type DuplicateGroup as InternalDuplicateGroup, type FindDuplicatesOptions as InternalFindDuplicatesOptions, MetadataStore, type NormalizationOptions, OllamaEmbeddingClient, type SearchOptions, type SearchResult, type SimilarLocationOptions, type SimilarityResult, type StoredChunkMetadata, type StructuralScore, type StructuralScorerWeights, VectorStore, type VectorStoreOptions, calculateCombinedScore, calculateDuplicateScore, calculateGroupAverageSimilarity, calculateNormalizedSimilarity, calculateQuickScore, calculateSizeRatio$1 as calculateSizeRatio, calculateStructuralSimilarity, calculateSizeRatio as calculateStructuralSizeRatio, chunkFile, clearIndexerCache, compareConfidenceLevels, createIndexer, filterByConfidence, findDuplicateGroups, findDuplicates, findSimilarAtLocation, findSimilarToLocation, findSimilarToQuery, findStructurallySimilar, formatCombinedScore, formatConfidence, formatConfidenceVerbose, getConfidenceAnsiColor, getConfidenceEmoji, getConfidenceLevel, getConfidenceResult, getIndexStats, getOllamaEmbeddingClient, getRecommendedAction, hasHighStructuralSimilarity, hasIndex, hashContent, hashContentSync, indexDirectory, isNearIdentical, isPotentialDuplicate, jaccard, levenshteinDistance, meetsMinimumThreshold, normalizeCode, prepareEmbeddingInput, prepareForEmbedding, searchSimilar, sortDuplicateGroups };

package/dist/index.js

@@ -1,54 +1,106 @@
 import {
+  DEFAULT_COMBINED_SCORER_OPTIONS,
+  DEFAULT_CONFIDENCE_CONFIG,
   FileTracker,
   IncrementalIndexer,
   MetadataStore,
   OllamaEmbeddingClient,
   VectorStore,
+  calculateCombinedScore,
   calculateDuplicateScore,
   calculateGroupAverageSimilarity,
+  calculateNormalizedSimilarity,
+  calculateQuickScore,
   calculateSizeRatio,
+  calculateSizeRatio2,
+  calculateStructuralSimilarity,
   chunkFile,
   clearIndexerCache,
+  compareConfidenceLevels,
   createIndexer,
+  filterByConfidence,
   findDuplicateGroups,
   findDuplicates,
   findSimilarAtLocation,
   findSimilarToLocation,
   findSimilarToQuery,
+  findStructurallySimilar,
+  formatCombinedScore,
+  formatConfidence,
+  formatConfidenceVerbose,
+  getConfidenceAnsiColor,
+  getConfidenceEmoji,
+  getConfidenceLevel,
+  getConfidenceResult,
   getIndexStats,
   getOllamaEmbeddingClient,
+  getRecommendedAction,
+  hasHighStructuralSimilarity,
   hasIndex,
   hashContent,
   hashContentSync,
   indexDirectory,
+  isNearIdentical,
+  isPotentialDuplicate,
+  jaccard,
+  levenshteinDistance,
+  meetsMinimumThreshold,
+  normalizeCode,
   prepareEmbeddingInput,
+  prepareForEmbedding,
   searchSimilar,
   sortDuplicateGroups
-} from "./chunk-54SLRAFO.js";
+} from "./chunk-BAZQUJDS.js";
 export {
+  DEFAULT_COMBINED_SCORER_OPTIONS,
+  DEFAULT_CONFIDENCE_CONFIG,
   FileTracker,
   IncrementalIndexer,
   MetadataStore,
   OllamaEmbeddingClient,
   VectorStore,
+  calculateCombinedScore,
   calculateDuplicateScore,
   calculateGroupAverageSimilarity,
+  calculateNormalizedSimilarity,
+  calculateQuickScore,
   calculateSizeRatio,
+  calculateStructuralSimilarity,
+  calculateSizeRatio2 as calculateStructuralSizeRatio,
   chunkFile,
   clearIndexerCache,
+  compareConfidenceLevels,
   createIndexer,
+  filterByConfidence,
   findDuplicateGroups,
   findDuplicates,
   findSimilarAtLocation,
   findSimilarToLocation,
   findSimilarToQuery,
+  findStructurallySimilar,
+  formatCombinedScore,
+  formatConfidence,
+  formatConfidenceVerbose,
+  getConfidenceAnsiColor,
+  getConfidenceEmoji,
+  getConfidenceLevel,
+  getConfidenceResult,
   getIndexStats,
   getOllamaEmbeddingClient,
+  getRecommendedAction,
+  hasHighStructuralSimilarity,
   hasIndex,
   hashContent,
   hashContentSync,
   indexDirectory,
+  isNearIdentical,
+  isPotentialDuplicate,
+  jaccard,
+  levenshteinDistance,
+  meetsMinimumThreshold,
+  normalizeCode,
   prepareEmbeddingInput,
+  prepareForEmbedding,
   searchSimilar,
   sortDuplicateGroups
 };

package/dist/node.d.ts

@@ -1 +1 @@
-export { ChunkKind, ChunkMetadata, ChunkingOptions, CodeChunk, DuplicateGroup, DuplicateGroupMember, DuplicateMember, DuplicateScore, EmbeddingOptions, EmbeddingResult, FileChange, FileHashEntry, FileTracker, FindDuplicatesOptions, HashStore, IncrementalIndexer, IndexManifest, IndexOptions, IndexUpdateResult, IndexerOptions, InternalDuplicateGroup, InternalFindDuplicatesOptions, MetadataStore, OllamaEmbeddingClient, SearchOptions, SearchResult, SimilarLocationOptions, SimilarityResult, StoredChunkMetadata, VectorStore, VectorStoreOptions, calculateDuplicateScore, calculateGroupAverageSimilarity, calculateSizeRatio, chunkFile, clearIndexerCache, createIndexer, findDuplicateGroups, findDuplicates, findSimilarAtLocation, findSimilarToLocation, findSimilarToQuery, getIndexStats, getOllamaEmbeddingClient, hasIndex, hashContent, hashContentSync, indexDirectory, prepareEmbeddingInput, searchSimilar, sortDuplicateGroups } from './index.js';
+export { ChunkKind, ChunkMetadata, ChunkingOptions, CodeChunk, CombinedScore, CombinedScorerOptions, ConfidenceConfig, ConfidenceLevel, ConfidenceResult, DEFAULT_COMBINED_SCORER_OPTIONS, DEFAULT_CONFIDENCE_CONFIG, DuplicateGroup, DuplicateGroupMember, DuplicateMember, DuplicateScore, EmbeddingOptions, EmbeddingResult, FileChange, FileHashEntry, FileTracker, FindDuplicatesOptions, HashStore, IncrementalIndexer, IndexManifest, IndexOptions, IndexUpdateResult, IndexerOptions, InternalDuplicateGroup, InternalFindDuplicatesOptions, MetadataStore, NormalizationOptions, OllamaEmbeddingClient, SearchOptions, SearchResult, SimilarLocationOptions, SimilarityResult, StoredChunkMetadata, StructuralScore, StructuralScorerWeights, VectorStore, VectorStoreOptions, calculateCombinedScore, calculateDuplicateScore, calculateGroupAverageSimilarity, calculateNormalizedSimilarity, calculateQuickScore, calculateSizeRatio, calculateStructuralSimilarity, calculateStructuralSizeRatio, chunkFile, clearIndexerCache, compareConfidenceLevels, createIndexer, filterByConfidence, findDuplicateGroups, findDuplicates, findSimilarAtLocation, findSimilarToLocation, findSimilarToQuery, findStructurallySimilar, formatCombinedScore, formatConfidence, formatConfidenceVerbose, getConfidenceAnsiColor, getConfidenceEmoji, getConfidenceLevel, getConfidenceResult, getIndexStats, getOllamaEmbeddingClient, getRecommendedAction, hasHighStructuralSimilarity, hasIndex, hashContent, hashContentSync, indexDirectory, isNearIdentical, isPotentialDuplicate, jaccard, levenshteinDistance, meetsMinimumThreshold, normalizeCode, prepareEmbeddingInput, prepareForEmbedding, searchSimilar, sortDuplicateGroups } from './index.js';

package/dist/node.js

@@ -1,54 +1,106 @@
 import {
+  DEFAULT_COMBINED_SCORER_OPTIONS,
+  DEFAULT_CONFIDENCE_CONFIG,
   FileTracker,
   IncrementalIndexer,
   MetadataStore,
   OllamaEmbeddingClient,
   VectorStore,
+  calculateCombinedScore,
   calculateDuplicateScore,
   calculateGroupAverageSimilarity,
+  calculateNormalizedSimilarity,
+  calculateQuickScore,
   calculateSizeRatio,
+  calculateSizeRatio2,
+  calculateStructuralSimilarity,
   chunkFile,
   clearIndexerCache,
+  compareConfidenceLevels,
   createIndexer,
+  filterByConfidence,
   findDuplicateGroups,
   findDuplicates,
   findSimilarAtLocation,
   findSimilarToLocation,
   findSimilarToQuery,
+  findStructurallySimilar,
+  formatCombinedScore,
+  formatConfidence,
+  formatConfidenceVerbose,
+  getConfidenceAnsiColor,
+  getConfidenceEmoji,
+  getConfidenceLevel,
+  getConfidenceResult,
   getIndexStats,
   getOllamaEmbeddingClient,
+  getRecommendedAction,
+  hasHighStructuralSimilarity,
   hasIndex,
   hashContent,
   hashContentSync,
   indexDirectory,
+  isNearIdentical,
+  isPotentialDuplicate,
+  jaccard,
+  levenshteinDistance,
+  meetsMinimumThreshold,
+  normalizeCode,
   prepareEmbeddingInput,
+  prepareForEmbedding,
   searchSimilar,
   sortDuplicateGroups
-} from "./chunk-54SLRAFO.js";
+} from "./chunk-BAZQUJDS.js";
 export {
+  DEFAULT_COMBINED_SCORER_OPTIONS,
+  DEFAULT_CONFIDENCE_CONFIG,
   FileTracker,
   IncrementalIndexer,
   MetadataStore,
   OllamaEmbeddingClient,
   VectorStore,
+  calculateCombinedScore,
   calculateDuplicateScore,
   calculateGroupAverageSimilarity,
+  calculateNormalizedSimilarity,
+  calculateQuickScore,
   calculateSizeRatio,
+  calculateStructuralSimilarity,
+  calculateSizeRatio2 as calculateStructuralSizeRatio,
   chunkFile,
   clearIndexerCache,
+  compareConfidenceLevels,
   createIndexer,
+  filterByConfidence,
   findDuplicateGroups,
   findDuplicates,
   findSimilarAtLocation,
   findSimilarToLocation,
   findSimilarToQuery,
+  findStructurallySimilar,
+  formatCombinedScore,
+  formatConfidence,
+  formatConfidenceVerbose,
+  getConfidenceAnsiColor,
+  getConfidenceEmoji,
+  getConfidenceLevel,
+  getConfidenceResult,
   getIndexStats,
   getOllamaEmbeddingClient,
+  getRecommendedAction,
+  hasHighStructuralSimilarity,
   hasIndex,
   hashContent,
   hashContentSync,
   indexDirectory,
+  isNearIdentical,
+  isPotentialDuplicate,
+  jaccard,
+  levenshteinDistance,
+  meetsMinimumThreshold,
+  normalizeCode,
   prepareEmbeddingInput,
+  prepareForEmbedding,
   searchSimilar,
   sortDuplicateGroups
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uilint-duplicates",
-  "version": "0.2.122",
+  "version": "0.2.124",
   "description": "Semantic code duplicate detection for React/TypeScript codebases",
   "author": "Peter Suggate",
   "repository": {
@@ -55,7 +55,7 @@
     "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "uilint-core": "0.2.122"
+    "uilint-core": "0.2.124"
   },
   "keywords": [
     "duplicate-detection",