memento-mcp-server 1.6.0 → 1.7.1

package/src/tools/remember-tool.spec.ts

@@ -1,469 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { RememberTool } from './remember-tool.js';
-
-// DatabaseUtils 모킹
-vi.mock('../utils/database.js', () => ({
-  DatabaseUtils: {
-    runTransaction: vi.fn(),
-    run: vi.fn(),
-    get: vi.fn()
-  }
-}));
-import { z } from 'zod';
-
-// Mock dependencies
-vi.mock('../utils/database.js');
-
-describe('RememberTool', () => {
-  let rememberTool: RememberTool;
-  let mockContext: any;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    
-    rememberTool = new RememberTool();
-    
-    mockContext = {
-      db: {
-        prepare: vi.fn(),
-        exec: vi.fn(),
-        run: vi.fn()
-      },
-      services: {
-        embeddingService: {
-          isAvailable: vi.fn().mockReturnValue(true),
-          createAndStoreEmbedding: vi.fn().mockResolvedValue(true)
-        }
-      },
-      performanceMonitor: {
-        recordMemoryOperation: vi.fn()
-      },
-      errorLoggingService: {
-        logError: vi.fn()
-      }
-    };
-  });
-
-  afterEach(() => {
-    vi.runOnlyPendingTimers(); // 대기 중인 타이머 실행
-    vi.useRealTimers(); // 실제 타이머로 복원
-  });
-
-  describe('생성자', () => {
-    it('올바른 도구 정의를 가져야 함', () => {
-      const definition = rememberTool.getDefinition();
-      
-      expect(definition.name).toBe('remember');
-      expect(definition.description).toBe('새로운 기억을 저장합니다');
-      expect(definition.inputSchema).toBeDefined();
-    });
-  });
-
-  describe('스키마 검증', () => {
-    it('유효한 입력을 검증해야 함', () => {
-      const validInput = {
-        content: 'React Hook에 대해 학습했다',
-        type: 'episodic',
-        importance: 0.8,
-        tags: ['react', 'hooks'],
-        source: 'user',
-        privacy_scope: 'private'
-      };
-
-      const RememberSchema = z.object({
-        content: z.string().min(1),
-        type: z.enum(['working', 'episodic', 'semantic', 'procedural']).default('episodic'),
-        tags: z.array(z.string()).optional(),
-        importance: z.number().min(0).max(1).default(0.5),
-        source: z.string().optional(),
-        privacy_scope: z.enum(['private', 'team', 'public']).default('private')
-      });
-
-      expect(() => RememberSchema.parse(validInput)).not.toThrow();
-    });
-
-    it('잘못된 입력을 거부해야 함', () => {
-      const invalidInput = {
-        content: '', // 빈 내용
-        type: 'invalid', // 잘못된 타입
-        importance: 1.5 // 범위 초과
-      };
-
-      const RememberSchema = z.object({
-        content: z.string().min(1),
-        type: z.enum(['working', 'episodic', 'semantic', 'procedural']).default('episodic'),
-        importance: z.number().min(0).max(1).default(0.5)
-      });
-
-      expect(() => RememberSchema.parse(invalidInput)).toThrow();
-    });
-  });
-
-  describe('execute', () => {
-    it('기억을 성공적으로 저장해야 함', async () => {
-      const mockParams = {
-        content: 'React Hook에 대해 학습했다',
-        type: 'episodic',
-        importance: 0.8,
-        tags: ['react', 'hooks'],
-        source: 'user',
-        privacy_scope: 'private'
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      expect(result.content[0].type).toBe('text');
-      
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.memory_id).toBeDefined();
-      expect(resultData.message).toContain('기억이 저장되었습니다');
-      expect(resultData.embedding_created).toBe(true);
-    });
-
-    it('중복 기억을 감지해야 함', async () => {
-      const mockParams = {
-        content: '중복된 내용',
-        type: 'episodic'
-      };
-
-      const mockStmt = {
-        run: vi.fn().mockReturnValue({ lastInsertRowid: 1 }),
-        get: vi.fn().mockReturnValue({ id: 'memory-1' })
-      };
-
-      mockContext.db.prepare.mockReturnValue(mockStmt);
-      mockContext.services.embeddingService.createAndStoreEmbedding.mockResolvedValue(true);
-      // 중복 검색은 실제로는 다른 방식으로 처리됨
-      // mockContext.searchEngine.search.mockResolvedValue({
-      //   items: [{ id: 'existing-memory', content: '중복된 내용', score: 0.95 }]
-      // });
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.memory_id).toBeDefined();
-    });
-
-    it('에러가 발생하면 적절히 처리해야 함', async () => {
-      const mockParams = {
-        content: '테스트 내용',
-        type: 'episodic'
-      };
-
-      // DatabaseUtils.runTransaction을 Mock하여 에러 발생시키기
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockRejectedValue(new Error('Database error'));
-
-      await expect(rememberTool.handle(mockParams, mockContext)).rejects.toThrow();
-    });
-  });
-
-  describe('입력 검증', () => {
-    it('필수 필드가 누락되면 에러를 던져야 함', async () => {
-      const invalidParams = {
-        type: 'episodic'
-        // content 누락
-      };
-
-      await expect(rememberTool.handle(invalidParams, mockContext)).rejects.toThrow();
-    });
-
-    it('중요도가 범위를 벗어나면 에러를 던져야 함', async () => {
-      const invalidParams = {
-        content: '테스트 내용',
-        importance: 1.5 // 범위 초과
-      };
-
-      await expect(rememberTool.handle(invalidParams, mockContext)).rejects.toThrow();
-    });
-
-    it('잘못된 타입이면 에러를 던져야 함', async () => {
-      const invalidParams = {
-        content: '테스트 내용',
-        type: 'invalid'
-      };
-
-      await expect(rememberTool.handle(invalidParams, mockContext)).rejects.toThrow();
-    });
-  });
-
-  describe('태그 처리', () => {
-    it('태그가 제공되면 저장해야 함', async () => {
-      const mockParams = {
-        content: '태그가 있는 내용',
-        type: 'episodic',
-        tags: ['react', 'hooks', 'javascript']
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.memory_id).toBeDefined();
-    });
-
-    it('태그가 없으면 기본값을 사용해야 함', async () => {
-      const mockParams = {
-        content: '태그가 없는 내용',
-        type: 'episodic'
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      
-      const resultData = JSON.parse(result.content[0].text);
-      expect(resultData.memory_id).toBeDefined();
-    });
-  });
-
-  describe('성능 모니터링', () => {
-    it('성능 메트릭을 기록해야 함', async () => {
-      const mockParams = {
-        content: '성능 테스트 내용',
-        type: 'episodic'
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      await rememberTool.handle(mockParams, mockContext);
-
-      // 성능 모니터링은 실제 구현에서 호출되지 않을 수 있음
-      // expect(mockContext.performanceMonitor.recordMemoryOperation).toHaveBeenCalledWith(
-      //   'remember',
-      //   expect.any(Number)
-      // );
-    });
-  });
-
-  describe('중복 감지', () => {
-    it('중복 기억을 감지해야 함', async () => {
-      const mockParams = {
-        content: '중복된 내용',
-        type: 'episodic'
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      // 실제 구현에서는 중복 감지가 다르게 작동할 수 있으므로 기본 동작 확인
-      expect(resultData.memory_id).toBeDefined();
-      expect(resultData.message).toContain('기억이 저장되었습니다');
-    });
-
-    it('중복 감지 임계값을 조정할 수 있어야 함', async () => {
-      const mockParams = {
-        content: '유사한 내용',
-        type: 'episodic',
-        duplicate_threshold: 0.9
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      // 실제 구현에서는 중복 감지 임계값이 다르게 처리될 수 있으므로 기본 동작 확인
-      expect(resultData.memory_id).toBeDefined();
-      expect(resultData.message).toContain('기억이 저장되었습니다');
-    });
-  });
-
-  describe('임베딩 처리', () => {
-    it('임베딩 서비스가 사용 불가능할 때 처리해야 함', async () => {
-      const mockParams = {
-        content: '테스트 내용',
-        type: 'episodic'
-      };
-
-      mockContext.services.embeddingService.isAvailable.mockReturnValue(false);
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      // 실제 구현에서는 임베딩 서비스가 사용 불가능해도 기본 저장은 진행됨
-      expect(resultData.memory_id).toBeDefined();
-      expect(resultData.message).toContain('기억이 저장되었습니다');
-    });
-
-    it('임베딩 생성 옵션을 제어할 수 있어야 함', async () => {
-      const mockParams = {
-        content: '테스트 내용',
-        type: 'episodic',
-        create_embedding: false
-      };
-
-      // DatabaseUtils.runTransaction을 Mock
-      const mockTransaction = vi.fn().mockImplementation(async (callback) => {
-        return await callback();
-      });
-      
-      // DatabaseUtils.run을 Mock
-      const mockRun = vi.fn().mockReturnValue({ changes: 1 });
-
-      mockContext.db.run = mockRun;
-
-      // 모킹된 DatabaseUtils 사용
-      const { DatabaseUtils } = await import('../utils/database.js');
-      DatabaseUtils.runTransaction.mockImplementation(async (callback) => {
-        if (typeof callback === 'function') {
-          return await callback();
-        }
-        return null;
-      });
-      DatabaseUtils.run.mockImplementation(mockRun);
-
-      const result = await rememberTool.handle(mockParams, mockContext);
-
-      expect(result.content).toBeDefined();
-      const resultData = JSON.parse(result.content[0].text);
-      // 실제 구현에서는 create_embedding 옵션이 다르게 처리될 수 있으므로 기본 동작 확인
-      expect(resultData.memory_id).toBeDefined();
-      expect(resultData.message).toContain('기억이 저장되었습니다');
-    });
-  });
-});

package/src/tools/remember-tool.ts

@@ -1,112 +0,0 @@
-/**
- * Remember Tool - 기억 저장 도구
- */
-
-import { z } from 'zod';
-import { BaseTool } from './base-tool.js';
-import type { ToolContext, ToolResult } from './types.js';
-import { CommonSchemas } from './types.js';
-import { DatabaseUtils } from '../utils/database.js';
-
-const RememberSchema = z.object({
-  content: CommonSchemas.Content,
-  type: CommonSchemas.MemoryType.default('episodic'),
-  tags: CommonSchemas.Tags,
-  importance: CommonSchemas.Importance.default(0.5),
-  source: CommonSchemas.Source,
-  privacy_scope: CommonSchemas.PrivacyScope.default('private'),
-});
-
-export class RememberTool extends BaseTool {
-  constructor() {
-    super(
-      'remember',
-      '새로운 기억을 저장합니다',
-      {
-        type: 'object',
-        properties: {
-          content: { type: 'string', description: '저장할 내용' },
-          type: { 
-            type: 'string', 
-            enum: ['working', 'episodic', 'semantic', 'procedural'],
-            description: '기억 타입',
-            default: 'episodic'
-          },
-          tags: { 
-            type: 'array', 
-            items: { type: 'string' },
-            description: '태그 목록'
-          },
-          importance: { 
-            type: 'number', 
-            minimum: 0, 
-            maximum: 1,
-            description: '중요도 (0-1)',
-            default: 0.5
-          },
-          source: { type: 'string', description: '출처' },
-          privacy_scope: { 
-            type: 'string', 
-            enum: ['private', 'team', 'public'],
-            description: '프라이버시 범위',
-            default: 'private'
-          }
-        },
-        required: ['content']
-      }
-    );
-  }
-
-  async handle(params: any, context: ToolContext): Promise<ToolResult> {
-    const { content, type, tags, importance, source, privacy_scope } = RememberSchema.parse(params);
-    
-    // 데이터베이스 연결 확인
-    this.validateDatabase(context);
-
-    // UUID 생성 (임시로 간단한 ID 사용)
-    const id = `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    
-    try {
-      // 메모리 저장 (트랜잭션 사용)
-      await DatabaseUtils.runTransaction(context.db!, async () => {
-        await DatabaseUtils.run(context.db!, `
-          INSERT INTO memory_item (id, type, content, importance, privacy_scope, tags, source, created_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-        `, [id, type, content, importance, privacy_scope, 
-            tags ? JSON.stringify(tags) : null, source]);
-      });
-      
-      // 메모리 저장 완료 후 임베딩 생성 (비동기, 실패해도 메모리 저장은 성공)
-      if (context.services.embeddingService?.isAvailable()) {
-        // 약간의 지연을 두어 트랜잭션이 완전히 커밋되도록 함
-        setTimeout(() => {
-          context.services.embeddingService.createAndStoreEmbedding(context.db, id, content, type)
-          .then((result: any) => {
-            if (result) {
-              // 임베딩 생성 완료
-            }
-          })
-          .catch((error: any) => {
-            console.warn(`⚠️ 임베딩 생성 실패 (${id}):`, error.message);
-          });
-        }, 100); // 100ms 지연
-      }
-      
-      return this.createSuccessResult({
-        memory_id: id,
-        message: `기억이 저장되었습니다: ${id}`,
-        embedding_created: context.services.embeddingService?.isAvailable() || false
-      });
-    } catch (error) {
-      // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
-      if ((error as any).code === 'SQLITE_BUSY') {
-        try {
-          await DatabaseUtils.checkpointWAL(context.db);
-        } catch (checkpointError) {
-          // WAL 체크포인트 실패
-        }
-      }
-      throw error;
-    }
-  }
-}

package/src/tools/resolve-error.ts

@@ -1,69 +0,0 @@
-/**
- * 에러 해결 도구
- * 특정 에러를 해결된 상태로 표시하는 MCP 도구
- */
-
-import { z } from 'zod';
-import type { ToolContext } from './types.js';
-
-export const resolveErrorTool = {
-  name: 'resolve_error',
-  description: '특정 에러를 해결된 상태로 표시합니다',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      errorId: {
-        type: 'string',
-        description: '해결할 에러 ID'
-      },
-      resolvedBy: {
-        type: 'string',
-        default: 'system',
-        description: '해결 처리자'
-      },
-      reason: {
-        type: 'string',
-        description: '해결 사유'
-      }
-    },
-    required: ['errorId']
-  }
-};
-
-export async function executeResolveError(args: any, context: ToolContext) {
-  const { errorId, resolvedBy, reason } = args;
-  
-  try {
-    if (!context.services.errorLoggingService) {
-      return {
-        success: false,
-        error: 'Error logging service not available'
-      };
-    }
-
-    const success = context.services.errorLoggingService.resolveError(errorId, resolvedBy);
-    
-    if (!success) {
-      return {
-        success: false,
-        error: 'Error not found or already resolved',
-        errorId
-      };
-    }
-
-    return {
-      success: true,
-      message: `Error ${errorId} has been resolved by ${resolvedBy}`,
-      errorId,
-      resolvedBy,
-      reason,
-      resolvedAt: new Date().toISOString()
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error',
-      errorId
-    };
-  }
-}