memento-mcp-server 0.1.0

package/src/test/test-vector-search-engine.ts

@@ -0,0 +1,303 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { getVectorSearchEngine, VectorSearchEngine } from '../algorithms/vector-search-engine.js';
+import Database from 'better-sqlite3';
+import { DatabaseUtils } from '../utils/database.js';
+
+// Mock sqlite-vec functions
+const mockVecSearch = vi.fn();
+const mockVecDistance = vi.fn();
+
+// Mock sqlite-vec extension
+vi.mock('better-sqlite3', async () => {
+  const actual = await vi.importActual('better-sqlite3');
+  return {
+    ...actual,
+    default: class MockDatabase extends actual.default {
+      constructor(...args: any[]) {
+        super(...args);
+        // Mock sqlite-vec functions
+        this.function('vec_search', mockVecSearch);
+        this.function('vec_distance', mockVecDistance);
+      }
+    }
+  };
+});
+
+describe('VectorSearchEngine', () => {
+  let db: Database.Database;
+  let vectorSearchEngine: VectorSearchEngine;
+
+  beforeEach(() => {
+    // Create in-memory database for testing
+    db = new Database(':memory:');
+    DatabaseUtils.initializeDatabase(db);
+    
+    vectorSearchEngine = getVectorSearchEngine();
+    vectorSearchEngine.initialize(db);
+  });
+
+  afterEach(() => {
+    if (db) {
+      db.close();
+    }
+    vi.clearAllMocks();
+  });
+
+  describe('초기화', () => {
+    it('should initialize successfully', () => {
+      expect(() => vectorSearchEngine.initialize(db)).not.toThrow();
+    });
+
+    it('should check VSS availability', () => {
+      const status = vectorSearchEngine.getIndexStatus();
+      expect(status).toHaveProperty('available');
+      expect(status).toHaveProperty('dimensions');
+      expect(typeof status.available).toBe('boolean');
+      expect(typeof status.dimensions).toBe('number');
+    });
+  });
+
+  describe('인덱스 상태', () => {
+    it('should return correct dimensions', () => {
+      const status = vectorSearchEngine.getIndexStatus();
+      expect(status.dimensions).toBe(1536); // Default embedding dimensions
+    });
+  });
+
+  describe('벡터 검색', () => {
+    const testQueryVector = Array(1536).fill(0.1);
+    const mockSearchResults = [
+      { memory_id: 'test1', similarity: 0.95 },
+      { memory_id: 'test2', similarity: 0.87 },
+      { memory_id: 'test3', similarity: 0.76 }
+    ];
+
+    beforeEach(() => {
+      // Setup mock VSS search results
+      mockVssSearchRbf.mockReturnValue(0.95);
+      mockVssSearch.mockReturnValue(0.95);
+    });
+
+    it('should return empty array when not initialized', async () => {
+      const newEngine = getVectorSearchEngine();
+      const results = await newEngine.search(testQueryVector);
+      expect(results).toEqual([]);
+    });
+
+    it('should return empty array when VSS not available', async () => {
+      // Mock VSS not available
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue({
+          get: vi.fn().mockReturnValue(null)
+        })
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector);
+      expect(results).toEqual([]);
+    });
+
+    it('should perform basic vector search', async () => {
+      // Mock database query results
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue(mockSearchResults)
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector);
+      
+      expect(mockQuery).toHaveBeenCalled();
+      expect(results).toHaveLength(3);
+      expect(results[0]).toHaveProperty('memory_id');
+      expect(results[0]).toHaveProperty('similarity');
+    });
+
+    it('should apply similarity threshold', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue(mockSearchResults)
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector, { threshold: 0.8 });
+      
+      expect(mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('WHERE similarity >= ?'),
+        expect.any(String),
+        0.8,
+        expect.any(Number)
+      );
+    });
+
+    it('should apply limit', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue(mockSearchResults)
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector, { limit: 5 });
+      
+      expect(mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('LIMIT ?'),
+        expect.any(String),
+        expect.any(Number),
+        5
+      );
+    });
+
+    it('should filter by type', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue(mockSearchResults)
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector, { 
+        type: ['episodic', 'semantic'] 
+      });
+      
+      expect(mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('AND vss.rowid IN'),
+        expect.any(String),
+        expect.any(Number),
+        'episodic',
+        'semantic',
+        expect.any(Number)
+      );
+    });
+
+    it('should include content when requested', async () => {
+      const mockSearchQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue(mockSearchResults)
+      });
+      
+      const mockContentQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([
+          { id: 'test1', content: 'Test content 1', type: 'episodic', importance: 0.5, created_at: '2024-01-01' },
+          { id: 'test2', content: 'Test content 2', type: 'semantic', importance: 0.7, created_at: '2024-01-02' }
+        ])
+      });
+      
+      const mockDb = {
+        prepare: vi.fn()
+          .mockReturnValueOnce(mockSearchQuery)
+          .mockReturnValueOnce(mockContentQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector, { 
+        includeContent: true 
+      });
+      
+      expect(results[0]).toHaveProperty('content');
+      expect(results[0]).toHaveProperty('type');
+      expect(results[0]).toHaveProperty('importance');
+      expect(results[0]).toHaveProperty('created_at');
+    });
+
+    it('should handle empty search results', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([])
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector);
+      expect(results).toEqual([]);
+    });
+
+    it('should handle database errors gracefully', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockImplementation(() => {
+          throw new Error('Database error');
+        })
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      const results = await newEngine.search(testQueryVector);
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('기본값 처리', () => {
+    it('should use default options when none provided', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([])
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      await newEngine.search(testQueryVector);
+      
+      expect(mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('LIMIT ?'),
+        expect.any(String),
+        0.7, // default threshold
+        10   // default limit
+      );
+    });
+  });
+
+  describe('JSON 직렬화', () => {
+    it('should serialize query vector to JSON', async () => {
+      const mockQuery = vi.fn().mockReturnValue({
+        all: vi.fn().mockReturnValue([])
+      });
+      
+      const mockDb = {
+        prepare: vi.fn().mockReturnValue(mockQuery)
+      };
+      
+      const newEngine = getVectorSearchEngine();
+      newEngine.initialize(mockDb as any);
+      
+      await newEngine.search(testQueryVector);
+      
+      const callArgs = mockQuery.mock.calls[0];
+      const queryVectorJson = callArgs[0];
+      expect(queryVectorJson).toBe(JSON.stringify(testQueryVector));
+    });
+  });
+});

package/src/tools/base-tool.ts

@@ -0,0 +1,189 @@
+/**
+ * 기본 도구 클래스
+ * 모든 MCP 도구의 기본 구조를 제공
+ */
+
+import type { ToolDefinition, ToolHandler, ToolContext, ToolResult, ToolError } from './types.js';
+
+export abstract class BaseTool {
+  protected name: string;
+  protected description: string;
+  protected inputSchema: any;
+
+  constructor(name: string, description: string, inputSchema: any) {
+    this.name = name;
+    this.description = description;
+    this.inputSchema = inputSchema;
+  }
+
+  /**
+   * 도구 정의 반환
+   */
+  getDefinition(): ToolDefinition {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema,
+      handler: this.handle.bind(this),
+    };
+  }
+
+  /**
+   * 도구 실행 (추상 메서드)
+   */
+  abstract handle(params: any, context: ToolContext): Promise<ToolResult>;
+
+  /**
+   * 성공 결과 생성
+   */
+  protected createSuccessResult(data: any): ToolResult {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(data, null, 2),
+        },
+      ],
+    };
+  }
+
+  /**
+   * 에러 결과 생성
+   */
+  protected createErrorResult(error: string, message?: string, details?: string): ToolError {
+    return {
+      error,
+      ...(message && { message }),
+      ...(details && { details }),
+    };
+  }
+
+  /**
+   * 안전한 JSON 파싱
+   */
+  protected safeJsonParse(jsonString: string, fallback: any = null): any {
+    try {
+      return JSON.parse(jsonString);
+    } catch (error) {
+      console.warn(`JSON 파싱 실패: ${error instanceof Error ? error.message : String(error)}`);
+      return fallback;
+    }
+  }
+
+  /**
+   * 안전한 문자열 검증
+   */
+  protected validateString(value: any, fieldName: string, maxLength: number = 1000): string {
+    if (typeof value !== 'string') {
+      throw new Error(`${fieldName}은 문자열이어야 합니다`);
+    }
+    
+    if (value.length === 0) {
+      throw new Error(`${fieldName}은 비어있을 수 없습니다`);
+    }
+    
+    if (value.length > maxLength) {
+      throw new Error(`${fieldName}은 ${maxLength}자를 초과할 수 없습니다`);
+    }
+    
+    return value.trim();
+  }
+
+  /**
+   * 안전한 숫자 검증
+   */
+  protected validateNumber(value: any, fieldName: string, min?: number, max?: number): number {
+    const num = Number(value);
+    
+    if (isNaN(num)) {
+      throw new Error(`${fieldName}은 유효한 숫자여야 합니다`);
+    }
+    
+    if (min !== undefined && num < min) {
+      throw new Error(`${fieldName}은 ${min} 이상이어야 합니다`);
+    }
+    
+    if (max !== undefined && num > max) {
+      throw new Error(`${fieldName}은 ${max} 이하여야 합니다`);
+    }
+    
+    return num;
+  }
+
+  /**
+   * 안전한 배열 검증
+   */
+  protected validateArray(value: any, fieldName: string, maxLength: number = 100): any[] {
+    if (!Array.isArray(value)) {
+      throw new Error(`${fieldName}은 배열이어야 합니다`);
+    }
+    
+    if (value.length > maxLength) {
+      throw new Error(`${fieldName}은 ${maxLength}개를 초과할 수 없습니다`);
+    }
+    
+    return value;
+  }
+
+  /**
+   * 에러 로깅
+   */
+  protected logError(error: Error, context: string, additionalData?: any): void {
+    const errorInfo = {
+      tool: this.name,
+      context,
+      error: error.message,
+      stack: error.stack,
+      timestamp: new Date().toISOString(),
+      ...additionalData
+    };
+    
+    console.error(`[${this.name}] ${context}:`, errorInfo);
+  }
+
+  /**
+   * 경고 로깅
+   */
+  protected logWarning(message: string, additionalData?: any): void {
+    const warningInfo = {
+      tool: this.name,
+      message,
+      timestamp: new Date().toISOString(),
+      ...additionalData
+    };
+    
+    console.warn(`[${this.name}] ${message}:`, warningInfo);
+  }
+
+  /**
+   * 정보 로깅
+   */
+  protected logInfo(message: string, additionalData?: any): void {
+    const infoData = {
+      tool: this.name,
+      message,
+      timestamp: new Date().toISOString(),
+      ...additionalData
+    };
+    
+    console.log(`[${this.name}] ${message}:`, infoData);
+  }
+
+  /**
+   * 데이터베이스 연결 확인
+   */
+  protected validateDatabase(context: ToolContext): void {
+    if (!context.db) {
+      throw new Error('데이터베이스가 초기화되지 않았습니다');
+    }
+  }
+
+  /**
+   * 서비스 확인
+   */
+  protected validateService(service: any, serviceName: string): void {
+    if (!service) {
+      throw new Error(`${serviceName}이 초기화되지 않았습니다`);
+    }
+  }
+}

package/src/tools/cleanup-memory-tool.ts

@@ -0,0 +1,77 @@
+/**
+ * Cleanup Memory Tool - 메모리 정리 도구
+ */
+
+import { z } from 'zod';
+import { BaseTool } from './base-tool.js';
+import type { ToolContext, ToolResult } from './types.js';
+import { CommonSchemas } from './types.js';
+
+const CleanupMemorySchema = z.object({
+  dry_run: CommonSchemas.DryRun,
+});
+
+export class CleanupMemoryTool extends BaseTool {
+  constructor() {
+    super(
+      'cleanup_memory',
+      '망각 정책에 따라 메모리를 정리합니다',
+      {
+        type: 'object',
+        properties: {
+          dry_run: { 
+            type: 'boolean', 
+            description: '드라이런 모드 (실제 삭제 없이 분석만)',
+            default: false
+          }
+        }
+      }
+    );
+  }
+
+  async handle(params: any, context: ToolContext): Promise<ToolResult> {
+    const { dry_run } = CleanupMemorySchema.parse(params);
+    
+    // 데이터베이스 연결 확인
+    this.validateDatabase(context);
+    
+    // 망각 정책 서비스 확인
+    this.validateService(context.services.forgettingPolicyService, '망각 정책 서비스');
+    
+    try {
+      if (dry_run) {
+        // 드라이런 모드: 실제 삭제 없이 분석만 수행
+        const stats = await context.services.forgettingPolicyService.generateForgettingStats(context.db);
+        
+        return this.createSuccessResult({
+          mode: 'dry_run',
+          stats: {
+            totalMemories: stats.totalMemories,
+            forgetCandidates: stats.forgetCandidates,
+            reviewCandidates: stats.reviewCandidates,
+            averageForgetScore: stats.averageForgetScore,
+            memoryDistribution: stats.memoryDistribution
+          },
+          message: '망각 후보 분석 완료 (실제 삭제 없음)'
+        });
+      } else {
+        // 실제 정리 실행
+        const result = await context.services.forgettingPolicyService.executeMemoryCleanup(context.db);
+        
+        return this.createSuccessResult({
+          mode: 'execution',
+          result: {
+            softDeleted: result.softDeleted,
+            hardDeleted: result.hardDeleted,
+            reviewed: result.reviewed,
+            totalProcessed: result.totalProcessed,
+            summary: result.summary
+          },
+          message: `메모리 정리 완료: 소프트 삭제 ${result.summary.actualSoftDeletes}개, 하드 삭제 ${result.summary.actualHardDeletes}개, 리뷰 ${result.summary.actualReviews}개`
+        });
+      }
+    } catch (error) {
+      throw new Error(`메모리 정리 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}

package/src/tools/database-optimize-tool.ts

@@ -0,0 +1,79 @@
+/**
+ * Database Optimize Tool - 데이터베이스 최적화 도구
+ */
+
+import { z } from 'zod';
+import { BaseTool } from './base-tool.js';
+import type { ToolContext, ToolResult } from './types.js';
+import { CommonSchemas } from './types.js';
+
+const DatabaseOptimizeSchema = z.object({
+  analyze: CommonSchemas.Analyze,
+  create_indexes: CommonSchemas.CreateIndexes,
+});
+
+export class DatabaseOptimizeTool extends BaseTool {
+  constructor() {
+    super(
+      'database_optimize',
+      '데이터베이스 최적화를 수행합니다',
+      {
+        type: 'object',
+        properties: {
+          analyze: { 
+            type: 'boolean', 
+            description: '데이터베이스 분석 실행',
+            default: false
+          },
+          create_indexes: { 
+            type: 'boolean', 
+            description: '추천 인덱스 생성',
+            default: false
+          }
+        }
+      }
+    );
+  }
+
+  async handle(params: any, context: ToolContext): Promise<ToolResult> {
+    const { analyze, create_indexes } = DatabaseOptimizeSchema.parse(params);
+    
+    // 데이터베이스 연결 확인
+    this.validateDatabase(context);
+    
+    // 데이터베이스 최적화기 확인
+    this.validateService(context.services.databaseOptimizer, '데이터베이스 최적화기');
+    
+    try {
+      const results: any = {
+        message: '데이터베이스 최적화 완료',
+        operations: []
+      };
+      
+      if (analyze) {
+        await context.services.databaseOptimizer.analyzeDatabase();
+        results.operations.push('데이터베이스 분석 완료');
+      }
+      
+      if (create_indexes) {
+        const recommendations = await context.services.databaseOptimizer.generateIndexRecommendations();
+        const highPriorityRecs = recommendations.filter((r: any) => r.priority === 'high');
+        
+        for (const rec of highPriorityRecs) {
+          const indexName = `idx_${rec.table}_${rec.columns.join('_')}`;
+          await context.services.databaseOptimizer.createIndex(indexName, rec.table, rec.columns);
+          results.operations.push(`인덱스 생성: ${indexName}`);
+        }
+      }
+      
+      const report = await context.services.databaseOptimizer.generateOptimizationReport();
+      
+      return this.createSuccessResult({
+        ...results,
+        report: report
+      });
+    } catch (error) {
+      throw new Error(`데이터베이스 최적화 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}