claude-brain 0.3.0

package/src/server/mcp-server.ts

@@ -0,0 +1,283 @@
+/**
+ * Claude Brain MCP Server
+ * Main MCP server implementation using the Model Context Protocol SDK
+ * Phase 6.5: Enhanced with system prompts and resources
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from '@modelcontextprotocol/sdk/types.js'
+import type { Logger } from 'pino'
+import type { Config } from '@/config'
+import type { ConnectionState, ServerStatus, ServerOptions, ServerEvents } from './types'
+import { PromptProvider } from './providers/prompts'
+import { ResourceProvider } from './providers/resources'
+
+export class ClaudeBrainMCPServer {
+  private server: Server
+  private logger: Logger
+  private config: Config
+  private isRunning: boolean = false
+  private connectionState: ConnectionState = 'disconnected'
+  private startedAt?: Date
+  private requestCount: number = 0
+  private events: ServerEvents
+
+  // Phase 6.5: Prompt and Resource providers
+  private promptProvider: PromptProvider
+  private resourceProvider: ResourceProvider
+
+  constructor(config: Config, logger: Logger, options: ServerOptions = {}) {
+    this.config = config
+    this.logger = logger.child({ component: 'mcp-server' })
+    this.events = options.events || {}
+
+    // Phase 6.5: Initialize providers
+    this.promptProvider = new PromptProvider(logger)
+    this.resourceProvider = new ResourceProvider(logger)
+
+    // Initialize MCP Server with metadata and enhanced capabilities
+    this.server = new Server(
+      {
+        name: config.serverName,
+        version: config.serverVersion
+      },
+      {
+        capabilities: {
+          tools: {},
+          prompts: {},    // Phase 6.5: Enable prompts
+          resources: {}   // Phase 6.5: Enable resources
+        }
+      }
+    )
+
+    // Setup request handlers
+    this.setupHandlers()
+
+    // Setup error handling
+    this.setupErrorHandling()
+
+    this.logger.debug('MCP server instance created with Phase 6.5 enhancements')
+  }
+
+  /**
+   * Setup MCP request handlers for tools, prompts, and resources
+   */
+  private setupHandlers(): void {
+    // Handle tools/list request
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      this.logger.debug('Handling tools/list request')
+
+      // Import dynamically to avoid circular dependencies
+      const { handleListTools } = await import('./handlers/list-tools')
+      return await handleListTools()
+    })
+
+    // Handle tools/call request
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const toolName = request.params.name
+      const args = request.params.arguments || {}
+
+      this.requestCount++
+      const requestId = `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`
+
+      this.logger.debug({
+        tool: toolName,
+        args,
+        requestId
+      }, 'Handling tools/call request')
+
+      // Emit request event
+      this.events.onRequest?.(toolName, requestId)
+
+      const startTime = Date.now()
+
+      try {
+        // Import dynamically to avoid circular dependencies
+        const { handleCallTool } = await import('./handlers/call-tool')
+        const result = await handleCallTool(toolName, args, this.logger)
+
+        const duration = Date.now() - startTime
+        this.logger.debug({
+          tool: toolName,
+          requestId,
+          durationMs: duration
+        }, 'Tool call completed')
+
+        // Emit response event
+        this.events.onResponse?.(toolName, requestId, duration)
+
+        return result
+      } catch (error) {
+        const duration = Date.now() - startTime
+        this.logger.error({
+          tool: toolName,
+          requestId,
+          durationMs: duration,
+          error: error instanceof Error ? error.message : String(error)
+        }, 'Tool call failed')
+
+        throw error
+      }
+    })
+
+    // Phase 6.5: Handle prompts/list request
+    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
+      this.logger.debug('Handling prompts/list request')
+      return await this.promptProvider.listPrompts()
+    })
+
+    // Phase 6.5: Handle prompts/get request
+    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      this.logger.debug({ name: request.params.name }, 'Handling prompts/get request')
+      return await this.promptProvider.getPrompt(request.params.name)
+    })
+
+    // Phase 6.5: Handle resources/list request
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      this.logger.debug('Handling resources/list request')
+      return await this.resourceProvider.listResources()
+    })
+
+    // Phase 6.5: Handle resources/read request
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      this.logger.debug({ uri: request.params.uri }, 'Handling resources/read request')
+      return await this.resourceProvider.readResource(request.params.uri)
+    })
+
+    this.logger.debug('Request handlers configured (tools, prompts, resources)')
+  }
+
+  /**
+   * Setup error handling for the server
+   */
+  private setupErrorHandling(): void {
+    this.server.onerror = (error) => {
+      this.logger.error({
+        error: error instanceof Error ? {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        } : error
+      }, 'MCP server error')
+
+      this.events.onError?.(error instanceof Error ? error : new Error(String(error)))
+    }
+  }
+
+  /**
+   * Update connection state and emit events
+   */
+  private setConnectionState(state: ConnectionState): void {
+    const previousState = this.connectionState
+    this.connectionState = state
+
+    if (previousState !== state) {
+      this.logger.info({
+        previousState,
+        newState: state
+      }, 'Connection state changed')
+
+      this.events.onConnectionStateChange?.(state)
+    }
+  }
+
+  /**
+   * Start the MCP server and connect via stdio transport
+   */
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      this.logger.warn('Server already running')
+      return
+    }
+
+    try {
+      this.logger.info('Starting MCP server...')
+      this.setConnectionState('connecting')
+
+      const transport = new StdioServerTransport()
+      await this.server.connect(transport)
+
+      this.isRunning = true
+      this.startedAt = new Date()
+      this.setConnectionState('connected')
+
+      this.logger.info({
+        name: this.config.serverName,
+        version: this.config.serverVersion,
+        startedAt: this.startedAt.toISOString()
+      }, 'MCP server started successfully')
+
+    } catch (error) {
+      this.setConnectionState('disconnected')
+      this.logger.error({
+        error: error instanceof Error ? {
+          message: error.message,
+          stack: error.stack
+        } : error
+      }, 'Failed to start MCP server')
+      throw error
+    }
+  }
+
+  /**
+   * Stop the MCP server gracefully
+   */
+  async stop(): Promise<void> {
+    if (!this.isRunning) {
+      this.logger.debug('Server not running, skip stop')
+      return
+    }
+
+    try {
+      this.logger.info('Stopping MCP server...')
+      await this.server.close()
+
+      this.isRunning = false
+      this.setConnectionState('disconnected')
+
+      this.logger.info({
+        totalRequests: this.requestCount,
+        uptimeMs: this.startedAt ? Date.now() - this.startedAt.getTime() : 0
+      }, 'MCP server stopped')
+
+    } catch (error) {
+      this.logger.error({
+        error: error instanceof Error ? {
+          message: error.message,
+          stack: error.stack
+        } : error
+      }, 'Error stopping MCP server')
+      throw error
+    }
+  }
+
+  /**
+   * Get current server status
+   */
+  getStatus(): ServerStatus {
+    return {
+      running: this.isRunning,
+      name: this.config.serverName,
+      version: this.config.serverVersion,
+      connectionState: this.connectionState,
+      startedAt: this.startedAt,
+      requestCount: this.requestCount,
+      capabilities: ['tools', 'prompts', 'resources']
+    }
+  }
+
+  /**
+   * Health check method
+   */
+  isHealthy(): boolean {
+    return this.isRunning && this.connectionState === 'connected'
+  }
+}

package/src/server/providers/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Server Providers Exports
+ * Phase 6.5: System prompts and resources
+ */
+
+export { PromptProvider } from './prompts'
+export { ResourceProvider } from './resources'

package/src/server/providers/prompts.ts

@@ -0,0 +1,327 @@
+/**
+ * Prompt Provider
+ * Phase 6.5: System prompts for proactive Claude behavior
+ */
+
+import type { Logger } from 'pino'
+import path from 'path'
+import { getVaultService, getContextService, isServicesInitialized } from '@/server/services'
+import { isPhase12Available, getPhase12Instance } from '@/utils/phase12-helper'
+
+interface DetectedProject {
+  name: string
+  path: string
+  confidence: number
+  indicators: string[]
+}
+
+export class PromptProvider {
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'prompt-provider' })
+  }
+
+  /**
+   * Get all available prompts
+   */
+  async listPrompts() {
+    return {
+      prompts: [
+        {
+          name: 'claude-brain-behavior',
+          description: 'Instructions for using Claude Brain proactively',
+          arguments: []
+        },
+        {
+          name: 'current-project-context',
+          description: 'Auto-detected project context summary',
+          arguments: []
+        }
+      ]
+    }
+  }
+
+  /**
+   * Get specific prompt content
+   */
+  async getPrompt(name: string) {
+    switch (name) {
+      case 'claude-brain-behavior':
+        return await this.getBehaviorPrompt()
+      case 'current-project-context':
+        return await this.getProjectContextPrompt()
+      default:
+        throw new Error(`Unknown prompt: ${name}`)
+    }
+  }
+
+  /**
+   * Get behavior instructions prompt
+   */
+  private async getBehaviorPrompt() {
+    const detectedProject = await this.detectCurrentProject()
+
+    return {
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: this.buildBehaviorPromptText(detectedProject)
+          }
+        }
+      ]
+    }
+  }
+
+  /**
+   * Build the behavior prompt text
+   */
+  private buildBehaviorPromptText(detectedProject: DetectedProject | null): string {
+    const phase12Status = isPhase12Available()
+      ? `
+**Phase 12 Advanced Features Available:**
+The system includes advanced automation that may auto-detect and save decisions.
+Continue being proactive - Phase 12 features complement your behavior.
+`
+      : ''
+
+    const projectContext = detectedProject
+      ? `
+**CURRENT PROJECT DETECTED: ${detectedProject.name}**
+- Confidence: ${Math.round(detectedProject.confidence * 100)}%
+- Detection method: ${detectedProject.indicators.join(', ')}
+
+When the user asks questions, assume they're asking about this project unless they specify otherwise.
+`
+      : 'No project currently detected in working directory.'
+
+    return `
+# Claude Brain Integration
+
+You are connected to Claude Brain, a persistent memory and context management system.
+
+## CRITICAL BEHAVIORS (Always Follow)
+
+### 1. Proactive Tool Usage
+When users ask questions about their projects, YOU SHOULD:
+- Use \`get_project_context\` when they mention a project name
+- Use \`recall_similar\` before answering architecture/design questions
+- Use \`remember_decision\` when making important recommendations
+- Use \`update_progress\` when they complete tasks
+
+DO NOT wait for explicit commands like "use the tool". Act proactively based on context.
+
+### 2. Decision Detection
+When you make recommendations that include:
+- "I recommend..."
+- "You should use..."
+- "The best approach is..."
+- Technical architecture choices
+
+YOU SHOULD automatically use \`remember_decision\` to store this for future reference.
+
+### 3. Context Awareness
+${projectContext}
+
+### 4. Memory-First Approach
+BEFORE answering architecture, design, or technical questions:
+1. Use \`recall_similar\` to check past decisions
+2. If relevant past context exists, reference it in your answer
+3. Build on past decisions rather than starting from scratch
+
+### 5. Available Tools
+
+**Context & Information:**
+- \`get_project_context\`: Get full project details, tech stack, progress, standards
+- \`list_projects\`: See all available projects
+- \`get_code_standards\`: Get coding standards for a project
+
+**Memory & Decisions:**
+- \`remember_decision\`: Store important decisions (use proactively!)
+- \`recall_similar\`: Search past decisions by semantic similarity
+
+**Progress Tracking:**
+- \`update_progress\`: Mark tasks complete and set next steps
+
+**Phase 12 Smart Tools:**
+- \`smart_context\`: Get context + proactive memory recall for current task
+- \`auto_remember\`: Auto-detect and save decisions from text
+- \`get_phase12_status\`: Check automation status
+
+## Example Behaviors
+
+**Good (Proactive):**
+\`\`\`
+User: "How should I handle authentication in my-app?"
+
+You (internally):
+1. Use recall_similar("authentication approaches")
+2. Use get_project_context("my-app") if needed
+
+You (response): "Based on our past Auth0 decision in your-other-app
+(which worked well), I recommend a similar approach for my-app..."
+\`\`\`
+
+**Bad (Waiting for Commands):**
+\`\`\`
+User: "How should I handle authentication in my-app?"
+You: "Would you like me to check past decisions first?"
+\`\`\`
+
+## Phase 12 Integration Notice
+${phase12Status}
+
+Remember: Be helpful and proactive. Users expect you to use these tools automatically based on context, not wait for explicit commands.
+`.trim()
+  }
+
+  /**
+   * Get current project context prompt
+   */
+  private async getProjectContextPrompt() {
+    const detectedProject = await this.detectCurrentProject()
+
+    if (!detectedProject) {
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: 'No project detected in current working directory.'
+            }
+          }
+        ]
+      }
+    }
+
+    try {
+      if (!isServicesInitialized()) {
+        return {
+          messages: [
+            {
+              role: 'user',
+              content: {
+                type: 'text',
+                text: `Project detected: ${detectedProject.name}, but services not initialized.`
+              }
+            }
+          ]
+        }
+      }
+
+      const contextService = getContextService()
+
+      // Get brief context summary
+      const context = await contextService.getContext(detectedProject.name, {
+        includeMemories: false, // Brief summary only
+        includeProgress: true,
+        includeStandards: false,
+        maxTokens: 1000
+      })
+
+      const techStack = context.project.techStack?.join(', ') || 'Not specified'
+      const currentPhase = context.progress?.currentPhase || 'Not specified'
+      const completion = context.progress?.completionPercentage || 0
+      const currentTasks = context.progress?.currentTasks?.slice(0, 3).map(t => `- ${t.title}`).join('\n') || 'No current tasks'
+
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `
+# Current Project: ${detectedProject.name}
+
+## Quick Summary
+${context.project.description || 'No description available'}
+
+## Tech Stack
+${techStack}
+
+## Current Phase
+${currentPhase} (${completion}% complete)
+
+## Recent Activity
+${currentTasks}
+
+Use \`get_project_context\` for complete details including decisions, standards, and relevant memories.
+`.trim()
+            }
+          }
+        ]
+      }
+
+    } catch (error) {
+      this.logger.error({ error, project: detectedProject.name }, 'Failed to load project context')
+
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `Project detected: ${detectedProject.name}, but context could not be loaded. Use \`get_project_context\` to access details.`
+            }
+          }
+        ]
+      }
+    }
+  }
+
+  /**
+   * Detect current project from working directory
+   */
+  private async detectCurrentProject(): Promise<DetectedProject | null> {
+    try {
+      const cwd = process.cwd()
+
+      // Check if Phase 12 is available with better detection
+      if (isPhase12Available()) {
+        const phase12 = getPhase12Instance()
+        if (phase12?.projectDetector?.detectProject) {
+          return await phase12.projectDetector.detectProject(cwd)
+        }
+      }
+
+      // Fallback: Simple detection
+      if (!isServicesInitialized()) {
+        return null
+      }
+
+      const vault = getVaultService()
+      const projects = await vault.reader.getProjectDirectories(vault.paths.projects)
+      const dirName = path.basename(cwd)
+
+      if (projects.includes(dirName)) {
+        return {
+          name: dirName,
+          path: cwd,
+          confidence: 1.0,
+          indicators: ['directory-match']
+        }
+      }
+
+      // Check if cwd contains a project folder name
+      for (const project of projects) {
+        if (cwd.toLowerCase().includes(project.toLowerCase())) {
+          return {
+            name: project,
+            path: cwd,
+            confidence: 0.7,
+            indicators: ['path-contains-project']
+          }
+        }
+      }
+
+      return null
+
+    } catch (error) {
+      this.logger.debug({ error }, 'Project detection failed')
+      return null
+    }
+  }
+}