memento-mcp-server 1.6.0 → 1.7.1

package/.cursor/rules/testing.mdc

@@ -1,473 +0,0 @@
----
-globs: *.test.ts,*.spec.ts,*.test.js,*.spec.js
-description: 테스트 작성 및 실행 규칙
----
-
-# 테스트 규칙
-
-## 🧪 테스트 프레임워크
-
-### Jest 설정
-```json
-{
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node",
-    "roots": ["<rootDir>/src", "<rootDir>/tests"],
-    "testMatch": ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
-    "collectCoverageFrom": [
-      "src/**/*.ts",
-      "!src/**/*.d.ts",
-      "!src/**/index.ts"
-    ],
-    "coverageThreshold": {
-      "global": {
-        "branches": 80,
-        "functions": 80,
-        "lines": 80,
-        "statements": 80
-      }
-    }
-  }
-}
-```
-
-## 📝 테스트 작성 규칙
-
-### 파일 명명
-- **단위 테스트**: `*.test.ts`
-- **통합 테스트**: `*.integration.test.ts`
-- **E2E 테스트**: `*.e2e.test.ts`
-- **픽스처**: `*.fixture.ts`
-
-### 테스트 구조 (AAA 패턴)
-```typescript
-describe('MemoryManager', () => {
-  describe('remember', () => {
-    it('should store memory successfully', async () => {
-      // Arrange (준비)
-      const memoryManager = new MemoryManager(mockClient);
-      const content = 'Test memory content';
-      const options = { type: 'episodic', importance: 0.8 };
-      
-      // Act (실행)
-      const result = await memoryManager.remember(content, options);
-      
-      // Assert (검증)
-      expect(result).toBeDefined();
-      expect(typeof result).toBe('string');
-    });
-  });
-});
-```
-
-## 🔧 단위 테스트
-
-### MCP Tools 테스트
-```typescript
-// tests/unit/tools/remember.test.ts
-import { RememberTool } from '@/server/tools/remember';
-import { MemoryRepository } from '@/server/database/memory-repository';
-
-describe('RememberTool', () => {
-  let rememberTool: RememberTool;
-  let mockRepository: jest.Mocked<MemoryRepository>;
-  
-  beforeEach(() => {
-    mockRepository = {
-      create: jest.fn(),
-      findById: jest.fn(),
-      update: jest.fn(),
-      delete: jest.fn()
-    } as any;
-    
-    rememberTool = new RememberTool(mockRepository);
-  });
-  
-  it('should create memory with valid parameters', async () => {
-    // Given
-    const params = {
-      content: 'Test content',
-      type: 'episodic',
-      importance: 0.8
-    };
-    
-    mockRepository.create.mockResolvedValue('memory-123');
-    
-    // When
-    const result = await rememberTool.execute(params);
-    
-    // Then
-    expect(result).toEqual({ memory_id: 'memory-123' });
-    expect(mockRepository.create).toHaveBeenCalledWith({
-      content: 'Test content',
-      type: 'episodic',
-      importance: 0.8,
-      created_at: expect.any(Date)
-    });
-  });
-  
-  it('should throw error for invalid content', async () => {
-    // Given
-    const params = { content: '', type: 'episodic' };
-    
-    // When & Then
-    await expect(rememberTool.execute(params))
-      .rejects
-      .toThrow('Content cannot be empty');
-  });
-});
-```
-
-### 알고리즘 테스트
-```typescript
-// tests/unit/algorithms/search-ranking.test.ts
-import { SearchRanking } from '@/algorithms/search-ranking';
-
-describe('SearchRanking', () => {
-  let searchRanking: SearchRanking;
-  
-  beforeEach(() => {
-    searchRanking = new SearchRanking();
-  });
-  
-  describe('calculateFinalScore', () => {
-    it('should calculate correct final score', () => {
-      // Given
-      const features = {
-        relevance: 0.8,
-        recency: 0.6,
-        importance: 0.7,
-        usage: 0.5,
-        duplication_penalty: 0.2
-      };
-      
-      // When
-      const score = searchRanking.calculateFinalScore(features);
-      
-      // Then
-      expect(score).toBeCloseTo(0.8 * 0.5 + 0.6 * 0.2 + 0.7 * 0.2 + 0.5 * 0.1 - 0.2 * 0.15);
-    });
-  });
-});
-```
-
-## 🔗 통합 테스트
-
-### MCP 서버 통합 테스트
-```typescript
-// tests/integration/mcp-server.test.ts
-import { MCPClient } from '@modelcontextprotocol/sdk';
-import { MCPServer } from '@/server';
-
-describe('MCP Server Integration', () => {
-  let server: MCPServer;
-  let client: MCPClient;
-  
-  beforeAll(async () => {
-    // 서버 시작
-    server = new MCPServer();
-    await server.start();
-    
-    // 클라이언트 연결
-    client = new MCPClient({
-      name: 'test-client',
-      version: '1.0.0'
-    });
-    await client.connect({
-      command: 'node',
-      args: ['dist/server/index.js']
-    });
-  });
-  
-  afterAll(async () => {
-    await client.close();
-    await server.stop();
-  });
-  
-  it('should handle remember tool', async () => {
-    // Given
-    const params = {
-      content: 'Integration test memory',
-      type: 'episodic'
-    };
-    
-    // When
-    const result = await client.callTool('remember', params);
-    
-    // Then
-    expect(result).toHaveProperty('memory_id');
-    expect(typeof result.memory_id).toBe('string');
-  });
-  
-  it('should handle recall tool', async () => {
-    // Given
-    const query = 'test memory';
-    
-    // When
-    const result = await client.callTool('recall', { query });
-    
-    // Then
-    expect(Array.isArray(result.items)).toBe(true);
-  });
-});
-```
-
-### 데이터베이스 통합 테스트
-```typescript
-// tests/integration/database.test.ts
-import { Database } from '@/server/database';
-import { MemoryItem } from '@/shared/types';
-
-describe('Database Integration', () => {
-  let db: Database;
-  
-  beforeAll(async () => {
-    db = new Database(':memory:'); // 인메모리 SQLite
-    await db.initialize();
-  });
-  
-  afterAll(async () => {
-    await db.close();
-  });
-  
-  beforeEach(async () => {
-    await db.clear(); // 각 테스트 전 데이터 정리
-  });
-  
-  it('should create and retrieve memory', async () => {
-    // Given
-    const memory: Omit<MemoryItem, 'id' | 'created_at'> = {
-      content: 'Test memory',
-      type: 'episodic',
-      importance: 0.8
-    };
-    
-    // When
-    const created = await db.createMemory(memory);
-    const retrieved = await db.getMemory(created.id);
-    
-    // Then
-    expect(retrieved).toMatchObject(memory);
-    expect(retrieved.id).toBe(created.id);
-  });
-});
-```
-
-## 🎭 Mock 및 Stub
-
-### MCP 클라이언트 Mock
-```typescript
-// tests/mocks/mcp-client.mock.ts
-export class MockMCPClient {
-  private tools: Map<string, jest.Mock> = new Map();
-  
-  constructor() {
-    this.setupDefaultMocks();
-  }
-  
-  private setupDefaultMocks() {
-    this.tools.set('remember', jest.fn().mockResolvedValue({ memory_id: 'mock-123' }));
-    this.tools.set('recall', jest.fn().mockResolvedValue({ items: [] }));
-    this.tools.set('forget', jest.fn().mockResolvedValue({ success: true }));
-  }
-  
-  async callTool(name: string, params: any) {
-    const mock = this.tools.get(name);
-    if (!mock) {
-      throw new Error(`Tool ${name} not found`);
-    }
-    return mock(params);
-  }
-  
-  setMockTool(name: string, mock: jest.Mock) {
-    this.tools.set(name, mock);
-  }
-}
-```
-
-### 데이터베이스 Mock
-```typescript
-// tests/mocks/database.mock.ts
-export class MockDatabase {
-  private memories: Map<string, MemoryItem> = new Map();
-  
-  async createMemory(memory: Omit<MemoryItem, 'id' | 'created_at'>): Promise<MemoryItem> {
-    const id = `memory-${Date.now()}`;
-    const created: MemoryItem = {
-      ...memory,
-      id,
-      created_at: new Date()
-    };
-    this.memories.set(id, created);
-    return created;
-  }
-  
-  async getMemory(id: string): Promise<MemoryItem | null> {
-    return this.memories.get(id) || null;
-  }
-  
-  async searchMemories(query: string): Promise<MemoryItem[]> {
-    return Array.from(this.memories.values())
-      .filter(memory => memory.content.includes(query));
-  }
-}
-```
-
-## 📊 테스트 커버리지
-
-### 커버리지 설정
-```json
-{
-  "jest": {
-    "collectCoverageFrom": [
-      "src/**/*.ts",
-      "!src/**/*.d.ts",
-      "!src/**/index.ts",
-      "!src/**/*.test.ts",
-      "!src/**/*.spec.ts"
-    ],
-    "coverageReporters": ["text", "lcov", "html"],
-    "coverageDirectory": "coverage"
-  }
-}
-```
-
-### 커버리지 임계값
-```json
-{
-  "jest": {
-    "coverageThreshold": {
-      "global": {
-        "branches": 80,
-        "functions": 80,
-        "lines": 80,
-        "statements": 80
-      },
-      "./src/server/": {
-        "branches": 90,
-        "functions": 90,
-        "lines": 90,
-        "statements": 90
-      }
-    }
-  }
-}
-```
-
-## 🚀 테스트 실행
-
-### npm 스크립트
-```json
-{
-  "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:unit": "jest --testPathPattern=unit",
-    "test:integration": "jest --testPathPattern=integration",
-    "test:e2e": "jest --testPathPattern=e2e",
-    "test:ci": "jest --ci --coverage --watchAll=false"
-  }
-}
-```
-
-### 테스트 실행 명령어
-```bash
-# 모든 테스트 실행
-npm test
-
-# 감시 모드
-npm run test:watch
-
-# 커버리지 포함
-npm run test:coverage
-
-# 단위 테스트만
-npm run test:unit
-
-# 통합 테스트만
-npm run test:integration
-
-# CI 환경
-npm run test:ci
-```
-
-## 🔍 테스트 디버깅
-
-### Jest 디버깅
-```bash
-# 특정 테스트 디버깅
-npm test -- --testNamePattern="should create memory"
-
-# 상세 로그
-npm test -- --verbose
-
-# 실패한 테스트만 재실행
-npm test -- --onlyFailures
-```
-
-### VS Code 디버깅 설정
-```json
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Debug Jest Tests",
-      "type": "node",
-      "request": "launch",
-      "program": "${workspaceFolder}/node_modules/.bin/jest",
-      "args": ["--runInBand"],
-      "console": "integratedTerminal",
-      "internalConsoleOptions": "neverOpen"
-    }
-  ]
-}
-```
-
-## 📋 테스트 체크리스트
-
-### 단위 테스트
-- [ ] 모든 public 메서드 테스트
-- [ ] 경계값 테스트 (null, undefined, 빈 문자열)
-- [ ] 예외 상황 테스트
-- [ ] Mock 사용으로 외부 의존성 격리
-
-### 통합 테스트
-- [ ] MCP 서버와 클라이언트 통신
-- [ ] 데이터베이스 CRUD 작업
-- [ ] 검색 알고리즘 동작
-- [ ] 에러 처리 및 복구
-
-### E2E 테스트
-- [ ] 전체 워크플로우 테스트
-- [ ] 사용자 시나리오 테스트
-- [ ] 성능 테스트
-- [ ] 보안 테스트
-
-## 🎯 테스트 모범 사례
-
-### 1. 테스트 명명
-- **Given-When-Then** 패턴 사용
-- 구체적이고 명확한 테스트 이름
-- 예: `should return error when content is empty`
-
-### 2. 테스트 격리
-- 각 테스트는 독립적으로 실행 가능
-- 공유 상태 사용 금지
-- 테스트 간 의존성 제거
-
-### 3. 테스트 데이터
-- 픽스처 파일로 테스트 데이터 관리
-- 실제 데이터와 유사한 테스트 데이터 사용
-- 민감한 정보는 마스킹
-
-### 4. 에러 테스트
-- 정상 케이스와 에러 케이스 모두 테스트
-- 예외 메시지 검증
-- 로깅 및 모니터링 테스트
-
-### 5. 성능 테스트
-- 응답 시간 측정
-- 메모리 사용량 모니터링
-- 동시성 테스트

package/.dockerignore

@@ -1,15 +0,0 @@
-node_modules
-npm-debug.log
-.git
-.gitignore
-README.md
-.env
-.nyc_output
-coverage
-.vscode
-.idea
-*.log
-dist
-src/**/*.test.ts
-src/**/*.spec.ts
-test-*.ts

package/.eslintrc.json

@@ -1,34 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es2022": true
-  },
-  "extends": [
-    "eslint:recommended",
-    "@typescript-eslint/recommended"
-  ],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module",
-    "project": "./tsconfig.json"
-  },
-  "plugins": [
-    "@typescript-eslint"
-  ],
-  "rules": {
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "@typescript-eslint/no-non-null-assertion": "warn",
-    "prefer-const": "error",
-    "no-var": "error",
-    "no-console": "warn"
-  },
-  "ignorePatterns": [
-    "dist/",
-    "node_modules/",
-    "*.js"
-  ]
-}

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,51 +0,0 @@
----
-name: 버그 리포트
-about: 버그를 발견하셨나요? 이 템플릿을 사용하여 리포트해주세요.
-title: '[BUG] '
-labels: ['bug', 'needs-triage']
-assignees: ''
----
-
-## 🐛 버그 설명
-버그에 대한 명확하고 간결한 설명을 작성해주세요.
-
-## 🔄 재현 단계
-버그를 재현하는 단계를 작성해주세요:
-
-1. '...'로 이동
-2. '...'를 클릭
-3. '...'까지 스크롤
-4. 오류 확인
-
-## 🎯 예상 동작
-어떻게 동작해야 하는지 명확하고 간결한 설명을 작성해주세요.
-
-## 💥 실제 동작
-실제로 어떻게 동작하는지 명확하고 간결한 설명을 작성해주세요.
-
-## 📸 스크린샷
-가능하다면 스크린샷을 추가하여 문제를 설명해주세요.
-
-## 🖥️ 환경 정보
-다음 정보를 작성해주세요:
-
-- **OS**: [예: Windows 10, macOS 12.0, Ubuntu 20.04]
-- **Node.js 버전**: [예: 20.0.0]
-- **Memento 버전**: [예: 0.1.0]
-- **브라우저**: [예: Chrome 91, Firefox 89] (웹 관련 버그인 경우)
-
-## 📋 추가 컨텍스트
-문제에 대한 다른 컨텍스트나 정보를 추가해주세요.
-
-## 🔍 로그
-관련 로그가 있다면 여기에 붙여넣어주세요:
-
-```
-로그 내용을 여기에 붙여넣어주세요
-```
-
-## ✅ 체크리스트
-- [ ] 이슈가 이미 존재하지 않는지 확인했습니다
-- [ ] 최신 버전에서 문제가 발생하는지 확인했습니다
-- [ ] 문제를 재현할 수 있습니다
-- [ ] 필요한 정보를 모두 제공했습니다

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,45 +0,0 @@
----
-name: 기능 제안
-about: 새로운 기능을 제안하고 싶으신가요? 이 템플릿을 사용해주세요.
-title: '[FEATURE] '
-labels: ['enhancement', 'needs-triage']
-assignees: ''
----
-
-## 🚀 기능 설명
-원하는 기능에 대한 명확하고 간결한 설명을 작성해주세요.
-
-## 💡 동기
-이 기능이 왜 필요한지 설명해주세요. 어떤 문제를 해결하나요?
-
-## 📝 상세 설명
-기능이 어떻게 동작해야 하는지 자세히 설명해주세요.
-
-## 🎯 사용 사례
-이 기능을 사용할 구체적인 시나리오를 설명해주세요:
-
-1. 사용자가 ...를 하고 싶을 때
-2. 사용자가 ...를 해야 할 때
-3. 사용자가 ...를 원할 때
-
-## 🔧 구현 아이디어
-구현 방법에 대한 아이디어가 있다면 작성해주세요. (선택사항)
-
-## 📊 우선순위
-이 기능의 중요도를 평가해주세요:
-
-- [ ] 매우 중요 (핵심 기능)
-- [ ] 중요 (사용성 향상)
-- [ ] 보통 (편의 기능)
-- [ ] 낮음 (선택적 기능)
-
-## 🔗 관련 이슈
-관련된 다른 이슈나 토론이 있다면 링크해주세요.
-
-## 📸 목업/스크린샷
-UI 관련 기능인 경우 목업이나 스크린샷을 추가해주세요.
-
-## ✅ 체크리스트
-- [ ] 이슈가 이미 존재하지 않는지 확인했습니다
-- [ ] 기능이 기존 기능과 중복되지 않는지 확인했습니다
-- [ ] 필요한 정보를 모두 제공했습니다

package/.github/ISSUE_TEMPLATE/question.md

@@ -1,31 +0,0 @@
----
-name: 질문
-about: 질문이 있으신가요? 이 템플릿을 사용해주세요.
-title: '[QUESTION] '
-labels: ['question', 'needs-triage']
-assignees: ''
----
-
-## ❓ 질문
-질문을 명확하고 간결하게 작성해주세요.
-
-## 🔍 시도해본 것
-이미 시도해본 방법이나 해결책이 있다면 설명해주세요.
-
-## 📚 참고 자료
-관련 문서나 자료가 있다면 링크해주세요.
-
-## 🖥️ 환경 정보
-필요한 경우 환경 정보를 제공해주세요:
-
-- **OS**: [예: Windows 10, macOS 12.0, Ubuntu 20.04]
-- **Node.js 버전**: [예: 20.0.0]
-- **Memento 버전**: [예: 0.1.0]
-
-## 📋 추가 컨텍스트
-질문에 대한 다른 컨텍스트나 정보를 추가해주세요.
-
-## ✅ 체크리스트
-- [ ] 질문이 명확하게 작성되었습니다
-- [ ] 관련 정보를 모두 제공했습니다
-- [ ] 기존 문서를 확인했습니다