memory-engineering/src/index.ts

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

#!/usr/bin/env node

/**
 * Memory Engineering 2.3.0 - Complete Claude-Flow Architecture
 * Advanced Memory-Aware Code Context System
 */

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { registerTools } from './tools/index.js';
import { getMemoryManager, shutdownMemoryManager } from './memory/factory.js';
import { logger } from './utils/logger.js';

const SERVER_INFO = {
  name: 'memory-engineering',
  version: '2.3.0',
  description: 'Advanced Memory-Aware Code Context System with claude-flow-inspired architecture'
};

async function main() {
  console.log(`
╔══════════════════════════════════════════════╗
║       Memory Engineering 2.3 MCP Server      ║
║         Complete Claude-Flow Architecture    ║
╚══════════════════════════════════════════════╝
`);

  const server = new Server(SERVER_INFO, {
    capabilities: {
      tools: {}
    }
  });

  try {
    // Initialize memory manager
    logger.info('Initializing memory system...');
    const memoryManager = await getMemoryManager();
    
    // Check health
    const health = await memoryManager.getHealthStatus();
    if (!health.healthy) {
      throw new Error(`Memory system unhealthy: ${health.error}`);
    }

    logger.info('Memory system initialized', {
      healthy: health.healthy,
      metrics: health.metrics
    });

    // Register all tools
    await registerTools(server);

    // Setup transport
    const transport = new StdioServerTransport();
    
    // Handle shutdown gracefully
    process.on('SIGINT', async () => {
      logger.info('Shutting down server...');
      await shutdownMemoryManager();
      process.exit(0);
    });

    process.on('SIGTERM', async () => {
      logger.info('Shutting down server...');
      await shutdownMemoryManager();
      process.exit(0);
    });

    // Start server
    await server.connect(transport);
    
    logger.info('Memory Engineering MCP Server started', {
      version: SERVER_INFO.version,
      architecture: 'claude-flow-inspired'
    });

    console.log(`
✅ Server ready!

🧠 **Claude-Flow Architecture:**
- Conflict-free MongoDB operations
- Event-driven memory management
- Professional error handling
- Health monitoring & metrics

🛠️ **Available Tools:**
1. memory_init - Initialize memory system
2. memory_project_brief - Project requirements
3. memory_product_context - Product vision
4. memory_active_context - Current work tracking
5. memory_search - Search memories
6. memory_codebase_embed - Index codebase (superior to code-context-master)

Ready for connections...
`);

  } catch (error) {
    logger.error('Failed to start server', error);
    console.error(`❌ Server startup failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
    process.exit(1);
  }
}

// Handle unhandled rejections
process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled Rejection', { reason, promise });
});

process.on('uncaughtException', (error) => {
  logger.error('Uncaught Exception', error);
  process.exit(1);
});

if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((error) => {
    logger.error('Main execution failed', error);
    process.exit(1);
  });
}