memory-engineering/src/tools/index.ts

Advanced Memory-Aware Code Context System with claude-flow-inspired architecture, showcasing MongoDB + Voyage AI strategic positioning

/**
 * Tools Registry
 * All memory tools using claude-flow-inspired MemoryManager
 */

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import { getMemoryManager } from '../memory/factory.js';
import { logger } from '../utils/logger.js';

// Import all tools
import { memoryInitTool, createMemoryInitHandler } from './memory-init.js';
import { memoryProjectBriefTool, createMemoryProjectBriefHandler } from './memory-project-brief.js';
import { memoryProductContextTool, createMemoryProductContextHandler } from './memory-product-context.js';
import { memoryActiveContextTool, createMemoryActiveContextHandler } from './memory-active-context.js';
import { memorySearchTool, createMemorySearchHandler } from './memory-search.js';
import { memoryCodebaseEmbedTool, createMemoryCodebaseEmbedHandler } from './memory-codebase-embed.js';

export async function registerTools(server: Server): Promise<void> {
  // Get memory manager instance
  const memoryManager = await getMemoryManager();
  
  // Define all tools with their handlers
  const tools = [
    {
      definition: memoryInitTool,
      handler: createMemoryInitHandler(memoryManager),
    },
    {
      definition: memoryProjectBriefTool,
      handler: createMemoryProjectBriefHandler(memoryManager),
    },
    {
      definition: memoryProductContextTool,
      handler: createMemoryProductContextHandler(memoryManager),
    },
    {
      definition: memoryActiveContextTool,
      handler: createMemoryActiveContextHandler(memoryManager),
    },
    {
      definition: memorySearchTool,
      handler: createMemorySearchHandler(memoryManager),
    },
    {
      definition: memoryCodebaseEmbedTool,
      handler: createMemoryCodebaseEmbedHandler(memoryManager),
    }
  ];

  // Register list_tools handler
  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: tools.map(t => t.definition)
    };
  });

  // Register call_tool handler
  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
    
    logger.info('Tool called', { 
      tool: name, 
      hasArgs: !!args 
    });

    const tool = tools.find(t => t.definition.name === name);
    if (!tool) {
      throw new Error(`Unknown tool: ${name}`);
    }

    try {
      const result = await tool.handler(args || {});
      
      logger.info('Tool completed', { 
        tool: name, 
        isError: result.isError 
      });
      
      return { content: result.content, isError: result.isError };
    } catch (error) {
      logger.error('Tool execution failed', { tool: name, error });
      
      return {
        content: [{
          type: 'text',
          text: `❌ Tool execution failed: ${error instanceof Error ? error.message : 'Unknown error'}`
        }],
        isError: true
      };
    }
  });

  logger.info('Tools registered', {
    count: tools.length,
    names: tools.map(t => t.definition.name)
  });
}