claude-brain 0.15.2 → 0.16.0

package/src/retrieval/fusion/index.ts

@@ -1,194 +1,194 @@
-/**
- * Fusion Strategies
- * Different methods for combining dense and sparse search results
- */
-
-import type { HybridSearchResult } from '../types'
-import { fuseWithRRF, fuseMultipleWithRRF, calculateRRFScore } from './rrf'
-
-export interface FusionConfig {
-  /** Fusion method to use */
-  method: 'rrf' | 'linear' | 'max'
-  /** RRF k parameter (for RRF method) */
-  rrfK?: number
-  /** Dense weight (for linear method) */
-  denseWeight?: number
-  /** Sparse weight (for linear method) */
-  sparseWeight?: number
-}
-
-const DEFAULT_CONFIG: FusionConfig = {
-  method: 'rrf',
-  rrfK: 60,
-  denseWeight: 0.7,
-  sparseWeight: 0.3
-}
-
-/**
- * RRF Fusion - Reciprocal Rank Fusion
- */
-export class RRFFusion {
-  private k: number
-
-  constructor(k: number = 60) {
-    this.k = k
-  }
-
-  fuse(
-    denseResults: HybridSearchResult[],
-    sparseResults: HybridSearchResult[]
-  ): HybridSearchResult[] {
-    return fuseWithRRF(denseResults, sparseResults, { k: this.k })
-  }
-
-  fuseMultiple(rankedLists: HybridSearchResult[][]): HybridSearchResult[] {
-    return fuseMultipleWithRRF(rankedLists, { k: this.k })
-  }
-}
-
-/**
- * Linear Fusion - Weighted combination of scores
- */
-export class LinearFusion {
-  private denseWeight: number
-  private sparseWeight: number
-
-  constructor(denseWeight: number = 0.7, sparseWeight: number = 0.3) {
-    this.denseWeight = denseWeight
-    this.sparseWeight = sparseWeight
-  }
-
-  fuse(
-    denseResults: HybridSearchResult[],
-    sparseResults: HybridSearchResult[]
-  ): HybridSearchResult[] {
-    // Create map for merging
-    const merged = new Map<string, HybridSearchResult>()
-
-    // Add dense results
-    for (const result of denseResults) {
-      merged.set(result.id, {
-        ...result,
-        scores: {
-          ...result.scores,
-          fusion: result.scores.dense * this.denseWeight,
-          final: result.scores.dense * this.denseWeight
-        },
-        provenance: 'dense'
-      })
-    }
-
-    // Add/merge sparse results
-    for (const result of sparseResults) {
-      const existing = merged.get(result.id)
-      if (existing) {
-        const combinedScore =
-          existing.scores.fusion + result.scores.sparse * this.sparseWeight
-        merged.set(result.id, {
-          ...existing,
-          scores: {
-            ...existing.scores,
-            sparse: result.scores.sparse,
-            fusion: combinedScore,
-            final: combinedScore
-          },
-          provenance: 'both'
-        })
-      } else {
-        merged.set(result.id, {
-          ...result,
-          scores: {
-            ...result.scores,
-            fusion: result.scores.sparse * this.sparseWeight,
-            final: result.scores.sparse * this.sparseWeight
-          },
-          provenance: 'sparse'
-        })
-      }
-    }
-
-    // Sort by fusion score
-    const results = Array.from(merged.values())
-    results.sort((a, b) => b.scores.fusion - a.scores.fusion)
-
-    return results
-  }
-}
-
-/**
- * Max Fusion - Take maximum score from either list
- */
-export class MaxFusion {
-  fuse(
-    denseResults: HybridSearchResult[],
-    sparseResults: HybridSearchResult[]
-  ): HybridSearchResult[] {
-    // Create map for merging
-    const merged = new Map<string, HybridSearchResult>()
-
-    // Add dense results
-    for (const result of denseResults) {
-      merged.set(result.id, {
-        ...result,
-        scores: {
-          ...result.scores,
-          fusion: result.scores.dense,
-          final: result.scores.dense
-        },
-        provenance: 'dense'
-      })
-    }
-
-    // Add/merge sparse results
-    for (const result of sparseResults) {
-      const existing = merged.get(result.id)
-      if (existing) {
-        const maxScore = Math.max(existing.scores.dense || 0, result.scores.sparse)
-        merged.set(result.id, {
-          ...existing,
-          scores: {
-            ...existing.scores,
-            sparse: result.scores.sparse,
-            fusion: maxScore,
-            final: maxScore
-          },
-          provenance: 'both'
-        })
-      } else {
-        merged.set(result.id, {
-          ...result,
-          scores: {
-            ...result.scores,
-            fusion: result.scores.sparse,
-            final: result.scores.sparse
-          },
-          provenance: 'sparse'
-        })
-      }
-    }
-
-    // Sort by fusion score
-    const results = Array.from(merged.values())
-    results.sort((a, b) => b.scores.fusion - a.scores.fusion)
-
-    return results
-  }
-}
-
-/**
- * Create a fusion strategy based on config
- */
-export function createFusionStrategy(config: FusionConfig = DEFAULT_CONFIG) {
-  switch (config.method) {
-    case 'rrf':
-      return new RRFFusion(config.rrfK)
-    case 'linear':
-      return new LinearFusion(config.denseWeight, config.sparseWeight)
-    case 'max':
-      return new MaxFusion()
-    default:
-      return new RRFFusion(config.rrfK)
-  }
-}
-
-export { fuseWithRRF, fuseMultipleWithRRF, calculateRRFScore } from './rrf'
+/**
+ * Fusion Strategies
+ * Different methods for combining dense and sparse search results
+ */
+
+import type { HybridSearchResult } from '../types'
+import { fuseWithRRF, fuseMultipleWithRRF, calculateRRFScore } from './rrf'
+
+export interface FusionConfig {
+  /** Fusion method to use */
+  method: 'rrf' | 'linear' | 'max'
+  /** RRF k parameter (for RRF method) */
+  rrfK?: number
+  /** Dense weight (for linear method) */
+  denseWeight?: number
+  /** Sparse weight (for linear method) */
+  sparseWeight?: number
+}
+
+const DEFAULT_CONFIG: FusionConfig = {
+  method: 'rrf',
+  rrfK: 60,
+  denseWeight: 0.7,
+  sparseWeight: 0.3
+}
+
+/**
+ * RRF Fusion - Reciprocal Rank Fusion
+ */
+export class RRFFusion {
+  private k: number
+
+  constructor(k: number = 60) {
+    this.k = k
+  }
+
+  fuse(
+    denseResults: HybridSearchResult[],
+    sparseResults: HybridSearchResult[]
+  ): HybridSearchResult[] {
+    return fuseWithRRF(denseResults, sparseResults, { k: this.k })
+  }
+
+  fuseMultiple(rankedLists: HybridSearchResult[][]): HybridSearchResult[] {
+    return fuseMultipleWithRRF(rankedLists, { k: this.k })
+  }
+}
+
+/**
+ * Linear Fusion - Weighted combination of scores
+ */
+export class LinearFusion {
+  private denseWeight: number
+  private sparseWeight: number
+
+  constructor(denseWeight: number = 0.7, sparseWeight: number = 0.3) {
+    this.denseWeight = denseWeight
+    this.sparseWeight = sparseWeight
+  }
+
+  fuse(
+    denseResults: HybridSearchResult[],
+    sparseResults: HybridSearchResult[]
+  ): HybridSearchResult[] {
+    // Create map for merging
+    const merged = new Map<string, HybridSearchResult>()
+
+    // Add dense results
+    for (const result of denseResults) {
+      merged.set(result.id, {
+        ...result,
+        scores: {
+          ...result.scores,
+          fusion: result.scores.dense * this.denseWeight,
+          final: result.scores.dense * this.denseWeight
+        },
+        provenance: 'dense'
+      })
+    }
+
+    // Add/merge sparse results
+    for (const result of sparseResults) {
+      const existing = merged.get(result.id)
+      if (existing) {
+        const combinedScore =
+          existing.scores.fusion + result.scores.sparse * this.sparseWeight
+        merged.set(result.id, {
+          ...existing,
+          scores: {
+            ...existing.scores,
+            sparse: result.scores.sparse,
+            fusion: combinedScore,
+            final: combinedScore
+          },
+          provenance: 'both'
+        })
+      } else {
+        merged.set(result.id, {
+          ...result,
+          scores: {
+            ...result.scores,
+            fusion: result.scores.sparse * this.sparseWeight,
+            final: result.scores.sparse * this.sparseWeight
+          },
+          provenance: 'sparse'
+        })
+      }
+    }
+
+    // Sort by fusion score
+    const results = Array.from(merged.values())
+    results.sort((a, b) => b.scores.fusion - a.scores.fusion)
+
+    return results
+  }
+}
+
+/**
+ * Max Fusion - Take maximum score from either list
+ */
+export class MaxFusion {
+  fuse(
+    denseResults: HybridSearchResult[],
+    sparseResults: HybridSearchResult[]
+  ): HybridSearchResult[] {
+    // Create map for merging
+    const merged = new Map<string, HybridSearchResult>()
+
+    // Add dense results
+    for (const result of denseResults) {
+      merged.set(result.id, {
+        ...result,
+        scores: {
+          ...result.scores,
+          fusion: result.scores.dense,
+          final: result.scores.dense
+        },
+        provenance: 'dense'
+      })
+    }
+
+    // Add/merge sparse results
+    for (const result of sparseResults) {
+      const existing = merged.get(result.id)
+      if (existing) {
+        const maxScore = Math.max(existing.scores.dense || 0, result.scores.sparse)
+        merged.set(result.id, {
+          ...existing,
+          scores: {
+            ...existing.scores,
+            sparse: result.scores.sparse,
+            fusion: maxScore,
+            final: maxScore
+          },
+          provenance: 'both'
+        })
+      } else {
+        merged.set(result.id, {
+          ...result,
+          scores: {
+            ...result.scores,
+            fusion: result.scores.sparse,
+            final: result.scores.sparse
+          },
+          provenance: 'sparse'
+        })
+      }
+    }
+
+    // Sort by fusion score
+    const results = Array.from(merged.values())
+    results.sort((a, b) => b.scores.fusion - a.scores.fusion)
+
+    return results
+  }
+}
+
+/**
+ * Create a fusion strategy based on config
+ */
+export function createFusionStrategy(config: FusionConfig = DEFAULT_CONFIG) {
+  switch (config.method) {
+    case 'rrf':
+      return new RRFFusion(config.rrfK)
+    case 'linear':
+      return new LinearFusion(config.denseWeight, config.sparseWeight)
+    case 'max':
+      return new MaxFusion()
+    default:
+      return new RRFFusion(config.rrfK)
+  }
+}
+
+export { fuseWithRRF, fuseMultipleWithRRF, calculateRRFScore } from './rrf'