memory-engineering/dist/index.js

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);
    });
}
//# sourceMappingURL=index.js.map