memento-mcp-server 1.16.3-a → 1.16.3-b

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();

package/scripts/debug-embeddings.js

@@ -3,25 +3,28 @@
 /**
  * 임베딩 디버깅 스크립트
  * 현재 데이터베이스의 임베딩 상태를 상세히 분석
+ * 
+ * 리팩토링: 공통 모듈(initializeDatabase)을 사용하여 일관된 DB 초기화 보장
+ * 
+ * 사용법: 
+ *   - 개발 환경: npx tsx scripts/debug-embeddings.js
+ *   - 프로덕션: npm run build && node dist/scripts/debug-embeddings.js
  */
 
-import Database from 'better-sqlite3';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 데이터베이스 경로 설정
-const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
+// TypeScript 소스를 직접 import (tsx로 실행 시)
+// 빌드된 파일을 사용하려면 '../dist/infrastructure/database/database/init.js'로 변경
+import { initializeDatabase, closeDatabase } from '../src/infrastructure/database/database/init.js';
 
 async function debugEmbeddings() {
   console.log('🔍 임베딩 상태 디버깅 시작...');
   
-  // 데이터베이스 연결
-  const db = new Database(dbPath);
+  let db = null;
   
   try {
+    // 공통 모듈을 사용하여 데이터베이스 초기화
+    // initializeDatabase는 DB 파일이 없으면 자동으로 생성하고 초기화함
+    db = await initializeDatabase();
+    
     // 1. 전체 임베딩 통계
     console.log('\n📊 전체 임베딩 통계:');
     const totalStats = db.prepare(`
@@ -49,21 +52,18 @@ async function debugEmbeddings() {
         GROUP_CONCAT(memory_id) as memory_ids
       FROM memory_embedding
       GROUP BY dim
-      ORDER BY dim
+      ORDER BY count DESC
     `).all();
 
     dimensionStats.forEach(stat => {
       console.log(`- ${stat.dim}차원: ${stat.count}개`);
-      if (stat.count <= 5) {
-        console.log(`  메모리 ID: ${stat.memory_ids}`);
-      }
     });
 
     // 3. 모델별 분포
     console.log('\n🤖 모델별 분포:');
     const modelStats = db.prepare(`
       SELECT 
-        model,
+        COALESCE(model, 'NULL') as model,
         COUNT(*) as count,
         AVG(dim) as avg_dim
       FROM memory_embedding
@@ -72,113 +72,94 @@ async function debugEmbeddings() {
     `).all();
 
     modelStats.forEach(stat => {
-      console.log(`- ${stat.model || 'NULL'}: ${stat.count}개 (평균 ${stat.avg_dim?.toFixed(1)}차원)`);
+      console.log(`- ${stat.model}: ${stat.count}개 (평균 ${stat.avg_dim?.toFixed(1) || 'N/A'}차원)`);
     });
 
-    // 4. 최근 생성된 임베딩들
-    console.log('\n🕒 최근 생성된 임베딩 (최대 10개):');
-    const recentEmbeddings = db.prepare(`
+    // 4. 임베딩 제공자별 분포 (컬럼이 있는 경우)
+    const hasProvider = db.prepare("PRAGMA table_info(memory_embedding)").all()
+      .some(col => col.name === 'embedding_provider');
+    
+    if (hasProvider) {
+      console.log('\n🔧 임베딩 제공자별 분포:');
+      const providerStats = db.prepare(`
+        SELECT 
+          COALESCE(embedding_provider, 'NULL') as provider,
+          COUNT(*) as count,
+          AVG(dimensions) as avg_dim
+        FROM memory_embedding
+        GROUP BY embedding_provider
+        ORDER BY count DESC
+      `).all();
+
+      providerStats.forEach(stat => {
+        console.log(`- ${stat.provider}: ${stat.count}개 (평균 ${stat.avg_dim?.toFixed(1) || 'N/A'}차원)`);
+      });
+    }
+
+    // 5. 문제가 있는 임베딩 확인
+    console.log('\n⚠️ 문제가 있는 임베딩:');
+    const problematic = db.prepare(`
       SELECT 
         memory_id,
         dim,
         model,
-        created_at,
-        LENGTH(embedding) as embedding_length
+        CASE 
+          WHEN embedding IS NULL OR embedding = '' THEN '빈 임베딩'
+          WHEN dim IS NULL OR dim = 0 THEN '차원 없음'
+          ELSE '정상'
+        END as issue
       FROM memory_embedding
-      ORDER BY created_at DESC
+      WHERE embedding IS NULL OR embedding = '' OR dim IS NULL OR dim = 0
       LIMIT 10
     `).all();
 
-    recentEmbeddings.forEach(emb => {
-      console.log(`- ${emb.memory_id}: ${emb.dim}차원, ${emb.model}, ${emb.created_at}`);
-    });
-
-    // 5. 문제가 있는 임베딩 찾기
-    console.log('\n⚠️ 문제가 있을 수 있는 임베딩들:');
-    
-    // 차원이 0인 경우
-    const zeroDim = db.prepare(`
-      SELECT memory_id, dim, model FROM memory_embedding WHERE dim = 0
-    `).all();
-    
-    if (zeroDim.length > 0) {
-      console.log(`- 차원이 0인 임베딩: ${zeroDim.length}개`);
-      zeroDim.forEach(emb => {
-        console.log(`  ${emb.memory_id} (${emb.model})`);
+    if (problematic.length === 0) {
+      console.log('- 문제가 있는 임베딩이 없습니다.');
+    } else {
+      problematic.forEach(item => {
+        console.log(`- ${item.memory_id}: ${item.issue} (차원: ${item.dim || 'N/A'}, 모델: ${item.model || 'N/A'})`);
       });
     }
 
-    // 차원이 매우 큰 경우 (1536보다 큰 경우)
-    const largeDim = db.prepare(`
-      SELECT memory_id, dim, model FROM memory_embedding WHERE dim > 1536
-    `).all();
-    
-    if (largeDim.length > 0) {
-      console.log(`- 차원이 1536보다 큰 임베딩: ${largeDim.length}개`);
-      largeDim.forEach(emb => {
-        console.log(`  ${emb.memory_id}: ${emb.dim}차원 (${emb.model})`);
-      });
-    }
-
-    // 6. 임베딩 데이터 샘플 확인
-    console.log('\n🔬 임베딩 데이터 샘플 (첫 3개):');
-    const samples = db.prepare(`
+    // 6. 최근 생성된 임베딩
+    console.log('\n🕐 최근 생성된 임베딩 (최대 5개):');
+    const recent = db.prepare(`
       SELECT 
         memory_id,
         dim,
         model,
-        SUBSTR(embedding, 1, 100) as embedding_preview
+        created_at
       FROM memory_embedding
-      LIMIT 3
+      ORDER BY created_at DESC
+      LIMIT 5
     `).all();
 
-    samples.forEach((sample, index) => {
-      console.log(`\n샘플 ${index + 1}:`);
-      console.log(`- 메모리 ID: ${sample.memory_id}`);
-      console.log(`- 차원: ${sample.dim}`);
-      console.log(`- 모델: ${sample.model}`);
-      console.log(`- 임베딩 미리보기: ${sample.embedding_preview}...`);
-      
-      // 실제 벡터 길이 확인
-      try {
-        const fullEmbedding = db.prepare(`
-          SELECT embedding FROM memory_embedding WHERE memory_id = ?
-        `).get(sample.memory_id);
-        
-        const vector = JSON.parse(fullEmbedding.embedding);
-        console.log(`- 실제 벡터 길이: ${vector.length}`);
-        console.log(`- 첫 5개 값: [${vector.slice(0, 5).join(', ')}...]`);
-      } catch (error) {
-        console.log(`- 벡터 파싱 오류: ${error.message}`);
-      }
+    recent.forEach(item => {
+      console.log(`- ${item.memory_id}: ${item.dim}차원, ${item.model || 'N/A'} (${item.created_at})`);
     });
 
-    // 7. 메모리 아이템과의 연결 상태 확인
-    console.log('\n🔗 메모리 아이템 연결 상태:');
-    const connectionStats = db.prepare(`
-      SELECT 
-        (SELECT COUNT(*) FROM memory_item) as total_memories,
-        (SELECT COUNT(*) FROM memory_embedding) as total_embeddings,
-        (SELECT COUNT(*) FROM memory_item mi 
-         LEFT JOIN memory_embedding me ON mi.id = me.memory_id 
-         WHERE me.memory_id IS NULL) as memories_without_embedding
-    `).get();
-
-    console.log(`- 총 메모리 개수: ${connectionStats.total_memories}`);
-    console.log(`- 총 임베딩 개수: ${connectionStats.total_embeddings}`);
-    console.log(`- 임베딩이 없는 메모리: ${connectionStats.memories_without_embedding}`);
+    console.log('\n✅ 디버깅 완료!');
 
   } 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]}`) {
-  debugEmbeddings().catch(console.error);
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
+  debugEmbeddings().catch((error) => {
+    console.error('❌ 스크립트 실행 중 오류 발생:', error);
+    process.exit(1);
+  });
 }
 
 export { debugEmbeddings };