claude-brain 0.14.2 → 0.14.4

package/src/automation/proactive-recall.ts

@@ -1,373 +1,373 @@
-/**
- * Proactive Recall Engine
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Automatically searches for relevant context before responding
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from '@/memory'
-import type { MemorySearchResult } from '@/memory/types'
-
-export interface RecallResult {
-  query: string
-  memories: MemorySearchResult[]
-  relevanceScore: number
-  triggeredBy: string[]
-  formattedContext?: string
-}
-
-export interface RecallStats {
-  totalRecalls: number
-  successfulRecalls: number
-  averageRelevance: number
-  lastRecallTime?: Date
-}
-
-export class ProactiveRecallEngine {
-  private logger: Logger
-  private memory: MemoryManager
-
-  // Track statistics
-  private recallCount = 0
-  private successfulRecalls = 0
-  private totalRelevance = 0
-  private lastRecallTime?: Date
-
-  // Keywords that trigger recall
-  private readonly RECALL_TRIGGERS = [
-    'how should',
-    "what's the best",
-    'which',
-    'recommend',
-    'approach',
-    'implement',
-    'handle',
-    'deal with',
-    'what did we',
-    'remember when',
-    'previously',
-    'last time',
-    'similar to',
-    'like before',
-    'as we did',
-    'pattern for',
-    'best practice',
-    'how do i',
-    'what is the'
-  ]
-
-  // Question indicators
-  private readonly QUESTION_PATTERNS = [
-    /^how\s/i,
-    /^what\s/i,
-    /^which\s/i,
-    /^should\s/i,
-    /^can\s(i|we)\s/i,
-    /\?$/
-  ]
-
-  constructor(logger: Logger, memory: MemoryManager) {
-    this.logger = logger.child({ component: 'proactive-recall' })
-    this.memory = memory
-  }
-
-  /**
-   * Check if query should trigger recall
-   */
-  shouldRecall(query: string): boolean {
-    const queryLower = query.toLowerCase()
-
-    // Check trigger phrases
-    const hasTrigger = this.RECALL_TRIGGERS.some(trigger =>
-      queryLower.includes(trigger)
-    )
-
-    if (hasTrigger) return true
-
-    // Check question patterns
-    const isQuestion = this.QUESTION_PATTERNS.some(pattern =>
-      pattern.test(query)
-    )
-
-    // Questions about implementation or choices should trigger recall
-    if (isQuestion) {
-      const implementationWords = [
-        'implement', 'create', 'build', 'design', 'structure',
-        'organize', 'handle', 'manage', 'use', 'choose'
-      ]
-      return implementationWords.some(word => queryLower.includes(word))
-    }
-
-    return false
-  }
-
-  /**
-   * Get which triggers matched
-   */
-  private getMatchedTriggers(query: string): string[] {
-    const queryLower = query.toLowerCase()
-    const matched: string[] = []
-
-    for (const trigger of this.RECALL_TRIGGERS) {
-      if (queryLower.includes(trigger)) {
-        matched.push(trigger)
-      }
-    }
-
-    for (const pattern of this.QUESTION_PATTERNS) {
-      if (pattern.test(query)) {
-        matched.push('question-pattern')
-        break
-      }
-    }
-
-    return matched
-  }
-
-  /**
-   * Extract search terms from query
-   */
-  extractSearchTerms(query: string): string[] {
-    // Common stop words to remove
-    const stopWords = new Set([
-      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at',
-      'to', 'for', 'of', 'with', 'by', 'from', 'how', 'what',
-      'should', 'i', 'we', 'is', 'are', 'do', 'does', 'can',
-      'could', 'would', 'will', 'be', 'been', 'being', 'have',
-      'has', 'had', 'this', 'that', 'these', 'those', 'it',
-      'its', 'my', 'our', 'your', 'their', 'about', 'like'
-    ])
-
-    const words = query
-      .toLowerCase()
-      .replace(/[^\w\s]/g, ' ')
-      .split(/\s+/)
-      .filter(word => word.length > 2 && !stopWords.has(word))
-
-    // Also extract potential compound terms
-    const compounds: string[] = []
-    for (let i = 0; i < words.length - 1; i++) {
-      if (words[i].length > 3 && words[i + 1].length > 3) {
-        compounds.push(`${words[i]} ${words[i + 1]}`)
-      }
-    }
-
-    return [...new Set([...words, ...compounds])]
-  }
-
-  /**
-   * Proactively recall relevant memories
-   */
-  async recall(query: string, project?: string): Promise<RecallResult | null> {
-    this.recallCount++
-
-    if (!this.shouldRecall(query)) {
-      return null
-    }
-
-    const triggeredBy = this.getMatchedTriggers(query)
-    this.logger.info({ query: query.slice(0, 50), triggeredBy }, 'Proactive recall triggered')
-
-    // Extract search terms
-    const searchTerms = this.extractSearchTerms(query)
-
-    if (searchTerms.length === 0) {
-      return null
-    }
-
-    // Search for each term and combine results
-    const allMemories: Map<string, MemorySearchResult> = new Map()
-
-    // Search with the full query first
-    try {
-      const fullResults = await this.memory.searchRaw(query, {
-        project,
-        limit: 5,
-        minSimilarity: 0.5
-      })
-
-      for (const memory of fullResults) {
-        allMemories.set(memory.memory.id, memory)
-      }
-    } catch (error) {
-      this.logger.warn({ error }, 'Full query search failed')
-    }
-
-    // Then search individual terms for broader coverage
-    for (const term of searchTerms.slice(0, 5)) {
-      try {
-        const memories = await this.memory.searchRaw(term, {
-          project,
-          limit: 3,
-          minSimilarity: 0.6
-        })
-
-        for (const memory of memories) {
-          // Only add if not already present or if higher similarity
-          const existing = allMemories.get(memory.memory.id)
-          if (!existing || memory.similarity > existing.similarity) {
-            allMemories.set(memory.memory.id, memory)
-          }
-        }
-      } catch (error) {
-        this.logger.warn({ error, term }, 'Term search failed')
-      }
-    }
-
-    const memories = Array.from(allMemories.values())
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, 5)
-
-    // Calculate relevance score
-    const relevanceScore = this.calculateRelevance(query, memories)
-
-    // Update stats
-    if (memories.length > 0) {
-      this.successfulRecalls++
-      this.totalRelevance += relevanceScore
-    }
-    this.lastRecallTime = new Date()
-
-    this.logger.info(
-      {
-        query: query.slice(0, 50),
-        memoryCount: memories.length,
-        relevanceScore
-      },
-      'Proactive recall complete'
-    )
-
-    const result: RecallResult = {
-      query,
-      memories,
-      relevanceScore,
-      triggeredBy
-    }
-
-    // Add formatted context if we have results
-    if (memories.length > 0 && relevanceScore > 0.4) {
-      result.formattedContext = this.formatForContext(result)
-    }
-
-    return result
-  }
-
-  /**
-   * Calculate relevance score
-   */
-  private calculateRelevance(query: string, memories: MemorySearchResult[]): number {
-    if (memories.length === 0) return 0
-
-    // Average similarity score
-    const avgSimilarity = memories.reduce((sum, m) => sum + m.similarity, 0) / memories.length
-
-    // Recency bonus (newer memories are more relevant)
-    const now = Date.now()
-    let totalRecencyScore = 0
-
-    for (const memory of memories) {
-      const age = now - memory.memory.createdAt.getTime()
-      const daysSince = age / (1000 * 60 * 60 * 24)
-      const recencyScore = Math.max(0, 1 - (daysSince / 365)) // Decay over a year
-      totalRecencyScore += recencyScore
-    }
-
-    const avgRecency = totalRecencyScore / memories.length
-
-    // Decision bonus (decisions are more relevant than raw memories)
-    const decisionCount = memories.filter(m => m.decision).length
-    const decisionBonus = (decisionCount / memories.length) * 0.1
-
-    // Combine scores
-    return (avgSimilarity * 0.6) + (avgRecency * 0.3) + decisionBonus
-  }
-
-  /**
-   * Format memories for context
-   */
-  formatForContext(result: RecallResult): string {
-    if (result.memories.length === 0) {
-      return ''
-    }
-
-    const parts: string[] = []
-    parts.push('\n---')
-    parts.push('**Relevant Past Context** (proactively recalled):')
-    parts.push('')
-
-    for (const [i, memory] of result.memories.entries()) {
-      const title = memory.decision?.decision || memory.memory.content.slice(0, 100)
-      parts.push(`${i + 1}. **${title}**`)
-
-      if (memory.decision?.reasoning) {
-        parts.push(`   *Reasoning:* ${memory.decision.reasoning}`)
-      }
-
-      parts.push(`   *Project:* ${memory.memory.project}`)
-      parts.push(`   *Relevance:* ${Math.round(memory.similarity * 100)}%`)
-
-      const date = memory.memory.createdAt.toLocaleDateString()
-      parts.push(`   *Recorded:* ${date}`)
-      parts.push('')
-    }
-
-    parts.push('---')
-    return parts.join('\n')
-  }
-
-  /**
-   * Get recall statistics
-   */
-  getStats(): RecallStats {
-    return {
-      totalRecalls: this.recallCount,
-      successfulRecalls: this.successfulRecalls,
-      averageRelevance: this.successfulRecalls > 0
-        ? this.totalRelevance / this.successfulRecalls
-        : 0,
-      lastRecallTime: this.lastRecallTime
-    }
-  }
-
-  /**
-   * Reset statistics
-   */
-  resetStats(): void {
-    this.recallCount = 0
-    this.successfulRecalls = 0
-    this.totalRelevance = 0
-    this.lastRecallTime = undefined
-  }
-
-  /**
-   * Add custom recall triggers
-   */
-  addTriggers(triggers: string[]): void {
-    for (const trigger of triggers) {
-      if (!this.RECALL_TRIGGERS.includes(trigger.toLowerCase())) {
-        (this.RECALL_TRIGGERS as string[]).push(trigger.toLowerCase())
-      }
-    }
-  }
-
-  /**
-   * Quick recall for a specific topic
-   */
-  async recallTopic(
-    topic: string,
-    project?: string,
-    limit: number = 3
-  ): Promise<MemorySearchResult[]> {
-    try {
-      return await this.memory.searchRaw(topic, {
-        project,
-        limit,
-        minSimilarity: 0.5
-      })
-    } catch (error) {
-      this.logger.error({ error, topic }, 'Topic recall failed')
-      return []
-    }
-  }
-}
+/**
+ * Proactive Recall Engine
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Automatically searches for relevant context before responding
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from '@/memory'
+import type { MemorySearchResult } from '@/memory/types'
+
+export interface RecallResult {
+  query: string
+  memories: MemorySearchResult[]
+  relevanceScore: number
+  triggeredBy: string[]
+  formattedContext?: string
+}
+
+export interface RecallStats {
+  totalRecalls: number
+  successfulRecalls: number
+  averageRelevance: number
+  lastRecallTime?: Date
+}
+
+export class ProactiveRecallEngine {
+  private logger: Logger
+  private memory: MemoryManager
+
+  // Track statistics
+  private recallCount = 0
+  private successfulRecalls = 0
+  private totalRelevance = 0
+  private lastRecallTime?: Date
+
+  // Keywords that trigger recall
+  private readonly RECALL_TRIGGERS = [
+    'how should',
+    "what's the best",
+    'which',
+    'recommend',
+    'approach',
+    'implement',
+    'handle',
+    'deal with',
+    'what did we',
+    'remember when',
+    'previously',
+    'last time',
+    'similar to',
+    'like before',
+    'as we did',
+    'pattern for',
+    'best practice',
+    'how do i',
+    'what is the'
+  ]
+
+  // Question indicators
+  private readonly QUESTION_PATTERNS = [
+    /^how\s/i,
+    /^what\s/i,
+    /^which\s/i,
+    /^should\s/i,
+    /^can\s(i|we)\s/i,
+    /\?$/
+  ]
+
+  constructor(logger: Logger, memory: MemoryManager) {
+    this.logger = logger.child({ component: 'proactive-recall' })
+    this.memory = memory
+  }
+
+  /**
+   * Check if query should trigger recall
+   */
+  shouldRecall(query: string): boolean {
+    const queryLower = query.toLowerCase()
+
+    // Check trigger phrases
+    const hasTrigger = this.RECALL_TRIGGERS.some(trigger =>
+      queryLower.includes(trigger)
+    )
+
+    if (hasTrigger) return true
+
+    // Check question patterns
+    const isQuestion = this.QUESTION_PATTERNS.some(pattern =>
+      pattern.test(query)
+    )
+
+    // Questions about implementation or choices should trigger recall
+    if (isQuestion) {
+      const implementationWords = [
+        'implement', 'create', 'build', 'design', 'structure',
+        'organize', 'handle', 'manage', 'use', 'choose'
+      ]
+      return implementationWords.some(word => queryLower.includes(word))
+    }
+
+    return false
+  }
+
+  /**
+   * Get which triggers matched
+   */
+  private getMatchedTriggers(query: string): string[] {
+    const queryLower = query.toLowerCase()
+    const matched: string[] = []
+
+    for (const trigger of this.RECALL_TRIGGERS) {
+      if (queryLower.includes(trigger)) {
+        matched.push(trigger)
+      }
+    }
+
+    for (const pattern of this.QUESTION_PATTERNS) {
+      if (pattern.test(query)) {
+        matched.push('question-pattern')
+        break
+      }
+    }
+
+    return matched
+  }
+
+  /**
+   * Extract search terms from query
+   */
+  extractSearchTerms(query: string): string[] {
+    // Common stop words to remove
+    const stopWords = new Set([
+      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at',
+      'to', 'for', 'of', 'with', 'by', 'from', 'how', 'what',
+      'should', 'i', 'we', 'is', 'are', 'do', 'does', 'can',
+      'could', 'would', 'will', 'be', 'been', 'being', 'have',
+      'has', 'had', 'this', 'that', 'these', 'those', 'it',
+      'its', 'my', 'our', 'your', 'their', 'about', 'like'
+    ])
+
+    const words = query
+      .toLowerCase()
+      .replace(/[^\w\s]/g, ' ')
+      .split(/\s+/)
+      .filter(word => word.length > 2 && !stopWords.has(word))
+
+    // Also extract potential compound terms
+    const compounds: string[] = []
+    for (let i = 0; i < words.length - 1; i++) {
+      if (words[i].length > 3 && words[i + 1].length > 3) {
+        compounds.push(`${words[i]} ${words[i + 1]}`)
+      }
+    }
+
+    return [...new Set([...words, ...compounds])]
+  }
+
+  /**
+   * Proactively recall relevant memories
+   */
+  async recall(query: string, project?: string): Promise<RecallResult | null> {
+    this.recallCount++
+
+    if (!this.shouldRecall(query)) {
+      return null
+    }
+
+    const triggeredBy = this.getMatchedTriggers(query)
+    this.logger.info({ query: query.slice(0, 50), triggeredBy }, 'Proactive recall triggered')
+
+    // Extract search terms
+    const searchTerms = this.extractSearchTerms(query)
+
+    if (searchTerms.length === 0) {
+      return null
+    }
+
+    // Search for each term and combine results
+    const allMemories: Map<string, MemorySearchResult> = new Map()
+
+    // Search with the full query first
+    try {
+      const fullResults = await this.memory.searchRaw(query, {
+        project,
+        limit: 5,
+        minSimilarity: 0.5
+      })
+
+      for (const memory of fullResults) {
+        allMemories.set(memory.memory.id, memory)
+      }
+    } catch (error) {
+      this.logger.warn({ error }, 'Full query search failed')
+    }
+
+    // Then search individual terms for broader coverage
+    for (const term of searchTerms.slice(0, 5)) {
+      try {
+        const memories = await this.memory.searchRaw(term, {
+          project,
+          limit: 3,
+          minSimilarity: 0.6
+        })
+
+        for (const memory of memories) {
+          // Only add if not already present or if higher similarity
+          const existing = allMemories.get(memory.memory.id)
+          if (!existing || memory.similarity > existing.similarity) {
+            allMemories.set(memory.memory.id, memory)
+          }
+        }
+      } catch (error) {
+        this.logger.warn({ error, term }, 'Term search failed')
+      }
+    }
+
+    const memories = Array.from(allMemories.values())
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, 5)
+
+    // Calculate relevance score
+    const relevanceScore = this.calculateRelevance(query, memories)
+
+    // Update stats
+    if (memories.length > 0) {
+      this.successfulRecalls++
+      this.totalRelevance += relevanceScore
+    }
+    this.lastRecallTime = new Date()
+
+    this.logger.info(
+      {
+        query: query.slice(0, 50),
+        memoryCount: memories.length,
+        relevanceScore
+      },
+      'Proactive recall complete'
+    )
+
+    const result: RecallResult = {
+      query,
+      memories,
+      relevanceScore,
+      triggeredBy
+    }
+
+    // Add formatted context if we have results
+    if (memories.length > 0 && relevanceScore > 0.4) {
+      result.formattedContext = this.formatForContext(result)
+    }
+
+    return result
+  }
+
+  /**
+   * Calculate relevance score
+   */
+  private calculateRelevance(query: string, memories: MemorySearchResult[]): number {
+    if (memories.length === 0) return 0
+
+    // Average similarity score
+    const avgSimilarity = memories.reduce((sum, m) => sum + m.similarity, 0) / memories.length
+
+    // Recency bonus (newer memories are more relevant)
+    const now = Date.now()
+    let totalRecencyScore = 0
+
+    for (const memory of memories) {
+      const age = now - memory.memory.createdAt.getTime()
+      const daysSince = age / (1000 * 60 * 60 * 24)
+      const recencyScore = Math.max(0, 1 - (daysSince / 365)) // Decay over a year
+      totalRecencyScore += recencyScore
+    }
+
+    const avgRecency = totalRecencyScore / memories.length
+
+    // Decision bonus (decisions are more relevant than raw memories)
+    const decisionCount = memories.filter(m => m.decision).length
+    const decisionBonus = (decisionCount / memories.length) * 0.1
+
+    // Combine scores
+    return (avgSimilarity * 0.6) + (avgRecency * 0.3) + decisionBonus
+  }
+
+  /**
+   * Format memories for context
+   */
+  formatForContext(result: RecallResult): string {
+    if (result.memories.length === 0) {
+      return ''
+    }
+
+    const parts: string[] = []
+    parts.push('\n---')
+    parts.push('**Relevant Past Context** (proactively recalled):')
+    parts.push('')
+
+    for (const [i, memory] of result.memories.entries()) {
+      const title = memory.decision?.decision || memory.memory.content.slice(0, 100)
+      parts.push(`${i + 1}. **${title}**`)
+
+      if (memory.decision?.reasoning) {
+        parts.push(`   *Reasoning:* ${memory.decision.reasoning}`)
+      }
+
+      parts.push(`   *Project:* ${memory.memory.project}`)
+      parts.push(`   *Relevance:* ${Math.round(memory.similarity * 100)}%`)
+
+      const date = memory.memory.createdAt.toLocaleDateString()
+      parts.push(`   *Recorded:* ${date}`)
+      parts.push('')
+    }
+
+    parts.push('---')
+    return parts.join('\n')
+  }
+
+  /**
+   * Get recall statistics
+   */
+  getStats(): RecallStats {
+    return {
+      totalRecalls: this.recallCount,
+      successfulRecalls: this.successfulRecalls,
+      averageRelevance: this.successfulRecalls > 0
+        ? this.totalRelevance / this.successfulRecalls
+        : 0,
+      lastRecallTime: this.lastRecallTime
+    }
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats(): void {
+    this.recallCount = 0
+    this.successfulRecalls = 0
+    this.totalRelevance = 0
+    this.lastRecallTime = undefined
+  }
+
+  /**
+   * Add custom recall triggers
+   */
+  addTriggers(triggers: string[]): void {
+    for (const trigger of triggers) {
+      if (!this.RECALL_TRIGGERS.includes(trigger.toLowerCase())) {
+        (this.RECALL_TRIGGERS as string[]).push(trigger.toLowerCase())
+      }
+    }
+  }
+
+  /**
+   * Quick recall for a specific topic
+   */
+  async recallTopic(
+    topic: string,
+    project?: string,
+    limit: number = 3
+  ): Promise<MemorySearchResult[]> {
+    try {
+      return await this.memory.searchRaw(topic, {
+        project,
+        limit,
+        minSimilarity: 0.5
+      })
+    } catch (error) {
+      this.logger.error({ error, topic }, 'Topic recall failed')
+      return []
+    }
+  }
+}