claude-brain 0.30.2 → 0.30.3

package/src/memory/compression.ts

@@ -1,121 +1,121 @@
-/**
- * Observation Compressor — Phase 30
- * Optional LLM-based compression for long observations.
- * Uses Anthropic API directly via fetch (no Agent SDK dependency).
- * Graceful fallback: if compression fails, store original text.
- */
-
-import type { Logger } from 'pino'
-
-export interface CompressionConfig {
-  enabled: boolean
-  provider: 'claude' | 'ollama'
-  model: string
-  apiKey?: string
-  minContentLength: number
-}
-
-export interface CompressedObservation {
-  summary: string
-  original?: string
-  compressed: boolean
-}
-
-export class ObservationCompressor {
-  private config: CompressionConfig
-  private logger: Logger
-
-  constructor(config: CompressionConfig, logger: Logger) {
-    this.config = config
-    this.logger = logger.child({ component: 'compressor' })
-  }
-
-  async compress(content: string, category: string): Promise<CompressedObservation> {
-    if (!this.config.enabled || content.length < this.config.minContentLength) {
-      return { summary: content, compressed: false }
-    }
-
-    const prompt = `Compress this ${category} observation into a concise summary (2-3 sentences max).
-Preserve: the core decision/insight, reasoning, and any specific technologies mentioned.
-Drop: filler words, repetition, context that's obvious from the category.
-
-Observation: ${content}`
-
-    try {
-      const startTime = Date.now()
-      const response = await this.callLLM(prompt)
-      const result: CompressedObservation = { summary: response, original: content, compressed: true }
-
-      // SLM Phase 1A: Log compression input/output pair as gold training data
-      try {
-        const { logTrainingData } = require('@/training/data-store')
-        logTrainingData({
-          task: 'compress' as const,
-          input: content,
-          output: JSON.stringify({ summary: response }),
-          metadata: JSON.stringify({ category, elapsed_ms: Date.now() - startTime, provider: this.config.provider }),
-        })
-      } catch {
-        // Non-critical
-      }
-
-      return result
-    } catch (error) {
-      this.logger.warn({ error }, 'LLM compression failed, storing original')
-      return { summary: content, compressed: false }
-    }
-  }
-
-  private async callLLM(prompt: string): Promise<string> {
-    const apiKey = this.config.apiKey || process.env.ANTHROPIC_API_KEY
-    if (!apiKey) {
-      throw new Error('No API key configured for compression')
-    }
-
-    if (this.config.provider === 'ollama') {
-      return this.callOllama(prompt)
-    }
-
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01'
-      },
-      body: JSON.stringify({
-        model: this.config.model || 'claude-haiku-4-5-20251001',
-        max_tokens: 200,
-        messages: [{ role: 'user', content: prompt }]
-      }),
-      signal: AbortSignal.timeout(10000)
-    })
-
-    if (!res.ok) {
-      throw new Error(`Anthropic API error: ${res.status} ${res.statusText}`)
-    }
-
-    const data = await res.json() as { content: Array<{ text: string }> }
-    return data.content[0].text
-  }
-
-  private async callOllama(prompt: string): Promise<string> {
-    const res = await fetch('http://localhost:11434/api/generate', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        model: this.config.model || 'llama3',
-        prompt,
-        stream: false
-      }),
-      signal: AbortSignal.timeout(10000)
-    })
-
-    if (!res.ok) {
-      throw new Error(`Ollama API error: ${res.status} ${res.statusText}`)
-    }
-
-    const data = await res.json() as { response: string }
-    return data.response
-  }
-}
+/**
+ * Observation Compressor — Phase 30
+ * Optional LLM-based compression for long observations.
+ * Uses Anthropic API directly via fetch (no Agent SDK dependency).
+ * Graceful fallback: if compression fails, store original text.
+ */
+
+import type { Logger } from 'pino'
+
+export interface CompressionConfig {
+  enabled: boolean
+  provider: 'claude' | 'ollama'
+  model: string
+  apiKey?: string
+  minContentLength: number
+}
+
+export interface CompressedObservation {
+  summary: string
+  original?: string
+  compressed: boolean
+}
+
+export class ObservationCompressor {
+  private config: CompressionConfig
+  private logger: Logger
+
+  constructor(config: CompressionConfig, logger: Logger) {
+    this.config = config
+    this.logger = logger.child({ component: 'compressor' })
+  }
+
+  async compress(content: string, category: string): Promise<CompressedObservation> {
+    if (!this.config.enabled || content.length < this.config.minContentLength) {
+      return { summary: content, compressed: false }
+    }
+
+    const prompt = `Compress this ${category} observation into a concise summary (2-3 sentences max).
+Preserve: the core decision/insight, reasoning, and any specific technologies mentioned.
+Drop: filler words, repetition, context that's obvious from the category.
+
+Observation: ${content}`
+
+    try {
+      const startTime = Date.now()
+      const response = await this.callLLM(prompt)
+      const result: CompressedObservation = { summary: response, original: content, compressed: true }
+
+      // SLM Phase 1A: Log compression input/output pair as gold training data
+      try {
+        const { logTrainingData } = require('@/training/data-store')
+        logTrainingData({
+          task: 'compress' as const,
+          input: content,
+          output: JSON.stringify({ summary: response }),
+          metadata: JSON.stringify({ category, elapsed_ms: Date.now() - startTime, provider: this.config.provider }),
+        })
+      } catch {
+        // Non-critical
+      }
+
+      return result
+    } catch (error) {
+      this.logger.warn({ error }, 'LLM compression failed, storing original')
+      return { summary: content, compressed: false }
+    }
+  }
+
+  private async callLLM(prompt: string): Promise<string> {
+    const apiKey = this.config.apiKey || process.env.ANTHROPIC_API_KEY
+    if (!apiKey) {
+      throw new Error('No API key configured for compression')
+    }
+
+    if (this.config.provider === 'ollama') {
+      return this.callOllama(prompt)
+    }
+
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        model: this.config.model || 'claude-haiku-4-5-20251001',
+        max_tokens: 200,
+        messages: [{ role: 'user', content: prompt }]
+      }),
+      signal: AbortSignal.timeout(10000)
+    })
+
+    if (!res.ok) {
+      throw new Error(`Anthropic API error: ${res.status} ${res.statusText}`)
+    }
+
+    const data = await res.json() as { content: Array<{ text: string }> }
+    return data.content[0].text
+  }
+
+  private async callOllama(prompt: string): Promise<string> {
+    const res = await fetch('http://localhost:11434/api/generate', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: this.config.model || 'llama3',
+        prompt,
+        stream: false
+      }),
+      signal: AbortSignal.timeout(10000)
+    })
+
+    if (!res.ok) {
+      throw new Error(`Ollama API error: ${res.status} ${res.statusText}`)
+    }
+
+    const data = await res.json() as { response: string }
+    return data.response
+  }
+}

package/src/memory/consolidation/archiver.ts

@@ -1,165 +1,162 @@
-/**
- * Memory Archiver
- * Moves low-importance memories to archive collection
- */
-
-import type { Logger } from 'pino'
-import type { CollectionManager } from '../chroma/collection-manager'
-import type { EmbeddingProvider } from '../chroma/embeddings'
-import type { ImportanceScorer } from './scorer'
-
-export interface ArchiveResult {
-  archivedCount: number
-  archivedIds: string[]
-}
-
-export class MemoryArchiver {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-  private scorer: ImportanceScorer
-
-  constructor(
-    logger: Logger,
-    collections: CollectionManager,
-    scorer: ImportanceScorer,
-    embeddings?: EmbeddingProvider
-  ) {
-    this.logger = logger.child({ component: 'memory-archiver' })
-    this.collections = collections
-    this.scorer = scorer
-    this.embeddings = embeddings
-  }
-
-  async archiveLowImportance(threshold: number = 0.2): Promise<ArchiveResult> {
-    const archivedIds: string[] = []
-
-    try {
-      const decisionsCollection = await this.collections.getDecisions()
-      const archiveCollection = await this.collections.getArchivedMemories()
-
-      const results = await decisionsCollection.get({
-        include: ['documents', 'metadatas', 'embeddings']
-      })
-
-      for (let i = 0; i < results.ids.length; i++) {
-        const id = results.ids[i] ?? ''
-        if (!id) continue
-        const metadata = results.metadatas?.[i] as Record<string, any>
-
-        const score = this.scorer.score({
-          id,
-          created_at: metadata?.created_at || new Date().toISOString(),
-          recall_count: metadata?.recall_count || 0,
-          average_rating: metadata?.average_rating,
-          max_similarity: metadata?.max_similarity
-        })
-
-        if (score.total < threshold) {
-          // Move to archive
-          try {
-            await archiveCollection.add({
-              ids: [id],
-              documents: [results.documents?.[i] as string],
-              metadatas: [{
-                ...metadata,
-                archived_at: new Date().toISOString(),
-                importance_score: score.total
-              }],
-              ...(results.embeddings?.[i] ? { embeddings: [results.embeddings[i] as number[]] } : {})
-            })
-
-            await decisionsCollection.delete({ ids: [id] })
-            archivedIds.push(id)
-          } catch (moveError) {
-            this.logger.warn({ error: moveError, id }, 'Failed to archive individual memory')
-          }
-        }
-      }
-
-      this.logger.info({
-        archivedCount: archivedIds.length,
-        totalChecked: results.ids.length,
-        threshold
-      }, 'Archive sweep complete')
-
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to archive low-importance memories')
-    }
-
-    return { archivedCount: archivedIds.length, archivedIds }
-  }
-
-  async restore(memoryId: string): Promise<boolean> {
-    try {
-      const archiveCollection = await this.collections.getArchivedMemories()
-      const decisionsCollection = await this.collections.getDecisions()
-
-      const result = await archiveCollection.get({
-        ids: [memoryId],
-        include: ['documents', 'metadatas', 'embeddings']
-      })
-
-      if (result.ids.length === 0) {
-        this.logger.warn({ memoryId }, 'Memory not found in archive')
-        return false
-      }
-
-      const metadata = { ...(result.metadatas?.[0] as Record<string, any>) }
-      delete metadata.archived_at
-      delete metadata.importance_score
-      metadata.updated_at = new Date().toISOString()
-      metadata.restored_from_archive = true
-
-      await decisionsCollection.add({
-        ids: [memoryId],
-        documents: [result.documents?.[0] as string],
-        metadatas: [metadata],
-        ...(result.embeddings?.[0] ? { embeddings: [result.embeddings[0] as number[]] } : {})
-      })
-
-      await archiveCollection.delete({ ids: [memoryId] })
-
-      this.logger.info({ memoryId }, 'Memory restored from archive')
-      return true
-    } catch (error) {
-      this.logger.error({ error, memoryId }, 'Failed to restore memory')
-      return false
-    }
-  }
-
-  async searchArchive(query: string, limit: number = 10): Promise<any[]> {
-    try {
-      const archiveCollection = await this.collections.getArchivedMemories()
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        results = await archiveCollection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await archiveCollection.query({
-          queryTexts: [query],
-          nResults: limit,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids?.[0]) return []
-
-      return results.ids[0].map((id: string, i: number) => ({
-        id,
-        content: results.documents?.[0]?.[i],
-        metadata: results.metadatas?.[0]?.[i],
-        similarity: 1 - (results.distances?.[0]?.[i] || 0)
-      }))
-    } catch (error) {
-      this.logger.error({ error, query }, 'Failed to search archive')
-      return []
-    }
-  }
-}
+/**
+ * Memory Archiver
+ * Moves low-importance memories to archive collection
+ */
+
+import type { Metadata } from 'chromadb'
+import type { Logger } from 'pino'
+import type { CollectionManager } from '../chroma/collection-manager'
+import type { EmbeddingProvider } from '../chroma/embeddings'
+import type { ImportanceScorer } from './scorer'
+
+export interface ArchiveResult {
+  archivedCount: number
+  archivedIds: string[]
+}
+
+export class MemoryArchiver {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+  private scorer: ImportanceScorer
+
+  constructor(
+    logger: Logger,
+    collections: CollectionManager,
+    scorer: ImportanceScorer,
+    embeddings?: EmbeddingProvider
+  ) {
+    this.logger = logger.child({ component: 'memory-archiver' })
+    this.collections = collections
+    this.scorer = scorer
+    this.embeddings = embeddings
+  }
+
+  async archiveLowImportance(threshold: number = 0.2): Promise<ArchiveResult> {
+    const archivedIds: string[] = []
+
+    try {
+      const decisionsCollection = await this.collections.getDecisions()
+      const archiveCollection = await this.collections.getArchivedMemories()
+
+      const results = await decisionsCollection.get({
+        include: ['documents', 'metadatas', 'embeddings']
+      })
+
+      for (let i = 0; i < results.ids.length; i++) {
+        const id = results.ids[i] ?? ''
+        if (!id) continue
+        const metadata = results.metadatas?.[i] as Metadata
+
+        const score = this.scorer.score({
+          id,
+          created_at: (metadata?.created_at as string) || new Date().toISOString(),
+          recall_count: (metadata?.recall_count as number) || 0,
+          average_rating: metadata?.average_rating as number | undefined,
+          max_similarity: metadata?.max_similarity as number | undefined
+        })
+
+        if (score.total < threshold) {
+          // Move to archive
+          try {
+            await archiveCollection.add({
+              ids: [id],
+              documents: [results.documents?.[i] as string],
+              metadatas: [{
+                ...metadata,
+                archived_at: new Date().toISOString(),
+                importance_score: score.total
+              }],
+              ...(results.embeddings?.[i] ? { embeddings: [results.embeddings[i] as number[]] } : {})
+            })
+
+            await decisionsCollection.delete({ ids: [id] })
+            archivedIds.push(id)
+          } catch (moveError) {
+            this.logger.warn({ error: moveError, id }, 'Failed to archive individual memory')
+          }
+        }
+      }
+
+      this.logger.info({
+        archivedCount: archivedIds.length,
+        totalChecked: results.ids.length,
+        threshold
+      }, 'Archive sweep complete')
+
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to archive low-importance memories')
+    }
+
+    return { archivedCount: archivedIds.length, archivedIds }
+  }
+
+  async restore(memoryId: string): Promise<boolean> {
+    try {
+      const archiveCollection = await this.collections.getArchivedMemories()
+      const decisionsCollection = await this.collections.getDecisions()
+
+      const result = await archiveCollection.get({
+        ids: [memoryId],
+        include: ['documents', 'metadatas', 'embeddings']
+      })
+
+      if (result.ids.length === 0) {
+        this.logger.warn({ memoryId }, 'Memory not found in archive')
+        return false
+      }
+
+      const rawMetadata = { ...(result.metadatas?.[0] as Metadata) }
+      delete rawMetadata.archived_at
+      delete rawMetadata.importance_score
+      rawMetadata.updated_at = new Date().toISOString()
+      rawMetadata.restored_from_archive = true
+      const metadata = rawMetadata as Metadata
+
+      await decisionsCollection.add({
+        ids: [memoryId],
+        documents: [result.documents?.[0] as string],
+        metadatas: [metadata],
+        ...(result.embeddings?.[0] ? { embeddings: [result.embeddings[0] as number[]] } : {})
+      })
+
+      await archiveCollection.delete({ ids: [memoryId] })
+
+      this.logger.info({ memoryId }, 'Memory restored from archive')
+      return true
+    } catch (error) {
+      this.logger.error({ error, memoryId }, 'Failed to restore memory')
+      return false
+    }
+  }
+
+  async searchArchive(query: string, limit: number = 10): Promise<Record<string, unknown>[]> {
+    try {
+      const archiveCollection = await this.collections.getArchivedMemories()
+
+      const results = this.embeddings
+        ? await archiveCollection.query({
+            queryEmbeddings: [await this.embeddings.generate(query)],
+            nResults: limit,
+            include: ['documents', 'metadatas', 'distances']
+          })
+        : await archiveCollection.query({
+            queryTexts: [query],
+            nResults: limit,
+            include: ['documents', 'metadatas', 'distances']
+          })
+
+      if (!results.ids?.[0]) return []
+
+      return results.ids[0].map((id: string, i: number) => ({
+        id,
+        content: results.documents?.[0]?.[i],
+        metadata: results.metadatas?.[0]?.[i],
+        similarity: 1 - (results.distances?.[0]?.[i] || 0)
+      }))
+    } catch (error) {
+      this.logger.error({ error, query }, 'Failed to search archive')
+      return []
+    }
+  }
+}