claude-brain 0.30.2 → 0.30.3

package/src/knowledge/graph/builder.ts

@@ -1,185 +1,185 @@
-/**
- * Knowledge Graph Builder
- * Auto-populates the graph when decisions/patterns/corrections are stored
- */
-
-import type { Logger } from 'pino'
-import type { InMemoryKnowledgeGraph } from './memory-graph'
-import { EntityExtractor } from '../entity-extractor'
-import { RelationshipExtractor } from '../relationship-extractor'
-import type { StoreDecisionInput } from '../../memory/chroma/store'
-import type { CollectionManager } from '../../memory/chroma/collection-manager'
-
-export class KnowledgeGraphBuilder {
-  private graph: InMemoryKnowledgeGraph
-  private entityExtractor: EntityExtractor
-  private relationshipExtractor: RelationshipExtractor
-  private logger: Logger
-
-  constructor(graph: InMemoryKnowledgeGraph, logger: Logger) {
-    this.graph = graph
-    this.entityExtractor = new EntityExtractor()
-    this.relationshipExtractor = new RelationshipExtractor()
-    this.logger = logger.child({ component: 'graph-builder' })
-  }
-
-  async initialize(): Promise<void> {
-    await this.entityExtractor.initialize()
-  }
-
-  /**
-   * Remove a decision node and its edges from the knowledge graph by decision ID.
-   * Used when a decision is deleted from the store.
-   */
-  removeDecision(decisionId: string): void {
-    try {
-      const nodes = this.graph.findNodes({
-        type: 'decision',
-        properties: { decision_id: decisionId }
-      })
-
-      for (const node of nodes) {
-        this.graph.deleteNode(node.id)
-      }
-
-      if (nodes.length > 0) {
-        this.logger.debug({ decisionId, nodesRemoved: nodes.length }, 'Decision removed from knowledge graph')
-      }
-    } catch (error) {
-      this.logger.error({ error, decisionId }, 'Failed to remove decision from graph')
-    }
-  }
-
-  processDecision(input: StoreDecisionInput & { id: string }): void {
-    try {
-      // Dedup guard: remove existing node with same decision_id before re-creating
-      this.removeDecision(input.id)
-
-      const fullText = `${input.decision} ${input.context} ${input.reasoning}`
-      const entities = this.entityExtractor.extract(fullText)
-      const relationships = this.relationshipExtractor.extract(fullText, entities)
-
-      // Create decision node
-      const decisionNode = this.graph.addNode({
-        name: input.decision.slice(0, 100),
-        type: 'decision',
-        properties: {
-          decision_id: input.id,
-          project: input.project,
-          context: input.context,
-          reasoning: input.reasoning,
-          full_decision: input.decision
-        }
-      })
-
-      // Create project node if it doesn't exist
-      let projectNode = this.graph.findNodeByName(input.project, 'project')
-      if (!projectNode) {
-        projectNode = this.graph.addNode({
-          name: input.project,
-          type: 'project',
-          properties: {}
-        })
-      }
-
-      // Link decision to project
-      this.graph.addEdge({
-        source: decisionNode.id,
-        target: projectNode.id,
-        relationship: 'decided_in',
-        weight: 1.0,
-        properties: {}
-      })
-
-      // Create entity nodes and link to decision
-      const entityNodeMap = new Map<string, string>() // normalizedName → nodeId
-      for (const entity of entities) {
-        let entityNode = this.graph.findNodeByName(entity.normalizedName, entity.type)
-        if (!entityNode) {
-          entityNode = this.graph.addNode({
-            name: entity.normalizedName,
-            type: entity.type,
-            properties: {
-              confidence: entity.confidence,
-              source: entity.source
-            }
-          })
-        }
-        entityNodeMap.set(entity.normalizedName, entityNode.id)
-
-        // Link decision to entity
-        this.graph.addEdge({
-          source: decisionNode.id,
-          target: entityNode.id,
-          relationship: 'relates_to',
-          weight: entity.confidence,
-          properties: {}
-        })
-      }
-
-      // Create relationship edges between entities
-      for (const rel of relationships) {
-        const sourceId = entityNodeMap.get(rel.sourceEntity)
-        const targetId = entityNodeMap.get(rel.targetEntity)
-
-        if (sourceId && targetId) {
-          this.graph.addEdge({
-            source: sourceId,
-            target: targetId,
-            relationship: rel.relationship,
-            weight: rel.confidence,
-            properties: { evidence: rel.evidence }
-          })
-        }
-      }
-
-      this.logger.debug({
-        decisionId: input.id,
-        entities: entities.length,
-        relationships: relationships.length
-      }, 'Decision processed into knowledge graph')
-    } catch (error) {
-      this.logger.error({ error, decisionId: input.id }, 'Failed to process decision into graph')
-    }
-  }
-
-  async migrateExistingDecisions(collections: CollectionManager): Promise<{ processed: number; errors: number }> {
-    let processed = 0
-    let errors = 0
-
-    try {
-      const collection = await collections.getDecisions()
-      const result = await collection.get({
-        include: ['documents', 'metadatas']
-      })
-
-      for (let i = 0; i < result.ids.length; i++) {
-        try {
-          const id = result.ids[i]!
-          const document = result.documents?.[i] as string
-          const metadata = result.metadatas?.[i] as Record<string, any>
-
-          if (!document || !metadata) continue
-
-          this.processDecision({
-            id,
-            project: metadata.project || 'unknown',
-            context: metadata.context || '',
-            decision: document,
-            reasoning: metadata.reasoning || ''
-          })
-
-          processed++
-        } catch {
-          errors++
-        }
-      }
-
-      this.logger.info({ processed, errors }, 'Migration of existing decisions complete')
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to migrate existing decisions')
-    }
-
-    return { processed, errors }
-  }
-}
+/**
+ * Knowledge Graph Builder
+ * Auto-populates the graph when decisions/patterns/corrections are stored
+ */
+
+import type { Logger } from 'pino'
+import type { InMemoryKnowledgeGraph } from './memory-graph'
+import { EntityExtractor } from '../entity-extractor'
+import { RelationshipExtractor } from '../relationship-extractor'
+import type { StoreDecisionInput } from '../../memory/chroma/store'
+import type { CollectionManager } from '../../memory/chroma/collection-manager'
+
+export class KnowledgeGraphBuilder {
+  private graph: InMemoryKnowledgeGraph
+  private entityExtractor: EntityExtractor
+  private relationshipExtractor: RelationshipExtractor
+  private logger: Logger
+
+  constructor(graph: InMemoryKnowledgeGraph, logger: Logger) {
+    this.graph = graph
+    this.entityExtractor = new EntityExtractor()
+    this.relationshipExtractor = new RelationshipExtractor()
+    this.logger = logger.child({ component: 'graph-builder' })
+  }
+
+  async initialize(): Promise<void> {
+    await this.entityExtractor.initialize()
+  }
+
+  /**
+   * Remove a decision node and its edges from the knowledge graph by decision ID.
+   * Used when a decision is deleted from the store.
+   */
+  removeDecision(decisionId: string): void {
+    try {
+      const nodes = this.graph.findNodes({
+        type: 'decision',
+        properties: { decision_id: decisionId }
+      })
+
+      for (const node of nodes) {
+        this.graph.deleteNode(node.id)
+      }
+
+      if (nodes.length > 0) {
+        this.logger.debug({ decisionId, nodesRemoved: nodes.length }, 'Decision removed from knowledge graph')
+      }
+    } catch (error) {
+      this.logger.error({ error, decisionId }, 'Failed to remove decision from graph')
+    }
+  }
+
+  processDecision(input: StoreDecisionInput & { id: string }): void {
+    try {
+      // Dedup guard: remove existing node with same decision_id before re-creating
+      this.removeDecision(input.id)
+
+      const fullText = `${input.decision} ${input.context} ${input.reasoning}`
+      const entities = this.entityExtractor.extract(fullText)
+      const relationships = this.relationshipExtractor.extract(fullText, entities)
+
+      // Create decision node
+      const decisionNode = this.graph.addNode({
+        name: input.decision.slice(0, 100),
+        type: 'decision',
+        properties: {
+          decision_id: input.id,
+          project: input.project,
+          context: input.context,
+          reasoning: input.reasoning,
+          full_decision: input.decision
+        }
+      })
+
+      // Create project node if it doesn't exist
+      let projectNode = this.graph.findNodeByName(input.project, 'project')
+      if (!projectNode) {
+        projectNode = this.graph.addNode({
+          name: input.project,
+          type: 'project',
+          properties: {}
+        })
+      }
+
+      // Link decision to project
+      this.graph.addEdge({
+        source: decisionNode.id,
+        target: projectNode.id,
+        relationship: 'decided_in',
+        weight: 1.0,
+        properties: {}
+      })
+
+      // Create entity nodes and link to decision
+      const entityNodeMap = new Map<string, string>() // normalizedName → nodeId
+      for (const entity of entities) {
+        let entityNode = this.graph.findNodeByName(entity.normalizedName, entity.type)
+        if (!entityNode) {
+          entityNode = this.graph.addNode({
+            name: entity.normalizedName,
+            type: entity.type,
+            properties: {
+              confidence: entity.confidence,
+              source: entity.source
+            }
+          })
+        }
+        entityNodeMap.set(entity.normalizedName, entityNode.id)
+
+        // Link decision to entity
+        this.graph.addEdge({
+          source: decisionNode.id,
+          target: entityNode.id,
+          relationship: 'relates_to',
+          weight: entity.confidence,
+          properties: {}
+        })
+      }
+
+      // Create relationship edges between entities
+      for (const rel of relationships) {
+        const sourceId = entityNodeMap.get(rel.sourceEntity)
+        const targetId = entityNodeMap.get(rel.targetEntity)
+
+        if (sourceId && targetId) {
+          this.graph.addEdge({
+            source: sourceId,
+            target: targetId,
+            relationship: rel.relationship,
+            weight: rel.confidence,
+            properties: { evidence: rel.evidence }
+          })
+        }
+      }
+
+      this.logger.debug({
+        decisionId: input.id,
+        entities: entities.length,
+        relationships: relationships.length
+      }, 'Decision processed into knowledge graph')
+    } catch (error) {
+      this.logger.error({ error, decisionId: input.id }, 'Failed to process decision into graph')
+    }
+  }
+
+  async migrateExistingDecisions(collections: CollectionManager): Promise<{ processed: number; errors: number }> {
+    let processed = 0
+    let errors = 0
+
+    try {
+      const collection = await collections.getDecisions()
+      const result = await collection.get({
+        include: ['documents', 'metadatas']
+      })
+
+      for (let i = 0; i < result.ids.length; i++) {
+        try {
+          const id = result.ids[i]!
+          const document = result.documents?.[i] as string
+          const metadata = result.metadatas?.[i] as Record<string, any>
+
+          if (!document || !metadata) continue
+
+          this.processDecision({
+            id,
+            project: metadata.project || 'unknown',
+            context: metadata.context || '',
+            decision: document,
+            reasoning: metadata.reasoning || ''
+          })
+
+          processed++
+        } catch {
+          errors++
+        }
+      }
+
+      this.logger.info({ processed, errors }, 'Migration of existing decisions complete')
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to migrate existing decisions')
+    }
+
+    return { processed, errors }
+  }
+}