memento-mcp-server 1.6.0 → 1.7.2

package/src/services/performance-monitoring-integration.ts.bak

@@ -1,276 +0,0 @@
-/**
- * 성능 모니터링 통합 서비스
- * 기존 성능 모니터와 알림 서비스를 통합하여 실시간 모니터링 제공
- */
-
-import { PerformanceMonitor } from './performance-monitor.js';
-import { PerformanceAlertService, AlertType, AlertLevel } from './performance-alert-service.js';
-import Database from 'better-sqlite3';
-
-export interface MonitoringConfig {
-  enableRealTimeMonitoring: boolean;
-  monitoringInterval: number; // 밀리초
-  alertThresholds: {
-    responseTime: { warning: number; critical: number };
-    memoryUsage: { warning: number; critical: number };
-    errorRate: { warning: number; critical: number };
-    throughput: { warning: number; critical: number };
-  };
-}
-
-export class PerformanceMonitoringIntegration {
-  private performanceMonitor: PerformanceMonitor;
-  private alertService: PerformanceAlertService;
-  private config: MonitoringConfig;
-  private monitoringInterval: NodeJS.Timeout | null = null;
-  private isMonitoring: boolean = false;
-
-  constructor(
-    db: Database.Database,
-    alertService: PerformanceAlertService,
-    config: MonitoringConfig
-  ) {
-    this.performanceMonitor = new PerformanceMonitor();
-    this.performanceMonitor.initialize(db);
-    this.alertService = alertService;
-    this.config = config;
-  }
-
-  /**
-   * 실시간 모니터링 시작
-   */
-  startRealTimeMonitoring(): void {
-    if (this.isMonitoring) {
-      console.warn('⚠️ 실시간 모니터링이 이미 실행 중입니다');
-      return;
-    }
-
-    if (!this.config.enableRealTimeMonitoring) {
-      console.log('ℹ️ 실시간 모니터링이 비활성화되어 있습니다');
-      return;
-    }
-
-    this.isMonitoring = true;
-    console.log('🚀 실시간 성능 모니터링 시작');
-
-    this.monitoringInterval = setInterval(async () => {
-      await this.performMonitoringCycle();
-    }, this.config.monitoringInterval);
-  }
-
-  /**
-   * 실시간 모니터링 중지
-   */
-  stopRealTimeMonitoring(): void {
-    if (this.monitoringInterval) {
-      clearInterval(this.monitoringInterval);
-      this.monitoringInterval = null;
-    }
-    this.isMonitoring = false;
-    console.log('🛑 실시간 성능 모니터링 중지');
-  }
-
-  /**
-   * 모니터링 사이클 실행
-   */
-  private async performMonitoringCycle(): Promise<void> {
-    try {
-      const metrics = await this.performanceMonitor.collectMetrics();
-      
-      // 응답시간 체크
-      if (metrics.search.averageSearchTime > 0) {
-        this.alertService.checkPerformanceMetric(
-          AlertType.RESPONSE_TIME,
-          metrics.search.averageSearchTime,
-          {
-            component: 'search_engine',
-            operation: 'search',
-            totalSearches: metrics.search.totalSearches
-          }
-        );
-      }
-
-      // 메모리 사용량 체크
-      const memoryUsageMB = metrics.memory.heapUsed / 1024 / 1024;
-      this.alertService.checkPerformanceMetric(
-        AlertType.MEMORY_USAGE,
-        memoryUsageMB,
-        {
-          component: 'memory_manager',
-          heapTotal: metrics.memory.heapTotal,
-          rss: metrics.memory.rss
-        }
-      );
-
-      // 에러율 체크 (간접적으로)
-      const errorRate = this.calculateErrorRate(metrics);
-      if (errorRate > 0) {
-        this.alertService.checkPerformanceMetric(
-          AlertType.ERROR_RATE,
-          errorRate,
-          {
-            component: 'system',
-            totalOperations: metrics.database.totalMemories + metrics.search.totalSearches
-          }
-        );
-      }
-
-      // 처리량 체크
-      const throughput = this.calculateThroughput(metrics);
-      if (throughput > 0) {
-        this.alertService.checkPerformanceMetric(
-          AlertType.THROUGHPUT,
-          throughput,
-          {
-            component: 'system',
-            totalOperations: metrics.database.totalMemories + metrics.search.totalSearches
-          }
-        );
-      }
-
-      // 데이터베이스 성능 체크
-      if (metrics.database.queryPerformance.averageQueryTime > 0) {
-        this.alertService.checkPerformanceMetric(
-          AlertType.DATABASE_PERFORMANCE,
-          metrics.database.queryPerformance.averageQueryTime,
-          {
-            component: 'database',
-            operation: 'query',
-            totalMemories: metrics.database.totalMemories
-          }
-        );
-      }
-
-      // 캐시 성능 체크
-      if (metrics.search.cacheHitRate > 0) {
-        this.alertService.checkPerformanceMetric(
-          AlertType.CACHE_PERFORMANCE,
-          metrics.search.cacheHitRate * 100, // 백분율로 변환
-          {
-            component: 'cache',
-            operation: 'search',
-            totalSearches: metrics.search.totalSearches
-          }
-        );
-      }
-
-    } catch (error) {
-      console.error('❌ 모니터링 사이클 실행 중 오류:', error);
-    }
-  }
-
-  /**
-   * 에러율 계산 (간접적)
-   */
-  private calculateErrorRate(metrics: any): number {
-    // 실제 에러율 계산 로직 (현재는 간단한 추정)
-    const totalOperations = metrics.database.totalMemories + metrics.search.totalSearches;
-    if (totalOperations === 0) return 0;
-    
-    // 느린 쿼리 비율을 에러율로 간접 추정
-    const slowQueries = metrics.database.queryPerformance.slowQueries.length;
-    return (slowQueries / totalOperations) * 100;
-  }
-
-  /**
-   * 처리량 계산
-   */
-  private calculateThroughput(metrics: any): number {
-    const totalOperations = metrics.database.totalMemories + metrics.search.totalSearches;
-    const uptimeSeconds = metrics.system.uptime / 1000;
-    
-    if (uptimeSeconds === 0) return 0;
-    
-    return totalOperations / uptimeSeconds; // ops/sec
-  }
-
-  /**
-   * 수동 성능 체크
-   */
-  async performManualCheck(): Promise<void> {
-    console.log('🔍 수동 성능 체크 실행');
-    await this.performMonitoringCycle();
-  }
-
-  /**
-   * 알림 임계값 업데이트
-   */
-  updateAlertThresholds(thresholds: Partial<MonitoringConfig['alertThresholds']>): void {
-    if (thresholds.responseTime) {
-      this.alertService.updateThreshold(
-        AlertType.RESPONSE_TIME,
-        AlertLevel.WARNING,
-        { threshold: thresholds.responseTime.warning, operator: 'gt' }
-      );
-      this.alertService.updateThreshold(
-        AlertType.RESPONSE_TIME,
-        AlertLevel.CRITICAL,
-        { threshold: thresholds.responseTime.critical, operator: 'gt' }
-      );
-    }
-
-    if (thresholds.memoryUsage) {
-      this.alertService.updateThreshold(
-        AlertType.MEMORY_USAGE,
-        AlertLevel.WARNING,
-        { threshold: thresholds.memoryUsage.warning, operator: 'gt' }
-      );
-      this.alertService.updateThreshold(
-        AlertType.MEMORY_USAGE,
-        AlertLevel.CRITICAL,
-        { threshold: thresholds.memoryUsage.critical, operator: 'gt' }
-      );
-    }
-
-    if (thresholds.errorRate) {
-      this.alertService.updateThreshold(
-        AlertType.ERROR_RATE,
-        AlertLevel.WARNING,
-        { threshold: thresholds.errorRate.warning, operator: 'gt' }
-      );
-      this.alertService.updateThreshold(
-        AlertType.ERROR_RATE,
-        AlertLevel.CRITICAL,
-        { threshold: thresholds.errorRate.critical, operator: 'gt' }
-      );
-    }
-
-    if (thresholds.throughput) {
-      this.alertService.updateThreshold(
-        AlertType.THROUGHPUT,
-        AlertLevel.WARNING,
-        { threshold: thresholds.throughput.warning, operator: 'lt' }
-      );
-      this.alertService.updateThreshold(
-        AlertType.THROUGHPUT,
-        AlertLevel.CRITICAL,
-        { threshold: thresholds.throughput.critical, operator: 'lt' }
-      );
-    }
-
-    console.log('✅ 알림 임계값 업데이트 완료');
-  }
-
-  /**
-   * 모니터링 상태 확인
-   */
-  getMonitoringStatus(): {
-    isMonitoring: boolean;
-    config: MonitoringConfig;
-    alertService: PerformanceAlertService;
-  } {
-    return {
-      isMonitoring: this.isMonitoring,
-      config: this.config,
-      alertService: this.alertService
-    };
-  }
-
-  /**
-   * 서비스 정리
-   */
-  cleanup(): void {
-    this.stopRealTimeMonitoring();
-    this.alertService.cleanup();
-  }
-}

package/src/services/unified-embedding-service.spec.ts

@@ -1,224 +0,0 @@
-/**
- * 통합 임베딩 서비스 테스트
- * TDD 방식으로 구현
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { UnifiedEmbeddingService } from './unified-embedding-service.js';
-import { EmbeddingProviderFactory } from './embedding-provider-factory.js';
-import type { EmbeddingServiceInterface, EmbeddingResult, SimilarityResult, EmbeddingData } from '../types/embedding.types.js';
-
-// 팩토리 모킹
-const mockFactory = {
-  getProvider: vi.fn(),
-  getAvailableProviders: vi.fn(),
-  selectProvider: vi.fn()
-};
-
-vi.mock('./embedding-provider-factory.js', () => ({
-  EmbeddingProviderFactory: {
-    getInstance: vi.fn(() => mockFactory)
-  }
-}));
-
-// Mock 제공자 클래스
-class MockEmbeddingService implements EmbeddingServiceInterface {
-  constructor(private available: boolean = true, private shouldFail: boolean = false) {}
-
-  async generateEmbedding(text: string): Promise<EmbeddingResult | null> {
-    if (this.shouldFail) {
-      throw new Error('Mock service failed');
-    }
-    return {
-      embedding: [0.1, 0.2, 0.3],
-      model: 'mock-model',
-      usage: { prompt_tokens: 10, total_tokens: 10 }
-    };
-  }
-
-  async searchSimilar(query: string, embeddings: EmbeddingData[], limit?: number, threshold?: number): Promise<SimilarityResult[]> {
-    if (this.shouldFail) {
-      throw new Error('Mock service failed');
-    }
-    return [
-      { id: '1', content: 'test', similarity: 0.8, score: 0.8 }
-    ];
-  }
-
-  isAvailable(): boolean {
-    return this.available;
-  }
-
-  getModelInfo() {
-    return { model: 'mock-model', dimensions: 384, maxTokens: 256 };
-  }
-}
-
-describe('UnifiedEmbeddingService', () => {
-  let service: UnifiedEmbeddingService;
-  let mockProvider: MockEmbeddingService;
-
-  beforeEach(() => {
-    mockProvider = new MockEmbeddingService();
-    
-    // 팩토리 모킹 설정
-    mockFactory.getProvider.mockReturnValue(mockProvider);
-    mockFactory.getAvailableProviders.mockReturnValue([
-      { name: 'minilm', available: true, priority: 1, cost: 'free', performance: 'high' },
-      { name: 'openai', available: true, priority: 2, cost: 'paid', performance: 'high' },
-      { name: 'gemini', available: true, priority: 3, cost: 'paid', performance: 'high' },
-      { name: 'tfidf', available: true, priority: 4, cost: 'free', performance: 'low' }
-    ]);
-    mockFactory.selectProvider.mockReturnValue(mockProvider);
-    
-    service = new UnifiedEmbeddingService();
-  });
-
-  describe('생성자', () => {
-    it('서비스가 올바르게 초기화되어야 한다', () => {
-      expect(service).toBeDefined();
-      expect(EmbeddingProviderFactory.getInstance).toHaveBeenCalled();
-    });
-  });
-
-  describe('generateEmbedding', () => {
-    it('빈 텍스트에 대해 에러를 던져야 한다', async () => {
-      await expect(service.generateEmbedding('')).rejects.toThrow('텍스트가 비어있습니다');
-      await expect(service.generateEmbedding('   ')).rejects.toThrow('텍스트가 비어있습니다');
-    });
-
-    it('유효한 텍스트에 대해 임베딩을 생성해야 한다', async () => {
-      const mockProvider = new MockEmbeddingService();
-      mockFactory.selectProvider.mockReturnValue(mockProvider);
-
-      const result = await service.generateEmbedding('테스트 텍스트');
-      
-      expect(result).toBeDefined();
-      expect(result?.embedding).toEqual([0.1, 0.2, 0.3]);
-      expect(result?.model).toBe('mock-model');
-    });
-
-    it('제공자 실패 시 폴백을 시도해야 한다', async () => {
-      const failingProvider = new MockEmbeddingService(true, true);
-      const fallbackProvider = new MockEmbeddingService();
-      
-      mockFactory.selectProvider.mockReturnValue(failingProvider);
-      mockFactory.getProvider
-        .mockReturnValueOnce(failingProvider) // 첫 번째 시도
-        .mockReturnValueOnce(fallbackProvider); // 폴백 시도
-
-      const result = await service.generateEmbedding('테스트 텍스트');
-      
-      expect(result).toBeDefined();
-      expect(result?.model).toBe('mock-model');
-    });
-
-    it('모든 제공자 실패 시 에러를 던져야 한다', async () => {
-      const failingProvider = new MockEmbeddingService(true, true);
-      mockFactory.selectProvider.mockReturnValue(failingProvider);
-      mockFactory.getProvider.mockReturnValue(failingProvider);
-
-      await expect(service.generateEmbedding('테스트 텍스트')).rejects.toThrow('모든 임베딩 제공자 실패');
-    });
-  });
-
-  describe('searchSimilar', () => {
-    const mockEmbeddings: EmbeddingData[] = [
-      { id: '1', content: '테스트 내용', embedding: [0.1, 0.2, 0.3] }
-    ];
-
-    it('빈 쿼리에 대해 에러를 던져야 한다', async () => {
-      await expect(service.searchSimilar('', mockEmbeddings)).rejects.toThrow('텍스트가 비어있습니다');
-    });
-
-    it('유효한 쿼리에 대해 검색 결과를 반환해야 한다', async () => {
-      const mockProvider = new MockEmbeddingService();
-      mockFactory.selectProvider.mockReturnValue(mockProvider);
-
-      const results = await service.searchSimilar('쿼리', mockEmbeddings);
-      
-      expect(results).toHaveLength(1);
-      expect(results[0].id).toBe('1');
-      expect(results[0].similarity).toBe(0.8);
-    });
-
-    it('제공자 실패 시 폴백을 시도해야 한다', async () => {
-      const failingProvider = new MockEmbeddingService(true, true);
-      const fallbackProvider = new MockEmbeddingService();
-      
-      mockFactory.selectProvider.mockReturnValue(failingProvider);
-      mockFactory.getProvider
-        .mockReturnValueOnce(failingProvider)
-        .mockReturnValueOnce(fallbackProvider);
-
-      const results = await service.searchSimilar('쿼리', mockEmbeddings);
-      
-      expect(results).toHaveLength(1);
-    });
-  });
-
-  describe('isAvailable', () => {
-    it('사용 가능한 제공자가 있으면 true를 반환해야 한다', () => {
-      mockFactory.getAvailableProviders.mockReturnValue([
-        { name: 'minilm', available: true },
-        { name: 'tfidf', available: false }
-      ]);
-
-      expect(service.isAvailable()).toBe(true);
-    });
-
-    it('사용 가능한 제공자가 없으면 false를 반환해야 한다', () => {
-      mockFactory.getAvailableProviders.mockReturnValue([
-        { name: 'minilm', available: false },
-        { name: 'tfidf', available: false }
-      ]);
-
-      expect(service.isAvailable()).toBe(false);
-    });
-  });
-
-  describe('getModelInfo', () => {
-    it('현재 제공자가 있으면 해당 정보를 반환해야 한다', () => {
-      const mockProvider = new MockEmbeddingService();
-      mockFactory.selectProvider.mockReturnValue(mockProvider);
-      
-      // 임베딩 생성으로 현재 제공자 설정
-      service.generateEmbedding('test');
-      
-      const info = service.getModelInfo();
-      expect(info.model).toBe('mock-model');
-      expect(info.dimensions).toBe(384);
-    });
-
-    it('현재 제공자가 없으면 기본값을 반환해야 한다', () => {
-      const info = service.getModelInfo();
-      expect(info.model).toBe('unified-embedding');
-      expect(info.dimensions).toBe(384);
-    });
-  });
-
-  describe('getCurrentProviderName', () => {
-    it('현재 제공자 이름을 반환해야 한다', () => {
-      const mockProvider = new MockEmbeddingService();
-      mockFactory.selectProvider.mockReturnValue(mockProvider);
-      mockFactory.getAvailableProviders.mockReturnValue([
-        { name: 'minilm', available: true }
-      ]);
-      mockFactory.getProvider.mockReturnValue(mockProvider);
-      
-      service.generateEmbedding('test');
-      
-      expect(service.getCurrentProviderName()).toBe('minilm');
-    });
-  });
-
-  describe('setFallbackProviders', () => {
-    it('폴백 제공자를 설정해야 한다', () => {
-      const newFallbacks = ['tfidf', 'minilm'];
-      service.setFallbackProviders(newFallbacks);
-      
-      // 내부 상태 확인은 어려우므로, 에러 없이 실행되는지 확인
-      expect(() => service.setFallbackProviders(newFallbacks)).not.toThrow();
-    });
-  });
-});