claude-brain 0.14.2 → 0.14.4

package/src/knowledge/graph/schema.ts

@@ -1,99 +1,99 @@
-/**
- * Knowledge Graph Schema
- * Type definitions for the knowledge graph data structures
- */
-
-export type EntityType =
-  | 'project'
-  | 'technology'
-  | 'concept'
-  | 'person'
-  | 'file'
-  | 'decision'
-  | 'pattern'
-  | 'correction'
-  | 'date'
-
-export type RelationshipType =
-  | 'uses'
-  | 'depends_on'
-  | 'replaces'
-  | 'contradicts'
-  | 'relates_to'
-  | 'part_of'
-  | 'created_by'
-  | 'decided_in'
-  | 'similar_to'
-  | 'precedes'
-  | 'follows'
-
-export interface GraphNode {
-  id: string
-  name: string
-  type: EntityType
-  properties: Record<string, unknown>
-  created_at: string
-  updated_at: string
-}
-
-export interface GraphEdge {
-  id: string
-  source: string
-  target: string
-  relationship: RelationshipType
-  weight: number
-  properties: Record<string, unknown>
-  created_at: string
-}
-
-export interface TraversalOptions {
-  maxDepth?: number
-  nodeTypes?: EntityType[]
-  relationshipTypes?: RelationshipType[]
-  limit?: number
-}
-
-export interface GraphSearchOptions {
-  query?: string
-  nodeType?: EntityType
-  relationshipType?: RelationshipType
-  startNodeId?: string
-  hops?: number
-  limit?: number
-  alpha?: number
-}
-
-export interface GraphSearchResult {
-  nodes: GraphNode[]
-  edges: GraphEdge[]
-  paths: string[][]
-  scores: Map<string, number>
-}
-
-export interface KnowledgeGraph {
-  addNode(node: Omit<GraphNode, 'id' | 'created_at' | 'updated_at'>): GraphNode
-  getNode(id: string): GraphNode | undefined
-  updateNode(id: string, updates: Partial<Omit<GraphNode, 'id' | 'created_at'>>): GraphNode | undefined
-  deleteNode(id: string): boolean
-
-  addEdge(edge: Omit<GraphEdge, 'id' | 'created_at'>): GraphEdge
-  getEdges(nodeId: string, direction?: 'outgoing' | 'incoming' | 'both'): GraphEdge[]
-  deleteEdge(id: string): boolean
-
-  traverse(startId: string, options?: TraversalOptions): GraphNode[]
-  shortestPath(sourceId: string, targetId: string): string[] | null
-  findNodes(query: { type?: EntityType; name?: string; properties?: Record<string, unknown> }): GraphNode[]
-
-  getNodeCount(): number
-  getEdgeCount(): number
-
-  save(path: string): Promise<void>
-  load(path: string): Promise<void>
-}
-
-export interface SerializedGraph {
-  nodes: GraphNode[]
-  edges: GraphEdge[]
-  version: string
-  saved_at: string
-}
+/**
+ * Knowledge Graph Schema
+ * Type definitions for the knowledge graph data structures
+ */
+
+export type EntityType =
+  | 'project'
+  | 'technology'
+  | 'concept'
+  | 'person'
+  | 'file'
+  | 'decision'
+  | 'pattern'
+  | 'correction'
+  | 'date'
+
+export type RelationshipType =
+  | 'uses'
+  | 'depends_on'
+  | 'replaces'
+  | 'contradicts'
+  | 'relates_to'
+  | 'part_of'
+  | 'created_by'
+  | 'decided_in'
+  | 'similar_to'
+  | 'precedes'
+  | 'follows'
+
+export interface GraphNode {
+  id: string
+  name: string
+  type: EntityType
+  properties: Record<string, unknown>
+  created_at: string
+  updated_at: string
+}
+
+export interface GraphEdge {
+  id: string
+  source: string
+  target: string
+  relationship: RelationshipType
+  weight: number
+  properties: Record<string, unknown>
+  created_at: string
+}
+
+export interface TraversalOptions {
+  maxDepth?: number
+  nodeTypes?: EntityType[]
+  relationshipTypes?: RelationshipType[]
+  limit?: number
+}
+
+export interface GraphSearchOptions {
+  query?: string
+  nodeType?: EntityType
+  relationshipType?: RelationshipType
+  startNodeId?: string
+  hops?: number
+  limit?: number
+  alpha?: number
+}
+
+export interface GraphSearchResult {
+  nodes: GraphNode[]
+  edges: GraphEdge[]
+  paths: string[][]
+  scores: Map<string, number>
+}
+
+export interface KnowledgeGraph {
+  addNode(node: Omit<GraphNode, 'id' | 'created_at' | 'updated_at'>): GraphNode
+  getNode(id: string): GraphNode | undefined
+  updateNode(id: string, updates: Partial<Omit<GraphNode, 'id' | 'created_at'>>): GraphNode | undefined
+  deleteNode(id: string): boolean
+
+  addEdge(edge: Omit<GraphEdge, 'id' | 'created_at'>): GraphEdge
+  getEdges(nodeId: string, direction?: 'outgoing' | 'incoming' | 'both'): GraphEdge[]
+  deleteEdge(id: string): boolean
+
+  traverse(startId: string, options?: TraversalOptions): GraphNode[]
+  shortestPath(sourceId: string, targetId: string): string[] | null
+  findNodes(query: { type?: EntityType; name?: string; properties?: Record<string, unknown> }): GraphNode[]
+
+  getNodeCount(): number
+  getEdgeCount(): number
+
+  save(path: string): Promise<void>
+  load(path: string): Promise<void>
+}
+
+export interface SerializedGraph {
+  nodes: GraphNode[]
+  edges: GraphEdge[]
+  version: string
+  saved_at: string
+}

package/src/knowledge/graph/search.ts

@@ -1,168 +1,168 @@
-/**
- * Graph Search Engine
- * Combines vector similarity with graph proximity for enhanced search
- */
-
-import type { Logger } from 'pino'
-import type { InMemoryKnowledgeGraph } from './memory-graph'
-import type { GraphNode, GraphEdge, GraphSearchOptions, GraphSearchResult } from './schema'
-
-export class GraphSearchEngine {
-  private graph: InMemoryKnowledgeGraph
-  private logger: Logger
-
-  constructor(graph: InMemoryKnowledgeGraph, logger: Logger) {
-    this.graph = graph
-    this.logger = logger.child({ component: 'graph-search' })
-  }
-
-  search(options: GraphSearchOptions): GraphSearchResult {
-    const {
-      query,
-      nodeType,
-      startNodeId,
-      hops = 2,
-      limit = 20,
-      alpha = 0.6
-    } = options
-
-    const scores = new Map<string, number>()
-    const resultNodes: GraphNode[] = []
-    const resultEdges: GraphEdge[] = []
-    const paths: string[][] = []
-
-    if (startNodeId) {
-      // Graph expansion from a starting node
-      return this.expandFromNode(startNodeId, hops, limit, nodeType)
-    }
-
-    if (query) {
-      // Text-based search: find nodes matching query, then expand
-      const matchingNodes = this.findMatchingNodes(query, nodeType)
-
-      for (const node of matchingNodes) {
-        const nameScore = this.calculateNameScore(node.name, query)
-        scores.set(node.id, nameScore)
-
-        // Expand from each matching node
-        const neighbors = this.graph.traverse(node.id, {
-          maxDepth: hops,
-          nodeTypes: nodeType ? [nodeType] : undefined,
-          limit: Math.ceil(limit / Math.max(matchingNodes.length, 1))
-        })
-
-        for (const neighbor of neighbors) {
-          if (!scores.has(neighbor.id)) {
-            // Graph proximity score: decreases with distance
-            const path = this.graph.shortestPath(node.id, neighbor.id)
-            const distance = path ? path.length - 1 : hops + 1
-            const graphScore = 1 / (1 + distance)
-
-            // Combined score
-            const combinedScore = alpha * nameScore + (1 - alpha) * graphScore
-            scores.set(neighbor.id, Math.max(scores.get(neighbor.id) || 0, combinedScore))
-
-            if (path && path.length > 1) {
-              paths.push(path)
-            }
-          }
-        }
-      }
-
-      // Collect nodes sorted by score
-      const sortedEntries = Array.from(scores.entries())
-        .sort(([, a], [, b]) => b - a)
-        .slice(0, limit)
-
-      for (const [nodeId] of sortedEntries) {
-        const node = this.graph.getNode(nodeId)
-        if (node) resultNodes.push(node)
-      }
-
-      // Collect edges between result nodes
-      const resultNodeIds = new Set(resultNodes.map(n => n.id))
-      for (const node of resultNodes) {
-        const edges = this.graph.getEdges(node.id)
-        for (const edge of edges) {
-          if (resultNodeIds.has(edge.source) && resultNodeIds.has(edge.target)) {
-            if (!resultEdges.some(e => e.id === edge.id)) {
-              resultEdges.push(edge)
-            }
-          }
-        }
-      }
-    }
-
-    return { nodes: resultNodes, edges: resultEdges, paths, scores }
-  }
-
-  findRelated(nodeId: string, hops: number = 2): GraphSearchResult {
-    return this.expandFromNode(nodeId, hops, 50)
-  }
-
-  private expandFromNode(
-    nodeId: string,
-    hops: number,
-    limit: number,
-    nodeType?: string
-  ): GraphSearchResult {
-    const scores = new Map<string, number>()
-    const nodes = this.graph.traverse(nodeId, {
-      maxDepth: hops,
-      nodeTypes: nodeType ? [nodeType as any] : undefined,
-      limit
-    })
-
-    const resultEdges: GraphEdge[] = []
-    const paths: string[][] = []
-    const nodeIds = new Set(nodes.map(n => n.id))
-
-    for (const node of nodes) {
-      const path = this.graph.shortestPath(nodeId, node.id)
-      const distance = path ? path.length - 1 : 0
-      scores.set(node.id, 1 / (1 + distance))
-
-      if (path && path.length > 1) {
-        paths.push(path)
-      }
-
-      const edges = this.graph.getEdges(node.id)
-      for (const edge of edges) {
-        if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
-          if (!resultEdges.some(e => e.id === edge.id)) {
-            resultEdges.push(edge)
-          }
-        }
-      }
-    }
-
-    return { nodes, edges: resultEdges, paths, scores }
-  }
-
-  private findMatchingNodes(query: string, nodeType?: string): GraphNode[] {
-    const lowerQuery = query.toLowerCase()
-    const queryTerms = lowerQuery.split(/\s+/).filter(t => t.length > 1)
-
-    return this.graph.findNodes({
-      type: nodeType as any,
-      name: undefined
-    }).filter(node => {
-      const lowerName = node.name.toLowerCase()
-      return queryTerms.some(term => lowerName.includes(term) || term.includes(lowerName))
-    })
-  }
-
-  private calculateNameScore(nodeName: string, query: string): number {
-    const lowerName = nodeName.toLowerCase()
-    const lowerQuery = query.toLowerCase()
-
-    if (lowerName === lowerQuery) return 1.0
-    if (lowerQuery.includes(lowerName)) return 0.9
-    if (lowerName.includes(lowerQuery)) return 0.8
-
-    // Partial term matching
-    const queryTerms = lowerQuery.split(/\s+/)
-    const matchCount = queryTerms.filter(t => lowerName.includes(t)).length
-    return matchCount > 0 ? 0.5 + (0.3 * matchCount / queryTerms.length) : 0.3
-  }
-}
+/**
+ * Graph Search Engine
+ * Combines vector similarity with graph proximity for enhanced search
+ */
+
+import type { Logger } from 'pino'
+import type { InMemoryKnowledgeGraph } from './memory-graph'
+import type { GraphNode, GraphEdge, GraphSearchOptions, GraphSearchResult } from './schema'
+
+export class GraphSearchEngine {
+  private graph: InMemoryKnowledgeGraph
+  private logger: Logger
+
+  constructor(graph: InMemoryKnowledgeGraph, logger: Logger) {
+    this.graph = graph
+    this.logger = logger.child({ component: 'graph-search' })
+  }
+
+  search(options: GraphSearchOptions): GraphSearchResult {
+    const {
+      query,
+      nodeType,
+      startNodeId,
+      hops = 2,
+      limit = 20,
+      alpha = 0.6
+    } = options
+
+    const scores = new Map<string, number>()
+    const resultNodes: GraphNode[] = []
+    const resultEdges: GraphEdge[] = []
+    const paths: string[][] = []
+
+    if (startNodeId) {
+      // Graph expansion from a starting node
+      return this.expandFromNode(startNodeId, hops, limit, nodeType)
+    }
+
+    if (query) {
+      // Text-based search: find nodes matching query, then expand
+      const matchingNodes = this.findMatchingNodes(query, nodeType)
+
+      for (const node of matchingNodes) {
+        const nameScore = this.calculateNameScore(node.name, query)
+        scores.set(node.id, nameScore)
+
+        // Expand from each matching node
+        const neighbors = this.graph.traverse(node.id, {
+          maxDepth: hops,
+          nodeTypes: nodeType ? [nodeType] : undefined,
+          limit: Math.ceil(limit / Math.max(matchingNodes.length, 1))
+        })
+
+        for (const neighbor of neighbors) {
+          if (!scores.has(neighbor.id)) {
+            // Graph proximity score: decreases with distance
+            const path = this.graph.shortestPath(node.id, neighbor.id)
+            const distance = path ? path.length - 1 : hops + 1
+            const graphScore = 1 / (1 + distance)
+
+            // Combined score
+            const combinedScore = alpha * nameScore + (1 - alpha) * graphScore
+            scores.set(neighbor.id, Math.max(scores.get(neighbor.id) || 0, combinedScore))
+
+            if (path && path.length > 1) {
+              paths.push(path)
+            }
+          }
+        }
+      }
+
+      // Collect nodes sorted by score
+      const sortedEntries = Array.from(scores.entries())
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, limit)
+
+      for (const [nodeId] of sortedEntries) {
+        const node = this.graph.getNode(nodeId)
+        if (node) resultNodes.push(node)
+      }
+
+      // Collect edges between result nodes
+      const resultNodeIds = new Set(resultNodes.map(n => n.id))
+      for (const node of resultNodes) {
+        const edges = this.graph.getEdges(node.id)
+        for (const edge of edges) {
+          if (resultNodeIds.has(edge.source) && resultNodeIds.has(edge.target)) {
+            if (!resultEdges.some(e => e.id === edge.id)) {
+              resultEdges.push(edge)
+            }
+          }
+        }
+      }
+    }
+
+    return { nodes: resultNodes, edges: resultEdges, paths, scores }
+  }
+
+  findRelated(nodeId: string, hops: number = 2): GraphSearchResult {
+    return this.expandFromNode(nodeId, hops, 50)
+  }
+
+  private expandFromNode(
+    nodeId: string,
+    hops: number,
+    limit: number,
+    nodeType?: string
+  ): GraphSearchResult {
+    const scores = new Map<string, number>()
+    const nodes = this.graph.traverse(nodeId, {
+      maxDepth: hops,
+      nodeTypes: nodeType ? [nodeType as any] : undefined,
+      limit
+    })
+
+    const resultEdges: GraphEdge[] = []
+    const paths: string[][] = []
+    const nodeIds = new Set(nodes.map(n => n.id))
+
+    for (const node of nodes) {
+      const path = this.graph.shortestPath(nodeId, node.id)
+      const distance = path ? path.length - 1 : 0
+      scores.set(node.id, 1 / (1 + distance))
+
+      if (path && path.length > 1) {
+        paths.push(path)
+      }
+
+      const edges = this.graph.getEdges(node.id)
+      for (const edge of edges) {
+        if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
+          if (!resultEdges.some(e => e.id === edge.id)) {
+            resultEdges.push(edge)
+          }
+        }
+      }
+    }
+
+    return { nodes, edges: resultEdges, paths, scores }
+  }
+
+  private findMatchingNodes(query: string, nodeType?: string): GraphNode[] {
+    const lowerQuery = query.toLowerCase()
+    const queryTerms = lowerQuery.split(/\s+/).filter(t => t.length > 1)
+
+    return this.graph.findNodes({
+      type: nodeType as any,
+      name: undefined
+    }).filter(node => {
+      const lowerName = node.name.toLowerCase()
+      return queryTerms.some(term => lowerName.includes(term) || term.includes(lowerName))
+    })
+  }
+
+  private calculateNameScore(nodeName: string, query: string): number {
+    const lowerName = nodeName.toLowerCase()
+    const lowerQuery = query.toLowerCase()
+
+    if (lowerName === lowerQuery) return 1.0
+    if (lowerQuery.includes(lowerName)) return 0.9
+    if (lowerName.includes(lowerQuery)) return 0.8
+
+    // Partial term matching
+    const queryTerms = lowerQuery.split(/\s+/)
+    const matchCount = queryTerms.filter(t => lowerName.includes(t)).length
+    return matchCount > 0 ? 0.5 + (0.3 * matchCount / queryTerms.length) : 0.3
+  }
+}