memento-mcp-server 1.6.0 → 1.7.1

package/src/test/test-performance-monitor.spec.ts

@@ -1,284 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { getPerformanceMonitor, PerformanceMonitor } from '../services/performance-monitor.js';
-import Database from 'better-sqlite3';
-import { DatabaseUtils } from '../utils/database.js';
-
-describe('PerformanceMonitor', () => {
-  let db: Database.Database;
-  let performanceMonitor: PerformanceMonitor;
-
-  beforeEach(() => {
-    // Create in-memory database for testing
-    db = new Database(':memory:');
-    // Initialize database schema
-    db.exec(`
-      CREATE TABLE memory_item (
-        id TEXT PRIMARY KEY,
-        type TEXT CHECK (type IN ('working','episodic','semantic','procedural')),
-        content TEXT NOT NULL,
-        importance REAL CHECK (importance >= 0 AND importance <= 1) DEFAULT 0.5,
-        privacy_scope TEXT CHECK (privacy_scope IN ('private','team','public')) DEFAULT 'private',
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        last_accessed TIMESTAMP,
-        pinned BOOLEAN DEFAULT FALSE,
-        source TEXT,
-        agent_id TEXT,
-        user_id TEXT,
-        project_id TEXT,
-        origin_trace TEXT
-      );
-    `);
-    
-    performanceMonitor = getPerformanceMonitor();
-    performanceMonitor.initialize(db);
-  });
-
-  afterEach(() => {
-    if (db) {
-      db.close();
-    }
-  });
-
-  describe('초기화', () => {
-    it('should initialize successfully', () => {
-      expect(() => performanceMonitor.initialize(db)).not.toThrow();
-    });
-
-    it('should reset state on initialization', () => {
-      performanceMonitor.initialize(db);
-      const alerts = performanceMonitor.getActiveAlerts();
-      expect(alerts).toEqual([]);
-    });
-  });
-
-  describe('메트릭 수집', () => {
-    it('should collect basic metrics', async () => {
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics).toHaveProperty('timestamp');
-      expect(metrics).toHaveProperty('cpu');
-      expect(metrics).toHaveProperty('memory');
-      expect(metrics).toHaveProperty('database');
-      expect(metrics).toHaveProperty('uptime');
-      
-      expect(metrics.cpu).toHaveProperty('user');
-      expect(metrics.cpu).toHaveProperty('system');
-      expect(metrics.memory).toHaveProperty('rss');
-      expect(metrics.memory).toHaveProperty('heapTotal');
-      expect(metrics.memory).toHaveProperty('heapUsed');
-      expect(metrics.memory).toHaveProperty('external');
-      
-      expect(metrics.database).toHaveProperty('size');
-      expect(metrics.database).toHaveProperty('memoryCount');
-      expect(metrics.database).toHaveProperty('queryTime');
-    });
-
-    it('should collect database metrics', async () => {
-      // Add test data
-      db.prepare(`
-        INSERT INTO memory_item (id, type, content, importance, created_at)
-        VALUES ('test1', 'episodic', 'Test memory 1', 0.5, datetime('now'))
-      `).run();
-
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics.database.memoryCount).toBe(1);
-      expect(metrics.database.size).toBeGreaterThan(0);
-    });
-
-    it('should handle database errors gracefully', async () => {
-      // Close database to simulate error
-      db.close();
-      
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics.database.memoryCount).toBe(0);
-      expect(metrics.database.size).toBe(0);
-    });
-  });
-
-  describe('메트릭 히스토리', () => {
-    it('should maintain metrics history', async () => {
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      
-      const history = performanceMonitor.getMetricsHistory();
-      expect(history.length).toBeGreaterThanOrEqual(2);
-    });
-
-    it('should limit metrics history size', async () => {
-      // Collect more than maxHistorySize (1000) metrics
-      for (let i = 0; i < 5; i++) {
-        await performanceMonitor.collectMetrics();
-      }
-      
-      const history = performanceMonitor.getMetricsHistory();
-      expect(history.length).toBeLessThanOrEqual(1000);
-    });
-
-    it('should return limited history when limit specified', async () => {
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      
-      const limitedHistory = performanceMonitor.getMetricsHistory(2);
-      expect(limitedHistory.length).toBe(2);
-    });
-  });
-
-  describe('알림 관리', () => {
-    it('should return active alerts', () => {
-      const alerts = performanceMonitor.getActiveAlerts();
-      expect(Array.isArray(alerts)).toBe(true);
-    });
-
-    it('should return all alerts', () => {
-      const allAlerts = performanceMonitor.getAllAlerts();
-      expect(Array.isArray(allAlerts)).toBe(true);
-    });
-
-    it('should resolve alerts', () => {
-      // Create a mock alert by triggering high memory usage
-      const originalMemoryUsage = process.memoryUsage;
-      process.memoryUsage = vi.fn().mockReturnValue({
-        rss: 0,
-        heapTotal: 1000,
-        heapUsed: 900, // 90% usage
-        external: 0,
-        arrayBuffers: 0
-      });
-
-      // Trigger alert by collecting metrics
-      performanceMonitor.collectMetrics();
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      if (alerts.length > 0) {
-        const alertId = alerts[0].id;
-        const resolved = performanceMonitor.resolveAlert(alertId);
-        
-        expect(resolved).toBe(true);
-        
-        const activeAlerts = performanceMonitor.getActiveAlerts();
-        expect(activeAlerts.find(a => a.id === alertId)?.resolved).toBe(true);
-      }
-      
-      // Restore original function
-      process.memoryUsage = originalMemoryUsage;
-    });
-
-    it('should not resolve non-existent alert', () => {
-      const resolved = performanceMonitor.resolveAlert('non-existent-id');
-      expect(resolved).toBe(false);
-    });
-  });
-
-  describe('성능 요약', () => {
-    it('should return performance summary', () => {
-      const summary = performanceMonitor.getPerformanceSummary();
-      
-      expect(summary).toHaveProperty('current');
-      expect(summary).toHaveProperty('alerts');
-      expect(summary).toHaveProperty('trends');
-      expect(summary.alerts).toHaveProperty('active');
-      expect(summary.alerts).toHaveProperty('total');
-      expect(summary.trends).toHaveProperty('memoryTrend');
-      expect(summary.trends).toHaveProperty('dbSizeTrend');
-    });
-
-    it('should calculate trends when metrics available', async () => {
-      // Collect some metrics
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      
-      const summary = performanceMonitor.getPerformanceSummary();
-      
-      expect(summary.current).toBeDefined();
-      expect(summary.trends.memoryTrend).toMatch(/^(increasing|decreasing|stable)$/);
-      expect(summary.trends.dbSizeTrend).toMatch(/^(increasing|decreasing|stable)$/);
-    });
-  });
-
-  describe('알림 규칙', () => {
-    it('should trigger memory alert on high usage', async () => {
-      // Mock high memory usage
-      const originalMemoryUsage = process.memoryUsage;
-      process.memoryUsage = vi.fn().mockReturnValue({
-        rss: 0,
-        heapTotal: 1000,
-        heapUsed: 900, // 90% usage
-        external: 0,
-        arrayBuffers: 0
-      });
-
-      await performanceMonitor.collectMetrics();
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      const memoryAlert = alerts.find(a => a.type === 'memory');
-      
-      expect(memoryAlert).toBeDefined();
-      expect(memoryAlert?.severity).toBe('warning');
-      
-      // Restore original function
-      process.memoryUsage = originalMemoryUsage;
-    });
-
-    it('should trigger database size alert on large database', 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: 100000 }) };
-        }
-        if (query.includes('PRAGMA page_size')) {
-          return { get: () => ({ page_size: 4096 }) };
-        }
-        return originalPrepare.call(db, query);
-      });
-
-      await performanceMonitor.collectMetrics();
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      const dbAlert = alerts.find(a => a.type === 'database');
-      
-      expect(dbAlert).toBeDefined();
-      expect(dbAlert?.severity).toBe('critical');
-      
-      // Restore original function
-      db.prepare = originalPrepare;
-    });
-
-    it('should trigger query time alert on slow queries', async () => {
-      // Mock slow query time by directly calling checkAlerts with slow query metrics
-      const slowMetrics = {
-        timestamp: new Date(),
-        memory: { rss: 100000000, heapTotal: 100000000, heapUsed: 100000000, external: 0 },
-        cpu: { user: 0, system: 0 },
-        database: { size: 1000000, memoryCount: 0, queryTime: 2500 }, // 2.5 seconds
-        uptime: 1000
-      };
-      
-      // Call checkAlerts directly to test alert generation
-      await (performanceMonitor as any).checkAlerts(slowMetrics);
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      const queryAlert = alerts.find(a => a.type === 'query');
-      
-      expect(queryAlert).toBeDefined();
-      expect(queryAlert?.severity).toBe('critical');
-    });
-  });
-
-  describe('임계값 관리', () => {
-    it('should update thresholds', () => {
-      const newThresholds = {
-        memoryUsagePercent: 90,
-        databaseSizeMB: 200
-      };
-      
-      performanceMonitor.updateThresholds(newThresholds);
-      
-      // Should not throw
-      expect(() => performanceMonitor.updateThresholds(newThresholds)).not.toThrow();
-    });
-  });
-});

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

@@ -1,228 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { getPerformanceMonitor, PerformanceMonitor } from '../services/performance-monitor.js';
-import Database from 'better-sqlite3';
-import { DatabaseUtils } from '../utils/database.js';
-
-describe('PerformanceMonitor', () => {
-  let db: Database.Database;
-  let performanceMonitor: PerformanceMonitor;
-
-  beforeEach(() => {
-    // Create in-memory database for testing
-    db = new Database(':memory:');
-    DatabaseUtils.initializeDatabase(db);
-    
-    performanceMonitor = getPerformanceMonitor();
-    performanceMonitor.initialize(db);
-  });
-
-  afterEach(() => {
-    if (db) {
-      db.close();
-    }
-  });
-
-  describe('초기화', () => {
-    it('should initialize successfully', () => {
-      expect(() => performanceMonitor.initialize(db)).not.toThrow();
-    });
-
-    it('should reset state on initialization', () => {
-      performanceMonitor.initialize(db);
-      const alerts = performanceMonitor.getActiveAlerts();
-      expect(alerts).toEqual([]);
-    });
-  });
-
-  describe('메트릭 수집', () => {
-    it('should collect basic metrics', async () => {
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics).toHaveProperty('timestamp');
-      expect(metrics).toHaveProperty('cpu');
-      expect(metrics).toHaveProperty('memory');
-      expect(metrics).toHaveProperty('database');
-      expect(metrics).toHaveProperty('uptime');
-      
-      expect(metrics.cpu).toHaveProperty('user');
-      expect(metrics.cpu).toHaveProperty('system');
-      expect(metrics.cpu).toHaveProperty('idle');
-      
-      expect(metrics.memory).toHaveProperty('rss');
-      expect(metrics.memory).toHaveProperty('heapTotal');
-      expect(metrics.memory).toHaveProperty('heapUsed');
-      expect(metrics.memory).toHaveProperty('external');
-      expect(metrics.memory).toHaveProperty('arrayBuffers');
-      
-      expect(metrics.database).toHaveProperty('totalMemories');
-      expect(metrics.database).toHaveProperty('size');
-      expect(metrics.database).toHaveProperty('queryTime');
-    });
-
-    it('should collect database metrics', async () => {
-      // Add test data
-      DatabaseUtils.runQuery(db, `
-        INSERT INTO memory_item (id, type, content, importance, created_at)
-        VALUES ('test1', 'episodic', 'Test memory 1', 0.5, datetime('now'))
-      `);
-
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics.database.totalMemories).toBe(1);
-      expect(metrics.database.size).toBeGreaterThan(0);
-    });
-
-    it('should handle database errors gracefully', async () => {
-      // Close database to simulate error
-      db.close();
-      
-      const metrics = await performanceMonitor.collectMetrics();
-      
-      expect(metrics.database.totalMemories).toBe(0);
-      expect(metrics.database.size).toBe(0);
-    });
-  });
-
-  describe('쿼리 시간 기록', () => {
-    it('should record query times', () => {
-      performanceMonitor.recordQueryTime(100);
-      performanceMonitor.recordQueryTime(200);
-      performanceMonitor.recordQueryTime(300);
-      
-      // Should not throw
-      expect(() => performanceMonitor.recordQueryTime(150)).not.toThrow();
-    });
-
-    it('should maintain max query times limit', () => {
-      // Record more than MAX_QUERY_TIMES (100)
-      for (let i = 0; i < 150; i++) {
-        performanceMonitor.recordQueryTime(i);
-      }
-      
-      // Should not throw
-      expect(() => performanceMonitor.recordQueryTime(999)).not.toThrow();
-    });
-  });
-
-  describe('알림 관리', () => {
-    it('should return active alerts', () => {
-      const alerts = performanceMonitor.getActiveAlerts();
-      expect(Array.isArray(alerts)).toBe(true);
-    });
-
-    it('should resolve alerts', () => {
-      // Create a mock alert by triggering high memory usage
-      const mockMetrics = {
-        timestamp: new Date().toISOString(),
-        cpu: { user: 0, system: 0, idle: 0 },
-        memory: { rss: 0, heapTotal: 1000, heapUsed: 900, external: 0, arrayBuffers: 0 },
-        database: { totalMemories: 0, size: 0, queryTime: 0 },
-        uptime: 0
-      };
-
-      // Trigger alert by calling checkAlerts directly
-      (performanceMonitor as any).checkAlerts(mockMetrics);
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      expect(alerts.length).toBeGreaterThan(0);
-      
-      const alertId = alerts[0].id;
-      const resolved = performanceMonitor.resolveAlert(alertId);
-      
-      expect(resolved).toBe(true);
-      
-      const activeAlerts = performanceMonitor.getActiveAlerts();
-      expect(activeAlerts.find(a => a.id === alertId)?.resolved).toBe(true);
-    });
-
-    it('should not resolve non-existent alert', () => {
-      const resolved = performanceMonitor.resolveAlert('non-existent-id');
-      expect(resolved).toBe(false);
-    });
-  });
-
-  describe('성능 요약', () => {
-    it('should return performance summary', () => {
-      const summary = performanceMonitor.getPerformanceSummary();
-      
-      expect(summary).toHaveProperty('activeAlertsCount');
-      expect(summary).toHaveProperty('criticalAlertsCount');
-      expect(typeof summary.activeAlertsCount).toBe('number');
-      expect(typeof summary.criticalAlertsCount).toBe('number');
-    });
-
-    it('should calculate averages when metrics available', async () => {
-      // Collect some metrics
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      
-      const summary = performanceMonitor.getPerformanceSummary();
-      
-      expect(summary.averageCpuUsage).toBeDefined();
-      expect(summary.averageMemoryUsage).toBeDefined();
-      expect(summary.averageDbSize).toBeDefined();
-      expect(summary.averageQueryTime).toBeDefined();
-    });
-  });
-
-  describe('알림 규칙', () => {
-    it('should trigger memory alert on high usage', async () => {
-      // Mock high memory usage
-      const originalMemoryUsage = process.memoryUsage;
-      process.memoryUsage = vi.fn().mockReturnValue({
-        rss: 0,
-        heapTotal: 1000,
-        heapUsed: 900, // 90% usage
-        external: 0,
-        arrayBuffers: 0
-      });
-
-      await performanceMonitor.collectMetrics();
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      const memoryAlert = alerts.find(a => a.metric === 'memory.heapUsed');
-      
-      expect(memoryAlert).toBeDefined();
-      expect(memoryAlert?.severity).toBe('critical');
-      
-      // Restore original function
-      process.memoryUsage = originalMemoryUsage;
-    });
-
-    it('should trigger query time alert on slow queries', async () => {
-      // Record slow query times
-      performanceMonitor.recordQueryTime(150); // Above threshold of 100
-      performanceMonitor.recordQueryTime(200);
-      
-      await performanceMonitor.collectMetrics();
-      
-      const alerts = performanceMonitor.getActiveAlerts();
-      const queryAlert = alerts.find(a => a.metric === 'database.queryTime');
-      
-      expect(queryAlert).toBeDefined();
-      expect(queryAlert?.severity).toBe('warning');
-    });
-  });
-
-  describe('메트릭 히스토리', () => {
-    it('should maintain metrics history', async () => {
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      await performanceMonitor.collectMetrics();
-      
-      const summary = performanceMonitor.getPerformanceSummary();
-      expect(summary.lastMetrics).toBeDefined();
-    });
-
-    it('should limit metrics history size', async () => {
-      // Collect more than MAX_METRICS_HISTORY (100) metrics
-      for (let i = 0; i < 150; i++) {
-        await performanceMonitor.collectMetrics();
-      }
-      
-      // Should not throw and should maintain reasonable history size
-      const summary = performanceMonitor.getPerformanceSummary();
-      expect(summary.lastMetrics).toBeDefined();
-    });
-  });
-});

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

@@ -1,171 +0,0 @@
-/**
- * 성능 모니터링 기능 테스트
- * Memento MCP 서버의 성능 모니터링 도구들 테스트
- */
-
-import { createMementoClient } from '../client/index.js';
-
-async function testPerformanceMonitoring() {
-  console.log('📊 성능 모니터링 기능 테스트 시작');
-  
-  const client = createMementoClient();
-  
-  try {
-    // 1. 서버 연결
-    console.log('\n1️⃣ 서버 연결 중...');
-    await client.connect();
-    console.log('✅ Memento MCP 서버에 연결되었습니다');
-
-    // 2. 테스트 데이터 생성
-    console.log('\n2️⃣ 테스트 데이터 생성');
-    const testMemories = [];
-    for (let i = 0; i < 20; i++) {
-      const id = await client.remember({
-        content: `성능 테스트 메모리 ${i}: 다양한 타입의 메모리를 생성하여 성능을 측정합니다.`,
-        type: i % 2 === 0 ? 'episodic' : 'semantic',
-        tags: ['performance', 'test', `batch-${Math.floor(i / 5)}`],
-        importance: 0.5 + Math.random() * 0.5,
-        source: 'performance-test'
-      });
-      testMemories.push(id);
-      console.log(`✅ 저장됨: ${id.substring(0, 20)}...`);
-    }
-
-    // 3. 성능 통계 조회
-    console.log('\n3️⃣ 성능 통계 조회');
-    try {
-      const perfStats = await client.callTool('performance_stats', {});
-      console.log('📊 성능 통계:');
-      console.log(`   데이터베이스:`);
-      console.log(`     총 메모리: ${perfStats.metrics?.database?.totalMemories || 0}개`);
-      console.log(`     데이터베이스 크기: ${((perfStats.metrics?.database?.databaseSize || 0) / 1024 / 1024).toFixed(2)} MB`);
-      console.log(`     평균 메모리 크기: ${perfStats.metrics?.database?.averageMemorySize || 0} 문자`);
-      console.log(`     평균 쿼리 시간: ${perfStats.metrics?.database?.queryPerformance?.averageQueryTime?.toFixed(2) || 'N/A'}ms`);
-      
-      console.log(`   검색:`);
-      console.log(`     총 검색: ${perfStats.metrics?.search?.totalSearches || 0}회`);
-      console.log(`     평균 검색 시간: ${perfStats.metrics?.search?.averageSearchTime || 0}ms`);
-      console.log(`     캐시 적중률: ${((perfStats.metrics?.search?.cacheHitRate || 0) * 100).toFixed(1)}%`);
-      
-      console.log(`   메모리 사용량:`);
-      console.log(`     힙 사용량: ${((perfStats.metrics?.memory?.heapUsed || 0) / 1024 / 1024).toFixed(2)} MB`);
-      console.log(`     RSS: ${((perfStats.metrics?.memory?.rss || 0) / 1024 / 1024).toFixed(2)} MB`);
-      
-      console.log(`   시스템:`);
-      console.log(`     가동 시간: ${Math.floor((perfStats.metrics?.system?.uptime || 0) / 60)}분`);
-      
-    } catch (error) {
-      console.error(`   ❌ 성능 통계 조회 실패: ${error}`);
-    }
-
-    // 4. 데이터베이스 최적화 (분석만)
-    console.log('\n4️⃣ 데이터베이스 최적화 (분석)');
-    try {
-      const optimizeResult = await client.callTool('database_optimize', { 
-        analyze: true, 
-        create_indexes: false 
-      });
-      console.log('🔧 데이터베이스 최적화 결과:');
-      console.log(`   메시지: ${optimizeResult.message}`);
-      console.log(`   수행된 작업: ${optimizeResult.operations?.join(', ') || '없음'}`);
-      
-      if (optimizeResult.report) {
-        console.log('📋 최적화 리포트:');
-        console.log(optimizeResult.report);
-      }
-    } catch (error) {
-      console.error(`   ❌ 데이터베이스 최적화 실패: ${error}`);
-    }
-
-    // 5. 검색 성능 테스트
-    console.log('\n5️⃣ 검색 성능 테스트');
-    const searchQueries = [
-      '성능 테스트',
-      '메모리',
-      '데이터베이스',
-      '최적화',
-      '벤치마크'
-    ];
-
-    for (const query of searchQueries) {
-      const startTime = process.hrtime.bigint();
-      try {
-        const results = await client.recall({ query, limit: 5 });
-        const endTime = process.hrtime.bigint();
-        const searchTime = Number(endTime - startTime) / 1_000_000;
-        
-        console.log(`   🔍 "${query}": ${results.length}개 결과 (${searchTime.toFixed(2)}ms)`);
-      } catch (error) {
-        console.error(`   ❌ 검색 실패 ("${query}"): ${error}`);
-      }
-    }
-
-    // 6. 망각 통계 조회
-    console.log('\n6️⃣ 망각 통계 조회');
-    try {
-      const forgettingStats = await client.callTool('forgetting_stats', {});
-      console.log('🧠 망각 통계:');
-      console.log(`   총 메모리: ${forgettingStats.stats?.totalMemories || 0}개`);
-      console.log(`   망각 후보: ${forgettingStats.stats?.forgetCandidates || 0}개`);
-      console.log(`   리뷰 후보: ${forgettingStats.stats?.reviewCandidates || 0}개`);
-      console.log(`   평균 망각 점수: ${forgettingStats.stats?.averageForgetScore?.toFixed(3) || 'N/A'}`);
-      console.log(`   메모리 분포:`, forgettingStats.stats?.memoryDistribution || {});
-    } catch (error) {
-      console.error(`   ❌ 망각 통계 조회 실패: ${error}`);
-    }
-
-    // 7. 메모리 정리 (드라이런)
-    console.log('\n7️⃣ 메모리 정리 (드라이런)');
-    try {
-      const cleanupResult = await client.callTool('cleanup_memory', { dry_run: true });
-      console.log('🧹 메모리 정리 분석:');
-      console.log(`   모드: ${cleanupResult.mode}`);
-      console.log(`   총 메모리: ${cleanupResult.stats?.totalMemories || 0}개`);
-      console.log(`   망각 후보: ${cleanupResult.stats?.forgetCandidates || 0}개`);
-      console.log(`   리뷰 후보: ${cleanupResult.stats?.reviewCandidates || 0}개`);
-      console.log(`   평균 망각 점수: ${cleanupResult.stats?.averageForgetScore?.toFixed(3) || 'N/A'}`);
-    } catch (error) {
-      console.error(`   ❌ 메모리 정리 분석 실패: ${error}`);
-    }
-
-    // 8. 최종 성능 통계
-    console.log('\n8️⃣ 최종 성능 통계');
-    try {
-      const finalStats = await client.callTool('performance_stats', {});
-      console.log('📊 최종 성능 통계:');
-      console.log(`   데이터베이스:`);
-      console.log(`     총 메모리: ${finalStats.metrics?.database?.totalMemories || 0}개`);
-      console.log(`     평균 쿼리 시간: ${finalStats.metrics?.database?.queryPerformance?.averageQueryTime?.toFixed(2) || 'N/A'}ms`);
-      
-      console.log(`   검색:`);
-      console.log(`     총 검색: ${finalStats.metrics?.search?.totalSearches || 0}회`);
-      console.log(`     평균 검색 시간: ${finalStats.metrics?.search?.averageSearchTime || 0}ms`);
-      
-      console.log(`   메모리 사용량:`);
-      console.log(`     힙 사용량: ${((finalStats.metrics?.memory?.heapUsed || 0) / 1024 / 1024).toFixed(2)} MB`);
-      
-    } 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-performance-monitoring.ts')) {
-  testPerformanceMonitoring()
-    .then(() => {
-      console.log('✅ 성능 모니터링 테스트 완료');
-      process.exit(0);
-    })
-    .catch((error) => {
-      console.error('❌ 성능 모니터링 테스트 실패:', error);
-      process.exit(1);
-    });
-}