claude-brain 0.30.2 → 0.30.3

package/src/memory/chroma/migration.ts

@@ -1,270 +1,270 @@
-import type { Logger } from 'pino'
-import type { Database } from 'bun:sqlite'
-import type { ChromaMemoryStore } from './store'
-import type { CollectionManager } from './collection-manager'
-
-export interface MigrationStats {
-  totalDecisions: number
-  migratedDecisions: number
-  failedDecisions: number
-  totalMemories: number
-  migratedMemories: number
-  failedMemories: number
-  duration: number
-}
-
-export interface MigrationOptions {
-  batchSize?: number
-  dryRun?: boolean
-  skipExisting?: boolean
-  validateAfter?: boolean
-}
-
-export class ChromaMigration {
-  private logger: Logger
-  private sqliteDb: Database
-  private chromaStore: ChromaMemoryStore
-  private collections: CollectionManager
-
-  constructor(
-    logger: Logger,
-    sqliteDb: Database,
-    chromaStore: ChromaMemoryStore,
-    collections: CollectionManager
-  ) {
-    this.logger = logger.child({ component: 'chroma-migration' })
-    this.sqliteDb = sqliteDb
-    this.chromaStore = chromaStore
-    this.collections = collections
-  }
-
-  async migrate(options: MigrationOptions = {}): Promise<MigrationStats> {
-    const {
-      batchSize = 100,
-      dryRun = false,
-      skipExisting = true,
-      validateAfter = true
-    } = options
-
-    this.logger.info({ options }, 'Starting migration from SQLite to ChromaDB')
-
-    const startTime = Date.now()
-
-    const stats: MigrationStats = {
-      totalDecisions: 0,
-      migratedDecisions: 0,
-      failedDecisions: 0,
-      totalMemories: 0,
-      migratedMemories: 0,
-      failedMemories: 0,
-      duration: 0
-    }
-
-    try {
-      await this.migrateDecisions(stats, batchSize, dryRun, skipExisting)
-      await this.migrateMemories(stats, batchSize, dryRun, skipExisting)
-
-      if (validateAfter && !dryRun) {
-        await this.validateMigration(stats)
-      }
-
-      stats.duration = Date.now() - startTime
-
-      this.logger.info(
-        { stats },
-        'Migration completed'
-      )
-
-      return stats
-
-    } catch (error) {
-      this.logger.error({ error }, 'Migration failed')
-      throw error
-    }
-  }
-
-  private async migrateDecisions(
-    stats: MigrationStats,
-    batchSize: number,
-    dryRun: boolean,
-    skipExisting: boolean
-  ): Promise<void> {
-    this.logger.info('Migrating decisions...')
-
-    const query = `
-      SELECT
-        d.id,
-        d.context,
-        d.decision,
-        d.reasoning,
-        d.alternatives,
-        d.outcome,
-        d.tags,
-        m.project,
-        m.created_at,
-        m.updated_at
-      FROM decisions d
-      JOIN memories m ON d.memory_id = m.id
-    `
-
-    const decisions = this.sqliteDb.query(query).all() as any[]
-    stats.totalDecisions = decisions.length
-
-    this.logger.info({ total: decisions.length }, 'Found decisions to migrate')
-
-    for (let i = 0; i < decisions.length; i += batchSize) {
-      const batch = decisions.slice(i, i + batchSize)
-
-      for (const decision of batch) {
-        try {
-          if (dryRun) {
-            this.logger.debug({ id: decision.id }, '[DRY RUN] Would migrate decision')
-            stats.migratedDecisions++
-            continue
-          }
-
-          if (skipExisting) {
-            const existing = await this.chromaStore.getDecision(decision.id)
-            if (existing) {
-              this.logger.debug({ id: decision.id }, 'Decision already exists, skipping')
-              stats.migratedDecisions++
-              continue
-            }
-          }
-
-          let tags: string[] = []
-          try {
-            tags = JSON.parse(decision.tags || '[]')
-          } catch {
-            tags = []
-          }
-
-          await this.chromaStore.upsertDecision(decision.id, {
-            project: decision.project,
-            context: decision.context,
-            decision: decision.decision,
-            reasoning: decision.reasoning,
-            alternatives: decision.alternatives,
-            outcome: decision.outcome,
-            tags
-          })
-
-          stats.migratedDecisions++
-
-        } catch (error) {
-          this.logger.error(
-            { error, id: decision.id },
-            'Failed to migrate decision'
-          )
-          stats.failedDecisions++
-        }
-      }
-
-      this.logger.info(
-        { progress: `${Math.min(i + batchSize, decisions.length)}/${decisions.length}` },
-        'Decision migration progress'
-      )
-    }
-  }
-
-  private async migrateMemories(
-    stats: MigrationStats,
-    batchSize: number,
-    dryRun: boolean,
-    _skipExisting: boolean
-  ): Promise<void> {
-    this.logger.info('Migrating memories...')
-
-    const query = `
-      SELECT
-        m.id,
-        m.project,
-        m.content,
-        m.metadata,
-        m.created_at,
-        m.updated_at
-      FROM memories m
-      LEFT JOIN decisions d ON d.memory_id = m.id
-      WHERE d.id IS NULL
-    `
-
-    const memories = this.sqliteDb.query(query).all() as any[]
-    stats.totalMemories = memories.length
-
-    this.logger.info({ total: memories.length }, 'Found memories to migrate')
-
-    for (let i = 0; i < memories.length; i += batchSize) {
-      const batch = memories.slice(i, i + batchSize)
-
-      for (const memory of batch) {
-        try {
-          if (dryRun) {
-            this.logger.debug({ id: memory.id }, '[DRY RUN] Would migrate memory')
-            stats.migratedMemories++
-            continue
-          }
-
-          let metadata: Record<string, any> = {}
-          try {
-            metadata = JSON.parse(memory.metadata || '{}')
-          } catch {
-            metadata = {}
-          }
-
-          await this.chromaStore.storeMemory({
-            project: memory.project,
-            content: memory.content,
-            type: metadata.type || 'general',
-            source: 'migration',
-            confidence: metadata.confidence || 1.0,
-            metadata
-          })
-
-          stats.migratedMemories++
-
-        } catch (error) {
-          this.logger.error(
-            { error, id: memory.id },
-            'Failed to migrate memory'
-          )
-          stats.failedMemories++
-        }
-      }
-
-      this.logger.info(
-        { progress: `${Math.min(i + batchSize, memories.length)}/${memories.length}` },
-        'Memory migration progress'
-      )
-    }
-  }
-
-  private async validateMigration(stats: MigrationStats): Promise<void> {
-    this.logger.info('Validating migration...')
-
-    const chromaStats = await this.collections.getStats()
-
-    if (chromaStats.decisions !== stats.migratedDecisions) {
-      this.logger.warn({
-        expected: stats.migratedDecisions,
-        actual: chromaStats.decisions
-      }, 'Decision count mismatch')
-    }
-
-    if (chromaStats.memories !== stats.migratedMemories) {
-      this.logger.warn({
-        expected: stats.migratedMemories,
-        actual: chromaStats.memories
-      }, 'Memory count mismatch')
-    }
-
-    this.logger.info('Migration validation complete')
-  }
-
-  async rollback(): Promise<void> {
-    this.logger.warn('Rolling back ChromaDB migration...')
-
-    await this.collections.clearAll()
-
-    this.logger.info('Rollback complete - ChromaDB collections cleared')
-  }
-}
+import type { Logger } from 'pino'
+import type { Database } from 'bun:sqlite'
+import type { ChromaMemoryStore } from './store'
+import type { CollectionManager } from './collection-manager'
+
+export interface MigrationStats {
+  totalDecisions: number
+  migratedDecisions: number
+  failedDecisions: number
+  totalMemories: number
+  migratedMemories: number
+  failedMemories: number
+  duration: number
+}
+
+export interface MigrationOptions {
+  batchSize?: number
+  dryRun?: boolean
+  skipExisting?: boolean
+  validateAfter?: boolean
+}
+
+export class ChromaMigration {
+  private logger: Logger
+  private sqliteDb: Database
+  private chromaStore: ChromaMemoryStore
+  private collections: CollectionManager
+
+  constructor(
+    logger: Logger,
+    sqliteDb: Database,
+    chromaStore: ChromaMemoryStore,
+    collections: CollectionManager
+  ) {
+    this.logger = logger.child({ component: 'chroma-migration' })
+    this.sqliteDb = sqliteDb
+    this.chromaStore = chromaStore
+    this.collections = collections
+  }
+
+  async migrate(options: MigrationOptions = {}): Promise<MigrationStats> {
+    const {
+      batchSize = 100,
+      dryRun = false,
+      skipExisting = true,
+      validateAfter = true
+    } = options
+
+    this.logger.info({ options }, 'Starting migration from SQLite to ChromaDB')
+
+    const startTime = Date.now()
+
+    const stats: MigrationStats = {
+      totalDecisions: 0,
+      migratedDecisions: 0,
+      failedDecisions: 0,
+      totalMemories: 0,
+      migratedMemories: 0,
+      failedMemories: 0,
+      duration: 0
+    }
+
+    try {
+      await this.migrateDecisions(stats, batchSize, dryRun, skipExisting)
+      await this.migrateMemories(stats, batchSize, dryRun, skipExisting)
+
+      if (validateAfter && !dryRun) {
+        await this.validateMigration(stats)
+      }
+
+      stats.duration = Date.now() - startTime
+
+      this.logger.info(
+        { stats },
+        'Migration completed'
+      )
+
+      return stats
+
+    } catch (error) {
+      this.logger.error({ error }, 'Migration failed')
+      throw error
+    }
+  }
+
+  private async migrateDecisions(
+    stats: MigrationStats,
+    batchSize: number,
+    dryRun: boolean,
+    skipExisting: boolean
+  ): Promise<void> {
+    this.logger.info('Migrating decisions...')
+
+    const query = `
+      SELECT
+        d.id,
+        d.context,
+        d.decision,
+        d.reasoning,
+        d.alternatives,
+        d.outcome,
+        d.tags,
+        m.project,
+        m.created_at,
+        m.updated_at
+      FROM decisions d
+      JOIN memories m ON d.memory_id = m.id
+    `
+
+    const decisions = this.sqliteDb.query(query).all() as any[]
+    stats.totalDecisions = decisions.length
+
+    this.logger.info({ total: decisions.length }, 'Found decisions to migrate')
+
+    for (let i = 0; i < decisions.length; i += batchSize) {
+      const batch = decisions.slice(i, i + batchSize)
+
+      for (const decision of batch) {
+        try {
+          if (dryRun) {
+            this.logger.debug({ id: decision.id }, '[DRY RUN] Would migrate decision')
+            stats.migratedDecisions++
+            continue
+          }
+
+          if (skipExisting) {
+            const existing = await this.chromaStore.getDecision(decision.id)
+            if (existing) {
+              this.logger.debug({ id: decision.id }, 'Decision already exists, skipping')
+              stats.migratedDecisions++
+              continue
+            }
+          }
+
+          let tags: string[] = []
+          try {
+            tags = JSON.parse(decision.tags || '[]')
+          } catch {
+            tags = []
+          }
+
+          await this.chromaStore.upsertDecision(decision.id, {
+            project: decision.project,
+            context: decision.context,
+            decision: decision.decision,
+            reasoning: decision.reasoning,
+            alternatives: decision.alternatives,
+            outcome: decision.outcome,
+            tags
+          })
+
+          stats.migratedDecisions++
+
+        } catch (error) {
+          this.logger.error(
+            { error, id: decision.id },
+            'Failed to migrate decision'
+          )
+          stats.failedDecisions++
+        }
+      }
+
+      this.logger.info(
+        { progress: `${Math.min(i + batchSize, decisions.length)}/${decisions.length}` },
+        'Decision migration progress'
+      )
+    }
+  }
+
+  private async migrateMemories(
+    stats: MigrationStats,
+    batchSize: number,
+    dryRun: boolean,
+    _skipExisting: boolean
+  ): Promise<void> {
+    this.logger.info('Migrating memories...')
+
+    const query = `
+      SELECT
+        m.id,
+        m.project,
+        m.content,
+        m.metadata,
+        m.created_at,
+        m.updated_at
+      FROM memories m
+      LEFT JOIN decisions d ON d.memory_id = m.id
+      WHERE d.id IS NULL
+    `
+
+    const memories = this.sqliteDb.query(query).all() as any[]
+    stats.totalMemories = memories.length
+
+    this.logger.info({ total: memories.length }, 'Found memories to migrate')
+
+    for (let i = 0; i < memories.length; i += batchSize) {
+      const batch = memories.slice(i, i + batchSize)
+
+      for (const memory of batch) {
+        try {
+          if (dryRun) {
+            this.logger.debug({ id: memory.id }, '[DRY RUN] Would migrate memory')
+            stats.migratedMemories++
+            continue
+          }
+
+          let metadata: Record<string, any> = {}
+          try {
+            metadata = JSON.parse(memory.metadata || '{}')
+          } catch {
+            metadata = {}
+          }
+
+          await this.chromaStore.storeMemory({
+            project: memory.project,
+            content: memory.content,
+            type: metadata.type || 'general',
+            source: 'migration',
+            confidence: metadata.confidence || 1.0,
+            metadata
+          })
+
+          stats.migratedMemories++
+
+        } catch (error) {
+          this.logger.error(
+            { error, id: memory.id },
+            'Failed to migrate memory'
+          )
+          stats.failedMemories++
+        }
+      }
+
+      this.logger.info(
+        { progress: `${Math.min(i + batchSize, memories.length)}/${memories.length}` },
+        'Memory migration progress'
+      )
+    }
+  }
+
+  private async validateMigration(stats: MigrationStats): Promise<void> {
+    this.logger.info('Validating migration...')
+
+    const chromaStats = await this.collections.getStats()
+
+    if (chromaStats.decisions !== stats.migratedDecisions) {
+      this.logger.warn({
+        expected: stats.migratedDecisions,
+        actual: chromaStats.decisions
+      }, 'Decision count mismatch')
+    }
+
+    if (chromaStats.memories !== stats.migratedMemories) {
+      this.logger.warn({
+        expected: stats.migratedMemories,
+        actual: chromaStats.memories
+      }, 'Memory count mismatch')
+    }
+
+    this.logger.info('Migration validation complete')
+  }
+
+  async rollback(): Promise<void> {
+    this.logger.warn('Rolling back ChromaDB migration...')
+
+    await this.collections.clearAll()
+
+    this.logger.info('Rollback complete - ChromaDB collections cleared')
+  }
+}

package/src/memory/chroma/schemas.ts

@@ -1,69 +1,69 @@
-export interface DecisionMetadata {
-  project: string
-  context: string
-  reasoning: string
-  alternatives?: string
-  outcome?: string
-  tags: string[]
-  created_at: string
-  updated_at: string
-  confidence?: number
-  source: 'manual' | 'auto-detected'
-}
-
-export interface MemoryMetadata {
-  project: string
-  type: 'fact' | 'preference' | 'constraint' | 'goal' | 'general'
-  source: string
-  confidence: number
-  created_at: string
-  updated_at: string
-}
-
-export interface PatternMetadata {
-  pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-  occurrences: number
-  projects: string[]
-  confidence: number
-  first_seen: string
-  last_seen: string
-}
-
-export interface FeedbackMetadata {
-  memory_id: string
-  query_id: string
-  query: string
-  rating: 1 | 2 | 3 | 4 | 5
-  was_used: boolean
-  feedback_text?: string
-  project?: string
-  created_at: string
-  collection_type: 'decisions' | 'memories' | 'patterns' | 'corrections'
-}
-
-export interface EpisodeCollectionMetadata {
-  episode_id: string
-  project: string
-  status: 'active' | 'completed'
-  started_at: string
-  ended_at: string
-  message_count: number
-  token_count: number
-  key_topics: string
-  brief_summary: string
-  related_decisions: string
-  related_patterns: string
-  related_corrections: string
-}
-
-export const COLLECTIONS = {
-  DECISIONS: 'decisions',
-  MEMORIES: 'memories',
-  PATTERNS: 'patterns',
-  CORRECTIONS: 'corrections',
-  FEEDBACK: 'feedback',
-  EPISODES: 'episodes',
-  ARCHIVED_MEMORIES: 'archived_memories'
-} as const
-
-export type CollectionName = typeof COLLECTIONS[keyof typeof COLLECTIONS]
+export interface DecisionMetadata {
+  project: string
+  context: string
+  reasoning: string
+  alternatives?: string
+  outcome?: string
+  tags: string[]
+  created_at: string
+  updated_at: string
+  confidence?: number
+  source: 'manual' | 'auto-detected'
+}
+
+export interface MemoryMetadata {
+  project: string
+  type: 'fact' | 'preference' | 'constraint' | 'goal' | 'general'
+  source: string
+  confidence: number
+  created_at: string
+  updated_at: string
+}
+
+export interface PatternMetadata {
+  pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+  occurrences: number
+  projects: string[]
+  confidence: number
+  first_seen: string
+  last_seen: string
+}
+
+export interface FeedbackMetadata {
+  memory_id: string
+  query_id: string
+  query: string
+  rating: 1 | 2 | 3 | 4 | 5
+  was_used: boolean
+  feedback_text?: string
+  project?: string
+  created_at: string
+  collection_type: 'decisions' | 'memories' | 'patterns' | 'corrections'
+}
+
+export interface EpisodeCollectionMetadata {
+  episode_id: string
+  project: string
+  status: 'active' | 'completed'
+  started_at: string
+  ended_at: string
+  message_count: number
+  token_count: number
+  key_topics: string
+  brief_summary: string
+  related_decisions: string
+  related_patterns: string
+  related_corrections: string
+}
+
+export const COLLECTIONS = {
+  DECISIONS: 'decisions',
+  MEMORIES: 'memories',
+  PATTERNS: 'patterns',
+  CORRECTIONS: 'corrections',
+  FEEDBACK: 'feedback',
+  EPISODES: 'episodes',
+  ARCHIVED_MEMORIES: 'archived_memories'
+} as const
+
+export type CollectionName = typeof COLLECTIONS[keyof typeof COLLECTIONS]