memento-mcp-server 0.1.0

package/packages/mcp-client/test-integration.js

@@ -0,0 +1,366 @@
+/**
+ * @memento/client 통합 테스트
+ * 
+ * 이 파일은 실제 Memento MCP 서버와의 연동을 테스트합니다.
+ * 테스트 실행 전에 Memento MCP 서버가 실행 중이어야 합니다.
+ * 
+ * 서버 실행: npm run dev:http
+ */
+
+const { MementoClient, MemoryManager, ContextInjector } = require('./dist/index.js');
+
+class IntegrationTester {
+  constructor() {
+    this.client = new MementoClient({
+      serverUrl: 'http://localhost:3000',
+      logLevel: 'info',
+      timeout: 15000,
+      retryCount: 3
+    });
+    
+    this.manager = new MemoryManager(this.client);
+    this.injector = new ContextInjector(this.client);
+    this.testResults = [];
+  }
+
+  async runAllTests() {
+    console.log('🧪 @memento/client 통합 테스트 시작\n');
+    console.log('📋 테스트 전제조건:');
+    console.log('  - Memento MCP 서버가 http://localhost:3000에서 실행 중이어야 함');
+    console.log('  - 서버 실행 명령: npm run dev:http\n');
+
+    try {
+      // 1. 서버 연결 테스트
+      await this.testServerConnection();
+      
+      // 2. 기본 CRUD 테스트
+      await this.testBasicCRUD();
+      
+      // 3. 검색 기능 테스트
+      await this.testSearchFeatures();
+      
+      // 4. 컨텍스트 주입 테스트
+      await this.testContextInjection();
+      
+      // 5. 고급 기능 테스트
+      await this.testAdvancedFeatures();
+      
+      // 6. 에러 처리 테스트
+      await this.testErrorHandling();
+      
+      // 7. 성능 테스트
+      await this.testPerformance();
+      
+      // 테스트 결과 요약
+      this.printTestSummary();
+      
+    } catch (error) {
+      console.error('❌ 통합 테스트 실패:', error.message);
+      console.error('스택 트레이스:', error.stack);
+    } finally {
+      // 정리 작업
+      await this.cleanup();
+    }
+  }
+
+  async testServerConnection() {
+    console.log('🔌 1. 서버 연결 테스트');
+    
+    try {
+      await this.client.connect();
+      this.recordTest('서버 연결', true, '서버에 성공적으로 연결됨');
+      
+      // 서버 상태 확인
+      const health = await this.client.healthCheck();
+      this.recordTest('서버 상태 확인', true, `서버 상태: ${health.status}`);
+      
+    } catch (error) {
+      this.recordTest('서버 연결', false, `연결 실패: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async testBasicCRUD() {
+    console.log('\n📝 2. 기본 CRUD 테스트');
+    
+    try {
+      // 기억 생성
+      const memory = await this.manager.create({
+        content: '통합 테스트용 기억입니다. React Hook에 대해 학습했습니다.',
+        type: 'episodic',
+        importance: 0.8,
+        tags: ['test', 'react', 'integration'],
+        source: 'integration-test'
+      });
+      
+      this.recordTest('기억 생성', true, `생성된 기억 ID: ${memory.id}`);
+      
+      // 기억 조회
+      const retrieved = await this.manager.get(memory.id);
+      this.recordTest('기억 조회', !!retrieved, retrieved ? '기억 조회 성공' : '기억 조회 실패');
+      
+      // 기억 업데이트
+      const updated = await this.manager.update(memory.id, {
+        importance: 0.9,
+        tags: ['test', 'react', 'integration', 'updated']
+      });
+      
+      this.recordTest('기억 업데이트', true, `중요도: ${updated.importance}`);
+      
+      // 기억 고정
+      await this.manager.pin(memory.id);
+      this.recordTest('기억 고정', true, '기억이 고정됨');
+      
+      // 테스트용 기억 ID 저장 (정리용)
+      this.testMemoryId = memory.id;
+      
+    } catch (error) {
+      this.recordTest('기본 CRUD', false, `CRUD 테스트 실패: ${error.message}`);
+    }
+  }
+
+  async testSearchFeatures() {
+    console.log('\n🔍 3. 검색 기능 테스트');
+    
+    try {
+      // 기본 검색
+      const searchResults = await this.manager.search('React Hook', {
+        limit: 5
+      });
+      
+      this.recordTest('기본 검색', searchResults.total_count > 0, 
+        `검색 결과: ${searchResults.total_count}개`);
+      
+      // 태그 검색
+      const tagResults = await this.manager.searchByTags(['test', 'react']);
+      this.recordTest('태그 검색', tagResults.total_count > 0, 
+        `태그 검색 결과: ${tagResults.total_count}개`);
+      
+      // 타입별 검색
+      const typeResults = await this.manager.searchByType('episodic');
+      this.recordTest('타입별 검색', typeResults.total_count > 0, 
+        `타입별 검색 결과: ${typeResults.total_count}개`);
+      
+      // 하이브리드 검색
+      const hybridResults = await this.manager.search('React Hook', {
+        useHybrid: true,
+        limit: 3
+      });
+      
+      this.recordTest('하이브리드 검색', hybridResults.total_count > 0, 
+        `하이브리드 검색 결과: ${hybridResults.total_count}개`);
+      
+    } catch (error) {
+      this.recordTest('검색 기능', false, `검색 테스트 실패: ${error.message}`);
+    }
+  }
+
+  async testContextInjection() {
+    console.log('\n💭 4. 컨텍스트 주입 테스트');
+    
+    try {
+      // 기본 컨텍스트 주입
+      const context = await this.injector.inject('React 개발 질문', {
+        tokenBudget: 1000,
+        contextType: 'conversation'
+      });
+      
+      this.recordTest('컨텍스트 주입', !!context.content, 
+        `주입된 컨텍스트 길이: ${context.content.length}자`);
+      
+      // 대화 컨텍스트 주입
+      const conversationContext = await this.injector.injectConversationContext(
+        '프로그래밍 학습', 800
+      );
+      
+      this.recordTest('대화 컨텍스트', !!conversationContext.content, 
+        '대화 컨텍스트 주입 성공');
+      
+      // 학습 컨텍스트 주입
+      const learningContext = await this.injector.injectLearningContext(
+        'React Hook', 1200
+      );
+      
+      this.recordTest('학습 컨텍스트', !!learningContext.content, 
+        '학습 컨텍스트 주입 성공');
+      
+    } catch (error) {
+      this.recordTest('컨텍스트 주입', false, `컨텍스트 주입 실패: ${error.message}`);
+    }
+  }
+
+  async testAdvancedFeatures() {
+    console.log('\n🚀 5. 고급 기능 테스트');
+    
+    try {
+      // 통계 조회
+      const stats = await this.manager.getStats();
+      this.recordTest('통계 조회', stats.total > 0, 
+        `총 기억 수: ${stats.total}, 고정: ${stats.pinned}개`);
+      
+      // 인기 태그 조회
+      const popularTags = await this.manager.getPopularTags(5);
+      this.recordTest('인기 태그', popularTags.length > 0, 
+        `인기 태그: ${popularTags.map(t => t.tag).join(', ')}`);
+      
+      // 유사 기억 검색 (테스트용 기억이 있는 경우)
+      if (this.testMemoryId) {
+        const similarMemories = await this.manager.findSimilar(this.testMemoryId, 3);
+        this.recordTest('유사 기억 검색', true, 
+          `유사 기억: ${similarMemories.total_count}개`);
+      }
+      
+      // 관련 기억 검색
+      if (this.testMemoryId) {
+        const relatedMemories = await this.manager.findRelated(this.testMemoryId, 3);
+        this.recordTest('관련 기억 검색', true, 
+          `관련 기억: ${relatedMemories.total_count}개`);
+      }
+      
+    } catch (error) {
+      this.recordTest('고급 기능', false, `고급 기능 테스트 실패: ${error.message}`);
+    }
+  }
+
+  async testErrorHandling() {
+    console.log('\n⚠️ 6. 에러 처리 테스트');
+    
+    try {
+      // 존재하지 않는 기억 조회
+      const notFound = await this.manager.get('non-existent-id');
+      this.recordTest('존재하지 않는 기억 조회', notFound === null, 
+        '존재하지 않는 기억은 null 반환');
+      
+      // 잘못된 서버 URL로 연결 시도
+      const badClient = new MementoClient({
+        serverUrl: 'http://localhost:9999',
+        timeout: 1000
+      });
+      
+      try {
+        await badClient.connect();
+        this.recordTest('잘못된 서버 연결', false, '연결이 성공했지만 실패해야 함');
+      } catch (error) {
+        this.recordTest('잘못된 서버 연결', true, '예상대로 연결 실패');
+      }
+      
+    } catch (error) {
+      this.recordTest('에러 처리', false, `에러 처리 테스트 실패: ${error.message}`);
+    }
+  }
+
+  async testPerformance() {
+    console.log('\n⚡ 7. 성능 테스트');
+    
+    try {
+      // 대량 기억 생성 테스트
+      const startTime = Date.now();
+      const batchSize = 10;
+      const batchMemories = [];
+      
+      for (let i = 0; i < batchSize; i++) {
+        batchMemories.push({
+          content: `성능 테스트용 기억 ${i + 1}: TypeScript와 React에 대한 학습 내용입니다.`,
+          type: 'episodic',
+          importance: 0.5 + (i * 0.05),
+          tags: ['performance', 'test', `batch-${i}`],
+          source: 'performance-test'
+        });
+      }
+      
+      const createdMemories = await this.manager.createBatch(batchMemories);
+      const creationTime = Date.now() - startTime;
+      
+      this.recordTest('대량 기억 생성', createdMemories.length === batchSize, 
+        `${batchSize}개 기억 생성 시간: ${creationTime}ms`);
+      
+      // 대량 검색 테스트
+      const searchStartTime = Date.now();
+      const searchResults = await this.manager.search('TypeScript React', {
+        limit: 20
+      });
+      const searchTime = Date.now() - searchStartTime;
+      
+      this.recordTest('대량 검색', searchResults.total_count > 0, 
+        `검색 시간: ${searchTime}ms, 결과: ${searchResults.total_count}개`);
+      
+      // 성능 테스트용 기억 ID 저장 (정리용)
+      this.performanceMemoryIds = createdMemories.map(m => m.id);
+      
+    } catch (error) {
+      this.recordTest('성능 테스트', false, `성능 테스트 실패: ${error.message}`);
+    }
+  }
+
+  async cleanup() {
+    console.log('\n🧹 정리 작업');
+    
+    try {
+      // 테스트용 기억들 삭제
+      const memoryIdsToDelete = [
+        this.testMemoryId,
+        ...(this.performanceMemoryIds || [])
+      ].filter(Boolean);
+      
+      if (memoryIdsToDelete.length > 0) {
+        const deletedCount = await this.manager.deleteBatch(memoryIdsToDelete, false);
+        console.log(`  삭제된 테스트 기억: ${deletedCount}개`);
+      }
+      
+      // 연결 해제
+      await this.client.disconnect();
+      console.log('  클라이언트 연결 해제 완료');
+      
+    } catch (error) {
+      console.error('  정리 작업 중 오류:', error.message);
+    }
+  }
+
+  recordTest(testName, passed, message) {
+    this.testResults.push({ testName, passed, message });
+    const status = passed ? '✅' : '❌';
+    console.log(`  ${status} ${testName}: ${message}`);
+  }
+
+  printTestSummary() {
+    console.log('\n📊 테스트 결과 요약');
+    console.log('='.repeat(50));
+    
+    const totalTests = this.testResults.length;
+    const passedTests = this.testResults.filter(t => t.passed).length;
+    const failedTests = totalTests - passedTests;
+    
+    console.log(`총 테스트: ${totalTests}개`);
+    console.log(`성공: ${passedTests}개`);
+    console.log(`실패: ${failedTests}개`);
+    console.log(`성공률: ${((passedTests / totalTests) * 100).toFixed(1)}%`);
+    
+    if (failedTests > 0) {
+      console.log('\n❌ 실패한 테스트:');
+      this.testResults
+        .filter(t => !t.passed)
+        .forEach(t => console.log(`  - ${t.testName}: ${t.message}`));
+    }
+    
+    console.log('\n' + '='.repeat(50));
+    
+    if (failedTests === 0) {
+      console.log('🎉 모든 테스트 통과! @memento/client가 정상적으로 작동합니다.');
+    } else {
+      console.log('⚠️ 일부 테스트가 실패했습니다. 서버 상태를 확인해주세요.');
+    }
+  }
+}
+
+// 테스트 실행
+async function runIntegrationTests() {
+  const tester = new IntegrationTester();
+  await tester.runAllTests();
+}
+
+// 모듈로 실행할 때만 테스트 실행
+if (require.main === module) {
+  runIntegrationTests().catch(console.error);
+}
+
+module.exports = { IntegrationTester, runIntegrationTests };

package/scripts/auto-setup.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+
+// 색상 코드
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function logStep(step, message) {
+  log(`\n${colors.cyan}🚀 ${step}: ${message}${colors.reset}`);
+}
+
+function logSuccess(message) {
+  log(`✅ ${message}`, 'green');
+}
+
+function logWarning(message) {
+  log(`⚠️  ${message}`, 'yellow');
+}
+
+function logError(message) {
+  log(`❌ ${message}`, 'red');
+}
+
+async function checkNodeVersion() {
+  const nodeVersion = process.version;
+  const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+  
+  if (majorVersion < 20) {
+    logError(`Node.js 20 이상이 필요합니다. 현재 버전: ${nodeVersion}`);
+    process.exit(1);
+  }
+  
+  logSuccess(`Node.js 버전 확인 완료: ${nodeVersion}`);
+}
+
+async function createEnvFile() {
+  const envPath = path.join(projectRoot, '.env');
+  const envExamplePath = path.join(projectRoot, 'env.example');
+  
+  if (fs.existsSync(envPath)) {
+    logSuccess('.env 파일이 이미 존재합니다.');
+    return;
+  }
+  
+  if (!fs.existsSync(envExamplePath)) {
+    logError('env.example 파일을 찾을 수 없습니다.');
+    return;
+  }
+  
+  try {
+    fs.copyFileSync(envExamplePath, envPath);
+    logSuccess('.env 파일 생성 완료');
+    
+    // API 키 설정 안내
+    logWarning('API 키를 설정하려면 .env 파일을 편집하세요:');
+    log('  - OPENAI_API_KEY: OpenAI API 키 (선택사항)');
+    log('  - GEMINI_API_KEY: Gemini API 키 (선택사항)');
+    log('  - API 키가 없어도 경량 임베딩으로 동작합니다.');
+  } catch (error) {
+    logError(`.env 파일 생성 실패: ${error.message}`);
+  }
+}
+
+async function createDataDirectory() {
+  const dataDir = path.join(projectRoot, 'data');
+  
+  if (!fs.existsSync(dataDir)) {
+    try {
+      fs.mkdirSync(dataDir, { recursive: true });
+      logSuccess('데이터 디렉토리 생성 완료');
+    } catch (error) {
+      logError(`데이터 디렉토리 생성 실패: ${error.message}`);
+    }
+  } else {
+    logSuccess('데이터 디렉토리가 이미 존재합니다.');
+  }
+}
+
+async function initializeDatabase() {
+  try {
+    logStep('데이터베이스 초기화', 'SQLite 데이터베이스 설정 중...');
+    
+    // TypeScript 파일을 직접 실행
+    execSync('npx tsx src/database/init.ts', { 
+      cwd: projectRoot, 
+      stdio: 'inherit' 
+    });
+    
+    logSuccess('데이터베이스 초기화 완료');
+  } catch (error) {
+    logError(`데이터베이스 초기화 실패: ${error.message}`);
+    logWarning('수동으로 실행하세요: npm run db:init');
+  }
+}
+
+async function checkDependencies() {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  const nodeModulesPath = path.join(projectRoot, 'node_modules');
+  
+  if (!fs.existsSync(nodeModulesPath)) {
+    logStep('의존성 설치', 'npm install 실행 중...');
+    try {
+      execSync('npm install', { 
+        cwd: projectRoot, 
+        stdio: 'inherit' 
+      });
+      logSuccess('의존성 설치 완료');
+    } catch (error) {
+      logError(`의존성 설치 실패: ${error.message}`);
+      process.exit(1);
+    }
+  } else {
+    logSuccess('의존성이 이미 설치되어 있습니다.');
+  }
+}
+
+async function createStartScripts() {
+  const startScripts = {
+    'start-dev.sh': `#!/bin/bash
+echo "🚀 Memento MCP Server 개발 모드 시작..."
+npm run dev
+`,
+    'start-prod.sh': `#!/bin/bash
+echo "🚀 Memento MCP Server 프로덕션 모드 시작..."
+npm run build
+npm run start
+`,
+    'start-docker.sh': `#!/bin/bash
+echo "🐳 Memento MCP Server Docker 모드 시작..."
+docker-compose up -d
+echo "서버가 http://localhost:8080 에서 실행 중입니다."
+`
+  };
+  
+  for (const [filename, content] of Object.entries(startScripts)) {
+    const filePath = path.join(projectRoot, filename);
+    if (!fs.existsSync(filePath)) {
+      try {
+        fs.writeFileSync(filePath, content);
+        // 실행 권한 부여 (Unix 계열)
+        if (process.platform !== 'win32') {
+          fs.chmodSync(filePath, '755');
+        }
+        logSuccess(`${filename} 생성 완료`);
+      } catch (error) {
+        logWarning(`${filename} 생성 실패: ${error.message}`);
+      }
+    }
+  }
+}
+
+async function showUsageInstructions() {
+  log('\n' + '='.repeat(60), 'cyan');
+  log('🎉 Memento MCP Server 자동 설정 완료!', 'bright');
+  log('='.repeat(60), 'cyan');
+  
+  log('\n📋 사용 방법:', 'yellow');
+  log('1. 개발 모드:');
+  log('   npm run dev');
+  log('   또는: npx memento-mcp-server@latest dev');
+  
+  log('\n2. 프로덕션 모드:');
+  log('   npm run build && npm run start');
+  log('   또는: npx memento-mcp-server@latest start');
+  
+  log('\n3. HTTP/WebSocket 서버:');
+  log('   npm run dev:http');
+  log('   또는: npx memento-mcp-server@latest dev-http');
+  
+  log('\n4. Docker 모드:');
+  log('   docker-compose up -d');
+  log('   또는: ./start-docker.sh');
+  
+  log('\n5. 원클릭 시작:');
+  log('   npm run quick-start');
+  
+  log('\n📚 자세한 사용법:');
+  log('   - README.md 파일 참조');
+  log('   - docs/ 폴더의 문서들');
+  
+  log('\n🔧 문제 해결:');
+  log('   - 로그 확인: logs/memento-server.log');
+  log('   - 데이터베이스 재초기화: npm run db:init');
+  log('   - 의존성 재설치: rm -rf node_modules && npm install');
+  
+  log('\n' + '='.repeat(60), 'cyan');
+}
+
+async function main() {
+  try {
+    log('🚀 Memento MCP Server 자동 설정을 시작합니다...', 'bright');
+    
+    await checkNodeVersion();
+    await checkDependencies();
+    await createDataDirectory();
+    await createEnvFile();
+    await initializeDatabase();
+    await createStartScripts();
+    await showUsageInstructions();
+    
+    logSuccess('자동 설정이 완료되었습니다!');
+    
+  } catch (error) {
+    logError(`자동 설정 중 오류 발생: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// 스크립트가 직접 실행된 경우에만 main 함수 호출
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { main as autoSetup };

package/scripts/backup-daily.bat

@@ -0,0 +1,28 @@
+@echo off
+REM Memento 데이터베이스 일일 백업 스크립트
+REM 실행 시간: 매일 오전 2시
+
+set timestamp=%date:~0,4%%date:~5,2%%date:~8,2%-%time:~0,2%%time:~3,2%%time:~6,2%
+set timestamp=%timestamp: =0%
+
+echo [%date% %time%] 데이터베이스 백업 시작...
+
+REM 백업 디렉토리 생성
+if not exist "backup" mkdir backup
+
+REM 메인 데이터베이스 백업
+copy "data\memory.db" "backup\memory-backup-%timestamp%.db"
+
+if %errorlevel% equ 0 (
+    echo [%date% %time%] 백업 완료: memory-backup-%timestamp%.db
+    
+    REM 오래된 백업 파일 정리 (30일 이상)
+    forfiles /p backup /m memory-backup-*.db /d -30 /c "cmd /c del @path" 2>nul
+    
+    echo [%date% %time%] 오래된 백업 파일 정리 완료
+) else (
+    echo [%date% %time%] 백업 실패!
+    exit /b 1
+)
+
+echo [%date% %time%] 데이터베이스 백업 완료