claude-brain 0.30.2 → 0.30.3

package/src/memory/store.ts

@@ -1,787 +1,911 @@
-/**
- * Memory Store - CRUD Operations
- * Phase 3: Memory and Embedding System
- *
- * Handles storing and retrieving memories with embeddings
- */
-
-import { randomUUID } from 'crypto'
-import type { Database } from 'bun:sqlite'
-import type { Logger } from 'pino'
-import type {
-  Memory,
-  Decision,
-  StoreMemoryInput,
-  StoreDecisionInput,
-  MemoryRow,
-  DecisionRow
-} from './types'
-import { EmbeddingService } from './embeddings'
-import { embeddingToBuffer, bufferToEmbedding, cosineSimilarity } from './embedding-utils'
-
-export class MemoryStore {
-  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: 'memory-store' })
-  }
-
-  /**
-   * Store a new memory with embedding
-   */
-  async storeMemory(input: StoreMemoryInput): Promise<string> {
-    try {
-      // Generate embedding
-      const embedding = await this.embeddings.generateEmbedding(input.content)
-
-      // Create memory record
-      const id = randomUUID()
-      const now = new Date().toISOString()
-
-      const stmt = this.db.prepare(`
-        INSERT INTO memories (id, project, content, embedding, created_at, updated_at, metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `)
-
-      stmt.run(
-        id,
-        input.project,
-        input.content,
-        embeddingToBuffer(embedding),
-        now,
-        now,
-        input.metadata ? JSON.stringify(input.metadata) : null
-      )
-
-      this.logger.info({ id, project: input.project }, 'Memory stored')
-      return id
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store memory')
-      throw error
-    }
-  }
-
-  /**
-   * Store a decision (creates memory + decision record)
-   */
-  async storeDecision(input: StoreDecisionInput): Promise<string> {
-    try {
-      // Combine context, decision, and reasoning for embedding
-      const content = `Context: ${input.context}\nDecision: ${input.decision}\nReasoning: ${input.reasoning}`
-
-      // Store as memory
-      const memoryId = await this.storeMemory({
-        project: input.project,
-        content,
-        metadata: {
-          type: 'decision',
-          tags: input.tags || []
-        }
-      })
-
-      // Store decision details
-      const decisionId = randomUUID()
-      const stmt = this.db.prepare(`
-        INSERT INTO decisions (id, memory_id, context, decision, reasoning, alternatives, tags)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `)
-
-      stmt.run(
-        decisionId,
-        memoryId,
-        input.context,
-        input.decision,
-        input.reasoning,
-        input.alternatives || null,
-        input.tags ? JSON.stringify(input.tags) : null
-      )
-
-      this.logger.info({ decisionId, memoryId, project: input.project }, 'Decision stored')
-      return decisionId
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store decision')
-      throw error
-    }
-  }
-
-  /**
-   * Retrieve memory by ID
-   */
-  getMemory(id: string): Memory | null {
-    try {
-      const stmt = this.db.prepare(`
-        SELECT * FROM memories WHERE id = ?
-      `)
-
-      const row = stmt.get(id) as MemoryRow | null
-
-      if (!row) {
-        return null
-      }
-
-      return this.rowToMemory(row)
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to get memory')
-      return null
-    }
-  }
-
-  /**
-   * Retrieve decision by ID
-   */
-  getDecision(id: string): Decision | null {
-    try {
-      const stmt = this.db.prepare(`
-        SELECT * FROM decisions WHERE id = ?
-      `)
-
-      const row = stmt.get(id) as DecisionRow | null
-
-      if (!row) {
-        return null
-      }
-
-      return this.rowToDecision(row)
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to get decision')
-      return null
-    }
-  }
-
-  /**
-   * Get decision by memory ID
-   */
-  getDecisionByMemoryId(memoryId: string): Decision | null {
-    try {
-      const stmt = this.db.prepare(`
-        SELECT * FROM decisions WHERE memory_id = ?
-      `)
-
-      const row = stmt.get(memoryId) as DecisionRow | null
-
-      if (!row) {
-        return null
-      }
-
-      return this.rowToDecision(row)
-    } catch (error) {
-      this.logger.error({ error, memoryId }, 'Failed to get decision by memory ID')
-      return null
-    }
-  }
-
-  /**
-   * Update memory content (regenerates embedding)
-   */
-  async updateMemory(id: string, content: string): Promise<void> {
-    try {
-      // Generate new embedding
-      const embedding = await this.embeddings.generateEmbedding(content)
-
-      const stmt = this.db.prepare(`
-        UPDATE memories
-        SET content = ?, embedding = ?, updated_at = ?
-        WHERE id = ?
-      `)
-
-      stmt.run(content, embeddingToBuffer(embedding), new Date().toISOString(), id)
-
-      this.logger.info({ id }, 'Memory updated')
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to update memory')
-      throw error
-    }
-  }
-
-  /**
-   * Update decision outcome
-   */
-  updateDecisionOutcome(id: string, outcome: string): void {
-    try {
-      const stmt = this.db.prepare(`
-        UPDATE decisions
-        SET outcome = ?
-        WHERE id = ?
-      `)
-
-      stmt.run(outcome, id)
-
-      this.logger.info({ id }, 'Decision outcome updated')
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to update decision outcome')
-      throw error
-    }
-  }
-
-  /**
-   * Delete memory (cascades to decisions)
-   */
-  deleteMemory(id: string): void {
-    try {
-      const stmt = this.db.prepare('DELETE FROM memories WHERE id = ?')
-      stmt.run(id)
-      this.logger.info({ id }, 'Memory deleted')
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to delete memory')
-      throw error
-    }
-  }
-
-  /**
-   * Get all memories for a project
-   */
-  getProjectMemories(project: string): Memory[] {
-    try {
-      const stmt = this.db.prepare(`
-        SELECT * FROM memories WHERE project = ? ORDER BY created_at DESC
-      `)
-
-      const rows = stmt.all(project) as MemoryRow[]
-
-      return rows.map((row) => this.rowToMemory(row))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get project memories')
-      return []
-    }
-  }
-
-  /**
-   * Get all decisions for a project
-   */
-  getProjectDecisions(project: string): Decision[] {
-    try {
-      const stmt = this.db.prepare(`
-        SELECT d.* FROM decisions d
-        JOIN memories m ON d.memory_id = m.id
-        WHERE m.project = ?
-        ORDER BY m.created_at DESC
-      `)
-
-      const rows = stmt.all(project) as DecisionRow[]
-
-      return rows.map((row) => this.rowToDecision(row))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get project decisions')
-      return []
-    }
-  }
-
-  /**
-   * Get memory count by project
-   */
-  getMemoryCount(project?: string): number {
-    try {
-      let query = 'SELECT COUNT(*) as count FROM memories'
-      const params: string[] = []
-
-      if (project) {
-        query += ' WHERE project = ?'
-        params.push(project)
-      }
-
-      const stmt = this.db.prepare(query)
-      const result = stmt.get(...params) as { count: number }
-
-      return result.count
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get memory count')
-      return 0
-    }
-  }
-
-  /**
-   * Get all unique project names
-   */
-  getProjects(): string[] {
-    try {
-      const stmt = this.db.prepare(`
-        SELECT DISTINCT project FROM memories ORDER BY project
-      `)
-
-      const rows = stmt.all() as Array<{ project: string }>
-
-      return rows.map((row) => row.project)
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get projects')
-      return []
-    }
-  }
-
-  /**
-   * Convert database row to Memory object
-   */
-  private rowToMemory(row: MemoryRow): Memory {
-    return {
-      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
-    }
-  }
-
-  /**
-   * Store a pattern (creates memory + pattern record)
-   */
-  async storePattern(input: {
-    project: string
-    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-    description: string
-    example?: string
-    confidence: number
-    context?: string
-    source?: string
-  }): Promise<string> {
-    try {
-      const content = `Pattern (${input.pattern_type}): ${input.description}${input.context ? `\nContext: ${input.context}` : ''}${input.example ? `\nExample: ${input.example}` : ''}`
-
-      const memoryId = await this.storeMemory({
-        project: input.project,
-        content,
-        metadata: {
-          type: 'pattern',
-          pattern_type: input.pattern_type,
-          confidence: input.confidence
-        }
-      })
-
-      const patternId = randomUUID()
-      const now = new Date().toISOString()
-      const stmt = this.db.prepare(`
-        INSERT INTO patterns (id, memory_id, project, pattern_type, description, example, confidence, context, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `)
-
-      stmt.run(
-        patternId,
-        memoryId,
-        input.project,
-        input.pattern_type,
-        input.description,
-        input.example || null,
-        input.confidence,
-        input.context || null,
-        now
-      )
-
-      this.logger.info({ patternId, memoryId, project: input.project }, 'Pattern stored')
-      return patternId
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store pattern')
-      throw error
-    }
-  }
-
-  /**
-   * Store a correction (creates memory + correction record)
-   */
-  async storeCorrection(input: {
-    project: string
-    original: string
-    correction: string
-    reasoning: string
-    context?: string
-    confidence: number
-  }): Promise<string> {
-    try {
-      const content = `Correction: ${input.correction}\nOriginal: ${input.original}\nReasoning: ${input.reasoning}${input.context ? `\nContext: ${input.context}` : ''}`
-
-      const memoryId = await this.storeMemory({
-        project: input.project,
-        content,
-        metadata: {
-          type: 'correction',
-          confidence: input.confidence
-        }
-      })
-
-      const correctionId = randomUUID()
-      const now = new Date().toISOString()
-      const stmt = this.db.prepare(`
-        INSERT INTO corrections (id, memory_id, project, original, correction, reasoning, context, confidence, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `)
-
-      stmt.run(
-        correctionId,
-        memoryId,
-        input.project,
-        input.original,
-        input.correction,
-        input.reasoning,
-        input.context || null,
-        input.confidence,
-        now
-      )
-
-      this.logger.info({ correctionId, memoryId, project: input.project }, 'Correction stored')
-      return correctionId
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store correction')
-      throw error
-    }
-  }
-
-  /**
-   * Get patterns by project with optional type filter
-   */
-  getPatternsByProject(project: string, options?: {
-    pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-    limit?: number
-  }): any[] {
-    try {
-      let sql = 'SELECT * FROM patterns WHERE project = ?'
-      const params: any[] = [project]
-
-      if (options?.pattern_type) {
-        sql += ' AND pattern_type = ?'
-        params.push(options.pattern_type)
-      }
-
-      sql += ' ORDER BY created_at DESC'
-
-      if (options?.limit) {
-        sql += ' LIMIT ?'
-        params.push(options.limit)
-      }
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as any[]
-
-      return rows.map(row => ({
-        id: row.id,
-        description: row.description,
-        metadata: {
-          project: row.project,
-          pattern_type: row.pattern_type,
-          description: row.description,
-          example: row.example || '',
-          confidence: row.confidence,
-          context: row.context || '',
-          created_at: row.created_at,
-          first_seen: row.created_at,
-          last_seen: row.created_at,
-          occurrences: 1
-        }
-      }))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get patterns by project')
-      return []
-    }
-  }
-
-  /**
-   * Get corrections by project
-   */
-  getCorrectionsByProject(project: string, limit: number = 10): any[] {
-    try {
-      const stmt = this.db.prepare(
-        'SELECT * FROM corrections WHERE project = ? ORDER BY created_at DESC LIMIT ?'
-      )
-      const rows = stmt.all(project, limit) as any[]
-
-      return rows.map(row => ({
-        id: row.id,
-        correction: row.correction,
-        description: row.correction,
-        metadata: {
-          project: row.project,
-          original: row.original,
-          correction: row.correction,
-          description: row.correction,
-          reasoning: row.reasoning,
-          context: row.context || '',
-          confidence: row.confidence,
-          created_at: row.created_at,
-          first_seen: row.created_at,
-          last_seen: row.created_at,
-          occurrences: 1
-        }
-      }))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get corrections by project')
-      return []
-    }
-  }
-
-  /**
-   * Search patterns using semantic search on underlying memories
-   */
-  async searchPatterns(
-    query: string,
-    options?: {
-      project?: string
-      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-      limit?: number
-      minSimilarity?: number
-    }
-  ): Promise<any[]> {
-    try {
-      // If no query, return all patterns for the project
-      if (!query && options?.project) {
-        return this.getPatternsByProject(options.project, {
-          pattern_type: options?.pattern_type,
-          limit: options?.limit
-        })
-      }
-
-      // Generate embedding for semantic search
-      const queryEmbedding = await this.embeddings.generateEmbedding(query || 'pattern')
-
-      let sql = `
-        SELECT p.*, m.embedding, m.content as memory_content
-        FROM patterns p
-        JOIN memories m ON p.memory_id = m.id
-        WHERE 1=1
-      `
-      const params: any[] = []
-
-      if (options?.project) {
-        sql += ' AND p.project = ?'
-        params.push(options.project)
-      }
-      if (options?.pattern_type) {
-        sql += ' AND p.pattern_type = ?'
-        params.push(options.pattern_type)
-      }
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as any[]
-
-      const results = rows.map(row => {
-        const embedding = bufferToEmbedding(row.embedding)
-        const similarity = cosineSimilarity(queryEmbedding, embedding)
-        return {
-          id: row.id,
-          content: row.description,
-          metadata: {
-            project: row.project,
-            pattern_type: row.pattern_type,
-            description: row.description,
-            example: row.example || '',
-            confidence: row.confidence,
-            context: row.context || '',
-            created_at: row.created_at,
-            first_seen: row.created_at,
-            last_seen: row.created_at,
-            occurrences: 1
-          },
-          similarity
-        }
-      })
-      .filter(r => r.similarity >= (options?.minSimilarity || 0.3))
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, options?.limit || 10)
-
-      return results
-    } catch (error) {
-      this.logger.error({ error, query }, 'Pattern search failed')
-      return []
-    }
-  }
-
-  /**
-   * Search corrections using semantic search on underlying memories
-   */
-  async searchCorrections(
-    query: string,
-    options?: {
-      project?: string
-      limit?: number
-      minSimilarity?: number
-    }
-  ): Promise<any[]> {
-    try {
-      // If no query, return all corrections for the project
-      if (!query && options?.project) {
-        return this.getCorrectionsByProject(options.project, options?.limit || 10)
-      }
-
-      const queryEmbedding = await this.embeddings.generateEmbedding(query || 'correction')
-
-      let sql = `
-        SELECT c.*, m.embedding, m.content as memory_content
-        FROM corrections c
-        JOIN memories m ON c.memory_id = m.id
-        WHERE 1=1
-      `
-      const params: any[] = []
-
-      if (options?.project) {
-        sql += ' AND c.project = ?'
-        params.push(options.project)
-      }
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as any[]
-
-      const results = rows.map(row => {
-        const embedding = bufferToEmbedding(row.embedding)
-        const similarity = cosineSimilarity(queryEmbedding, embedding)
-        return {
-          id: row.id,
-          content: row.correction,
-          description: row.correction,
-          metadata: {
-            project: row.project,
-            original: row.original,
-            correction: row.correction,
-            description: row.correction,
-            reasoning: row.reasoning,
-            context: row.context || '',
-            confidence: row.confidence,
-            created_at: row.created_at,
-            first_seen: row.created_at,
-            last_seen: row.created_at,
-            occurrences: 1
-          },
-          similarity
-        }
-      })
-      .filter(r => r.similarity >= (options?.minSimilarity || 0.3))
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, options?.limit || 10)
-
-      return results
-    } catch (error) {
-      this.logger.error({ error, query }, 'Correction search failed')
-      return []
-    }
-  }
-
-  /**
-   * Get all decisions with full content (for analytical tools without ChromaDB)
-   */
-  getAllDecisionsWithContent(project?: string): any[] {
-    try {
-      let sql = `
-        SELECT d.id, d.context, d.decision, d.reasoning, d.alternatives, d.tags,
-               m.content, m.project, m.created_at, m.metadata
-        FROM decisions d
-        JOIN memories m ON d.memory_id = m.id
-      `
-      const params: any[] = []
-      if (project) {
-        sql += ' WHERE m.project = ?'
-        params.push(project)
-      }
-      sql += ' ORDER BY m.created_at DESC'
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as any[]
-
-      return rows.map(row => ({
-        id: row.id,
-        content: row.content,
-        date: row.created_at,
-        project: row.project,
-        context: row.context,
-        decision: row.decision,
-        reasoning: row.reasoning,
-        alternatives: row.alternatives,
-        tags: row.tags ? JSON.parse(row.tags) : []
-      }))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get all decisions with content')
-      return []
-    }
-  }
-
-  /**
-   * Get all patterns with full content (for analytical tools without ChromaDB)
-   */
-  getAllPatternsWithContent(project?: string): any[] {
-    try {
-      let sql = `
-        SELECT p.id, p.pattern_type, p.description, p.example, p.confidence, p.context,
-               m.content, m.project, m.created_at
-        FROM patterns p
-        JOIN memories m ON p.memory_id = m.id
-      `
-      const params: any[] = []
-      if (project) {
-        sql += ' WHERE p.project = ?'
-        params.push(project)
-      }
-      sql += ' ORDER BY m.created_at DESC'
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as any[]
-
-      return rows.map(row => ({
-        id: row.id,
-        content: row.content,
-        date: row.created_at,
-        project: row.project,
-        pattern_type: row.pattern_type,
-        description: row.description,
-        example: row.example,
-        confidence: row.confidence,
-        context: row.context
-      }))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get all patterns with content')
-      return []
-    }
-  }
-
-  /**
-   * Get all corrections with full content (for analytical tools without ChromaDB)
-   */
-  getAllCorrectionsWithContent(project?: string): any[] {
-    try {
-      let sql = `
-        SELECT c.id, c.original, c.correction, c.reasoning, c.context as correction_context,
-               c.confidence, m.content, m.project, m.created_at
-        FROM corrections c
-        JOIN memories m ON c.memory_id = m.id
-      `
-      const params: any[] = []
-      if (project) {
-        sql += ' WHERE c.project = ?'
-        params.push(project)
-      }
-      sql += ' ORDER BY m.created_at DESC'
-
-      const stmt = this.db.prepare(sql)
-      const rows = stmt.all(...params) as any[]
-
-      return rows.map(row => ({
-        id: row.id,
-        content: row.content,
-        date: row.created_at,
-        project: row.project,
-        original: row.original,
-        correction: row.correction,
-        reasoning: row.reasoning,
-        context: row.correction_context,
-        confidence: row.confidence
-      }))
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get all corrections with content')
-      return []
-    }
-  }
-
-  /**
-   * Convert database row to Decision object
-   */
-  private rowToDecision(row: DecisionRow): Decision {
-    return {
-      id: row.id,
-      memoryId: row.memory_id,
-      context: row.context,
-      decision: row.decision,
-      reasoning: row.reasoning,
-      alternatives: row.alternatives || undefined,
-      outcome: row.outcome || undefined,
-      tags: row.tags ? JSON.parse(row.tags) : undefined
-    }
-  }
-}
+/**
+ * Memory Store - CRUD Operations
+ * Phase 3: Memory and Embedding System
+ *
+ * Handles storing and retrieving memories with embeddings
+ */
+
+import { randomUUID } from 'crypto'
+import type { Database } from 'bun:sqlite'
+import type { Logger } from 'pino'
+import type {
+  Memory,
+  Decision,
+  StoreMemoryInput,
+  StoreDecisionInput,
+  MemoryRow,
+  DecisionRow
+} from './types'
+import { EmbeddingService } from './embeddings'
+import { embeddingToBuffer, bufferToEmbedding, cosineSimilarity } from './embedding-utils'
+
+/** Raw row from the patterns table */
+interface PatternRow {
+  id: string
+  memory_id: string
+  project: string
+  pattern_type: string
+  description: string
+  example: string | null
+  confidence: number
+  context: string | null
+  created_at: string
+}
+
+/** Raw row from the patterns table joined with memories (includes embedding) */
+interface PatternWithEmbeddingRow extends PatternRow {
+  embedding: Buffer | Uint8Array
+  memory_content: string
+}
+
+/** Raw row from the corrections table */
+interface CorrectionRow {
+  id: string
+  memory_id: string
+  project: string
+  original: string
+  correction: string
+  reasoning: string
+  context: string | null
+  confidence: number
+  created_at: string
+}
+
+/** Raw row from the corrections table joined with memories */
+interface CorrectionWithEmbeddingRow extends CorrectionRow {
+  embedding: Buffer | Uint8Array
+  memory_content: string
+}
+
+/** Decision joined with memory content */
+interface DecisionWithContentRow {
+  id: string
+  context: string
+  decision: string
+  reasoning: string
+  alternatives: string | null
+  tags: string | null
+  content: string
+  project: string
+  created_at: string
+  metadata: string | null
+}
+
+/** Pattern joined with memory content */
+interface PatternWithContentRow {
+  id: string
+  pattern_type: string
+  description: string
+  example: string | null
+  confidence: number
+  context: string | null
+  content: string
+  project: string
+  created_at: string
+}
+
+/** Correction joined with memory content */
+interface CorrectionWithContentRow {
+  id: string
+  original: string
+  correction: string
+  reasoning: string
+  correction_context: string | null
+  confidence: number
+  content: string
+  project: string
+  created_at: string
+}
+
+/** Formatted pattern result returned by getPatternsByProject */
+interface FormattedPatternResult {
+  id: string
+  description: string
+  metadata: {
+    project: string
+    pattern_type: string
+    description: string
+    example: string
+    confidence: number
+    context: string
+    created_at: string
+    first_seen: string
+    last_seen: string
+    occurrences: number
+  }
+}
+
+/** Formatted correction result */
+interface FormattedCorrectionResult {
+  id: string
+  correction: string
+  description: string
+  metadata: {
+    project: string
+    original: string
+    correction: string
+    description: string
+    reasoning: string
+    context: string
+    confidence: number
+    created_at: string
+    first_seen: string
+    last_seen: string
+    occurrences: number
+  }
+}
+
+/** Search result with similarity score */
+interface ScoredSearchResult {
+  id: string
+  content: string
+  metadata: Record<string, unknown>
+  similarity: number
+}
+
+export class MemoryStore {
+  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: 'memory-store' })
+  }
+
+  /**
+   * Store a new memory with embedding
+   */
+  async storeMemory(input: StoreMemoryInput): Promise<string> {
+    try {
+      // Generate embedding
+      const embedding = await this.embeddings.generateEmbedding(input.content)
+
+      // Create memory record
+      const id = randomUUID()
+      const now = new Date().toISOString()
+
+      const stmt = this.db.prepare(`
+        INSERT INTO memories (id, project, content, embedding, created_at, updated_at, metadata)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+
+      stmt.run(
+        id,
+        input.project,
+        input.content,
+        embeddingToBuffer(embedding),
+        now,
+        now,
+        input.metadata ? JSON.stringify(input.metadata) : null
+      )
+
+      this.logger.info({ id, project: input.project }, 'Memory stored')
+      return id
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store memory')
+      throw error
+    }
+  }
+
+  /**
+   * Store a decision (creates memory + decision record)
+   */
+  async storeDecision(input: StoreDecisionInput): Promise<string> {
+    try {
+      // Combine context, decision, and reasoning for embedding
+      const content = `Context: ${input.context}\nDecision: ${input.decision}\nReasoning: ${input.reasoning}`
+
+      // Store as memory
+      const memoryId = await this.storeMemory({
+        project: input.project,
+        content,
+        metadata: {
+          type: 'decision',
+          tags: input.tags || []
+        }
+      })
+
+      // Store decision details
+      const decisionId = randomUUID()
+      const stmt = this.db.prepare(`
+        INSERT INTO decisions (id, memory_id, context, decision, reasoning, alternatives, tags)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+
+      stmt.run(
+        decisionId,
+        memoryId,
+        input.context,
+        input.decision,
+        input.reasoning,
+        input.alternatives || null,
+        input.tags ? JSON.stringify(input.tags) : null
+      )
+
+      this.logger.info({ decisionId, memoryId, project: input.project }, 'Decision stored')
+      return decisionId
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store decision')
+      throw error
+    }
+  }
+
+  /**
+   * Retrieve memory by ID
+   */
+  getMemory(id: string): Memory | null {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT * FROM memories WHERE id = ?
+      `)
+
+      const row = stmt.get(id) as MemoryRow | null
+
+      if (!row) {
+        return null
+      }
+
+      return this.rowToMemory(row)
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to get memory')
+      return null
+    }
+  }
+
+  /**
+   * Retrieve decision by ID
+   */
+  getDecision(id: string): Decision | null {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT * FROM decisions WHERE id = ?
+      `)
+
+      const row = stmt.get(id) as DecisionRow | null
+
+      if (!row) {
+        return null
+      }
+
+      return this.rowToDecision(row)
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to get decision')
+      return null
+    }
+  }
+
+  /**
+   * Get decision by memory ID
+   */
+  getDecisionByMemoryId(memoryId: string): Decision | null {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT * FROM decisions WHERE memory_id = ?
+      `)
+
+      const row = stmt.get(memoryId) as DecisionRow | null
+
+      if (!row) {
+        return null
+      }
+
+      return this.rowToDecision(row)
+    } catch (error) {
+      this.logger.error({ error, memoryId }, 'Failed to get decision by memory ID')
+      return null
+    }
+  }
+
+  /**
+   * Update memory content (regenerates embedding)
+   */
+  async updateMemory(id: string, content: string): Promise<void> {
+    try {
+      // Generate new embedding
+      const embedding = await this.embeddings.generateEmbedding(content)
+
+      const stmt = this.db.prepare(`
+        UPDATE memories
+        SET content = ?, embedding = ?, updated_at = ?
+        WHERE id = ?
+      `)
+
+      stmt.run(content, embeddingToBuffer(embedding), new Date().toISOString(), id)
+
+      this.logger.info({ id }, 'Memory updated')
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to update memory')
+      throw error
+    }
+  }
+
+  /**
+   * Update decision outcome
+   */
+  updateDecisionOutcome(id: string, outcome: string): void {
+    try {
+      const stmt = this.db.prepare(`
+        UPDATE decisions
+        SET outcome = ?
+        WHERE id = ?
+      `)
+
+      stmt.run(outcome, id)
+
+      this.logger.info({ id }, 'Decision outcome updated')
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to update decision outcome')
+      throw error
+    }
+  }
+
+  /**
+   * Delete memory (cascades to decisions)
+   */
+  deleteMemory(id: string): void {
+    try {
+      const stmt = this.db.prepare('DELETE FROM memories WHERE id = ?')
+      stmt.run(id)
+      this.logger.info({ id }, 'Memory deleted')
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to delete memory')
+      throw error
+    }
+  }
+
+  /**
+   * Get all memories for a project
+   */
+  getProjectMemories(project: string): Memory[] {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT * FROM memories WHERE project = ? ORDER BY created_at DESC
+      `)
+
+      const rows = stmt.all(project) as MemoryRow[]
+
+      return rows.map((row) => this.rowToMemory(row))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get project memories')
+      return []
+    }
+  }
+
+  /**
+   * Get all decisions for a project
+   */
+  getProjectDecisions(project: string): Decision[] {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT d.* FROM decisions d
+        JOIN memories m ON d.memory_id = m.id
+        WHERE m.project = ?
+        ORDER BY m.created_at DESC
+      `)
+
+      const rows = stmt.all(project) as DecisionRow[]
+
+      return rows.map((row) => this.rowToDecision(row))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get project decisions')
+      return []
+    }
+  }
+
+  /**
+   * Get memory count by project
+   */
+  getMemoryCount(project?: string): number {
+    try {
+      let query = 'SELECT COUNT(*) as count FROM memories'
+      const params: string[] = []
+
+      if (project) {
+        query += ' WHERE project = ?'
+        params.push(project)
+      }
+
+      const stmt = this.db.prepare(query)
+      const result = stmt.get(...params) as { count: number }
+
+      return result.count
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get memory count')
+      return 0
+    }
+  }
+
+  /**
+   * Get all unique project names
+   */
+  getProjects(): string[] {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT DISTINCT project FROM memories ORDER BY project
+      `)
+
+      const rows = stmt.all() as Array<{ project: string }>
+
+      return rows.map((row) => row.project)
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get projects')
+      return []
+    }
+  }
+
+  /**
+   * Convert database row to Memory object
+   */
+  private rowToMemory(row: MemoryRow): Memory {
+    return {
+      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
+    }
+  }
+
+  /**
+   * Store a pattern (creates memory + pattern record)
+   */
+  async storePattern(input: {
+    project: string
+    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    description: string
+    example?: string
+    confidence: number
+    context?: string
+    source?: string
+  }): Promise<string> {
+    try {
+      const content = `Pattern (${input.pattern_type}): ${input.description}${input.context ? `\nContext: ${input.context}` : ''}${input.example ? `\nExample: ${input.example}` : ''}`
+
+      const memoryId = await this.storeMemory({
+        project: input.project,
+        content,
+        metadata: {
+          type: 'pattern',
+          pattern_type: input.pattern_type,
+          confidence: input.confidence
+        }
+      })
+
+      const patternId = randomUUID()
+      const now = new Date().toISOString()
+      const stmt = this.db.prepare(`
+        INSERT INTO patterns (id, memory_id, project, pattern_type, description, example, confidence, context, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+
+      stmt.run(
+        patternId,
+        memoryId,
+        input.project,
+        input.pattern_type,
+        input.description,
+        input.example || null,
+        input.confidence,
+        input.context || null,
+        now
+      )
+
+      this.logger.info({ patternId, memoryId, project: input.project }, 'Pattern stored')
+      return patternId
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store pattern')
+      throw error
+    }
+  }
+
+  /**
+   * Store a correction (creates memory + correction record)
+   */
+  async storeCorrection(input: {
+    project: string
+    original: string
+    correction: string
+    reasoning: string
+    context?: string
+    confidence: number
+  }): Promise<string> {
+    try {
+      const content = `Correction: ${input.correction}\nOriginal: ${input.original}\nReasoning: ${input.reasoning}${input.context ? `\nContext: ${input.context}` : ''}`
+
+      const memoryId = await this.storeMemory({
+        project: input.project,
+        content,
+        metadata: {
+          type: 'correction',
+          confidence: input.confidence
+        }
+      })
+
+      const correctionId = randomUUID()
+      const now = new Date().toISOString()
+      const stmt = this.db.prepare(`
+        INSERT INTO corrections (id, memory_id, project, original, correction, reasoning, context, confidence, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+
+      stmt.run(
+        correctionId,
+        memoryId,
+        input.project,
+        input.original,
+        input.correction,
+        input.reasoning,
+        input.context || null,
+        input.confidence,
+        now
+      )
+
+      this.logger.info({ correctionId, memoryId, project: input.project }, 'Correction stored')
+      return correctionId
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store correction')
+      throw error
+    }
+  }
+
+  /**
+   * Get patterns by project with optional type filter
+   */
+  getPatternsByProject(project: string, options?: {
+    pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    limit?: number
+  }): FormattedPatternResult[] {
+    try {
+      let sql = 'SELECT * FROM patterns WHERE project = ?'
+      const params: (string | number)[] = [project]
+
+      if (options?.pattern_type) {
+        sql += ' AND pattern_type = ?'
+        params.push(options.pattern_type)
+      }
+
+      sql += ' ORDER BY created_at DESC'
+
+      if (options?.limit) {
+        sql += ' LIMIT ?'
+        params.push(options.limit)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as PatternRow[]
+
+      return rows.map(row => ({
+        id: row.id,
+        description: row.description,
+        metadata: {
+          project: row.project,
+          pattern_type: row.pattern_type,
+          description: row.description,
+          example: row.example || '',
+          confidence: row.confidence,
+          context: row.context || '',
+          created_at: row.created_at,
+          first_seen: row.created_at,
+          last_seen: row.created_at,
+          occurrences: 1
+        }
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get patterns by project')
+      return []
+    }
+  }
+
+  /**
+   * Get corrections by project
+   */
+  getCorrectionsByProject(project: string, limit: number = 10): FormattedCorrectionResult[] {
+    try {
+      const stmt = this.db.prepare(
+        'SELECT * FROM corrections WHERE project = ? ORDER BY created_at DESC LIMIT ?'
+      )
+      const rows = stmt.all(project, limit) as CorrectionRow[]
+
+      return rows.map(row => ({
+        id: row.id,
+        correction: row.correction,
+        description: row.correction,
+        metadata: {
+          project: row.project,
+          original: row.original,
+          correction: row.correction,
+          description: row.correction,
+          reasoning: row.reasoning,
+          context: row.context || '',
+          confidence: row.confidence,
+          created_at: row.created_at,
+          first_seen: row.created_at,
+          last_seen: row.created_at,
+          occurrences: 1
+        }
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get corrections by project')
+      return []
+    }
+  }
+
+  /**
+   * Search patterns using semantic search on underlying memories
+   */
+  async searchPatterns(
+    query: string,
+    options?: {
+      project?: string
+      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+      limit?: number
+      minSimilarity?: number
+    }
+  ): Promise<ScoredSearchResult[]> {
+    try {
+      // If no query, return all patterns for the project
+      if (!query && options?.project) {
+        return this.getPatternsByProject(options.project, {
+          pattern_type: options?.pattern_type,
+          limit: options?.limit
+        })
+      }
+
+      // Generate embedding for semantic search
+      const queryEmbedding = await this.embeddings.generateEmbedding(query || 'pattern')
+
+      let sql = `
+        SELECT p.*, m.embedding, m.content as memory_content
+        FROM patterns p
+        JOIN memories m ON p.memory_id = m.id
+        WHERE 1=1
+      `
+      const params: (string | number)[] = []
+
+      if (options?.project) {
+        sql += ' AND p.project = ?'
+        params.push(options.project)
+      }
+      if (options?.pattern_type) {
+        sql += ' AND p.pattern_type = ?'
+        params.push(options.pattern_type)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as PatternWithEmbeddingRow[]
+
+      const results = rows.map(row => {
+        const embedding = bufferToEmbedding(row.embedding)
+        const similarity = cosineSimilarity(queryEmbedding, embedding)
+        return {
+          id: row.id,
+          content: row.description,
+          metadata: {
+            project: row.project,
+            pattern_type: row.pattern_type,
+            description: row.description,
+            example: row.example || '',
+            confidence: row.confidence,
+            context: row.context || '',
+            created_at: row.created_at,
+            first_seen: row.created_at,
+            last_seen: row.created_at,
+            occurrences: 1
+          },
+          similarity
+        }
+      })
+      .filter(r => r.similarity >= (options?.minSimilarity || 0.3))
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, options?.limit || 10)
+
+      return results
+    } catch (error) {
+      this.logger.error({ error, query }, 'Pattern search failed')
+      return []
+    }
+  }
+
+  /**
+   * Search corrections using semantic search on underlying memories
+   */
+  async searchCorrections(
+    query: string,
+    options?: {
+      project?: string
+      limit?: number
+      minSimilarity?: number
+    }
+  ): Promise<ScoredSearchResult[]> {
+    try {
+      // If no query, return all corrections for the project
+      if (!query && options?.project) {
+        return this.getCorrectionsByProject(options.project, options?.limit || 10)
+      }
+
+      const queryEmbedding = await this.embeddings.generateEmbedding(query || 'correction')
+
+      let sql = `
+        SELECT c.*, m.embedding, m.content as memory_content
+        FROM corrections c
+        JOIN memories m ON c.memory_id = m.id
+        WHERE 1=1
+      `
+      const params: (string | number)[] = []
+
+      if (options?.project) {
+        sql += ' AND c.project = ?'
+        params.push(options.project)
+      }
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as CorrectionWithEmbeddingRow[]
+
+      const results = rows.map(row => {
+        const embedding = bufferToEmbedding(row.embedding)
+        const similarity = cosineSimilarity(queryEmbedding, embedding)
+        return {
+          id: row.id,
+          content: row.correction,
+          description: row.correction,
+          metadata: {
+            project: row.project,
+            original: row.original,
+            correction: row.correction,
+            description: row.correction,
+            reasoning: row.reasoning,
+            context: row.context || '',
+            confidence: row.confidence,
+            created_at: row.created_at,
+            first_seen: row.created_at,
+            last_seen: row.created_at,
+            occurrences: 1
+          },
+          similarity
+        }
+      })
+      .filter(r => r.similarity >= (options?.minSimilarity || 0.3))
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, options?.limit || 10)
+
+      return results
+    } catch (error) {
+      this.logger.error({ error, query }, 'Correction search failed')
+      return []
+    }
+  }
+
+  /**
+   * Get all decisions with full content (for analytical tools without ChromaDB)
+   */
+  getAllDecisionsWithContent(project?: string): Record<string, unknown>[] {
+    try {
+      let sql = `
+        SELECT d.id, d.context, d.decision, d.reasoning, d.alternatives, d.tags,
+               m.content, m.project, m.created_at, m.metadata
+        FROM decisions d
+        JOIN memories m ON d.memory_id = m.id
+      `
+      const params: string[] = []
+      if (project) {
+        sql += ' WHERE m.project = ?'
+        params.push(project)
+      }
+      sql += ' ORDER BY m.created_at DESC'
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as DecisionWithContentRow[]
+
+      return rows.map(row => ({
+        id: row.id,
+        content: row.content,
+        date: row.created_at,
+        project: row.project,
+        context: row.context,
+        decision: row.decision,
+        reasoning: row.reasoning,
+        alternatives: row.alternatives,
+        tags: row.tags ? JSON.parse(row.tags) : []
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get all decisions with content')
+      return []
+    }
+  }
+
+  /**
+   * Get all patterns with full content (for analytical tools without ChromaDB)
+   */
+  getAllPatternsWithContent(project?: string): Record<string, unknown>[] {
+    try {
+      let sql = `
+        SELECT p.id, p.pattern_type, p.description, p.example, p.confidence, p.context,
+               m.content, m.project, m.created_at
+        FROM patterns p
+        JOIN memories m ON p.memory_id = m.id
+      `
+      const params: string[] = []
+      if (project) {
+        sql += ' WHERE p.project = ?'
+        params.push(project)
+      }
+      sql += ' ORDER BY m.created_at DESC'
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as PatternWithContentRow[]
+
+      return rows.map(row => ({
+        id: row.id,
+        content: row.content,
+        date: row.created_at,
+        project: row.project,
+        pattern_type: row.pattern_type,
+        description: row.description,
+        example: row.example,
+        confidence: row.confidence,
+        context: row.context
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get all patterns with content')
+      return []
+    }
+  }
+
+  /**
+   * Get all corrections with full content (for analytical tools without ChromaDB)
+   */
+  getAllCorrectionsWithContent(project?: string): Record<string, unknown>[] {
+    try {
+      let sql = `
+        SELECT c.id, c.original, c.correction, c.reasoning, c.context as correction_context,
+               c.confidence, m.content, m.project, m.created_at
+        FROM corrections c
+        JOIN memories m ON c.memory_id = m.id
+      `
+      const params: string[] = []
+      if (project) {
+        sql += ' WHERE c.project = ?'
+        params.push(project)
+      }
+      sql += ' ORDER BY m.created_at DESC'
+
+      const stmt = this.db.prepare(sql)
+      const rows = stmt.all(...params) as CorrectionWithContentRow[]
+
+      return rows.map(row => ({
+        id: row.id,
+        content: row.content,
+        date: row.created_at,
+        project: row.project,
+        original: row.original,
+        correction: row.correction,
+        reasoning: row.reasoning,
+        context: row.correction_context,
+        confidence: row.confidence
+      }))
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get all corrections with content')
+      return []
+    }
+  }
+
+  /**
+   * Convert database row to Decision object
+   */
+  private rowToDecision(row: DecisionRow): Decision {
+    return {
+      id: row.id,
+      memoryId: row.memory_id,
+      context: row.context,
+      decision: row.decision,
+      reasoning: row.reasoning,
+      alternatives: row.alternatives || undefined,
+      outcome: row.outcome || undefined,
+      tags: row.tags ? JSON.parse(row.tags) : undefined
+    }
+  }
+}