memento-mcp-server 0.1.0

package/src/database/init.ts

@@ -0,0 +1,130 @@
+/**
+ * SQLite 데이터베이스 초기화 스크립트
+ */
+
+import Database from 'better-sqlite3';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { mementoConfig } from '../config/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// MCP 서버에서는 모든 로그 출력을 완전히 차단
+const log = (...args: any[]) => {};
+
+export async function initializeDatabase(): Promise<Database.Database> {
+  log('🗄️  SQLite 데이터베이스 초기화 중...');
+  
+  // 데이터 디렉토리 생성
+  const dbDir = dirname(mementoConfig.dbPath);
+  try {
+    const fs = require('fs');
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+  } catch (error) {
+    // 디렉토리가 이미 존재하는 경우 무시
+  }
+  
+  try {
+    // SQLite 데이터베이스 연결
+    const db = new Database(mementoConfig.dbPath);
+    
+    // WAL 모드 사용 (동시 읽기 성능 향상)
+    db.pragma('journal_mode = WAL');
+    
+    // 외래키 제약 조건 활성화
+    db.pragma('foreign_keys = ON');
+    
+    // FTS5 확장 로드 시도 (Docker 환경에서는 더 안정적)
+    try {
+      // Docker 환경에서는 FTS5가 기본적으로 포함되어 있음
+      if (process.env.NODE_ENV === 'production' || process.env.DOCKER === 'true') {
+        // Docker 환경에서는 FTS5가 기본 포함되어 있으므로 로드 시도하지 않음
+        log('🐳 Docker 환경에서 FTS5 사용 가능');
+      } else {
+        // 로컬 환경에서만 확장 로드 시도
+        db.loadExtension('fts5');
+        log('✅ FTS5 확장 로드 완료');
+      }
+    } catch (error) {
+      log('⚠️  FTS5 확장 로드 실패, 기본 검색으로 전환:', error);
+      // FTS5가 없어도 기본 기능은 동작하도록 계속 진행
+    }
+    
+    // 잠금 타임아웃 설정 (60초로 증가)
+    db.pragma('busy_timeout = 60000');
+    
+    // 동시성 설정 최적화
+    db.pragma('synchronous = NORMAL');
+    db.pragma('cache_size = 20000'); // 캐시 크기 증가
+    db.pragma('temp_store = MEMORY');
+    db.pragma('mmap_size = 268435456'); // 256MB 메모리 맵핑
+    
+    // WAL 설정 최적화 (락 문제 해결)
+    db.pragma('wal_autocheckpoint = 100'); // 더 자주 체크포인트 (100페이지마다)
+    db.pragma('journal_size_limit = 33554432'); // 32MB WAL 크기 제한 (더 작게)
+    db.pragma('wal_checkpoint(TRUNCATE)'); // WAL 파일 정리
+    
+    // 추가 안정성 설정
+    db.pragma('locking_mode = NORMAL'); // 정상 잠금 모드
+    db.pragma('read_uncommitted = 0'); // 커밋된 읽기만 허용
+    
+        // sqlite-vec 확장 로드
+        try {
+          const { getLoadablePath } = await import('sqlite-vec');
+          const extensionPath = getLoadablePath();
+          db.loadExtension(extensionPath);
+          console.log('✅ sqlite-vec 확장 로드 성공');
+        } catch (error) {
+          console.warn('⚠️ sqlite-vec 확장 로드 실패 (벡터 검색 기능 비활성화):', error);
+        }
+    
+    // 스키마 파일 읽기 및 실행
+    const schemaPath = join(__dirname, 'schema.sql');
+    const schema = readFileSync(schemaPath, 'utf-8');
+    
+    // 스키마 실행
+    db.exec(schema);
+    
+    log('✅ 데이터베이스 초기화 완료');
+    log(`📁 데이터베이스 경로: ${mementoConfig.dbPath}`);
+    
+    return db;
+  } catch (error) {
+    log('❌ 데이터베이스 초기화 실패:', error);
+    throw error;
+  }
+}
+
+export function closeDatabase(db: Database.Database): void {
+  if (!db) {
+    log('🔒 데이터베이스가 이미 닫혔습니다');
+    return;
+  }
+  
+  try {
+    db.close();
+    log('🔒 데이터베이스 연결 종료');
+  } catch (error) {
+    log('❌ 데이터베이스 종료 실패:', error);
+  }
+}
+
+// CLI에서 직접 실행할 때
+if (process.argv[1] && process.argv[1].endsWith('init.ts')) {
+  console.log('🚀 데이터베이스 초기화 스크립트 시작');
+  (async () => {
+    try {
+      const db = await initializeDatabase();
+      console.log('🎉 데이터베이스 초기화 성공!');
+      closeDatabase(db);
+      process.exit(0);
+    } catch (error) {
+      console.error('❌ 데이터베이스 초기화 실패:', error);
+      process.exit(1);
+    }
+  })();
+}

package/src/database/migrate.spec.ts

@@ -0,0 +1,293 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { migrateDatabase } from './migrate.js';
+import Database from 'better-sqlite3';
+import { mementoConfig } from '../config/index.js';
+
+// Mock dependencies
+vi.mock('better-sqlite3');
+vi.mock('../config/index.js', () => ({
+  mementoConfig: {
+    dbPath: './test-data/test.db'
+  }
+}));
+
+describe('Database Migration', () => {
+  let mockDb: any;
+  let consoleSpy: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Mock database instance
+    mockDb = {
+      exec: vi.fn(),
+      close: vi.fn(),
+      prepare: vi.fn().mockReturnValue({
+        run: vi.fn(),
+        all: vi.fn(),
+        get: vi.fn()
+      })
+    };
+
+    vi.mocked(Database).mockImplementation(() => mockDb);
+    
+    // Mock console methods
+    consoleSpy = {
+      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+      error: vi.spyOn(console, 'error').mockImplementation(() => {})
+    };
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('migrateDatabase', () => {
+    it('마이그레이션을 성공적으로 실행해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(Database).toHaveBeenCalledWith('./test-data/test.db');
+      expect(mockDb.close).toHaveBeenCalled();
+    });
+
+    it('사용성 통계 컬럼을 추가해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith('ALTER TABLE memory_item ADD COLUMN view_count INTEGER DEFAULT 0');
+      expect(mockDb.exec).toHaveBeenCalledWith('ALTER TABLE memory_item ADD COLUMN cite_count INTEGER DEFAULT 0');
+      expect(mockDb.exec).toHaveBeenCalledWith('ALTER TABLE memory_item ADD COLUMN edit_count INTEGER DEFAULT 0');
+    });
+
+    it('중복 컬럼 에러를 무시해야 함', () => {
+      mockDb.exec.mockImplementation((sql: string) => {
+        if (sql.includes('view_count')) {
+          throw new Error('duplicate column name: view_count');
+        }
+        if (sql.includes('cite_count')) {
+          throw new Error('duplicate column name: cite_count');
+        }
+        if (sql.includes('edit_count')) {
+          throw new Error('duplicate column name: edit_count');
+        }
+      });
+
+      expect(() => migrateDatabase()).not.toThrow();
+    });
+
+    it('중복 컬럼이 아닌 다른 에러는 던져야 함', () => {
+      mockDb.exec.mockImplementation((sql: string) => {
+        if (sql.includes('view_count')) {
+          throw new Error('table not found');
+        }
+      });
+
+      expect(() => migrateDatabase()).toThrow('table not found');
+    });
+
+    it('임베딩 테이블을 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE IF NOT EXISTS memory_embedding'));
+    });
+
+    it('임베딩 인덱스를 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE INDEX IF NOT EXISTS idx_memory_embedding_memory_id'));
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE INDEX IF NOT EXISTS idx_memory_embedding_model'));
+    });
+
+    it('링크 테이블을 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE IF NOT EXISTS memory_link'));
+    });
+
+    it('링크 인덱스를 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE INDEX IF NOT EXISTS idx_memory_link_source'));
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE INDEX IF NOT EXISTS idx_memory_link_target'));
+    });
+
+    it('피드백 테이블을 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE IF NOT EXISTS memory_feedback'));
+    });
+
+    it('피드백 인덱스를 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE INDEX IF NOT EXISTS idx_memory_feedback_memory_id'));
+      expect(mockDb.exec).toHaveBeenCalledWith(expect.stringContaining('CREATE INDEX IF NOT EXISTS idx_memory_feedback_event_type'));
+    });
+
+    it('성공 메시지를 출력해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(consoleSpy.log).toHaveBeenCalledWith('🔄 데이터베이스 마이그레이션 시작');
+      expect(consoleSpy.log).toHaveBeenCalledWith('📊 사용성 통계 컬럼 추가 중...');
+      expect(consoleSpy.log).toHaveBeenCalledWith('✅ 사용성 통계 컬럼 추가 완료');
+      expect(consoleSpy.log).toHaveBeenCalledWith('🧠 임베딩 테이블 생성 중...');
+      expect(consoleSpy.log).toHaveBeenCalledWith('✅ 임베딩 테이블 생성 완료');
+      expect(consoleSpy.log).toHaveBeenCalledWith('🔗 링크 테이블 생성 중...');
+      expect(consoleSpy.log).toHaveBeenCalledWith('✅ 링크 테이블 생성 완료');
+      expect(consoleSpy.log).toHaveBeenCalledWith('💬 피드백 테이블 생성 중...');
+      expect(consoleSpy.log).toHaveBeenCalledWith('✅ 피드백 테이블 생성 완료');
+      expect(consoleSpy.log).toHaveBeenCalledWith('🎉 데이터베이스 마이그레이션 완료');
+    });
+
+    it('에러 발생 시 에러 메시지를 출력하고 에러를 던져야 함', () => {
+      const error = new Error('Migration failed');
+      mockDb.exec.mockImplementation(() => {
+        throw error;
+      });
+
+      expect(() => migrateDatabase()).toThrow('Migration failed');
+      expect(consoleSpy.error).toHaveBeenCalledWith('❌ 데이터베이스 마이그레이션 실패:', error);
+    });
+
+    it('데이터베이스 연결 실패 시 에러를 던져야 함', () => {
+      vi.mocked(Database).mockImplementation(() => {
+        throw new Error('Connection failed');
+      });
+
+      expect(() => migrateDatabase()).toThrow('Connection failed');
+    });
+
+    it('마이그레이션 완료 후 데이터베이스를 닫아야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      expect(mockDb.close).toHaveBeenCalled();
+    });
+
+    it('에러 발생 시에도 데이터베이스를 닫아야 함', () => {
+      mockDb.exec.mockImplementation(() => {
+        throw new Error('Migration failed');
+      });
+
+      try {
+        migrateDatabase();
+      } catch (error) {
+        // Expected error
+      }
+
+      expect(mockDb.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('테이블 생성', () => {
+    it('임베딩 테이블에 올바른 컬럼을 포함해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      const embeddingTableCall = mockDb.exec.mock.calls.find(call => 
+        call[0].includes('CREATE TABLE IF NOT EXISTS memory_embedding')
+      );
+
+      expect(embeddingTableCall).toBeDefined();
+      expect(embeddingTableCall[0]).toContain('memory_id TEXT NOT NULL');
+      expect(embeddingTableCall[0]).toContain('embedding BLOB NOT NULL');
+      expect(embeddingTableCall[0]).toContain('model TEXT NOT NULL');
+      expect(embeddingTableCall[0]).toContain('created_at DATETIME DEFAULT CURRENT_TIMESTAMP');
+    });
+
+    it('링크 테이블에 올바른 컬럼을 포함해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      const linkTableCall = mockDb.exec.mock.calls.find(call => 
+        call[0].includes('CREATE TABLE IF NOT EXISTS memory_link')
+      );
+
+      expect(linkTableCall).toBeDefined();
+      expect(linkTableCall[0]).toContain('source_id TEXT NOT NULL');
+      expect(linkTableCall[0]).toContain('target_id TEXT NOT NULL');
+      expect(linkTableCall[0]).toContain('relation_type TEXT NOT NULL');
+      expect(linkTableCall[0]).toContain('created_at DATETIME DEFAULT CURRENT_TIMESTAMP');
+    });
+
+    it('피드백 테이블에 올바른 컬럼을 포함해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      const feedbackTableCall = mockDb.exec.mock.calls.find(call => 
+        call[0].includes('CREATE TABLE IF NOT EXISTS memory_feedback')
+      );
+
+      expect(feedbackTableCall).toBeDefined();
+      expect(feedbackTableCall[0]).toContain('memory_id TEXT NOT NULL');
+      expect(feedbackTableCall[0]).toContain('event_type TEXT NOT NULL');
+      expect(feedbackTableCall[0]).toContain('score REAL');
+      expect(feedbackTableCall[0]).toContain('created_at DATETIME DEFAULT CURRENT_TIMESTAMP');
+    });
+  });
+
+  describe('인덱스 생성', () => {
+    it('임베딩 테이블에 필요한 인덱스를 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      const indexCalls = mockDb.exec.mock.calls.filter(call => 
+        call[0].includes('CREATE INDEX IF NOT EXISTS idx_memory_embedding')
+      );
+
+      expect(indexCalls).toHaveLength(2);
+      expect(indexCalls.some(call => call[0].includes('memory_id'))).toBe(true);
+      expect(indexCalls.some(call => call[0].includes('model'))).toBe(true);
+    });
+
+    it('링크 테이블에 필요한 인덱스를 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      const indexCalls = mockDb.exec.mock.calls.filter(call => 
+        call[0].includes('CREATE INDEX IF NOT EXISTS idx_memory_link')
+      );
+
+      expect(indexCalls).toHaveLength(2);
+      expect(indexCalls.some(call => call[0].includes('source_id'))).toBe(true);
+      expect(indexCalls.some(call => call[0].includes('target_id'))).toBe(true);
+    });
+
+    it('피드백 테이블에 필요한 인덱스를 생성해야 함', () => {
+      mockDb.exec.mockImplementation(() => {});
+
+      migrateDatabase();
+
+      const indexCalls = mockDb.exec.mock.calls.filter(call => 
+        call[0].includes('CREATE INDEX IF NOT EXISTS idx_memory_feedback')
+      );
+
+      expect(indexCalls).toHaveLength(2);
+      expect(indexCalls.some(call => call[0].includes('memory_id'))).toBe(true);
+      expect(indexCalls.some(call => call[0].includes('event_type'))).toBe(true);
+    });
+  });
+});

package/src/database/migrate.ts

@@ -0,0 +1,94 @@
+/**
+ * 데이터베이스 마이그레이션 스크립트
+ * 기존 데이터베이스에 새 컬럼 추가
+ */
+
+import Database from 'better-sqlite3';
+import { mementoConfig } from '../config/index.js';
+
+function migrateDatabase() {
+  console.log('🔄 데이터베이스 마이그레이션 시작');
+  
+  const db = new Database(mementoConfig.dbPath);
+  
+  try {
+    // 사용성 통계 컬럼 추가
+    console.log('📊 사용성 통계 컬럼 추가 중...');
+    
+    try {
+      db.exec('ALTER TABLE memory_item ADD COLUMN view_count INTEGER DEFAULT 0');
+    } catch (err: any) {
+      if (!err.message.includes('duplicate column name')) {
+        throw err;
+      }
+    }
+    
+    try {
+      db.exec('ALTER TABLE memory_item ADD COLUMN cite_count INTEGER DEFAULT 0');
+    } catch (err: any) {
+      if (!err.message.includes('duplicate column name')) {
+        throw err;
+      }
+    }
+    
+    try {
+      db.exec('ALTER TABLE memory_item ADD COLUMN edit_count INTEGER DEFAULT 0');
+    } catch (err: any) {
+      if (!err.message.includes('duplicate column name')) {
+        throw err;
+      }
+    }
+    
+    console.log('✅ 사용성 통계 컬럼 추가 완료');
+    
+    // 임베딩 테이블 생성 (기존에 없다면)
+    console.log('🧠 임베딩 테이블 생성 중...');
+    
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_embedding (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id TEXT NOT NULL,
+        embedding TEXT NOT NULL,
+        dim INTEGER NOT NULL,
+        model TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (memory_id) REFERENCES memory_item(id) ON DELETE CASCADE,
+        UNIQUE(memory_id)
+      )
+    `);
+    
+    console.log('✅ 임베딩 테이블 생성 완료');
+    
+    // 기존 데이터에 기본값 설정
+    console.log('🔧 기존 데이터 업데이트 중...');
+    
+    db.exec(`
+      UPDATE memory_item 
+      SET view_count = 0, cite_count = 0, edit_count = 0 
+      WHERE view_count IS NULL OR cite_count IS NULL OR edit_count IS NULL
+    `);
+    
+    console.log('✅ 기존 데이터 업데이트 완료');
+    
+    // 마이그레이션 완료
+    console.log('🎉 데이터베이스 마이그레이션 완료!');
+    
+  } catch (error) {
+    console.error('❌ 마이그레이션 실패:', error);
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+
+// 마이그레이션 실행
+if (process.argv[1] && process.argv[1].endsWith('migrate.ts')) {
+  try {
+    migrateDatabase();
+    console.log('✅ 마이그레이션 완료');
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ 마이그레이션 실패:', error);
+    process.exit(1);
+  }
+}

package/src/database/migrations/001_add_embedding_metadata.sql

@@ -0,0 +1,29 @@
+-- 임베딩 메타데이터 추가 마이그레이션
+-- 기존 memory_embedding 테이블에 제공자 정보 추가
+
+-- 1. 새로운 컬럼 추가
+ALTER TABLE memory_embedding ADD COLUMN embedding_provider TEXT;
+ALTER TABLE memory_embedding ADD COLUMN dimensions INTEGER;
+ALTER TABLE memory_embedding ADD COLUMN created_by TEXT DEFAULT 'migration';
+
+-- 2. 기존 데이터 업데이트
+-- 512차원 데이터는 TF-IDF로 추정 (기본값)
+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;
+
+-- 3. 인덱스 추가
+CREATE INDEX IF NOT EXISTS idx_memory_embedding_provider ON memory_embedding(embedding_provider);
+CREATE INDEX IF NOT EXISTS idx_memory_embedding_dimensions ON memory_embedding(dimensions);
+CREATE INDEX IF NOT EXISTS idx_memory_embedding_created_by ON memory_embedding(created_by);
+
+-- 4. 제약 조건 추가
+-- embedding_provider는 유효한 값만 허용
+-- 이 부분은 SQLite에서 CHECK 제약조건이 제한적이므로 애플리케이션 레벨에서 검증