claude-brain 0.4.1 → 0.5.1

package/src/memory/store.ts

@@ -459,10 +459,14 @@ export class MemoryStore {
         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
+          created_at: row.created_at,
+          first_seen: row.created_at,
+          last_seen: row.created_at,
+          occurrences: 1
         }
       }))
     } catch (error) {
@@ -484,14 +488,19 @@ export class MemoryStore {
       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
+          created_at: row.created_at,
+          first_seen: row.created_at,
+          last_seen: row.created_at,
+          occurrences: 1
         }
       }))
     } catch (error) {
@@ -553,10 +562,14 @@ export class MemoryStore {
           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
+            created_at: row.created_at,
+            first_seen: row.created_at,
+            last_seen: row.created_at,
+            occurrences: 1
           },
           similarity
         }
@@ -613,14 +626,19 @@ export class MemoryStore {
         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
+            created_at: row.created_at,
+            first_seen: row.created_at,
+            last_seen: row.created_at,
+            occurrences: 1
           },
           similarity
         }
@@ -636,6 +654,120 @@ export class MemoryStore {
     }
   }
 
+  /**
+   * 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
    */

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

@@ -25,12 +25,82 @@ export async function handleAnalyzeDecisionEvolution(
     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.'
-      )
+      // SQLite fallback: use searchRaw for semantic search + chronological analysis
+      const results = await memory.searchRaw(topic, {
+        project: project_name,
+        limit: limit || 20,
+        minSimilarity: 0.2
+      })
+
+      if (results.length === 0) {
+        return ResponseFormatter.text(`No decisions found for topic: "${topic}"`)
+      }
+
+      // Sort chronologically
+      const sorted = results
+        .map(r => ({
+          date: r.memory?.createdAt?.toISOString?.() || r.memory?.created_at || new Date().toISOString(),
+          decision: r.decision?.decision || r.memory?.content || '',
+          reasoning: r.decision?.reasoning || '',
+          similarity: r.similarity || 0
+        }))
+        .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+
+      // Simple stability assessment based on content similarity between consecutive decisions
+      let totalSimilarity = 0
+      let comparisons = 0
+      const changes: Array<{ daysBetween: number; summary: string }> = []
+
+      for (let i = 1; i < sorted.length; i++) {
+        const prev = sorted[i - 1]
+        const curr = sorted[i]
+        const daysBetween = Math.round((new Date(curr.date).getTime() - new Date(prev.date).getTime()) / (1000 * 60 * 60 * 24))
+
+        // Simple Jaccard similarity between word sets
+        const prevWords = new Set(prev.decision.toLowerCase().split(/\s+/).filter(w => w.length > 3))
+        const currWords = new Set(curr.decision.toLowerCase().split(/\s+/).filter(w => w.length > 3))
+        const intersection = new Set([...prevWords].filter(w => currWords.has(w)))
+        const union = new Set([...prevWords, ...currWords])
+        const jaccard = union.size > 0 ? intersection.size / union.size : 0
+        totalSimilarity += jaccard
+        comparisons++
+
+        if (jaccard < 0.5) {
+          changes.push({
+            daysBetween,
+            summary: `Changed from "${prev.decision.slice(0, 60)}..." to "${curr.decision.slice(0, 60)}..."`
+          })
+        }
+      }
+
+      const avgSimilarity = comparisons > 0 ? totalSimilarity / comparisons : 1
+      const stability = avgSimilarity > 0.7 ? 'stable' : avgSimilarity > 0.4 ? 'evolving' : 'volatile'
+      const currentState = sorted[sorted.length - 1].decision
+
+      const parts: string[] = []
+      parts.push(`## Decision Evolution: "${topic}" (SQLite)`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      parts.push(`**Total decisions:** ${sorted.length}`)
+      parts.push(`**Stability:** ${stability}`)
+      parts.push(`**Current state:** ${currentState.slice(0, 200)}`)
+      parts.push('')
+
+      if (changes.length > 0) {
+        parts.push('### Changes Over Time')
+        for (const change of changes) {
+          parts.push(`- **${change.daysBetween} days apart:** ${change.summary}`)
+        }
+        parts.push('')
+      }
+
+      parts.push('### Timeline')
+      for (const entry of sorted.slice(0, 10)) {
+        const date = new Date(entry.date).toLocaleDateString()
+        parts.push(`- **${date}:** ${entry.decision.slice(0, 150)}`)
+      }
+
+      const statsLine = formatMemoryStats({ recalled: sorted.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), sorted.length) + '\n\n' + statsLine)
     }
 
     const tracker = new DecisionEvolutionTracker(

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

@@ -25,12 +25,66 @@ export async function handleDetectTrends(
     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.'
-      )
+      // SQLite fallback: frequency-based trend analysis
+      const decisions = await memory.fetchAllDecisions(project_name)
+
+      if (decisions.length === 0) {
+        return ResponseFormatter.text('No decisions found for trend analysis.')
+      }
+
+      // Filter by period
+      const cutoffDate = new Date()
+      cutoffDate.setDate(cutoffDate.getDate() - (period_days || 90))
+      const filtered = decisions.filter(d => new Date(d.date) >= cutoffDate)
+
+      if (filtered.length === 0) {
+        return ResponseFormatter.text(`No decisions found in the last ${period_days || 90} days.`)
+      }
+
+      // Extract term frequencies from decision content
+      const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'between', 'out', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either', 'neither', 'each', 'every', 'all', 'any', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'only', 'own', 'same', 'than', 'too', 'very', 'just', 'because', 'if', 'when', 'where', 'how', 'what', 'which', 'who', 'whom', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'him', 'his', 'she', 'her', 'it', 'its', 'they', 'them', 'their', 'use', 'using', 'used', 'decision', 'context', 'reasoning'])
+      const termCounts: Record<string, { count: number; projects: Set<string> }> = {}
+
+      for (const d of filtered) {
+        const text = `${d.decision || ''} ${d.context || ''} ${d.reasoning || ''}`.toLowerCase()
+        const words = text.match(/\b[a-z][a-z-]{2,}\b/g) || []
+        const seen = new Set<string>()
+        for (const word of words) {
+          if (stopWords.has(word) || seen.has(word)) continue
+          seen.add(word)
+          if (!termCounts[word]) termCounts[word] = { count: 0, projects: new Set() }
+          termCounts[word].count++
+          if (d.project) termCounts[word].projects.add(d.project)
+        }
+      }
+
+      const minOcc = min_occurrences || 2
+      const trends = Object.entries(termCounts)
+        .filter(([, v]) => v.count >= minOcc)
+        .map(([term, v]) => ({ term, occurrences: v.count, projects: Array.from(v.projects) }))
+        .sort((a, b) => b.occurrences - a.occurrences)
+        .slice(0, limit || 20)
+
+      const parts: string[] = []
+      parts.push(`## Trend Analysis (SQLite)`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      parts.push(`**Period:** Last ${period_days || 90} days`)
+      parts.push(`**Decisions analyzed:** ${filtered.length}`)
+      parts.push('')
+
+      if (trends.length > 0) {
+        parts.push('### Top Terms by Frequency')
+        for (const t of trends) {
+          parts.push(`- **${t.term}** (${t.occurrences}x, projects: ${t.projects.join(', ')})`)
+        }
+      } else {
+        parts.push('No significant trends found with current filters.')
+      }
+
+      parts.push('\n*Note: SQLite mode provides frequency-based analysis. Enable ChromaDB for momentum and rising/declining classification.*')
+
+      const statsLine = formatMemoryStats({ recalled: filtered.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), filtered.length) + '\n\n' + statsLine)
     }
 
     const detector = new TrendDetector(logger, memory.chroma.collections)

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

@@ -25,12 +25,97 @@ export async function handleFindCrossProjectPatterns(
     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.'
-      )
+      // SQLite fallback: fetch all decisions, group by project, find shared terms
+      const decisions = await memory.fetchAllDecisions()
+
+      if (decisions.length === 0) {
+        return ResponseFormatter.text('No cross-project patterns found (no decisions in database).')
+      }
+
+      // Group by project
+      const byProject: Record<string, any[]> = {}
+      for (const d of decisions) {
+        const proj = d.project || 'unknown'
+        if (!byProject[proj]) byProject[proj] = []
+        byProject[proj].push(d)
+      }
+
+      const projectNames = Object.keys(byProject)
+      const minProj = min_projects || 2
+
+      if (projectNames.length < minProj) {
+        return ResponseFormatter.text(
+          `Only ${projectNames.length} project(s) found (${projectNames.join(', ')}). Need at least ${minProj} for cross-project analysis.`
+        )
+      }
+
+      // Extract significant terms per project
+      const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'and', 'but', 'or', 'not', 'so', 'if', 'when', 'where', 'how', 'what', 'which', 'who', 'this', 'that', 'use', 'using', 'used', 'decision', 'context', 'reasoning'])
+      const termProjects: Record<string, { projects: Set<string>; examples: Array<{ project: string; content: string }> }> = {}
+
+      for (const [proj, decs] of Object.entries(byProject)) {
+        const projectTerms = new Set<string>()
+        for (const d of decs) {
+          const text = `${d.decision || ''} ${d.context || ''}`.toLowerCase()
+          const words = text.match(/\b[a-z][a-z-]{2,}\b/g) || []
+          for (const word of words) {
+            if (stopWords.has(word)) continue
+            if (!projectTerms.has(word)) {
+              projectTerms.add(word)
+              if (!termProjects[word]) termProjects[word] = { projects: new Set(), examples: [] }
+              termProjects[word].projects.add(proj)
+              if (termProjects[word].examples.length < 3) {
+                termProjects[word].examples.push({ project: proj, content: d.decision?.slice(0, 100) || d.content?.slice(0, 100) || '' })
+              }
+            }
+          }
+        }
+      }
+
+      // Filter terms that appear in >= minProj projects
+      const crossPatterns = Object.entries(termProjects)
+        .filter(([, v]) => v.projects.size >= minProj)
+        .map(([term, v]) => ({
+          description: term,
+          projects: Array.from(v.projects),
+          occurrences: v.projects.size,
+          confidence: v.projects.size / projectNames.length,
+          examples: v.examples
+        }))
+        .sort((a, b) => b.occurrences - a.occurrences)
+        .slice(0, limit || 20)
+
+      if (crossPatterns.length === 0) {
+        return ResponseFormatter.text(
+          `No cross-project patterns found (analyzed ${decisions.length} decisions across ${projectNames.length} projects).`
+        )
+      }
+
+      const parts: string[] = []
+      parts.push(`## Cross-Project Patterns (SQLite)`)
+      parts.push(`**Projects analyzed:** ${projectNames.join(', ')}`)
+      parts.push(`**Decisions analyzed:** ${decisions.length}`)
+      parts.push(`**Shared terms found:** ${crossPatterns.length}`)
+      parts.push('')
+
+      for (const pattern of crossPatterns) {
+        const confidence = Math.round(pattern.confidence * 100)
+        parts.push(`### ${pattern.description} (${confidence}% confidence)`)
+        parts.push(`**Projects:** ${pattern.projects.join(', ')}`)
+        parts.push(`**Occurrences:** ${pattern.occurrences} projects`)
+        if (pattern.examples.length > 0) {
+          parts.push('**Examples:**')
+          for (const ex of pattern.examples.slice(0, 3)) {
+            parts.push(`- [${ex.project}] ${ex.content}`)
+          }
+        }
+        parts.push('')
+      }
+
+      parts.push('*Note: SQLite mode uses term-frequency analysis. Enable ChromaDB for semantic pattern generalization.*')
+
+      const statsLine = formatMemoryStats({ patterns: crossPatterns.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), crossPatterns.length) + '\n\n' + statsLine)
     }
 
     const generalizer = new PatternGeneralizer(

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

@@ -25,21 +25,6 @@ export async function handleGetDecisionTimeline(
 
     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,
-      memory.chroma.embeddings
-    )
-
     // Parse temporal expression if provided
     let startDate: string | undefined
     let endDate: string | undefined
@@ -51,6 +36,97 @@ export async function handleGetDecisionTimeline(
       endDate = parsed.endDate
     }
 
+    if (!memory.isChromaDBEnabled()) {
+      // SQLite fallback: fetch all data and build timeline
+      const [decisions, patterns, corrections] = await Promise.all([
+        memory.fetchAllDecisions(project_name),
+        memory.fetchAllPatterns(project_name),
+        memory.fetchAllCorrections(project_name)
+      ])
+
+      // Combine into timeline entries
+      let entries: Array<{ date: string; type: string; content: string; reasoning?: string }> = []
+
+      for (const d of decisions) {
+        entries.push({
+          date: d.date,
+          type: 'decision',
+          content: d.decision || d.content,
+          reasoning: d.reasoning
+        })
+      }
+      for (const p of patterns) {
+        entries.push({
+          date: p.date,
+          type: 'pattern',
+          content: p.description || p.content
+        })
+      }
+      for (const c of corrections) {
+        entries.push({
+          date: c.date,
+          type: 'correction',
+          content: c.correction || c.content,
+          reasoning: c.reasoning
+        })
+      }
+
+      // Filter by topic (substring match)
+      if (topic) {
+        const topicLower = topic.toLowerCase()
+        entries = entries.filter(e =>
+          e.content.toLowerCase().includes(topicLower) ||
+          (e.reasoning && e.reasoning.toLowerCase().includes(topicLower))
+        )
+      }
+
+      // Filter by date range
+      if (startDate) {
+        entries = entries.filter(e => e.date >= startDate!)
+      }
+      if (endDate) {
+        entries = entries.filter(e => e.date <= endDate!)
+      }
+
+      // Sort chronologically and limit
+      entries.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+      const limited = entries.slice(0, limit || 20)
+
+      if (limited.length === 0) {
+        return ResponseFormatter.text('No decisions found for the specified criteria.')
+      }
+
+      const parts: string[] = []
+      parts.push(`## Decision Timeline (SQLite)`)
+      if (project_name) parts.push(`**Project:** ${project_name}`)
+      if (topic) parts.push(`**Topic:** ${topic}`)
+      if (limited.length > 0) {
+        parts.push(`**Period:** ${new Date(limited[0].date).toLocaleDateString()} - ${new Date(limited[limited.length - 1].date).toLocaleDateString()}`)
+      }
+      parts.push(`**Total entries:** ${limited.length}`)
+      parts.push('')
+
+      for (const entry of limited) {
+        const date = new Date(entry.date).toLocaleDateString()
+        const icon = entry.type === 'decision' ? '📋' : entry.type === 'pattern' ? '🔄' : '⚠️'
+        parts.push(`### ${icon} ${date} [${entry.type}]`)
+        parts.push(entry.content.slice(0, 200))
+        if (entry.reasoning) {
+          parts.push(`*Reasoning:* ${entry.reasoning.slice(0, 100)}`)
+        }
+        parts.push('')
+      }
+
+      const statsLine = formatMemoryStats({ recalled: limited.length })
+      return ResponseFormatter.text(withMemoryIndicator(parts.join('\n'), limited.length) + '\n\n' + statsLine)
+    }
+
+    const timelineBuilder = new TimelineBuilder(
+      logger,
+      memory.chroma.collections,
+      memory.chroma.embeddings
+    )
+
     const timeline = await timelineBuilder.buildTimeline({
       project: project_name,
       topic,

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

@@ -32,7 +32,17 @@ export async function handleGetEpisode(
     const episodeService = getEpisodeService()
     if (!episodeService) {
       return ResponseFormatter.text(
-        'Episodic memory is not enabled. Enable it by setting knowledge.episodic.enabled=true in config.'
+        '## Episodic Memory Not Available\n\n' +
+        'Episodic memory requires ChromaDB to track conversation sessions.\n\n' +
+        '**To enable:**\n' +
+        '- Start a ChromaDB server: `chroma run --path /path/to/data`\n' +
+        '- Set `CHROMA_URL=http://localhost:8000` in your environment\n' +
+        '- Set `knowledge.episodic.enabled=true` in config\n\n' +
+        '**Alternative tools that work without ChromaDB:**\n' +
+        '- `recall_similar` — search past decisions by semantic similarity\n' +
+        '- `get_patterns` — retrieve recognized patterns\n' +
+        '- `get_corrections` — retrieve lessons learned\n' +
+        '- `smart_context` — get full project context with memory recall'
       )
     }