memento-mcp-server 0.1.0 → 1.7.1

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

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

@@ -1,189 +0,0 @@
-/**
- * 기본 도구 클래스
- * 모든 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

@@ -1,77 +0,0 @@
-/**
- * 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

@@ -1,79 +0,0 @@
-/**
- * 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'}`);
-    }
-  }
-}