memento-mcp-server 0.1.0

package/src/server/index-refactored.ts

@@ -0,0 +1,237 @@
+/**
+ * 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 { 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;
+
+// MCP 서버에서는 모든 로그 출력을 완전히 차단
+// 모든 console 메서드를 빈 함수로 교체
+console.log = () => {};
+console.error = () => {};
+console.warn = () => {};
+console.info = () => {};
+console.debug = () => {};
+
+// 데이터베이스 상태 모니터링
+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(db);
+    searchCache = new SearchCacheService(1000, 300000); // 5분 TTL
+    databaseOptimizer = new DatabaseOptimizer(db);
+    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();
+      
+      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`);
+      
+      try {
+        // 도구 컨텍스트 생성
+        const context: ToolContext = {
+          db,
+          services: {
+            searchEngine,
+            hybridSearchEngine,
+            embeddingService,
+            forgettingPolicyService,
+            performanceMonitor,
+            databaseOptimizer
+          }
+        };
+        
+        // 도구 실행
+        const result = await toolRegistry.execute(name, args, context);
+        return result;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Tool execution failed: ${error.message}`);
+        }
+        throw error;
+      }
+    });
+    
+    process.stderr.write('✅ MCP 서버 초기화 완료\n');
+    process.stderr.write('🚀 Memento MCP Server가 시작되었습니다!\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/index.spec.ts

@@ -0,0 +1,281 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+// Mock all dependencies
+vi.mock('@modelcontextprotocol/sdk/server/index.js');
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js');
+vi.mock('@modelcontextprotocol/sdk/types.js');
+vi.mock('../database/init.js');
+vi.mock('../config/index.js');
+vi.mock('../utils/database.js');
+vi.mock('../algorithms/search-engine.js');
+vi.mock('../algorithms/hybrid-search-engine.js');
+vi.mock('../services/memory-embedding-service.js');
+vi.mock('../services/forgetting-policy-service.js');
+vi.mock('../services/performance-monitor.js');
+vi.mock('../services/cache-service.js');
+vi.mock('../services/database-optimizer.js');
+vi.mock('../services/error-logging-service.js');
+vi.mock('../services/performance-alert-service.js');
+vi.mock('../services/performance-monitoring-integration.js');
+vi.mock('../tools/index.js');
+vi.mock('better-sqlite3');
+
+describe('Memento MCP Server', () => {
+  let mockServer: any;
+  let mockTransport: any;
+  let mockDb: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Mock Server
+    mockServer = {
+      setRequestHandler: vi.fn(),
+      connect: vi.fn(),
+      close: vi.fn(),
+      on: vi.fn()
+    };
+    
+    // Mock Transport
+    mockTransport = {
+      start: vi.fn(),
+      close: vi.fn()
+    };
+    
+    // Mock Database
+    mockDb = {
+      prepare: vi.fn(),
+      exec: vi.fn(),
+      close: vi.fn()
+    };
+
+    // Mock Server constructor
+    vi.mocked(Server).mockImplementation(() => mockServer);
+    vi.mocked(StdioServerTransport).mockImplementation(() => mockTransport);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('서버 초기화', () => {
+    it('서버가 올바르게 생성되어야 함', async () => {
+      // 서버 모듈을 동적으로 import하여 실제 초기화 과정을 테스트
+      const serverModule = await import('../server/index.js');
+      expect(serverModule).toBeDefined();
+    });
+
+    it('stdio 전송이 올바르게 생성되어야 함', () => {
+      // Mock이 호출되었는지 확인 (실제 서버 시작 시에만 호출됨)
+      expect(StdioServerTransport).toBeDefined();
+    });
+  });
+
+  describe('도구 등록', () => {
+    it('핵심 도구들이 등록되어야 함', () => {
+      // Mock tool registry
+      const mockToolRegistry = {
+        getTools: vi.fn().mockReturnValue([
+          { name: 'remember', description: '기억을 저장합니다' },
+          { name: 'recall', description: '기억을 검색합니다' },
+          { name: 'pin', description: '기억을 고정합니다' },
+          { name: 'unpin', description: '기억 고정을 해제합니다' },
+          { name: 'forget', description: '기억을 삭제합니다' }
+        ])
+      };
+
+      vi.doMock('../tools/index.js', () => ({
+        getToolRegistry: () => mockToolRegistry
+      }));
+
+      // Mock이 정의되었는지 확인
+      expect(mockServer.setRequestHandler).toBeDefined();
+    });
+  });
+
+  describe('데이터베이스 연결', () => {
+    it('데이터베이스가 올바르게 초기화되어야 함', async () => {
+      const { initializeDatabase } = await import('../database/init.js');
+      vi.mocked(initializeDatabase).mockResolvedValue(mockDb);
+
+      // Mock이 정의되었는지 확인
+      expect(initializeDatabase).toBeDefined();
+    });
+  });
+
+  describe('서비스 초기화', () => {
+    it('검색 엔진이 초기화되어야 함', async () => {
+      const { SearchEngine } = await import('../algorithms/search-engine.js');
+      expect(SearchEngine).toBeDefined();
+    });
+
+    it('하이브리드 검색 엔진이 초기화되어야 함', async () => {
+      const { HybridSearchEngine } = await import('../algorithms/hybrid-search-engine.js');
+      expect(HybridSearchEngine).toBeDefined();
+    });
+
+    it('임베딩 서비스가 초기화되어야 함', async () => {
+      const { MemoryEmbeddingService } = await import('../services/memory-embedding-service.js');
+      expect(MemoryEmbeddingService).toBeDefined();
+    });
+
+    it('망각 정책 서비스가 초기화되어야 함', async () => {
+      const { ForgettingPolicyService } = await import('../services/forgetting-policy-service.js');
+      expect(ForgettingPolicyService).toBeDefined();
+    });
+
+    it('성능 모니터가 초기화되어야 함', async () => {
+      const { PerformanceMonitor } = await import('../services/performance-monitor.js');
+      expect(PerformanceMonitor).toBeDefined();
+    });
+  });
+
+  describe('에러 처리', () => {
+    it('초기화 에러가 적절히 처리되어야 함', async () => {
+      const { initializeDatabase } = await import('../database/init.js');
+      vi.mocked(initializeDatabase).mockRejectedValue(new Error('Database connection failed'));
+
+      // Mock이 정의되었는지 확인
+      expect(initializeDatabase).toBeDefined();
+    });
+  });
+
+  describe('로그 차단', () => {
+    it('console 메서드들이 차단되어야 함', () => {
+      const originalConsole = { ...console };
+      
+      // 서버 초기화 후 console 메서드들이 차단되었는지 확인
+      expect(console.log).toBeDefined();
+      expect(console.error).toBeDefined();
+      expect(console.warn).toBeDefined();
+      expect(console.info).toBeDefined();
+      expect(console.debug).toBeDefined();
+    });
+  });
+
+  describe('세마포어', () => {
+    it('동시성 제한이 올바르게 작동해야 함', async () => {
+      // Semaphore 클래스 테스트
+      const Semaphore = (await import('../server/index.js')).Semaphore;
+      const semaphore = new Semaphore(2);
+
+      expect(semaphore).toBeDefined();
+      expect(semaphore.acquire).toBeDefined();
+      expect(semaphore.release).toBeDefined();
+    });
+
+    it('세마포어가 동시 요청을 제한한다', async () => {
+      const Semaphore = (await import('../server/index.js')).Semaphore;
+      const semaphore = new Semaphore(2);
+      const results: number[] = [];
+      const startTime = Date.now();
+
+      // 5개의 동시 요청을 생성하지만 세마포어는 2개만 허용
+      const promises = Array.from({ length: 5 }, async (_, i) => {
+        await semaphore.acquire();
+        results.push(i);
+        await new Promise(resolve => setTimeout(resolve, 100)); // 100ms 대기
+        semaphore.release();
+      });
+
+      await Promise.all(promises);
+      const endTime = Date.now();
+
+      // 결과가 순차적으로 처리되었는지 확인
+      expect(results).toHaveLength(5);
+      // 최소 300ms 이상 걸려야 함 (2개씩 처리하므로 3번의 배치)
+      expect(endTime - startTime).toBeGreaterThanOrEqual(300);
+    });
+
+    it('세마포어가 순서대로 요청을 처리한다', async () => {
+      const Semaphore = (await import('../server/index.js')).Semaphore;
+      const semaphore = new Semaphore(1);
+      const results: number[] = [];
+
+      // 순차적으로 요청을 처리해야 함
+      const promises = Array.from({ length: 3 }, async (_, i) => {
+        await semaphore.acquire();
+        results.push(i);
+        await new Promise(resolve => setTimeout(resolve, 50));
+        semaphore.release();
+      });
+
+      await Promise.all(promises);
+
+      // 결과가 순서대로 처리되었는지 확인
+      expect(results).toEqual([0, 1, 2]);
+    });
+  });
+
+  describe('데이터베이스 상태 모니터링', () => {
+    it('데이터베이스 상태를 모니터링한다', async () => {
+      const { DatabaseUtils } = await import('../utils/database.js');
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue({
+          get: vi.fn().mockReturnValue({
+            journal_mode: 'WAL',
+            wal_autocheckpoint: 1000,
+            busy_timeout: 5000,
+            is_locked: 0
+          })
+        })
+      };
+
+      vi.mocked(DatabaseUtils.getDatabaseStatus).mockResolvedValue({
+        journalMode: 'WAL',
+        walAutoCheckpoint: 1000,
+        busyTimeout: 5000,
+        isLocked: false
+      });
+
+      const status = await DatabaseUtils.getDatabaseStatus(mockDb as any);
+      expect(status).toBeDefined();
+      expect(status.journalMode).toBe('WAL');
+      expect(status.isLocked).toBe(false);
+    });
+
+    it('데이터베이스 락이 감지되면 WAL 체크포인트를 실행한다', async () => {
+      const { DatabaseUtils } = await import('../utils/database.js');
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue({
+          get: vi.fn().mockReturnValue({
+            journal_mode: 'WAL',
+            wal_autocheckpoint: 1000,
+            busy_timeout: 5000,
+            is_locked: 1 // 락 상태
+          })
+        })
+      };
+
+      vi.mocked(DatabaseUtils.getDatabaseStatus).mockResolvedValue({
+        journalMode: 'WAL',
+        walAutoCheckpoint: 1000,
+        busyTimeout: 5000,
+        isLocked: true
+      });
+
+      vi.mocked(DatabaseUtils.checkpointWAL).mockResolvedValue();
+
+      const status = await DatabaseUtils.getDatabaseStatus(mockDb as any);
+      expect(status.isLocked).toBe(true);
+      
+      // 락이 감지되면 WAL 체크포인트가 호출되어야 함
+      if (status.isLocked) {
+        await DatabaseUtils.checkpointWAL(mockDb as any);
+        expect(DatabaseUtils.checkpointWAL).toHaveBeenCalledWith(mockDb);
+      }
+    });
+  });
+
+  describe('서버 종료', () => {
+    it('서버가 올바르게 종료되어야 함', async () => {
+      const { closeDatabase } = await import('../database/init.js');
+      vi.mocked(closeDatabase).mockResolvedValue();
+
+      // Mock이 정의되었는지 확인
+      expect(closeDatabase).toBeDefined();
+    });
+  });
+});