claude-brain 0.14.2 → 0.14.4

package/src/intelligence/optimization/semantic-cache.ts

@@ -1,207 +1,207 @@
-/**
- * Semantic Cache
- * LRU cache with semantic similarity matching for query deduplication
- */
-
-import { LRUCache } from 'lru-cache'
-import type { Logger } from 'pino'
-import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
-
-export interface CachedResult {
-  query: string
-  result: any
-  embedding?: number[]
-  timestamp: number
-  hitCount: number
-}
-
-export interface CacheStats {
-  size: number
-  maxSize: number
-  hits: number
-  misses: number
-  hitRate: number
-  semanticHits: number
-}
-
-export class SemanticCache {
-  private logger: Logger
-  private cache: LRUCache<string, CachedResult>
-  private embeddings?: EmbeddingProvider
-  private similarityThreshold: number
-  private stats = { hits: 0, misses: 0, semanticHits: 0 }
-  private embeddingIndex: Array<{ key: string; embedding: number[] }> = []
-
-  constructor(
-    logger: Logger,
-    options: {
-      maxSize?: number
-      ttlMs?: number
-      similarityThreshold?: number
-      embeddings?: EmbeddingProvider
-    } = {}
-  ) {
-    this.logger = logger.child({ component: 'semantic-cache' })
-    this.similarityThreshold = options.similarityThreshold || 0.85
-    this.embeddings = options.embeddings
-
-    this.cache = new LRUCache<string, CachedResult>({
-      max: options.maxSize || 500,
-      ttl: options.ttlMs || 30 * 60 * 1000, // 30 minutes default
-      dispose: (value, key) => {
-        // Remove from embedding index
-        this.embeddingIndex = this.embeddingIndex.filter(e => e.key !== key)
-      }
-    })
-  }
-
-  /**
-   * Get cached result for a query
-   * Checks exact match first, then semantic similarity
-   */
-  async get(query: string): Promise<any | undefined> {
-    // Exact match
-    const normalizedKey = this.normalizeKey(query)
-    const exact = this.cache.get(normalizedKey)
-
-    if (exact) {
-      exact.hitCount++
-      this.stats.hits++
-      return exact.result
-    }
-
-    // Semantic match (if embeddings available)
-    if (this.embeddings && this.embeddingIndex.length > 0) {
-      try {
-        const queryEmbedding = await this.embeddings.generate(query)
-        const match = this.findSemanticMatch(queryEmbedding)
-
-        if (match) {
-          const cached = this.cache.get(match.key)
-          if (cached) {
-            cached.hitCount++
-            this.stats.hits++
-            this.stats.semanticHits++
-            return cached.result
-          }
-        }
-      } catch (error) {
-        this.logger.debug({ error }, 'Semantic cache lookup failed')
-      }
-    }
-
-    this.stats.misses++
-    return undefined
-  }
-
-  /**
-   * Store a result in the cache
-   */
-  async set(query: string, result: any): Promise<void> {
-    const normalizedKey = this.normalizeKey(query)
-
-    let embedding: number[] | undefined
-
-    if (this.embeddings) {
-      try {
-        embedding = await this.embeddings.generate(query)
-        this.embeddingIndex.push({ key: normalizedKey, embedding })
-      } catch (error) {
-        this.logger.debug({ error }, 'Failed to generate embedding for cache')
-      }
-    }
-
-    this.cache.set(normalizedKey, {
-      query,
-      result,
-      embedding,
-      timestamp: Date.now(),
-      hitCount: 0
-    })
-  }
-
-  /**
-   * Invalidate cache entries matching a pattern
-   */
-  invalidate(pattern: string): number {
-    const lowerPattern = pattern.toLowerCase()
-    let count = 0
-
-    for (const [key] of this.cache.entries()) {
-      if (key.includes(lowerPattern)) {
-        this.cache.delete(key)
-        count++
-      }
-    }
-
-    return count
-  }
-
-  /**
-   * Invalidate all entries for a project
-   */
-  invalidateProject(project: string): number {
-    return this.invalidate(project)
-  }
-
-  /**
-   * Clear the entire cache
-   */
-  clear(): void {
-    this.cache.clear()
-    this.embeddingIndex = []
-    this.stats = { hits: 0, misses: 0, semanticHits: 0 }
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getStats(): CacheStats {
-    const total = this.stats.hits + this.stats.misses
-    return {
-      size: this.cache.size,
-      maxSize: this.cache.max,
-      hits: this.stats.hits,
-      misses: this.stats.misses,
-      hitRate: total > 0 ? this.stats.hits / total : 0,
-      semanticHits: this.stats.semanticHits
-    }
-  }
-
-  private normalizeKey(query: string): string {
-    return query.toLowerCase().replace(/\s+/g, ' ').trim()
-  }
-
-  private findSemanticMatch(queryEmbedding: number[]): { key: string; similarity: number } | null {
-    let bestMatch: { key: string; similarity: number } | null = null
-
-    for (const entry of this.embeddingIndex) {
-      const similarity = this.cosineSimilarity(queryEmbedding, entry.embedding)
-
-      if (similarity >= this.similarityThreshold) {
-        if (!bestMatch || similarity > bestMatch.similarity) {
-          bestMatch = { key: entry.key, similarity }
-        }
-      }
-    }
-
-    return bestMatch
-  }
-
-  private cosineSimilarity(a: number[], b: number[]): number {
-    if (a.length !== b.length) return 0
-
-    let dotProduct = 0
-    let normA = 0
-    let normB = 0
-
-    for (let i = 0; i < a.length; i++) {
-      dotProduct += a[i] * b[i]
-      normA += a[i] * a[i]
-      normB += b[i] * b[i]
-    }
-
-    const denominator = Math.sqrt(normA) * Math.sqrt(normB)
-    return denominator > 0 ? dotProduct / denominator : 0
-  }
-}
+/**
+ * Semantic Cache
+ * LRU cache with semantic similarity matching for query deduplication
+ */
+
+import { LRUCache } from 'lru-cache'
+import type { Logger } from 'pino'
+import type { EmbeddingProvider } from '@/memory/chroma/embeddings'
+
+export interface CachedResult {
+  query: string
+  result: any
+  embedding?: number[]
+  timestamp: number
+  hitCount: number
+}
+
+export interface CacheStats {
+  size: number
+  maxSize: number
+  hits: number
+  misses: number
+  hitRate: number
+  semanticHits: number
+}
+
+export class SemanticCache {
+  private logger: Logger
+  private cache: LRUCache<string, CachedResult>
+  private embeddings?: EmbeddingProvider
+  private similarityThreshold: number
+  private stats = { hits: 0, misses: 0, semanticHits: 0 }
+  private embeddingIndex: Array<{ key: string; embedding: number[] }> = []
+
+  constructor(
+    logger: Logger,
+    options: {
+      maxSize?: number
+      ttlMs?: number
+      similarityThreshold?: number
+      embeddings?: EmbeddingProvider
+    } = {}
+  ) {
+    this.logger = logger.child({ component: 'semantic-cache' })
+    this.similarityThreshold = options.similarityThreshold || 0.85
+    this.embeddings = options.embeddings
+
+    this.cache = new LRUCache<string, CachedResult>({
+      max: options.maxSize || 500,
+      ttl: options.ttlMs || 30 * 60 * 1000, // 30 minutes default
+      dispose: (value, key) => {
+        // Remove from embedding index
+        this.embeddingIndex = this.embeddingIndex.filter(e => e.key !== key)
+      }
+    })
+  }
+
+  /**
+   * Get cached result for a query
+   * Checks exact match first, then semantic similarity
+   */
+  async get(query: string): Promise<any | undefined> {
+    // Exact match
+    const normalizedKey = this.normalizeKey(query)
+    const exact = this.cache.get(normalizedKey)
+
+    if (exact) {
+      exact.hitCount++
+      this.stats.hits++
+      return exact.result
+    }
+
+    // Semantic match (if embeddings available)
+    if (this.embeddings && this.embeddingIndex.length > 0) {
+      try {
+        const queryEmbedding = await this.embeddings.generate(query)
+        const match = this.findSemanticMatch(queryEmbedding)
+
+        if (match) {
+          const cached = this.cache.get(match.key)
+          if (cached) {
+            cached.hitCount++
+            this.stats.hits++
+            this.stats.semanticHits++
+            return cached.result
+          }
+        }
+      } catch (error) {
+        this.logger.debug({ error }, 'Semantic cache lookup failed')
+      }
+    }
+
+    this.stats.misses++
+    return undefined
+  }
+
+  /**
+   * Store a result in the cache
+   */
+  async set(query: string, result: any): Promise<void> {
+    const normalizedKey = this.normalizeKey(query)
+
+    let embedding: number[] | undefined
+
+    if (this.embeddings) {
+      try {
+        embedding = await this.embeddings.generate(query)
+        this.embeddingIndex.push({ key: normalizedKey, embedding })
+      } catch (error) {
+        this.logger.debug({ error }, 'Failed to generate embedding for cache')
+      }
+    }
+
+    this.cache.set(normalizedKey, {
+      query,
+      result,
+      embedding,
+      timestamp: Date.now(),
+      hitCount: 0
+    })
+  }
+
+  /**
+   * Invalidate cache entries matching a pattern
+   */
+  invalidate(pattern: string): number {
+    const lowerPattern = pattern.toLowerCase()
+    let count = 0
+
+    for (const [key] of this.cache.entries()) {
+      if (key.includes(lowerPattern)) {
+        this.cache.delete(key)
+        count++
+      }
+    }
+
+    return count
+  }
+
+  /**
+   * Invalidate all entries for a project
+   */
+  invalidateProject(project: string): number {
+    return this.invalidate(project)
+  }
+
+  /**
+   * Clear the entire cache
+   */
+  clear(): void {
+    this.cache.clear()
+    this.embeddingIndex = []
+    this.stats = { hits: 0, misses: 0, semanticHits: 0 }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats(): CacheStats {
+    const total = this.stats.hits + this.stats.misses
+    return {
+      size: this.cache.size,
+      maxSize: this.cache.max,
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      hitRate: total > 0 ? this.stats.hits / total : 0,
+      semanticHits: this.stats.semanticHits
+    }
+  }
+
+  private normalizeKey(query: string): string {
+    return query.toLowerCase().replace(/\s+/g, ' ').trim()
+  }
+
+  private findSemanticMatch(queryEmbedding: number[]): { key: string; similarity: number } | null {
+    let bestMatch: { key: string; similarity: number } | null = null
+
+    for (const entry of this.embeddingIndex) {
+      const similarity = this.cosineSimilarity(queryEmbedding, entry.embedding)
+
+      if (similarity >= this.similarityThreshold) {
+        if (!bestMatch || similarity > bestMatch.similarity) {
+          bestMatch = { key: entry.key, similarity }
+        }
+      }
+    }
+
+    return bestMatch
+  }
+
+  private cosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) return 0
+
+    let dotProduct = 0
+    let normA = 0
+    let normB = 0
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i]
+      normA += a[i] * a[i]
+      normB += b[i] * b[i]
+    }
+
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB)
+    return denominator > 0 ? dotProduct / denominator : 0
+  }
+}