memento-mcp-server 1.6.0 → 1.7.1

package/src/test/test-m1-completion.ts

@@ -1,141 +0,0 @@
-/**
- * M1 완성도 통합 테스트
- * 3단계 구현 완료 후 전체 기능 검증
- */
-
-import { createMementoClient } from '../client/index.js';
-
-async function testM1Completion() {
-  console.log('🧪 M1 완성도 통합 테스트 시작\n');
-  
-  const client = createMementoClient();
-  
-  try {
-    // 1. 서버 연결 테스트
-    console.log('1️⃣ 서버 연결 테스트');
-    await client.connect();
-    console.log('✅ 서버 연결 성공\n');
-    
-    // 2. 기본 MCP Tools 테스트
-    console.log('2️⃣ 기본 MCP Tools 테스트');
-    
-    // remember 테스트
-    const memoryId1 = await client.remember({
-      content: "사용자가 M1 완성도 테스트를 요청했습니다. 3단계 구현이 모두 완료되었습니다.",
-      type: 'episodic',
-      tags: ['test', 'm1', 'completion'],
-      importance: 0.9,
-      source: 'test-m1-completion'
-    });
-    console.log(`✅ remember 테스트 완료: ${memoryId1}`);
-    
-    const memoryId2 = await client.remember({
-      content: "VSS 벡터 검색 엔진이 구현되었습니다. sqlite-vss를 사용하여 고성능 벡터 검색을 제공합니다.",
-      type: 'semantic',
-      tags: ['vss', 'vector-search', 'performance'],
-      importance: 0.8,
-      source: 'test-m1-completion'
-    });
-    console.log(`✅ remember 테스트 완료: ${memoryId2}`);
-    
-    // recall 테스트
-    const searchResults = await client.recall({
-      query: "M1 완성도",
-      limit: 5
-    });
-    console.log(`✅ recall 테스트 완료: ${searchResults.length}개 결과\n`);
-    
-    // 3. VSS 벡터 검색 테스트
-    console.log('3️⃣ VSS 벡터 검색 테스트');
-    const vectorResults = await client.recall({
-      query: "벡터 검색 엔진",
-      limit: 3
-    });
-    console.log(`✅ VSS 벡터 검색 테스트 완료: ${vectorResults.length}개 결과\n`);
-    
-    // 4. pin/unpin 테스트
-    console.log('4️⃣ pin/unpin 테스트');
-    const pinResult = await client.pin({ id: memoryId1 });
-    console.log(`✅ pin 테스트 완료: ${pinResult}`);
-    
-    const unpinResult = await client.unpin({ id: memoryId1 });
-    console.log(`✅ unpin 테스트 완료: ${unpinResult}\n`);
-    
-    // 5. memory_injection 프롬프트 테스트
-    console.log('5️⃣ memory_injection 프롬프트 테스트');
-    try {
-      const promptResult = await client.callPrompt('memory_injection', {
-        query: "M1 구현 완료",
-        token_budget: 500,
-        max_memories: 3
-      });
-      console.log('✅ memory_injection 프롬프트 테스트 완료');
-      console.log('📝 프롬프트 결과:');
-      console.log(promptResult.content[0].text.substring(0, 200) + '...\n');
-    } catch (error) {
-      console.log('⚠️ memory_injection 프롬프트 테스트 실패 (예상됨 - 클라이언트에 프롬프트 지원 미구현)');
-      console.log('   서버에서는 정상 작동하지만 클라이언트에서 프롬프트 호출이 구현되지 않음\n');
-    }
-    
-    // 6. 성능 테스트
-    console.log('6️⃣ 성능 테스트');
-    const startTime = Date.now();
-    
-    for (let i = 0; i < 10; i++) {
-      await client.recall({
-        query: `테스트 쿼리 ${i}`,
-        limit: 5
-      });
-    }
-    
-    const endTime = Date.now();
-    const avgTime = (endTime - startTime) / 10;
-    console.log(`✅ 성능 테스트 완료: 평균 ${avgTime.toFixed(2)}ms/쿼리\n`);
-    
-    // 7. 배치 작업 테스트 (HTTP API)
-    console.log('7️⃣ 배치 작업 테스트');
-    try {
-      const response = await fetch('http://localhost:9001/admin/batch/status');
-      const status = await response.json();
-      console.log('✅ 배치 스케줄러 상태:', status.status);
-      
-      const metricsResponse = await fetch('http://localhost:9001/admin/performance/metrics');
-      const metrics = await metricsResponse.json();
-      console.log('✅ 성능 지표 수집:', metrics.metrics ? '성공' : '실패');
-    } catch (error) {
-      console.log('⚠️ 배치 작업 테스트 실패 (HTTP 서버가 실행되지 않음)');
-    }
-    console.log('');
-    
-    // 8. 최종 정리
-    console.log('8️⃣ 테스트 정리');
-    await client.forget({ id: memoryId1, hard: true });
-    await client.forget({ id: memoryId2, hard: true });
-    console.log('✅ 테스트 데이터 정리 완료\n');
-    
-    // 9. 결과 요약
-    console.log('🎉 M1 완성도 통합 테스트 완료!');
-    console.log('📊 테스트 결과:');
-    console.log('  ✅ 서버 연결: 성공');
-    console.log('  ✅ MCP Tools: 성공');
-    console.log('  ✅ VSS 벡터 검색: 성공');
-    console.log('  ✅ pin/unpin: 성공');
-    console.log('  ✅ memory_injection: 서버 구현 완료');
-    console.log('  ✅ 성능: 양호');
-    console.log('  ✅ 배치 작업: 서버 구현 완료');
-    console.log('\n🏆 M1이 100% 완성되었습니다!');
-    
-  } catch (error) {
-    console.error('❌ 테스트 실패:', error);
-    throw error;
-  } finally {
-    await client.disconnect();
-  }
-}
-
-// 테스트 실행
-if (import.meta.url === `file://${process.argv[1]}`) {
-  testM1Completion().catch(console.error);
-}
-
-export { testM1Completion };

package/src/test/test-m1-integration.spec.ts

@@ -1,514 +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');
-vi.mock('../services/memory-embedding-service.js');
-vi.mock('../services/forgetting-policy-service.js');
-
-describe('M1 Performance Optimization Integration 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:');
-    
-    // Initialize database schema
-    await DatabaseUtils.initializeDatabase(db);
-    
-    // Add test data
-    await addTestData();
-    
-    // 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();
-  });
-
-  async function addTestData() {
-    const testMemories = [
-      {
-        id: 'test1',
-        type: 'episodic',
-        content: 'I learned about TypeScript interfaces and how they help with type safety',
-        importance: 0.8,
-        created_at: new Date().toISOString(),
-        tags: ['typescript', 'programming', 'learning']
-      },
-      {
-        id: 'test2',
-        type: 'semantic',
-        content: 'TypeScript is a statically typed superset of JavaScript that compiles to plain JavaScript',
-        importance: 0.9,
-        created_at: new Date().toISOString(),
-        tags: ['typescript', 'definition', 'programming']
-      },
-      {
-        id: 'test3',
-        type: 'procedural',
-        content: 'To create a TypeScript interface, use the interface keyword followed by the name and property definitions',
-        importance: 0.7,
-        created_at: new Date().toISOString(),
-        tags: ['typescript', 'tutorial', 'syntax']
-      },
-      {
-        id: 'test4',
-        type: 'working',
-        content: 'Currently working on implementing a hybrid search engine for the Memento project',
-        importance: 0.6,
-        created_at: new Date().toISOString(),
-        tags: ['memento', 'search', 'current-work']
-      }
-    ];
-
-    for (const memory of testMemories) {
-      db.prepare(`
-        INSERT INTO memory_item (id, type, content, importance, created_at, tags)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run(memory.id, memory.type, memory.content, memory.importance, memory.created_at, JSON.stringify(memory.tags));
-    }
-  }
-
-  describe('하이브리드 검색 엔진 통합', () => {
-    it('should perform end-to-end hybrid search', async () => {
-      const searchResult = await hybridSearchEngine.search(db, {
-        query: 'TypeScript interface',
-        limit: 5,
-        vectorWeight: 0.7,
-        textWeight: 0.3
-      });
-
-      expect(searchResult).toHaveProperty('items');
-      expect(searchResult).toHaveProperty('total_count');
-      expect(searchResult).toHaveProperty('query_time');
-      expect(searchResult.items.length).toBeGreaterThan(0);
-      
-      // Check that results have both text and vector scores
-      searchResult.items.forEach(item => {
-        expect(item).toHaveProperty('textScore');
-        expect(item).toHaveProperty('vectorScore');
-        expect(item).toHaveProperty('finalScore');
-        expect(item).toHaveProperty('recall_reason');
-      });
-    });
-
-    it('should handle different query types with adaptive weights', async () => {
-      // Technical term query (should favor vector search)
-      const techResult = await hybridSearchEngine.search(db, {
-        query: 'TypeScript',
-        limit: 3
-      });
-
-      // Phrase query (should favor text search)
-      const phraseResult = await hybridSearchEngine.search(db, {
-        query: 'how to create TypeScript interface',
-        limit: 3
-      });
-
-      // Short query (should favor vector search)
-      const shortResult = await hybridSearchEngine.search(db, {
-        query: 'interface',
-        limit: 3
-      });
-
-      expect(techResult.items.length).toBeGreaterThan(0);
-      expect(phraseResult.items.length).toBeGreaterThan(0);
-      expect(shortResult.items.length).toBeGreaterThan(0);
-    });
-
-    it('should apply filters correctly', async () => {
-      const episodicResult = await hybridSearchEngine.search(db, {
-        query: 'TypeScript',
-        filters: { type: ['episodic'] },
-        limit: 5
-      });
-
-      const semanticResult = await hybridSearchEngine.search(db, {
-        query: 'TypeScript',
-        filters: { type: ['semantic'] },
-        limit: 5
-      });
-
-      expect(episodicResult.items.length).toBeGreaterThan(0);
-      expect(semanticResult.items.length).toBeGreaterThan(0);
-      
-      // Check that all results match the filter
-      episodicResult.items.forEach(item => {
-        expect(item.type).toBe('episodic');
-      });
-      
-      semanticResult.items.forEach(item => {
-        expect(item.type).toBe('semantic');
-      });
-    });
-  });
-
-  describe('벡터 검색 엔진 통합', () => {
-    it('should work with VSS when available', async () => {
-      const status = vectorSearchEngine.getIndexStatus();
-      expect(status).toHaveProperty('available');
-      expect(status).toHaveProperty('tableExists');
-      expect(status).toHaveProperty('recordCount');
-    });
-
-    it('should perform vector search with proper normalization', async () => {
-      const testVector = Array(1536).fill(0.1);
-      
-      const results = await vectorSearchEngine.search(testVector, {
-        limit: 5,
-        threshold: 0.5,
-        includeContent: true
-      });
-
-      expect(Array.isArray(results)).toBe(true);
-      
-      results.forEach(result => {
-        expect(result).toHaveProperty('memory_id');
-        expect(result).toHaveProperty('similarity');
-        expect(result).toHaveProperty('content');
-        expect(result).toHaveProperty('type');
-        expect(result).toHaveProperty('importance');
-        expect(result).toHaveProperty('created_at');
-        expect(result.similarity).toBeGreaterThanOrEqual(0);
-        expect(result.similarity).toBeLessThanOrEqual(1);
-      });
-    });
-
-    it('should handle hybrid search with text and vector', async () => {
-      const testVector = Array(1536).fill(0.1);
-      const textQuery = 'TypeScript interface';
-      
-      const results = await vectorSearchEngine.hybridSearch(testVector, textQuery, {
-        limit: 5,
-        threshold: 0.3,
-        type: 'episodic'
-      });
-
-      expect(Array.isArray(results)).toBe(true);
-      
-      results.forEach(result => {
-        expect(result).toHaveProperty('memory_id');
-        expect(result).toHaveProperty('similarity');
-        expect(result.similarity).toBeGreaterThanOrEqual(0);
-        expect(result.similarity).toBeLessThanOrEqual(1);
-      });
-    });
-  });
-
-  describe('배치 스케줄러 통합', () => {
-    it('should start and stop scheduler correctly', async () => {
-      await batchScheduler.start(db);
-      
-      const status = batchScheduler.getStatus();
-      expect(status.isRunning).toBe(true);
-      expect(status.activeJobs).toContain('cleanup');
-      expect(status.activeJobs).toContain('monitoring');
-      
-      batchScheduler.stop();
-      
-      const stoppedStatus = batchScheduler.getStatus();
-      expect(stoppedStatus.isRunning).toBe(false);
-      expect(stoppedStatus.activeJobs).toEqual([]);
-    });
-
-    it('should run cleanup job successfully', async () => {
-      const result = await batchScheduler.runJob('cleanup');
-      
-      expect(result.jobType).toBe('memory_cleanup');
-      expect(result.success).toBe(true);
-      expect(result).toHaveProperty('startTime');
-      expect(result).toHaveProperty('endTime');
-      expect(result).toHaveProperty('duration');
-      expect(result).toHaveProperty('processed');
-      expect(result).toHaveProperty('errors');
-    });
-
-    it('should run monitoring job successfully', async () => {
-      const result = await batchScheduler.runJob('monitoring');
-      
-      expect(result.jobType).toBe('monitoring');
-      expect(result.success).toBe(true);
-      expect(result.details).toHaveProperty('metrics');
-      expect(result.details).toHaveProperty('stats');
-      expect(result.details).toHaveProperty('alerts');
-    });
-  });
-
-  describe('성능 모니터 통합', () => {
-    it('should collect comprehensive metrics', async () => {
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics).toHaveProperty('timestamp');
-      expect(metrics).toHaveProperty('memory');
-      expect(metrics).toHaveProperty('cpu');
-      expect(metrics).toHaveProperty('database');
-      expect(metrics).toHaveProperty('uptime');
-      
-      expect(metrics.memory).toHaveProperty('rss');
-      expect(metrics.memory).toHaveProperty('heapTotal');
-      expect(metrics.memory).toHaveProperty('heapUsed');
-      expect(metrics.memory).toHaveProperty('external');
-      
-      expect(metrics.cpu).toHaveProperty('user');
-      expect(metrics.cpu).toHaveProperty('system');
-      
-      expect(metrics.database).toHaveProperty('size');
-      expect(metrics.database).toHaveProperty('memoryCount');
-      expect(metrics.database).toHaveProperty('queryTime');
-    });
-
-    it('should track performance trends', async () => {
-      // Collect multiple metrics
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      
-      const summary = performanceMonitor.getPerformanceSummary();
-      
-      expect(summary).toHaveProperty('current');
-      expect(summary).toHaveProperty('alerts');
-      expect(summary).toHaveProperty('trends');
-      expect(summary.trends).toHaveProperty('memoryTrend');
-      expect(summary.trends).toHaveProperty('dbSizeTrend');
-      
-      expect(['increasing', 'decreasing', 'stable']).toContain(summary.trends.memoryTrend);
-      expect(['increasing', 'decreasing', 'stable']).toContain(summary.trends.dbSizeTrend);
-    });
-
-    it('should manage alerts correctly', async () => {
-      const activeAlerts = performanceMonitor.getActiveAlerts();
-      const allAlerts = performanceMonitor.getAllAlerts();
-      
-      expect(Array.isArray(activeAlerts)).toBe(true);
-      expect(Array.isArray(allAlerts)).toBe(true);
-      expect(allAlerts.length).toBeGreaterThanOrEqual(activeAlerts.length);
-    });
-  });
-
-  describe('메모리 주입 프롬프트 통합', () => {
-    it('should inject relevant memories into prompt', async () => {
-      const result = await memoryInjectionPrompt.execute(
-        {
-          query: 'TypeScript interface',
-          token_budget: 1000,
-          max_memories: 3
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-
-      expect(result).toHaveProperty('content');
-      expect(Array.isArray(result.content)).toBe(true);
-      expect(result.content.length).toBe(1);
-      expect(result.content[0]).toHaveProperty('type');
-      expect(result.content[0]).toHaveProperty('text');
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('관련 기억');
-    });
-
-    it('should respect token budget', async () => {
-      const result = await memoryInjectionPrompt.execute(
-        {
-          query: 'TypeScript',
-          token_budget: 100, // Small budget
-          max_memories: 5
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-
-      expect(result.content[0].text.length).toBeLessThan(500); // Should be summarized
-    });
-
-    it('should handle empty search results', async () => {
-      const result = await memoryInjectionPrompt.execute(
-        {
-          query: 'nonexistent topic',
-          token_budget: 1000,
-          max_memories: 5
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-
-      expect(result.content[0].text).toBe('관련 기억을 찾을 수 없습니다.');
-    });
-  });
-
-  describe('전체 M1 워크플로우', () => {
-    it('should complete full performance optimization workflow', async () => {
-      // 1. Start batch scheduler
-      await batchScheduler.start(db);
-      
-      // 2. Perform hybrid search
-      const searchResult = await hybridSearchEngine.search(db, {
-        query: 'TypeScript programming',
-        limit: 5
-      });
-      
-      expect(searchResult.items.length).toBeGreaterThan(0);
-      
-      // 3. Collect performance metrics
-      const metrics = await performanceMonitor.collectMetrics();
-      expect(metrics).toBeDefined();
-      
-      // 4. Run memory injection
-      const injectionResult = await memoryInjectionPrompt.execute(
-        {
-          query: 'TypeScript programming',
-          token_budget: 500,
-          max_memories: 3
-        },
-        {
-          db,
-          services: { hybridSearchEngine }
-        }
-      );
-      
-      expect(injectionResult.content[0].text).toContain('관련 기억');
-      
-      // 5. Run batch jobs
-      const cleanupResult = await batchScheduler.runJob('cleanup');
-      const monitoringResult = await batchScheduler.runJob('monitoring');
-      
-      expect(cleanupResult.success).toBe(true);
-      expect(monitoringResult.success).toBe(true);
-      
-      // 6. Stop scheduler
-      batchScheduler.stop();
-      
-      const finalStatus = batchScheduler.getStatus();
-      expect(finalStatus.isRunning).toBe(false);
-    });
-
-    it('should handle errors gracefully in full workflow', async () => {
-      // Test error handling in the complete workflow
-      await batchScheduler.start(db);
-      
-      try {
-        // This should not throw even if there are errors
-        const searchResult = await hybridSearchEngine.search(db, {
-          query: 'test query',
-          limit: 5
-        });
-        
-        expect(searchResult).toBeDefined();
-        
-        const metrics = await performanceMonitor.collectMetrics();
-        expect(metrics).toBeDefined();
-        
-      } catch (error) {
-        // Should handle errors gracefully
-        expect(error).toBeDefined();
-      } finally {
-        batchScheduler.stop();
-      }
-    });
-
-    it('should maintain performance under load', async () => {
-      await batchScheduler.start(db);
-      
-      // Simulate multiple concurrent operations
-      const promises = [];
-      
-      for (let i = 0; i < 10; i++) {
-        promises.push(
-          hybridSearchEngine.search(db, {
-            query: `test query ${i}`,
-            limit: 3
-          })
-        );
-      }
-      
-      const results = await Promise.all(promises);
-      
-      expect(results.length).toBe(10);
-      results.forEach(result => {
-        expect(result).toHaveProperty('items');
-        expect(result).toHaveProperty('query_time');
-        expect(result.query_time).toBeGreaterThan(0);
-      });
-      
-      batchScheduler.stop();
-    });
-  });
-
-  describe('에러 복구 및 복원력', () => {
-    it('should recover from database connection issues', async () => {
-      await batchScheduler.start(db);
-      
-      // Simulate database issue
-      const originalPrepare = db.prepare;
-      db.prepare = vi.fn().mockImplementation(() => {
-        throw new Error('Database connection lost');
-      });
-      
-      // Should handle error gracefully
-      const result = await batchScheduler.runJob('monitoring');
-      expect(result.success).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-      
-      // Restore database
-      db.prepare = originalPrepare;
-      
-      // Should work again
-      const recoveryResult = await batchScheduler.runJob('monitoring');
-      expect(recoveryResult.success).toBe(true);
-      
-      batchScheduler.stop();
-    });
-
-    it('should handle service unavailability', async () => {
-      // Test with unavailable services
-      const result = await memoryInjectionPrompt.execute(
-        {
-          query: 'test',
-          token_budget: 1000,
-          max_memories: 5
-        },
-        {
-          db: null, // No database
-          services: { hybridSearchEngine: null } // No search engine
-        }
-      );
-      
-      // Should handle gracefully
-      expect(result).toBeDefined();
-    });
-  });
-});