claude-brain 0.14.2 → 0.14.4

package/src/server/handlers/tools/search-knowledge-graph.ts

@@ -1,102 +1,102 @@
-/**
- * Search Knowledge Graph Handler
- * Searches the knowledge graph for related nodes and edges
- */
-
-import type { Logger } from 'pino'
-import type { ToolResponse } from '@/tools/types'
-import { getKnowledgeGraphService, getMemoryService, isServicesInitialized } from '@/server/services'
-import { ToolValidator } from '@/server/utils/validators'
-import { ResponseFormatter } from '@/server/utils/response-formatter'
-import { ErrorHandler } from '@/server/utils/error-handler'
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
-import { SearchKnowledgeGraphSchema } from './schemas'
-
-export async function handleSearchKnowledgeGraph(
-  args: unknown,
-  logger: Logger
-): Promise<ToolResponse> {
-  try {
-    const input = ToolValidator.validate(args, SearchKnowledgeGraphSchema)
-    const { query, node_type, start_node_id, hops, limit } = input
-
-    logger.debug({ query, nodeType: node_type, hops, limit }, 'Searching knowledge graph')
-
-    if (!isServicesInitialized()) {
-      throw new McpError(
-        ErrorCode.InternalError,
-        'Services not initialized. The server may still be starting up.'
-      )
-    }
-
-    const kgService = getKnowledgeGraphService()
-    if (!kgService) {
-      return ResponseFormatter.text(
-        'Knowledge graph is not enabled. Enable it by setting knowledge.graph.enabled=true in config.'
-      )
-    }
-
-    const result = kgService.search.search({
-      query,
-      nodeType: node_type as any,
-      startNodeId: start_node_id,
-      hops,
-      limit
-    })
-
-    const formattedNodes = result.nodes.map(n => ({
-      id: n.id,
-      name: n.name,
-      type: n.type,
-      properties: n.properties,
-      score: result.scores.get(n.id) || 0
-    }))
-
-    const formattedEdges = result.edges.map(e => ({
-      source: e.source,
-      target: e.target,
-      relationship: e.relationship,
-      weight: e.weight
-    }))
-
-    const response = {
-      nodes: formattedNodes,
-      edges: formattedEdges,
-      paths: result.paths,
-      total_nodes: result.nodes.length,
-      total_edges: result.edges.length
-    }
-
-    logger.info({
-      nodeCount: result.nodes.length,
-      edgeCount: result.edges.length
-    }, 'Knowledge graph search complete')
-
-    // If graph is empty and ChromaDB is not connected, add guidance
-    if (result.nodes.length === 0 && result.edges.length === 0) {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) {
-        return ResponseFormatter.text(
-          'Knowledge graph is empty (0 nodes, 0 edges).\n\n' +
-          'Note: ChromaDB is not connected. The knowledge graph is populated from stored decisions. ' +
-          'New decisions stored via SQLite will populate the graph going forward. ' +
-          'To migrate existing decisions into the graph, start a ChromaDB server or configure persistent mode.'
-        )
-      }
-    }
-
-    return ResponseFormatter.json(response, 'Knowledge Graph Search Results')
-
-  } catch (error) {
-    ErrorHandler.logError(logger, error, { tool: 'search_knowledge_graph', args })
-
-    if (error instanceof McpError) {
-      throw error
-    }
-
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Failed to search knowledge graph: ${error instanceof Error ? error.message : 'Unknown error'}`
-    )
-  }
-}
+/**
+ * Search Knowledge Graph Handler
+ * Searches the knowledge graph for related nodes and edges
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { getKnowledgeGraphService, getMemoryService, isServicesInitialized } from '@/server/services'
+import { ToolValidator } from '@/server/utils/validators'
+import { ResponseFormatter } from '@/server/utils/response-formatter'
+import { ErrorHandler } from '@/server/utils/error-handler'
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { SearchKnowledgeGraphSchema } from './schemas'
+
+export async function handleSearchKnowledgeGraph(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = ToolValidator.validate(args, SearchKnowledgeGraphSchema)
+    const { query, node_type, start_node_id, hops, limit } = input
+
+    logger.debug({ query, nodeType: node_type, hops, limit }, 'Searching knowledge graph')
+
+    if (!isServicesInitialized()) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        'Services not initialized. The server may still be starting up.'
+      )
+    }
+
+    const kgService = getKnowledgeGraphService()
+    if (!kgService) {
+      return ResponseFormatter.text(
+        'Knowledge graph is not enabled. Enable it by setting knowledge.graph.enabled=true in config.'
+      )
+    }
+
+    const result = kgService.search.search({
+      query,
+      nodeType: node_type as any,
+      startNodeId: start_node_id,
+      hops,
+      limit
+    })
+
+    const formattedNodes = result.nodes.map(n => ({
+      id: n.id,
+      name: n.name,
+      type: n.type,
+      properties: n.properties,
+      score: result.scores.get(n.id) || 0
+    }))
+
+    const formattedEdges = result.edges.map(e => ({
+      source: e.source,
+      target: e.target,
+      relationship: e.relationship,
+      weight: e.weight
+    }))
+
+    const response = {
+      nodes: formattedNodes,
+      edges: formattedEdges,
+      paths: result.paths,
+      total_nodes: result.nodes.length,
+      total_edges: result.edges.length
+    }
+
+    logger.info({
+      nodeCount: result.nodes.length,
+      edgeCount: result.edges.length
+    }, 'Knowledge graph search complete')
+
+    // If graph is empty and ChromaDB is not connected, add guidance
+    if (result.nodes.length === 0 && result.edges.length === 0) {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) {
+        return ResponseFormatter.text(
+          'Knowledge graph is empty (0 nodes, 0 edges).\n\n' +
+          'Note: ChromaDB is not connected. The knowledge graph is populated from stored decisions. ' +
+          'New decisions stored via SQLite will populate the graph going forward. ' +
+          'To migrate existing decisions into the graph, start a ChromaDB server or configure persistent mode.'
+        )
+      }
+    }
+
+    return ResponseFormatter.json(response, 'Knowledge Graph Search Results')
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'search_knowledge_graph', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Failed to search knowledge graph: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}

package/src/server/handlers/tools/smart-context.ts

@@ -1,146 +1,146 @@
-/**
- * Smart Context Handler
- * Gets project context + proactive memory recall based on current task
- */
-
-import type { Logger } from 'pino'
-import type { ToolResponse } from '@/tools/types'
-import { getContextService, getPhase12Service, getMemoryService, isServicesInitialized } from '@/server/services'
-import { ToolValidator } from '@/server/utils/validators'
-import { ResponseFormatter } from '@/server/utils/response-formatter'
-import { withMemoryIndicator, formatMemoryStats } from '@/server/utils/memory-indicator'
-import { ErrorHandler } from '@/server/utils/error-handler'
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
-import { SmartContextSchema } from './schemas'
-
-export async function handleSmartContext(
-  args: unknown,
-  logger: Logger
-): Promise<ToolResponse> {
-  try {
-    const input = ToolValidator.validate(args, SmartContextSchema)
-    const { project_name, current_task, min_similarity } = input
-
-    logger.debug({
-      project_name,
-      current_task: current_task.slice(0, 50),
-      min_similarity
-    }, 'Smart context request')
-
-    if (!isServicesInitialized()) {
-      throw new McpError(
-        ErrorCode.InternalError,
-        'Services not initialized'
-      )
-    }
-
-    const contextService = getContextService()
-    const phase12 = getPhase12Service()
-
-    // Set current project in Phase 12 (use project name directly since we're getting it from user)
-    // The autoContext will be updated when context is loaded below
-
-    // Get base project context
-    const context = await contextService.getContext(project_name, {
-      includeMemories: false, // We'll use Phase 12 for smarter recall
-      includeProgress: true,
-      includeStandards: true,
-      maxTokens: 6000,
-      relevanceThreshold: 0.5
-    })
-
-    // Process with Phase 12 for proactive recall
-    const phase12Result = await phase12.processMessage(current_task, project_name)
-
-    // If Phase12's gated recall found nothing, do direct search (like recall_similar)
-    if (!phase12Result.recalledMemories || phase12Result.recalledMemories.memories.length === 0) {
-      try {
-        const memory = getMemoryService()
-        const directRecall = await memory.searchRaw(current_task, {
-          project: project_name,
-          limit: 5,
-          minSimilarity: min_similarity || 0.3
-        })
-        if (directRecall.length > 0) {
-          phase12Result.recalledMemories = {
-            query: current_task,
-            memories: directRecall,
-            relevanceScore: directRecall.reduce((sum: number, m: any) => sum + (m.similarity || 0), 0) / directRecall.length,
-            triggeredBy: ['direct-search-fallback']
-          }
-        }
-      } catch (e) {
-        logger.debug({ error: e }, 'Direct recall fallback failed, continuing without')
-      }
-    }
-
-    // Format base context
-    const formattedContext = contextService.formatter.format(context)
-
-    // Build response
-    const parts: string[] = []
-    parts.push(formattedContext)
-    parts.push('\n---\n')
-    parts.push('## 🧠 Intelligent Context (Phase 12)\n')
-
-    // Add proactive recall results
-    if (phase12Result.recalledMemories && phase12Result.recalledMemories.memories.length > 0) {
-      parts.push('### Relevant Past Decisions\n')
-      parts.push(`*Automatically recalled for: "${current_task.slice(0, 50)}${current_task.length > 50 ? '...' : ''}"*\n`)
-
-      for (const memory of phase12Result.recalledMemories.memories) {
-        const similarity = Math.round(memory.similarity * 100)
-        parts.push(`\n**[${similarity}% match]** ${memory.decision?.decision || memory.content.slice(0, 100)}`)
-        if (memory.decision?.reasoning) {
-          parts.push(`\n- *Reasoning:* ${memory.decision.reasoning}`)
-        }
-        if (memory.decision?.context) {
-          parts.push(`\n- *Context:* ${memory.decision.context}`)
-        }
-      }
-      parts.push('\n')
-    } else {
-      parts.push('*No relevant past decisions found for this task.*\n')
-      parts.push('*Tip: As you make decisions, use `remember_decision` or `auto_remember` to build up your knowledge base.*\n')
-    }
-
-    // Add extracted knowledge if any
-    if (phase12Result.extractedKnowledge && phase12Result.extractedKnowledge.length > 0) {
-      parts.push('\n### Extracted Knowledge\n')
-      for (const k of phase12Result.extractedKnowledge) {
-        parts.push(`- **${k.type}:** ${k.content.slice(0, 100)}`)
-      }
-    }
-
-    const recalledCount = phase12Result.recalledMemories?.memories.length || 0
-    const knowledgeCount = phase12Result.extractedKnowledge?.length || 0
-
-    logger.info({
-      project_name,
-      recalledCount,
-      knowledgeCount
-    }, 'Smart context retrieved')
-
-    const content = parts.join('\n')
-
-    // Add memory indicator if we found helpful memories
-    if (recalledCount > 0) {
-      const statsLine = formatMemoryStats({ recalled: recalledCount })
-      return ResponseFormatter.text(withMemoryIndicator(content, recalledCount) + '\n\n' + statsLine)
-    }
-
-    return ResponseFormatter.text(content)
-
-  } catch (error) {
-    ErrorHandler.logError(logger, error, { tool: 'smart_context', args })
-
-    if (error instanceof McpError) {
-      throw error
-    }
-
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Smart context failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-    )
-  }
-}
+/**
+ * Smart Context Handler
+ * Gets project context + proactive memory recall based on current task
+ */
+
+import type { Logger } from 'pino'
+import type { ToolResponse } from '@/tools/types'
+import { getContextService, getPhase12Service, getMemoryService, isServicesInitialized } from '@/server/services'
+import { ToolValidator } from '@/server/utils/validators'
+import { ResponseFormatter } from '@/server/utils/response-formatter'
+import { withMemoryIndicator, formatMemoryStats } from '@/server/utils/memory-indicator'
+import { ErrorHandler } from '@/server/utils/error-handler'
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'
+import { SmartContextSchema } from './schemas'
+
+export async function handleSmartContext(
+  args: unknown,
+  logger: Logger
+): Promise<ToolResponse> {
+  try {
+    const input = ToolValidator.validate(args, SmartContextSchema)
+    const { project_name, current_task, min_similarity } = input
+
+    logger.debug({
+      project_name,
+      current_task: current_task.slice(0, 50),
+      min_similarity
+    }, 'Smart context request')
+
+    if (!isServicesInitialized()) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        'Services not initialized'
+      )
+    }
+
+    const contextService = getContextService()
+    const phase12 = getPhase12Service()
+
+    // Set current project in Phase 12 (use project name directly since we're getting it from user)
+    // The autoContext will be updated when context is loaded below
+
+    // Get base project context
+    const context = await contextService.getContext(project_name, {
+      includeMemories: false, // We'll use Phase 12 for smarter recall
+      includeProgress: true,
+      includeStandards: true,
+      maxTokens: 6000,
+      relevanceThreshold: 0.5
+    })
+
+    // Process with Phase 12 for proactive recall
+    const phase12Result = await phase12.processMessage(current_task, project_name)
+
+    // If Phase12's gated recall found nothing, do direct search (like recall_similar)
+    if (!phase12Result.recalledMemories || phase12Result.recalledMemories.memories.length === 0) {
+      try {
+        const memory = getMemoryService()
+        const directRecall = await memory.searchRaw(current_task, {
+          project: project_name,
+          limit: 5,
+          minSimilarity: min_similarity || 0.3
+        })
+        if (directRecall.length > 0) {
+          phase12Result.recalledMemories = {
+            query: current_task,
+            memories: directRecall,
+            relevanceScore: directRecall.reduce((sum: number, m: any) => sum + (m.similarity || 0), 0) / directRecall.length,
+            triggeredBy: ['direct-search-fallback']
+          }
+        }
+      } catch (e) {
+        logger.debug({ error: e }, 'Direct recall fallback failed, continuing without')
+      }
+    }
+
+    // Format base context
+    const formattedContext = contextService.formatter.format(context)
+
+    // Build response
+    const parts: string[] = []
+    parts.push(formattedContext)
+    parts.push('\n---\n')
+    parts.push('## 🧠 Intelligent Context (Phase 12)\n')
+
+    // Add proactive recall results
+    if (phase12Result.recalledMemories && phase12Result.recalledMemories.memories.length > 0) {
+      parts.push('### Relevant Past Decisions\n')
+      parts.push(`*Automatically recalled for: "${current_task.slice(0, 50)}${current_task.length > 50 ? '...' : ''}"*\n`)
+
+      for (const memory of phase12Result.recalledMemories.memories) {
+        const similarity = Math.round(memory.similarity * 100)
+        parts.push(`\n**[${similarity}% match]** ${memory.decision?.decision || memory.content.slice(0, 100)}`)
+        if (memory.decision?.reasoning) {
+          parts.push(`\n- *Reasoning:* ${memory.decision.reasoning}`)
+        }
+        if (memory.decision?.context) {
+          parts.push(`\n- *Context:* ${memory.decision.context}`)
+        }
+      }
+      parts.push('\n')
+    } else {
+      parts.push('*No relevant past decisions found for this task.*\n')
+      parts.push('*Tip: As you make decisions, use `remember_decision` or `auto_remember` to build up your knowledge base.*\n')
+    }
+
+    // Add extracted knowledge if any
+    if (phase12Result.extractedKnowledge && phase12Result.extractedKnowledge.length > 0) {
+      parts.push('\n### Extracted Knowledge\n')
+      for (const k of phase12Result.extractedKnowledge) {
+        parts.push(`- **${k.type}:** ${k.content.slice(0, 100)}`)
+      }
+    }
+
+    const recalledCount = phase12Result.recalledMemories?.memories.length || 0
+    const knowledgeCount = phase12Result.extractedKnowledge?.length || 0
+
+    logger.info({
+      project_name,
+      recalledCount,
+      knowledgeCount
+    }, 'Smart context retrieved')
+
+    const content = parts.join('\n')
+
+    // Add memory indicator if we found helpful memories
+    if (recalledCount > 0) {
+      const statsLine = formatMemoryStats({ recalled: recalledCount })
+      return ResponseFormatter.text(withMemoryIndicator(content, recalledCount) + '\n\n' + statsLine)
+    }
+
+    return ResponseFormatter.text(content)
+
+  } catch (error) {
+    ErrorHandler.logError(logger, error, { tool: 'smart_context', args })
+
+    if (error instanceof McpError) {
+      throw error
+    }
+
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Smart context failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+    )
+  }
+}