claude-brain 0.30.2 → 0.31.1

package/src/memory/chroma/collection-manager.ts

@@ -1,92 +1,92 @@
-import type { Collection } from 'chromadb'
-import type { Logger } from 'pino'
-import type { ChromaClientManager } from './client'
-import { COLLECTIONS } from './schemas'
-
-export class CollectionManager {
-  private logger: Logger
-  private client: ChromaClientManager
-
-  constructor(logger: Logger, client: ChromaClientManager) {
-    this.logger = logger.child({ component: 'collection-manager' })
-    this.client = client
-  }
-
-  async initialize(): Promise<void> {
-    this.logger.info('Initializing collections')
-
-    try {
-      for (const collectionName of Object.values(COLLECTIONS)) {
-        await this.client.getCollection(collectionName)
-      }
-
-      this.logger.info('All collections initialized')
-
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to initialize collections')
-      throw error
-    }
-  }
-
-  async getDecisions(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.DECISIONS)
-  }
-
-  async getMemories(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.MEMORIES)
-  }
-
-  async getPatterns(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.PATTERNS)
-  }
-
-  async getCorrections(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.CORRECTIONS)
-  }
-
-  async getFeedback(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.FEEDBACK)
-  }
-
-  async getEpisodes(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.EPISODES)
-  }
-
-  async getArchivedMemories(): Promise<Collection> {
-    return this.client.getCollection(COLLECTIONS.ARCHIVED_MEMORIES)
-  }
-
-  async getProjectCollection(projectName: string): Promise<Collection> {
-    const collectionName = `project_${projectName.toLowerCase().replace(/[^a-z0-9]/g, '_')}`
-    return this.client.getCollection(collectionName)
-  }
-
-  async getStats(): Promise<Record<string, number>> {
-    const stats: Record<string, number> = {}
-
-    for (const collectionName of Object.values(COLLECTIONS)) {
-      try {
-        const collection = await this.client.getCollection(collectionName)
-        stats[collectionName] = await collection.count()
-      } catch {
-        stats[collectionName] = 0
-      }
-    }
-
-    return stats
-  }
-
-  async clearAll(): Promise<void> {
-    this.logger.warn('Clearing all collections')
-
-    for (const collectionName of Object.values(COLLECTIONS)) {
-      try {
-        await this.client.deleteCollection(collectionName)
-      } catch (error) {
-        this.logger.error({ error, collection: collectionName }, 'Failed to delete collection')
-      }
-    }
-
-    await this.initialize()
-  }
-}
+import type { Collection } from 'chromadb'
+import type { Logger } from 'pino'
+import type { ChromaClientManager } from './client'
+import { COLLECTIONS } from './schemas'
+
+export class CollectionManager {
+  private logger: Logger
+  private client: ChromaClientManager
+
+  constructor(logger: Logger, client: ChromaClientManager) {
+    this.logger = logger.child({ component: 'collection-manager' })
+    this.client = client
+  }
+
+  async initialize(): Promise<void> {
+    this.logger.info('Initializing collections')
+
+    try {
+      for (const collectionName of Object.values(COLLECTIONS)) {
+        await this.client.getCollection(collectionName)
+      }
+
+      this.logger.info('All collections initialized')
+
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to initialize collections')
+      throw error
+    }
+  }
+
+  async getDecisions(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.DECISIONS)
+  }
+
+  async getMemories(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.MEMORIES)
+  }
+
+  async getPatterns(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.PATTERNS)
+  }
+
+  async getCorrections(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.CORRECTIONS)
+  }
+
+  async getFeedback(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.FEEDBACK)
+  }
+
+  async getEpisodes(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.EPISODES)
+  }
+
+  async getArchivedMemories(): Promise<Collection> {
+    return this.client.getCollection(COLLECTIONS.ARCHIVED_MEMORIES)
+  }
+
+  async getProjectCollection(projectName: string): Promise<Collection> {
+    const collectionName = `project_${projectName.toLowerCase().replace(/[^a-z0-9]/g, '_')}`
+    return this.client.getCollection(collectionName)
+  }
+
+  async getStats(): Promise<Record<string, number>> {
+    const stats: Record<string, number> = {}
+
+    for (const collectionName of Object.values(COLLECTIONS)) {
+      try {
+        const collection = await this.client.getCollection(collectionName)
+        stats[collectionName] = await collection.count()
+      } catch {
+        stats[collectionName] = 0
+      }
+    }
+
+    return stats
+  }
+
+  async clearAll(): Promise<void> {
+    this.logger.warn('Clearing all collections')
+
+    for (const collectionName of Object.values(COLLECTIONS)) {
+      try {
+        await this.client.deleteCollection(collectionName)
+      } catch (error) {
+        this.logger.error({ error, collection: collectionName }, 'Failed to delete collection')
+      }
+    }
+
+    await this.initialize()
+  }
+}

package/src/memory/chroma/config.ts

@@ -1,57 +1,57 @@
-import { z } from 'zod'
-
-export const ChromaConfigSchema = z.object({
-  mode: z.enum(['persistent', 'client-server', 'ephemeral', 'cloud']).default('persistent'),
-  path: z.string().default('./data/chroma'),
-  host: z.string().optional(),
-  port: z.number().optional(),
-  embeddingProvider: z.enum(['default', 'transformers', 'openai']).default('default'),
-  embeddingModel: z.string().default('Xenova/all-MiniLM-L6-v2'),
-  defaultCollection: z.string().default('memories'),
-  batchSize: z.number().default(100),
-  openaiApiKey: z.string().optional(),
-  chromaAuthToken: z.string().optional(),
-  chromaTenant: z.string().optional(),
-  chromaDatabase: z.string().optional()
-})
-
-export type ChromaConfig = z.infer<typeof ChromaConfigSchema>
-
-export const DEFAULT_CHROMA_CONFIG: ChromaConfig = {
-  mode: 'persistent',
-  path: './data/chroma',
-  embeddingProvider: 'default',
-  embeddingModel: 'Xenova/all-MiniLM-L6-v2',
-  defaultCollection: 'memories',
-  batchSize: 100
-}
-
-export function getChromaConfigFromEnv(): Partial<ChromaConfig> {
-  const config: Partial<ChromaConfig> = {
-    chromaAuthToken: process.env.CHROMA_API_KEY,
-    chromaTenant: process.env.CHROMA_TENANT,
-    chromaDatabase: process.env.CHROMA_DATABASE
-  }
-
-  if (process.env.CHROMA_HOST) {
-    config.host = process.env.CHROMA_HOST
-    // Only default to cloud if CHROMA_MODE isn't explicitly set
-    if (!process.env.CHROMA_MODE) {
-      config.mode = 'cloud'
-    }
-  }
-
-  if (process.env.CHROMA_MODE) {
-    config.mode = process.env.CHROMA_MODE as any
-  }
-
-  if (process.env.CHROMA_PORT) {
-    config.port = parseInt(process.env.CHROMA_PORT, 10)
-  }
-
-  if (process.env.CHROMA_EMBEDDING_PROVIDER) {
-    config.embeddingProvider = process.env.CHROMA_EMBEDDING_PROVIDER as any
-  }
-
-  return config
-}
+import { z } from 'zod'
+
+export const ChromaConfigSchema = z.object({
+  mode: z.enum(['persistent', 'client-server', 'ephemeral', 'cloud']).default('persistent'),
+  path: z.string().default('./data/chroma'),
+  host: z.string().optional(),
+  port: z.number().optional(),
+  embeddingProvider: z.enum(['default', 'transformers', 'openai']).default('default'),
+  embeddingModel: z.string().default('Xenova/all-MiniLM-L6-v2'),
+  defaultCollection: z.string().default('memories'),
+  batchSize: z.number().default(100),
+  openaiApiKey: z.string().optional(),
+  chromaAuthToken: z.string().optional(),
+  chromaTenant: z.string().optional(),
+  chromaDatabase: z.string().optional()
+})
+
+export type ChromaConfig = z.infer<typeof ChromaConfigSchema>
+
+export const DEFAULT_CHROMA_CONFIG: ChromaConfig = {
+  mode: 'persistent',
+  path: './data/chroma',
+  embeddingProvider: 'default',
+  embeddingModel: 'Xenova/all-MiniLM-L6-v2',
+  defaultCollection: 'memories',
+  batchSize: 100
+}
+
+export function getChromaConfigFromEnv(): Partial<ChromaConfig> {
+  const config: Partial<ChromaConfig> = {
+    chromaAuthToken: process.env.CHROMA_API_KEY,
+    chromaTenant: process.env.CHROMA_TENANT,
+    chromaDatabase: process.env.CHROMA_DATABASE
+  }
+
+  if (process.env.CHROMA_HOST) {
+    config.host = process.env.CHROMA_HOST
+    // Only default to cloud if CHROMA_MODE isn't explicitly set
+    if (!process.env.CHROMA_MODE) {
+      config.mode = 'cloud'
+    }
+  }
+
+  if (process.env.CHROMA_MODE) {
+    config.mode = process.env.CHROMA_MODE as any
+  }
+
+  if (process.env.CHROMA_PORT) {
+    config.port = parseInt(process.env.CHROMA_PORT, 10)
+  }
+
+  if (process.env.CHROMA_EMBEDDING_PROVIDER) {
+    config.embeddingProvider = process.env.CHROMA_EMBEDDING_PROVIDER as any
+  }
+
+  return config
+}

package/src/memory/chroma/embeddings.ts

@@ -1,175 +1,177 @@
-import type { Logger } from 'pino'
-import type { ChromaConfig } from './config'
-
-export interface EmbeddingProvider {
-  name: string
-  dimensions: number
-  generate(text: string): Promise<number[]>
-  generateBatch(texts: string[]): Promise<number[][]>
-}
-
-export class DefaultEmbeddingProvider implements EmbeddingProvider {
-  name = 'default'
-  dimensions = 384
-
-  async generate(_text: string): Promise<number[]> {
-    throw new Error('Default provider uses ChromaDB auto-embedding')
-  }
-
-  async generateBatch(_texts: string[]): Promise<number[][]> {
-    throw new Error('Default provider uses ChromaDB auto-embedding')
-  }
-}
-
-export class TransformersEmbeddingProvider implements EmbeddingProvider {
-  name = 'transformers'
-  dimensions = 384
-
-  private pipeline: any = null
-  private logger: Logger
-  private modelName: string
-
-  constructor(logger: Logger, modelName: string = 'Xenova/all-MiniLM-L6-v2') {
-    this.logger = logger.child({ component: 'transformers-embeddings' })
-    this.modelName = modelName
-  }
-
-  private async getPipeline() {
-    if (!this.pipeline) {
-      try {
-        const { pipeline } = await import('@xenova/transformers')
-        this.pipeline = await pipeline('feature-extraction', this.modelName)
-      } catch (error) {
-        this.logger.warn({ error }, 'Model load failed, clearing cache and retrying')
-        await this.clearModelCache()
-        const { pipeline } = await import('@xenova/transformers')
-        this.pipeline = await pipeline('feature-extraction', this.modelName)
-      }
-      this.logger.info({ model: this.modelName }, 'Transformers pipeline initialized')
-    }
-    return this.pipeline
-  }
-
-  private async clearModelCache(): Promise<void> {
-    const { rm } = await import('fs/promises')
-    const { join } = await import('path')
-    const cacheDir = join(
-      require.resolve('@xenova/transformers'),
-      '..', '.cache', ...this.modelName.split('/')
-    )
-    try {
-      await rm(cacheDir, { recursive: true, force: true })
-      this.logger.info({ cacheDir }, 'Cleared corrupted model cache')
-    } catch {
-      // Cache dir may not exist, continue
-    }
-  }
-
-  async generate(text: string): Promise<number[]> {
-    const pipe = await this.getPipeline()
-
-    const output = await pipe(text, {
-      pooling: 'mean',
-      normalize: true
-    })
-
-    return Array.from(output.data as Float32Array)
-  }
-
-  async generateBatch(texts: string[]): Promise<number[][]> {
-    const embeddings: number[][] = []
-
-    const batchSize = 10
-
-    for (let i = 0; i < texts.length; i += batchSize) {
-      const batch = texts.slice(i, i + batchSize)
-      const batchEmbeddings = await Promise.all(
-        batch.map(text => this.generate(text))
-      )
-      embeddings.push(...batchEmbeddings)
-    }
-
-    return embeddings
-  }
-}
-
-export class OpenAIEmbeddingProvider implements EmbeddingProvider {
-  name = 'openai'
-  dimensions = 1536
-
-  private apiKey: string
-  private model: string
-
-  constructor(
-    _logger: Logger,
-    apiKey: string,
-    model: string = 'text-embedding-3-small'
-  ) {
-    this.apiKey = apiKey
-    this.model = model
-  }
-
-  async generate(text: string): Promise<number[]> {
-    const response = await fetch('https://api.openai.com/v1/embeddings', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        model: this.model,
-        input: text
-      })
-    })
-
-    if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.statusText}`)
-    }
-
-    const data: any = await response.json()
-    return data.data[0].embedding
-  }
-
-  async generateBatch(texts: string[]): Promise<number[][]> {
-    const response = await fetch('https://api.openai.com/v1/embeddings', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        model: this.model,
-        input: texts
-      })
-    })
-
-    if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.statusText}`)
-    }
-
-    const data: any = await response.json()
-    return data.data.map((d: any) => d.embedding)
-  }
-}
-
-export function createEmbeddingProvider(
-  logger: Logger,
-  config: ChromaConfig
-): EmbeddingProvider | undefined {
-  switch (config.embeddingProvider) {
-    case 'openai':
-      if (!config.openaiApiKey) {
-        throw new Error('OpenAI API key required for OpenAI embedding provider')
-      }
-      return new OpenAIEmbeddingProvider(logger, config.openaiApiKey)
-
-    case 'transformers':
-      return new TransformersEmbeddingProvider(logger, config.embeddingModel)
-
-    case 'default':
-    default:
-      // Return undefined so store/search code falls through to queryTexts path
-      // (ChromaDB's built-in auto-embedding)
-      return undefined
-  }
-}
+import type { Logger } from 'pino'
+import type { ChromaConfig } from './config'
+
+export interface EmbeddingProvider {
+  name: string
+  dimensions: number
+  generate(text: string): Promise<number[]>
+  generateBatch(texts: string[]): Promise<number[][]>
+}
+
+export class DefaultEmbeddingProvider implements EmbeddingProvider {
+  name = 'default'
+  dimensions = 384
+
+  async generate(_text: string): Promise<number[]> {
+    throw new Error('Default provider uses ChromaDB auto-embedding')
+  }
+
+  async generateBatch(_texts: string[]): Promise<number[][]> {
+    throw new Error('Default provider uses ChromaDB auto-embedding')
+  }
+}
+
+export class TransformersEmbeddingProvider implements EmbeddingProvider {
+  name = 'transformers'
+  dimensions = 384
+
+  private pipeline: unknown = null
+  private logger: Logger
+  private modelName: string
+
+  constructor(logger: Logger, modelName: string = 'Xenova/all-MiniLM-L6-v2') {
+    this.logger = logger.child({ component: 'transformers-embeddings' })
+    this.modelName = modelName
+  }
+
+  private async getPipeline(): Promise<(text: string, options: Record<string, unknown>) => Promise<{ data: Float32Array }>> {
+    if (!this.pipeline) {
+      try {
+        const { pipeline } = await import('@xenova/transformers')
+        this.pipeline = await pipeline('feature-extraction', this.modelName)
+      } catch (error) {
+        this.logger.warn({ error }, 'Model load failed, clearing cache and retrying')
+        await this.clearModelCache()
+        const { pipeline } = await import('@xenova/transformers')
+        this.pipeline = await pipeline('feature-extraction', this.modelName)
+      }
+      this.logger.info({ model: this.modelName }, 'Transformers pipeline initialized')
+    }
+    return this.pipeline as (text: string, options: Record<string, unknown>) => Promise<{ data: Float32Array }>
+  }
+
+  private async clearModelCache(): Promise<void> {
+    const { rm } = await import('fs/promises')
+    const { join } = await import('path')
+    const cacheDir = join(
+      require.resolve('@xenova/transformers'),
+      '..', '.cache', ...this.modelName.split('/')
+    )
+    try {
+      await rm(cacheDir, { recursive: true, force: true })
+      this.logger.info({ cacheDir }, 'Cleared corrupted model cache')
+    } catch {
+      // Cache dir may not exist, continue
+    }
+  }
+
+  async generate(text: string): Promise<number[]> {
+    const pipe = await this.getPipeline()
+
+    const output = await pipe(text, {
+      pooling: 'mean',
+      normalize: true
+    })
+
+    return Array.from(output.data as Float32Array)
+  }
+
+  async generateBatch(texts: string[]): Promise<number[][]> {
+    const embeddings: number[][] = []
+
+    const batchSize = 10
+
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize)
+      const batchEmbeddings = await Promise.all(
+        batch.map(text => this.generate(text))
+      )
+      embeddings.push(...batchEmbeddings)
+    }
+
+    return embeddings
+  }
+}
+
+export class OpenAIEmbeddingProvider implements EmbeddingProvider {
+  name = 'openai'
+  dimensions = 1536
+
+  private apiKey: string
+  private model: string
+
+  constructor(
+    _logger: Logger,
+    apiKey: string,
+    model: string = 'text-embedding-3-small'
+  ) {
+    this.apiKey = apiKey
+    this.model = model
+  }
+
+  async generate(text: string): Promise<number[]> {
+    const response = await fetch('https://api.openai.com/v1/embeddings', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input: text
+      })
+    })
+
+    if (!response.ok) {
+      throw new Error(`OpenAI API error: ${response.statusText}`)
+    }
+
+    const data = await response.json() as { data: Array<{ embedding: number[] }> }
+    const first = data.data[0]
+    if (!first) throw new Error('OpenAI returned empty embedding data')
+    return first.embedding
+  }
+
+  async generateBatch(texts: string[]): Promise<number[][]> {
+    const response = await fetch('https://api.openai.com/v1/embeddings', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input: texts
+      })
+    })
+
+    if (!response.ok) {
+      throw new Error(`OpenAI API error: ${response.statusText}`)
+    }
+
+    const data = await response.json() as { data: Array<{ embedding: number[] }> }
+    return data.data.map((d) => d.embedding)
+  }
+}
+
+export function createEmbeddingProvider(
+  logger: Logger,
+  config: ChromaConfig
+): EmbeddingProvider | undefined {
+  switch (config.embeddingProvider) {
+    case 'openai':
+      if (!config.openaiApiKey) {
+        throw new Error('OpenAI API key required for OpenAI embedding provider')
+      }
+      return new OpenAIEmbeddingProvider(logger, config.openaiApiKey)
+
+    case 'transformers':
+      return new TransformersEmbeddingProvider(logger, config.embeddingModel)
+
+    case 'default':
+    default:
+      // Return undefined so store/search code falls through to queryTexts path
+      // (ChromaDB's built-in auto-embedding)
+      return undefined
+  }
+}