claude-brain 0.30.2 → 0.30.3

package/src/knowledge/relationship-extractor.ts

@@ -1,108 +1,108 @@
-/**
- * Relationship Extractor
- * Pattern-based extraction of relationships between entities
- */
-
-import type { RelationshipType } from './graph/schema'
-import type { ExtractedEntity } from './entity-extractor'
-
-export interface ExtractedRelationship {
-  sourceEntity: string
-  targetEntity: string
-  relationship: RelationshipType
-  confidence: number
-  evidence: string
-}
-
-interface RelationshipPattern {
-  regex: RegExp
-  relationship: RelationshipType
-  confidence: number
-  sourceGroup: number
-  targetGroup: number
-}
-
-const PATTERNS: RelationshipPattern[] = [
-  // "chose X for Y", "use X for Y", "selected X for Y"
-  { regex: /(?:chose|choose|use|using|selected|picked)\s+(\w[\w.-]*)\s+(?:for|in|with)\s+(\w[\w.-]*)/gi, relationship: 'uses', confidence: 0.85, sourceGroup: 2, targetGroup: 1 },
-  // "X uses Y", "X depends on Y"
-  { regex: /(\w[\w.-]*)\s+(?:uses|utilizes|leverages|employs)\s+(\w[\w.-]*)/gi, relationship: 'uses', confidence: 0.8, sourceGroup: 1, targetGroup: 2 },
-  // "X depends on Y", "X requires Y"
-  { regex: /(\w[\w.-]*)\s+(?:depends?\s+on|requires|needs)\s+(\w[\w.-]*)/gi, relationship: 'depends_on', confidence: 0.85, sourceGroup: 1, targetGroup: 2 },
-  // "replaced X with Y", "migrated from X to Y"
-  { regex: /(?:replaced|replace|swap(?:ped)?)\s+(\w[\w.-]*)\s+(?:with|for)\s+(\w[\w.-]*)/gi, relationship: 'replaces', confidence: 0.9, sourceGroup: 2, targetGroup: 1 },
-  { regex: /(?:migrated?|moved?|switched?)\s+(?:from\s+)?(\w[\w.-]*)\s+to\s+(\w[\w.-]*)/gi, relationship: 'replaces', confidence: 0.85, sourceGroup: 2, targetGroup: 1 },
-  // "X contradicts Y", "X conflicts with Y"
-  { regex: /(\w[\w.-]*)\s+(?:contradicts|conflicts?\s+with|incompatible\s+with)\s+(\w[\w.-]*)/gi, relationship: 'contradicts', confidence: 0.8, sourceGroup: 1, targetGroup: 2 },
-  // "X is part of Y", "X belongs to Y"
-  { regex: /(\w[\w.-]*)\s+(?:is\s+part\s+of|belongs?\s+to|included?\s+in)\s+(\w[\w.-]*)/gi, relationship: 'part_of', confidence: 0.8, sourceGroup: 1, targetGroup: 2 },
-  // "X relates to Y", "X is related to Y"
-  { regex: /(\w[\w.-]*)\s+(?:relates?\s+to|is\s+related\s+to|connects?\s+(?:to|with))\s+(\w[\w.-]*)/gi, relationship: 'relates_to', confidence: 0.7, sourceGroup: 1, targetGroup: 2 },
-  // "X is similar to Y", "X like Y"
-  { regex: /(\w[\w.-]*)\s+(?:is\s+similar\s+to|like|resembles|comparable\s+to)\s+(\w[\w.-]*)/gi, relationship: 'similar_to', confidence: 0.7, sourceGroup: 1, targetGroup: 2 },
-  // "after X, Y" / "X then Y" (temporal sequencing)
-  { regex: /(?:after|following)\s+(\w[\w.-]*)\s*,?\s*(?:we\s+)?(?:use|chose|moved\s+to|adopted)\s+(\w[\w.-]*)/gi, relationship: 'follows', confidence: 0.7, sourceGroup: 2, targetGroup: 1 },
-]
-
-export class RelationshipExtractor {
-  extract(text: string, entities: ExtractedEntity[]): ExtractedRelationship[] {
-    const relationships: ExtractedRelationship[] = []
-    const entityNames = new Set(entities.map(e => e.normalizedName))
-
-    for (const pattern of PATTERNS) {
-      let match: RegExpExecArray | null
-      const regex = new RegExp(pattern.regex.source, pattern.regex.flags)
-
-      while ((match = regex.exec(text)) !== null) {
-        const rawSource = match[pattern.sourceGroup]?.toLowerCase()
-        const rawTarget = match[pattern.targetGroup]?.toLowerCase()
-
-        if (!rawSource || !rawTarget) continue
-        if (rawSource === rawTarget) continue
-
-        // Check if at least one entity is known
-        const sourceKnown = entityNames.has(rawSource) || this.findEntityMatch(rawSource, entities)
-        const targetKnown = entityNames.has(rawTarget) || this.findEntityMatch(rawTarget, entities)
-
-        if (!sourceKnown && !targetKnown) continue
-
-        const sourceName = this.resolveEntityName(rawSource, entities) || rawSource
-        const targetName = this.resolveEntityName(rawTarget, entities) || rawTarget
-
-        // Avoid duplicates
-        const exists = relationships.some(r =>
-          r.sourceEntity === sourceName &&
-          r.targetEntity === targetName &&
-          r.relationship === pattern.relationship
-        )
-
-        if (!exists) {
-          relationships.push({
-            sourceEntity: sourceName,
-            targetEntity: targetName,
-            relationship: pattern.relationship,
-            confidence: pattern.confidence * (sourceKnown && targetKnown ? 1.0 : 0.8),
-            evidence: match[0].trim()
-          })
-        }
-      }
-    }
-
-    return relationships
-  }
-
-  private findEntityMatch(name: string, entities: ExtractedEntity[]): boolean {
-    return entities.some(e =>
-      e.normalizedName === name ||
-      e.name.toLowerCase() === name
-    )
-  }
-
-  private resolveEntityName(name: string, entities: ExtractedEntity[]): string | undefined {
-    const entity = entities.find(e =>
-      e.normalizedName === name ||
-      e.name.toLowerCase() === name
-    )
-    return entity?.normalizedName
-  }
-}
+/**
+ * Relationship Extractor
+ * Pattern-based extraction of relationships between entities
+ */
+
+import type { RelationshipType } from './graph/schema'
+import type { ExtractedEntity } from './entity-extractor'
+
+export interface ExtractedRelationship {
+  sourceEntity: string
+  targetEntity: string
+  relationship: RelationshipType
+  confidence: number
+  evidence: string
+}
+
+interface RelationshipPattern {
+  regex: RegExp
+  relationship: RelationshipType
+  confidence: number
+  sourceGroup: number
+  targetGroup: number
+}
+
+const PATTERNS: RelationshipPattern[] = [
+  // "chose X for Y", "use X for Y", "selected X for Y"
+  { regex: /(?:chose|choose|use|using|selected|picked)\s+(\w[\w.-]*)\s+(?:for|in|with)\s+(\w[\w.-]*)/gi, relationship: 'uses', confidence: 0.85, sourceGroup: 2, targetGroup: 1 },
+  // "X uses Y", "X depends on Y"
+  { regex: /(\w[\w.-]*)\s+(?:uses|utilizes|leverages|employs)\s+(\w[\w.-]*)/gi, relationship: 'uses', confidence: 0.8, sourceGroup: 1, targetGroup: 2 },
+  // "X depends on Y", "X requires Y"
+  { regex: /(\w[\w.-]*)\s+(?:depends?\s+on|requires|needs)\s+(\w[\w.-]*)/gi, relationship: 'depends_on', confidence: 0.85, sourceGroup: 1, targetGroup: 2 },
+  // "replaced X with Y", "migrated from X to Y"
+  { regex: /(?:replaced|replace|swap(?:ped)?)\s+(\w[\w.-]*)\s+(?:with|for)\s+(\w[\w.-]*)/gi, relationship: 'replaces', confidence: 0.9, sourceGroup: 2, targetGroup: 1 },
+  { regex: /(?:migrated?|moved?|switched?)\s+(?:from\s+)?(\w[\w.-]*)\s+to\s+(\w[\w.-]*)/gi, relationship: 'replaces', confidence: 0.85, sourceGroup: 2, targetGroup: 1 },
+  // "X contradicts Y", "X conflicts with Y"
+  { regex: /(\w[\w.-]*)\s+(?:contradicts|conflicts?\s+with|incompatible\s+with)\s+(\w[\w.-]*)/gi, relationship: 'contradicts', confidence: 0.8, sourceGroup: 1, targetGroup: 2 },
+  // "X is part of Y", "X belongs to Y"
+  { regex: /(\w[\w.-]*)\s+(?:is\s+part\s+of|belongs?\s+to|included?\s+in)\s+(\w[\w.-]*)/gi, relationship: 'part_of', confidence: 0.8, sourceGroup: 1, targetGroup: 2 },
+  // "X relates to Y", "X is related to Y"
+  { regex: /(\w[\w.-]*)\s+(?:relates?\s+to|is\s+related\s+to|connects?\s+(?:to|with))\s+(\w[\w.-]*)/gi, relationship: 'relates_to', confidence: 0.7, sourceGroup: 1, targetGroup: 2 },
+  // "X is similar to Y", "X like Y"
+  { regex: /(\w[\w.-]*)\s+(?:is\s+similar\s+to|like|resembles|comparable\s+to)\s+(\w[\w.-]*)/gi, relationship: 'similar_to', confidence: 0.7, sourceGroup: 1, targetGroup: 2 },
+  // "after X, Y" / "X then Y" (temporal sequencing)
+  { regex: /(?:after|following)\s+(\w[\w.-]*)\s*,?\s*(?:we\s+)?(?:use|chose|moved\s+to|adopted)\s+(\w[\w.-]*)/gi, relationship: 'follows', confidence: 0.7, sourceGroup: 2, targetGroup: 1 },
+]
+
+export class RelationshipExtractor {
+  extract(text: string, entities: ExtractedEntity[]): ExtractedRelationship[] {
+    const relationships: ExtractedRelationship[] = []
+    const entityNames = new Set(entities.map(e => e.normalizedName))
+
+    for (const pattern of PATTERNS) {
+      let match: RegExpExecArray | null
+      const regex = new RegExp(pattern.regex.source, pattern.regex.flags)
+
+      while ((match = regex.exec(text)) !== null) {
+        const rawSource = match[pattern.sourceGroup]?.toLowerCase()
+        const rawTarget = match[pattern.targetGroup]?.toLowerCase()
+
+        if (!rawSource || !rawTarget) continue
+        if (rawSource === rawTarget) continue
+
+        // Check if at least one entity is known
+        const sourceKnown = entityNames.has(rawSource) || this.findEntityMatch(rawSource, entities)
+        const targetKnown = entityNames.has(rawTarget) || this.findEntityMatch(rawTarget, entities)
+
+        if (!sourceKnown && !targetKnown) continue
+
+        const sourceName = this.resolveEntityName(rawSource, entities) || rawSource
+        const targetName = this.resolveEntityName(rawTarget, entities) || rawTarget
+
+        // Avoid duplicates
+        const exists = relationships.some(r =>
+          r.sourceEntity === sourceName &&
+          r.targetEntity === targetName &&
+          r.relationship === pattern.relationship
+        )
+
+        if (!exists) {
+          relationships.push({
+            sourceEntity: sourceName,
+            targetEntity: targetName,
+            relationship: pattern.relationship,
+            confidence: pattern.confidence * (sourceKnown && targetKnown ? 1.0 : 0.8),
+            evidence: match[0].trim()
+          })
+        }
+      }
+    }
+
+    return relationships
+  }
+
+  private findEntityMatch(name: string, entities: ExtractedEntity[]): boolean {
+    return entities.some(e =>
+      e.normalizedName === name ||
+      e.name.toLowerCase() === name
+    )
+  }
+
+  private resolveEntityName(name: string, entities: ExtractedEntity[]): string | undefined {
+    const entity = entities.find(e =>
+      e.normalizedName === name ||
+      e.name.toLowerCase() === name
+    )
+    return entity?.normalizedName
+  }
+}

package/src/memory/chroma/client.ts

@@ -1,192 +1,211 @@
-import { ChromaClient, Collection } from 'chromadb'
-import type { Logger } from 'pino'
-import type { ChromaConfig } from './config'
-
-export class ChromaClientManager {
-  private client: ChromaClient | null = null
-  private logger: Logger
-  private config: ChromaConfig
-  private isConnected: boolean = false
-  private collections: Map<string, Collection> = new Map()
-  private pendingCollections: Map<string, Promise<Collection>> = new Map()
-
-  constructor(logger: Logger, config: ChromaConfig) {
-    this.logger = logger.child({ component: 'chroma-client' })
-    this.config = config
-  }
-
-  async initialize(): Promise<void> {
-    this.logger.info({ mode: this.config.mode }, 'Initializing ChromaDB client')
-
-    try {
-      const authConfig = this.config.chromaAuthToken ? {
-        headers: {
-          'Authorization': `Bearer ${this.config.chromaAuthToken}`,
-          'X-Chroma-Token': this.config.chromaAuthToken
-        },
-        ...(this.config.chromaTenant ? { tenant: this.config.chromaTenant } : {}),
-        ...(this.config.chromaDatabase ? { database: this.config.chromaDatabase } : {})
-      } : {}
-
-      switch (this.config.mode) {
-        case 'persistent':
-          // ChromaDB v3.x no longer supports embedded persistent mode via 'path'.
-          // Fall through to client-server connecting to localhost.
-          this.logger.info('Persistent mode: connecting to ChromaDB server on localhost (v3.x requires a running server)')
-          this.client = new ChromaClient({
-            host: this.config.host || 'localhost',
-            port: this.config.port || 8000,
-            ...authConfig
-          })
-          break
-
-        case 'client-server':
-          if (!this.config.host) {
-            throw new Error('Host required for client-server mode')
-          }
-          this.client = new ChromaClient({
-            host: this.config.host,
-            port: this.config.port || 8000,
-            ...authConfig
-          })
-          break
-
-        case 'cloud':
-          if (!this.config.host) {
-            throw new Error('Host URL required for cloud mode')
-          }
-          const hostWithProtocol = this.config.host.startsWith('http')
-            ? this.config.host
-            : `https://${this.config.host}`
-          const url = new URL(hostWithProtocol)
-          this.client = new ChromaClient({
-            host: url.hostname,
-            port: url.port ? parseInt(url.port) : (url.protocol === 'https:' ? 443 : 80),
-            ssl: url.protocol === 'https:',
-            ...authConfig
-          })
-          break
-
-        case 'ephemeral':
-          try {
-            this.client = new ChromaClient()
-          } catch (err) {
-            this.logger.warn({ error: err }, 'Ephemeral mode failed, attempting client-server mode')
-            this.client = new ChromaClient({
-              host: 'localhost',
-              port: 8000,
-              ssl: false,
-              ...authConfig
-            })
-          }
-          break
-      }
-
-      try {
-        await this.client.heartbeat()
-        this.isConnected = true
-        this.logger.info('ChromaDB client initialized successfully')
-      } catch (heartbeatError) {
-        this.isConnected = false
-        this.logger.warn({ error: heartbeatError }, 'ChromaDB heartbeat failed')
-        throw new Error(`ChromaDB server unreachable: ${heartbeatError instanceof Error ? heartbeatError.message : String(heartbeatError)}`)
-      }
-
-    } catch (error) {
-      this.logger.warn({ error }, 'ChromaDB not available, will use SQLite fallback')
-      throw error
-    }
-  }
-
-  async getCollection(name: string): Promise<Collection> {
-    if (!this.client) {
-      throw new Error('ChromaDB client not initialized')
-    }
-
-    if (this.collections.has(name)) {
-      return this.collections.get(name)!
-    }
-
-    // Deduplicate concurrent calls: if a getOrCreateCollection is already
-    // in-flight for this name, reuse the same promise instead of racing.
-    if (this.pendingCollections.has(name)) {
-      return this.pendingCollections.get(name)!
-    }
-
-    const pending = this.fetchAndCacheCollection(name)
-    this.pendingCollections.set(name, pending)
-
-    try {
-      return await pending
-    } finally {
-      this.pendingCollections.delete(name)
-    }
-  }
-
-  private async fetchAndCacheCollection(name: string): Promise<Collection> {
-    try {
-      const collection = await this.client!.getOrCreateCollection({
-        name,
-        metadata: {
-          'hnsw:space': 'cosine',
-          'created_at': new Date().toISOString()
-        }
-      })
-
-      this.collections.set(name, collection)
-      this.logger.info({ collection: name }, 'Collection retrieved/created')
-
-      return collection
-
-    } catch (error) {
-      this.logger.error({ error, collection: name }, 'Failed to get collection')
-      throw error
-    }
-  }
-
-  async listCollections(): Promise<string[]> {
-    if (!this.client) {
-      throw new Error('ChromaDB client not initialized')
-    }
-
-    const collections = await this.client.listCollections()
-    return collections.map(c => c.name)
-  }
-
-  async deleteCollection(name: string): Promise<void> {
-    if (!this.client) {
-      throw new Error('ChromaDB client not initialized')
-    }
-
-    await this.client.deleteCollection({ name })
-    this.collections.delete(name)
-    this.logger.info({ collection: name }, 'Collection deleted')
-  }
-
-  async healthCheck(): Promise<boolean> {
-    if (!this.client) return false
-
-    try {
-      await this.client.heartbeat()
-      return true
-    } catch {
-      this.isConnected = false
-      return false
-    }
-  }
-
-  getStatus(): { connected: boolean; mode: string; collections: number } {
-    return {
-      connected: this.isConnected,
-      mode: this.config.mode,
-      collections: this.collections.size
-    }
-  }
-
-  async close(): Promise<void> {
-    this.collections.clear()
-    this.client = null
-    this.isConnected = false
-    this.logger.info('ChromaDB client closed')
-  }
-}
+import { ChromaClient, Collection } from 'chromadb'
+import type { Logger } from 'pino'
+import type { ChromaConfig } from './config'
+
+export class ChromaClientManager {
+  private client: ChromaClient | null = null
+  private logger: Logger
+  private config: ChromaConfig
+  private isConnected: boolean = false
+  private collections: Map<string, Collection> = new Map()
+  private pendingCollections: Map<string, Promise<Collection>> = new Map()
+
+  constructor(logger: Logger, config: ChromaConfig) {
+    this.logger = logger.child({ component: 'chroma-client' })
+    this.config = config
+  }
+
+  async initialize(): Promise<void> {
+    this.logger.info({ mode: this.config.mode }, 'Initializing ChromaDB client')
+
+    // Enforce HTTPS when API key/auth token is configured
+    if (this.config.host && this.config.chromaAuthToken) {
+      try {
+        const hostUrl = this.config.host.startsWith('http')
+          ? this.config.host
+          : `https://${this.config.host}`
+        const url = new URL(hostUrl)
+        if (url.protocol !== 'https:') {
+          throw new Error(
+            `ChromaDB host must use HTTPS when API key is configured. Got: ${url.protocol} ` +
+            `Change CHROMA_HOST to use https://`
+          )
+        }
+      } catch (e) {
+        if ((e as Error).message.includes('HTTPS')) throw e
+        // URL parsing failed — will be caught downstream
+      }
+    }
+
+    try {
+      const authConfig = this.config.chromaAuthToken ? {
+        headers: {
+          'Authorization': `Bearer ${this.config.chromaAuthToken}`,
+          'X-Chroma-Token': this.config.chromaAuthToken
+        },
+        ...(this.config.chromaTenant ? { tenant: this.config.chromaTenant } : {}),
+        ...(this.config.chromaDatabase ? { database: this.config.chromaDatabase } : {})
+      } : {}
+
+      switch (this.config.mode) {
+        case 'persistent':
+          // ChromaDB v3.x no longer supports embedded persistent mode via 'path'.
+          // Fall through to client-server connecting to localhost.
+          this.logger.info('Persistent mode: connecting to ChromaDB server on localhost (v3.x requires a running server)')
+          this.client = new ChromaClient({
+            host: this.config.host || 'localhost',
+            port: this.config.port || 8000,
+            ...authConfig
+          })
+          break
+
+        case 'client-server':
+          if (!this.config.host) {
+            throw new Error('Host required for client-server mode')
+          }
+          this.client = new ChromaClient({
+            host: this.config.host,
+            port: this.config.port || 8000,
+            ...authConfig
+          })
+          break
+
+        case 'cloud':
+          if (!this.config.host) {
+            throw new Error('Host URL required for cloud mode')
+          }
+          const hostWithProtocol = this.config.host.startsWith('http')
+            ? this.config.host
+            : `https://${this.config.host}`
+          const url = new URL(hostWithProtocol)
+          this.client = new ChromaClient({
+            host: url.hostname,
+            port: url.port ? parseInt(url.port) : (url.protocol === 'https:' ? 443 : 80),
+            ssl: url.protocol === 'https:',
+            ...authConfig
+          })
+          break
+
+        case 'ephemeral':
+          try {
+            this.client = new ChromaClient()
+          } catch (err) {
+            this.logger.warn({ error: err }, 'Ephemeral mode failed, attempting client-server mode')
+            this.client = new ChromaClient({
+              host: 'localhost',
+              port: 8000,
+              ssl: false,
+              ...authConfig
+            })
+          }
+          break
+      }
+
+      try {
+        await this.client.heartbeat()
+        this.isConnected = true
+        this.logger.info('ChromaDB client initialized successfully')
+      } catch (heartbeatError) {
+        this.isConnected = false
+        this.logger.warn({ error: heartbeatError }, 'ChromaDB heartbeat failed')
+        throw new Error(`ChromaDB server unreachable: ${heartbeatError instanceof Error ? heartbeatError.message : String(heartbeatError)}`)
+      }
+
+    } catch (error) {
+      this.logger.warn({ error }, 'ChromaDB not available, will use SQLite fallback')
+      throw error
+    }
+  }
+
+  async getCollection(name: string): Promise<Collection> {
+    if (!this.client) {
+      throw new Error('ChromaDB client not initialized')
+    }
+
+    if (this.collections.has(name)) {
+      return this.collections.get(name)!
+    }
+
+    // Deduplicate concurrent calls: if a getOrCreateCollection is already
+    // in-flight for this name, reuse the same promise instead of racing.
+    if (this.pendingCollections.has(name)) {
+      return this.pendingCollections.get(name)!
+    }
+
+    const pending = this.fetchAndCacheCollection(name)
+    this.pendingCollections.set(name, pending)
+
+    try {
+      return await pending
+    } finally {
+      this.pendingCollections.delete(name)
+    }
+  }
+
+  private async fetchAndCacheCollection(name: string): Promise<Collection> {
+    try {
+      const collection = await this.client!.getOrCreateCollection({
+        name,
+        metadata: {
+          'hnsw:space': 'cosine',
+          'created_at': new Date().toISOString()
+        }
+      })
+
+      this.collections.set(name, collection)
+      this.logger.info({ collection: name }, 'Collection retrieved/created')
+
+      return collection
+
+    } catch (error) {
+      this.logger.error({ error, collection: name }, 'Failed to get collection')
+      throw error
+    }
+  }
+
+  async listCollections(): Promise<string[]> {
+    if (!this.client) {
+      throw new Error('ChromaDB client not initialized')
+    }
+
+    const collections = await this.client.listCollections()
+    return collections.map(c => c.name)
+  }
+
+  async deleteCollection(name: string): Promise<void> {
+    if (!this.client) {
+      throw new Error('ChromaDB client not initialized')
+    }
+
+    await this.client.deleteCollection({ name })
+    this.collections.delete(name)
+    this.logger.info({ collection: name }, 'Collection deleted')
+  }
+
+  async healthCheck(): Promise<boolean> {
+    if (!this.client) return false
+
+    try {
+      await this.client.heartbeat()
+      return true
+    } catch {
+      this.isConnected = false
+      return false
+    }
+  }
+
+  getStatus(): { connected: boolean; mode: string; collections: number } {
+    return {
+      connected: this.isConnected,
+      mode: this.config.mode,
+      collections: this.collections.size
+    }
+  }
+
+  async close(): Promise<void> {
+    this.collections.clear()
+    this.client = null
+    this.isConnected = false
+    this.logger.info('ChromaDB client closed')
+  }
+}