claude-brain 0.15.2 → 0.16.0

package/src/memory/database.ts

@@ -1,169 +1,169 @@
-/**
- * Database Connection Manager
- * Phase 3: Memory and Embedding System
- *
- * Manages SQLite database connection for memory storage
- */
-
-import { Database } from 'bun:sqlite'
-import path from 'node:path'
-import fs from 'node:fs/promises'
-import type { Logger } from 'pino'
-import { MEMORY_SCHEMA } from './schema'
-import type { DatabaseStats } from './types'
-
-export class MemoryDatabase {
-  private db: Database | null = null
-  private logger: Logger
-  private dbPath: string
-
-  constructor(dbPath: string, logger: Logger) {
-    this.dbPath = dbPath
-    this.logger = logger.child({ component: 'memory-database' })
-  }
-
-  /**
-   * Initialize database and create schema
-   */
-  async initialize(): Promise<void> {
-    try {
-      // Ensure directory exists
-      await fs.mkdir(path.dirname(this.dbPath), { recursive: true })
-
-      // Open database
-      this.db = new Database(this.dbPath)
-
-      // Enable Write-Ahead Logging for better concurrency
-      this.db.run('PRAGMA journal_mode = WAL')
-
-      // Enable foreign keys
-      this.db.run('PRAGMA foreign_keys = ON')
-
-      // Create schema
-      this.db.exec(MEMORY_SCHEMA)
-
-      this.logger.info({ dbPath: this.dbPath }, 'Database initialized')
-    } catch (error) {
-      this.logger.error({ error, dbPath: this.dbPath }, 'Failed to initialize database')
-      throw error
-    }
-  }
-
-  /**
-   * Get the SQLite database instance
-   */
-  getDb(): Database {
-    if (!this.db) {
-      throw new Error('Database not initialized. Call initialize() first.')
-    }
-    return this.db
-  }
-
-  /**
-   * Close database connection
-   */
-  close(): void {
-    if (this.db) {
-      this.db.close()
-      this.db = null
-      this.logger.info('Database closed')
-    }
-  }
-
-  /**
-   * Get database statistics
-   */
-  getStats(): DatabaseStats {
-    if (!this.db) {
-      throw new Error('Database not initialized')
-    }
-
-    const memoriesCount = this.db.query('SELECT COUNT(*) as count FROM memories').get() as {
-      count: number
-    }
-    const decisionsCount = this.db.query('SELECT COUNT(*) as count FROM decisions').get() as {
-      count: number
-    }
-    const dbSize = this.db
-      .query(
-        'SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()'
-      )
-      .get() as { size: number }
-
-    return {
-      memories: memoriesCount.count,
-      decisions: decisionsCount.count,
-      sizeBytes: dbSize.size,
-      sizeMB: (dbSize.size / 1024 / 1024).toFixed(2)
-    }
-  }
-
-  /**
-   * Run database health check
-   */
-  async healthCheck(): Promise<boolean> {
-    try {
-      if (!this.db) {
-        return false
-      }
-      this.db.query('SELECT 1').get()
-      return true
-    } catch (error) {
-      this.logger.error({ error }, 'Database health check failed')
-      return false
-    }
-  }
-
-  /**
-   * Vacuum database to reclaim space
-   */
-  async vacuum(): Promise<void> {
-    try {
-      if (!this.db) {
-        throw new Error('Database not initialized')
-      }
-      this.db.run('VACUUM')
-      this.logger.info('Database vacuumed')
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to vacuum database')
-      throw error
-    }
-  }
-
-  /**
-   * Begin a transaction
-   */
-  beginTransaction(): void {
-    if (!this.db) {
-      throw new Error('Database not initialized')
-    }
-    this.db.run('BEGIN TRANSACTION')
-  }
-
-  /**
-   * Commit a transaction
-   */
-  commit(): void {
-    if (!this.db) {
-      throw new Error('Database not initialized')
-    }
-    this.db.run('COMMIT')
-  }
-
-  /**
-   * Rollback a transaction
-   */
-  rollback(): void {
-    if (!this.db) {
-      throw new Error('Database not initialized')
-    }
-    this.db.run('ROLLBACK')
-  }
-
-  /**
-   * Check if database is initialized
-   */
-  isInitialized(): boolean {
-    return this.db !== null
-  }
-}
+/**
+ * Database Connection Manager
+ * Phase 3: Memory and Embedding System
+ *
+ * Manages SQLite database connection for memory storage
+ */
+
+import { Database } from 'bun:sqlite'
+import path from 'node:path'
+import fs from 'node:fs/promises'
+import type { Logger } from 'pino'
+import { MEMORY_SCHEMA } from './schema'
+import type { DatabaseStats } from './types'
+
+export class MemoryDatabase {
+  private db: Database | null = null
+  private logger: Logger
+  private dbPath: string
+
+  constructor(dbPath: string, logger: Logger) {
+    this.dbPath = dbPath
+    this.logger = logger.child({ component: 'memory-database' })
+  }
+
+  /**
+   * Initialize database and create schema
+   */
+  async initialize(): Promise<void> {
+    try {
+      // Ensure directory exists
+      await fs.mkdir(path.dirname(this.dbPath), { recursive: true })
+
+      // Open database
+      this.db = new Database(this.dbPath)
+
+      // Enable Write-Ahead Logging for better concurrency
+      this.db.run('PRAGMA journal_mode = WAL')
+
+      // Enable foreign keys
+      this.db.run('PRAGMA foreign_keys = ON')
+
+      // Create schema
+      this.db.exec(MEMORY_SCHEMA)
+
+      this.logger.info({ dbPath: this.dbPath }, 'Database initialized')
+    } catch (error) {
+      this.logger.error({ error, dbPath: this.dbPath }, 'Failed to initialize database')
+      throw error
+    }
+  }
+
+  /**
+   * Get the SQLite database instance
+   */
+  getDb(): Database {
+    if (!this.db) {
+      throw new Error('Database not initialized. Call initialize() first.')
+    }
+    return this.db
+  }
+
+  /**
+   * Close database connection
+   */
+  close(): void {
+    if (this.db) {
+      this.db.close()
+      this.db = null
+      this.logger.info('Database closed')
+    }
+  }
+
+  /**
+   * Get database statistics
+   */
+  getStats(): DatabaseStats {
+    if (!this.db) {
+      throw new Error('Database not initialized')
+    }
+
+    const memoriesCount = this.db.query('SELECT COUNT(*) as count FROM memories').get() as {
+      count: number
+    }
+    const decisionsCount = this.db.query('SELECT COUNT(*) as count FROM decisions').get() as {
+      count: number
+    }
+    const dbSize = this.db
+      .query(
+        'SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()'
+      )
+      .get() as { size: number }
+
+    return {
+      memories: memoriesCount.count,
+      decisions: decisionsCount.count,
+      sizeBytes: dbSize.size,
+      sizeMB: (dbSize.size / 1024 / 1024).toFixed(2)
+    }
+  }
+
+  /**
+   * Run database health check
+   */
+  async healthCheck(): Promise<boolean> {
+    try {
+      if (!this.db) {
+        return false
+      }
+      this.db.query('SELECT 1').get()
+      return true
+    } catch (error) {
+      this.logger.error({ error }, 'Database health check failed')
+      return false
+    }
+  }
+
+  /**
+   * Vacuum database to reclaim space
+   */
+  async vacuum(): Promise<void> {
+    try {
+      if (!this.db) {
+        throw new Error('Database not initialized')
+      }
+      this.db.run('VACUUM')
+      this.logger.info('Database vacuumed')
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to vacuum database')
+      throw error
+    }
+  }
+
+  /**
+   * Begin a transaction
+   */
+  beginTransaction(): void {
+    if (!this.db) {
+      throw new Error('Database not initialized')
+    }
+    this.db.run('BEGIN TRANSACTION')
+  }
+
+  /**
+   * Commit a transaction
+   */
+  commit(): void {
+    if (!this.db) {
+      throw new Error('Database not initialized')
+    }
+    this.db.run('COMMIT')
+  }
+
+  /**
+   * Rollback a transaction
+   */
+  rollback(): void {
+    if (!this.db) {
+      throw new Error('Database not initialized')
+    }
+    this.db.run('ROLLBACK')
+  }
+
+  /**
+   * Check if database is initialized
+   */
+  isInitialized(): boolean {
+    return this.db !== null
+  }
+}

package/src/memory/embedding-utils.ts

@@ -1,156 +1,156 @@
-/**
- * Embedding Utility Functions
- * Phase 3: Memory and Embedding System
- *
- * Helper functions for embedding conversion and manipulation
- */
-
-/**
- * Convert embedding array to Buffer for SQLite storage
- * Stores as float32 array (4 bytes per number)
- */
-export function embeddingToBuffer(embedding: number[]): Buffer {
-  const buffer = Buffer.allocUnsafe(embedding.length * 4) // 4 bytes per float32
-  for (let i = 0; i < embedding.length; i++) {
-    buffer.writeFloatLE(embedding[i]!, i * 4)
-  }
-  return buffer
-}
-
-/**
- * Convert Buffer or Uint8Array from SQLite to embedding array
- * Reads float32 values from buffer
- * Note: Bun's SQLite returns BLOBs as Uint8Array, not Buffer
- */
-export function bufferToEmbedding(buffer: Buffer | Uint8Array): number[] {
-  // Convert Uint8Array to Buffer if needed (Bun SQLite returns Uint8Array for BLOBs)
-  const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer)
-
-  const embedding: number[] = []
-  for (let i = 0; i < buf.length; i += 4) {
-    embedding.push(buf.readFloatLE(i))
-  }
-  return embedding
-}
-
-/**
- * Normalize embedding vector to unit length
- * Required for accurate cosine similarity calculation
- */
-export function normalizeEmbedding(embedding: number[]): number[] {
-  const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0))
-  if (norm === 0) {
-    return embedding
-  }
-  return embedding.map((val) => val / norm)
-}
-
-/**
- * Calculate euclidean distance between two embeddings
- * Lower distance = more similar
- */
-export function euclideanDistance(a: number[], b: number[]): number {
-  if (a.length !== b.length) {
-    throw new Error('Embeddings must have same dimensions')
-  }
-
-  let sum = 0
-  for (let i = 0; i < a.length; i++) {
-    const diff = a[i]! - b[i]!
-    sum += diff * diff
-  }
-
-  return Math.sqrt(sum)
-}
-
-/**
- * Calculate dot product of two vectors
- */
-export function dotProduct(a: number[], b: number[]): number {
-  if (a.length !== b.length) {
-    throw new Error('Vectors must have same dimensions')
-  }
-
-  let sum = 0
-  for (let i = 0; i < a.length; i++) {
-    sum += a[i]! * b[i]!
-  }
-  return sum
-}
-
-/**
- * Calculate magnitude (L2 norm) of a vector
- */
-export function magnitude(v: number[]): number {
-  return Math.sqrt(v.reduce((sum, val) => sum + val * val, 0))
-}
-
-/**
- * Calculate cosine similarity between two embeddings
- * Returns value between -1 and 1 (1 = identical, 0 = orthogonal, -1 = opposite)
- */
-export function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length) {
-    throw new Error('Embeddings must have same dimensions')
-  }
-
-  let dotProd = 0
-  let normA = 0
-  let normB = 0
-
-  for (let i = 0; i < a.length; i++) {
-    dotProd += a[i]! * b[i]!
-    normA += a[i]! * a[i]!
-    normB += b[i]! * b[i]!
-  }
-
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB)
-  if (denominator === 0) {
-    return 0
-  }
-
-  return dotProd / denominator
-}
-
-/**
- * Average multiple embeddings into a single embedding
- * Useful for combining related content
- */
-export function averageEmbeddings(embeddings: number[][]): number[] {
-  if (embeddings.length === 0) {
-    throw new Error('Cannot average empty array of embeddings')
-  }
-
-  const firstEmbedding = embeddings[0]!
-  const dimensions = firstEmbedding.length
-  const result = new Array(dimensions).fill(0) as number[]
-
-  for (const embedding of embeddings) {
-    if (embedding.length !== dimensions) {
-      throw new Error('All embeddings must have same dimensions')
-    }
-    for (let i = 0; i < dimensions; i++) {
-      result[i]! += embedding[i]!
-    }
-  }
-
-  const count = embeddings.length
-  return result.map((val) => val / count)
-}
-
-/**
- * Find the top-k most similar embeddings to a query
- * Returns indices sorted by similarity (descending)
- */
-export function topKSimilar(
-  query: number[],
-  candidates: number[][],
-  k: number
-): Array<{ index: number; similarity: number }> {
-  const similarities = candidates.map((candidate, index) => ({
-    index,
-    similarity: cosineSimilarity(query, candidate)
-  }))
-
-  return similarities.sort((a, b) => b.similarity - a.similarity).slice(0, k)
-}
+/**
+ * Embedding Utility Functions
+ * Phase 3: Memory and Embedding System
+ *
+ * Helper functions for embedding conversion and manipulation
+ */
+
+/**
+ * Convert embedding array to Buffer for SQLite storage
+ * Stores as float32 array (4 bytes per number)
+ */
+export function embeddingToBuffer(embedding: number[]): Buffer {
+  const buffer = Buffer.allocUnsafe(embedding.length * 4) // 4 bytes per float32
+  for (let i = 0; i < embedding.length; i++) {
+    buffer.writeFloatLE(embedding[i]!, i * 4)
+  }
+  return buffer
+}
+
+/**
+ * Convert Buffer or Uint8Array from SQLite to embedding array
+ * Reads float32 values from buffer
+ * Note: Bun's SQLite returns BLOBs as Uint8Array, not Buffer
+ */
+export function bufferToEmbedding(buffer: Buffer | Uint8Array): number[] {
+  // Convert Uint8Array to Buffer if needed (Bun SQLite returns Uint8Array for BLOBs)
+  const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer)
+
+  const embedding: number[] = []
+  for (let i = 0; i < buf.length; i += 4) {
+    embedding.push(buf.readFloatLE(i))
+  }
+  return embedding
+}
+
+/**
+ * Normalize embedding vector to unit length
+ * Required for accurate cosine similarity calculation
+ */
+export function normalizeEmbedding(embedding: number[]): number[] {
+  const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0))
+  if (norm === 0) {
+    return embedding
+  }
+  return embedding.map((val) => val / norm)
+}
+
+/**
+ * Calculate euclidean distance between two embeddings
+ * Lower distance = more similar
+ */
+export function euclideanDistance(a: number[], b: number[]): number {
+  if (a.length !== b.length) {
+    throw new Error('Embeddings must have same dimensions')
+  }
+
+  let sum = 0
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i]! - b[i]!
+    sum += diff * diff
+  }
+
+  return Math.sqrt(sum)
+}
+
+/**
+ * Calculate dot product of two vectors
+ */
+export function dotProduct(a: number[], b: number[]): number {
+  if (a.length !== b.length) {
+    throw new Error('Vectors must have same dimensions')
+  }
+
+  let sum = 0
+  for (let i = 0; i < a.length; i++) {
+    sum += a[i]! * b[i]!
+  }
+  return sum
+}
+
+/**
+ * Calculate magnitude (L2 norm) of a vector
+ */
+export function magnitude(v: number[]): number {
+  return Math.sqrt(v.reduce((sum, val) => sum + val * val, 0))
+}
+
+/**
+ * Calculate cosine similarity between two embeddings
+ * Returns value between -1 and 1 (1 = identical, 0 = orthogonal, -1 = opposite)
+ */
+export function cosineSimilarity(a: number[], b: number[]): number {
+  if (a.length !== b.length) {
+    throw new Error('Embeddings must have same dimensions')
+  }
+
+  let dotProd = 0
+  let normA = 0
+  let normB = 0
+
+  for (let i = 0; i < a.length; i++) {
+    dotProd += a[i]! * b[i]!
+    normA += a[i]! * a[i]!
+    normB += b[i]! * b[i]!
+  }
+
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB)
+  if (denominator === 0) {
+    return 0
+  }
+
+  return dotProd / denominator
+}
+
+/**
+ * Average multiple embeddings into a single embedding
+ * Useful for combining related content
+ */
+export function averageEmbeddings(embeddings: number[][]): number[] {
+  if (embeddings.length === 0) {
+    throw new Error('Cannot average empty array of embeddings')
+  }
+
+  const firstEmbedding = embeddings[0]!
+  const dimensions = firstEmbedding.length
+  const result = new Array(dimensions).fill(0) as number[]
+
+  for (const embedding of embeddings) {
+    if (embedding.length !== dimensions) {
+      throw new Error('All embeddings must have same dimensions')
+    }
+    for (let i = 0; i < dimensions; i++) {
+      result[i]! += embedding[i]!
+    }
+  }
+
+  const count = embeddings.length
+  return result.map((val) => val / count)
+}
+
+/**
+ * Find the top-k most similar embeddings to a query
+ * Returns indices sorted by similarity (descending)
+ */
+export function topKSimilar(
+  query: number[],
+  candidates: number[][],
+  k: number
+): Array<{ index: number; similarity: number }> {
+  const similarities = candidates.map((candidate, index) => ({
+    index,
+    similarity: cosineSimilarity(query, candidate)
+  }))
+
+  return similarities.sort((a, b) => b.similarity - a.similarity).slice(0, k)
+}