claude-brain 0.14.2 → 0.14.4

package/src/memory/learning.ts

@@ -1,378 +1,378 @@
-/**
- * Learning System
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Learns from corrections and user preferences over time
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from './index'
-
-export interface Correction {
-  id: string
-  originalDecision: string
-  correctedDecision: string
-  reasoning: string
-  project: string
-  timestamp: Date
-}
-
-export interface Preference {
-  category: string
-  preference: string
-  strength: number // 0-1
-  examples: string[]
-  lastUpdated: Date
-}
-
-export interface LearningInsights {
-  preferences: Preference[]
-  correctionCount: number
-  categoriesImproved: string[]
-  recentCorrections: Correction[]
-}
-
-export class LearningSystem {
-  private logger: Logger
-  private memory: MemoryManager
-  private corrections: Correction[] = []
-  private preferences: Map<string, Preference> = new Map()
-
-  constructor(logger: Logger, memory: MemoryManager) {
-    this.logger = logger.child({ component: 'learning-system' })
-    this.memory = memory
-  }
-
-  /**
-   * Record a correction
-   */
-  async recordCorrection(
-    originalDecision: string,
-    correctedDecision: string,
-    reasoning: string,
-    project: string
-  ): Promise<string> {
-    const correction: Correction = {
-      id: this.generateId(),
-      originalDecision,
-      correctedDecision,
-      reasoning,
-      project,
-      timestamp: new Date()
-    }
-
-    this.corrections.push(correction)
-
-    // Store in memory system
-    try {
-      await this.memory.store.storeMemory({
-        project,
-        content: `Correction: Changed "${originalDecision}" to "${correctedDecision}". Reason: ${reasoning}`,
-        metadata: {
-          type: 'correction',
-          original: originalDecision,
-          corrected: correctedDecision
-        }
-      })
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to store correction in memory')
-    }
-
-    // Extract preferences from correction
-    await this.extractPreferences(correction)
-
-    this.logger.info(
-      { correctionId: correction.id, project },
-      'Correction recorded and preferences updated'
-    )
-
-    return correction.id
-  }
-
-  /**
-   * Extract preferences from correction
-   */
-  private async extractPreferences(correction: Correction): Promise<void> {
-    // Analyze what changed
-    const category = this.categorizeCorrection(correction)
-    const preference = this.extractPreference(correction)
-
-    // Update or create preference
-    const existing = this.preferences.get(category)
-
-    if (existing) {
-      // Strengthen existing preference
-      existing.strength = Math.min(existing.strength + 0.1, 1.0)
-      existing.examples.push(correction.correctedDecision)
-      existing.lastUpdated = new Date()
-
-      // Keep only recent examples
-      if (existing.examples.length > 10) {
-        existing.examples = existing.examples.slice(-10)
-      }
-    } else {
-      // Create new preference
-      this.preferences.set(category, {
-        category,
-        preference,
-        strength: 0.5,
-        examples: [correction.correctedDecision],
-        lastUpdated: new Date()
-      })
-    }
-  }
-
-  /**
-   * Categorize correction to extract learning
-   */
-  private categorizeCorrection(correction: Correction): string {
-    const reasoning = correction.reasoning.toLowerCase()
-    const original = correction.originalDecision.toLowerCase()
-    const corrected = correction.correctedDecision.toLowerCase()
-
-    // Check various categories
-    if (reasoning.includes('naming') || reasoning.includes('convention') ||
-        reasoning.includes('name')) {
-      return 'naming-conventions'
-    }
-
-    if (reasoning.includes('architecture') || reasoning.includes('structure') ||
-        reasoning.includes('pattern')) {
-      return 'architecture-preferences'
-    }
-
-    if (reasoning.includes('library') || reasoning.includes('framework') ||
-        reasoning.includes('dependency') || reasoning.includes('package')) {
-      return 'technology-preferences'
-    }
-
-    if (reasoning.includes('testing') || reasoning.includes('test') ||
-        reasoning.includes('spec')) {
-      return 'testing-preferences'
-    }
-
-    if (reasoning.includes('style') || reasoning.includes('format') ||
-        reasoning.includes('lint')) {
-      return 'code-style'
-    }
-
-    if (reasoning.includes('performance') || reasoning.includes('speed') ||
-        reasoning.includes('optimization')) {
-      return 'performance-preferences'
-    }
-
-    if (reasoning.includes('security') || reasoning.includes('auth') ||
-        reasoning.includes('access')) {
-      return 'security-preferences'
-    }
-
-    // Try to detect from content
-    if (original.includes('use') || corrected.includes('use')) {
-      return 'technology-preferences'
-    }
-
-    return 'general'
-  }
-
-  /**
-   * Extract preference from correction
-   */
-  private extractPreference(correction: Correction): string {
-    // Use the corrected decision as the preference
-    return correction.correctedDecision
-  }
-
-  /**
-   * Get applicable preferences for context
-   */
-  getRelevantPreferences(context: string): Preference[] {
-    const contextLower = context.toLowerCase()
-
-    return Array.from(this.preferences.values())
-      .filter(pref => {
-        // Check if preference category matches context
-        const categoryWords = pref.category.split('-')
-        const contextMatches = categoryWords.some(word =>
-          contextLower.includes(word)
-        )
-
-        // Check if examples match context
-        const exampleMatches = pref.examples.some(ex =>
-          contextLower.includes(ex.toLowerCase().slice(0, 20))
-        )
-
-        return contextMatches || exampleMatches
-      })
-      .sort((a, b) => b.strength - a.strength)
-      .slice(0, 5)
-  }
-
-  /**
-   * Get all preferences
-   */
-  getAllPreferences(): Preference[] {
-    return Array.from(this.preferences.values())
-      .sort((a, b) => b.strength - a.strength)
-  }
-
-  /**
-   * Get preferences by category
-   */
-  getPreferencesByCategory(category: string): Preference | undefined {
-    return this.preferences.get(category)
-  }
-
-  /**
-   * Decay preference strength over time
-   * Call this periodically to prevent stale preferences from dominating
-   */
-  decayPreferences(decayFactor: number = 0.95): void {
-    const now = Date.now()
-    const dayInMs = 24 * 60 * 60 * 1000
-
-    for (const [key, pref] of this.preferences.entries()) {
-      const ageInDays = (now - pref.lastUpdated.getTime()) / dayInMs
-
-      // Decay more for older preferences
-      if (ageInDays > 30) {
-        pref.strength *= decayFactor
-
-        // Remove very weak preferences
-        if (pref.strength < 0.1) {
-          this.preferences.delete(key)
-        }
-      }
-    }
-  }
-
-  /**
-   * Get learning insights
-   */
-  getLearningInsights(): LearningInsights {
-    const topPrefs = Array.from(this.preferences.values())
-      .sort((a, b) => b.strength - a.strength)
-      .slice(0, 10)
-
-    const categories = new Set(this.corrections.map(c => this.categorizeCorrection(c)))
-
-    const recentCorrections = this.corrections
-      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
-      .slice(0, 5)
-
-    return {
-      preferences: topPrefs,
-      correctionCount: this.corrections.length,
-      categoriesImproved: Array.from(categories),
-      recentCorrections
-    }
-  }
-
-  /**
-   * Format learning insights as markdown
-   */
-  formatLearningInsights(): string {
-    const insights = this.getLearningInsights()
-    const parts: string[] = []
-
-    if (insights.preferences.length > 0) {
-      parts.push('## Learned Preferences\n')
-      for (const pref of insights.preferences) {
-        const confidence = Math.round(pref.strength * 100)
-        parts.push(`- **${pref.category}**: ${pref.preference} (${confidence}% confidence)\n`)
-      }
-    }
-
-    if (insights.correctionCount > 0) {
-      parts.push('\n## Correction Statistics\n')
-      parts.push(`- Total corrections: ${insights.correctionCount}\n`)
-      parts.push(`- Categories improved: ${insights.categoriesImproved.join(', ')}\n`)
-    }
-
-    if (insights.recentCorrections.length > 0) {
-      parts.push('\n## Recent Corrections\n')
-      for (const correction of insights.recentCorrections) {
-        parts.push(`- ${correction.project}: "${correction.correctedDecision}"\n`)
-      }
-    }
-
-    return parts.join('') || 'No learning data yet.'
-  }
-
-  /**
-   * Apply learned preferences to a decision
-   * Returns suggestions based on past corrections
-   */
-  async applySuggestions(
-    decision: string,
-    project: string
-  ): Promise<string[]> {
-    const suggestions: string[] = []
-    const decisionLower = decision.toLowerCase()
-
-    // Get relevant preferences
-    const relevantPrefs = this.getRelevantPreferences(decision)
-
-    for (const pref of relevantPrefs) {
-      if (pref.strength >= 0.5) {
-        // Check if the decision might conflict with preference
-        const exampleKeywords = pref.examples
-          .flatMap(ex => ex.toLowerCase().split(/\W+/))
-          .filter(w => w.length > 4)
-
-        const hasRelevantKeyword = exampleKeywords.some(keyword =>
-          decisionLower.includes(keyword)
-        )
-
-        if (hasRelevantKeyword) {
-          suggestions.push(
-            `Consider ${pref.category}: Previous preference was "${pref.preference}"`
-          )
-        }
-      }
-    }
-
-    // Check against past corrections
-    for (const correction of this.corrections) {
-      if (correction.project === project) {
-        const originalKeywords = correction.originalDecision
-          .toLowerCase()
-          .split(/\W+/)
-          .filter(w => w.length > 4)
-
-        const matchesOriginal = originalKeywords.some(keyword =>
-          decisionLower.includes(keyword)
-        )
-
-        if (matchesOriginal) {
-          suggestions.push(
-            `Note: Previously corrected similar decision. Consider: "${correction.correctedDecision}"`
-          )
-        }
-      }
-    }
-
-    return suggestions.slice(0, 3) // Return top 3 suggestions
-  }
-
-  /**
-   * Get correction history for a project
-   */
-  getProjectCorrections(project: string): Correction[] {
-    return this.corrections
-      .filter(c => c.project === project)
-      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
-  }
-
-  /**
-   * Clear all learning data
-   */
-  clearLearning(): void {
-    this.corrections = []
-    this.preferences.clear()
-    this.logger.info('Learning data cleared')
-  }
-
-  private generateId(): string {
-    return `correction-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`
-  }
-}
+/**
+ * Learning System
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Learns from corrections and user preferences over time
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from './index'
+
+export interface Correction {
+  id: string
+  originalDecision: string
+  correctedDecision: string
+  reasoning: string
+  project: string
+  timestamp: Date
+}
+
+export interface Preference {
+  category: string
+  preference: string
+  strength: number // 0-1
+  examples: string[]
+  lastUpdated: Date
+}
+
+export interface LearningInsights {
+  preferences: Preference[]
+  correctionCount: number
+  categoriesImproved: string[]
+  recentCorrections: Correction[]
+}
+
+export class LearningSystem {
+  private logger: Logger
+  private memory: MemoryManager
+  private corrections: Correction[] = []
+  private preferences: Map<string, Preference> = new Map()
+
+  constructor(logger: Logger, memory: MemoryManager) {
+    this.logger = logger.child({ component: 'learning-system' })
+    this.memory = memory
+  }
+
+  /**
+   * Record a correction
+   */
+  async recordCorrection(
+    originalDecision: string,
+    correctedDecision: string,
+    reasoning: string,
+    project: string
+  ): Promise<string> {
+    const correction: Correction = {
+      id: this.generateId(),
+      originalDecision,
+      correctedDecision,
+      reasoning,
+      project,
+      timestamp: new Date()
+    }
+
+    this.corrections.push(correction)
+
+    // Store in memory system
+    try {
+      await this.memory.store.storeMemory({
+        project,
+        content: `Correction: Changed "${originalDecision}" to "${correctedDecision}". Reason: ${reasoning}`,
+        metadata: {
+          type: 'correction',
+          original: originalDecision,
+          corrected: correctedDecision
+        }
+      })
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to store correction in memory')
+    }
+
+    // Extract preferences from correction
+    await this.extractPreferences(correction)
+
+    this.logger.info(
+      { correctionId: correction.id, project },
+      'Correction recorded and preferences updated'
+    )
+
+    return correction.id
+  }
+
+  /**
+   * Extract preferences from correction
+   */
+  private async extractPreferences(correction: Correction): Promise<void> {
+    // Analyze what changed
+    const category = this.categorizeCorrection(correction)
+    const preference = this.extractPreference(correction)
+
+    // Update or create preference
+    const existing = this.preferences.get(category)
+
+    if (existing) {
+      // Strengthen existing preference
+      existing.strength = Math.min(existing.strength + 0.1, 1.0)
+      existing.examples.push(correction.correctedDecision)
+      existing.lastUpdated = new Date()
+
+      // Keep only recent examples
+      if (existing.examples.length > 10) {
+        existing.examples = existing.examples.slice(-10)
+      }
+    } else {
+      // Create new preference
+      this.preferences.set(category, {
+        category,
+        preference,
+        strength: 0.5,
+        examples: [correction.correctedDecision],
+        lastUpdated: new Date()
+      })
+    }
+  }
+
+  /**
+   * Categorize correction to extract learning
+   */
+  private categorizeCorrection(correction: Correction): string {
+    const reasoning = correction.reasoning.toLowerCase()
+    const original = correction.originalDecision.toLowerCase()
+    const corrected = correction.correctedDecision.toLowerCase()
+
+    // Check various categories
+    if (reasoning.includes('naming') || reasoning.includes('convention') ||
+        reasoning.includes('name')) {
+      return 'naming-conventions'
+    }
+
+    if (reasoning.includes('architecture') || reasoning.includes('structure') ||
+        reasoning.includes('pattern')) {
+      return 'architecture-preferences'
+    }
+
+    if (reasoning.includes('library') || reasoning.includes('framework') ||
+        reasoning.includes('dependency') || reasoning.includes('package')) {
+      return 'technology-preferences'
+    }
+
+    if (reasoning.includes('testing') || reasoning.includes('test') ||
+        reasoning.includes('spec')) {
+      return 'testing-preferences'
+    }
+
+    if (reasoning.includes('style') || reasoning.includes('format') ||
+        reasoning.includes('lint')) {
+      return 'code-style'
+    }
+
+    if (reasoning.includes('performance') || reasoning.includes('speed') ||
+        reasoning.includes('optimization')) {
+      return 'performance-preferences'
+    }
+
+    if (reasoning.includes('security') || reasoning.includes('auth') ||
+        reasoning.includes('access')) {
+      return 'security-preferences'
+    }
+
+    // Try to detect from content
+    if (original.includes('use') || corrected.includes('use')) {
+      return 'technology-preferences'
+    }
+
+    return 'general'
+  }
+
+  /**
+   * Extract preference from correction
+   */
+  private extractPreference(correction: Correction): string {
+    // Use the corrected decision as the preference
+    return correction.correctedDecision
+  }
+
+  /**
+   * Get applicable preferences for context
+   */
+  getRelevantPreferences(context: string): Preference[] {
+    const contextLower = context.toLowerCase()
+
+    return Array.from(this.preferences.values())
+      .filter(pref => {
+        // Check if preference category matches context
+        const categoryWords = pref.category.split('-')
+        const contextMatches = categoryWords.some(word =>
+          contextLower.includes(word)
+        )
+
+        // Check if examples match context
+        const exampleMatches = pref.examples.some(ex =>
+          contextLower.includes(ex.toLowerCase().slice(0, 20))
+        )
+
+        return contextMatches || exampleMatches
+      })
+      .sort((a, b) => b.strength - a.strength)
+      .slice(0, 5)
+  }
+
+  /**
+   * Get all preferences
+   */
+  getAllPreferences(): Preference[] {
+    return Array.from(this.preferences.values())
+      .sort((a, b) => b.strength - a.strength)
+  }
+
+  /**
+   * Get preferences by category
+   */
+  getPreferencesByCategory(category: string): Preference | undefined {
+    return this.preferences.get(category)
+  }
+
+  /**
+   * Decay preference strength over time
+   * Call this periodically to prevent stale preferences from dominating
+   */
+  decayPreferences(decayFactor: number = 0.95): void {
+    const now = Date.now()
+    const dayInMs = 24 * 60 * 60 * 1000
+
+    for (const [key, pref] of this.preferences.entries()) {
+      const ageInDays = (now - pref.lastUpdated.getTime()) / dayInMs
+
+      // Decay more for older preferences
+      if (ageInDays > 30) {
+        pref.strength *= decayFactor
+
+        // Remove very weak preferences
+        if (pref.strength < 0.1) {
+          this.preferences.delete(key)
+        }
+      }
+    }
+  }
+
+  /**
+   * Get learning insights
+   */
+  getLearningInsights(): LearningInsights {
+    const topPrefs = Array.from(this.preferences.values())
+      .sort((a, b) => b.strength - a.strength)
+      .slice(0, 10)
+
+    const categories = new Set(this.corrections.map(c => this.categorizeCorrection(c)))
+
+    const recentCorrections = this.corrections
+      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
+      .slice(0, 5)
+
+    return {
+      preferences: topPrefs,
+      correctionCount: this.corrections.length,
+      categoriesImproved: Array.from(categories),
+      recentCorrections
+    }
+  }
+
+  /**
+   * Format learning insights as markdown
+   */
+  formatLearningInsights(): string {
+    const insights = this.getLearningInsights()
+    const parts: string[] = []
+
+    if (insights.preferences.length > 0) {
+      parts.push('## Learned Preferences\n')
+      for (const pref of insights.preferences) {
+        const confidence = Math.round(pref.strength * 100)
+        parts.push(`- **${pref.category}**: ${pref.preference} (${confidence}% confidence)\n`)
+      }
+    }
+
+    if (insights.correctionCount > 0) {
+      parts.push('\n## Correction Statistics\n')
+      parts.push(`- Total corrections: ${insights.correctionCount}\n`)
+      parts.push(`- Categories improved: ${insights.categoriesImproved.join(', ')}\n`)
+    }
+
+    if (insights.recentCorrections.length > 0) {
+      parts.push('\n## Recent Corrections\n')
+      for (const correction of insights.recentCorrections) {
+        parts.push(`- ${correction.project}: "${correction.correctedDecision}"\n`)
+      }
+    }
+
+    return parts.join('') || 'No learning data yet.'
+  }
+
+  /**
+   * Apply learned preferences to a decision
+   * Returns suggestions based on past corrections
+   */
+  async applySuggestions(
+    decision: string,
+    project: string
+  ): Promise<string[]> {
+    const suggestions: string[] = []
+    const decisionLower = decision.toLowerCase()
+
+    // Get relevant preferences
+    const relevantPrefs = this.getRelevantPreferences(decision)
+
+    for (const pref of relevantPrefs) {
+      if (pref.strength >= 0.5) {
+        // Check if the decision might conflict with preference
+        const exampleKeywords = pref.examples
+          .flatMap(ex => ex.toLowerCase().split(/\W+/))
+          .filter(w => w.length > 4)
+
+        const hasRelevantKeyword = exampleKeywords.some(keyword =>
+          decisionLower.includes(keyword)
+        )
+
+        if (hasRelevantKeyword) {
+          suggestions.push(
+            `Consider ${pref.category}: Previous preference was "${pref.preference}"`
+          )
+        }
+      }
+    }
+
+    // Check against past corrections
+    for (const correction of this.corrections) {
+      if (correction.project === project) {
+        const originalKeywords = correction.originalDecision
+          .toLowerCase()
+          .split(/\W+/)
+          .filter(w => w.length > 4)
+
+        const matchesOriginal = originalKeywords.some(keyword =>
+          decisionLower.includes(keyword)
+        )
+
+        if (matchesOriginal) {
+          suggestions.push(
+            `Note: Previously corrected similar decision. Consider: "${correction.correctedDecision}"`
+          )
+        }
+      }
+    }
+
+    return suggestions.slice(0, 3) // Return top 3 suggestions
+  }
+
+  /**
+   * Get correction history for a project
+   */
+  getProjectCorrections(project: string): Correction[] {
+    return this.corrections
+      .filter(c => c.project === project)
+      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
+  }
+
+  /**
+   * Clear all learning data
+   */
+  clearLearning(): void {
+    this.corrections = []
+    this.preferences.clear()
+    this.logger.info('Learning data cleared')
+  }
+
+  private generateId(): string {
+    return `correction-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`
+  }
+}