claude-brain 0.30.2 → 0.30.3

package/src/knowledge/graph/linker.ts

@@ -1,201 +1,201 @@
-/**
- * Cross-Reference Linker
- * Finds implicit links, contradictions, and decision chains
- */
-
-import type { Logger } from 'pino'
-import type { InMemoryKnowledgeGraph } from './memory-graph'
-import type { GraphNode } from './schema'
-
-export interface ImplicitLink {
-  sourceId: string
-  targetId: string
-  sourceName: string
-  targetName: string
-  reason: string
-  confidence: number
-}
-
-export interface Contradiction {
-  decisionA: GraphNode
-  decisionB: GraphNode
-  reason: string
-  confidence: number
-}
-
-export interface DecisionChain {
-  topic: string
-  decisions: GraphNode[]
-}
-
-export class CrossReferenceLinker {
-  private graph: InMemoryKnowledgeGraph
-  private logger: Logger
-
-  constructor(graph: InMemoryKnowledgeGraph, logger: Logger) {
-    this.graph = graph
-    this.logger = logger.child({ component: 'cross-reference-linker' })
-  }
-
-  findImplicitLinks(): ImplicitLink[] {
-    const links: ImplicitLink[] = []
-    const decisionNodes = this.graph.findNodes({ type: 'decision' })
-
-    for (let i = 0; i < decisionNodes.length; i++) {
-      for (let j = i + 1; j < decisionNodes.length; j++) {
-        const nodeA = decisionNodes[i]!
-        const nodeB = decisionNodes[j]!
-
-        // Check if they share entities (connected via common neighbor)
-        const sharedEntities = this.findSharedEntities(nodeA.id, nodeB.id)
-
-        if (sharedEntities.length >= 2) {
-          // Already directly connected?
-          const existingEdges = this.graph.getEdges(nodeA.id, 'outgoing')
-          const alreadyLinked = existingEdges.some(e => e.target === nodeB.id && e.relationship === 'similar_to')
-
-          if (!alreadyLinked) {
-            links.push({
-              sourceId: nodeA.id,
-              targetId: nodeB.id,
-              sourceName: nodeA.name,
-              targetName: nodeB.name,
-              reason: `Share ${sharedEntities.length} entities: ${sharedEntities.slice(0, 3).join(', ')}`,
-              confidence: Math.min(0.9, 0.5 + sharedEntities.length * 0.1)
-            })
-          }
-        }
-      }
-    }
-
-    this.logger.debug({ linkCount: links.length }, 'Found implicit links')
-    return links
-  }
-
-  findContradictions(): Contradiction[] {
-    const contradictions: Contradiction[] = []
-    const decisionNodes = this.graph.findNodes({ type: 'decision' })
-
-    const contradictionKeywords = ['not', 'avoid', 'don\'t', 'never', 'instead', 'rather than', 'rejected']
-    const approvalKeywords = ['chose', 'use', 'adopt', 'selected', 'prefer', 'recommend']
-
-    for (let i = 0; i < decisionNodes.length; i++) {
-      for (let j = i + 1; j < decisionNodes.length; j++) {
-        const nodeA = decisionNodes[i]!
-        const nodeB = decisionNodes[j]!
-
-        // Check if same project
-        const projectA = nodeA.properties.project as string
-        const projectB = nodeB.properties.project as string
-        if (projectA !== projectB) continue
-
-        // Check if they share entities but with opposing sentiment
-        const sharedEntities = this.findSharedEntities(nodeA.id, nodeB.id)
-        if (sharedEntities.length === 0) continue
-
-        const textA = (nodeA.properties.full_decision as string || nodeA.name).toLowerCase()
-        const textB = (nodeB.properties.full_decision as string || nodeB.name).toLowerCase()
-
-        // Check for opposing sentiment
-        const aNegative = contradictionKeywords.some(k => textA.includes(k))
-        const bNegative = contradictionKeywords.some(k => textB.includes(k))
-        const aPositive = approvalKeywords.some(k => textA.includes(k))
-        const bPositive = approvalKeywords.some(k => textB.includes(k))
-
-        if ((aNegative && bPositive) || (aPositive && bNegative)) {
-          contradictions.push({
-            decisionA: nodeA!,
-            decisionB: nodeB!,
-            reason: `Opposing sentiment about shared entities: ${sharedEntities.join(', ')}`,
-            confidence: 0.7
-          })
-        }
-      }
-    }
-
-    this.logger.debug({ count: contradictions.length }, 'Found potential contradictions')
-    return contradictions
-  }
-
-  findDecisionChains(): DecisionChain[] {
-    const chains: DecisionChain[] = []
-    const decisionNodes = this.graph.findNodes({ type: 'decision' })
-
-    // Group by shared topics (entity neighbors)
-    const topicGroups = new Map<string, GraphNode[]>()
-
-    for (const decision of decisionNodes) {
-      const edges = this.graph.getEdges(decision.id, 'outgoing')
-      for (const edge of edges) {
-        if (edge.relationship === 'relates_to') {
-          const target = this.graph.getNode(edge.target)
-          if (target && target.type === 'technology') {
-            const topic = target.name
-            if (!topicGroups.has(topic)) {
-              topicGroups.set(topic, [])
-            }
-            topicGroups.get(topic)!.push(decision)
-          }
-        }
-      }
-    }
-
-    // Create chains from groups with 2+ decisions
-    for (const [topic, decisions] of topicGroups) {
-      if (decisions.length >= 2) {
-        // Sort by creation time
-        const sorted = [...decisions].sort((a, b) =>
-          a.created_at.localeCompare(b.created_at)
-        )
-        chains.push({ topic, decisions: sorted })
-      }
-    }
-
-    this.logger.debug({ chainCount: chains.length }, 'Found decision chains')
-    return chains
-  }
-
-  applyImplicitLinks(links: ImplicitLink[]): number {
-    let applied = 0
-    for (const link of links) {
-      try {
-        this.graph.addEdge({
-          source: link.sourceId,
-          target: link.targetId,
-          relationship: 'similar_to',
-          weight: link.confidence,
-          properties: { reason: link.reason, auto_linked: true }
-        })
-        applied++
-      } catch {
-        // May fail if nodes were deleted
-      }
-    }
-    return applied
-  }
-
-  private findSharedEntities(nodeAId: string, nodeBId: string): string[] {
-    const edgesA = this.graph.getEdges(nodeAId, 'outgoing')
-    const edgesB = this.graph.getEdges(nodeBId, 'outgoing')
-
-    const neighborsA = new Set<string>()
-    for (const edge of edgesA) {
-      if (edge.relationship === 'relates_to') {
-        const target = this.graph.getNode(edge.target)
-        if (target) neighborsA.add(target.name)
-      }
-    }
-
-    const shared: string[] = []
-    for (const edge of edgesB) {
-      if (edge.relationship === 'relates_to') {
-        const target = this.graph.getNode(edge.target)
-        if (target && neighborsA.has(target.name)) {
-          shared.push(target.name)
-        }
-      }
-    }
-
-    return shared
-  }
-}
+/**
+ * Cross-Reference Linker
+ * Finds implicit links, contradictions, and decision chains
+ */
+
+import type { Logger } from 'pino'
+import type { InMemoryKnowledgeGraph } from './memory-graph'
+import type { GraphNode } from './schema'
+
+export interface ImplicitLink {
+  sourceId: string
+  targetId: string
+  sourceName: string
+  targetName: string
+  reason: string
+  confidence: number
+}
+
+export interface Contradiction {
+  decisionA: GraphNode
+  decisionB: GraphNode
+  reason: string
+  confidence: number
+}
+
+export interface DecisionChain {
+  topic: string
+  decisions: GraphNode[]
+}
+
+export class CrossReferenceLinker {
+  private graph: InMemoryKnowledgeGraph
+  private logger: Logger
+
+  constructor(graph: InMemoryKnowledgeGraph, logger: Logger) {
+    this.graph = graph
+    this.logger = logger.child({ component: 'cross-reference-linker' })
+  }
+
+  findImplicitLinks(): ImplicitLink[] {
+    const links: ImplicitLink[] = []
+    const decisionNodes = this.graph.findNodes({ type: 'decision' })
+
+    for (let i = 0; i < decisionNodes.length; i++) {
+      for (let j = i + 1; j < decisionNodes.length; j++) {
+        const nodeA = decisionNodes[i]!
+        const nodeB = decisionNodes[j]!
+
+        // Check if they share entities (connected via common neighbor)
+        const sharedEntities = this.findSharedEntities(nodeA.id, nodeB.id)
+
+        if (sharedEntities.length >= 2) {
+          // Already directly connected?
+          const existingEdges = this.graph.getEdges(nodeA.id, 'outgoing')
+          const alreadyLinked = existingEdges.some(e => e.target === nodeB.id && e.relationship === 'similar_to')
+
+          if (!alreadyLinked) {
+            links.push({
+              sourceId: nodeA.id,
+              targetId: nodeB.id,
+              sourceName: nodeA.name,
+              targetName: nodeB.name,
+              reason: `Share ${sharedEntities.length} entities: ${sharedEntities.slice(0, 3).join(', ')}`,
+              confidence: Math.min(0.9, 0.5 + sharedEntities.length * 0.1)
+            })
+          }
+        }
+      }
+    }
+
+    this.logger.debug({ linkCount: links.length }, 'Found implicit links')
+    return links
+  }
+
+  findContradictions(): Contradiction[] {
+    const contradictions: Contradiction[] = []
+    const decisionNodes = this.graph.findNodes({ type: 'decision' })
+
+    const contradictionKeywords = ['not', 'avoid', 'don\'t', 'never', 'instead', 'rather than', 'rejected']
+    const approvalKeywords = ['chose', 'use', 'adopt', 'selected', 'prefer', 'recommend']
+
+    for (let i = 0; i < decisionNodes.length; i++) {
+      for (let j = i + 1; j < decisionNodes.length; j++) {
+        const nodeA = decisionNodes[i]!
+        const nodeB = decisionNodes[j]!
+
+        // Check if same project
+        const projectA = nodeA.properties.project as string
+        const projectB = nodeB.properties.project as string
+        if (projectA !== projectB) continue
+
+        // Check if they share entities but with opposing sentiment
+        const sharedEntities = this.findSharedEntities(nodeA.id, nodeB.id)
+        if (sharedEntities.length === 0) continue
+
+        const textA = (nodeA.properties.full_decision as string || nodeA.name).toLowerCase()
+        const textB = (nodeB.properties.full_decision as string || nodeB.name).toLowerCase()
+
+        // Check for opposing sentiment
+        const aNegative = contradictionKeywords.some(k => textA.includes(k))
+        const bNegative = contradictionKeywords.some(k => textB.includes(k))
+        const aPositive = approvalKeywords.some(k => textA.includes(k))
+        const bPositive = approvalKeywords.some(k => textB.includes(k))
+
+        if ((aNegative && bPositive) || (aPositive && bNegative)) {
+          contradictions.push({
+            decisionA: nodeA!,
+            decisionB: nodeB!,
+            reason: `Opposing sentiment about shared entities: ${sharedEntities.join(', ')}`,
+            confidence: 0.7
+          })
+        }
+      }
+    }
+
+    this.logger.debug({ count: contradictions.length }, 'Found potential contradictions')
+    return contradictions
+  }
+
+  findDecisionChains(): DecisionChain[] {
+    const chains: DecisionChain[] = []
+    const decisionNodes = this.graph.findNodes({ type: 'decision' })
+
+    // Group by shared topics (entity neighbors)
+    const topicGroups = new Map<string, GraphNode[]>()
+
+    for (const decision of decisionNodes) {
+      const edges = this.graph.getEdges(decision.id, 'outgoing')
+      for (const edge of edges) {
+        if (edge.relationship === 'relates_to') {
+          const target = this.graph.getNode(edge.target)
+          if (target && target.type === 'technology') {
+            const topic = target.name
+            if (!topicGroups.has(topic)) {
+              topicGroups.set(topic, [])
+            }
+            topicGroups.get(topic)!.push(decision)
+          }
+        }
+      }
+    }
+
+    // Create chains from groups with 2+ decisions
+    for (const [topic, decisions] of topicGroups) {
+      if (decisions.length >= 2) {
+        // Sort by creation time
+        const sorted = [...decisions].sort((a, b) =>
+          a.created_at.localeCompare(b.created_at)
+        )
+        chains.push({ topic, decisions: sorted })
+      }
+    }
+
+    this.logger.debug({ chainCount: chains.length }, 'Found decision chains')
+    return chains
+  }
+
+  applyImplicitLinks(links: ImplicitLink[]): number {
+    let applied = 0
+    for (const link of links) {
+      try {
+        this.graph.addEdge({
+          source: link.sourceId,
+          target: link.targetId,
+          relationship: 'similar_to',
+          weight: link.confidence,
+          properties: { reason: link.reason, auto_linked: true }
+        })
+        applied++
+      } catch {
+        // May fail if nodes were deleted
+      }
+    }
+    return applied
+  }
+
+  private findSharedEntities(nodeAId: string, nodeBId: string): string[] {
+    const edgesA = this.graph.getEdges(nodeAId, 'outgoing')
+    const edgesB = this.graph.getEdges(nodeBId, 'outgoing')
+
+    const neighborsA = new Set<string>()
+    for (const edge of edgesA) {
+      if (edge.relationship === 'relates_to') {
+        const target = this.graph.getNode(edge.target)
+        if (target) neighborsA.add(target.name)
+      }
+    }
+
+    const shared: string[] = []
+    for (const edge of edgesB) {
+      if (edge.relationship === 'relates_to') {
+        const target = this.graph.getNode(edge.target)
+        if (target && neighborsA.has(target.name)) {
+          shared.push(target.name)
+        }
+      }
+    }
+
+    return shared
+  }
+}