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

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 };

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 };