memento-mcp-server 0.1.0

package/src/test/test-memory-injection-prompt.ts

@@ -0,0 +1,391 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { MemoryInjectionPrompt } from '../tools/memory-injection-prompt.js';
+import { getHybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
+import Database from 'better-sqlite3';
+import { DatabaseUtils } from '../utils/database.js';
+
+// Mock hybrid search engine
+vi.mock('../algorithms/hybrid-search-engine.js');
+
+describe('MemoryInjectionPrompt', () => {
+  let db: Database.Database;
+  let memoryInjectionPrompt: MemoryInjectionPrompt;
+  let mockHybridSearchEngine: any;
+
+  beforeEach(() => {
+    // Create in-memory database for testing
+    db = new Database(':memory:');
+    DatabaseUtils.initializeDatabase(db);
+    
+    memoryInjectionPrompt = new MemoryInjectionPrompt();
+    
+    // Mock hybrid search engine
+    mockHybridSearchEngine = {
+      search: vi.fn()
+    };
+    
+    vi.mocked(getHybridSearchEngine).mockReturnValue(mockHybridSearchEngine);
+  });
+
+  afterEach(() => {
+    if (db) {
+      db.close();
+    }
+    vi.clearAllMocks();
+  });
+
+  describe('초기화', () => {
+    it('should initialize with correct name and description', () => {
+      expect(memoryInjectionPrompt.name).toBe('memory_injection');
+      expect(memoryInjectionPrompt.description).toBe('관련 기억을 요약하여 프롬프트에 주입');
+    });
+
+    it('should have correct input schema', () => {
+      const schema = memoryInjectionPrompt.inputSchema;
+      expect(schema.shape.query).toBeDefined();
+      expect(schema.shape.token_budget).toBeDefined();
+      expect(schema.shape.max_memories).toBeDefined();
+    });
+
+    it('should have correct output schema', () => {
+      const schema = memoryInjectionPrompt.outputSchema;
+      expect(schema.element.shape.role).toBeDefined();
+      expect(schema.element.shape.content).toBeDefined();
+    });
+  });
+
+  describe('기본 실행', () => {
+    it('should execute successfully with valid parameters', async () => {
+      const mockSearchResults = {
+        items: [
+          {
+            id: 'test1',
+            content: 'Test memory 1',
+            type: 'episodic',
+            importance: 0.5,
+            created_at: '2024-01-01'
+          },
+          {
+            id: 'test2',
+            content: 'Test memory 2',
+            type: 'semantic',
+            importance: 0.7,
+            created_at: '2024-01-02'
+          }
+        ]
+      };
+
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 1000,
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0].role).toBe('system');
+      expect(result[0].content).toContain('관련 장기기억 요약');
+      expect(result[0].content).toContain('[episodic] Test memory 1');
+      expect(result[0].content).toContain('[semantic] Test memory 2');
+    });
+
+    it('should handle empty search results', async () => {
+      mockHybridSearchEngine.search.mockResolvedValue({ items: [] });
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 1000,
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0].role).toBe('system');
+      expect(result[0].content).toBe('관련 장기기억을 찾을 수 없습니다.');
+    });
+
+    it('should respect token budget', async () => {
+      const mockSearchResults = {
+        items: [
+          {
+            id: 'test1',
+            content: 'Very long memory content that exceeds token budget when combined with others',
+            type: 'episodic',
+            importance: 0.5,
+            created_at: '2024-01-01'
+          },
+          {
+            id: 'test2',
+            content: 'Another long memory content',
+            type: 'semantic',
+            importance: 0.7,
+            created_at: '2024-01-02'
+          }
+        ]
+      };
+
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 50, // Very small budget
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0].role).toBe('system');
+      expect(result[0].content).toContain('관련 장기기억 요약');
+      // Should only include memories that fit within token budget
+    });
+
+    it('should respect max_memories limit', async () => {
+      const mockSearchResults = {
+        items: Array.from({ length: 10 }, (_, i) => ({
+          id: `test${i}`,
+          content: `Test memory ${i}`,
+          type: 'episodic',
+          importance: 0.5,
+          created_at: '2024-01-01'
+        }))
+      };
+
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 1000,
+          max_memories: 3
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(mockHybridSearchEngine.search).toHaveBeenCalledWith(
+        db,
+        expect.objectContaining({
+          query: 'test query',
+          limit: 3
+        })
+      );
+    });
+  });
+
+  describe('에러 처리', () => {
+    it('should throw error when database not available', async () => {
+      await expect(
+        memoryInjectionPrompt.execute(
+          {
+            query: 'test query',
+            token_budget: 1000,
+            max_memories: 5
+          },
+          {
+            db: null,
+            services: { hybridSearchEngine: mockHybridSearchEngine }
+          }
+        )
+      ).rejects.toThrow('Database connection is not available.');
+    });
+
+    it('should throw error when hybrid search engine not available', async () => {
+      await expect(
+        memoryInjectionPrompt.execute(
+          {
+            query: 'test query',
+            token_budget: 1000,
+            max_memories: 5
+          },
+          {
+            db,
+            services: {}
+          }
+        )
+      ).rejects.toThrow('HybridSearchEngine service is not available.');
+    });
+
+    it('should handle search engine errors', async () => {
+      mockHybridSearchEngine.search.mockRejectedValue(new Error('Search failed'));
+
+      await expect(
+        memoryInjectionPrompt.execute(
+          {
+            query: 'test query',
+            token_budget: 1000,
+            max_memories: 5
+          },
+          {
+            db,
+            services: { hybridSearchEngine: mockHybridSearchEngine }
+          }
+        )
+      ).rejects.toThrow('Search failed');
+    });
+  });
+
+  describe('토큰 추정', () => {
+    it('should estimate tokens correctly', () => {
+      const testText = 'This is a test sentence with multiple words';
+      const estimatedTokens = (memoryInjectionPrompt as any).estimateTokens(testText);
+      
+      // Should be based on word count (whitespace splitting)
+      const expectedTokens = testText.split(/\s+/).length;
+      expect(estimatedTokens).toBe(expectedTokens);
+    });
+
+    it('should handle empty text', () => {
+      const estimatedTokens = (memoryInjectionPrompt as any).estimateTokens('');
+      expect(estimatedTokens).toBe(0);
+    });
+
+    it('should handle text with multiple spaces', () => {
+      const testText = 'word1    word2   word3';
+      const estimatedTokens = (memoryInjectionPrompt as any).estimateTokens(testText);
+      
+      // Should split on multiple whitespace characters
+      const expectedTokens = testText.split(/\s+/).length;
+      expect(estimatedTokens).toBe(expectedTokens);
+    });
+  });
+
+  describe('기억 요약', () => {
+    it('should format memories correctly', async () => {
+      const mockSearchResults = {
+        items: [
+          {
+            id: 'test1',
+            content: 'Test memory 1',
+            type: 'episodic',
+            importance: 0.5,
+            created_at: '2024-01-01'
+          }
+        ]
+      };
+
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 1000,
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(result[0].content).toContain('[episodic] Test memory 1');
+    });
+
+    it('should handle different memory types', async () => {
+      const mockSearchResults = {
+        items: [
+          {
+            id: 'test1',
+            content: 'Working memory',
+            type: 'working',
+            importance: 0.5,
+            created_at: '2024-01-01'
+          },
+          {
+            id: 'test2',
+            content: 'Semantic memory',
+            type: 'semantic',
+            importance: 0.7,
+            created_at: '2024-01-02'
+          },
+          {
+            id: 'test3',
+            content: 'Procedural memory',
+            type: 'procedural',
+            importance: 0.8,
+            created_at: '2024-01-03'
+          }
+        ]
+      };
+
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 1000,
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(result[0].content).toContain('[working] Working memory');
+      expect(result[0].content).toContain('[semantic] Semantic memory');
+      expect(result[0].content).toContain('[procedural] Procedural memory');
+    });
+  });
+
+  describe('기본값 처리', () => {
+    it('should use default token_budget when not provided', async () => {
+      const mockSearchResults = { items: [] };
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      await memoryInjectionPrompt.execute(
+        {
+          query: 'test query'
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      // Should not throw error and use default values
+      expect(mockHybridSearchEngine.search).toHaveBeenCalled();
+    });
+
+    it('should use default max_memories when not provided', async () => {
+      const mockSearchResults = { items: [] };
+      mockHybridSearchEngine.search.mockResolvedValue(mockSearchResults);
+
+      await memoryInjectionPrompt.execute(
+        {
+          query: 'test query',
+          token_budget: 1000
+        },
+        {
+          db,
+          services: { hybridSearchEngine: mockHybridSearchEngine }
+        }
+      );
+
+      expect(mockHybridSearchEngine.search).toHaveBeenCalledWith(
+        db,
+        expect.objectContaining({
+          limit: 5 // default max_memories
+        })
+      );
+    });
+  });
+});

package/src/test/test-performance-alerts.ts

@@ -0,0 +1,125 @@
+/**
+ * 성능 알림 시스템 테스트
+ * 성능 알림 서비스의 기능을 테스트하고 알림을 확인
+ */
+
+import { createMementoClient } from '../client/index.js';
+
+async function testPerformanceAlerts() {
+  console.log('🚨 성능 알림 시스템 테스트 시작');
+  
+  let client;
+  try {
+    // MCP 클라이언트 연결
+    client = createMementoClient();
+    await client.connect();
+    console.log('✅ MCP 클라이언트 연결 완료');
+
+    // 1. 초기 알림 통계 조회
+    console.log('\n📊 초기 알림 통계:');
+    const initialStats = await client.callTool('performance_alerts', { 
+      action: 'stats',
+      hours: 1 
+    });
+    console.log(JSON.stringify(initialStats, null, 2));
+
+    // 2. 활성 알림 조회
+    console.log('\n🔍 활성 알림 조회:');
+    const activeAlerts = await client.callTool('performance_alerts', {
+      action: 'list',
+      hours: 1,
+      limit: 10
+    });
+    console.log(JSON.stringify(activeAlerts, null, 2));
+
+    // 3. 성능 테스트 실행 (알림 트리거용)
+    console.log('\n⚡ 성능 테스트 실행 (알림 트리거):');
+    
+    // 메모리 사용량 증가 시뮬레이션
+    console.log('📝 대량 메모리 작업 실행...');
+    for (let i = 0; i < 50; i++) {
+      await client.remember({
+        content: `성능 테스트용 메모리 ${i} - ${'x'.repeat(1000)}`, // 큰 데이터
+        type: 'episodic',
+        tags: ['performance', 'test', 'alert'],
+        importance: 0.5
+      });
+    }
+
+    // 검색 성능 테스트
+    console.log('🔍 검색 성능 테스트...');
+    for (let i = 0; i < 20; i++) {
+      await client.recall({
+        query: `성능 테스트 ${i}`,
+        limit: 10
+      });
+    }
+
+    // 4. 알림 발생 후 통계 재조회
+    console.log('\n📊 알림 발생 후 통계:');
+    const afterStats = await client.callTool('performance_alerts', {
+      action: 'stats',
+      hours: 1
+    });
+    console.log(JSON.stringify(afterStats, null, 2));
+
+    // 5. 특정 레벨별 알림 조회
+    console.log('\n🔍 WARNING 레벨 알림 조회:');
+    const warningAlerts = await client.callTool('performance_alerts', {
+      action: 'search',
+      level: 'warning',
+      hours: 1,
+      limit: 5
+    });
+    console.log(JSON.stringify(warningAlerts, null, 2));
+
+    // 6. 알림 해결 테스트 (첫 번째 알림 해결)
+    if (afterStats.stats && afterStats.stats.recentAlerts && afterStats.stats.recentAlerts.length > 0) {
+      const firstAlert = afterStats.stats.recentAlerts[0];
+      console.log(`\n🔧 알림 해결 테스트: ${firstAlert.id}`);
+      
+      const resolveResult = await client.callTool('performance_alerts', {
+        action: 'resolve',
+        alertId: firstAlert.id,
+        resolvedBy: 'test_user',
+        resolution: '테스트용 알림 해결'
+      });
+      console.log('해결 결과:', JSON.stringify(resolveResult, null, 2));
+
+      // 7. 해결 후 통계 확인
+      console.log('\n📊 알림 해결 후 통계:');
+      const afterResolveStats = await client.callTool('performance_alerts', {
+        action: 'stats',
+        hours: 1
+      });
+      console.log(JSON.stringify(afterResolveStats, null, 2));
+    }
+
+    // 8. 성능 통계와 비교
+    console.log('\n📈 성능 통계와 비교:');
+    const performanceStats = await client.callTool('performance_stats', {});
+    console.log('성능 통계:', JSON.stringify(performanceStats, null, 2));
+
+    // 9. 에러 통계와 비교
+    console.log('\n🚨 에러 통계와 비교:');
+    const errorStats = await client.callTool('error_stats', { hours: 1 });
+    console.log('에러 통계:', JSON.stringify(errorStats, null, 2));
+
+  } catch (error) {
+    console.error('❌ 테스트 실패:', error);
+  } finally {
+    if (client) {
+      await client.disconnect();
+      console.log('🔌 MCP 클라이언트 연결 해제');
+    }
+  }
+
+  console.log('\n🎉 성능 알림 시스템 테스트 완료');
+}
+
+// 직접 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  testPerformanceAlerts().catch(console.error);
+}
+
+export { testPerformanceAlerts };