memento-mcp-server 1.16.2 → 1.16.3-b

package/scripts/__tests__/migrate-embedding-data.integration.spec.ts

@@ -0,0 +1,219 @@
+/**
+ * migrate-embedding-data.js 통합 테스트
+ * 
+ * Given/When/Then 구조를 따르는 통합 테스트
+ * 공통 모듈(initializeDatabase)을 사용하는 버전으로 리팩토링 후 검증
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, unlinkSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { initializeDatabase, closeDatabase } from '../../src/infrastructure/database/database/init.js';
+import Database from 'better-sqlite3';
+
+describe('migrate-embedding-data 통합 테스트', () => {
+  let testDbPath: string;
+  let testBackupPath: string;
+  let originalDbPath: string | undefined;
+
+  beforeEach(() => {
+    // 테스트용 임시 디렉토리 생성
+    const testDir = join(tmpdir(), `memento-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    
+    testDbPath = join(testDir, 'memory.db');
+    testBackupPath = join(testDir, `memory-backup-${Date.now()}.db`);
+    
+    // 환경 변수 백업 및 설정
+    originalDbPath = process.env.DB_PATH;
+    process.env.DB_PATH = testDbPath;
+  });
+
+  afterEach(() => {
+    // 환경 변수 복원
+    if (originalDbPath !== undefined) {
+      process.env.DB_PATH = originalDbPath;
+    } else {
+      delete process.env.DB_PATH;
+    }
+    
+    // 테스트 파일 정리
+    try {
+      if (existsSync(testDbPath)) {
+        unlinkSync(testDbPath);
+      }
+      if (existsSync(testBackupPath)) {
+        unlinkSync(testBackupPath);
+      }
+    } catch (error) {
+      // 파일 정리 실패는 무시
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 migrate-embedding-data 함수
+   * @when 데이터베이스 연결 및 백업 생성
+   * @then 백업 파일이 정상적으로 생성됨
+   */
+  it('should create backup successfully', async () => {
+    // Given: 정상적인 데이터베이스 초기화
+    const db = await initializeDatabase();
+    
+    try {
+      // 테스트 데이터 삽입
+      db.exec(`
+        INSERT INTO memory_embedding (id, embedding, dim, model)
+        VALUES (1, '[]', 384, 'lightweight-hybrid')
+      `);
+      
+      // When: 백업 생성
+      const backupDb = new Database(testBackupPath);
+      db.backup(testBackupPath);
+      backupDb.close();
+      
+      // Then: 백업 파일이 생성되었는지 확인
+      expect(existsSync(testBackupPath)).toBe(true);
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 migrate-embedding-data 함수
+   * @when 기존 데이터 분석 실행
+   * @then 분석 결과가 정상적으로 반환됨
+   */
+  it('should analyze existing data correctly', async () => {
+    // Given: 정상적인 데이터베이스 초기화 및 테스트 데이터
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_embedding 테이블이 있는지 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_embedding'
+      `).get();
+      
+      if (tableExists) {
+        // When: 데이터 분석
+        const dimensionStats = db.prepare(`
+          SELECT dim, COUNT(*) as count, 
+                 COUNT(CASE WHEN model IS NOT NULL AND model != '' THEN 1 END) as with_model
+          FROM memory_embedding 
+          GROUP BY dim
+        `).all();
+        
+        const totalStats = db.prepare(`
+          SELECT COUNT(*) as total,
+                 COUNT(CASE WHEN embedding_provider IS NOT NULL THEN 1 END) as migrated
+          FROM memory_embedding
+        `).get();
+        
+        // Then: 분석 결과가 정상적으로 반환됨
+        expect(dimensionStats).toBeDefined();
+        expect(totalStats).toBeDefined();
+        expect(totalStats.total).toBeGreaterThanOrEqual(0);
+      } else {
+        // 테이블이 없으면 스킵
+        console.log('⚠️ memory_embedding 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 migrate-embedding-data 함수
+   * @when 메타데이터 업데이트 실행
+   * @then 메타데이터가 정상적으로 업데이트됨
+   */
+  it('should update metadata successfully', async () => {
+    // Given: 정상적인 데이터베이스 초기화 및 테스트 데이터
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_embedding 테이블 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_embedding'
+      `).get();
+      
+      if (tableExists) {
+        // 컬럼 존재 확인
+        const schema = db.prepare("PRAGMA table_info(memory_embedding)").all() as Array<{ name: string }>;
+        const hasProvider = schema.some(col => col.name === 'embedding_provider');
+        const hasDimensions = schema.some(col => col.name === 'dimensions');
+        const hasCreatedBy = schema.some(col => col.name === 'created_by');
+        
+        if (hasProvider && hasDimensions && hasCreatedBy) {
+          // When: 메타데이터 업데이트
+          const updateStmt = db.prepare(`
+            UPDATE memory_embedding 
+            SET 
+              embedding_provider = CASE 
+                WHEN model = 'lightweight-hybrid' THEN 'tfidf'
+                WHEN model IS NULL OR model = '' THEN 'tfidf'
+                ELSE 'unknown'
+              END,
+              dimensions = dim,
+              created_by = 'legacy'
+            WHERE embedding_provider IS NULL
+          `);
+          
+          const result = updateStmt.run();
+          
+          // Then: 업데이트 성공 확인
+          expect(result.changes).toBeGreaterThanOrEqual(0);
+        } else {
+          console.log('⚠️ 필요한 컬럼이 없습니다. 테스트 스킵');
+        }
+      } else {
+        console.log('⚠️ memory_embedding 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 migrate-embedding-data 함수
+   * @when 마이그레이션 검증 실행
+   * @then 검증 결과가 정상적으로 반환됨
+   */
+  it('should validate migration successfully', async () => {
+    // Given: 정상적인 데이터베이스 초기화
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_embedding 테이블 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_embedding'
+      `).get();
+      
+      if (tableExists) {
+        // When: 마이그레이션 검증
+        const validation = db.prepare(`
+          SELECT 
+            COUNT(*) as total,
+            COUNT(CASE WHEN embedding_provider IS NOT NULL THEN 1 END) as with_provider,
+            COUNT(CASE WHEN dimensions IS NOT NULL THEN 1 END) as with_dimensions,
+            COUNT(CASE WHEN created_by IS NOT NULL THEN 1 END) as with_created_by
+          FROM memory_embedding
+        `).get() as { total: number; with_provider: number; with_dimensions: number; with_created_by: number };
+        
+        // Then: 검증 결과가 정상적으로 반환됨
+        expect(validation.total).toBeGreaterThanOrEqual(0);
+        expect(validation.with_provider).toBeGreaterThanOrEqual(0);
+        expect(validation.with_dimensions).toBeGreaterThanOrEqual(0);
+        expect(validation.with_created_by).toBeGreaterThanOrEqual(0);
+      } else {
+        console.log('⚠️ memory_embedding 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+});
+

package/scripts/__tests__/regenerate-embeddings.integration.spec.ts

@@ -0,0 +1,192 @@
+/**
+ * regenerate-embeddings.js 통합 테스트
+ * 
+ * Given/When/Then 구조를 따르는 통합 테스트
+ * 공통 모듈(initializeDatabase)을 사용하는 버전으로 리팩토링 후 검증
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, unlinkSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { initializeDatabase, closeDatabase } from '../../src/infrastructure/database/database/init.js';
+import Database from 'better-sqlite3';
+
+describe('regenerate-embeddings 통합 테스트', () => {
+  let testDbPath: string;
+  let originalDbPath: string | undefined;
+
+  beforeEach(() => {
+    // 테스트용 임시 디렉토리 생성
+    const testDir = join(tmpdir(), `memento-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    
+    testDbPath = join(testDir, 'memory.db');
+    
+    // 환경 변수 백업 및 설정
+    originalDbPath = process.env.DB_PATH;
+    process.env.DB_PATH = testDbPath;
+  });
+
+  afterEach(() => {
+    // 환경 변수 복원
+    if (originalDbPath !== undefined) {
+      process.env.DB_PATH = originalDbPath;
+    } else {
+      delete process.env.DB_PATH;
+    }
+    
+    // 테스트 파일 정리
+    try {
+      if (existsSync(testDbPath)) {
+        unlinkSync(testDbPath);
+      }
+    } catch (error) {
+      // 파일 정리 실패는 무시
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 regenerate-embeddings 함수
+   * @when 데이터베이스 연결 및 기억 조회
+   * @then 기억 목록이 정상적으로 조회됨
+   */
+  it('should query memories successfully', async () => {
+    // Given: 정상적인 데이터베이스 초기화
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_item 테이블 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_item'
+      `).get();
+      
+      if (tableExists) {
+        // When: 기억 조회
+        const memories = db.prepare(`
+          SELECT id, content, type, importance, created_at
+          FROM memory_item
+          ORDER BY created_at
+        `).all();
+        
+        // Then: 기억 목록이 정상적으로 조회됨
+        expect(memories).toBeDefined();
+        expect(Array.isArray(memories)).toBe(true);
+      } else {
+        console.log('⚠️ memory_item 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 regenerate-embeddings 함수
+   * @when 임베딩 통계 조회
+   * @then 통계가 정상적으로 반환됨
+   */
+  it('should query embedding statistics successfully', async () => {
+    // Given: 정상적인 데이터베이스 초기화
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_embedding 테이블 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_embedding'
+      `).get();
+      
+      if (tableExists) {
+        // When: 임베딩 통계 조회
+        const finalStats = db.prepare(`
+          SELECT 
+            COUNT(*) as total,
+            AVG(dim) as avg_dim,
+            MIN(dim) as min_dim,
+            MAX(dim) as max_dim
+          FROM memory_embedding
+        `).get();
+        
+        // Then: 통계가 정상적으로 반환됨
+        expect(finalStats).toBeDefined();
+        expect(finalStats.total).toBeGreaterThanOrEqual(0);
+      } else {
+        console.log('⚠️ memory_embedding 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 regenerate-embeddings 함수
+   * @when 차원 일치성 확인
+   * @then 차원 불일치가 정상적으로 감지됨
+   */
+  it('should detect dimension mismatches correctly', async () => {
+    // Given: 정상적인 데이터베이스 초기화
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_embedding 테이블 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_embedding'
+      `).get();
+      
+      if (tableExists) {
+        // When: 차원 일치성 확인
+        const expectedDim = 384; // 예상 차원
+        const mismatchedDims = db.prepare(`
+          SELECT COUNT(*) as count FROM memory_embedding WHERE dim != ?
+        `).get(expectedDim) as { count: number };
+        
+        // Then: 차원 불일치가 정상적으로 감지됨
+        expect(mismatchedDims).toBeDefined();
+        expect(mismatchedDims.count).toBeGreaterThanOrEqual(0);
+      } else {
+        console.log('⚠️ memory_embedding 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
+  /**
+   * @given 공통 모듈(initializeDatabase)을 사용하는 regenerate-embeddings 함수
+   * @when 빈 기억 목록 처리
+   * @then 적절한 메시지 출력 및 종료
+   */
+  it('should handle empty memory list gracefully', async () => {
+    // Given: 정상적인 데이터베이스 초기화
+    const db = await initializeDatabase();
+    
+    try {
+      // memory_item 테이블 확인
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_item'
+      `).get();
+      
+      if (tableExists) {
+        // When: 기억 조회
+        const memories = db.prepare(`
+          SELECT id, content, type, importance, created_at
+          FROM memory_item
+          ORDER BY created_at
+        `).all();
+        
+        // Then: 빈 목록도 정상적으로 처리됨
+        expect(memories).toBeDefined();
+        expect(Array.isArray(memories)).toBe(true);
+        // 빈 목록인 경우에도 에러 없이 처리되어야 함
+      } else {
+        console.log('⚠️ memory_item 테이블이 없습니다. 테스트 스킵');
+      }
+    } finally {
+      closeDatabase(db);
+    }
+  });
+});
+

package/scripts/backup-daily.bat

@@ -1,17 +1,25 @@
 @echo off
 REM Memento 데이터베이스 일일 백업 스크립트
 REM 실행 시간: 매일 오전 2시
+REM PRD 0019: 보안 강화 (Phase 1) - Path Traversal 방지
 
 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 백업 디렉토리 생성
+REM 백업 디렉토리 생성 (PRD 0019: Path Traversal 방지 - 허용된 디렉토리만 사용)
 if not exist "backup" mkdir backup
 
+REM 백업 파일명 정제 (PRD 0019: Path Traversal 방지)
+REM timestamp는 날짜/시간에서 생성되므로 상대적으로 안전하지만, 
+REM 추가 보안을 위해 Node.js 유틸리티로 파일명 정제 (선택사항)
+set backupFileName=memory-backup-%timestamp%.db
+
 REM 메인 데이터베이스 백업
-copy "data\memory.db" "backup\memory-backup-%timestamp%.db"
+REM PRD 0019: Path Traversal 방지 - 경로는 하드코딩되어 있어 상대적으로 안전
+REM data\memory.db와 backup\ 디렉토리는 기본 허용 디렉토리 목록에 포함됨
+copy "data\memory.db" "backup\%backupFileName%"
 
 if %errorlevel% equ 0 (
     echo [%date% %time%] 백업 완료: memory-backup-%timestamp%.db

package/scripts/backup-embeddings.js

@@ -3,106 +3,117 @@
 /**
  * 임베딩 백업 스크립트
  * 기존 벡터값을 백업한 후 삭제하고 재생성하는 스크립트
+ * 
+ * 리팩토링: 공통 모듈(initializeDatabase)을 사용하여 일관된 DB 초기화 보장
+ * 
+ * 사용법: 
+ *   - 개발 환경: npx tsx scripts/backup-embeddings.js
+ *   - 프로덕션: npm run build && node dist/scripts/backup-embeddings.js
  */
 
-import Database from 'better-sqlite3';
+// TypeScript 소스를 직접 import (tsx로 실행 시)
+// 빌드된 파일을 사용하려면 '../dist/infrastructure/database/database/init.js'로 변경
+import { initializeDatabase, closeDatabase } from '../src/infrastructure/database/database/init.js';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { validateFilePath, sanitizeFileName } from '../src/shared/utils/path-validator.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// 데이터베이스 경로 설정
-const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
-const backupDir = path.join(__dirname, '..', 'backup');
-const backupFile = path.join(backupDir, `embeddings-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`);
+// 백업 디렉토리 설정
+// PRD 0019: 보안 강화 (Phase 1) - Path Traversal 방지
+const backupDir = path.join(process.cwd(), 'backup');
+if (!validateFilePath(backupDir, 'backup')) {
+  throw new Error(
+    `Path Traversal 방지: 허용되지 않은 백업 디렉토리 경로입니다. ` +
+    `경로: ${backupDir}`
+  );
+}
+
+// 백업 파일명 정제
+const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+const sanitizedFileName = sanitizeFileName(`embeddings-backup-${timestamp}.json`);
+const backupFile = path.join(backupDir, sanitizedFileName);
 
 async function backupEmbeddings() {
   console.log('🔄 임베딩 백업 시작...');
   
-  // 백업 디렉토리 생성
+  // 백업 디렉토리 생성 (PRD 0019: Path Traversal 방지)
+  // 경로 검증은 이미 위에서 수행됨
   if (!fs.existsSync(backupDir)) {
     fs.mkdirSync(backupDir, { recursive: true });
   }
 
-  // 데이터베이스 연결
-  const db = new Database(dbPath);
+  let db = null;
   
   try {
-    // 기존 임베딩 데이터 조회
+    // 공통 모듈을 사용하여 데이터베이스 초기화
+    // initializeDatabase는 DB 파일이 없으면 자동으로 생성하고 초기화함
+    db = await initializeDatabase();
+    
+    // 모든 임베딩 데이터 조회
     const embeddings = db.prepare(`
       SELECT 
-        me.memory_id,
-        me.embedding,
-        me.dim,
-        me.model,
-        me.created_at,
-        mi.content,
-        mi.type
-      FROM memory_embedding me
-      JOIN memory_item mi ON me.memory_id = mi.id
-      ORDER BY me.created_at
+        memory_id,
+        embedding,
+        dim,
+        model,
+        created_at
+      FROM memory_embedding
     `).all();
 
-    console.log(`📊 발견된 임베딩 개수: ${embeddings.length}`);
+    console.log(`📊 백업할 임베딩 개수: ${embeddings.length}`);
 
     if (embeddings.length === 0) {
       console.log('⚠️ 백업할 임베딩이 없습니다.');
       return;
     }
 
-    // 차원별 통계
-    const dimensionStats = {};
-    embeddings.forEach(emb => {
-      const dim = emb.dim;
-      dimensionStats[dim] = (dimensionStats[dim] || 0) + 1;
-    });
-
-    console.log('📈 차원별 통계:');
-    Object.entries(dimensionStats).forEach(([dim, count]) => {
-      console.log(`  - ${dim}차원: ${count}개`);
-    });
-
-    // 백업 데이터 생성
+    // 백업 데이터 준비
     const backupData = {
       timestamp: new Date().toISOString(),
-      totalEmbeddings: embeddings.length,
-      dimensionStats,
-      embeddings: embeddings.map(emb => ({
-        memory_id: emb.memory_id,
-        content: emb.content,
-        type: emb.type,
-        embedding: JSON.parse(emb.embedding),
-        dim: emb.dim,
-        model: emb.model,
-        created_at: emb.created_at
+      count: embeddings.length,
+      embeddings: embeddings.map(e => ({
+        memory_id: e.memory_id,
+        embedding: e.embedding,
+        dim: e.dim,
+        model: e.model,
+        created_at: e.created_at
       }))
     };
 
-    // 백업 파일 저장
-    fs.writeFileSync(backupFile, JSON.stringify(backupData, null, 2));
+    // JSON 파일로 저장
+    fs.writeFileSync(backupFile, JSON.stringify(backupData, null, 2), 'utf8');
     console.log(`✅ 백업 완료: ${backupFile}`);
+    console.log(`📦 백업 크기: ${(fs.statSync(backupFile).size / 1024).toFixed(2)} KB`);
 
-    // 임베딩 테이블 삭제
-    console.log('🗑️ 기존 임베딩 삭제 중...');
-    const deleteResult = db.prepare('DELETE FROM memory_embedding').run();
-    console.log(`✅ 삭제 완료: ${deleteResult.changes}개 행 삭제`);
-
-    console.log('🎉 백업 및 삭제 완료!');
-    console.log('다음 단계: npm run regenerate-embeddings');
+    // 사용자 확인
+    console.log('\n⚠️ 백업이 완료되었습니다.');
+    console.log('다음 단계로 임베딩을 삭제하고 재생성할 수 있습니다.');
+    console.log('백업 파일:', backupFile);
 
   } catch (error) {
-    console.error('❌ 백업 실패:', error);
+    console.error('❌ 백업 실패:', error.message);
+    if (error.stack) {
+      console.error('   스택 트레이스:', error.stack);
+    }
     process.exit(1);
   } finally {
-    db.close();
+    // 데이터베이스 연결 종료
+    if (db) {
+      closeDatabase(db);
+    }
   }
 }
 
 // 스크립트 실행
-if (import.meta.url === `file://${process.argv[1]}`) {
-  backupEmbeddings().catch(console.error);
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
+  backupEmbeddings().catch((error) => {
+    console.error('❌ 스크립트 실행 중 오류 발생:', error);
+    process.exit(1);
+  });
 }
 
 export { backupEmbeddings };