memento-mcp-server 1.6.0 → 1.7.2

package/src/server/index-refactored.ts

@@ -1,237 +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 { 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

@@ -1,281 +0,0 @@
-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();
-    });
-  });
-});