memento-mcp-server 0.1.0 → 1.7.1

package/src/services/error-logging-service.ts

@@ -1,383 +0,0 @@
-/**
- * 에러 로깅 서비스
- * 구조화된 에러 로깅, 분류, 모니터링, 알림 시스템
- */
-
-export enum ErrorSeverity {
-  LOW = 'low',
-  MEDIUM = 'medium',
-  HIGH = 'high',
-  CRITICAL = 'critical'
-}
-
-export enum ErrorCategory {
-  DATABASE = 'database',
-  NETWORK = 'network',
-  VALIDATION = 'validation',
-  AUTHENTICATION = 'authentication',
-  PERFORMANCE = 'performance',
-  MEMORY = 'memory',
-  SEARCH = 'search',
-  EMBEDDING = 'embedding',
-  CACHE = 'cache',
-  UNKNOWN = 'unknown'
-}
-
-export interface ErrorLog {
-  id: string;
-  timestamp: Date;
-  severity: ErrorSeverity;
-  category: ErrorCategory;
-  message: string;
-  stack?: string;
-  context: {
-    userId?: string;
-    sessionId?: string;
-    requestId?: string;
-    operation?: string;
-    component?: string;
-    [key: string]: any;
-  };
-  metadata: {
-    userAgent?: string;
-    ipAddress?: string;
-    memoryUsage?: NodeJS.MemoryUsage;
-    cpuUsage?: NodeJS.CpuUsage;
-    [key: string]: any;
-  };
-  resolved: boolean;
-  resolvedAt?: Date;
-  resolvedBy?: string;
-}
-
-export interface ErrorStats {
-  totalErrors: number;
-  errorsBySeverity: Record<ErrorSeverity, number>;
-  errorsByCategory: Record<ErrorCategory, number>;
-  errorsByHour: Record<string, number>;
-  averageResolutionTime: number;
-  criticalErrors: number;
-  recentErrors: ErrorLog[];
-}
-
-export interface ErrorAlert {
-  id: string;
-  errorId: string;
-  severity: ErrorSeverity;
-  message: string;
-  timestamp: Date;
-  acknowledged: boolean;
-  acknowledgedAt?: Date;
-  acknowledgedBy?: string;
-}
-
-export class ErrorLoggingService {
-  private errors: Map<string, ErrorLog> = new Map();
-  private alerts: Map<string, ErrorAlert> = new Map();
-  private maxErrors: number = 10000;
-  private maxAlerts: number = 1000;
-  private alertThresholds: Map<ErrorSeverity, number> = new Map([
-    [ErrorSeverity.LOW, 100],
-    [ErrorSeverity.MEDIUM, 50],
-    [ErrorSeverity.HIGH, 10],
-    [ErrorSeverity.CRITICAL, 1]
-  ]);
-
-  /**
-   * 에러 로깅
-   */
-  logError(
-    error: Error | string,
-    severity: ErrorSeverity = ErrorSeverity.MEDIUM,
-    category: ErrorCategory = ErrorCategory.UNKNOWN,
-    context: Partial<ErrorLog['context']> = {},
-    metadata: Partial<ErrorLog['metadata']> = {}
-  ): string {
-    const errorId = this.generateErrorId();
-    const timestamp = new Date();
-    
-    const errorMessage = typeof error === 'string' ? error : error.message;
-    const stack = typeof error === 'string' ? undefined : error.stack;
-    
-    const errorLog: ErrorLog = {
-      id: errorId,
-      timestamp,
-      severity,
-      category,
-      message: errorMessage,
-      stack,
-      context: {
-        ...context,
-        component: context.component || 'unknown'
-      },
-      metadata: {
-        ...metadata,
-        memoryUsage: process.memoryUsage(),
-        cpuUsage: process.cpuUsage()
-      },
-      resolved: false
-    };
-
-    this.errors.set(errorId, errorLog);
-    this.cleanupOldErrors();
-    
-    // 심각도에 따른 알림 생성
-    this.checkAlertThresholds(errorLog);
-    
-    // 콘솔 출력 (개발 환경)
-    this.logToConsole(errorLog);
-    
-    return errorId;
-  }
-
-  /**
-   * 에러 해결 처리
-   */
-  resolveError(errorId: string, resolvedBy: string = 'system'): boolean {
-    const error = this.errors.get(errorId);
-    if (!error) {
-      return false;
-    }
-
-    error.resolved = true;
-    error.resolvedAt = new Date();
-    error.resolvedBy = resolvedBy;
-    
-    return true;
-  }
-
-  /**
-   * 에러 통계 조회
-   */
-  getErrorStats(hours: number = 24): ErrorStats {
-    const cutoffTime = new Date(Date.now() - hours * 60 * 60 * 1000);
-    const recentErrors = Array.from(this.errors.values())
-      .filter(error => error.timestamp >= cutoffTime);
-
-    const errorsBySeverity: Record<ErrorSeverity, number> = {
-      [ErrorSeverity.LOW]: 0,
-      [ErrorSeverity.MEDIUM]: 0,
-      [ErrorSeverity.HIGH]: 0,
-      [ErrorSeverity.CRITICAL]: 0
-    };
-
-    const errorsByCategory: Record<ErrorCategory, number> = {
-      [ErrorCategory.DATABASE]: 0,
-      [ErrorCategory.NETWORK]: 0,
-      [ErrorCategory.VALIDATION]: 0,
-      [ErrorCategory.AUTHENTICATION]: 0,
-      [ErrorCategory.PERFORMANCE]: 0,
-      [ErrorCategory.MEMORY]: 0,
-      [ErrorCategory.SEARCH]: 0,
-      [ErrorCategory.EMBEDDING]: 0,
-      [ErrorCategory.CACHE]: 0,
-      [ErrorCategory.UNKNOWN]: 0
-    };
-
-    const errorsByHour: Record<string, number> = {};
-
-    recentErrors.forEach(error => {
-      errorsBySeverity[error.severity]++;
-      errorsByCategory[error.category]++;
-      
-      const hour = error.timestamp.toISOString().substring(0, 13);
-      errorsByHour[hour] = (errorsByHour[hour] || 0) + 1;
-    });
-
-    const resolvedErrors = recentErrors.filter(error => error.resolved);
-    const averageResolutionTime = resolvedErrors.length > 0 
-      ? resolvedErrors.reduce((sum, error) => {
-          if (error.resolvedAt) {
-            return sum + (error.resolvedAt.getTime() - error.timestamp.getTime());
-          }
-          return sum;
-        }, 0) / resolvedErrors.length
-      : 0;
-
-    return {
-      totalErrors: recentErrors.length,
-      errorsBySeverity,
-      errorsByCategory,
-      errorsByHour,
-      averageResolutionTime,
-      criticalErrors: errorsBySeverity[ErrorSeverity.CRITICAL],
-      recentErrors: recentErrors.slice(-10).reverse()
-    };
-  }
-
-  /**
-   * 활성 알림 조회
-   */
-  getActiveAlerts(): ErrorAlert[] {
-    return Array.from(this.alerts.values())
-      .filter(alert => !alert.acknowledged)
-      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-  }
-
-  /**
-   * 알림 확인 처리
-   */
-  acknowledgeAlert(alertId: string, acknowledgedBy: string = 'system'): boolean {
-    const alert = this.alerts.get(alertId);
-    if (!alert) {
-      return false;
-    }
-
-    alert.acknowledged = true;
-    alert.acknowledgedAt = new Date();
-    alert.acknowledgedBy = acknowledgedBy;
-    
-    return true;
-  }
-
-  /**
-   * 에러 검색
-   */
-  searchErrors(filters: {
-    severity?: ErrorSeverity;
-    category?: ErrorCategory;
-    resolved?: boolean;
-    startDate?: Date;
-    endDate?: Date;
-    limit?: number;
-  } = {}): ErrorLog[] {
-    let results = Array.from(this.errors.values());
-
-    if (filters.severity) {
-      results = results.filter(error => error.severity === filters.severity);
-    }
-
-    if (filters.category) {
-      results = results.filter(error => error.category === filters.category);
-    }
-
-    if (filters.resolved !== undefined) {
-      results = results.filter(error => error.resolved === filters.resolved);
-    }
-
-    if (filters.startDate) {
-      results = results.filter(error => error.timestamp >= filters.startDate!);
-    }
-
-    if (filters.endDate) {
-      results = results.filter(error => error.timestamp <= filters.endDate!);
-    }
-
-    results.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-
-    if (filters.limit) {
-      results = results.slice(0, filters.limit);
-    }
-
-    return results;
-  }
-
-  /**
-   * 에러 ID 생성
-   */
-  private generateErrorId(): string {
-    return `err_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * 오래된 에러 정리
-   */
-  private cleanupOldErrors(): void {
-    if (this.errors.size <= this.maxErrors) {
-      return;
-    }
-
-    const sortedErrors = Array.from(this.errors.entries())
-      .sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());
-
-    const toDelete = sortedErrors.slice(0, this.errors.size - this.maxErrors);
-    toDelete.forEach(([id]) => this.errors.delete(id));
-  }
-
-  /**
-   * 알림 임계값 확인
-   */
-  private checkAlertThresholds(error: ErrorLog): void {
-    const threshold = this.alertThresholds.get(error.severity);
-    if (!threshold) {
-      return;
-    }
-
-    const recentErrors = Array.from(this.errors.values())
-      .filter(e => 
-        e.severity === error.severity && 
-        e.timestamp >= new Date(Date.now() - 60 * 60 * 1000) // 최근 1시간
-      );
-
-    if (recentErrors.length >= threshold) {
-      this.createAlert(error);
-    }
-  }
-
-  /**
-   * 알림 생성
-   */
-  private createAlert(error: ErrorLog): void {
-    const alertId = `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    
-    const alert: ErrorAlert = {
-      id: alertId,
-      errorId: error.id,
-      severity: error.severity,
-      message: `High error rate detected: ${error.severity} level errors`,
-      timestamp: new Date(),
-      acknowledged: false
-    };
-
-    this.alerts.set(alertId, alert);
-    this.cleanupOldAlerts();
-  }
-
-  /**
-   * 오래된 알림 정리
-   */
-  private cleanupOldAlerts(): void {
-    if (this.alerts.size <= this.maxAlerts) {
-      return;
-    }
-
-    const sortedAlerts = Array.from(this.alerts.entries())
-      .sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());
-
-    const toDelete = sortedAlerts.slice(0, this.alerts.size - this.maxAlerts);
-    toDelete.forEach(([id]) => this.alerts.delete(id));
-  }
-
-  /**
-   * 콘솔 로깅
-   */
-  private logToConsole(error: ErrorLog): void {
-    const severityColors = {
-      [ErrorSeverity.LOW]: '\x1b[36m', // cyan
-      [ErrorSeverity.MEDIUM]: '\x1b[33m', // yellow
-      [ErrorSeverity.HIGH]: '\x1b[31m', // red
-      [ErrorSeverity.CRITICAL]: '\x1b[41m\x1b[37m' // red background, white text
-    };
-
-    const resetColor = '\x1b[0m';
-    const color = severityColors[error.severity] || '';
-    
-    console.error(
-      `${color}[${error.severity.toUpperCase()}] ${error.category.toUpperCase()}${resetColor}\n` +
-      `  ID: ${error.id}\n` +
-      `  Time: ${error.timestamp.toISOString()}\n` +
-      `  Message: ${error.message}\n` +
-      `  Component: ${error.context.component}\n` +
-      (error.stack ? `  Stack: ${error.stack}\n` : '') +
-      `  Context: ${JSON.stringify(error.context, null, 2)}\n`
-    );
-  }
-
-  /**
-   * 서비스 정리
-   */
-  cleanup(): void {
-    this.errors.clear();
-    this.alerts.clear();
-  }
-}

package/src/services/forgetting-policy-service.spec.ts

@@ -1,140 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import Database from 'better-sqlite3';
-import { ForgettingPolicyService } from './forgetting-policy-service.js';
-import { DatabaseUtils } from '../utils/database.js';
-
-const daysAgo = (days: number): string => {
-  const date = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-  return date.toISOString();
-};
-
-const closeDatabase = (db: Database.Database): void => {
-  db.close();
-};
-
-describe('ForgettingPolicyService.executeMemoryCleanup', () => {
-  let db: Database.Database;
-  let service: ForgettingPolicyService;
-
-  beforeEach(async () => {
-    db = new Database(':memory:');
-    service = new ForgettingPolicyService({ hardDeleteThreshold: 0.7 });
-
-    await DatabaseUtils.exec(
-      db,
-      `CREATE TABLE memory_item (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        content TEXT NOT NULL,
-        importance REAL NOT NULL,
-        privacy_scope TEXT DEFAULT 'private',
-        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-        last_accessed TEXT,
-        pinned BOOLEAN DEFAULT FALSE,
-        tags TEXT,
-        source TEXT,
-        embedding BLOB,
-        view_count INTEGER DEFAULT 0,
-        cite_count INTEGER DEFAULT 0,
-        edit_count INTEGER DEFAULT 0
-      )`
-    );
-
-    await DatabaseUtils.run(
-      db,
-      `INSERT INTO memory_item (id, type, content, importance, created_at, last_accessed, pinned, view_count, cite_count, edit_count)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        'memory-soft',
-        'episodic',
-        '오래되었지만 하드 삭제 기준은 넘지 않은 기억',
-        0.1,
-        daysAgo(60),
-        null,
-        0,
-        0,
-        0,
-        0
-      ]
-    );
-
-    await DatabaseUtils.run(
-      db,
-      `INSERT INTO memory_item (id, type, content, importance, created_at, last_accessed, pinned, view_count, cite_count, edit_count)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        'memory-hard',
-        'episodic',
-        '매우 오래되어 하드 삭제 대상이 되는 기억',
-        0.1,
-        daysAgo(400),
-        null,
-        0,
-        0,
-        0,
-        0
-      ]
-    );
-
-    await DatabaseUtils.run(
-      db,
-      `INSERT INTO memory_item (id, type, content, importance, created_at, last_accessed, pinned, view_count, cite_count, edit_count)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        'memory-recent',
-        'episodic',
-        '최근에 접근된 중요한 기억',
-        0.9,
-        daysAgo(5),
-        new Date().toISOString(),
-        0,
-        5,
-        1,
-        0
-      ]
-    );
-  });
-
-  afterEach(() => {
-    closeDatabase(db);
-  });
-
-  it('망각 정책에 따라 소프트/하드 삭제 및 리뷰 업데이트를 수행한다', async () => {
-    const result = await service.executeMemoryCleanup(db);
-
-    expect(result.totalProcessed).toBe(3);
-
-    expect(result.softDeleted).toContain('memory-soft');
-    expect(result.softDeleted).toContain('memory-hard');
-    expect(result.hardDeleted).toContain('memory-hard');
-    expect(result.hardDeleted).not.toContain('memory-soft');
-
-    expect(result.reviewed).toEqual(expect.arrayContaining(['memory-soft', 'memory-hard']));
-    expect(result.reviewed).not.toContain('memory-recent');
-
-    expect(result.summary.actualSoftDeletes).toBe(2);
-    expect(result.summary.actualHardDeletes).toBe(1);
-    expect(result.summary.actualReviews).toBe(2);
-
-    const softRow = await DatabaseUtils.get(
-      db,
-      'SELECT id, last_accessed FROM memory_item WHERE id = ?',
-      ['memory-soft']
-    );
-    expect(softRow).toBeDefined();
-    expect(softRow.last_accessed).not.toBeNull();
-
-    const hardRow = await DatabaseUtils.get(
-      db,
-      'SELECT id FROM memory_item WHERE id = ?',
-      ['memory-hard']
-    );
-    expect(hardRow).toBeUndefined();
-
-    const remainingIds = await DatabaseUtils.all(
-      db,
-      'SELECT id FROM memory_item ORDER BY id'
-    );
-    expect(remainingIds.map((row: any) => row.id)).toEqual(['memory-recent', 'memory-soft']);
-  });
-});