claude-brain 0.15.2 → 0.17.0

package/src/memory/search.ts

@@ -1,309 +1,309 @@
-/**
- * Semantic Search Engine
- * Phase 3: Memory and Embedding System
- *
- * Finds similar memories using vector similarity
- */
-
-import type { Database } from 'bun:sqlite'
-import type { Logger } from 'pino'
-import type { Decision, MemorySearchResult, SearchOptions, MemoryRow, DecisionRow } from './types'
-import { EmbeddingService } from './embeddings'
-import { bufferToEmbedding, cosineSimilarity } from './embedding-utils'
-
-export class SemanticSearch {
-  private db: Database
-  private embeddings: EmbeddingService
-  private logger: Logger
-
-  constructor(db: Database, embeddings: EmbeddingService, logger: Logger) {
-    this.db = db
-    this.embeddings = embeddings
-    this.logger = logger.child({ component: 'semantic-search' })
-  }
-
-  /**
-   * Search for similar memories using semantic similarity
-   */
-  async search(query: string, options: SearchOptions = {}): Promise<MemorySearchResult[]> {
-    try {
-      const startTime = Date.now()
-
-      // Generate query embedding
-      const queryEmbedding = await this.embeddings.generateEmbedding(query)
-
-      // Build SQL query with filters
-      let sql = 'SELECT * FROM memories WHERE 1=1'
-      const params: string[] = []
-
-      if (options.project) {
-        sql += ' AND project = ?'
-        params.push(options.project)
-      }
-
-      // Get all matching memories
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as MemoryRow[]
-
-      // Calculate similarity for each memory
-      const results: MemorySearchResult[] = []
-
-      for (const row of rows) {
-        const embedding = bufferToEmbedding(row.embedding)
-        const similarity = cosineSimilarity(queryEmbedding, embedding)
-
-        // Filter by minimum similarity
-        if (options.minSimilarity && similarity < options.minSimilarity) {
-          continue
-        }
-
-        // Get associated decision if exists
-        let decision: Decision | undefined = undefined
-        if (row.metadata) {
-          const metadata = JSON.parse(row.metadata)
-          if (metadata.type === 'decision') {
-            const decisionStmt = this.db.prepare('SELECT * FROM decisions WHERE memory_id = ?')
-            const decisionRow = decisionStmt.get(row.id) as DecisionRow | null
-
-            if (decisionRow) {
-              decision = {
-                id: decisionRow.id,
-                memoryId: decisionRow.memory_id,
-                context: decisionRow.context,
-                decision: decisionRow.decision,
-                reasoning: decisionRow.reasoning,
-                alternatives: decisionRow.alternatives || undefined,
-                outcome: decisionRow.outcome || undefined,
-                tags: decisionRow.tags ? JSON.parse(decisionRow.tags) : undefined
-              }
-
-              // Filter by tags if specified
-              if (options.tags && options.tags.length > 0) {
-                const decisionTags = decision.tags || []
-                const hasMatchingTag = options.tags.some((tag) => decisionTags.includes(tag))
-                if (!hasMatchingTag) {
-                  continue
-                }
-              }
-            }
-          }
-        }
-
-        results.push({
-          memory: {
-            id: row.id,
-            project: row.project,
-            content: row.content,
-            embedding: embedding,
-            createdAt: new Date(row.created_at),
-            updatedAt: new Date(row.updated_at),
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-          },
-          similarity,
-          decision
-        })
-      }
-
-      // Sort by similarity (descending)
-      results.sort((a, b) => b.similarity - a.similarity)
-
-      // Apply limit
-      const limit = options.limit || 10
-      const limitedResults = results.slice(0, limit)
-
-      const duration = Date.now() - startTime
-      this.logger.info(
-        { query: query.slice(0, 50), resultCount: limitedResults.length, duration },
-        'Semantic search completed'
-      )
-
-      return limitedResults
-    } catch (error) {
-      this.logger.error({ error, query, options }, 'Semantic search failed')
-      return []
-    }
-  }
-
-  /**
-   * Find similar decisions to a given context
-   */
-  async findSimilarDecisions(
-    context: string,
-    project?: string,
-    limit: number = 5
-  ): Promise<MemorySearchResult[]> {
-    // Filter for decision-type memories
-    // Use lower similarity threshold (0.3) to catch more variations in phrasing
-    const results = await this.search(context, {
-      project,
-      limit: limit * 2, // Get more to filter
-      minSimilarity: 0.3
-    })
-
-    // Keep only results with decisions
-    return results.filter((r) => r.decision !== undefined).slice(0, limit)
-  }
-
-  /**
-   * Get recommendations based on current context
-   */
-  async getRecommendations(
-    currentContext: string,
-    project: string,
-    limit: number = 3
-  ): Promise<MemorySearchResult[]> {
-    return this.search(currentContext, {
-      project,
-      limit,
-      minSimilarity: 0.7 // Higher threshold for recommendations
-    })
-  }
-
-  /**
-   * Find memories by tag
-   */
-  async findByTags(tags: string[], project?: string, limit: number = 10): Promise<MemorySearchResult[]> {
-    try {
-      // Get all decision memories that might have tags
-      let sql = `
-        SELECT m.*, d.tags as decision_tags
-        FROM memories m
-        LEFT JOIN decisions d ON m.id = d.memory_id
-        WHERE m.metadata LIKE '%"type":"decision"%'
-      `
-      const params: string[] = []
-
-      if (project) {
-        sql += ' AND m.project = ?'
-        params.push(project)
-      }
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as Array<MemoryRow & { decision_tags: string | null }>
-
-      const results: MemorySearchResult[] = []
-
-      for (const row of rows) {
-        if (!row.decision_tags) continue
-
-        const decisionTags = JSON.parse(row.decision_tags) as string[]
-        const hasMatchingTag = tags.some((tag) => decisionTags.includes(tag))
-
-        if (!hasMatchingTag) continue
-
-        // Get the full decision
-        const decisionStmt = this.db.prepare('SELECT * FROM decisions WHERE memory_id = ?')
-        const decisionRow = decisionStmt.get(row.id) as DecisionRow | null
-
-        if (decisionRow) {
-          results.push({
-            memory: {
-              id: row.id,
-              project: row.project,
-              content: row.content,
-              embedding: bufferToEmbedding(row.embedding),
-              createdAt: new Date(row.created_at),
-              updatedAt: new Date(row.updated_at),
-              metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-            },
-            similarity: 1.0, // Tag match, no semantic similarity
-            decision: {
-              id: decisionRow.id,
-              memoryId: decisionRow.memory_id,
-              context: decisionRow.context,
-              decision: decisionRow.decision,
-              reasoning: decisionRow.reasoning,
-              alternatives: decisionRow.alternatives || undefined,
-              outcome: decisionRow.outcome || undefined,
-              tags: decisionRow.tags ? JSON.parse(decisionRow.tags) : undefined
-            }
-          })
-        }
-      }
-
-      // Sort by created date (newest first)
-      results.sort((a, b) => b.memory.createdAt.getTime() - a.memory.createdAt.getTime())
-
-      return results.slice(0, limit)
-    } catch (error) {
-      this.logger.error({ error, tags, project }, 'Tag search failed')
-      return []
-    }
-  }
-
-  /**
-   * Search across all content with text matching and semantic similarity
-   */
-  async hybridSearch(
-    query: string,
-    options: SearchOptions = {}
-  ): Promise<MemorySearchResult[]> {
-    // Get semantic results
-    const semanticResults = await this.search(query, {
-      ...options,
-      limit: (options.limit || 10) * 2
-    })
-
-    // Also do text search
-    const textResults = this.textSearch(query, options.project)
-
-    // Merge and deduplicate results
-    const resultMap = new Map<string, MemorySearchResult>()
-
-    // Add semantic results first (they have similarity scores)
-    for (const result of semanticResults) {
-      resultMap.set(result.memory.id, result)
-    }
-
-    // Add text results (boost their similarity if they also matched semantically)
-    for (const result of textResults) {
-      const existing = resultMap.get(result.memory.id)
-      if (existing) {
-        // Boost similarity for hybrid matches
-        existing.similarity = Math.min(1.0, existing.similarity * 1.2)
-      } else {
-        resultMap.set(result.memory.id, result)
-      }
-    }
-
-    // Convert to array and sort
-    const combined = Array.from(resultMap.values())
-    combined.sort((a, b) => b.similarity - a.similarity)
-
-    return combined.slice(0, options.limit || 10)
-  }
-
-  /**
-   * Simple text search (case-insensitive)
-   */
-  private textSearch(query: string, project?: string): MemorySearchResult[] {
-    try {
-      let sql = 'SELECT * FROM memories WHERE content LIKE ?'
-      const params: string[] = [`%${query}%`]
-
-      if (project) {
-        sql += ' AND project = ?'
-        params.push(project)
-      }
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as MemoryRow[]
-
-      return rows.map((row) => ({
-        memory: {
-          id: row.id,
-          project: row.project,
-          content: row.content,
-          embedding: bufferToEmbedding(row.embedding),
-          createdAt: new Date(row.created_at),
-          updatedAt: new Date(row.updated_at),
-          metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-        },
-        similarity: 0.8 // Default similarity for text matches
-      }))
-    } catch (error) {
-      this.logger.error({ error, query }, 'Text search failed')
-      return []
-    }
-  }
-}
+/**
+ * Semantic Search Engine
+ * Phase 3: Memory and Embedding System
+ *
+ * Finds similar memories using vector similarity
+ */
+
+import type { Database } from 'bun:sqlite'
+import type { Logger } from 'pino'
+import type { Decision, MemorySearchResult, SearchOptions, MemoryRow, DecisionRow } from './types'
+import { EmbeddingService } from './embeddings'
+import { bufferToEmbedding, cosineSimilarity } from './embedding-utils'
+
+export class SemanticSearch {
+  private db: Database
+  private embeddings: EmbeddingService
+  private logger: Logger
+
+  constructor(db: Database, embeddings: EmbeddingService, logger: Logger) {
+    this.db = db
+    this.embeddings = embeddings
+    this.logger = logger.child({ component: 'semantic-search' })
+  }
+
+  /**
+   * Search for similar memories using semantic similarity
+   */
+  async search(query: string, options: SearchOptions = {}): Promise<MemorySearchResult[]> {
+    try {
+      const startTime = Date.now()
+
+      // Generate query embedding
+      const queryEmbedding = await this.embeddings.generateEmbedding(query)
+
+      // Build SQL query with filters
+      let sql = 'SELECT * FROM memories WHERE 1=1'
+      const params: string[] = []
+
+      if (options.project) {
+        sql += ' AND project = ?'
+        params.push(options.project)
+      }
+
+      // Get all matching memories
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as MemoryRow[]
+
+      // Calculate similarity for each memory
+      const results: MemorySearchResult[] = []
+
+      for (const row of rows) {
+        const embedding = bufferToEmbedding(row.embedding)
+        const similarity = cosineSimilarity(queryEmbedding, embedding)
+
+        // Filter by minimum similarity
+        if (options.minSimilarity && similarity < options.minSimilarity) {
+          continue
+        }
+
+        // Get associated decision if exists
+        let decision: Decision | undefined = undefined
+        if (row.metadata) {
+          const metadata = JSON.parse(row.metadata)
+          if (metadata.type === 'decision') {
+            const decisionStmt = this.db.prepare('SELECT * FROM decisions WHERE memory_id = ?')
+            const decisionRow = decisionStmt.get(row.id) as DecisionRow | null
+
+            if (decisionRow) {
+              decision = {
+                id: decisionRow.id,
+                memoryId: decisionRow.memory_id,
+                context: decisionRow.context,
+                decision: decisionRow.decision,
+                reasoning: decisionRow.reasoning,
+                alternatives: decisionRow.alternatives || undefined,
+                outcome: decisionRow.outcome || undefined,
+                tags: decisionRow.tags ? JSON.parse(decisionRow.tags) : undefined
+              }
+
+              // Filter by tags if specified
+              if (options.tags && options.tags.length > 0) {
+                const decisionTags = decision.tags || []
+                const hasMatchingTag = options.tags.some((tag) => decisionTags.includes(tag))
+                if (!hasMatchingTag) {
+                  continue
+                }
+              }
+            }
+          }
+        }
+
+        results.push({
+          memory: {
+            id: row.id,
+            project: row.project,
+            content: row.content,
+            embedding: embedding,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+          },
+          similarity,
+          decision
+        })
+      }
+
+      // Sort by similarity (descending)
+      results.sort((a, b) => b.similarity - a.similarity)
+
+      // Apply limit
+      const limit = options.limit || 10
+      const limitedResults = results.slice(0, limit)
+
+      const duration = Date.now() - startTime
+      this.logger.info(
+        { query: query.slice(0, 50), resultCount: limitedResults.length, duration },
+        'Semantic search completed'
+      )
+
+      return limitedResults
+    } catch (error) {
+      this.logger.error({ error, query, options }, 'Semantic search failed')
+      return []
+    }
+  }
+
+  /**
+   * Find similar decisions to a given context
+   */
+  async findSimilarDecisions(
+    context: string,
+    project?: string,
+    limit: number = 5
+  ): Promise<MemorySearchResult[]> {
+    // Filter for decision-type memories
+    // Use lower similarity threshold (0.3) to catch more variations in phrasing
+    const results = await this.search(context, {
+      project,
+      limit: limit * 2, // Get more to filter
+      minSimilarity: 0.3
+    })
+
+    // Keep only results with decisions
+    return results.filter((r) => r.decision !== undefined).slice(0, limit)
+  }
+
+  /**
+   * Get recommendations based on current context
+   */
+  async getRecommendations(
+    currentContext: string,
+    project: string,
+    limit: number = 3
+  ): Promise<MemorySearchResult[]> {
+    return this.search(currentContext, {
+      project,
+      limit,
+      minSimilarity: 0.7 // Higher threshold for recommendations
+    })
+  }
+
+  /**
+   * Find memories by tag
+   */
+  async findByTags(tags: string[], project?: string, limit: number = 10): Promise<MemorySearchResult[]> {
+    try {
+      // Get all decision memories that might have tags
+      let sql = `
+        SELECT m.*, d.tags as decision_tags
+        FROM memories m
+        LEFT JOIN decisions d ON m.id = d.memory_id
+        WHERE m.metadata LIKE '%"type":"decision"%'
+      `
+      const params: string[] = []
+
+      if (project) {
+        sql += ' AND m.project = ?'
+        params.push(project)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as Array<MemoryRow & { decision_tags: string | null }>
+
+      const results: MemorySearchResult[] = []
+
+      for (const row of rows) {
+        if (!row.decision_tags) continue
+
+        const decisionTags = JSON.parse(row.decision_tags) as string[]
+        const hasMatchingTag = tags.some((tag) => decisionTags.includes(tag))
+
+        if (!hasMatchingTag) continue
+
+        // Get the full decision
+        const decisionStmt = this.db.prepare('SELECT * FROM decisions WHERE memory_id = ?')
+        const decisionRow = decisionStmt.get(row.id) as DecisionRow | null
+
+        if (decisionRow) {
+          results.push({
+            memory: {
+              id: row.id,
+              project: row.project,
+              content: row.content,
+              embedding: bufferToEmbedding(row.embedding),
+              createdAt: new Date(row.created_at),
+              updatedAt: new Date(row.updated_at),
+              metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+            },
+            similarity: 1.0, // Tag match, no semantic similarity
+            decision: {
+              id: decisionRow.id,
+              memoryId: decisionRow.memory_id,
+              context: decisionRow.context,
+              decision: decisionRow.decision,
+              reasoning: decisionRow.reasoning,
+              alternatives: decisionRow.alternatives || undefined,
+              outcome: decisionRow.outcome || undefined,
+              tags: decisionRow.tags ? JSON.parse(decisionRow.tags) : undefined
+            }
+          })
+        }
+      }
+
+      // Sort by created date (newest first)
+      results.sort((a, b) => b.memory.createdAt.getTime() - a.memory.createdAt.getTime())
+
+      return results.slice(0, limit)
+    } catch (error) {
+      this.logger.error({ error, tags, project }, 'Tag search failed')
+      return []
+    }
+  }
+
+  /**
+   * Search across all content with text matching and semantic similarity
+   */
+  async hybridSearch(
+    query: string,
+    options: SearchOptions = {}
+  ): Promise<MemorySearchResult[]> {
+    // Get semantic results
+    const semanticResults = await this.search(query, {
+      ...options,
+      limit: (options.limit || 10) * 2
+    })
+
+    // Also do text search
+    const textResults = this.textSearch(query, options.project)
+
+    // Merge and deduplicate results
+    const resultMap = new Map<string, MemorySearchResult>()
+
+    // Add semantic results first (they have similarity scores)
+    for (const result of semanticResults) {
+      resultMap.set(result.memory.id, result)
+    }
+
+    // Add text results (boost their similarity if they also matched semantically)
+    for (const result of textResults) {
+      const existing = resultMap.get(result.memory.id)
+      if (existing) {
+        // Boost similarity for hybrid matches
+        existing.similarity = Math.min(1.0, existing.similarity * 1.2)
+      } else {
+        resultMap.set(result.memory.id, result)
+      }
+    }
+
+    // Convert to array and sort
+    const combined = Array.from(resultMap.values())
+    combined.sort((a, b) => b.similarity - a.similarity)
+
+    return combined.slice(0, options.limit || 10)
+  }
+
+  /**
+   * Simple text search (case-insensitive)
+   */
+  private textSearch(query: string, project?: string): MemorySearchResult[] {
+    try {
+      let sql = 'SELECT * FROM memories WHERE content LIKE ?'
+      const params: string[] = [`%${query}%`]
+
+      if (project) {
+        sql += ' AND project = ?'
+        params.push(project)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as MemoryRow[]
+
+      return rows.map((row) => ({
+        memory: {
+          id: row.id,
+          project: row.project,
+          content: row.content,
+          embedding: bufferToEmbedding(row.embedding),
+          createdAt: new Date(row.created_at),
+          updatedAt: new Date(row.updated_at),
+          metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+        },
+        similarity: 0.8 // Default similarity for text matches
+      }))
+    } catch (error) {
+      this.logger.error({ error, query }, 'Text search failed')
+      return []
+    }
+  }
+}