memento-mcp-server 0.1.0

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

@@ -0,0 +1,284 @@
+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

@@ -0,0 +1,228 @@
+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

@@ -0,0 +1,171 @@
+/**
+ * 성능 모니터링 기능 테스트
+ * 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);
+    });
+}