memento-mcp-server 1.6.0 → 1.7.2

package/src/tools/memory-injection-prompt.ts

@@ -1,257 +0,0 @@
-/**
- * Memory Injection 프롬프트 도구
- * MCP 프롬프트 인터페이스를 통한 관련 기억 주입
- */
-
-import { BaseTool } from './base-tool.js';
-import type { ToolContext } from './types.js';
-import { z } from 'zod';
-
-const MemoryInjectionSchema = z.object({
-  query: z.string().describe('검색할 쿼리'),
-  token_budget: z.number().optional().describe('토큰 예산 (기본값: 1000)'),
-  max_memories: z.number().optional().describe('최대 기억 개수 (기본값: 5)'),
-  memory_types: z.array(z.enum(['working', 'episodic', 'semantic', 'procedural'])).optional().describe('포함할 기억 타입들'),
-  importance_threshold: z.number().optional().describe('중요도 임계값 (기본값: 0.5)')
-});
-
-export class MemoryInjectionPrompt extends BaseTool {
-  constructor() {
-    super(
-      'memory_injection',
-      '관련 기억을 요약하여 프롬프트에 주입',
-      {
-        type: 'object',
-        properties: {
-          query: { 
-            type: 'string', 
-            description: '검색할 쿼리' 
-          },
-          token_budget: { 
-            type: 'number', 
-            description: '토큰 예산 (기본값: 1000)',
-            default: 1000
-          },
-          max_memories: { 
-            type: 'number', 
-            description: '최대 기억 개수 (기본값: 5)',
-            default: 5
-          },
-          memory_types: { 
-            type: 'array',
-            items: {
-              type: 'string',
-              enum: ['working', 'episodic', 'semantic', 'procedural']
-            },
-            description: '포함할 기억 타입들',
-            default: ['working', 'episodic', 'semantic', 'procedural']
-          },
-          importance_threshold: { 
-            type: 'number', 
-            description: '중요도 임계값 (기본값: 0.5)',
-            default: 0.5
-          }
-        },
-        required: ['query']
-      }
-    );
-  }
-
-  async handle(params: any, context: ToolContext): Promise<any> {
-    const {
-      query,
-      token_budget = 1000,
-      max_memories = 5,
-      memory_types = ['working', 'episodic', 'semantic', 'procedural'],
-      importance_threshold = 0.5
-    } = MemoryInjectionSchema.parse(params);
-
-    try {
-      console.log(`🧠 Memory Injection 시작: "${query}" (토큰 예산: ${token_budget})`);
-
-      if (!context.db) {
-        throw new Error('데이터베이스가 연결되지 않았습니다');
-      }
-
-      if (!context.services?.hybridSearchEngine) {
-        throw new Error('하이브리드 검색 엔진이 사용할 수 없습니다');
-      }
-
-      // 1. 관련 기억 검색
-      const searchResult = await context.services.hybridSearchEngine.search(context.db, {
-        query,
-        filters: {
-          type: memory_types.length === 4 ? undefined : memory_types as any,
-          importance_min: importance_threshold
-        },
-        limit: max_memories * 2, // 더 많은 후보를 가져와서 요약
-        vectorWeight: 0.7, // 의미적 유사성에 더 중점
-        textWeight: 0.3
-      });
-
-      const memories = searchResult.items;
-      console.log(`🔍 검색된 기억: ${memories.length}개`);
-
-      if (memories.length === 0) {
-        return this.createSuccessResult({
-          message: '관련 기억을 찾을 수 없습니다.',
-          memories_used: 0,
-          token_estimate: 0,
-          query: query
-        });
-      }
-
-      // 2. 기억 요약 및 토큰 예산 관리
-      const summary = await this.summarizeMemories(memories, token_budget, max_memories);
-
-      // 3. 프롬프트 형식으로 포맷팅
-      const formattedPrompt = this.formatMemoryPrompt(summary, query);
-
-      console.log(`✅ Memory Injection 완료: ${summary.length}개 기억, ${this.estimateTokens(formattedPrompt)} 토큰`);
-
-      return this.createSuccessResult({
-        message: formattedPrompt,
-        memories_used: summary.length,
-        token_estimate: this.estimateTokens(formattedPrompt),
-        query: query
-      });
-
-    } catch (error) {
-      console.error('❌ Memory Injection 실패:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 기억들을 요약하여 토큰 예산 내에서 관리
-   */
-  private async summarizeMemories(
-    memories: any[], 
-    tokenBudget: number, 
-    maxMemories: number
-  ): Promise<Array<{id: string, content: string, type: string, importance: number, summary: string}>> {
-    const summaries: Array<{id: string, content: string, type: string, importance: number, summary: string}> = [];
-    let usedTokens = 0;
-    const maxTokensPerMemory = Math.floor(tokenBudget / maxMemories);
-
-    // 중요도와 점수 순으로 정렬
-    const sortedMemories = memories
-      .sort((a, b) => (b.finalScore + b.importance) - (a.finalScore + a.importance))
-      .slice(0, maxMemories);
-
-    for (const memory of sortedMemories) {
-      if (usedTokens >= tokenBudget) break;
-
-      // 기억 내용 요약
-      const summary = this.summarizeMemoryContent(memory.content, maxTokensPerMemory);
-      const summaryTokens = this.estimateTokens(summary);
-
-      if (usedTokens + summaryTokens <= tokenBudget) {
-        summaries.push({
-          id: memory.id,
-          content: memory.content,
-          type: memory.type,
-          importance: memory.importance,
-          summary
-        });
-        usedTokens += summaryTokens;
-      }
-    }
-
-    return summaries;
-  }
-
-  /**
-   * 개별 기억 내용 요약
-   */
-  private summarizeMemoryContent(content: string, maxTokens: number): string {
-    // 간단한 요약 로직 (실제로는 더 정교한 요약 알고리즘 사용 가능)
-    const words = content.split(' ');
-    const maxWords = Math.floor(maxTokens / 1.5); // 대략적인 단어 수 계산
-
-    if (words.length <= maxWords) {
-      return content;
-    }
-
-    // 중요도 기반 요약 (첫 문장 + 마지막 문장 + 중간 핵심 내용)
-    const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
-    
-    if (sentences.length <= 2) {
-      return words.slice(0, maxWords).join(' ') + '...';
-    }
-
-    const firstSentence = sentences[0]?.trim() || '';
-    const lastSentence = sentences[sentences.length - 1]?.trim() || '';
-    const middleSentences = sentences.slice(1, -1);
-    
-    let summary = firstSentence;
-    let remainingWords = maxWords - firstSentence.split(' ').length;
-
-    if (remainingWords > 0 && middleSentences.length > 0) {
-      const middleText = middleSentences.join('. ');
-      const middleWords = middleText.split(' ');
-      const middleWordsToInclude = Math.min(remainingWords - lastSentence.split(' ').length, middleWords.length);
-      
-      if (middleWordsToInclude > 0) {
-        summary += ' ' + middleWords.slice(0, middleWordsToInclude).join(' ');
-        remainingWords -= middleWordsToInclude;
-      }
-    }
-
-    if (remainingWords > 0) {
-      summary += ' ' + lastSentence;
-    }
-
-    return summary + (summary.length < content.length ? '...' : '');
-  }
-
-  /**
-   * 프롬프트 형식으로 포맷팅
-   */
-  private formatMemoryPrompt(
-    summaries: Array<{id: string, content: string, type: string, importance: number, summary: string}>,
-    query: string
-  ): string {
-    if (summaries.length === 0) {
-      return '관련 기억을 찾을 수 없습니다.';
-    }
-
-    let prompt = `# 관련 기억 (${summaries.length}개)\n\n`;
-    prompt += `**검색 쿼리**: "${query}"\n\n`;
-
-    summaries.forEach((memory, index) => {
-      const typeEmoji = this.getMemoryTypeEmoji(memory.type);
-      const importanceStars = '★'.repeat(Math.ceil(memory.importance * 5));
-      
-      prompt += `## ${index + 1}. ${typeEmoji} ${memory.type.toUpperCase()} 기억\n`;
-      prompt += `**중요도**: ${importanceStars} (${memory.importance.toFixed(2)})\n`;
-      prompt += `**내용**: ${memory.summary}\n\n`;
-    });
-
-    prompt += '---\n';
-    prompt += '*이 기억들은 현재 대화와 관련된 맥락 정보입니다. 참고하여 더 정확하고 관련성 높은 답변을 제공하세요.*';
-
-    return prompt;
-  }
-
-  /**
-   * 기억 타입별 이모지
-   */
-  private getMemoryTypeEmoji(type: string): string {
-    const emojiMap: Record<string, string> = {
-      'working': '🧠',
-      'episodic': '📝',
-      'semantic': '📚',
-      'procedural': '⚙️'
-    };
-    return emojiMap[type] || '💭';
-  }
-
-  /**
-   * 토큰 수 추정 (간단한 추정)
-   */
-  private estimateTokens(text: string): number {
-    // 대략적인 토큰 수 추정 (실제로는 더 정확한 토크나이저 사용 가능)
-    return Math.ceil(text.length / 4);
-  }
-}

package/src/tools/performance-alerts.ts

@@ -1,226 +0,0 @@
-/**
- * 성능 알림 도구
- * 성능 알림 조회, 해결, 통계 확인을 위한 MCP 도구
- */
-
-import { z } from 'zod';
-import type { ToolContext } from './types.js';
-
-export const performanceAlertsTool = {
-  name: 'performance_alerts',
-  description: '성능 알림 정보를 조회하고 관리합니다',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ['stats', 'list', 'search', 'resolve'],
-        default: 'stats',
-        description: '수행할 작업'
-      },
-      hours: {
-        type: 'number',
-        minimum: 1,
-        maximum: 168,
-        default: 24,
-        description: '조회할 시간 범위 (시간 단위)'
-      },
-      level: {
-        type: 'string',
-        enum: ['info', 'warning', 'critical'],
-        description: '알림 레벨 필터'
-      },
-      type: {
-        type: 'string',
-        enum: ['response_time', 'memory_usage', 'error_rate', 'throughput', 'database_performance', 'cache_performance'],
-        description: '알림 타입 필터'
-      },
-      resolved: {
-        type: 'boolean',
-        description: '해결된 알림 포함 여부'
-      },
-      limit: {
-        type: 'number',
-        minimum: 1,
-        maximum: 100,
-        default: 50,
-        description: '결과 제한 수'
-      },
-      alertId: {
-        type: 'string',
-        description: '해결할 알림 ID (resolve 작업시)'
-      },
-      resolvedBy: {
-        type: 'string',
-        default: 'system',
-        description: '해결 처리자'
-      },
-      resolution: {
-        type: 'string',
-        description: '해결 사유'
-      }
-    },
-    required: []
-  }
-};
-
-export async function executePerformanceAlerts(args: any, context: ToolContext) {
-  const { action, hours, level, type, resolved, limit, alertId, resolvedBy, resolution } = args;
-  
-  try {
-    // 성능 알림 서비스가 없으면 기본 응답
-    if (!context.services.performanceAlertService) {
-      return {
-        success: false,
-        error: 'Performance alert service not available',
-        stats: {
-          totalAlerts: 0,
-          alertsByLevel: { info: 0, warning: 0, critical: 0 },
-          alertsByType: { response_time: 0, memory_usage: 0, error_rate: 0, throughput: 0, database_performance: 0, cache_performance: 0 },
-          recentAlerts: [],
-          averageResolutionTime: 0,
-          activeAlerts: 0
-        }
-      };
-    }
-
-    switch (action) {
-      case 'stats':
-        return await handleStats(context, hours);
-      
-      case 'list':
-        return await handleList(context, hours, limit);
-      
-      case 'search':
-        return await handleSearch(context, { level, type, resolved, hours, limit });
-      
-      case 'resolve':
-        return await handleResolve(context, alertId, resolvedBy, resolution);
-      
-      default:
-        return {
-          success: false,
-          error: `Unknown action: ${action}`
-        };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error'
-    };
-  }
-}
-
-async function handleStats(context: ToolContext, hours: number) {
-  const stats = context.services.performanceAlertService.getAlertStats(hours);
-  
-  return {
-    success: true,
-    stats: {
-      ...stats,
-      recentAlerts: stats.recentAlerts.map((alert: any) => ({
-        id: alert.id,
-        timestamp: alert.timestamp.toISOString(),
-        level: alert.level,
-        type: alert.type,
-        metric: alert.metric,
-        value: alert.value,
-        threshold: alert.threshold,
-        message: alert.message,
-        resolved: alert.resolved,
-        resolvedAt: alert.resolvedAt?.toISOString()
-      }))
-    },
-    summary: {
-      totalAlerts: stats.totalAlerts,
-      activeAlerts: stats.activeAlerts,
-      criticalAlerts: stats.alertsByLevel.critical,
-      averageResolutionTime: Math.round(stats.averageResolutionTime / 1000) // 초 단위로 변환
-    }
-  };
-}
-
-async function handleList(context: ToolContext, hours: number, limit: number) {
-  const activeAlerts = context.services.performanceAlertService.getActiveAlerts();
-  const recentAlerts = context.services.performanceAlertService.searchAlerts({
-    startDate: new Date(Date.now() - hours * 60 * 60 * 1000),
-    limit
-  });
-
-  return {
-    success: true,
-    activeAlerts: activeAlerts.map((alert: any) => ({
-      id: alert.id,
-      timestamp: alert.timestamp.toISOString(),
-      level: alert.level,
-      type: alert.type,
-      metric: alert.metric,
-      value: alert.value,
-      threshold: alert.threshold,
-      message: alert.message,
-      context: alert.context
-    })),
-    recentAlerts: recentAlerts.map((alert: any) => ({
-      id: alert.id,
-      timestamp: alert.timestamp.toISOString(),
-      level: alert.level,
-      type: alert.type,
-      metric: alert.metric,
-      value: alert.value,
-      threshold: alert.threshold,
-      message: alert.message,
-      resolved: alert.resolved,
-      resolvedAt: alert.resolvedAt?.toISOString()
-    }))
-  };
-}
-
-async function handleSearch(context: ToolContext, filters: any) {
-  const alerts = context.services.performanceAlertService.searchAlerts(filters);
-
-  return {
-    success: true,
-    alerts: alerts.map((alert: any) => ({
-      id: alert.id,
-      timestamp: alert.timestamp.toISOString(),
-      level: alert.level,
-      type: alert.type,
-      metric: alert.metric,
-      value: alert.value,
-      threshold: alert.threshold,
-      message: alert.message,
-      context: alert.context,
-      resolved: alert.resolved,
-      resolvedAt: alert.resolvedAt?.toISOString()
-    })),
-    total: alerts.length
-  };
-}
-
-async function handleResolve(context: ToolContext, alertId: string | undefined, resolvedBy: string, resolution?: string) {
-  if (!alertId) {
-    return {
-      success: false,
-      error: 'Alert ID is required for resolve action'
-    };
-  }
-
-  const success = context.services.performanceAlertService.resolveAlert(alertId, resolvedBy, resolution);
-  
-  if (!success) {
-    return {
-      success: false,
-      error: 'Alert not found or already resolved',
-      alertId
-    };
-  }
-
-  return {
-    success: true,
-    message: `Alert ${alertId} has been resolved by ${resolvedBy}`,
-    alertId,
-    resolvedBy,
-    resolution,
-    resolvedAt: new Date().toISOString()
-  };
-}

package/src/tools/performance-stats-tool.ts

@@ -1,48 +0,0 @@
-/**
- * Performance Stats Tool - 성능 통계 도구
- */
-
-import { z } from 'zod';
-import { BaseTool } from './base-tool.js';
-import type { ToolContext, ToolResult } from './types.js';
-
-const PerformanceStatsSchema = z.object({});
-
-export class PerformanceStatsTool extends BaseTool {
-  constructor() {
-    super(
-      'performance_stats',
-      '성능 통계를 조회합니다',
-      {
-        type: 'object',
-        properties: {}
-      }
-    );
-  }
-
-  async handle(params: any, context: ToolContext): Promise<ToolResult> {
-    // 데이터베이스 연결 확인
-    this.validateDatabase(context);
-    
-    // 성능 모니터 확인
-    this.validateService(context.services.performanceMonitor, '성능 모니터');
-    
-    try {
-      const metrics = await context.services.performanceMonitor.collectMetrics();
-      const report = await context.services.performanceMonitor.generateReport();
-      
-      return this.createSuccessResult({
-        metrics: {
-          database: metrics.database,
-          search: metrics.search,
-          memory: metrics.memory,
-          system: metrics.system
-        },
-        report: report,
-        message: '성능 통계 조회 완료'
-      });
-    } catch (error) {
-      throw new Error(`성능 통계 조회 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}