claude-brain 0.3.0

package/src/memory/patterns.ts

@@ -0,0 +1,396 @@
+/**
+ * Pattern Recognition System
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Detects recurring patterns across projects and decisions
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from './index'
+import type { Decision, MemorySearchResult } from './types'
+
+export interface Pattern {
+  id: string
+  type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+  description: string
+  occurrences: number
+  projects: string[]
+  examples: string[]
+  confidence: number
+  firstSeen: Date
+  lastSeen: Date
+}
+
+interface DecisionWithProject {
+  decision: string
+  reasoning?: string
+  project: string
+  timestamp: Date
+  tags?: string[]
+}
+
+export class PatternRecognizer {
+  private logger: Logger
+  private memory: MemoryManager
+  private patterns: Map<string, Pattern> = new Map()
+
+  constructor(logger: Logger, memory: MemoryManager) {
+    this.logger = logger.child({ component: 'pattern-recognizer' })
+    this.memory = memory
+  }
+
+  /**
+   * Analyze all decisions to find patterns
+   */
+  async analyzePatterns(): Promise<Pattern[]> {
+    this.logger.info('Analyzing patterns across all projects')
+
+    try {
+      // Get all decisions from all projects
+      const allDecisions = await this.getAllDecisions()
+
+      if (allDecisions.length < 3) {
+        this.logger.info('Not enough decisions for pattern analysis')
+        return []
+      }
+
+      // Group by similarity
+      const clusters = await this.clusterDecisions(allDecisions)
+
+      // Extract patterns from clusters
+      const patterns = this.extractPatterns(clusters)
+
+      // Store patterns
+      for (const pattern of patterns) {
+        this.patterns.set(pattern.id, pattern)
+      }
+
+      this.logger.info(
+        { patternCount: patterns.length },
+        'Pattern analysis complete'
+      )
+
+      return patterns
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to analyze patterns')
+      return []
+    }
+  }
+
+  /**
+   * Get all decisions from all projects
+   */
+  private async getAllDecisions(): Promise<DecisionWithProject[]> {
+    const projects = this.memory.store.getProjects()
+    const allDecisions: DecisionWithProject[] = []
+
+    for (const project of projects) {
+      const decisions = this.memory.store.getProjectDecisions(project)
+
+      for (const decision of decisions) {
+        // Get associated memory for timestamp
+        const memory = this.memory.store.getMemory(decision.memoryId)
+
+        allDecisions.push({
+          decision: decision.decision,
+          reasoning: decision.reasoning,
+          project,
+          timestamp: memory?.createdAt || new Date(),
+          tags: decision.tags
+        })
+      }
+    }
+
+    return allDecisions
+  }
+
+  /**
+   * Cluster similar decisions together
+   */
+  private async clusterDecisions(decisions: DecisionWithProject[]): Promise<DecisionWithProject[][]> {
+    const clusters: DecisionWithProject[][] = []
+    const processed = new Set<number>()
+
+    for (let i = 0; i < decisions.length; i++) {
+      if (processed.has(i)) continue
+
+      const decision = decisions[i]
+      const cluster: DecisionWithProject[] = [decision]
+      processed.add(i)
+
+      // Find similar decisions using semantic search
+      try {
+        const similar = await this.memory.searchRaw(
+          decision.decision,
+          {
+            limit: 10,
+            minSimilarity: 0.75
+          }
+        )
+
+        // Map similar results back to our decision array
+        for (const result of similar) {
+          if (result.decision) {
+            // Find matching decision in our array
+            for (let j = 0; j < decisions.length; j++) {
+              if (!processed.has(j) &&
+                  decisions[j].decision === result.decision.decision) {
+                cluster.push(decisions[j])
+                processed.add(j)
+              }
+            }
+          }
+        }
+      } catch (error) {
+        this.logger.warn({ error }, 'Error finding similar decisions')
+      }
+
+      // Only add cluster if it has enough items
+      if (cluster.length >= 3) {
+        clusters.push(cluster)
+      }
+    }
+
+    return clusters
+  }
+
+  /**
+   * Extract patterns from decision clusters
+   */
+  private extractPatterns(clusters: DecisionWithProject[][]): Pattern[] {
+    const patterns: Pattern[] = []
+
+    for (const cluster of clusters) {
+      const pattern = this.analyzeCluster(cluster)
+
+      if (pattern) {
+        patterns.push(pattern)
+      }
+    }
+
+    return patterns
+  }
+
+  /**
+   * Analyze a cluster to find the common pattern
+   */
+  private analyzeCluster(cluster: DecisionWithProject[]): Pattern | null {
+    if (cluster.length < 3) return null
+
+    // Extract common keywords
+    const keywords = this.extractCommonKeywords(cluster)
+
+    if (keywords.length === 0) return null
+
+    // Determine pattern type
+    const type = this.determinePatternType(cluster)
+
+    // Create pattern description
+    const description = this.generatePatternDescription(keywords, type)
+
+    // Get unique projects
+    const projects = [...new Set(cluster.map(d => d.project))]
+
+    // Get timestamps
+    const timestamps = cluster.map(d => d.timestamp.getTime())
+
+    return {
+      id: this.generatePatternId(description),
+      type,
+      description,
+      occurrences: cluster.length,
+      projects,
+      examples: cluster.slice(0, 3).map(d => d.decision),
+      confidence: this.calculateConfidence(cluster),
+      firstSeen: new Date(Math.min(...timestamps)),
+      lastSeen: new Date(Math.max(...timestamps))
+    }
+  }
+
+  /**
+   * Extract common keywords from decisions
+   */
+  private extractCommonKeywords(decisions: DecisionWithProject[]): string[] {
+    const wordFreq: Map<string, number> = new Map()
+
+    // Stop words to filter out
+    const stopWords = new Set([
+      'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+      'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',
+      'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+      'could', 'should', 'may', 'might', 'must', 'shall', 'can', 'need',
+      'this', 'that', 'these', 'those', 'it', 'its', 'we', 'our', 'you',
+      'your', 'they', 'their', 'use', 'using', 'because', 'since'
+    ])
+
+    for (const decision of decisions) {
+      const words = decision.decision
+        .toLowerCase()
+        .split(/\W+/)
+        .filter(w => w.length > 4 && !stopWords.has(w))
+
+      for (const word of words) {
+        wordFreq.set(word, (wordFreq.get(word) || 0) + 1)
+      }
+    }
+
+    // Return top keywords that appear in multiple decisions
+    return Array.from(wordFreq.entries())
+      .filter(([_, count]) => count >= 2)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([word]) => word)
+  }
+
+  /**
+   * Determine pattern type from cluster
+   */
+  private determinePatternType(cluster: DecisionWithProject[]): Pattern['type'] {
+    // Check for anti-pattern indicators
+    const hasNegative = cluster.some(d => {
+      const text = (d.reasoning || '').toLowerCase()
+      return text.includes('avoid') ||
+             text.includes("don't") ||
+             text.includes('problem') ||
+             text.includes('mistake') ||
+             text.includes('bad')
+    })
+
+    if (hasNegative) return 'anti-pattern'
+
+    // Check for best practice indicators
+    const hasBestPractice = cluster.some(d => {
+      const text = (d.reasoning || '').toLowerCase()
+      return text.includes('best practice') ||
+             text.includes('recommended') ||
+             text.includes('standard') ||
+             d.tags?.includes('best-practice')
+    })
+
+    if (hasBestPractice) return 'best-practice'
+
+    // Check for issue indicators
+    const hasIssue = cluster.some(d => {
+      const text = (d.reasoning || '').toLowerCase()
+      return text.includes('issue') ||
+             text.includes('bug') ||
+             text.includes('fix')
+    })
+
+    if (hasIssue) return 'common-issue'
+
+    return 'solution'
+  }
+
+  /**
+   * Generate pattern description
+   */
+  private generatePatternDescription(keywords: string[], type: Pattern['type']): string {
+    const keywordPhrase = keywords.join(', ')
+
+    switch (type) {
+      case 'anti-pattern':
+        return `Avoid: ${keywordPhrase} - identified as anti-pattern`
+      case 'best-practice':
+        return `Best practice: ${keywordPhrase}`
+      case 'common-issue':
+        return `Common issue: ${keywordPhrase}`
+      case 'solution':
+      default:
+        return `Common solution: ${keywordPhrase}`
+    }
+  }
+
+  /**
+   * Calculate confidence score for pattern
+   */
+  private calculateConfidence(cluster: DecisionWithProject[]): number {
+    // More occurrences = higher confidence
+    // More projects = higher confidence
+    const projects = new Set(cluster.map(d => d.project))
+
+    const occurrenceScore = Math.min(cluster.length / 10, 1)
+    const projectScore = Math.min(projects.size / 5, 1)
+
+    return (occurrenceScore + projectScore) / 2
+  }
+
+  /**
+   * Generate unique ID for pattern
+   */
+  private generatePatternId(description: string): string {
+    return description
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .slice(0, 50)
+  }
+
+  /**
+   * Get patterns matching query
+   */
+  async getRelevantPatterns(query: string): Promise<Pattern[]> {
+    const allPatterns = Array.from(this.patterns.values())
+
+    if (allPatterns.length === 0) {
+      // Try to analyze patterns first
+      await this.analyzePatterns()
+    }
+
+    // Score patterns by relevance
+    const scored = Array.from(this.patterns.values()).map(pattern => ({
+      pattern,
+      score: this.scorePatternRelevance(pattern, query)
+    }))
+
+    // Return top patterns
+    return scored
+      .filter(p => p.score > 0.3)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 5)
+      .map(p => p.pattern)
+  }
+
+  /**
+   * Score pattern relevance to query
+   */
+  private scorePatternRelevance(pattern: Pattern, query: string): number {
+    const queryLower = query.toLowerCase()
+    const descLower = pattern.description.toLowerCase()
+
+    // Exact match
+    if (descLower.includes(queryLower)) return 1.0
+
+    // Word overlap
+    const queryWords = queryLower.split(/\W+/).filter(w => w.length > 2)
+    const descWords = descLower.split(/\W+/).filter(w => w.length > 2)
+
+    if (queryWords.length === 0) return 0
+
+    const overlap = queryWords.filter(w => descWords.includes(w)).length
+
+    return overlap / queryWords.length
+  }
+
+  /**
+   * Get all detected patterns
+   */
+  getAllPatterns(): Pattern[] {
+    return Array.from(this.patterns.values())
+  }
+
+  /**
+   * Get patterns by type
+   */
+  getPatternsByType(type: Pattern['type']): Pattern[] {
+    return Array.from(this.patterns.values())
+      .filter(p => p.type === type)
+  }
+
+  /**
+   * Clear all patterns (useful for re-analysis)
+   */
+  clearPatterns(): void {
+    this.patterns.clear()
+    this.logger.info('Patterns cleared')
+  }
+}

package/src/memory/schema.ts

@@ -0,0 +1,56 @@
+/**
+ * Database Schema for Memory System
+ * Phase 3: Memory and Embedding System
+ *
+ * Uses SQLite with vectors stored as BLOBs (float32 arrays)
+ */
+
+export const MEMORY_SCHEMA = `
+-- Main memories table
+-- Stores content with vector embeddings for semantic search
+CREATE TABLE IF NOT EXISTS memories (
+  id TEXT PRIMARY KEY,
+  project TEXT NOT NULL,
+  content TEXT NOT NULL,
+  embedding BLOB NOT NULL,  -- Vector stored as BLOB (float32 array)
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  metadata TEXT  -- JSON metadata
+);
+
+-- Indexes for efficient filtering
+CREATE INDEX IF NOT EXISTS idx_memories_project
+  ON memories(project);
+CREATE INDEX IF NOT EXISTS idx_memories_created
+  ON memories(created_at);
+
+-- Decisions table (specific type of memory)
+-- Links to memories for full embedding support
+CREATE TABLE IF NOT EXISTS decisions (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  context TEXT NOT NULL,
+  decision TEXT NOT NULL,
+  reasoning TEXT NOT NULL,
+  alternatives TEXT,
+  outcome TEXT,
+  tags TEXT,  -- JSON array of tags
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+
+-- Index for decision lookups
+CREATE INDEX IF NOT EXISTS idx_decisions_memory
+  ON decisions(memory_id);
+`
+
+/**
+ * Schema version for migrations
+ */
+export const SCHEMA_VERSION = 1
+
+/**
+ * Check if schema needs migration
+ */
+export const MIGRATION_CHECK = `
+SELECT name FROM sqlite_master WHERE type='table' AND name='memories';
+`