memento-mcp-server 0.1.0 → 1.7.1

package/src/test/test-error-handling.spec.ts

@@ -1,575 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
-import { getVectorSearchEngine } from '../algorithms/vector-search-engine.js';
-import { getBatchScheduler } from '../services/batch-scheduler.js';
-import { getPerformanceMonitor } from '../services/performance-monitor.js';
-import { MemoryInjectionPrompt } from '../tools/memory-injection-prompt.js';
-import Database from 'better-sqlite3';
-import { DatabaseUtils } from '../utils/database.js';
-
-// Mock dependencies
-vi.mock('../algorithms/search-engine.js', () => ({
-  SearchEngine: vi.fn().mockImplementation(() => ({
-    search: vi.fn().mockResolvedValue({
-      items: [],
-      total_count: 0,
-      query_time: 0
-    })
-  }))
-}));
-vi.mock('../services/memory-embedding-service.js', () => ({
-  MemoryEmbeddingService: vi.fn().mockImplementation(() => ({
-    isAvailable: vi.fn().mockReturnValue(false),
-    generateEmbedding: vi.fn().mockRejectedValue(new Error('Embedding service unavailable')),
-    searchBySimilarity: vi.fn().mockResolvedValue([]),
-    getEmbeddingStats: vi.fn().mockResolvedValue({})
-  }))
-}));
-vi.mock('../services/forgetting-policy-service.js', () => ({
-  ForgettingPolicyService: vi.fn().mockImplementation(() => ({
-    executeMemoryCleanup: vi.fn().mockRejectedValue(new Error('Forgetting service unavailable'))
-  }))
-}));
-
-describe('Error Handling and Recovery Tests', () => {
-  let db: Database.Database;
-  let hybridSearchEngine: HybridSearchEngine;
-  let vectorSearchEngine: ReturnType<typeof getVectorSearchEngine>;
-  let batchScheduler: ReturnType<typeof getBatchScheduler>;
-  let performanceMonitor: ReturnType<typeof getPerformanceMonitor>;
-  let memoryInjectionPrompt: MemoryInjectionPrompt;
-
-  beforeEach(async () => {
-    // Create in-memory database for testing
-    db = new Database(':memory:');
-    await DatabaseUtils.initializeDatabase(db);
-    
-    // Initialize services
-    hybridSearchEngine = new HybridSearchEngine();
-    vectorSearchEngine = getVectorSearchEngine();
-    vectorSearchEngine.initialize(db);
-    
-    batchScheduler = getBatchScheduler({
-      cleanupInterval: 1000,
-      monitoringInterval: 500,
-      enableLogging: false
-    });
-    
-    performanceMonitor = getPerformanceMonitor();
-    performanceMonitor.initialize(db);
-    
-    memoryInjectionPrompt = new MemoryInjectionPrompt();
-  });
-
-  afterEach(() => {
-    if (db) {
-      db.close();
-    }
-    vi.clearAllMocks();
-  });
-
-  describe('데이터베이스 연결 실패', () => {
-    it('should handle database connection loss gracefully', async () => {
-      // Close database to simulate connection loss
-      db.close();
-      
-      // Hybrid search should handle gracefully - it should not throw but return empty results
-      const result = await hybridSearchEngine.search(db, {
-        query: 'test',
-        limit: 5
-      });
-      
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-      expect(Array.isArray(result.items)).toBe(true);
-    });
-
-    it('should handle database corruption', async () => {
-      // Simulate database corruption by closing and reopening
-      db.close();
-      db = new Database(':memory:');
-      
-      // Should not throw during initialization
-      expect(() => {
-        vectorSearchEngine.initialize(db);
-      }).not.toThrow();
-    });
-
-    it('should handle database timeout', async () => {
-      // Mock slow database operations
-      const originalPrepare = db.prepare;
-      db.prepare = vi.fn().mockImplementation((query: string) => {
-        return {
-          all: vi.fn().mockImplementation(() => {
-            return new Promise((resolve, reject) => {
-              setTimeout(() => reject(new Error('Database timeout')), 100);
-            });
-          })
-        };
-      });
-
-      const results = await vectorSearchEngine.search(Array(1536).fill(0.1));
-      expect(results).toEqual([]);
-      
-      // Restore original
-      db.prepare = originalPrepare;
-    });
-  });
-
-  describe('메모리 부족 상황', () => {
-    it('should handle memory allocation failures', async () => {
-      // Mock memory allocation failure
-      const originalMemoryUsage = process.memoryUsage;
-      process.memoryUsage = vi.fn().mockReturnValue({
-        rss: 0,
-        heapTotal: 1000,
-        heapUsed: 999, // 99.9% usage
-        external: 0,
-        arrayBuffers: 0
-      });
-
-      const metrics = await performanceMonitor.collectMetrics();
-      expect(metrics).toBeDefined();
-      
-      // Should trigger memory alert
-      const alerts = performanceMonitor.getActiveAlerts();
-      const memoryAlert = alerts.find(a => a.type === 'memory');
-      expect(memoryAlert).toBeDefined();
-      
-      // Restore original function
-      process.memoryUsage = originalMemoryUsage;
-    });
-
-    it('should handle large query vectors', async () => {
-      // Test with extremely large vector
-      const largeVector = Array(10000).fill(0.1);
-      
-      const results = await vectorSearchEngine.search(largeVector, {
-        limit: 5
-      });
-      
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should handle memory pressure in batch operations', async () => {
-      await batchScheduler.start(db);
-      
-      // Simulate memory pressure
-      const originalMemoryUsage = process.memoryUsage;
-      process.memoryUsage = vi.fn().mockReturnValue({
-        rss: 0,
-        heapTotal: 1000,
-        heapUsed: 950, // 95% usage
-        external: 0,
-        arrayBuffers: 0
-      });
-
-      const result = await batchScheduler.runJob('monitoring');
-      expect(result.success).toBe(true);
-      
-      // Should collect metrics even under memory pressure
-      expect(result.details?.metrics).toBeDefined();
-      
-      // Restore original function
-      process.memoryUsage = originalMemoryUsage;
-      
-      batchScheduler.stop();
-    });
-  });
-
-  describe('잘못된 입력 데이터', () => {
-    it('should handle invalid search queries', async () => {
-      const invalidQueries = [
-        '', // Empty query
-        null, // Null query
-        undefined, // Undefined query
-        'a'.repeat(10000), // Extremely long query
-        '🚀'.repeat(1000), // Emoji spam
-        '<script>alert("xss")</script>', // XSS attempt
-        'DROP TABLE memory_item;', // SQL injection attempt
-      ];
-
-      for (const query of invalidQueries) {
-        if (query === null || query === undefined) continue;
-        
-        const result = await hybridSearchEngine.search(db, {
-          query: query as string,
-          limit: 5
-        });
-        
-        expect(result).toBeDefined();
-        expect(result.items).toBeDefined();
-        expect(Array.isArray(result.items)).toBe(true);
-      }
-    });
-
-    it('should handle invalid vector dimensions', async () => {
-      const invalidVectors = [
-        [], // Empty vector
-        Array(100).fill(0.1), // Wrong dimensions
-        Array(5000).fill(0.1), // Too large
-        [1, 2, 3, 'invalid', 5], // Mixed types
-        Array(1536).fill(NaN), // NaN values
-        Array(1536).fill(Infinity), // Infinity values
-      ];
-
-      for (const vector of invalidVectors) {
-        const results = await vectorSearchEngine.search(vector as number[]);
-        expect(Array.isArray(results)).toBe(true);
-      }
-    });
-
-    it('should handle invalid memory injection parameters', async () => {
-      const invalidParams = [
-        { query: '', token_budget: -1, max_memories: 0 },
-        { query: 'test', token_budget: 0, max_memories: -1 },
-        { query: 'test', token_budget: 1000000, max_memories: 1000000 },
-        { query: null, token_budget: 1000, max_memories: 5 },
-        { query: 'test', token_budget: 'invalid', max_memories: 5 },
-      ];
-
-      for (const params of invalidParams) {
-        if (params.query === null) continue;
-        
-        try {
-          const result = await memoryInjectionPrompt.execute(
-            params as any,
-            {
-              db,
-              services: { hybridSearchEngine }
-            }
-          );
-          
-          expect(result).toBeDefined();
-        } catch (error) {
-          // Should handle gracefully
-          expect(error).toBeDefined();
-        }
-      }
-    });
-  });
-
-  describe('서비스 간 통신 실패', () => {
-    it('should handle search engine failures', async () => {
-      // Mock search engine failure
-      const mockSearchEngine = {
-        search: vi.fn().mockRejectedValue(new Error('Search engine unavailable'))
-      };
-      
-      // This should be handled by the hybrid search engine
-      const result = await hybridSearchEngine.search(db, {
-        query: 'test',
-        limit: 5
-      });
-      
-      // Should still return results (possibly empty or from fallback)
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-
-    it('should handle embedding service failures', async () => {
-      // Mock embedding service failure
-      const mockEmbeddingService = {
-        isAvailable: vi.fn().mockReturnValue(false),
-        generateEmbedding: vi.fn().mockRejectedValue(new Error('Embedding service unavailable')),
-        searchBySimilarity: vi.fn().mockRejectedValue(new Error('Embedding service unavailable'))
-      };
-
-      // Should fallback gracefully
-      const result = await hybridSearchEngine.search(db, {
-        query: 'test',
-        limit: 5
-      });
-      
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-
-    it('should handle forgetting service failures', async () => {
-      // Mock forgetting service failure
-      const mockForgettingService = {
-        executeMemoryCleanup: vi.fn().mockRejectedValue(new Error('Forgetting service unavailable'))
-      };
-
-      const result = await batchScheduler.runJob('cleanup');
-      
-      expect(result.success).toBe(false);
-      expect(result.errors).toContain('Forgetting service unavailable');
-    });
-
-    it('should handle performance monitor failures', async () => {
-      // Mock performance monitor failure by mocking the actual service
-      const originalCollectMetrics = performanceMonitor.collectMetrics;
-      performanceMonitor.collectMetrics = vi.fn().mockRejectedValue(new Error('Performance monitor unavailable'));
-
-      const result = await batchScheduler.runJob('monitoring');
-      
-      expect(result.success).toBe(false);
-      expect(result.errors).toContain('Performance monitor unavailable');
-      
-      // Restore original method
-      performanceMonitor.collectMetrics = originalCollectMetrics;
-    });
-  });
-
-  describe('리소스 제한 상황', () => {
-    it('should handle CPU overload', async () => {
-      // Mock high CPU usage
-      const originalCpuUsage = process.cpuUsage;
-      process.cpuUsage = vi.fn().mockReturnValue({
-        user: 1000000, // High user time
-        system: 1000000 // High system time
-      });
-
-      const metrics = await performanceMonitor.collectMetrics();
-      expect(metrics).toBeDefined();
-      expect(metrics.cpu.user).toBe(1000000);
-      expect(metrics.cpu.system).toBe(1000000);
-      
-      // Restore original function
-      process.cpuUsage = originalCpuUsage;
-    });
-
-    it('should handle disk space issues', async () => {
-      // Mock large database size
-      const originalPrepare = db.prepare;
-      db.prepare = vi.fn().mockImplementation((query: string) => {
-        if (query.includes('PRAGMA page_count')) {
-          return { get: () => ({ page_count: 10000000 }) }; // Very large DB
-        }
-        if (query.includes('PRAGMA page_size')) {
-          return { get: () => ({ page_size: 4096 }) };
-        }
-        if (query.includes('SELECT COUNT(*)')) {
-          return { get: () => ({ count: 0 }) };
-        }
-        return originalPrepare.call(db, query);
-      });
-
-      const metrics = await performanceMonitor.collectMetrics();
-      expect(metrics).toBeDefined();
-      
-      // Should trigger database size alert
-      const alerts = performanceMonitor.getActiveAlerts();
-      const dbAlert = alerts.find(a => a.type === 'database');
-      expect(dbAlert).toBeDefined();
-      
-      // Restore original function
-      db.prepare = originalPrepare;
-    });
-
-    it('should handle network timeouts', async () => {
-      // Mock network timeout in external services
-      const originalSetTimeout = global.setTimeout;
-      let timeoutErrorThrown = false;
-      
-      global.setTimeout = vi.fn().mockImplementation((callback: any, delay: number) => {
-        if (delay > 1000) {
-          // Simulate timeout by throwing error immediately
-          timeoutErrorThrown = true;
-          throw new Error('Network timeout');
-        }
-        return originalSetTimeout(callback, delay);
-      });
-
-      // Should handle timeouts gracefully
-      try {
-        const result = await hybridSearchEngine.search(db, {
-          query: 'test',
-          limit: 5
-        });
-        
-        // If no error was thrown, the result should be defined
-        expect(result).toBeDefined();
-        expect(result.items).toBeDefined();
-        expect(Array.isArray(result.items)).toBe(true);
-      } catch (error) {
-        // If timeout error was thrown, it should be handled gracefully
-        if (timeoutErrorThrown) {
-          expect(error).toBeDefined();
-          expect(error instanceof Error).toBe(true);
-        } else {
-          // Re-throw unexpected errors
-          throw error;
-        }
-      }
-      
-      // Restore original function
-      global.setTimeout = originalSetTimeout;
-    });
-  });
-
-  describe('동시성 및 경쟁 상태', () => {
-    it('should handle concurrent database access', async () => {
-      const promises = [];
-      
-      // Simulate concurrent database operations
-      for (let i = 0; i < 10; i++) {
-        promises.push(
-          hybridSearchEngine.search(db, {
-            query: `concurrent test ${i}`,
-            limit: 5
-          })
-        );
-      }
-      
-      const results = await Promise.all(promises);
-      
-      expect(results.length).toBe(10);
-      results.forEach(result => {
-        expect(result).toBeDefined();
-        expect(result.items).toBeDefined();
-      });
-    });
-
-    it('should handle scheduler start/stop race conditions', async () => {
-      const promises = [];
-      
-      // Simulate concurrent start/stop operations
-      for (let i = 0; i < 5; i++) {
-        promises.push(batchScheduler.start(db));
-        promises.push(batchScheduler.stop());
-      }
-      
-      // Should handle gracefully
-      await Promise.allSettled(promises);
-      
-      const status = batchScheduler.getStatus();
-      expect(status).toBeDefined();
-    });
-
-    it('should handle memory injection concurrent access', async () => {
-      const promises = [];
-      
-      // Simulate concurrent memory injection - skip this test for now as MemoryInjectionPrompt needs proper setup
-      // This test requires proper mocking of the MemoryInjectionPrompt class
-      expect(true).toBe(true); // Placeholder test
-    });
-  });
-
-  describe('데이터 무결성 및 복구', () => {
-    it('should handle corrupted memory data', async () => {
-      // Insert corrupted data with valid type and importance but invalid date
-      db.prepare(`
-        INSERT INTO memory_item (id, type, content, importance, created_at)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('corrupted1', 'episodic', 'content', 0.5, 'invalid_date');
-      
-      // Should handle gracefully
-      const result = await hybridSearchEngine.search(db, {
-        query: 'test',
-        limit: 5
-      });
-      
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-
-    it('should handle missing required fields', async () => {
-      // Insert incomplete data
-      db.prepare(`
-        INSERT INTO memory_item (id, type, content)
-        VALUES (?, ?, ?)
-      `).run('incomplete1', 'episodic', 'content');
-      
-      // Should handle gracefully
-      const result = await hybridSearchEngine.search(db, {
-        query: 'test',
-        limit: 5
-      });
-      
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-
-    it('should recover from partial failures', async () => {
-      await batchScheduler.start(db);
-      
-      // Simulate partial failure by mocking the forgetting service
-      const originalRunJob = batchScheduler.runJob;
-      let callCount = 0;
-      batchScheduler.runJob = vi.fn().mockImplementation(async (jobType: string) => {
-        callCount++;
-        if (callCount === 1) {
-          return { success: false, errors: ['First call failed'] };
-        }
-        // For second call, return success
-        return { success: true, details: { message: 'Recovery successful' } };
-      });
-      
-      // First call should fail
-      const result1 = await batchScheduler.runJob('cleanup');
-      expect(result1.success).toBe(false);
-      
-      // Second call should succeed
-      const result2 = await batchScheduler.runJob('cleanup');
-      expect(result2.success).toBe(true);
-      
-      // Restore original method
-      batchScheduler.runJob = originalRunJob;
-      
-      batchScheduler.stop();
-    });
-  });
-
-  describe('시스템 한계 및 스트레스 테스트', () => {
-    it('should handle maximum memory limit', async () => {
-      // Test with maximum possible memory count
-      const maxMemories = 10000;
-      
-      for (let i = 0; i < maxMemories; i++) {
-        db.prepare(`
-          INSERT INTO memory_item (id, type, content, importance, created_at)
-          VALUES (?, ?, ?, ?, ?)
-        `).run(`stress_${i}`, 'episodic', `Stress test memory ${i}`, 0.5, new Date().toISOString());
-      }
-      
-      const result = await hybridSearchEngine.search(db, {
-        query: 'stress test',
-        limit: 100
-      });
-      
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-
-    it('should handle extremely long content', async () => {
-      const longContent = 'a'.repeat(100000); // 100KB content
-      
-      db.prepare(`
-        INSERT INTO memory_item (id, type, content, importance, created_at)
-        VALUES (?, ?, ?, ?, ?)
-      `).run('long_content', 'episodic', longContent, 0.5, new Date().toISOString());
-      
-      const result = await hybridSearchEngine.search(db, {
-        query: 'long content',
-        limit: 5
-      });
-      
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-
-    it('should handle rapid successive operations', async () => {
-      const operations = [];
-      
-      // Rapid successive operations
-      for (let i = 0; i < 100; i++) {
-        operations.push(
-          hybridSearchEngine.search(db, {
-            query: `rapid test ${i}`,
-            limit: 1
-          })
-        );
-      }
-      
-      const results = await Promise.all(operations);
-      
-      expect(results.length).toBe(100);
-      results.forEach(result => {
-        expect(result).toBeDefined();
-        expect(result.items).toBeDefined();
-      });
-    });
-  });
-});

package/src/test/test-error-logging.ts

@@ -1,117 +0,0 @@
-/**
- * 에러 로깅 시스템 테스트
- * 에러 로깅 서비스의 기능을 테스트하고 통계를 확인
- */
-
-import { createMementoClient } from '../client/index.js';
-import { ErrorLoggingService, ErrorSeverity, ErrorCategory } from '../services/error-logging-service.js';
-
-async function testErrorLogging() {
-  console.log('🔍 에러 로깅 시스템 테스트 시작');
-  
-  let client;
-  try {
-    // MCP 클라이언트 연결
-    client = createMementoClient();
-    await client.connect();
-    console.log('✅ MCP 클라이언트 연결 완료');
-
-    // 1. 에러 통계 조회 (초기 상태)
-    console.log('\n📊 초기 에러 통계:');
-    const initialStats = await client.callTool('error_stats', { hours: 1 });
-    console.log(JSON.stringify(initialStats, null, 2));
-
-    // 2. 의도적으로 에러 발생시키기 (remember 도구에 잘못된 파라미터)
-    console.log('\n⚠️ 의도적 에러 발생 테스트:');
-    
-    try {
-      await client.remember({
-        content: '', // 빈 내용으로 에러 발생
-        type: 'episodic' as any, // 타입 우회
-        importance: 1.5 // 범위 초과
-      });
-    } catch (error) {
-      console.log('✅ 예상된 에러 발생:', (error as Error).message);
-    }
-
-    try {
-      await client.recall({
-        query: '', // 빈 쿼리로 에러 발생
-        limit: -1 // 잘못된 제한값
-      });
-    } catch (error) {
-      console.log('✅ 예상된 에러 발생:', (error as Error).message);
-    }
-
-    // 3. 에러 통계 재조회
-    console.log('\n📊 에러 발생 후 통계:');
-    const afterErrorStats = await client.callTool('error_stats', { 
-      hours: 1,
-      includeResolved: false,
-      limit: 10
-    });
-    console.log(JSON.stringify(afterErrorStats, null, 2));
-
-    // 4. 특정 심각도별 에러 조회
-    console.log('\n🔍 HIGH 심각도 에러 조회:');
-    const highSeverityStats = await client.callTool('error_stats', {
-      hours: 1,
-      severity: 'high',
-      limit: 5
-    });
-    console.log(JSON.stringify(highSeverityStats, null, 2));
-
-    // 5. 에러 해결 테스트 (첫 번째 에러 해결)
-    if (afterErrorStats.stats && afterErrorStats.stats.filteredErrors && afterErrorStats.stats.filteredErrors.length > 0) {
-      const firstError = afterErrorStats.stats.filteredErrors[0];
-      console.log(`\n🔧 에러 해결 테스트: ${firstError.id}`);
-      
-      const resolveResult = await client.callTool('resolve_error', {
-        errorId: firstError.id,
-        resolvedBy: 'test_user',
-        reason: '테스트용 에러 해결'
-      });
-      console.log('해결 결과:', JSON.stringify(resolveResult, null, 2));
-
-      // 6. 해결 후 통계 확인
-      console.log('\n📊 에러 해결 후 통계:');
-      const afterResolveStats = await client.callTool('error_stats', {
-        hours: 1,
-        includeResolved: true,
-        limit: 10
-      });
-      console.log(JSON.stringify(afterResolveStats, null, 2));
-    }
-
-    // 7. 활성 알림 확인
-    console.log('\n🚨 활성 알림 확인:');
-    const alertStats = await client.callTool('error_stats', { hours: 1 });
-    if (alertStats.alerts && alertStats.alerts.length > 0) {
-      console.log('활성 알림:', JSON.stringify(alertStats.alerts, null, 2));
-    } else {
-      console.log('활성 알림 없음');
-    }
-
-    // 8. 성능 통계와 비교
-    console.log('\n📈 성능 통계와 비교:');
-    const performanceStats = await client.callTool('performance_stats', {});
-    console.log('성능 통계:', JSON.stringify(performanceStats, 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]}`) {
-  testErrorLogging().catch(console.error);
-}
-
-export { testErrorLogging };