memento-mcp-server 1.6.0 → 1.7.2

package/src/test/test-search.ts

@@ -1,151 +0,0 @@
-/**
- * 검색 기능 상세 테스트
- */
-
-import { createMementoClient } from '../client/index.js';
-
-async function testSearchFunctionality() {
-  console.log('🔍 검색 기능 상세 테스트 시작');
-  
-  const client = createMementoClient();
-  
-  try {
-    // 1. 서버 연결
-    console.log('\n1️⃣ 서버 연결 중...');
-    await client.connect();
-    
-    // 2. 다양한 기억 저장
-    console.log('\n2️⃣ 다양한 기억 저장');
-    const memories = [
-      {
-        content: "React Hook에 대해 설명했다. useState는 상태를 관리하고, useEffect는 사이드 이펙트를 처리한다.",
-        type: 'episodic' as const,
-        tags: ['react', 'hooks', 'javascript'],
-        importance: 0.8
-      },
-      {
-        content: "TypeScript의 타입 시스템에 대해 설명했다. 인터페이스와 타입 별칭의 차이점을 다뤘다.",
-        type: 'semantic' as const,
-        tags: ['typescript', 'types', 'programming'],
-        importance: 0.9
-      },
-      {
-        content: "데이터베이스 최적화에 대해 질문받았다. 인덱싱과 쿼리 최적화 방법을 설명했다.",
-        type: 'episodic' as const,
-        tags: ['database', 'optimization', 'sql'],
-        importance: 0.7
-      },
-      {
-        content: "MCP 프로토콜에 대해 학습했다. Model Context Protocol은 AI 에이전트와 도구 간 통신을 위한 표준이다.",
-        type: 'semantic' as const,
-        tags: ['mcp', 'protocol', 'ai'],
-        importance: 0.85
-      }
-    ];
-    
-    const memoryIds: string[] = [];
-    for (const memory of memories) {
-      const id = await client.remember(memory);
-      memoryIds.push(id);
-      console.log(`✅ 저장됨: ${id.substring(0, 20)}... - ${memory.content.substring(0, 30)}...`);
-    }
-    
-    // 3. 다양한 검색 테스트
-    console.log('\n3️⃣ 다양한 검색 테스트');
-    
-    const searchQueries = [
-      { query: "React", description: "React 관련 검색" },
-      { query: "TypeScript", description: "TypeScript 관련 검색" },
-      { query: "데이터베이스", description: "데이터베이스 관련 검색" },
-      { query: "MCP", description: "MCP 관련 검색" },
-      { query: "Hook", description: "Hook 관련 검색" },
-      { query: "타입", description: "타입 관련 검색" }
-    ];
-    
-    for (const { query, description } of searchQueries) {
-      console.log(`\n🔍 ${description}: "${query}"`);
-      try {
-        const results = await client.recall({ query, limit: 5 });
-        console.log(`   결과: ${results.length}개`);
-        results.forEach((result, index) => {
-          console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 50)}... (점수: ${result.score || 'N/A'})`);
-        });
-      } catch (error) {
-        console.error(`   ❌ 검색 실패: ${error}`);
-      }
-    }
-    
-    // 4. 필터 검색 테스트
-    console.log('\n4️⃣ 필터 검색 테스트');
-    
-    console.log('\n🔍 episodic 타입만 검색:');
-    try {
-      const episodicResults = await client.recall({
-        query: "설명",
-        filters: { type: ['episodic'] },
-        limit: 5
-      });
-      console.log(`   결과: ${episodicResults.length}개`);
-      episodicResults.forEach((result, index) => {
-        console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 50)}...`);
-      });
-    } catch (error) {
-      console.error(`   ❌ 필터 검색 실패: ${error}`);
-    }
-    
-    console.log('\n🔍 semantic 타입만 검색:');
-    try {
-      const semanticResults = await client.recall({
-        query: "학습",
-        filters: { type: ['semantic'] },
-        limit: 5
-      });
-      console.log(`   결과: ${semanticResults.length}개`);
-      semanticResults.forEach((result, index) => {
-        console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 50)}...`);
-      });
-    } catch (error) {
-      console.error(`   ❌ 필터 검색 실패: ${error}`);
-    }
-    
-    // 5. 태그 검색 테스트
-    console.log('\n5️⃣ 태그 검색 테스트');
-    
-    const tagQueries = ['react', 'typescript', 'database', 'mcp'];
-    for (const tag of tagQueries) {
-      console.log(`\n🔍 "${tag}" 태그 검색:`);
-      try {
-        const results = await client.recall({
-          query: tag,
-          limit: 5
-        });
-        console.log(`   결과: ${results.length}개`);
-        results.forEach((result, index) => {
-          console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 50)}... (태그: ${result.tags?.join(', ') || '없음'})`);
-        });
-      } catch (error) {
-        console.error(`   ❌ 태그 검색 실패: ${error}`);
-      }
-    }
-    
-    console.log('\n🎉 검색 기능 테스트 완료!');
-    
-  } catch (error) {
-    console.error('❌ 테스트 실패:', error);
-  } finally {
-    await client.disconnect();
-  }
-}
-
-// 테스트 실행
-if (process.argv[1] && process.argv[1].endsWith('test-search.ts')) {
-  testSearchFunctionality()
-    .then(() => {
-      console.log('✅ 검색 테스트 완료');
-      process.exit(0);
-    })
-    .catch((error) => {
-      console.error('❌ 검색 테스트 실패:', error);
-      process.exit(1);
-    });
-}

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

@@ -1,136 +0,0 @@
-/**
- * 간단한 성능 알림 테스트
- * console.log 차단을 우회하여 테스트
- */
-
-import { PerformanceAlertService, AlertType, AlertLevel } from '../services/performance-alert-service.js';
-
-// console.log 복원
-const originalLog = console.log;
-const originalError = console.error;
-
-function testSimpleAlerts() {
-  // console 메서드 복원
-  console.log = originalLog;
-  console.error = originalError;
-  
-  console.log('🚨 간단한 성능 알림 테스트 시작');
-  
-  try {
-    // 성능 알림 서비스 생성
-    const alertService = new PerformanceAlertService('./logs');
-    
-    console.log('✅ 성능 알림 서비스 생성 완료');
-
-    // 1. 응답시간 알림 테스트
-    console.log('\n📊 응답시간 알림 테스트:');
-    const responseTimeAlerts = alertService.checkPerformanceMetric(
-      AlertType.RESPONSE_TIME,
-      150, // WARNING 임계값(100ms) 초과
-      { component: 'search_engine', operation: 'search' }
-    );
-    console.log(`생성된 알림 수: ${responseTimeAlerts.length}`);
-
-    // 2. 메모리 사용량 알림 테스트
-    console.log('\n📊 메모리 사용량 알림 테스트:');
-    const memoryAlerts = alertService.checkPerformanceMetric(
-      AlertType.MEMORY_USAGE,
-      150, // WARNING 임계값(100MB) 초과
-      { component: 'memory_manager', heapTotal: 200 }
-    );
-    console.log(`생성된 알림 수: ${memoryAlerts.length}`);
-
-    // 3. 에러율 알림 테스트
-    console.log('\n📊 에러율 알림 테스트:');
-    const errorRateAlerts = alertService.checkPerformanceMetric(
-      AlertType.ERROR_RATE,
-      7, // WARNING 임계값(5%) 초과
-      { component: 'system', totalOperations: 100 }
-    );
-    console.log(`생성된 알림 수: ${errorRateAlerts.length}`);
-
-    // 4. 알림 통계 조회
-    console.log('\n📈 알림 통계:');
-    const stats = alertService.getAlertStats(1);
-    console.log(`총 알림 수: ${stats.totalAlerts}`);
-    console.log(`활성 알림 수: ${stats.activeAlerts}`);
-    console.log(`WARNING 알림: ${stats.alertsByLevel.warning}`);
-    console.log(`CRITICAL 알림: ${stats.alertsByLevel.critical}`);
-
-    // 5. 활성 알림 조회
-    console.log('\n🔍 활성 알림:');
-    const activeAlerts = alertService.getActiveAlerts();
-    console.log(`활성 알림 수: ${activeAlerts.length}`);
-    
-    activeAlerts.forEach((alert, index) => {
-      console.log(`${index + 1}. [${alert.level.toUpperCase()}] ${alert.metric}: ${alert.value} (임계값: ${alert.threshold})`);
-      console.log(`   메시지: ${alert.message}`);
-      console.log(`   시간: ${alert.timestamp.toISOString()}`);
-    });
-
-    // 6. 알림 해결 테스트
-    if (activeAlerts.length > 0) {
-      const firstAlert = activeAlerts[0];
-      if (firstAlert) {
-        console.log(`\n🔧 알림 해결 테스트: ${firstAlert.id}`);
-        
-        const resolved = alertService.resolveAlert(
-          firstAlert.id,
-          'test_user',
-          '테스트용 해결'
-        );
-        
-        if (resolved) {
-          console.log('✅ 알림 해결 성공');
-        } else {
-          console.log('❌ 알림 해결 실패');
-        }
-      }
-    }
-
-    // 7. 해결 후 통계
-    console.log('\n📊 해결 후 통계:');
-    const finalStats = alertService.getAlertStats(1);
-    console.log(`총 알림 수: ${finalStats.totalAlerts}`);
-    console.log(`활성 알림 수: ${finalStats.activeAlerts}`);
-    console.log(`해결된 알림 수: ${finalStats.totalAlerts - finalStats.activeAlerts}`);
-
-    // 8. 로그 파일 확인
-    console.log('\n📁 로그 파일 확인:');
-    const fs = require('fs');
-    const logDir = './logs';
-    if (fs.existsSync(logDir)) {
-      const files = fs.readdirSync(logDir);
-      console.log(`로그 파일 수: ${files.length}`);
-      files.forEach((file: string) => {
-        const filePath = `${logDir}/${file}`;
-        const content = fs.readFileSync(filePath, 'utf8');
-        const lines = content.trim().split('\n');
-        console.log(`- ${file}: ${lines.length}개 알림 로그`);
-        
-        // 첫 번째 로그 내용 출력
-        if (lines.length > 0) {
-          try {
-            const firstLog = JSON.parse(lines[0]);
-            console.log(`  첫 번째 로그: ${firstLog.level} - ${firstLog.message}`);
-          } catch (e) {
-            console.log(`  첫 번째 로그: ${lines[0]}`);
-          }
-        }
-      });
-    } else {
-      console.log('❌ 로그 디렉토리가 존재하지 않습니다.');
-    }
-
-    // 정리
-    alertService.cleanup();
-    
-    console.log('\n🎉 간단한 성능 알림 테스트 완료');
-    
-  } catch (error) {
-    console.error('❌ 테스트 실패:', error);
-  }
-}
-
-// 직접 실행
-testSimpleAlerts();

package/src/test/test-vector-search-engine.spec.ts

@@ -1,408 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { getVectorSearchEngine, VectorSearchEngine, resetVectorSearchEngine } from '../algorithms/vector-search-engine.js';
-
-describe('VectorSearchEngine', () => {
-  let vectorSearchEngine: VectorSearchEngine;
-  
-  // Test data
-  const testQueryVector = new Array(1536).fill(0.1);
-  const testTextQuery = 'test query';
-  const mockSearchResults = [
-    { 
-      memory_id: '1', 
-      similarity: 0.9, 
-      content: 'test content 1', 
-      type: 'episodic', 
-      importance: 0.8,
-      created_at: '2024-01-01T00:00:00Z',
-      last_accessed: '2024-01-02T00:00:00Z',
-      pinned: false,
-      tags: '["test", "example"]'
-    },
-    { 
-      memory_id: '2', 
-      similarity: 0.8, 
-      content: 'test content 2', 
-      type: 'semantic', 
-      importance: 0.7,
-      created_at: '2024-01-02T00:00:00Z',
-      last_accessed: '2024-01-03T00:00:00Z',
-      pinned: true,
-      tags: '["test", "demo"]'
-    },
-    { 
-      memory_id: '3', 
-      similarity: 0.7, 
-      content: 'test content 3', 
-      type: 'procedural', 
-      importance: 0.6,
-      created_at: '2024-01-03T00:00:00Z',
-      last_accessed: '2024-01-04T00:00:00Z',
-      pinned: false,
-      tags: null
-    }
-  ];
-
-  beforeEach(() => {
-    // Reset singleton instance
-    resetVectorSearchEngine();
-    
-    vectorSearchEngine = getVectorSearchEngine();
-    
-    // Mock VEC availability for all tests
-    vi.spyOn(vectorSearchEngine as any, 'checkVecAvailability').mockImplementation(() => {
-      (vectorSearchEngine as any).isVecAvailable = true;
-      (vectorSearchEngine as any).vecExtensionLoaded = true;
-    });
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('초기화', () => {
-    it('should initialize successfully', () => {
-      expect(() => vectorSearchEngine.initialize({} as any)).not.toThrow();
-    });
-
-    it('should check VEC availability', () => {
-      const status = vectorSearchEngine.getIndexStatus();
-      expect(status).toHaveProperty('available');
-      expect(status).toHaveProperty('tableExists');
-      expect(status).toHaveProperty('recordCount');
-      expect(status).toHaveProperty('dimensions');
-      expect(status).toHaveProperty('vecExtensionLoaded');
-      expect(typeof status.available).toBe('boolean');
-      expect(typeof status.tableExists).toBe('boolean');
-      expect(typeof status.recordCount).toBe('number');
-      expect(typeof status.dimensions).toBe('number');
-      expect(typeof status.vecExtensionLoaded).toBe('boolean');
-    });
-
-    it('should return correct dimensions', () => {
-      const status = vectorSearchEngine.getIndexStatus();
-      expect(status.dimensions).toBe(1536);
-    });
-
-    it('should return correct table status', () => {
-      // Mock the getIndexStatus method to return expected values
-      vi.spyOn(vectorSearchEngine, 'getIndexStatus').mockReturnValue({
-        available: true,
-        tableExists: true,
-        recordCount: 0,
-        dimensions: 1536,
-        vecExtensionLoaded: true
-      });
-      
-      const status = vectorSearchEngine.getIndexStatus();
-      expect(status.tableExists).toBe(true);
-      expect(status.recordCount).toBe(0);
-    });
-  });
-
-  describe('벡터 검색', () => {
-    beforeEach(() => {
-      // Mock search method to return test results
-      vi.spyOn(vectorSearchEngine, 'search').mockResolvedValue(mockSearchResults);
-    });
-
-    it('should return empty array when not initialized', async () => {
-      const newEngine = new VectorSearchEngine();
-      const results = await newEngine.search(testQueryVector);
-      expect(results).toEqual([]);
-    });
-
-    it('should return empty array when VEC not available', async () => {
-      const newEngine = new VectorSearchEngine();
-      // Mock VEC not available
-      vi.spyOn(newEngine as any, 'checkVecAvailability').mockImplementation(() => {
-        (newEngine as any).isVecAvailable = false;
-        (newEngine as any).vecExtensionLoaded = false;
-      });
-      
-      const results = await newEngine.search(testQueryVector);
-      expect(results).toEqual([]);
-    });
-
-    it('should perform basic vector search', async () => {
-      const results = await vectorSearchEngine.search(testQueryVector);
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector);
-      expect(results).toHaveLength(3);
-      expect(results[0]).toHaveProperty('memory_id');
-      expect(results[0]).toHaveProperty('similarity');
-    });
-
-    it('should apply similarity threshold', async () => {
-      const results = await vectorSearchEngine.search(testQueryVector, { threshold: 0.8 });
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector, { threshold: 0.8 });
-    });
-
-    it('should apply limit', async () => {
-      const results = await vectorSearchEngine.search(testQueryVector, { limit: 5 });
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector, { limit: 5 });
-    });
-
-    it('should filter by type', async () => {
-      const results = await vectorSearchEngine.search(testQueryVector, { 
-        type: 'episodic'
-      });
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector, { 
-        type: 'episodic'
-      });
-    });
-
-    it('should include content when requested', async () => {
-      const results = await vectorSearchEngine.search(testQueryVector, { 
-        includeContent: true,
-        includeMetadata: true
-      });
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector, { 
-        includeContent: true,
-        includeMetadata: true
-      });
-      expect(results[0]).toHaveProperty('content');
-      expect(results[0]).toHaveProperty('type');
-      expect(results[0]).toHaveProperty('importance');
-      expect(results[0]).toHaveProperty('created_at');
-      expect(results[0]).toHaveProperty('last_accessed');
-      expect(results[0]).toHaveProperty('pinned');
-      expect(results[0]).toHaveProperty('tags');
-    });
-
-    it('should handle empty search results', async () => {
-      vi.spyOn(vectorSearchEngine, 'search').mockResolvedValue([]);
-      
-      const results = await vectorSearchEngine.search(testQueryVector);
-      expect(results).toEqual([]);
-    });
-
-    it('should handle database errors gracefully', async () => {
-      // Test that the method handles errors by returning empty array
-      // Since we're mocking the search method, we need to test the error handling logic
-      const newEngine = new VectorSearchEngine();
-      
-      // Mock the search method to simulate an error scenario
-      const originalSearch = newEngine.search.bind(newEngine);
-      vi.spyOn(newEngine, 'search').mockImplementation(async () => {
-        try {
-          // Simulate an error condition
-          throw new Error('Database error');
-        } catch (error) {
-          // Return empty array as per the implementation's error handling
-          return [];
-        }
-      });
-      
-      const results = await newEngine.search(testQueryVector);
-      expect(results).toEqual([]);
-    });
-
-    it('should validate vector dimensions', async () => {
-      const invalidVector = new Array(100).fill(0.1); // Wrong dimensions
-      
-      // Create a new engine instance without mocking to test actual validation
-      const newEngine = new VectorSearchEngine();
-      vi.spyOn(newEngine as any, 'checkVecAvailability').mockImplementation(() => {
-        (newEngine as any).isVecAvailable = true;
-        (newEngine as any).vecExtensionLoaded = true;
-      });
-      
-      const results = await newEngine.search(invalidVector);
-      expect(results).toEqual([]);
-    });
-  });
-
-  describe('기본값 처리', () => {
-    it('should use default options when none provided', async () => {
-      vi.spyOn(vectorSearchEngine, 'search').mockResolvedValue([]);
-      
-      await vectorSearchEngine.search(testQueryVector);
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector);
-    });
-  });
-
-  describe('JSON 직렬화', () => {
-    it('should serialize query vector to JSON', async () => {
-      vi.spyOn(vectorSearchEngine, 'search').mockResolvedValue([]);
-      
-      await vectorSearchEngine.search(testQueryVector);
-      
-      expect(vectorSearchEngine.search).toHaveBeenCalledWith(testQueryVector);
-    });
-  });
-
-  describe('하이브리드 검색', () => {
-    const mockHybridResults = [
-      { 
-        memory_id: 'test1', 
-        vector_similarity: 0.9, 
-        text_similarity: 0.8, 
-        content: 'Test content 1', 
-        type: 'episodic', 
-        importance: 0.5, 
-        created_at: '2024-01-01',
-        last_accessed: '2024-01-02',
-        pinned: false,
-        tags: '["test"]'
-      },
-      { 
-        memory_id: 'test2', 
-        vector_similarity: 0.7, 
-        text_similarity: 0.9, 
-        content: 'Test content 2', 
-        type: 'semantic', 
-        importance: 0.7, 
-        created_at: '2024-01-02',
-        last_accessed: '2024-01-03',
-        pinned: true,
-        tags: '["demo"]'
-      }
-    ];
-
-    beforeEach(() => {
-      vi.spyOn(vectorSearchEngine, 'hybridSearch').mockResolvedValue(mockHybridResults);
-    });
-
-    it('should perform hybrid search successfully', async () => {
-      const results = await vectorSearchEngine.hybridSearch(testQueryVector, testTextQuery);
-      
-      expect(vectorSearchEngine.hybridSearch).toHaveBeenCalledWith(testQueryVector, testTextQuery);
-      expect(results).toHaveLength(2);
-      expect(results[0]).toHaveProperty('memory_id');
-      expect(results[0]).toHaveProperty('vector_similarity');
-    });
-
-    it('should return empty array when VEC not available', async () => {
-      const newEngine = new VectorSearchEngine();
-      const results = await newEngine.hybridSearch(testQueryVector, testTextQuery);
-      expect(results).toEqual([]);
-    });
-
-    it('should apply type filter in hybrid search', async () => {
-      await vectorSearchEngine.hybridSearch(testQueryVector, testTextQuery, { type: 'episodic' });
-      
-      expect(vectorSearchEngine.hybridSearch).toHaveBeenCalledWith(testQueryVector, testTextQuery, { type: 'episodic' });
-    });
-  });
-
-  describe('인덱스 재구성', () => {
-    it('should rebuild index successfully', async () => {
-      vi.spyOn(vectorSearchEngine, 'rebuildIndex').mockResolvedValue(true);
-      
-      const result = await vectorSearchEngine.rebuildIndex();
-      
-      expect(result).toBe(true);
-    });
-
-    it('should return false when VEC not available', async () => {
-      const newEngine = new VectorSearchEngine();
-      const result = await newEngine.rebuildIndex();
-      expect(result).toBe(false);
-    });
-
-    it('should handle rebuild errors gracefully', async () => {
-      vi.spyOn(vectorSearchEngine, 'rebuildIndex').mockResolvedValue(false);
-      
-      const result = await vectorSearchEngine.rebuildIndex();
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('성능 테스트', () => {
-    it('should perform performance test successfully', async () => {
-      const mockPerformanceResult = {
-        averageTime: 10.5,
-        minTime: 8.2,
-        maxTime: 12.8,
-        results: 3,
-        successRate: 1.0
-      };
-      
-      vi.spyOn(vectorSearchEngine, 'performanceTest').mockResolvedValue(mockPerformanceResult);
-      
-      const result = await vectorSearchEngine.performanceTest(testQueryVector, 3);
-      
-      expect(result).toHaveProperty('averageTime');
-      expect(result).toHaveProperty('minTime');
-      expect(result).toHaveProperty('maxTime');
-      expect(result).toHaveProperty('results');
-      expect(result).toHaveProperty('successRate');
-      expect(result.results).toBe(3);
-      expect(result.averageTime).toBeGreaterThan(0);
-      expect(result.successRate).toBe(1.0);
-    });
-
-    it('should return zero values when VEC not available', async () => {
-      const newEngine = new VectorSearchEngine();
-      const result = await newEngine.performanceTest(testQueryVector, 3);
-      
-      expect(result.averageTime).toBe(0);
-      expect(result.minTime).toBe(0);
-      expect(result.maxTime).toBe(0);
-      expect(result.results).toBe(0);
-      expect(result.successRate).toBe(0);
-    });
-
-    it('should handle performance test with different iterations', async () => {
-      const mockPerformanceResult = {
-        averageTime: 15.2,
-        minTime: 12.1,
-        maxTime: 18.5,
-        results: 5,
-        successRate: 1.0
-      };
-      
-      vi.spyOn(vectorSearchEngine, 'performanceTest').mockResolvedValue(mockPerformanceResult);
-      
-      const result = await vectorSearchEngine.performanceTest(testQueryVector, 5);
-      
-      expect(result.averageTime).toBeGreaterThan(0);
-      expect(result.minTime).toBeGreaterThan(0);
-      expect(result.maxTime).toBeGreaterThan(0);
-      expect(result.successRate).toBe(1.0);
-    });
-  });
-
-  describe('유틸리티 메서드', () => {
-    it('should return correct dimensions', () => {
-      expect(vectorSearchEngine.getDimensions()).toBe(1536);
-    });
-
-    it('should check availability', () => {
-      const isAvailable = vectorSearchEngine.isAvailable();
-      expect(typeof isAvailable).toBe('boolean');
-    });
-
-    it('should check connection status', () => {
-      const isConnected = vectorSearchEngine.isConnected();
-      expect(typeof isConnected).toBe('boolean');
-    });
-  });
-
-  describe('싱글톤 패턴', () => {
-    it('should return same instance', () => {
-      const instance1 = getVectorSearchEngine();
-      const instance2 = getVectorSearchEngine();
-      expect(instance1).toBe(instance2);
-    });
-
-    it('should create new instance after reset', () => {
-      const instance1 = getVectorSearchEngine();
-      resetVectorSearchEngine();
-      const instance2 = getVectorSearchEngine();
-      expect(instance1).not.toBe(instance2);
-    });
-
-    it('should create independent instances', () => {
-      const instance1 = new VectorSearchEngine();
-      const instance2 = new VectorSearchEngine();
-      expect(instance1).not.toBe(instance2);
-    });
-  });
-});