claude-brain 0.3.7 → 0.4.1

package/src/memory/index.ts

@@ -55,6 +55,7 @@ export class MemoryManager {
   private logger: Logger
   private initialized: boolean = false
   private useChromaDB: boolean = true
+  private onDecisionStoredCallbacks: ((input: any) => void)[] = []
 
   constructor(
     dbPath: string,
@@ -176,6 +177,24 @@ export class MemoryManager {
     return this.database.healthCheck()
   }
 
+  /**
+   * Check if ChromaDB backend is enabled and connected
+   */
+  isChromaDBEnabled(): boolean {
+    return this.useChromaDB
+  }
+
+  /**
+   * Add a listener that fires when a decision is stored (from any backend)
+   */
+  addDecisionStoredListener(callback: (input: any) => void): void {
+    this.onDecisionStoredCallbacks.push(callback)
+    // Also wire to ChromaDB listener if available
+    if (this.useChromaDB) {
+      this.chroma.store.addDecisionStoredListener(callback)
+    }
+  }
+
   async rememberDecision(
     project: string,
     context: string,
@@ -193,7 +212,7 @@ export class MemoryManager {
         tags: options?.tags
       })
     }
-    return this.store.storeDecision({
+    const id = await this.store.storeDecision({
       project,
       context,
       decision,
@@ -201,6 +220,13 @@ export class MemoryManager {
       alternatives: options?.alternatives,
       tags: options?.tags
     })
+    // Notify listeners (e.g., knowledge graph builder) for SQLite path
+    for (const cb of this.onDecisionStoredCallbacks) {
+      try {
+        cb({ project, context, decision, reasoning, alternatives: options?.alternatives, tags: options?.tags, id })
+      } catch {}
+    }
+    return id
   }
 
   /**
@@ -281,7 +307,7 @@ export class MemoryManager {
   }
 
   /**
-   * Store a pattern in memory
+   * Store a pattern in memory — routes to ChromaDB or SQLite
    */
   async storePattern(input: {
     project: string
@@ -291,14 +317,14 @@ export class MemoryManager {
     confidence: number
     context?: string
   }): Promise<string> {
-    if (!this.useChromaDB) {
-      throw new Error('Pattern storage requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.storePattern(input)
     }
-    return this.chroma.store.storePattern(input)
+    return this.store.storePattern(input)
   }
 
   /**
-   * Store a correction/lesson learned in memory
+   * Store a correction/lesson learned — routes to ChromaDB or SQLite
    */
   async storeCorrection(input: {
     project: string
@@ -308,14 +334,14 @@ export class MemoryManager {
     context?: string
     confidence: number
   }): Promise<string> {
-    if (!this.useChromaDB) {
-      throw new Error('Correction storage requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.storeCorrection(input)
     }
-    return this.chroma.store.storeCorrection(input)
+    return this.store.storeCorrection(input)
   }
 
   /**
-   * Get patterns for a project
+   * Get patterns for a project — routes to ChromaDB or SQLite
    */
   async getPatterns(
     project?: string,
@@ -324,35 +350,39 @@ export class MemoryManager {
       limit?: number
     }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Pattern retrieval requires ChromaDB backend')
+    if (this.useChromaDB) {
+      if (project) {
+        return this.chroma.store.getPatternsByProject(project, options)
+      }
+      return this.chroma.store.searchPatterns('', { limit: options?.limit || 10 })
     }
     if (project) {
-      return this.chroma.store.getPatternsByProject(project, options)
+      return this.store.getPatternsByProject(project, options)
     }
-    // If no project specified, search all patterns
-    return this.chroma.store.searchPatterns('', { limit: options?.limit || 10 })
+    return this.store.searchPatterns('', { limit: options?.limit || 10 })
   }
 
   /**
-   * Get corrections for a project
+   * Get corrections for a project — routes to ChromaDB or SQLite
    */
   async getCorrections(
     project?: string,
     options?: { limit?: number }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Correction retrieval requires ChromaDB backend')
+    if (this.useChromaDB) {
+      if (project) {
+        return this.chroma.store.getCorrectionsByProject(project, options?.limit || 10)
+      }
+      return this.chroma.store.searchCorrections('', { limit: options?.limit || 10 })
     }
     if (project) {
-      return this.chroma.store.getCorrectionsByProject(project, options?.limit || 10)
+      return this.store.getCorrectionsByProject(project, options?.limit || 10)
     }
-    // If no project specified, search all corrections
-    return this.chroma.store.searchCorrections('', { limit: options?.limit || 10 })
+    return this.store.searchCorrections('', { limit: options?.limit || 10 })
   }
 
   /**
-   * Search patterns by query
+   * Search patterns by query — routes to ChromaDB or SQLite
    */
   async searchPatterns(
     query: string,
@@ -363,14 +393,14 @@ export class MemoryManager {
       minSimilarity?: number
     }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Pattern search requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.searchPatterns(query, options)
     }
-    return this.chroma.store.searchPatterns(query, options)
+    return this.store.searchPatterns(query, options)
   }
 
   /**
-   * Search corrections by query
+   * Search corrections by query — routes to ChromaDB or SQLite
    */
   async searchCorrections(
     query: string,
@@ -380,10 +410,10 @@ export class MemoryManager {
       minSimilarity?: number
     }
   ): Promise<any[]> {
-    if (!this.useChromaDB) {
-      throw new Error('Correction search requires ChromaDB backend')
+    if (this.useChromaDB) {
+      return this.chroma.store.searchCorrections(query, options)
     }
-    return this.chroma.store.searchCorrections(query, options)
+    return this.store.searchCorrections(query, options)
   }
 }
 

package/src/memory/schema.ts

@@ -41,12 +41,44 @@ CREATE TABLE IF NOT EXISTS decisions (
 -- Index for decision lookups
 CREATE INDEX IF NOT EXISTS idx_decisions_memory
   ON decisions(memory_id);
+
+-- Patterns table (Phase 12)
+-- Stores reusable patterns with SQLite fallback
+CREATE TABLE IF NOT EXISTS patterns (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  project TEXT NOT NULL,
+  pattern_type TEXT NOT NULL CHECK(pattern_type IN ('solution','anti-pattern','best-practice','common-issue')),
+  description TEXT NOT NULL,
+  example TEXT,
+  confidence REAL DEFAULT 0.8,
+  context TEXT,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_patterns_project ON patterns(project);
+
+-- Corrections table (Phase 12)
+-- Stores lessons learned with SQLite fallback
+CREATE TABLE IF NOT EXISTS corrections (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  project TEXT NOT NULL,
+  original TEXT NOT NULL,
+  correction TEXT NOT NULL,
+  reasoning TEXT NOT NULL,
+  context TEXT,
+  confidence REAL DEFAULT 0.9,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_corrections_project ON corrections(project);
 `
 
 /**
  * Schema version for migrations
  */
-export const SCHEMA_VERSION = 1
+export const SCHEMA_VERSION = 2
 
 /**
  * Check if schema needs migration

package/src/memory/store.ts

@@ -17,7 +17,7 @@ import type {
   DecisionRow
 } from './types'
 import { EmbeddingService } from './embeddings'
-import { embeddingToBuffer, bufferToEmbedding } from './embedding-utils'
+import { embeddingToBuffer, bufferToEmbedding, cosineSimilarity } from './embedding-utils'
 
 export class MemoryStore {
   private db: Database
@@ -326,6 +326,316 @@ export class MemoryStore {
     }
   }
 
+  /**
+   * 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
+  }): 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,
+          example: row.example || '',
+          confidence: row.confidence,
+          context: row.context || '',
+          created_at: row.created_at
+        }
+      }))
+    } 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,
+        metadata: {
+          project: row.project,
+          original: row.original,
+          correction: row.correction,
+          reasoning: row.reasoning,
+          context: row.context || '',
+          confidence: row.confidence,
+          created_at: row.created_at
+        }
+      }))
+    } 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,
+            example: row.example || '',
+            confidence: row.confidence,
+            context: row.context || '',
+            created_at: row.created_at
+          },
+          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,
+          metadata: {
+            project: row.project,
+            original: row.original,
+            correction: row.correction,
+            reasoning: row.reasoning,
+            context: row.context || '',
+            confidence: row.confidence,
+            created_at: row.created_at
+          },
+          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 []
+    }
+  }
+
   /**
    * Convert database row to Decision object
    */

package/src/server/handlers/tools/analyze-decision-evolution.ts

@@ -23,6 +23,16 @@ export async function handleAnalyzeDecisionEvolution(
     const { topic, project_name, limit } = input
 
     const memory = getMemoryService()
+
+    if (!memory.isChromaDBEnabled()) {
+      return ResponseFormatter.text(
+        `No decisions found for topic: "${topic}"\n\n` +
+        'Note: ChromaDB is not connected. Decision evolution analysis requires ChromaDB for semantic search. ' +
+        'Decisions stored via SQLite fallback are available through recall_similar. ' +
+        'To enable evolution tracking, start a ChromaDB server or configure persistent mode.'
+      )
+    }
+
     const tracker = new DecisionEvolutionTracker(
       logger,
       memory.chroma.collections,

package/src/server/handlers/tools/detect-trends.ts

@@ -23,6 +23,16 @@ export async function handleDetectTrends(
     const { project_name, period_days, min_occurrences, limit } = input
 
     const memory = getMemoryService()
+
+    if (!memory.isChromaDBEnabled()) {
+      return ResponseFormatter.text(
+        'No decisions found for trend analysis.\n\n' +
+        'Note: ChromaDB is not connected. Trend detection requires ChromaDB for semantic search across decisions. ' +
+        'Decisions stored via SQLite fallback are available through recall_similar and get_patterns. ' +
+        'To enable trend detection, start a ChromaDB server or configure persistent mode.'
+      )
+    }
+
     const detector = new TrendDetector(logger, memory.chroma.collections)
 
     const analysis = await detector.detectTrends({

package/src/server/handlers/tools/find-cross-project-patterns.ts

@@ -23,6 +23,16 @@ export async function handleFindCrossProjectPatterns(
     const { min_projects, limit, query } = input
 
     const memory = getMemoryService()
+
+    if (!memory.isChromaDBEnabled()) {
+      return ResponseFormatter.text(
+        'No cross-project patterns found.\n\n' +
+        'Note: ChromaDB is not connected. Cross-project pattern analysis requires ChromaDB for semantic search across decisions. ' +
+        'Decisions stored via SQLite fallback are available through recall_similar and get_patterns. ' +
+        'To enable cross-project analysis, start a ChromaDB server or configure persistent mode.'
+      )
+    }
+
     const generalizer = new PatternGeneralizer(
       logger,
       memory.chroma.collections,

package/src/server/handlers/tools/get-decision-timeline.ts

@@ -24,6 +24,16 @@ export async function handleGetDecisionTimeline(
     const { project_name, topic, time_range, limit } = input
 
     const memory = getMemoryService()
+
+    if (!memory.isChromaDBEnabled()) {
+      return ResponseFormatter.text(
+        'No decisions found for the specified criteria.\n\n' +
+        'Note: ChromaDB is not connected. Decision timeline requires ChromaDB for semantic search. ' +
+        'Decisions stored via SQLite fallback are available through recall_similar. ' +
+        'To enable timeline view, start a ChromaDB server or configure persistent mode.'
+      )
+    }
+
     const timelineBuilder = new TimelineBuilder(
       logger,
       memory.chroma.collections,

package/src/server/handlers/tools/get-recommendations.ts

@@ -23,6 +23,16 @@ export async function handleGetRecommendations(
     const { query, project_name, limit } = input
 
     const memory = getMemoryService()
+
+    if (!memory.isChromaDBEnabled()) {
+      return ResponseFormatter.text(
+        `No recommendations found for: "${query}"\n\n` +
+        'Note: ChromaDB is not connected. Recommendations require ChromaDB for semantic search across patterns, corrections, and decisions. ' +
+        'Decisions stored via SQLite fallback are available through recall_similar, get_patterns, and get_corrections. ' +
+        'To enable recommendations, start a ChromaDB server or configure persistent mode.'
+      )
+    }
+
     const recommender = new Recommender(
       logger,
       memory.chroma.collections,

package/src/server/handlers/tools/schemas.ts

@@ -204,7 +204,7 @@ export const GetRecommendationsSchema = z.object({
 })
 
 export const FindCrossProjectPatternsSchema = z.object({
-  min_projects: z.number().int().min(2).max(50).optional().default(2),
+  min_projects: z.number().int().min(1).max(50).optional().default(2),
   limit: z.number().int().min(1).max(100).optional().default(20),
   query: z.string().optional()
 })

package/src/server/handlers/tools/search-knowledge-graph.ts

@@ -5,7 +5,7 @@
 
 import type { Logger } from 'pino'
 import type { ToolResponse } from '@/tools/types'
-import { getKnowledgeGraphService, isServicesInitialized } from '@/server/services'
+import { getKnowledgeGraphService, getMemoryService, isServicesInitialized } from '@/server/services'
 import { ToolValidator } from '@/server/utils/validators'
 import { ResponseFormatter } from '@/server/utils/response-formatter'
 import { ErrorHandler } from '@/server/utils/error-handler'
@@ -72,6 +72,19 @@ export async function handleSearchKnowledgeGraph(
       edgeCount: result.edges.length
     }, 'Knowledge graph search complete')
 
+    // If graph is empty and ChromaDB is not connected, add guidance
+    if (result.nodes.length === 0 && result.edges.length === 0) {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) {
+        return ResponseFormatter.text(
+          'Knowledge graph is empty (0 nodes, 0 edges).\n\n' +
+          'Note: ChromaDB is not connected. The knowledge graph is populated from stored decisions. ' +
+          'New decisions stored via SQLite will populate the graph going forward. ' +
+          'To migrate existing decisions into the graph, start a ChromaDB server or configure persistent mode.'
+        )
+      }
+    }
+
     return ResponseFormatter.json(response, 'Knowledge Graph Search Results')
 
   } catch (error) {