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

package/scripts/fix-migration.js

@@ -1,93 +1,128 @@
 #!/usr/bin/env node
+/**
+ * Memento 마이그레이션 수정 스크립트
+ * 
+ * 리팩토링: 공통 모듈(initializeDatabase)을 사용하여 일관된 DB 초기화 보장
+ * 
+ * 사용법: 
+ *   - 개발 환경: npx tsx scripts/fix-migration.js
+ *   - 프로덕션: npm run build && node dist/scripts/fix-migration.js
+ */
 
-import Database from 'better-sqlite3';
-import { join } from 'path';
-
-const dbPath = join(process.cwd(), 'data', 'memory.db');
+// TypeScript 소스를 직접 import (tsx로 실행 시)
+// 빌드된 파일을 사용하려면 '../dist/infrastructure/database/database/init.js'로 변경
+import { initializeDatabase, closeDatabase } from '../src/infrastructure/database/database/init.js';
 
 console.log('🔧 마이그레이션 수정 중...');
 
-try {
-  const db = new Database(dbPath);
-  
-  // 1. 현재 상태 확인
-  console.log('📊 현재 상태 확인...');
-  const currentSchema = db.prepare("PRAGMA table_info(memory_embedding)").all();
-  console.log('현재 테이블 구조:');
-  console.table(currentSchema);
-  
-  // 2. 컬럼이 있는지 확인
-  const hasProvider = currentSchema.some(col => col.name === 'embedding_provider');
-  const hasDimensions = currentSchema.some(col => col.name === 'dimensions');
-  const hasCreatedBy = currentSchema.some(col => col.name === 'created_by');
-  
-  console.log(`embedding_provider: ${hasProvider ? '✅' : '❌'}`);
-  console.log(`dimensions: ${hasDimensions ? '✅' : '❌'}`);
-  console.log(`created_by: ${hasCreatedBy ? '✅' : '❌'}`);
+/**
+ * 마이그레이션 수정 메인 함수
+ */
+async function fixMigration() {
+  let db = null;
   
-  // 3. 데이터 업데이트 (컬럼이 있는 경우에만)
-  if (hasProvider && hasDimensions && hasCreatedBy) {
-    console.log('🔄 데이터 업데이트 중...');
-    
-    const updateResult = 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
-    `).run();
-    
-    console.log(`✅ ${updateResult.changes}개 레코드 업데이트 완료`);
-    
-    // 4. 인덱스 추가
-    console.log('📝 인덱스 추가 중...');
-    db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_provider ON memory_embedding(embedding_provider)');
-    db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_dimensions ON memory_embedding(dimensions)');
-    db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_created_by ON memory_embedding(created_by)');
-    console.log('✅ 인덱스 추가 완료');
+  try {
+    // 공통 모듈을 사용하여 데이터베이스 초기화
+    // initializeDatabase는 DB 파일이 없으면 자동으로 생성하고 초기화함
+    db = await initializeDatabase();
     
-    // 5. 최종 검증
-    console.log('🔍 최종 검증...');
-    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();
+    // 1. 현재 상태 확인
+    console.log('📊 현재 상태 확인...');
+    const currentSchema = db.prepare("PRAGMA table_info(memory_embedding)").all();
+    console.log('현재 테이블 구조:');
+    console.table(currentSchema);
     
-    console.log('📊 검증 결과:');
-    console.table(validation);
+    // 2. 컬럼이 있는지 확인
+    const hasProvider = currentSchema.some(col => col.name === 'embedding_provider');
+    const hasDimensions = currentSchema.some(col => col.name === 'dimensions');
+    const hasCreatedBy = currentSchema.some(col => col.name === 'created_by');
     
-    // 6. 최종 데이터 분포
-    const finalAnalysis = db.prepare(`
-      SELECT 
-        embedding_provider,
-        dimensions,
-        COUNT(*) as count
-      FROM memory_embedding 
-      GROUP BY embedding_provider, dimensions
-      ORDER BY count DESC
-    `).all();
+    console.log(`embedding_provider: ${hasProvider ? '✅' : '❌'}`);
+    console.log(`dimensions: ${hasDimensions ? '✅' : '❌'}`);
+    console.log(`created_by: ${hasCreatedBy ? '✅' : '❌'}`);
     
-    console.log('\n📊 최종 데이터 분포:');
-    console.table(finalAnalysis);
+    // 3. 데이터 업데이트 (컬럼이 있는 경우에만)
+    if (hasProvider && hasDimensions && hasCreatedBy) {
+      console.log('🔄 데이터 업데이트 중...');
+      
+      const updateResult = 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
+      `).run();
+      
+      console.log(`✅ ${updateResult.changes}개 레코드 업데이트 완료`);
+      
+      // 4. 인덱스 추가
+      console.log('📝 인덱스 추가 중...');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_provider ON memory_embedding(embedding_provider)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_dimensions ON memory_embedding(dimensions)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_created_by ON memory_embedding(created_by)');
+      console.log('✅ 인덱스 추가 완료');
+      
+      // 5. 최종 검증
+      console.log('🔍 최종 검증...');
+      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();
+      
+      console.log('📊 검증 결과:');
+      console.table(validation);
+      
+      // 6. 최종 데이터 분포
+      const finalAnalysis = db.prepare(`
+        SELECT 
+          embedding_provider,
+          dimensions,
+          COUNT(*) as count
+        FROM memory_embedding 
+        GROUP BY embedding_provider, dimensions
+        ORDER BY count DESC
+      `).all();
+      
+      console.log('\n📊 최종 데이터 분포:');
+      console.table(finalAnalysis);
+      
+      console.log('\n🎉 마이그레이션 완료!');
+      
+    } else {
+      console.log('❌ 필요한 컬럼이 없습니다. 스키마를 먼저 업데이트해주세요.');
+      console.log('   initializeDatabase가 자동으로 스키마를 생성하지만, 필요한 컬럼이 없을 수 있습니다.');
+      process.exit(1);
+    }
     
-    console.log('\n🎉 마이그레이션 완료!');
-    
-  } else {
-    console.log('❌ 필요한 컬럼이 없습니다. 스키마를 먼저 업데이트해주세요.');
+  } catch (error) {
+    console.error('❌ 오류 발생:', error.message);
+    if (error.stack) {
+      console.error('   스택 트레이스:', error.stack);
+    }
+    process.exit(1);
+  } finally {
+    // 데이터베이스 연결 종료
+    if (db) {
+      closeDatabase(db);
+    }
   }
-  
-  db.close();
-  
-} catch (error) {
-  console.error('❌ 오류 발생:', error.message);
-  process.exit(1);
 }
+
+// 스크립트가 직접 실행될 때만 main 함수 호출
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
+  fixMigration().catch((error) => {
+    console.error('❌ 스크립트 실행 중 오류 발생:', error);
+    process.exit(1);
+  });
+}
+
+export { fixMigration };

package/scripts/fix-vector-dimensions.js

@@ -3,27 +3,31 @@
 /**
  * 벡터 차원 통일 스크립트
  * 모든 임베딩을 삭제하고 현재 설정에 맞는 모델로 재생성
+ * 
+ * 리팩토링: 공통 모듈(initializeDatabase)을 사용하여 일관된 DB 초기화 보장
+ * 
+ * 사용법: 
+ *   - 개발 환경: npx tsx scripts/fix-vector-dimensions.js
+ *   - 프로덕션: npm run build && node dist/scripts/fix-vector-dimensions.js
  */
 
-import Database from 'better-sqlite3';
-import path from 'path';
-import { fileURLToPath } from 'url';
+// TypeScript 소스를 직접 import (tsx로 실행 시)
+// 빌드된 파일을 사용하려면 '../dist/infrastructure/database/database/init.js'로 변경
+import { initializeDatabase, closeDatabase } from '../src/infrastructure/database/database/init.js';
 import { EmbeddingService } from '../dist/services/embedding-service.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 데이터베이스 경로 설정
-const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
-
 async function fixVectorDimensions() {
   console.log('🔧 벡터 차원 통일 작업 시작...');
   
-  // 데이터베이스 연결
-  const db = new Database(dbPath);
-  const embeddingService = new EmbeddingService();
+  let db = null;
   
   try {
+    // 공통 모듈을 사용하여 데이터베이스 초기화
+    // initializeDatabase는 DB 파일이 없으면 자동으로 생성하고 초기화함
+    db = await initializeDatabase();
+    
+    const embeddingService = new EmbeddingService();
+    
     // 1. 현재 상태 확인
     console.log('\n📊 현재 상태:');
     const currentStats = db.prepare(`
@@ -50,59 +54,39 @@ async function fixVectorDimensions() {
       process.exit(1);
     }
 
-    // 3. 기존 임베딩 백업
-    console.log('\n💾 기존 임베딩 백업 중...');
-    const backupData = 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
-    `).all();
+    // 3. 사용자 확인
+    console.log('\n⚠️ 경고: 이 작업은 모든 임베딩을 삭제하고 재생성합니다.');
+    console.log('백업을 먼저 수행하는 것을 권장합니다.');
+    console.log('계속하려면 스크립트를 --confirm 플래그와 함께 실행하세요.');
 
-    const backupFile = path.join(__dirname, '..', 'backup', `embeddings-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`);
-    const fs = await import('fs');
-    
-    if (!fs.existsSync(path.dirname(backupFile))) {
-      fs.mkdirSync(path.dirname(backupFile), { recursive: true });
+    if (!process.argv.includes('--confirm')) {
+      console.log('\n❌ 확인 플래그가 없어 작업을 중단합니다.');
+      console.log('사용법: npx tsx scripts/fix-vector-dimensions.js --confirm');
+      return;
     }
 
-    fs.writeFileSync(backupFile, JSON.stringify({
-      timestamp: new Date().toISOString(),
-      totalEmbeddings: backupData.length,
-      embeddings: backupData.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
-      }))
-    }, null, 2));
-
-    console.log(`✅ 백업 완료: ${backupFile}`);
-
-    // 4. 기존 임베딩 삭제
-    console.log('\n🗑️ 기존 임베딩 삭제 중...');
-    const deleteResult = db.prepare('DELETE FROM memory_embedding').run();
-    console.log(`✅ 삭제 완료: ${deleteResult.changes}개 행 삭제`);
-
-    // 5. 모든 메모리에 대해 새로운 임베딩 생성
-    console.log('\n🔄 새로운 임베딩 생성 중...');
+    // 4. 모든 기억 조회
+    console.log('\n📋 기억 조회 중...');
     const memories = db.prepare(`
-      SELECT id, content, type, importance, created_at
+      SELECT id, content, type
       FROM memory_item
       ORDER BY created_at
     `).all();
 
-    console.log(`📊 처리할 메모리 개수: ${memories.length}`);
+    console.log(`📊 처리할 기억 개수: ${memories.length}`);
+
+    if (memories.length === 0) {
+      console.log('⚠️ 재생성할 기억이 없습니다.');
+      return;
+    }
 
+    // 5. 기존 임베딩 삭제
+    console.log('\n🗑️ 기존 임베딩 삭제 중...');
+    const deleteResult = db.prepare('DELETE FROM memory_embedding').run();
+    console.log(`✅ ${deleteResult.changes}개 임베딩 삭제 완료`);
+
+    // 6. 새로운 임베딩 생성
+    console.log('\n🔄 새로운 임베딩 생성 중...');
     let successCount = 0;
     let errorCount = 0;
 
@@ -136,7 +120,7 @@ async function fixVectorDimensions() {
         console.log(`${progress} ✅ 완료: ${memory.id} (${embeddingResult.embedding.length}차원)`);
         successCount++;
 
-        // API 제한을 위한 대기
+        // API 제한을 위한 대기 (필요시)
         if (i % 10 === 0 && i > 0) {
           console.log('⏳ API 제한 대기 중...');
           await new Promise(resolve => setTimeout(resolve, 1000));
@@ -144,63 +128,60 @@ async function fixVectorDimensions() {
 
       } catch (error) {
         console.error(`${progress} ❌ 오류: ${memory.id}`, error.message);
+        if (error.stack) {
+          console.error('   스택 트레이스:', error.stack);
+        }
         errorCount++;
       }
     }
 
-    // 6. 최종 검증
-    console.log('\n🔍 최종 검증:');
+    // 7. 결과 통계
+    console.log('\n📊 작업 완료!');
+    console.log(`✅ 성공: ${successCount}개`);
+    console.log(`❌ 실패: ${errorCount}개`);
+    console.log(`📈 성공률: ${((successCount / memories.length) * 100).toFixed(1)}%`);
+
+    // 8. 최종 검증
     const finalStats = db.prepare(`
       SELECT 
         COUNT(*) as total,
-        AVG(dim) as avg_dim,
-        MIN(dim) as min_dim,
-        MAX(dim) as max_dim,
-        COUNT(DISTINCT dim) as unique_dims
+        COUNT(DISTINCT dim) as unique_dims,
+        AVG(dim) as avg_dim
       FROM memory_embedding
     `).get();
 
+    console.log('\n🔍 최종 검증:');
     console.log(`- 총 임베딩: ${finalStats.total}개`);
-    console.log(`- 평균 차원: ${finalStats.avg_dim?.toFixed(1) || 'N/A'}`);
-    console.log(`- 최소 차원: ${finalStats.min_dim || 'N/A'}`);
-    console.log(`- 최대 차원: ${finalStats.max_dim || 'N/A'}`);
     console.log(`- 고유 차원 수: ${finalStats.unique_dims}개`);
+    console.log(`- 평균 차원: ${finalStats.avg_dim?.toFixed(1) || 'N/A'}`);
 
-    // 차원 일치성 확인
     const expectedDim = modelInfo.dimensions;
-    const mismatchedDims = db.prepare(`
-      SELECT COUNT(*) as count FROM memory_embedding WHERE dim != ?
-    `).get(expectedDim);
-
-    if (mismatchedDims.count > 0) {
-      console.warn(`⚠️ 차원 불일치 발견: ${mismatchedDims.count}개`);
-    } else {
+    if (finalStats.unique_dims === 1 && finalStats.avg_dim === expectedDim) {
       console.log('✅ 모든 임베딩의 차원이 일치합니다!');
-    }
-
-    // 7. 결과 요약
-    console.log('\n📊 작업 완료 요약:');
-    console.log(`✅ 성공: ${successCount}개`);
-    console.log(`❌ 실패: ${errorCount}개`);
-    console.log(`📈 성공률: ${((successCount / memories.length) * 100).toFixed(1)}%`);
-
-    if (finalStats.unique_dims === 1) {
-      console.log('🎉 벡터 차원 통일 완료! 이제 검색이 정상 작동할 것입니다.');
     } else {
-      console.log('⚠️ 여전히 차원 불일치가 있습니다. 추가 확인이 필요합니다.');
+      console.warn(`⚠️ 차원 불일치: 예상 ${expectedDim}차원, 실제 ${finalStats.avg_dim?.toFixed(1) || 'N/A'}차원`);
     }
 
   } 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]}`) {
-  fixVectorDimensions().catch(console.error);
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
+  fixVectorDimensions().catch((error) => {
+    console.error('❌ 스크립트 실행 중 오류 발생:', error);
+    process.exit(1);
+  });
 }
 
 export { fixVectorDimensions };

package/scripts/migrate-embedding-data.js

@@ -3,12 +3,21 @@
 /**
  * 임베딩 데이터 마이그레이션 스크립트
  * 기존 임베딩 데이터를 새로운 통합 시스템으로 마이그레이션
+ * 
+ * 리팩토링: 공통 모듈(initializeDatabase)을 사용하여 일관된 DB 초기화 보장
+ * 
+ * 사용법: 
+ *   - 개발 환경: npx tsx scripts/migrate-embedding-data.js migrate
+ *   - 프로덕션: npm run build && node dist/scripts/migrate-embedding-data.js migrate
  */
 
+// TypeScript 소스를 직접 import (tsx로 실행 시)
+// 빌드된 파일을 사용하려면 '../dist/infrastructure/database/database/init.js'로 변경
+import { initializeDatabase, closeDatabase } from '../src/infrastructure/database/database/init.js';
 import Database from 'better-sqlite3';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { readFileSync } from 'fs';
+import { readFileSync, copyFileSync } from 'fs';
 import { existsSync } from 'fs';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -16,17 +25,21 @@ const __dirname = dirname(__filename);
 
 class EmbeddingMigration {
   constructor() {
-    this.dbPath = join(__dirname, '..', 'data', 'memory.db');
-    this.backupPath = join(__dirname, '..', 'data', `memory-backup-${Date.now()}.db`);
+    // DB 경로는 initializeDatabase가 환경 변수에서 가져옴
+    // 백업 경로는 data 디렉토리에 생성
+    this.backupPath = join(process.cwd(), 'data', `memory-backup-${Date.now()}.db`);
     this.db = null;
   }
 
   /**
    * 데이터베이스 연결
+   * 공통 모듈을 사용하여 일관된 초기화 보장
    */
-  connect() {
+  async connect() {
     try {
-      this.db = new Database(this.dbPath);
+      // 공통 모듈을 사용하여 데이터베이스 초기화
+      // initializeDatabase는 DB 파일이 없으면 자동으로 생성하고 초기화함
+      this.db = await initializeDatabase();
       console.log('✅ 데이터베이스 연결 성공');
     } catch (error) {
       console.error('❌ 데이터베이스 연결 실패:', error);
@@ -39,9 +52,19 @@ class EmbeddingMigration {
    */
   createBackup() {
     try {
-      const db = new Database(this.dbPath);
-      db.backup(this.backupPath);
-      db.close();
+      if (!this.db) {
+        throw new Error('데이터베이스가 연결되지 않았습니다. connect()를 먼저 호출하세요.');
+      }
+      
+      // 백업 디렉토리 생성
+      const backupDir = dirname(this.backupPath);
+      if (!existsSync(backupDir)) {
+        const { mkdirSync } = require('fs');
+        mkdirSync(backupDir, { recursive: true });
+      }
+      
+      // 백업 생성
+      this.db.backup(this.backupPath);
       console.log(`✅ 백업 생성 완료: ${this.backupPath}`);
     } catch (error) {
       console.error('❌ 백업 생성 실패:', error);
@@ -76,11 +99,14 @@ class EmbeddingMigration {
       
     } catch (error) {
       console.error('❌ 마이그레이션 실패:', error);
-      console.log(`🔄 백업에서 복원하려면: cp ${this.backupPath} ${this.dbPath}`);
+      if (error.stack) {
+        console.error('   스택 트레이스:', error.stack);
+      }
+      console.log(`🔄 백업에서 복원하려면: cp ${this.backupPath} ${join(process.cwd(), 'data', 'memory.db')}`);
       throw error;
     } finally {
       if (this.db) {
-        this.db.close();
+        closeDatabase(this.db);
       }
     }
   }
@@ -122,11 +148,36 @@ class EmbeddingMigration {
    */
   async runDirectMigration() {
     try {
+      if (!this.db) {
+        throw new Error('데이터베이스가 연결되지 않았습니다.');
+      }
+      
       // 1. 새로운 컬럼 추가
       console.log('📝 컬럼 추가 중...');
-      this.db.exec('ALTER TABLE memory_embedding ADD COLUMN embedding_provider TEXT');
-      this.db.exec('ALTER TABLE memory_embedding ADD COLUMN dimensions INTEGER');
-      this.db.exec('ALTER TABLE memory_embedding ADD COLUMN created_by TEXT DEFAULT "migration"');
+      try {
+        this.db.exec('ALTER TABLE memory_embedding ADD COLUMN embedding_provider TEXT');
+      } catch (error) {
+        // 컬럼이 이미 존재할 수 있음
+        if (!error.message.includes('duplicate column')) {
+          throw error;
+        }
+      }
+      
+      try {
+        this.db.exec('ALTER TABLE memory_embedding ADD COLUMN dimensions INTEGER');
+      } catch (error) {
+        if (!error.message.includes('duplicate column')) {
+          throw error;
+        }
+      }
+      
+      try {
+        this.db.exec('ALTER TABLE memory_embedding ADD COLUMN created_by TEXT DEFAULT "migration"');
+      } catch (error) {
+        if (!error.message.includes('duplicate column')) {
+          throw error;
+        }
+      }
       
       // 2. 기존 데이터 업데이트
       console.log('📝 기존 데이터 업데이트 중...');
@@ -160,6 +211,10 @@ class EmbeddingMigration {
    * 기존 데이터 분석
    */
   analyzeExistingData() {
+    if (!this.db) {
+      throw new Error('데이터베이스가 연결되지 않았습니다.');
+    }
+    
     const analysis = {};
     
     // 차원별 분포
@@ -206,6 +261,10 @@ class EmbeddingMigration {
    * 메타데이터 업데이트
    */
   updateMetadata() {
+    if (!this.db) {
+      throw new Error('데이터베이스가 연결되지 않았습니다.');
+    }
+    
     const updateStmt = this.db.prepare(`
       UPDATE memory_embedding 
       SET 
@@ -240,6 +299,10 @@ class EmbeddingMigration {
    * 마이그레이션 검증
    */
   validateMigration() {
+    if (!this.db) {
+      throw new Error('데이터베이스가 연결되지 않았습니다.');
+    }
+    
     console.log('🔍 마이그레이션 검증 중...');
     
     const validation = this.db.prepare(`
@@ -265,41 +328,64 @@ class EmbeddingMigration {
    */
   rollback() {
     try {
-      const fs = require('fs');
-      fs.copyFileSync(this.backupPath, this.dbPath);
+      const dbPath = join(process.cwd(), 'data', 'memory.db');
+      copyFileSync(this.backupPath, dbPath);
       console.log('🔄 백업에서 복원 완료');
     } catch (error) {
       console.error('❌ 롤백 실패:', error);
+      throw error;
     }
   }
 }
 
 // CLI 실행
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith(process.argv[1])) {
   const migration = new EmbeddingMigration();
   
   const command = process.argv[2];
   
   switch (command) {
     case 'migrate':
-      migration.connect();
-      migration.migrate();
+      migration.connect().then(() => {
+        migration.migrate().catch((error) => {
+          console.error('❌ 마이그레이션 실행 중 오류:', error);
+          process.exit(1);
+        });
+      }).catch((error) => {
+        console.error('❌ 데이터베이스 연결 중 오류:', error);
+        process.exit(1);
+      });
       break;
     case 'rollback':
       migration.rollback();
       break;
     case 'analyze':
-      migration.connect();
-      const analysis = migration.analyzeExistingData();
-      console.log('📊 데이터 분석 결과:', JSON.stringify(analysis, null, 2));
+      migration.connect().then(() => {
+        try {
+          const analysis = migration.analyzeExistingData();
+          console.log('📊 데이터 분석 결과:', JSON.stringify(analysis, null, 2));
+          if (migration.db) {
+            closeDatabase(migration.db);
+          }
+        } catch (error) {
+          console.error('❌ 분석 중 오류:', error);
+          if (migration.db) {
+            closeDatabase(migration.db);
+          }
+          process.exit(1);
+        }
+      }).catch((error) => {
+        console.error('❌ 데이터베이스 연결 중 오류:', error);
+        process.exit(1);
+      });
       break;
     default:
       console.log(`
 사용법:
-  node migrate-embedding-data.js migrate     # 마이그레이션 실행
-  node migrate-embedding-data.js rollback   # 백업에서 복원
-  node migrate-embedding-data.js analyze    # 데이터 분석만
-  node migrate-embedding-data.js migrate --regenerate  # 임베딩 재생성 모드
+  npx tsx scripts/migrate-embedding-data.js migrate     # 마이그레이션 실행
+  npx tsx scripts/migrate-embedding-data.js rollback   # 백업에서 복원
+  npx tsx scripts/migrate-embedding-data.js analyze    # 데이터 분석만
+  npx tsx scripts/migrate-embedding-data.js migrate --regenerate  # 임베딩 재생성 모드
       `);
   }
 }