memento-mcp-server 1.6.0 → 1.7.1

package/dist/server/index-backup.js

@@ -1,793 +0,0 @@
-/**
- * Memento MCP Server 메인 진입점
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { initializeDatabase, closeDatabase } from '../database/init.js';
-import { mementoConfig, validateConfig } from '../config/index.js';
-import { DatabaseUtils } from '../utils/database.js';
-import { SearchEngine } from '../algorithms/search-engine.js';
-import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
-import { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
-import { ForgettingPolicyService } from '../services/forgetting-policy-service.js';
-import { PerformanceMonitor } from '../services/performance-monitor.js';
-import { SearchCacheService } from '../services/cache-service.js';
-import { DatabaseOptimizer } from '../services/database-optimizer.js';
-import Database from 'better-sqlite3';
-// MCP 서버 인스턴스
-let server;
-let db = null;
-let searchEngine;
-let hybridSearchEngine;
-let embeddingService;
-let forgettingPolicyService;
-let performanceMonitor;
-let searchCache;
-let databaseOptimizer;
-// MCP 서버에서는 모든 로그 출력을 완전히 차단
-// 모든 console 메서드를 빈 함수로 교체
-console.log = () => { };
-console.error = () => { };
-console.warn = () => { };
-console.info = () => { };
-console.debug = () => { };
-// MCP Tools 스키마 정의
-const RememberSchema = z.object({
-    content: z.string().min(1, 'Content cannot be empty'),
-    type: z.enum(['working', 'episodic', 'semantic', 'procedural']).default('episodic'),
-    tags: z.array(z.string()).optional(),
-    importance: z.number().min(0).max(1).default(0.5),
-    source: z.string().optional(),
-    privacy_scope: z.enum(['private', 'team', 'public']).default('private')
-});
-const RecallSchema = z.object({
-    query: z.string().min(1, 'Query cannot be empty'),
-    filters: z.object({
-        type: z.array(z.enum(['working', 'episodic', 'semantic', 'procedural'])).optional(),
-        tags: z.array(z.string()).optional(),
-        privacy_scope: z.array(z.enum(['private', 'team', 'public'])).optional(),
-        time_from: z.string().optional(),
-        time_to: z.string().optional(),
-        pinned: z.boolean().optional()
-    }).optional(),
-    limit: z.number().min(1).max(50).default(10)
-});
-const ForgetSchema = z.object({
-    id: z.string().min(1, 'Memory ID cannot be empty'),
-    hard: z.boolean().default(false)
-});
-const PinSchema = z.object({
-    id: z.string().min(1, 'Memory ID cannot be empty')
-});
-const UnpinSchema = z.object({
-    id: z.string().min(1, 'Memory ID cannot be empty')
-});
-// 망각 정책 관련 스키마
-const CleanupMemorySchema = z.object({
-    dry_run: z.boolean().default(false).optional()
-});
-const ForgettingStatsSchema = z.object({});
-// 성능 모니터링 관련 스키마
-const PerformanceStatsSchema = z.object({});
-const DatabaseOptimizeSchema = z.object({
-    analyze: z.boolean().default(false).optional(),
-    create_indexes: z.boolean().default(false).optional()
-});
-// Tool 핸들러들 (개선된 구현)
-async function handleRemember(params) {
-    const { content, type, tags, importance, source, privacy_scope } = params;
-    // UUID 생성 (임시로 간단한 ID 사용)
-    const id = `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    // 데이터베이스 연결 확인
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    try {
-        // 개선된 트랜잭션 재시도 로직 사용
-        const result = await DatabaseUtils.runTransaction(db, async () => {
-            await DatabaseUtils.run(db, `
-        INSERT INTO memory_item (id, type, content, importance, privacy_scope, tags, source, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-      `, [id, type, content, importance, privacy_scope,
-                tags ? JSON.stringify(tags) : null, source]);
-            return { id, type, content, importance, privacy_scope, tags, source };
-        });
-        // 임베딩 생성 (비동기, 실패해도 메모리 저장은 성공)
-        if (embeddingService.isAvailable()) {
-            embeddingService.createAndStoreEmbedding(db, id, content, type)
-                .then(result => {
-                if (result) {
-                    // 임베딩 생성 완료
-                }
-            })
-                .catch(error => {
-                console.warn(`⚠️ 임베딩 생성 실패 (${id}):`, error.message);
-            });
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        memory_id: id,
-                        message: `기억이 저장되었습니다: ${id}`,
-                        embedding_created: embeddingService.isAvailable()
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
-        if (error.code === 'SQLITE_BUSY') {
-            // 데이터베이스 락 감지, WAL 체크포인트 시도
-            try {
-                await DatabaseUtils.checkpointWAL(db);
-                // WAL 체크포인트 완료
-            }
-            catch (checkpointError) {
-                // WAL 체크포인트 실패
-            }
-        }
-        throw error;
-    }
-}
-async function handleRecall(params) {
-    const { query, filters, limit } = params;
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    if (!hybridSearchEngine) {
-        throw new Error('하이브리드 검색 엔진이 초기화되지 않았습니다');
-    }
-    // 하이브리드 검색 엔진 사용 (텍스트 + 벡터 검색)
-    const results = await hybridSearchEngine.search(db, {
-        query,
-        filters,
-        limit,
-        vectorWeight: 0.6, // 벡터 검색 60%
-        textWeight: 0.4, // 텍스트 검색 40%
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({
-                    items: results,
-                    search_type: 'hybrid',
-                    vector_search_available: hybridSearchEngine.isEmbeddingAvailable()
-                })
-            }
-        ]
-    };
-}
-async function handleForget(params) {
-    const { id, hard } = params;
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    try {
-        // 개선된 트랜잭션 재시도 로직 사용
-        const result = await DatabaseUtils.runTransaction(db, async () => {
-            if (hard) {
-                // 하드 삭제
-                const deleteResult = await DatabaseUtils.run(db, 'DELETE FROM memory_item WHERE id = ?', [id]);
-                if (deleteResult.changes === 0) {
-                    throw new Error(`Memory with ID ${id} not found`);
-                }
-                return { type: 'hard', changes: deleteResult.changes };
-            }
-            else {
-                // 소프트 삭제 (pinned 해제 후 TTL에 의해 삭제)
-                const updateResult = await DatabaseUtils.run(db, 'UPDATE memory_item SET pinned = FALSE WHERE id = ?', [id]);
-                if (updateResult.changes === 0) {
-                    throw new Error(`Memory with ID ${id} not found`);
-                }
-                return { type: 'soft', changes: updateResult.changes };
-            }
-        });
-        // 임베딩도 삭제 (하드 삭제인 경우)
-        if (hard && embeddingService.isAvailable()) {
-            try {
-                await embeddingService.deleteEmbedding(db, id);
-            }
-            catch (embeddingError) {
-                console.warn(`⚠️ 임베딩 삭제 실패 (${id}):`, embeddingError);
-            }
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        memory_id: id,
-                        message: hard ? `기억이 완전히 삭제되었습니다: ${id}` : `기억이 삭제 대상으로 표시되었습니다: ${id}`
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
-        if (error.code === 'SQLITE_BUSY') {
-            // 데이터베이스 락 감지, WAL 체크포인트 시도
-            try {
-                await DatabaseUtils.checkpointWAL(db);
-                // WAL 체크포인트 완료
-            }
-            catch (checkpointError) {
-                // WAL 체크포인트 실패
-            }
-        }
-        throw error;
-    }
-}
-async function handlePin(params) {
-    const { id } = params;
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    try {
-        // 개선된 트랜잭션 재시도 로직 사용
-        await DatabaseUtils.runTransaction(db, async () => {
-            const result = await DatabaseUtils.run(db, 'UPDATE memory_item SET pinned = TRUE WHERE id = ?', [id]);
-            if (result.changes === 0) {
-                throw new Error(`Memory with ID ${id} not found`);
-            }
-            return result;
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        memory_id: id,
-                        message: `기억이 고정되었습니다: ${id}`
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
-        if (error.code === 'SQLITE_BUSY') {
-            // 데이터베이스 락 감지, WAL 체크포인트 시도
-            try {
-                await DatabaseUtils.checkpointWAL(db);
-                // WAL 체크포인트 완료
-            }
-            catch (checkpointError) {
-                // WAL 체크포인트 실패
-            }
-        }
-        throw error;
-    }
-}
-async function handleUnpin(params) {
-    const { id } = params;
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    try {
-        // 개선된 트랜잭션 재시도 로직 사용
-        await DatabaseUtils.runTransaction(db, async () => {
-            const result = await DatabaseUtils.run(db, 'UPDATE memory_item SET pinned = FALSE WHERE id = ?', [id]);
-            if (result.changes === 0) {
-                throw new Error(`Memory with ID ${id} not found`);
-            }
-            return result;
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        memory_id: id,
-                        message: `기억 고정이 해제되었습니다: ${id}`
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
-        if (error.code === 'SQLITE_BUSY') {
-            // 데이터베이스 락 감지, WAL 체크포인트 시도
-            try {
-                await DatabaseUtils.checkpointWAL(db);
-                // WAL 체크포인트 완료
-            }
-            catch (checkpointError) {
-                // WAL 체크포인트 실패
-            }
-        }
-        throw error;
-    }
-}
-// 망각 정책 핸들러들
-async function handleCleanupMemory(params) {
-    const { dry_run } = params;
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    if (!forgettingPolicyService) {
-        throw new Error('망각 정책 서비스가 초기화되지 않았습니다');
-    }
-    try {
-        if (dry_run) {
-            // 드라이런 모드: 실제 삭제 없이 분석만 수행
-            const stats = await forgettingPolicyService.generateForgettingStats(db);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            mode: 'dry_run',
-                            stats: {
-                                totalMemories: stats.totalMemories,
-                                forgetCandidates: stats.forgetCandidates,
-                                reviewCandidates: stats.reviewCandidates,
-                                averageForgetScore: stats.averageForgetScore,
-                                memoryDistribution: stats.memoryDistribution
-                            },
-                            message: '망각 후보 분석 완료 (실제 삭제 없음)'
-                        })
-                    }
-                ]
-            };
-        }
-        else {
-            // 실제 정리 실행
-            const result = await forgettingPolicyService.executeMemoryCleanup(db);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            mode: 'execution',
-                            result: {
-                                softDeleted: result.softDeleted,
-                                hardDeleted: result.hardDeleted,
-                                reviewed: result.reviewed,
-                                totalProcessed: result.totalProcessed,
-                                summary: result.summary
-                            },
-                            message: `메모리 정리 완료: 소프트 삭제 ${result.summary.actualSoftDeletes}개, 하드 삭제 ${result.summary.actualHardDeletes}개, 리뷰 ${result.summary.actualReviews}개`
-                        })
-                    }
-                ]
-            };
-        }
-    }
-    catch (error) {
-        throw new Error(`메모리 정리 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-async function handleForgettingStats(params) {
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    if (!forgettingPolicyService) {
-        throw new Error('망각 정책 서비스가 초기화되지 않았습니다');
-    }
-    try {
-        const stats = await forgettingPolicyService.generateForgettingStats(db);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        stats: {
-                            totalMemories: stats.totalMemories,
-                            forgetCandidates: stats.forgetCandidates,
-                            reviewCandidates: stats.reviewCandidates,
-                            averageForgetScore: stats.averageForgetScore,
-                            memoryDistribution: stats.memoryDistribution
-                        },
-                        message: '망각 통계 조회 완료'
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        throw new Error(`망각 통계 조회 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-// 성능 모니터링 핸들러들
-async function handlePerformanceStats(params) {
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    if (!performanceMonitor) {
-        throw new Error('성능 모니터가 초기화되지 않았습니다');
-    }
-    try {
-        const metrics = await performanceMonitor.collectMetrics();
-        const report = await performanceMonitor.generateReport();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        metrics: {
-                            database: metrics.database,
-                            search: metrics.search,
-                            memory: metrics.memory,
-                            system: metrics.system
-                        },
-                        report: report,
-                        message: '성능 통계 조회 완료'
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        throw new Error(`성능 통계 조회 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-async function handleDatabaseOptimize(params) {
-    const { analyze, create_indexes } = params;
-    if (!db) {
-        throw new Error('데이터베이스가 초기화되지 않았습니다');
-    }
-    if (!databaseOptimizer) {
-        throw new Error('데이터베이스 최적화기가 초기화되지 않았습니다');
-    }
-    try {
-        const results = {
-            message: '데이터베이스 최적화 완료',
-            operations: []
-        };
-        if (analyze) {
-            await databaseOptimizer.analyzeDatabase();
-            results.operations.push('데이터베이스 분석 완료');
-        }
-        if (create_indexes) {
-            const recommendations = await databaseOptimizer.generateIndexRecommendations();
-            const highPriorityRecs = recommendations.filter(r => r.priority === 'high');
-            for (const rec of highPriorityRecs) {
-                const indexName = `idx_${rec.table}_${rec.columns.join('_')}`;
-                await databaseOptimizer.createIndex(indexName, rec.table, rec.columns);
-                results.operations.push(`인덱스 생성: ${indexName}`);
-            }
-        }
-        const report = await databaseOptimizer.generateOptimizationReport();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        ...results,
-                        report: report
-                    })
-                }
-            ]
-        };
-    }
-    catch (error) {
-        throw new Error(`데이터베이스 최적화 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-// 데이터베이스 상태 모니터링
-async function monitorDatabaseStatus() {
-    if (!db)
-        return;
-    try {
-        const status = await DatabaseUtils.getDatabaseStatus(db);
-        log('📊 데이터베이스 상태:', {
-            journalMode: status.journalMode,
-            walAutoCheckpoint: status.walAutoCheckpoint,
-            busyTimeout: status.busyTimeout,
-            isLocked: status.isLocked ? '🔒 잠김' : '🔓 정상'
-        });
-        // 락이 감지되면 WAL 체크포인트 실행
-        if (status.isLocked) {
-            log('⚠️ 데이터베이스 락 감지, WAL 체크포인트 실행...');
-            await DatabaseUtils.checkpointWAL(db);
-        }
-    }
-    catch (error) {
-        // 데이터베이스 상태 모니터링 실패
-    }
-}
-// MCP 모드 감지 (stdio를 통해 실행되는지 확인)
-const isMCPMode = process.stdin.isTTY === false && process.stdout.isTTY === false;
-// MCP 모드에서는 로그를 stderr로 출력
-const log = isMCPMode ? console.error : console.log;
-// MCP 서버 초기화
-async function initializeServer() {
-    try {
-        process.stderr.write('🚀 MCP 서버 초기화 시작...\n');
-        // 설정 검증
-        validateConfig();
-        process.stderr.write('✅ 설정 검증 완료\n');
-        // 데이터베이스 초기화
-        db = await initializeDatabase();
-        process.stderr.write('✅ 데이터베이스 초기화 완료\n');
-        // 데이터베이스 상태 모니터링
-        await monitorDatabaseStatus();
-        process.stderr.write('✅ 데이터베이스 상태 모니터링 완료\n');
-        // 검색 엔진 초기화
-        searchEngine = new SearchEngine();
-        hybridSearchEngine = new HybridSearchEngine();
-        embeddingService = new MemoryEmbeddingService();
-        forgettingPolicyService = new ForgettingPolicyService();
-        performanceMonitor = new PerformanceMonitor(db);
-        searchCache = new SearchCacheService(1000, 300000); // 5분 TTL
-        databaseOptimizer = new DatabaseOptimizer(db);
-        process.stderr.write('✅ 검색 엔진 초기화 완료\n');
-        // MCP 서버 생성
-        server = new Server({
-            name: mementoConfig.serverName,
-            version: mementoConfig.serverVersion,
-        }, {
-            capabilities: {
-                tools: {},
-                resources: {},
-                prompts: {}
-            }
-        });
-        process.stderr.write('✅ MCP 서버 생성 완료\n');
-        // Tools 등록
-        server.setRequestHandler(ListToolsRequestSchema, async () => {
-            process.stderr.write('📋 도구 목록 요청 처리\n');
-            return {
-                tools: [
-                    {
-                        name: 'remember',
-                        description: '새로운 기억을 저장합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                content: { type: 'string', description: '저장할 내용' },
-                                type: {
-                                    type: 'string',
-                                    enum: ['working', 'episodic', 'semantic', 'procedural'],
-                                    description: '기억 타입',
-                                    default: 'episodic'
-                                },
-                                tags: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: '태그 목록'
-                                },
-                                importance: {
-                                    type: 'number',
-                                    minimum: 0,
-                                    maximum: 1,
-                                    description: '중요도 (0-1)',
-                                    default: 0.5
-                                },
-                                source: { type: 'string', description: '출처' },
-                                privacy_scope: {
-                                    type: 'string',
-                                    enum: ['private', 'team', 'public'],
-                                    description: '프라이버시 범위',
-                                    default: 'private'
-                                }
-                            },
-                            required: ['content']
-                        }
-                    },
-                    {
-                        name: 'recall',
-                        description: '관련 기억을 검색합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                query: { type: 'string', description: '검색 쿼리' },
-                                filters: {
-                                    type: 'object',
-                                    properties: {
-                                        type: {
-                                            type: 'array',
-                                            items: { type: 'string', enum: ['working', 'episodic', 'semantic', 'procedural'] }
-                                        },
-                                        tags: { type: 'array', items: { type: 'string' } },
-                                        privacy_scope: {
-                                            type: 'array',
-                                            items: { type: 'string', enum: ['private', 'team', 'public'] }
-                                        },
-                                        time_from: { type: 'string' },
-                                        time_to: { type: 'string' },
-                                        pinned: { type: 'boolean' }
-                                    }
-                                },
-                                limit: { type: 'number', minimum: 1, maximum: 50, default: 10 }
-                            },
-                            required: ['query']
-                        }
-                    },
-                    {
-                        name: 'forget',
-                        description: '기억을 삭제합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'string', description: '삭제할 기억의 ID' },
-                                hard: { type: 'boolean', description: '완전 삭제 여부', default: false }
-                            },
-                            required: ['id']
-                        }
-                    },
-                    {
-                        name: 'pin',
-                        description: '기억을 고정합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'string', description: '고정할 기억의 ID' }
-                            },
-                            required: ['id']
-                        }
-                    },
-                    {
-                        name: 'unpin',
-                        description: '기억 고정을 해제합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'string', description: '고정 해제할 기억의 ID' }
-                            },
-                            required: ['id']
-                        }
-                    },
-                    {
-                        name: 'cleanup_memory',
-                        description: '망각 정책에 따라 메모리를 정리합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                dry_run: {
-                                    type: 'boolean',
-                                    description: '드라이런 모드 (실제 삭제 없이 분석만)',
-                                    default: false
-                                }
-                            }
-                        }
-                    },
-                    {
-                        name: 'forgetting_stats',
-                        description: '망각 통계를 조회합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {}
-                        }
-                    },
-                    {
-                        name: 'performance_stats',
-                        description: '성능 통계를 조회합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {}
-                        }
-                    },
-                    {
-                        name: 'database_optimize',
-                        description: '데이터베이스 최적화를 수행합니다',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                analyze: {
-                                    type: 'boolean',
-                                    description: '데이터베이스 분석 실행',
-                                    default: false
-                                },
-                                create_indexes: {
-                                    type: 'boolean',
-                                    description: '추천 인덱스 생성',
-                                    default: false
-                                }
-                            }
-                        }
-                    }
-                ]
-            };
-        });
-        // Tool 실행 핸들러
-        server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            process.stderr.write(`🔧 도구 실행 요청: ${name}\n`);
-            try {
-                switch (name) {
-                    case 'remember':
-                        return await handleRemember(RememberSchema.parse(args));
-                    case 'recall':
-                        return await handleRecall(RecallSchema.parse(args));
-                    case 'forget':
-                        return await handleForget(ForgetSchema.parse(args));
-                    case 'pin':
-                        return await handlePin(PinSchema.parse(args));
-                    case 'unpin':
-                        return await handleUnpin(UnpinSchema.parse(args));
-                    case 'cleanup_memory':
-                        return await handleCleanupMemory(CleanupMemorySchema.parse(args));
-                    case 'forgetting_stats':
-                        return await handleForgettingStats(ForgettingStatsSchema.parse(args));
-                    case 'performance_stats':
-                        return await handlePerformanceStats(PerformanceStatsSchema.parse(args));
-                    case 'database_optimize':
-                        return await handleDatabaseOptimize(DatabaseOptimizeSchema.parse(args));
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                if (error instanceof z.ZodError) {
-                    throw new Error(`Invalid parameters: ${error.errors.map(e => e.message).join(', ')}`);
-                }
-                throw error;
-            }
-        });
-        process.stderr.write('✅ MCP 서버 초기화 완료\n');
-        process.stderr.write('🚀 Memento MCP Server가 시작되었습니다!\n');
-    }
-    catch (error) {
-        process.stderr.write(`❌ 서버 초기화 실패: ${error}\n`);
-        process.exit(1);
-    }
-}
-// 서버 시작
-async function startServer() {
-    try {
-        await initializeServer();
-        process.stderr.write('✅ 서버 초기화 완료\n');
-        // Stdio 전송 계층 사용
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        process.stderr.write('✅ MCP 전송 계층 연결 완료\n');
-        // MCP 클라이언트 연결 대기 중
-        process.stderr.write('🔗 MCP 클라이언트 연결 대기 중...\n');
-        // 서버가 종료될 때까지 대기
-        return new Promise((resolve) => {
-            process.on('SIGINT', () => {
-                process.stderr.write('👋 서버 종료 신호 수신\n');
-                cleanup().then(() => {
-                    process.exit(0);
-                });
-            });
-            process.on('SIGTERM', () => {
-                process.stderr.write('👋 서버 종료 신호 수신\n');
-                cleanup().then(() => {
-                    process.exit(0);
-                });
-            });
-        });
-    }
-    catch (error) {
-        process.stderr.write(`❌ 서버 시작 실패: ${error}\n`);
-        process.exit(1);
-    }
-}
-// 정리 함수
-let isCleaningUp = false;
-async function cleanup() {
-    if (isCleaningUp) {
-        return; // 이미 정리 중이면 중복 실행 방지
-    }
-    isCleaningUp = true;
-    if (db) {
-        closeDatabase(db);
-        db = null; // 참조 제거
-    }
-    // Memento MCP Server 종료
-}
-// 프로세스 종료 시 정리
-process.on('SIGINT', cleanup);
-process.on('SIGTERM', cleanup);
-process.on('uncaughtException', (error) => {
-    // 예상치 못한 오류
-    cleanup();
-    process.exit(1);
-});
-// 서버 시작
-if (process.argv[1] && process.argv[1].endsWith('index.js')) {
-    startServer().catch(error => {
-        process.exit(1);
-    });
-}
-//# sourceMappingURL=index-backup.js.map