claude-brain 0.14.2 → 0.14.4

package/src/memory/consolidation/archiver.ts

@@ -1,164 +1,164 @@
-/**
- * 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, ImportanceScore } 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]
-        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 { Logger } from 'pino'
+import type { CollectionManager } from '../chroma/collection-manager'
+import type { EmbeddingProvider } from '../chroma/embeddings'
+import type { ImportanceScorer, ImportanceScore } 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]
+        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 []
+    }
+  }
+}