memento-mcp-server 1.11.0-a1 → 1.11.1-a

package/dist/server/http-server.js

@@ -24,6 +24,14 @@ import { DatabaseUtils } from '../utils/database.js';
 import { getToolRegistry } from '../tools/index.js';
 import Database from 'better-sqlite3';
 import packageJson from '../../package.json' with { type: 'json' };
+// Phase 1.2: 라우터 import
+import { createToolsRouter } from './routes/tools.routes.js';
+import { createAdminRouter } from './routes/admin.routes.js';
+import { createApiRouter } from './routes/api.routes.js';
+import { createMcpRouter } from './routes/mcp.routes.js';
+import { broadcastAnchorMapUpdate } from './handlers/anchor-map.handler.js';
+// Phase 0: 공통 미들웨어 import
+import { createServiceInjector, createToolContextMiddleware, errorHandler } from './middleware/index.js';
 // 전역 변수
 let db = null;
 let searchEngine;
@@ -39,6 +47,9 @@ let consolidationScoreService = null;
 let writeCoalescingManager = null;
 // 부트스트랩에서 반환된 전체 서비스 객체 (ToolContext 생성 시 사용)
 let serverServices = null;
+// Phase 1.2: 라우터에서 사용할 전역 변수들
+// SSE Transport 저장소 (MCP 라우터용)
+const transports = {};
 function setTestDependencies({ database, searchEngine: search, hybridSearchEngine: hybrid, embeddingService: embedding }) {
     db = database;
     searchEngine = search ?? new SearchEngine();
@@ -68,240 +79,17 @@ app.get('/health', (req, res) => {
         timestamp: new Date().toISOString()
     });
 });
-app.get('/tools', (req, res) => {
-    try {
-        const toolRegistry = getToolRegistry();
-        const tools = toolRegistry.getAll();
-        res.json({
-            tools,
-            count: tools.length,
-            server: mementoConfig.serverName
-        });
-    }
-    catch (error) {
-        console.error('❌ 도구 목록 조회 실패:', error);
-        res.status(500).json({
-            error: 'Failed to get tools',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-/**
- * Anchor Map 업데이트를 WebSocket 구독자에게 브로드캐스트
- */
-async function broadcastAnchorMapUpdate(agentId) {
-    if (!anchorMapSubscribers.has(agentId) || anchorMapSubscribers.get(agentId).size === 0) {
-        return; // 구독자가 없으면 브로드캐스트하지 않음
-    }
-    try {
-        // Anchor Map 데이터 생성 (API 엔드포인트와 동일한 로직)
-        if (!db || !serverServices || !serverServices.anchorManager) {
-            return;
-        }
-        const anchorManager = serverServices.anchorManager;
-        const anchors = await anchorManager.getAnchor(agentId);
-        if (!anchors || (Array.isArray(anchors) && anchors.length === 0)) {
-            // 앵커가 없어도 빈 데이터로 브로드캐스트
-            const updateData = {
-                agent_id: agentId,
-                anchors: [],
-                nodes: [],
-                links: [],
-                timestamp: new Date().toISOString()
-            };
-            const subscribers = anchorMapSubscribers.get(agentId);
-            for (const ws of subscribers) {
-                if (ws.readyState === 1) { // WebSocket.OPEN
-                    ws.send(JSON.stringify({
-                        type: 'anchor_map_update',
-                        data: updateData
-                    }));
-                }
-            }
-            return;
-        }
-        const anchorList = Array.isArray(anchors) ? anchors : [anchors];
-        // 각 앵커 주변의 관련 메모리 검색 및 네트워크 데이터 구성
-        const nodes = [];
-        const links = [];
-        const processedMemoryIds = new Set();
-        // 각 앵커에 대해 처리
-        for (const anchor of anchorList) {
-            if (!anchor.memory_id)
-                continue;
-            const anchorMemory = db.prepare(`
-        SELECT id, content, type, importance, created_at
-        FROM memory_item
-        WHERE id = ?
-      `).get(anchor.memory_id);
-            if (anchorMemory) {
-                nodes.push({
-                    id: anchor.memory_id,
-                    type: 'anchor',
-                    slot: anchor.slot,
-                    content: anchorMemory.content.substring(0, 100),
-                    importance: anchorMemory.importance,
-                    created_at: anchorMemory.created_at
-                });
-                processedMemoryIds.add(anchor.memory_id);
-                try {
-                    const slotConfig = anchorManager.getSlotConfig(anchor.slot);
-                    const searchResult = await anchorManager.searchLocal(agentId, anchor.slot, undefined, slotConfig.hop_limit, { limit: 50 });
-                    for (const item of searchResult.items) {
-                        if (processedMemoryIds.has(item.id))
-                            continue;
-                        nodes.push({
-                            id: item.id,
-                            type: 'memory',
-                            content: item.content.substring(0, 100),
-                            hop_distance: item.hop_distance || 0,
-                            similarity: item.similarity,
-                            importance: item.importance,
-                            created_at: item.created_at
-                        });
-                        processedMemoryIds.add(item.id);
-                        if (item.hop_distance === 1) {
-                            links.push({
-                                source: anchor.memory_id,
-                                target: item.id,
-                                type: 'hop',
-                                hop_distance: 1,
-                                similarity: item.similarity
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`❌ 앵커 ${anchor.slot} 주변 메모리 검색 실패:`, error);
-                }
-            }
-        }
-        // memory_link 테이블 활용
-        for (const node of nodes) {
-            if (node.type === 'anchor')
-                continue;
-            const linkedMemories = db.prepare(`
-        SELECT target_memory_id, similarity, created_at
-        FROM memory_link
-        WHERE source_memory_id = ?
-        UNION
-        SELECT source_memory_id, similarity, created_at
-        FROM memory_link
-        WHERE target_memory_id = ?
-      `).all(node.id, node.id);
-            for (const link of linkedMemories) {
-                const linkedId = link.target_memory_id || link.source_memory_id;
-                if (linkedId && processedMemoryIds.has(linkedId)) {
-                    links.push({
-                        source: node.id,
-                        target: linkedId,
-                        type: 'link',
-                        similarity: link.similarity
-                    });
-                }
-            }
-        }
-        const updateData = {
-            agent_id: agentId,
-            anchors: anchorList,
-            nodes,
-            links,
-            timestamp: new Date().toISOString()
-        };
-        // 구독자에게 브로드캐스트
-        const subscribers = anchorMapSubscribers.get(agentId);
-        for (const ws of subscribers) {
-            if (ws.readyState === 1) { // WebSocket.OPEN
-                try {
-                    ws.send(JSON.stringify({
-                        type: 'anchor_map_update',
-                        data: updateData
-                    }));
-                }
-                catch (error) {
-                    console.error('❌ WebSocket 브로드캐스트 실패:', error);
-                }
-            }
-        }
-        console.log(`📡 Anchor Map 업데이트 브로드캐스트: agent_id=${agentId}, subscribers=${subscribers.size}`);
-    }
-    catch (error) {
-        console.error(`❌ Anchor Map 브로드캐스트 실패 (agent: ${agentId}):`, error);
-    }
-}
-// 도구 실행 엔드포인트
-app.post('/tools/:name', async (req, res) => {
-    const { name } = req.params;
-    const params = req.body;
-    try {
-        const toolRegistry = getToolRegistry();
-        // 부트스트랩에서 초기화된 서비스 객체를 사용하여 ToolContext 생성
-        if (!serverServices) {
-            return res.status(500).json({
-                error: 'Services not initialized',
-                message: '서비스가 초기화되지 않았습니다'
-            });
-        }
-        const context = {
-            db,
-            services: {
-                searchEngine: serverServices.searchEngine,
-                hybridSearchEngine: serverServices.hybridSearchEngine,
-                embeddingService: serverServices.embeddingService,
-                forgettingPolicyService: serverServices.forgettingPolicyService,
-                performanceMonitor: serverServices.performanceMonitor,
-                databaseOptimizer: serverServices.databaseOptimizer,
-                errorLoggingService: serverServices.errorLoggingService,
-                performanceAlertService: serverServices.performanceAlertService,
-                consolidationScoreService: serverServices.consolidationScoreService,
-                writeCoalescingManager: serverServices.writeCoalescingManager,
-                anchorManager: serverServices.anchorManager
-            }
-        };
-        // 도구 실행
-        const toolResult = await toolRegistry.execute(name, params, context);
-        // MCP 형식의 ToolResult에서 실제 데이터 추출
-        // content 배열의 첫 번째 항목의 text를 JSON 파싱
-        let actualResult = toolResult;
-        if (toolResult.content && Array.isArray(toolResult.content) && toolResult.content.length > 0) {
-            const firstContent = toolResult.content[0];
-            if (firstContent && firstContent.text) {
-                try {
-                    const textContent = firstContent.text;
-                    actualResult = JSON.parse(textContent);
-                }
-                catch (parseError) {
-                    // JSON 파싱 실패 시 원본 content 사용
-                    actualResult = toolResult;
-                }
-            }
-        }
-        // 앵커 관련 도구 실행 후 WebSocket 브로드캐스트
-        if (name === 'set_anchor' || name === 'clear_anchor') {
-            const agentId = params.agent_id || 'default';
-            // 비동기로 브로드캐스트 (응답 지연 방지)
-            setImmediate(() => {
-                broadcastAnchorMapUpdate(agentId).catch(error => {
-                    console.error('❌ Anchor Map 브로드캐스트 실패:', error);
-                });
-            });
-        }
-        return res.json({
-            result: actualResult,
-            tool: name,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error(`❌ Tool ${name} 실행 실패:`, error);
-        return res.status(500).json({
-            error: 'Tool execution failed',
-            tool: name,
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-// 대시보드 라우트
+// Phase 1.2: 라우터 등록
+// WebSocket 클라이언트 관리 (Anchor Map 업데이트용) - 라우터에서도 사용
+const anchorMapSubscribers = new Map(); // agent_id -> WebSocket Set
+// 라우터 등록 (서비스 초기화 후 업데이트됨)
+let toolsRouter = null;
+let adminRouter = null;
+let apiRouter = null;
+let mcpRouter = null;
+// Phase 1.2: 기존 엔드포인트는 모두 라우터로 이동됨
+// 주석 처리된 기존 코드는 제거됨 (tools.routes.ts, admin.routes.ts, api.routes.ts, mcp.routes.ts로 이동)
+// 대시보드 라우트 (정적 파일 서빙)
 app.get('/dashboard', (req, res) => {
     res.sendFile('dashboard.html', { root: 'static' }, (err) => {
         if (err) {
@@ -310,901 +98,8 @@ app.get('/dashboard', (req, res) => {
         }
     });
 });
-// Anchor Map API 엔드포인트
-app.get('/api/anchors/map', async (req, res) => {
-    const agentId = req.query.agent_id || 'default';
-    try {
-        // 데이터베이스 연결 확인
-        if (!db || !serverServices) {
-            return res.status(500).json({
-                error: 'Services not initialized',
-                message: '서비스가 초기화되지 않았습니다'
-            });
-        }
-        const anchorManager = serverServices.anchorManager;
-        if (!anchorManager) {
-            return res.status(500).json({
-                error: 'AnchorManager not available',
-                message: 'AnchorManager가 사용할 수 없습니다'
-            });
-        }
-        // 앵커 정보 조회
-        const anchors = await anchorManager.getAnchor(agentId);
-        if (!anchors || (Array.isArray(anchors) && anchors.length === 0)) {
-            return res.json({
-                agent_id: agentId,
-                anchors: [],
-                nodes: [],
-                links: [],
-                timestamp: new Date().toISOString()
-            });
-        }
-        const anchorList = Array.isArray(anchors) ? anchors : [anchors];
-        // 각 앵커 주변의 관련 메모리 검색 및 네트워크 데이터 구성
-        const nodes = [];
-        const links = [];
-        const processedMemoryIds = new Set();
-        // 각 앵커에 대해 처리
-        for (const anchor of anchorList) {
-            if (!anchor.memory_id)
-                continue;
-            // 앵커 노드 추가
-            const anchorMemory = db.prepare(`
-        SELECT id, content, type, importance, created_at
-        FROM memory_item
-        WHERE id = ?
-      `).get(anchor.memory_id);
-            if (anchorMemory) {
-                nodes.push({
-                    id: anchor.memory_id,
-                    type: 'anchor',
-                    slot: anchor.slot,
-                    content: anchorMemory.content.substring(0, 100), // 처음 100자만
-                    importance: anchorMemory.importance,
-                    created_at: anchorMemory.created_at
-                });
-                processedMemoryIds.add(anchor.memory_id);
-                // 앵커 주변 메모리 검색 (hop 거리별)
-                try {
-                    const slotConfig = anchorManager.getSlotConfig(anchor.slot);
-                    const searchResult = await anchorManager.searchLocal(agentId, anchor.slot, undefined, // query 없이 앵커 기반 recall
-                    slotConfig.hop_limit, { limit: 50 } // 충분한 수의 메모리 가져오기
-                    );
-                    // 검색 결과를 노드와 링크로 변환
-                    for (const item of searchResult.items) {
-                        if (processedMemoryIds.has(item.id))
-                            continue;
-                        nodes.push({
-                            id: item.id,
-                            type: 'memory',
-                            content: item.content.substring(0, 100),
-                            hop_distance: item.hop_distance || 0,
-                            similarity: item.similarity,
-                            importance: item.importance,
-                            created_at: item.created_at
-                        });
-                        processedMemoryIds.add(item.id);
-                        // 링크 추가 (앵커에서 메모리로)
-                        if (item.hop_distance === 1) {
-                            links.push({
-                                source: anchor.memory_id,
-                                target: item.id,
-                                type: 'hop',
-                                hop_distance: 1,
-                                similarity: item.similarity
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`❌ 앵커 ${anchor.slot} 주변 메모리 검색 실패:`, error);
-                }
-            }
-        }
-        // memory_link 테이블을 활용한 직접 연결 정보 추가
-        for (const node of nodes) {
-            if (node.type === 'anchor')
-                continue;
-            // memory_link 테이블 스키마: source_id, target_id, relation_type, created_at
-            const linkedMemories = db.prepare(`
-        SELECT target_id, relation_type, created_at
-        FROM memory_link
-        WHERE source_id = ?
-        UNION
-        SELECT source_id, relation_type, created_at
-        FROM memory_link
-        WHERE target_id = ?
-      `).all(node.id, node.id);
-            for (const link of linkedMemories) {
-                const linkedId = link.target_id || link.source_id;
-                if (linkedId && processedMemoryIds.has(linkedId)) {
-                    // 이미 노드에 있는 메모리와의 직접 연결
-                    // relation_type을 기반으로 similarity 추정 (기본값 0.7)
-                    const similarity = link.relation_type === 'derived_from' ? 0.9 :
-                        link.relation_type === 'cause_of' ? 0.8 : 0.7;
-                    links.push({
-                        source: node.id,
-                        target: linkedId,
-                        type: 'link',
-                        similarity: similarity
-                    });
-                }
-            }
-        }
-        return res.json({
-            agent_id: agentId,
-            anchors: anchorList,
-            nodes,
-            links,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error(`❌ Anchor Map 데이터 조회 실패 (agent: ${agentId}):`, error);
-        return res.status(500).json({
-            error: 'Failed to get anchor map data',
-            message: error instanceof Error ? error.message : 'Unknown error',
-            agent_id: agentId
-        });
-    }
-});
-// 이웃 기억 조회 엔드포인트
-app.get('/memories/:id/neighbors', async (req, res) => {
-    const { id } = req.params;
-    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 5;
-    const similarityThreshold = req.query.similarity_threshold
-        ? parseFloat(req.query.similarity_threshold)
-        : 0.8;
-    try {
-        // 데이터베이스 연결 확인
-        if (!db) {
-            return res.status(500).json({
-                error: 'Database not connected',
-                message: '데이터베이스가 연결되지 않았습니다'
-            });
-        }
-        // 파라미터 검증
-        if (isNaN(limit) || limit < 1 || limit > 50) {
-            return res.status(400).json({
-                error: 'Invalid limit parameter',
-                message: 'limit은 1 이상 50 이하여야 합니다'
-            });
-        }
-        if (isNaN(similarityThreshold) || similarityThreshold < 0 || similarityThreshold > 1) {
-            return res.status(400).json({
-                error: 'Invalid similarity_threshold parameter',
-                message: 'similarity_threshold는 0 이상 1 이하여야 합니다'
-            });
-        }
-        // MemoryNeighborService 인스턴스 생성
-        const vectorSearchEngine = getVectorSearchEngine();
-        const neighborService = new MemoryNeighborService(vectorSearchEngine, embeddingService);
-        // 데이터베이스 설정
-        neighborService.setDatabase(db);
-        // 이웃 기억 조회
-        const result = await neighborService.getNeighbors(id, {
-            limit,
-            similarity_threshold: similarityThreshold
-        });
-        return res.json({
-            memory_id: result.memory_id,
-            neighbors: result.neighbors,
-            total_count: result.total_count,
-            query_time: result.query_time,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        // MemoryNotFoundError 처리 (404)
-        if (error instanceof MemoryNotFoundError) {
-            return res.status(404).json({
-                error: 'Memory not found',
-                message: `메모리를 찾을 수 없습니다: ${id}`,
-                memory_id: id
-            });
-        }
-        // 기타 에러 처리 (500)
-        console.error(`❌ 이웃 기억 조회 실패 (${id}):`, error);
-        return res.status(500).json({
-            error: 'Failed to get memory neighbors',
-            message: error instanceof Error ? error.message : 'Unknown error',
-            memory_id: id
-        });
-    }
-});
-// MCP SSE 엔드포인트 - MCP SDK 호환 구현
-// Store transports by session ID
-const transports = {};
-// SSE endpoint for establishing the stream
-app.get('/mcp', async (req, res) => {
-    console.log('🔗 MCP SSE 클라이언트 연결 요청');
-    try {
-        // SSE 헤더 설정
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache, no-transform',
-            'Connection': 'keep-alive',
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Headers': 'Cache-Control, Content-Type, Authorization',
-            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-            'X-Accel-Buffering': 'no' // nginx 버퍼링 비활성화
-        });
-        // Generate session ID
-        const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        // Send the endpoint event with session ID
-        const endpointUrl = `/messages?sessionId=${sessionId}`;
-        res.write(`event: endpoint\ndata: ${endpointUrl}\n\n`);
-        // MCP 서버 준비 완료 알림 (클라이언트가 initialize를 보내야 함)
-        res.write(`data: {"type": "ready"}\n\n`);
-        // Keep-alive ping 전송
-        const keepAliveInterval = setInterval(() => {
-            if (res.writableEnded) {
-                clearInterval(keepAliveInterval);
-                return;
-            }
-            try {
-                res.write(`data: {"type": "ping"}\n\n`);
-            }
-            catch (error) {
-                clearInterval(keepAliveInterval);
-            }
-        }, 30000); // 30초마다 ping
-        // Store the transport info
-        transports[sessionId] = {
-            res: res,
-            sessionId: sessionId,
-            keepAliveInterval: keepAliveInterval
-        };
-        // 연결 종료 처리
-        req.on('close', () => {
-            console.log(`🔌 MCP SSE 클라이언트 연결 정상 종료됨 (session: ${sessionId})`);
-            clearInterval(keepAliveInterval);
-            delete transports[sessionId];
-        });
-        req.on('error', (error) => {
-            // ECONNRESET은 정상적인 연결 종료이므로 에러로 처리하지 않음
-            if (error.code === 'ECONNRESET') {
-                console.log(`🔌 MCP SSE 클라이언트 연결 정상 종료됨 (session: ${sessionId})`);
-            }
-            else {
-                console.error(`❌ MCP SSE 연결 에러 (session: ${sessionId}):`, error);
-            }
-            clearInterval(keepAliveInterval);
-            delete transports[sessionId];
-        });
-        console.log(`✅ MCP SSE 스트림 설정 완료 (session: ${sessionId})`);
-        return;
-    }
-    catch (error) {
-        console.error('❌ SSE 스트림 설정 실패:', error);
-        if (!res.headersSent) {
-            res.status(500).send('Error establishing SSE stream');
-        }
-        return;
-    }
-});
-// Messages endpoint for receiving client JSON-RPC requests
-app.post('/messages', express.json(), async (req, res) => {
-    console.log('📨 MCP 메시지 수신:', req.body.method);
-    // Extract session ID from URL query parameter
-    const sessionId = req.query.sessionId;
-    if (!sessionId) {
-        console.error('❌ No session ID provided in request URL');
-        res.status(400).send('Missing sessionId parameter');
-        return;
-    }
-    const transport = transports[sessionId];
-    if (!transport) {
-        console.error(`❌ No active transport found for session ID: ${sessionId}`);
-        res.status(404).send('Session not found');
-        return;
-    }
-    const message = req.body;
-    let result;
-    console.log(`🔍 MCP 메시지 처리 중: ${message.method}`, JSON.stringify(message, null, 2));
-    try {
-        if (message.method === 'initialize') {
-            console.log('🚀 MCP initialize 요청 처리 중...');
-            result = {
-                jsonrpc: '2.0',
-                id: message.id,
-                result: {
-                    protocolVersion: '2024-11-05',
-                    capabilities: {
-                        tools: {}
-                    },
-                    serverInfo: {
-                        name: 'memento-memory',
-                        version: '0.1.0'
-                    }
-                }
-            };
-            console.log('✅ MCP initialize 응답 생성 완료:', JSON.stringify(result, null, 2));
-        }
-        else if (message.method === 'notifications/initialized') {
-            console.log('🔔 MCP initialized 알림 수신');
-            result = {
-                jsonrpc: '2.0',
-                id: message.id,
-                result: {}
-            };
-        }
-        else if (message.method === 'tools/list') {
-            console.log('📋 MCP tools/list 요청 처리 중...');
-            try {
-                const toolRegistry = getToolRegistry();
-                const tools = toolRegistry.getAll();
-                console.log('🔍 도구 목록 사용, 길이:', tools.length);
-                result = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    result: { tools }
-                };
-                console.log('✅ MCP tools/list 응답 생성 완료, tools 개수:', tools.length);
-                console.log('🔍 응답 크기:', JSON.stringify(result).length, 'bytes');
-                // SSE 응답 즉시 전송
-                console.log('📤 SSE 응답 즉시 전송 중...');
-                if (transport && transport.res && !transport.res.writableEnded) {
-                    const sseData = `data: ${JSON.stringify(result)}\n\n`;
-                    transport.res.write(sseData);
-                    console.log('✅ SSE 응답 즉시 전송 완료, 크기:', sseData.length, 'bytes');
-                }
-                else {
-                    console.error('❌ SSE transport가 유효하지 않음');
-                }
-                // HTTP 응답 전송
-                res.json({ status: 'ok' });
-                return;
-            }
-            catch (toolsError) {
-                console.error('❌ tools/list 처리 중 오류:', toolsError);
-                const errorResult = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    error: {
-                        code: -32603,
-                        message: 'Internal error',
-                        data: toolsError instanceof Error ? toolsError.message : String(toolsError)
-                    }
-                };
-                if (transport && transport.res && !transport.res.writableEnded) {
-                    transport.res.write(`data: ${JSON.stringify(errorResult)}\n\n`);
-                }
-                res.json({ status: 'error' });
-                return;
-            }
-        }
-        else if (message.method === 'tools/call') {
-            const { name, arguments: args } = message.params;
-            const toolRegistry = getToolRegistry();
-            // 부트스트랩에서 초기화된 서비스 객체를 사용하여 ToolContext 생성
-            if (!serverServices) {
-                result = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    error: {
-                        code: -32603,
-                        message: 'Internal error',
-                        data: '서비스가 초기화되지 않았습니다'
-                    }
-                };
-            }
-            else {
-                const context = {
-                    db,
-                    services: {
-                        searchEngine: serverServices.searchEngine,
-                        hybridSearchEngine: serverServices.hybridSearchEngine,
-                        embeddingService: serverServices.embeddingService,
-                        forgettingPolicyService: serverServices.forgettingPolicyService,
-                        performanceMonitor: serverServices.performanceMonitor,
-                        databaseOptimizer: serverServices.databaseOptimizer,
-                        errorLoggingService: serverServices.errorLoggingService,
-                        performanceAlertService: serverServices.performanceAlertService,
-                        consolidationScoreService: serverServices.consolidationScoreService,
-                        writeCoalescingManager: serverServices.writeCoalescingManager,
-                        anchorManager: serverServices.anchorManager
-                    }
-                };
-                // 도구 실행
-                const toolResult = await toolRegistry.execute(name, args, context);
-                result = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    result: { content: [{ type: 'text', text: JSON.stringify(toolResult) }] }
-                };
-            }
-        }
-        else if (message.method === 'prompts/list') {
-            console.log('📋 MCP prompts/list 요청 처리 중...');
-            const prompts = [
-                {
-                    name: 'memory_injection',
-                    description: '관련 기억을 요약하여 프롬프트에 주입',
-                    arguments: [
-                        {
-                            name: 'query',
-                            description: '검색할 쿼리',
-                            required: true
-                        },
-                        {
-                            name: 'token_budget',
-                            description: '토큰 예산 (기본값: 1000)',
-                            required: false
-                        },
-                        {
-                            name: 'max_memories',
-                            description: '최대 기억 개수 (기본값: 5)',
-                            required: false
-                        }
-                    ]
-                }
-            ];
-            result = {
-                jsonrpc: '2.0',
-                id: message.id,
-                result: { prompts }
-            };
-            console.log('✅ MCP prompts/list 응답 생성 완료');
-        }
-        else if (message.method === 'prompts/get') {
-            const { name } = message.params;
-            if (name === 'memory_injection') {
-                result = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    result: {
-                        description: '관련 기억을 요약하여 프롬프트에 주입',
-                        arguments: [
-                            {
-                                name: 'query',
-                                description: '검색할 쿼리',
-                                required: true
-                            },
-                            {
-                                name: 'token_budget',
-                                description: '토큰 예산 (기본값: 1000)',
-                                required: false
-                            },
-                            {
-                                name: 'max_memories',
-                                description: '최대 기억 개수 (기본값: 5)',
-                                required: false
-                            }
-                        ]
-                    }
-                };
-            }
-            else {
-                result = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    error: {
-                        code: -32601,
-                        message: 'Prompt not found'
-                    }
-                };
-            }
-        }
-        else if (message.method === 'prompts/call') {
-            const { name, arguments: args } = message.params;
-            if (name === 'memory_injection') {
-                try {
-                    // 부트스트랩에서 초기화된 서비스 객체를 사용하여 ToolContext 생성
-                    if (!serverServices) {
-                        result = {
-                            jsonrpc: '2.0',
-                            id: message.id,
-                            error: {
-                                code: -32603,
-                                message: 'Internal error',
-                                data: '서비스가 초기화되지 않았습니다'
-                            }
-                        };
-                    }
-                    else {
-                        // MemoryInjectionPrompt 도구 사용
-                        const toolRegistry = getToolRegistry();
-                        const context = {
-                            db,
-                            services: {
-                                searchEngine: serverServices.searchEngine,
-                                hybridSearchEngine: serverServices.hybridSearchEngine,
-                                embeddingService: serverServices.embeddingService,
-                                forgettingPolicyService: serverServices.forgettingPolicyService,
-                                performanceMonitor: serverServices.performanceMonitor,
-                                databaseOptimizer: serverServices.databaseOptimizer,
-                                errorLoggingService: serverServices.errorLoggingService,
-                                performanceAlertService: serverServices.performanceAlertService,
-                                consolidationScoreService: serverServices.consolidationScoreService,
-                                writeCoalescingManager: serverServices.writeCoalescingManager
-                            }
-                        };
-                        const promptResult = await toolRegistry.execute('memory_injection', args, context);
-                        result = {
-                            jsonrpc: '2.0',
-                            id: message.id,
-                            result: promptResult
-                        };
-                    }
-                }
-                catch (error) {
-                    result = {
-                        jsonrpc: '2.0',
-                        id: message.id,
-                        error: {
-                            code: -32603,
-                            message: 'Prompt execution failed',
-                            data: error instanceof Error ? error.message : 'Unknown error'
-                        }
-                    };
-                }
-            }
-            else {
-                result = {
-                    jsonrpc: '2.0',
-                    id: message.id,
-                    error: {
-                        code: -32601,
-                        message: 'Prompt not found'
-                    }
-                };
-            }
-        }
-        else {
-            result = {
-                jsonrpc: '2.0',
-                id: message.id,
-                error: {
-                    code: -32601,
-                    message: 'Method not found'
-                }
-            };
-        }
-        // Send response via SSE
-        console.log('📤 SSE 응답 전송 중:', JSON.stringify(result).substring(0, 200) + '...');
-        try {
-            // transport 객체 유효성 확인
-            if (!transport || !transport.res || transport.res.writableEnded) {
-                console.error('❌ SSE transport가 유효하지 않음');
-                res.status(500).json({ error: 'SSE transport invalid' });
-                return;
-            }
-            // SSE 응답 전송
-            const sseData = `data: ${JSON.stringify(result)}\n\n`;
-            transport.res.write(sseData);
-            console.log('✅ SSE 응답 전송 완료, 크기:', sseData.length, 'bytes');
-        }
-        catch (sseError) {
-            console.error('❌ SSE 응답 전송 실패:', sseError);
-            // SSE 전송 실패 시에도 HTTP 응답은 정상 처리
-        }
-        // Send HTTP response
-        res.json({ status: 'ok' });
-    }
-    catch (error) {
-        console.error('❌ MCP 메시지 처리 실패:', error);
-        const errorResponse = {
-            jsonrpc: '2.0',
-            id: message?.id || null,
-            error: {
-                code: -32603,
-                message: 'Internal error',
-                data: error instanceof Error ? error.message : 'Unknown error'
-            }
-        };
-        // Send error via SSE
-        try {
-            if (transport && transport.res && !transport.res.writableEnded) {
-                const errorSseData = `data: ${JSON.stringify(errorResponse)}\n\n`;
-                transport.res.write(errorSseData);
-                console.log('✅ SSE 에러 응답 전송 완료');
-            }
-            else {
-                console.error('❌ SSE transport가 유효하지 않아 에러 응답 전송 실패');
-            }
-        }
-        catch (errorSseError) {
-            console.error('❌ SSE 에러 응답 전송 실패:', errorSseError);
-        }
-        // Send HTTP response
-        res.json({ status: 'error' });
-    }
-});
-// 관리자 API 엔드포인트들
-app.post('/admin/memory/cleanup', async (req, res) => {
-    try {
-        // 메모리 정리 로직 (기존 CleanupMemoryTool 로직)
-        if (!db) {
-            return res.status(500).json({ error: '데이터베이스가 연결되지 않았습니다' });
-        }
-        // 간단한 메모리 정리 구현
-        const result = await db.prepare(`
-      DELETE FROM memory_item 
-      WHERE pinned = FALSE 
-        AND type = 'working' 
-        AND created_at < datetime('now', '-2 days')
-    `).run();
-        return res.json({
-            message: '메모리 정리 완료',
-            deleted_count: result.changes,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 메모리 정리 실패:', error);
-        return res.status(500).json({
-            error: '메모리 정리 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.get('/admin/stats/forgetting', async (req, res) => {
-    try {
-        // 망각 통계 로직 (기존 ForgettingStatsTool 로직)
-        if (!db) {
-            return res.status(500).json({ error: '데이터베이스가 연결되지 않았습니다' });
-        }
-        const stats = await db.prepare(`
-      SELECT 
-        type,
-        COUNT(*) as total_count,
-        COUNT(CASE WHEN pinned = TRUE THEN 1 END) as pinned_count,
-        COUNT(CASE WHEN created_at < datetime('now', '-30 days') THEN 1 END) as old_count
-      FROM memory_item 
-      GROUP BY type
-    `).all();
-        return res.json({
-            message: '망각 통계 조회 완료',
-            stats,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 망각 통계 조회 실패:', error);
-        return res.status(500).json({
-            error: '망각 통계 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.get('/admin/stats/performance', async (req, res) => {
-    try {
-        // 성능 통계 로직 (기존 PerformanceStatsTool 로직)
-        if (!db) {
-            return res.status(500).json({ error: '데이터베이스가 연결되지 않았습니다' });
-        }
-        const stats = await db.prepare(`
-      SELECT 
-        COUNT(*) as total_memories,
-        COUNT(CASE WHEN type = 'working' THEN 1 END) as working_memories,
-        COUNT(CASE WHEN type = 'episodic' THEN 1 END) as episodic_memories,
-        COUNT(CASE WHEN type = 'semantic' THEN 1 END) as semantic_memories,
-        COUNT(CASE WHEN type = 'procedural' THEN 1 END) as procedural_memories,
-        COUNT(CASE WHEN pinned = TRUE THEN 1 END) as pinned_memories
-      FROM memory_item
-    `).get();
-        return res.json({
-            message: '성능 통계 조회 완료',
-            stats,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 성능 통계 조회 실패:', error);
-        return res.status(500).json({
-            error: '성능 통계 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.post('/admin/database/optimize', async (req, res) => {
-    try {
-        // 데이터베이스 최적화 로직 (기존 DatabaseOptimizeTool 로직)
-        if (!db) {
-            return res.status(500).json({ error: '데이터베이스가 연결되지 않았습니다' });
-        }
-        // VACUUM 실행
-        await db.prepare('VACUUM').run();
-        // ANALYZE 실행
-        await db.prepare('ANALYZE').run();
-        return res.json({
-            message: '데이터베이스 최적화 완료',
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 데이터베이스 최적화 실패:', error);
-        return res.status(500).json({
-            error: '데이터베이스 최적화 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.get('/admin/stats/errors', async (req, res) => {
-    try {
-        // 에러 통계 로직 (기존 errorStatsTool 로직)
-        res.json({
-            message: '에러 통계 조회 완료',
-            stats: {
-                total_errors: 0,
-                recent_errors: [],
-                error_types: {}
-            },
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 에러 통계 조회 실패:', error);
-        res.status(500).json({
-            error: '에러 통계 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.post('/admin/errors/resolve', async (req, res) => {
-    try {
-        const { errorId, resolvedBy, reason } = req.body;
-        // 에러 해결 로직 (기존 resolveErrorTool 로직)
-        res.json({
-            message: '에러 해결 완료',
-            errorId,
-            resolvedBy,
-            reason,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 에러 해결 실패:', error);
-        res.status(500).json({
-            error: '에러 해결 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.get('/admin/alerts/performance', async (req, res) => {
-    try {
-        // 성능 알림 로직 (기존 performanceAlertsTool 로직)
-        res.json({
-            message: '성능 알림 조회 완료',
-            alerts: [],
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 성능 알림 조회 실패:', error);
-        res.status(500).json({
-            error: '성능 알림 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-// 배치 스케줄러 관리 API
-app.get('/admin/batch/status', async (req, res) => {
-    try {
-        const batchScheduler = getBatchScheduler();
-        const status = batchScheduler.getStatus();
-        res.json({
-            message: '배치 스케줄러 상태 조회 완료',
-            status,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 배치 스케줄러 상태 조회 실패:', error);
-        res.status(500).json({
-            error: '배치 스케줄러 상태 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.post('/admin/batch/run', async (req, res) => {
-    try {
-        const { jobType } = req.body;
-        if (!jobType || !['cleanup', 'monitoring'].includes(jobType)) {
-            return res.status(400).json({
-                error: 'Invalid job type. Must be "cleanup" or "monitoring"'
-            });
-        }
-        const batchScheduler = getBatchScheduler();
-        const result = await batchScheduler.runJob(jobType);
-        return res.json({
-            message: `배치 작업 ${jobType} 실행 완료`,
-            result,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 배치 작업 실행 실패:', error);
-        return res.status(500).json({
-            error: '배치 작업 실행 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-// 성능 모니터링 API
-app.get('/admin/performance/metrics', async (req, res) => {
-    try {
-        const monitor = getPerformanceMonitor();
-        const metrics = await monitor.collectMetrics();
-        res.json({
-            message: '성능 지표 수집 완료',
-            metrics,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 성능 지표 수집 실패:', error);
-        res.status(500).json({
-            error: '성능 지표 수집 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.get('/admin/performance/alerts', async (req, res) => {
-    try {
-        const monitor = getPerformanceMonitor();
-        const alerts = monitor.getActiveAlerts();
-        res.json({
-            message: '성능 알림 조회 완료',
-            alerts,
-            count: alerts.length,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 성능 알림 조회 실패:', error);
-        res.status(500).json({
-            error: '성능 알림 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.get('/admin/performance/summary', async (req, res) => {
-    try {
-        const monitor = getPerformanceMonitor();
-        const summary = monitor.getPerformanceSummary();
-        res.json({
-            message: '성능 요약 조회 완료',
-            summary,
-            timestamp: new Date().toISOString()
-        });
-    }
-    catch (error) {
-        console.error('❌ 성능 요약 조회 실패:', error);
-        res.status(500).json({
-            error: '성능 요약 조회 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
-app.post('/admin/performance/alerts/:alertId/resolve', async (req, res) => {
-    try {
-        const { alertId } = req.params;
-        const monitor = getPerformanceMonitor();
-        const resolved = monitor.resolveAlert(alertId);
-        if (resolved) {
-            res.json({
-                message: '알림 해결 완료',
-                alertId,
-                timestamp: new Date().toISOString()
-            });
-        }
-        else {
-            res.status(404).json({
-                error: '알림을 찾을 수 없습니다',
-                alertId
-            });
-        }
-    }
-    catch (error) {
-        console.error('❌ 알림 해결 실패:', error);
-        res.status(500).json({
-            error: '알림 해결 실패',
-            message: error instanceof Error ? error.message : 'Unknown error'
-        });
-    }
-});
+// Phase 1.2: 기존 엔드포인트는 모두 라우터로 이동됨
+// 주석 처리된 코드는 제거됨 (tools.routes.ts, admin.routes.ts, api.routes.ts, mcp.routes.ts로 이동)
 // 서버 초기화
 async function initializeServer() {
     try {
@@ -1232,6 +127,22 @@ async function initializeServer() {
         // Vector Search Engine 초기화 (HTTP 서버 전용)
         vectorSearchEngine = getVectorSearchEngine();
         vectorSearchEngine.initialize(db);
+        // Phase 0: 공통 미들웨어 적용
+        // 서비스 주입 미들웨어 (모든 라우터에 적용)
+        app.use(createServiceInjector(serverServices, db));
+        // Phase 1.2: 라우터 초기화 및 등록
+        toolsRouter = createToolsRouter(db, serverServices, anchorMapSubscribers);
+        adminRouter = createAdminRouter(db);
+        apiRouter = createApiRouter(db, serverServices);
+        mcpRouter = createMcpRouter(db, serverServices, transports);
+        // 라우터 등록
+        // ToolContext 미들웨어는 /tools 라우터에만 적용 (도구 실행 시 필요)
+        app.use('/tools', createToolContextMiddleware, toolsRouter);
+        app.use('/admin', adminRouter);
+        app.use('/api', apiRouter);
+        app.use('/', mcpRouter); // /mcp, /messages는 루트에 등록
+        // Phase 0: 공통 에러 핸들러 미들웨어 (모든 라우터 이후에 적용)
+        app.use(errorHandler);
         console.log('✅ 서비스 초기화 완료');
         // 배치 스케줄러 시작 (이미 실행 중이면 먼저 중지)
         const batchScheduler = getBatchScheduler();
@@ -1312,8 +223,7 @@ function registerCleanupHandlers() {
 }
 // WebSocket 서버 설정
 const wss = new WebSocketServer({ server });
-// WebSocket 클라이언트 관리 (Anchor Map 업데이트용)
-const anchorMapSubscribers = new Map(); // agent_id -> WebSocket Set
+// Phase 1.2: anchorMapSubscribers는 위에서 이미 선언됨
 wss.on('connection', (ws) => {
     console.log('🔗 WebSocket 클라이언트 연결됨');
     ws.on('message', async (data) => {