claude-brain 0.30.2 → 0.30.3

package/src/knowledge/graph/memory-graph.ts

@@ -1,359 +1,359 @@
-/**
- * In-Memory Knowledge Graph
- * Graph data structure with traversal, persistence, and search
- */
-
-import { randomUUID } from 'crypto'
-import { readFile, writeFile, mkdir } from 'fs/promises'
-import { dirname } from 'path'
-import type {
-  GraphNode,
-  GraphEdge,
-  KnowledgeGraph,
-  TraversalOptions,
-  EntityType,
-  SerializedGraph
-} from './schema'
-import type { Logger } from 'pino'
-
-export class InMemoryKnowledgeGraph implements KnowledgeGraph {
-  private nodes: Map<string, GraphNode> = new Map()
-  private edges: Map<string, GraphEdge> = new Map()
-  private outgoing: Map<string, Set<string>> = new Map()
-  private incoming: Map<string, Set<string>> = new Map()
-  private logger: Logger
-  private autoSaveTimer: ReturnType<typeof setInterval> | null = null
-  private dirty = false
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'knowledge-graph' })
-  }
-
-  addNode(input: Omit<GraphNode, 'id' | 'created_at' | 'updated_at'>): GraphNode {
-    const now = new Date().toISOString()
-    const node: GraphNode = {
-      ...input,
-      id: randomUUID(),
-      created_at: now,
-      updated_at: now
-    }
-    this.nodes.set(node.id, node)
-    this.outgoing.set(node.id, new Set())
-    this.incoming.set(node.id, new Set())
-    this.dirty = true
-    return node
-  }
-
-  getNode(id: string): GraphNode | undefined {
-    return this.nodes.get(id)
-  }
-
-  updateNode(id: string, updates: Partial<Omit<GraphNode, 'id' | 'created_at'>>): GraphNode | undefined {
-    const node = this.nodes.get(id)
-    if (!node) return undefined
-
-    const updated: GraphNode = {
-      ...node,
-      ...updates,
-      id: node.id,
-      created_at: node.created_at,
-      updated_at: new Date().toISOString()
-    }
-    this.nodes.set(id, updated)
-    this.dirty = true
-    return updated
-  }
-
-  deleteNode(id: string): boolean {
-    if (!this.nodes.has(id)) return false
-
-    // Delete all connected edges
-    const outEdges = this.outgoing.get(id) || new Set()
-    const inEdges = this.incoming.get(id) || new Set()
-
-    for (const edgeId of outEdges) {
-      const edge = this.edges.get(edgeId)
-      if (edge) {
-        this.incoming.get(edge.target)?.delete(edgeId)
-        this.edges.delete(edgeId)
-      }
-    }
-
-    for (const edgeId of inEdges) {
-      const edge = this.edges.get(edgeId)
-      if (edge) {
-        this.outgoing.get(edge.source)?.delete(edgeId)
-        this.edges.delete(edgeId)
-      }
-    }
-
-    this.outgoing.delete(id)
-    this.incoming.delete(id)
-    this.nodes.delete(id)
-    this.dirty = true
-    return true
-  }
-
-  addEdge(input: Omit<GraphEdge, 'id' | 'created_at'>): GraphEdge {
-    if (!this.nodes.has(input.source) || !this.nodes.has(input.target)) {
-      throw new Error(`Both source (${input.source}) and target (${input.target}) must exist`)
-    }
-
-    const edge: GraphEdge = {
-      ...input,
-      id: randomUUID(),
-      created_at: new Date().toISOString()
-    }
-
-    this.edges.set(edge.id, edge)
-
-    if (!this.outgoing.has(input.source)) this.outgoing.set(input.source, new Set())
-    if (!this.incoming.has(input.target)) this.incoming.set(input.target, new Set())
-
-    this.outgoing.get(input.source)!.add(edge.id)
-    this.incoming.get(input.target)!.add(edge.id)
-    this.dirty = true
-    return edge
-  }
-
-  getEdges(nodeId: string, direction: 'outgoing' | 'incoming' | 'both' = 'both'): GraphEdge[] {
-    const result: GraphEdge[] = []
-
-    if (direction === 'outgoing' || direction === 'both') {
-      const outEdgeIds = this.outgoing.get(nodeId) || new Set()
-      for (const edgeId of outEdgeIds) {
-        const edge = this.edges.get(edgeId)
-        if (edge) result.push(edge)
-      }
-    }
-
-    if (direction === 'incoming' || direction === 'both') {
-      const inEdgeIds = this.incoming.get(nodeId) || new Set()
-      for (const edgeId of inEdgeIds) {
-        const edge = this.edges.get(edgeId)
-        if (edge) result.push(edge)
-      }
-    }
-
-    return result
-  }
-
-  deleteEdge(id: string): boolean {
-    const edge = this.edges.get(id)
-    if (!edge) return false
-
-    this.outgoing.get(edge.source)?.delete(id)
-    this.incoming.get(edge.target)?.delete(id)
-    this.edges.delete(id)
-    this.dirty = true
-    return true
-  }
-
-  traverse(startId: string, options: TraversalOptions = {}): GraphNode[] {
-    const { maxDepth = 3, nodeTypes, relationshipTypes, limit = 100 } = options
-
-    if (!this.nodes.has(startId)) return []
-
-    const visited = new Set<string>()
-    const result: GraphNode[] = []
-    const queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }]
-
-    while (queue.length > 0 && result.length < limit) {
-      const { id, depth } = queue.shift()!
-
-      if (visited.has(id)) continue
-      visited.add(id)
-
-      const node = this.nodes.get(id)
-      if (!node) continue
-
-      if (nodeTypes && !nodeTypes.includes(node.type)) {
-        // Don't add to results but still traverse through
-      } else {
-        result.push(node)
-      }
-
-      if (depth >= maxDepth) continue
-
-      // Get neighbors via edges
-      const edges = this.getEdges(id)
-      for (const edge of edges) {
-        if (relationshipTypes && !relationshipTypes.includes(edge.relationship)) continue
-
-        const neighborId = edge.source === id ? edge.target : edge.source
-        if (!visited.has(neighborId)) {
-          queue.push({ id: neighborId, depth: depth + 1 })
-        }
-      }
-    }
-
-    return result
-  }
-
-  shortestPath(sourceId: string, targetId: string): string[] | null {
-    if (!this.nodes.has(sourceId) || !this.nodes.has(targetId)) return null
-    if (sourceId === targetId) return [sourceId]
-
-    const visited = new Set<string>()
-    const parent = new Map<string, string>()
-    const queue: string[] = [sourceId]
-    visited.add(sourceId)
-
-    while (queue.length > 0) {
-      const current = queue.shift()!
-
-      const edges = this.getEdges(current)
-      for (const edge of edges) {
-        const neighbor = edge.source === current ? edge.target : edge.source
-
-        if (!visited.has(neighbor)) {
-          visited.add(neighbor)
-          parent.set(neighbor, current)
-
-          if (neighbor === targetId) {
-            // Reconstruct path
-            const path: string[] = [targetId]
-            let node = targetId
-            while (parent.has(node)) {
-              node = parent.get(node)!
-              path.unshift(node)
-            }
-            return path
-          }
-
-          queue.push(neighbor)
-        }
-      }
-    }
-
-    return null
-  }
-
-  findNodes(query: { type?: EntityType; name?: string; properties?: Record<string, unknown> }): GraphNode[] {
-    const results: GraphNode[] = []
-
-    for (const node of this.nodes.values()) {
-      if (query.type && node.type !== query.type) continue
-      if (query.name && !node.name.toLowerCase().includes(query.name.toLowerCase())) continue
-
-      if (query.properties) {
-        let match = true
-        for (const [key, value] of Object.entries(query.properties)) {
-          if (node.properties[key] !== value) {
-            match = false
-            break
-          }
-        }
-        if (!match) continue
-      }
-
-      results.push(node)
-    }
-
-    return results
-  }
-
-  findNodeByName(name: string, type?: EntityType): GraphNode | undefined {
-    const lowerName = name.toLowerCase()
-    for (const node of this.nodes.values()) {
-      if (node.name.toLowerCase() === lowerName) {
-        if (type && node.type !== type) continue
-        return node
-      }
-    }
-    return undefined
-  }
-
-  getNodeCount(): number {
-    return this.nodes.size
-  }
-
-  getEdgeCount(): number {
-    return this.edges.size
-  }
-
-  async save(path: string): Promise<void> {
-    const data: SerializedGraph = {
-      nodes: Array.from(this.nodes.values()),
-      edges: Array.from(this.edges.values()),
-      version: '1.0.0',
-      saved_at: new Date().toISOString()
-    }
-
-    try {
-      await mkdir(dirname(path), { recursive: true })
-      await writeFile(path, JSON.stringify(data, null, 2), 'utf-8')
-      this.dirty = false
-      this.logger.debug({ path, nodes: data.nodes.length, edges: data.edges.length }, 'Graph saved')
-    } catch (error) {
-      this.logger.error({ error, path }, 'Failed to save graph')
-      throw error
-    }
-  }
-
-  async load(path: string): Promise<void> {
-    try {
-      const content = await readFile(path, 'utf-8')
-      const data: SerializedGraph = JSON.parse(content)
-
-      this.nodes.clear()
-      this.edges.clear()
-      this.outgoing.clear()
-      this.incoming.clear()
-
-      for (const node of data.nodes) {
-        this.nodes.set(node.id, node)
-        this.outgoing.set(node.id, new Set())
-        this.incoming.set(node.id, new Set())
-      }
-
-      for (const edge of data.edges) {
-        this.edges.set(edge.id, edge)
-        this.outgoing.get(edge.source)?.add(edge.id)
-        this.incoming.get(edge.target)?.add(edge.id)
-      }
-
-      this.dirty = false
-      this.logger.info({ path, nodes: data.nodes.length, edges: data.edges.length }, 'Graph loaded')
-    } catch (error: any) {
-      if (error.code === 'ENOENT') {
-        this.logger.info({ path }, 'No existing graph file, starting fresh')
-        return
-      }
-      this.logger.error({ error, path }, 'Failed to load graph')
-      throw error
-    }
-  }
-
-  startAutoSave(path: string, intervalMs: number = 60000): void {
-    this.stopAutoSave()
-    this.autoSaveTimer = setInterval(async () => {
-      if (this.dirty) {
-        try {
-          await this.save(path)
-        } catch (error) {
-          this.logger.error({ error }, 'Auto-save failed')
-        }
-      }
-    }, intervalMs)
-  }
-
-  stopAutoSave(): void {
-    if (this.autoSaveTimer) {
-      clearInterval(this.autoSaveTimer)
-      this.autoSaveTimer = null
-    }
-  }
-
-  isDirty(): boolean {
-    return this.dirty
-  }
-
-  clear(): void {
-    this.nodes.clear()
-    this.edges.clear()
-    this.outgoing.clear()
-    this.incoming.clear()
-    this.dirty = true
-  }
-}
+/**
+ * In-Memory Knowledge Graph
+ * Graph data structure with traversal, persistence, and search
+ */
+
+import { randomUUID } from 'crypto'
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { dirname } from 'path'
+import type {
+  GraphNode,
+  GraphEdge,
+  KnowledgeGraph,
+  TraversalOptions,
+  EntityType,
+  SerializedGraph
+} from './schema'
+import type { Logger } from 'pino'
+
+export class InMemoryKnowledgeGraph implements KnowledgeGraph {
+  private nodes: Map<string, GraphNode> = new Map()
+  private edges: Map<string, GraphEdge> = new Map()
+  private outgoing: Map<string, Set<string>> = new Map()
+  private incoming: Map<string, Set<string>> = new Map()
+  private logger: Logger
+  private autoSaveTimer: ReturnType<typeof setInterval> | null = null
+  private dirty = false
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'knowledge-graph' })
+  }
+
+  addNode(input: Omit<GraphNode, 'id' | 'created_at' | 'updated_at'>): GraphNode {
+    const now = new Date().toISOString()
+    const node: GraphNode = {
+      ...input,
+      id: randomUUID(),
+      created_at: now,
+      updated_at: now
+    }
+    this.nodes.set(node.id, node)
+    this.outgoing.set(node.id, new Set())
+    this.incoming.set(node.id, new Set())
+    this.dirty = true
+    return node
+  }
+
+  getNode(id: string): GraphNode | undefined {
+    return this.nodes.get(id)
+  }
+
+  updateNode(id: string, updates: Partial<Omit<GraphNode, 'id' | 'created_at'>>): GraphNode | undefined {
+    const node = this.nodes.get(id)
+    if (!node) return undefined
+
+    const updated: GraphNode = {
+      ...node,
+      ...updates,
+      id: node.id,
+      created_at: node.created_at,
+      updated_at: new Date().toISOString()
+    }
+    this.nodes.set(id, updated)
+    this.dirty = true
+    return updated
+  }
+
+  deleteNode(id: string): boolean {
+    if (!this.nodes.has(id)) return false
+
+    // Delete all connected edges
+    const outEdges = this.outgoing.get(id) || new Set()
+    const inEdges = this.incoming.get(id) || new Set()
+
+    for (const edgeId of outEdges) {
+      const edge = this.edges.get(edgeId)
+      if (edge) {
+        this.incoming.get(edge.target)?.delete(edgeId)
+        this.edges.delete(edgeId)
+      }
+    }
+
+    for (const edgeId of inEdges) {
+      const edge = this.edges.get(edgeId)
+      if (edge) {
+        this.outgoing.get(edge.source)?.delete(edgeId)
+        this.edges.delete(edgeId)
+      }
+    }
+
+    this.outgoing.delete(id)
+    this.incoming.delete(id)
+    this.nodes.delete(id)
+    this.dirty = true
+    return true
+  }
+
+  addEdge(input: Omit<GraphEdge, 'id' | 'created_at'>): GraphEdge {
+    if (!this.nodes.has(input.source) || !this.nodes.has(input.target)) {
+      throw new Error(`Both source (${input.source}) and target (${input.target}) must exist`)
+    }
+
+    const edge: GraphEdge = {
+      ...input,
+      id: randomUUID(),
+      created_at: new Date().toISOString()
+    }
+
+    this.edges.set(edge.id, edge)
+
+    if (!this.outgoing.has(input.source)) this.outgoing.set(input.source, new Set())
+    if (!this.incoming.has(input.target)) this.incoming.set(input.target, new Set())
+
+    this.outgoing.get(input.source)!.add(edge.id)
+    this.incoming.get(input.target)!.add(edge.id)
+    this.dirty = true
+    return edge
+  }
+
+  getEdges(nodeId: string, direction: 'outgoing' | 'incoming' | 'both' = 'both'): GraphEdge[] {
+    const result: GraphEdge[] = []
+
+    if (direction === 'outgoing' || direction === 'both') {
+      const outEdgeIds = this.outgoing.get(nodeId) || new Set()
+      for (const edgeId of outEdgeIds) {
+        const edge = this.edges.get(edgeId)
+        if (edge) result.push(edge)
+      }
+    }
+
+    if (direction === 'incoming' || direction === 'both') {
+      const inEdgeIds = this.incoming.get(nodeId) || new Set()
+      for (const edgeId of inEdgeIds) {
+        const edge = this.edges.get(edgeId)
+        if (edge) result.push(edge)
+      }
+    }
+
+    return result
+  }
+
+  deleteEdge(id: string): boolean {
+    const edge = this.edges.get(id)
+    if (!edge) return false
+
+    this.outgoing.get(edge.source)?.delete(id)
+    this.incoming.get(edge.target)?.delete(id)
+    this.edges.delete(id)
+    this.dirty = true
+    return true
+  }
+
+  traverse(startId: string, options: TraversalOptions = {}): GraphNode[] {
+    const { maxDepth = 3, nodeTypes, relationshipTypes, limit = 100 } = options
+
+    if (!this.nodes.has(startId)) return []
+
+    const visited = new Set<string>()
+    const result: GraphNode[] = []
+    const queue: Array<{ id: string; depth: number }> = [{ id: startId, depth: 0 }]
+
+    while (queue.length > 0 && result.length < limit) {
+      const { id, depth } = queue.shift()!
+
+      if (visited.has(id)) continue
+      visited.add(id)
+
+      const node = this.nodes.get(id)
+      if (!node) continue
+
+      if (nodeTypes && !nodeTypes.includes(node.type)) {
+        // Don't add to results but still traverse through
+      } else {
+        result.push(node)
+      }
+
+      if (depth >= maxDepth) continue
+
+      // Get neighbors via edges
+      const edges = this.getEdges(id)
+      for (const edge of edges) {
+        if (relationshipTypes && !relationshipTypes.includes(edge.relationship)) continue
+
+        const neighborId = edge.source === id ? edge.target : edge.source
+        if (!visited.has(neighborId)) {
+          queue.push({ id: neighborId, depth: depth + 1 })
+        }
+      }
+    }
+
+    return result
+  }
+
+  shortestPath(sourceId: string, targetId: string): string[] | null {
+    if (!this.nodes.has(sourceId) || !this.nodes.has(targetId)) return null
+    if (sourceId === targetId) return [sourceId]
+
+    const visited = new Set<string>()
+    const parent = new Map<string, string>()
+    const queue: string[] = [sourceId]
+    visited.add(sourceId)
+
+    while (queue.length > 0) {
+      const current = queue.shift()!
+
+      const edges = this.getEdges(current)
+      for (const edge of edges) {
+        const neighbor = edge.source === current ? edge.target : edge.source
+
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor)
+          parent.set(neighbor, current)
+
+          if (neighbor === targetId) {
+            // Reconstruct path
+            const path: string[] = [targetId]
+            let node = targetId
+            while (parent.has(node)) {
+              node = parent.get(node)!
+              path.unshift(node)
+            }
+            return path
+          }
+
+          queue.push(neighbor)
+        }
+      }
+    }
+
+    return null
+  }
+
+  findNodes(query: { type?: EntityType; name?: string; properties?: Record<string, unknown> }): GraphNode[] {
+    const results: GraphNode[] = []
+
+    for (const node of this.nodes.values()) {
+      if (query.type && node.type !== query.type) continue
+      if (query.name && !node.name.toLowerCase().includes(query.name.toLowerCase())) continue
+
+      if (query.properties) {
+        let match = true
+        for (const [key, value] of Object.entries(query.properties)) {
+          if (node.properties[key] !== value) {
+            match = false
+            break
+          }
+        }
+        if (!match) continue
+      }
+
+      results.push(node)
+    }
+
+    return results
+  }
+
+  findNodeByName(name: string, type?: EntityType): GraphNode | undefined {
+    const lowerName = name.toLowerCase()
+    for (const node of this.nodes.values()) {
+      if (node.name.toLowerCase() === lowerName) {
+        if (type && node.type !== type) continue
+        return node
+      }
+    }
+    return undefined
+  }
+
+  getNodeCount(): number {
+    return this.nodes.size
+  }
+
+  getEdgeCount(): number {
+    return this.edges.size
+  }
+
+  async save(path: string): Promise<void> {
+    const data: SerializedGraph = {
+      nodes: Array.from(this.nodes.values()),
+      edges: Array.from(this.edges.values()),
+      version: '1.0.0',
+      saved_at: new Date().toISOString()
+    }
+
+    try {
+      await mkdir(dirname(path), { recursive: true })
+      await writeFile(path, JSON.stringify(data, null, 2), 'utf-8')
+      this.dirty = false
+      this.logger.debug({ path, nodes: data.nodes.length, edges: data.edges.length }, 'Graph saved')
+    } catch (error) {
+      this.logger.error({ error, path }, 'Failed to save graph')
+      throw error
+    }
+  }
+
+  async load(path: string): Promise<void> {
+    try {
+      const content = await readFile(path, 'utf-8')
+      const data: SerializedGraph = JSON.parse(content)
+
+      this.nodes.clear()
+      this.edges.clear()
+      this.outgoing.clear()
+      this.incoming.clear()
+
+      for (const node of data.nodes) {
+        this.nodes.set(node.id, node)
+        this.outgoing.set(node.id, new Set())
+        this.incoming.set(node.id, new Set())
+      }
+
+      for (const edge of data.edges) {
+        this.edges.set(edge.id, edge)
+        this.outgoing.get(edge.source)?.add(edge.id)
+        this.incoming.get(edge.target)?.add(edge.id)
+      }
+
+      this.dirty = false
+      this.logger.info({ path, nodes: data.nodes.length, edges: data.edges.length }, 'Graph loaded')
+    } catch (error: unknown) {
+      if ((error as Record<string, unknown>)?.code === 'ENOENT') {
+        this.logger.info({ path }, 'No existing graph file, starting fresh')
+        return
+      }
+      this.logger.error({ error, path }, 'Failed to load graph')
+      throw error
+    }
+  }
+
+  startAutoSave(path: string, intervalMs: number = 60000): void {
+    this.stopAutoSave()
+    this.autoSaveTimer = setInterval(async () => {
+      if (this.dirty) {
+        try {
+          await this.save(path)
+        } catch (error) {
+          this.logger.error({ error }, 'Auto-save failed')
+        }
+      }
+    }, intervalMs)
+  }
+
+  stopAutoSave(): void {
+    if (this.autoSaveTimer) {
+      clearInterval(this.autoSaveTimer)
+      this.autoSaveTimer = null
+    }
+  }
+
+  isDirty(): boolean {
+    return this.dirty
+  }
+
+  clear(): void {
+    this.nodes.clear()
+    this.edges.clear()
+    this.outgoing.clear()
+    this.incoming.clear()
+    this.dirty = true
+  }
+}