memento-mcp-server 1.16.3-a → 1.16.3-c

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-embeddings.js

@@ -3,9 +3,17 @@
 /**
  * 임베딩 백업 스크립트
  * 기존 벡터값을 백업한 후 삭제하고 재생성하는 스크립트
+ * 
+ * 리팩토링: 공통 모듈(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';
@@ -14,17 +22,9 @@ import { validateFilePath, sanitizeFileName } from '../src/shared/utils/path-val
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// 데이터베이스 경로 설정
+// 백업 디렉토리 설정
 // PRD 0019: 보안 강화 (Phase 1) - Path Traversal 방지
-const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
-if (!validateFilePath(dbPath, 'data')) {
-  throw new Error(
-    `Path Traversal 방지: 허용되지 않은 데이터베이스 경로입니다. ` +
-    `경로: ${dbPath}`
-  );
-}
-
-const backupDir = path.join(__dirname, '..', 'backup');
+const backupDir = path.join(process.cwd(), 'backup');
 if (!validateFilePath(backupDir, 'backup')) {
   throw new Error(
     `Path Traversal 방지: 허용되지 않은 백업 디렉토리 경로입니다. ` +
@@ -46,83 +46,74 @@ async function backupEmbeddings() {
     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 };

package/scripts/check-db-integrity.js

@@ -1,46 +1,56 @@
 #!/usr/bin/env node
 /**
  * Memento 데이터베이스 무결성 검사 스크립트
- * 사용법: node scripts/check-db-integrity.js
+ * 
+ * 리팩토링: 공통 모듈(initializeDatabase)을 사용하여 일관된 DB 초기화 보장
+ * 
+ * 사용법: 
+ *   - 개발 환경: npx tsx scripts/check-db-integrity.js
+ *   - 프로덕션: npm run build && node dist/scripts/check-db-integrity.js
  */
 
-const Database = require('better-sqlite3');
-const fs = require('fs');
-const path = require('path');
+// TypeScript 소스를 직접 import (tsx로 실행 시)
+// 빌드된 파일을 사용하려면 '../dist/infrastructure/database/database/init.js'로 변경
+import { initializeDatabase, closeDatabase } from '../src/infrastructure/database/database/init.js';
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
 
-const DB_PATH = './data/memory.db';
 const LOG_PATH = './logs/db-integrity.log';
 
 // 로그 디렉토리 생성
-if (!fs.existsSync('./logs')) {
-  fs.mkdirSync('./logs');
+if (!existsSync('./logs')) {
+  mkdirSync('./logs', { recursive: true });
 }
 
+/**
+ * 로그 메시지 출력 및 파일 기록
+ */
 function log(message) {
   const timestamp = new Date().toISOString();
   const logMessage = `[${timestamp}] ${message}\n`;
   console.log(message);
-  fs.appendFileSync(LOG_PATH, logMessage);
+  appendFileSync(LOG_PATH, logMessage);
 }
 
-function checkDatabaseIntegrity() {
+/**
+ * 데이터베이스 무결성 검사
+ * 
+ * @returns {Promise<boolean>} 검사 통과 여부
+ */
+async function checkDatabaseIntegrity() {
   log('데이터베이스 무결성 검사 시작...');
   
+  let db = null;
+  
   try {
-    // 데이터베이스 파일 존재 확인
-    if (!fs.existsSync(DB_PATH)) {
-      log('❌ 데이터베이스 파일이 존재하지 않습니다.');
-      return false;
-    }
-    
-    // 데이터베이스 연결 테스트
-    const db = new Database(DB_PATH);
+    // 공통 모듈을 사용하여 데이터베이스 초기화
+    // initializeDatabase는 DB 파일이 없으면 자동으로 생성하고 초기화함
+    db = await initializeDatabase();
     
     // PRAGMA integrity_check 실행
     const integrityResult = db.prepare('PRAGMA integrity_check').get();
     if (integrityResult.integrity_check !== 'ok') {
       log(`❌ 데이터베이스 무결성 검사 실패: ${integrityResult.integrity_check}`);
-      db.close();
       return false;
     }
     
@@ -52,7 +62,7 @@ function checkDatabaseIntegrity() {
     
     if (tables.length < 3) {
       log('❌ 필수 테이블이 누락되었습니다.');
-      db.close();
+      log(`   발견된 테이블: ${tables.map(t => t.name).join(', ')}`);
       return false;
     }
     
@@ -65,17 +75,27 @@ function checkDatabaseIntegrity() {
     log(`   - 임베딩: ${embeddingCount.count}개`);
     log(`   - 테이블: ${tables.length}개`);
     
-    db.close();
     return true;
     
   } catch (error) {
     log(`❌ 데이터베이스 검사 중 오류 발생: ${error.message}`);
+    if (error.stack) {
+      log(`   스택 트레이스: ${error.stack}`);
+    }
     return false;
+  } finally {
+    // 데이터베이스 연결 종료
+    if (db) {
+      closeDatabase(db);
+    }
   }
 }
 
-function main() {
-  const isHealthy = checkDatabaseIntegrity();
+/**
+ * 메인 함수
+ */
+async function main() {
+  const isHealthy = await checkDatabaseIntegrity();
   
   if (!isHealthy) {
     log('🚨 데이터베이스에 문제가 있습니다. 백업에서 복구를 고려하세요.');
@@ -86,8 +106,12 @@ function main() {
   }
 }
 
-if (require.main === module) {
-  main();
+// 스크립트가 직접 실행될 때만 main 함수 호출
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
+  main().catch((error) => {
+    console.error('❌ 스크립트 실행 중 오류 발생:', error);
+    process.exit(1);
+  });
 }
 
-module.exports = { checkDatabaseIntegrity };
+export { checkDatabaseIntegrity };

package/scripts/check-file-sizes.ts

@@ -9,7 +9,7 @@
  *   tsx scripts/check-file-sizes.ts --ci
  *   tsx scripts/check-file-sizes.ts --threshold 500
  *   tsx scripts/check-file-sizes.ts --directory src/
- *   tsx scripts/check-file-sizes.ts --exclude "**/*.spec.ts"
+ *   tsx scripts/check-file-sizes.ts --exclude '*.spec.ts'
  * 
  * 목표:
  *   - 핵심 핸들러/서비스 파일이 500줄 이하
@@ -17,7 +17,7 @@
  *   - 경고/에러 출력
  */
 
-import { readFileSync, statSync } from 'fs';
+import { readFileSync } from 'fs';
 import { readdir } from 'fs/promises';
 import { join, relative } from 'path';
 
@@ -111,7 +111,7 @@ function printHelp(): void {
   tsx scripts/check-file-sizes.ts
   tsx scripts/check-file-sizes.ts --ci
   tsx scripts/check-file-sizes.ts --threshold 500
-  tsx scripts/check-file-sizes.ts --directory src/ --exclude "**/*.spec.ts"
+  tsx scripts/check-file-sizes.ts --directory src/ --exclude '*.spec.ts'
 `);
 }
 
@@ -164,7 +164,7 @@ function validateFileSize(filePath: string, threshold: number): FileSizeResult {
  * 패턴 매칭 (간단한 glob 패턴 지원)
  * 
  * @param path - 파일 경로
- * @param pattern - 패턴 (예: "**/node_modules/**", "**/*.spec.ts")
+ * @param pattern - 패턴 (예: node_modules, *.spec.ts)
  * @returns 매칭 여부
  */
 function matchesPattern(path: string, pattern: string): boolean {

package/scripts/check-pii-masking.ts

@@ -176,9 +176,6 @@ function checkFile(filePath: string): PIIMaskingLocation[] {
     // 로거 파일인지 확인 (logger, file-logger, error-logging-service 등)
     const isLoggerFile = /logger|log|error-logging/i.test(relativePath);
     
-    // PIIMasker import 확인
-    const hasPIIMaskerImport = /import.*PIIMasker|from.*pii-masker/.test(content);
-    
     // logger.error, logger.warn, logger.info, logger.debug 호출 확인
     // logger.ts를 import하는 경우는 이미 마스킹이 적용되어 있으므로 제외
     if (!usesLoggerUtils) {

package/scripts/check-sql-injection.ts

@@ -183,18 +183,6 @@ function findSqlInjectionPatterns(filePath: string): SqlInjectionLocation[] {
     const content = readFileSync(filePath, 'utf-8');
     const lines = content.split('\n');
     
-    // 패턴 1: 문자열 연결을 통한 SQL 쿼리 생성
-    // sql +=, query +=, sql = sql + 등
-    const stringConcatenationPattern = /\b(sql|query|stmt|statement)\s*([+]=|=.*\+)/gi;
-    
-    // 패턴 2: 템플릿 리터럴로 동적 테이블명/컬럼명 사용
-    // FROM ${, JOIN ${, WHERE ${ 등 (일부는 허용 가능하지만 검사 대상)
-    const templateLiteralPattern = /\b(FROM|JOIN|WHERE|SELECT|INSERT|UPDATE|DELETE|INTO|SET)\s+\$\{/gi;
-    
-    // 패턴 3: 파라미터 바인딩 미사용 (문자열 연결)
-    // '...' + variable, "..." + variable (SQL 쿼리 컨텍스트에서)
-    const parameterBindingPattern = /(['"]).*?\1\s*\+\s*\w+/g;
-    
     for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
       const line = lines[lineIndex];
       const trimmedLine = line.trim();