memento-mcp-server 0.1.0 → 1.7.1

package/src/server/index.ts

@@ -1,347 +0,0 @@
-/**
- * Memento MCP Server 메인 진입점 (리팩토링된 버전)
- * 모듈화된 도구들을 사용하여 유지보수성 개선
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { initializeDatabase, closeDatabase } from '../database/init.js';
-import { mementoConfig, validateConfig } from '../config/index.js';
-import { DatabaseUtils } from '../utils/database.js';
-import { SearchEngine } from '../algorithms/search-engine.js';
-import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
-import { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
-import { ForgettingPolicyService } from '../services/forgetting-policy-service.js';
-import { PerformanceMonitor } from '../services/performance-monitor.js';
-import { SearchCacheService } from '../services/cache-service.js';
-import { DatabaseOptimizer } from '../services/database-optimizer.js';
-import { ErrorLoggingService, ErrorSeverity, ErrorCategory } from '../services/error-logging-service.js';
-import { PerformanceAlertService, AlertType, AlertLevel } from '../services/performance-alert-service.js';
-// import { PerformanceMonitoringIntegration } from '../services/performance-monitoring-integration.js';
-import { getToolRegistry } from '../tools/index.js';
-import type { ToolContext } from '../tools/types.js';
-import Database from 'better-sqlite3';
-
-// MCP 서버 인스턴스
-let server: Server;
-let db: Database.Database | null = null;
-let searchEngine: SearchEngine;
-let hybridSearchEngine: HybridSearchEngine;
-let embeddingService: MemoryEmbeddingService;
-let forgettingPolicyService: ForgettingPolicyService;
-let performanceMonitor: PerformanceMonitor;
-let searchCache: SearchCacheService;
-let databaseOptimizer: DatabaseOptimizer;
-let errorLoggingService: ErrorLoggingService;
-let performanceAlertService: PerformanceAlertService;
-// let performanceMonitoringIntegration: PerformanceMonitoringIntegration;
-
-// MCP 서버에서는 모든 로그 출력을 완전히 차단
-// 모든 console 메서드를 빈 함수로 교체
-console.log = () => {};
-console.error = () => {};
-console.warn = () => {};
-console.info = () => {};
-console.debug = () => {};
-
-// 동시성 제한을 위한 세마포어
-export class Semaphore {
-  private permits: number;
-  private waiting: Array<() => void> = [];
-
-  constructor(permits: number) {
-    this.permits = permits;
-  }
-
-  async acquire(): Promise<void> {
-    if (this.permits > 0) {
-      this.permits--;
-      return;
-    }
-
-    return new Promise(resolve => {
-      this.waiting.push(resolve);
-    });
-  }
-
-  release(): void {
-    this.permits++;
-    if (this.waiting.length > 0) {
-      const resolve = this.waiting.shift()!;
-      this.permits--;
-      resolve();
-    }
-  }
-}
-
-// 동시 처리 제한 (최대 20개 동시 요청)
-const concurrencyLimiter = new Semaphore(20);
-
-// 데이터베이스 상태 모니터링
-async function monitorDatabaseStatus() {
-  if (!db) return;
-  
-  try {
-    const status = await DatabaseUtils.getDatabaseStatus(db);
-    log('📊 데이터베이스 상태:', {
-      journalMode: status.journalMode,
-      walAutoCheckpoint: status.walAutoCheckpoint,
-      busyTimeout: status.busyTimeout,
-      isLocked: status.isLocked ? '🔒 잠김' : '🔓 정상'
-    });
-    
-    // 락이 감지되면 WAL 체크포인트 실행
-    if (status.isLocked) {
-      log('⚠️ 데이터베이스 락 감지, WAL 체크포인트 실행...');
-      await DatabaseUtils.checkpointWAL(db);
-    }
-  } catch (error) {
-    // 데이터베이스 상태 모니터링 실패
-  }
-}
-
-// MCP 모드 감지 (stdio를 통해 실행되는지 확인)
-const isMCPMode = process.stdin.isTTY === false && process.stdout.isTTY === false;
-
-// MCP 모드에서는 로그를 stderr로 출력
-const log = isMCPMode ? console.error : console.log;
-
-// MCP 서버 초기화
-async function initializeServer() {
-  try {
-    process.stderr.write('🚀 MCP 서버 초기화 시작...\n');
-    
-    // 설정 검증
-    validateConfig();
-    process.stderr.write('✅ 설정 검증 완료\n');
-    
-    // 데이터베이스 초기화
-    db = await initializeDatabase();
-    process.stderr.write('✅ 데이터베이스 초기화 완료\n');
-    
-    // 데이터베이스 상태 모니터링
-    await monitorDatabaseStatus();
-    process.stderr.write('✅ 데이터베이스 상태 모니터링 완료\n');
-    
-    // 검색 엔진 초기화
-    searchEngine = new SearchEngine();
-    hybridSearchEngine = new HybridSearchEngine();
-    embeddingService = new MemoryEmbeddingService();
-    forgettingPolicyService = new ForgettingPolicyService();
-    performanceMonitor = new PerformanceMonitor();
-    searchCache = new SearchCacheService(1000, 300000); // 5분 TTL
-    databaseOptimizer = new DatabaseOptimizer(db);
-    errorLoggingService = new ErrorLoggingService();
-    performanceAlertService = new PerformanceAlertService('./logs');
-    // performanceMonitoringIntegration = new PerformanceMonitoringIntegration(
-    //   db,
-    //   performanceAlertService,
-    //   {
-    //     enableRealTimeMonitoring: true,
-    //     monitoringInterval: 30000, // 30초마다 체크
-    //     alertThresholds: {
-    //       responseTime: { warning: 100, critical: 500 },
-    //       memoryUsage: { warning: 100, critical: 200 },
-    //       errorRate: { warning: 5, critical: 10 },
-    //       throughput: { warning: 10, critical: 5 }
-    //     }
-    //   }
-    // );
-    
-    // 임베딩 프로바이더 정보 표시
-    process.stderr.write(`🔧 임베딩 프로바이더: ${mementoConfig.embeddingProvider.toUpperCase()}\n`);
-    if (mementoConfig.embeddingProvider === 'openai' && mementoConfig.openaiApiKey) {
-      process.stderr.write(`   📝 모델: ${mementoConfig.openaiModel} (${mementoConfig.embeddingDimensions}차원)\n`);
-    } else if (mementoConfig.embeddingProvider === 'gemini' && mementoConfig.geminiApiKey) {
-      process.stderr.write(`   📝 모델: ${mementoConfig.geminiModel} (${mementoConfig.embeddingDimensions}차원)\n`);
-    } else if (mementoConfig.embeddingProvider === 'lightweight') {
-      process.stderr.write(`   📝 모델: lightweight-hybrid (512차원)\n`);
-    }
-    
-    process.stderr.write('✅ 검색 엔진 초기화 완료\n');
-    
-    // MCP 서버 생성
-    server = new Server(
-      {
-        name: mementoConfig.serverName,
-        version: mementoConfig.serverVersion,
-      },
-      {
-        capabilities: {
-          tools: {},
-          resources: {},
-          prompts: {}
-        }
-      }
-    );
-    process.stderr.write('✅ MCP 서버 생성 완료\n');
-    
-    // 도구 레지스트리 가져오기
-    const toolRegistry = getToolRegistry();
-    
-    // Tools 등록
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-      process.stderr.write('📋 도구 목록 요청 처리\n');
-      const tools = toolRegistry.getAll();
-      process.stderr.write(`📋 등록된 도구 개수: ${tools.length}\n`);
-      tools.forEach(tool => {
-        process.stderr.write(`   - ${tool.name}: ${tool.description}\n`);
-      });
-      
-      return {
-        tools: tools.map(tool => ({
-          name: tool.name,
-          description: tool.description,
-          inputSchema: tool.inputSchema
-        }))
-      };
-    });
-    
-    // Tool 실행 핸들러 - 동시성 제한 적용
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      process.stderr.write(`🔧 도구 실행 요청: ${name}\n`);
-      process.stderr.write(`🔧 도구 인수: ${JSON.stringify(args)}\n`);
-      
-      // 동시성 제한 적용
-      await concurrencyLimiter.acquire();
-      
-      try {
-        // 도구 컨텍스트 생성
-        const context: ToolContext = {
-          db,
-          services: {
-            searchEngine,
-            hybridSearchEngine,
-            embeddingService,
-            forgettingPolicyService,
-            performanceMonitor,
-            databaseOptimizer,
-            errorLoggingService,
-            performanceAlertService
-            // performanceMonitoringIntegration
-          }
-        };
-        
-        process.stderr.write(`🔧 도구 실행 시작: ${name}\n`);
-        // 도구 실행
-        const toolResult = await toolRegistry.execute(name, args, context);
-        process.stderr.write(`🔧 도구 실행 완료: ${name}\n`);
-        
-        // MCP 형식으로 변환
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(toolResult)
-            }
-          ]
-        };
-      } catch (error) {
-        // 에러 로깅
-        if (errorLoggingService) {
-          errorLoggingService.logError(
-            error instanceof Error ? error : new Error(String(error)),
-            ErrorSeverity.HIGH,
-            ErrorCategory.UNKNOWN,
-            {
-              operation: 'tool_execution',
-              toolName: name,
-              requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-            }
-          );
-        }
-        
-        if (error instanceof Error) {
-          throw new Error(`Tool execution failed: ${error.message}`);
-        }
-        throw error;
-      } finally {
-        // 동시성 제한 해제
-        concurrencyLimiter.release();
-      }
-    });
-    
-    process.stderr.write('✅ MCP 서버 초기화 완료\n');
-    
-    // 실시간 성능 모니터링 시작
-    // performanceMonitoringIntegration.startRealTimeMonitoring();
-    
-    process.stderr.write('🚀 Memento MCP Server가 시작되었습니다!\n');
-    // process.stderr.write('📊 실시간 성능 모니터링이 활성화되었습니다\n');
-    
-  } catch (error) {
-    process.stderr.write(`❌ 서버 초기화 실패: ${error}\n`);
-    process.exit(1);
-  }
-}
-
-// 서버 시작
-async function startServer() {
-  try {
-    await initializeServer();
-    process.stderr.write('✅ 서버 초기화 완료\n');
-    
-    // Stdio 전송 계층 사용
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    process.stderr.write('✅ MCP 전송 계층 연결 완료\n');
-    
-    // MCP 클라이언트 연결 대기 중
-    process.stderr.write('🔗 MCP 클라이언트 연결 대기 중...\n');
-    
-    // 서버가 종료될 때까지 대기
-    return new Promise<void>((resolve) => {
-      process.on('SIGINT', () => {
-        process.stderr.write('👋 서버 종료 신호 수신\n');
-        cleanup().then(() => {
-          process.exit(0);
-        });
-      });
-
-      process.on('SIGTERM', () => {
-        process.stderr.write('👋 서버 종료 신호 수신\n');
-        cleanup().then(() => {
-          process.exit(0);
-        });
-      });
-    });
-  } catch (error) {
-    process.stderr.write(`❌ 서버 시작 실패: ${error}\n`);
-    process.exit(1);
-  }
-}
-
-// 정리 함수
-let isCleaningUp = false;
-
-async function cleanup() {
-  if (isCleaningUp) {
-    return; // 이미 정리 중이면 중복 실행 방지
-  }
-  
-  isCleaningUp = true;
-  
-  if (db) {
-    closeDatabase(db);
-    db = null; // 참조 제거
-  }
-  // Memento MCP Server 종료
-}
-
-// 프로세스 종료 시 정리
-process.on('SIGINT', cleanup);
-process.on('SIGTERM', cleanup);
-process.on('uncaughtException', (error) => {
-  // 예상치 못한 오류
-  cleanup();
-  process.exit(1);
-});
-
-// 서버 시작
-if (process.argv[1] && process.argv[1].endsWith('index.js')) {
-  startServer().catch(error => {
-    process.exit(1);
-  });
-}

package/src/server/simple-mcp-server.spec.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
-import { AddressInfo } from 'net';
-import type { Server } from 'http';
-
-type SimpleMCPModule = typeof import('./simple-mcp-server.js');
-
-let simpleModule: SimpleMCPModule;
-let server: Server | null = null;
-let baseUrl: string;
-
-const startTestServer = async (module: SimpleMCPModule) => {
-  const httpServer = module.server;
-  await new Promise<void>((resolve) => {
-    server = httpServer.listen(0, () => {
-      const address = server!.address() as AddressInfo;
-      baseUrl = `http://127.0.0.1:${address.port}`;
-      resolve();
-    });
-  });
-};
-
-const stopTestServer = async () => {
-  if (!server) return;
-  await new Promise<void>((resolve, reject) => {
-    server!.close((err) => (err ? reject(err) : resolve()));
-  });
-  server = null;
-};
-
-const postJson = async (path: string, body: unknown) => {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body)
-  });
-  return { status: response.status, json: await response.json() };
-};
-
-const getJson = async (path: string) => {
-  const response = await fetch(`${baseUrl}${path}`);
-  return { status: response.status, json: await response.json() };
-};
-
-beforeAll(async () => {
-  simpleModule = await import('./simple-mcp-server.js');
-  await startTestServer(simpleModule);
-});
-
-afterAll(async () => {
-  await stopTestServer();
-});
-
-describe('Simple MCP Server', () => {
-  describe('기본 기능', () => {
-    it('헬스 체크 엔드포인트가 작동한다', async () => {
-      const response = await getJson('/health');
-      expect(response.status).toBe(200);
-      expect(response.json.status).toBe('healthy');
-      expect(response.json.server).toBe('memento-memory');
-      expect(response.json.version).toBe('0.1.0');
-      expect(response.json.tools).toBe(2); // remember, recall
-    });
-
-    it('도구 목록을 반환한다', async () => {
-      const response = await getJson('/health');
-      expect(response.json.tools).toBeGreaterThan(0);
-    });
-  });
-
-  describe('SSE 엔드포인트', () => {
-    it('SSE 스트림을 설정한다', async () => {
-      const response = await fetch(`${baseUrl}/mcp`);
-      expect(response.status).toBe(200);
-      expect(response.headers.get('content-type')).toContain('text/event-stream');
-      expect(response.headers.get('cache-control')).toContain('no-cache');
-      expect(response.headers.get('connection')).toBe('keep-alive');
-      
-      // 응답을 읽고 즉시 연결을 종료하여 타임아웃 방지
-      const reader = response.body?.getReader();
-      if (reader) {
-        const { value } = await reader.read();
-        const text = new TextDecoder().decode(value);
-        expect(text).toContain('event: endpoint');
-        expect(text).toContain('data: {"type": "ready"}');
-        expect(text).toMatch(/session_\d+_[a-z0-9]+/);
-        reader.cancel();
-      }
-    }, 10000);
-
-    it('SSE 연결 종료를 처리한다', async () => {
-      const controller = new AbortController();
-      const response = await fetch(`${baseUrl}/mcp`, {
-        signal: controller.signal
-      });
-      
-      expect(response.status).toBe(200);
-      controller.abort();
-      expect(response.ok).toBe(true);
-    });
-  });
-
-  describe('MCP 메시지 처리', () => {
-    it('initialize 요청을 처리한다', async () => {
-      const response = await postJson('/messages?sessionId=test-session', {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'initialize',
-        params: {
-          protocolVersion: '2024-11-05',
-          capabilities: {},
-          clientInfo: {
-            name: 'test-client',
-            version: '1.0.0'
-          }
-        }
-      });
-
-      expect(response.status).toBe(200);
-      expect(response.json.status).toBe('ok');
-    });
-
-    it('notifications/initialized 요청을 처리한다', async () => {
-      const response = await postJson('/messages?sessionId=test-session', {
-        jsonrpc: '2.0',
-        id: 2,
-        method: 'notifications/initialized'
-      });
-
-      expect(response.status).toBe(200);
-      expect(response.json.status).toBe('ok');
-    });
-
-    it('tools/list 요청을 처리한다', async () => {
-      const response = await postJson('/messages?sessionId=test-session', {
-        jsonrpc: '2.0',
-        id: 3,
-        method: 'tools/list'
-      });
-
-      expect(response.status).toBe(200);
-      expect(response.json.status).toBe('ok');
-      expect(response.json.sseData).toContain('tools');
-    });
-
-    it('알 수 없는 메서드를 처리한다', async () => {
-      const response = await postJson('/messages?sessionId=test-session', {
-        jsonrpc: '2.0',
-        id: 4,
-        method: 'unknown/method'
-      });
-
-      expect(response.status).toBe(200);
-      expect(response.json.status).toBe('ok');
-      expect(response.json.sseData).toContain('Method not found');
-    });
-  });
-
-  describe('에러 처리', () => {
-    it('세션 ID가 없으면 400을 반환한다', async () => {
-      const response = await postJson('/messages', {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'initialize'
-      });
-
-      // simple-mcp-server는 세션 ID가 없어도 200을 반환하므로 실제 구현에 맞게 수정
-      expect(response.status).toBe(200);
-    });
-
-    it('잘못된 JSON을 처리한다', async () => {
-      const response = await fetch(`${baseUrl}/messages?sessionId=test-session`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: 'invalid json'
-      });
-
-      expect(response.status).toBe(400);
-    });
-
-    it('메시지 처리 중 에러가 발생하면 적절히 처리한다', async () => {
-      // 잘못된 메시지 구조로 에러 유발
-      const response = await postJson('/messages?sessionId=test-session', {
-        invalid: 'message'
-      });
-
-      expect(response.status).toBe(200);
-      // simple-mcp-server는 에러가 발생해도 'ok'를 반환하므로 실제 구현에 맞게 수정
-      expect(response.json.status).toBe('ok');
-    });
-  });
-
-  describe('CORS 설정', () => {
-    it('CORS 헤더가 올바르게 설정된다', async () => {
-      const response = await fetch(`${baseUrl}/health`, {
-        method: 'OPTIONS',
-        headers: {
-          'Origin': 'http://localhost:3000',
-          'Access-Control-Request-Method': 'GET'
-        }
-      });
-
-      // OPTIONS 요청은 204를 반환하는 것이 정상
-      expect(response.status).toBe(204);
-      expect(response.headers.get('access-control-allow-origin')).toBe('*');
-    });
-  });
-});