@ninebone/mcp 0.1.26

package/src/mcp/tools/modifySourceBrainTool.js

@@ -0,0 +1,283 @@
+import { z } from "zod";
+
+/**
+ * 💡 [초정밀 문맥 매칭] 공백, 들여쓰기, 따옴표 격차를 완전히 초월한 최종 진화형 머지 엔진
+ */
+const applyPureDiff = (asisSource, sourceChanges) => {
+    if (!asisSource) return "";
+    if (!sourceChanges || sourceChanges.length === 0) return asisSource;
+
+    let finalSource = asisSource.replace(/\r/g, "");
+
+    for (const change of sourceChanges) {
+        let searchText = change.search_block || change.search_string || "";
+        let replaceText = change.replace_block || change.replace_string || "";
+
+        if (!searchText) continue;
+
+        // 🎯 1. [마크업 청소]: 라인 번호 흔적 지우기
+        searchText = searchText.split("\n").map(line => line.replace(/^\[LN\d+\]\s*/, "")).join("\n");
+        replaceText = replaceText.split("\n").map(line => line.replace(/^\[LN\d+\]\s*/, "")).join("\n");
+
+        // 🎯 2. [공백/따옴표 정규화 헬퍼]: 모든 공백과 따옴표를 압축하여 순수 '알맹이'만 비교
+        const normalizeLine = (line) => {
+            return (line || "").replace(/['"]/g, '').replace(/\s+/g, '').trim();
+        };
+
+        // 검색 대상 블록을 라인별 알맹이 배열로 분리
+        const searchLinesNormalized = searchText.split("\n")
+            .map(l => normalizeLine(l))
+            .filter(Boolean);
+
+        if (searchLinesNormalized.length === 0) continue;
+
+        // 원본 소스코드 라인 배열
+        const sourceLines = finalSource.split("\n");
+        let startIdx = -1;
+        let matchedLineCount = searchLinesNormalized.length;
+
+        // 🎯 3. [슬라이딩 윈도우 정밀 탐색]: 원본 소스를 돌며 알맹이 순서가 완벽히 일치하는 구간 포착
+        for (let i = 0; i < sourceLines.length; i++) {
+            let matchCount = 0;
+            let sourceOffset = 0;
+
+            for (let j = 0; j < searchLinesNormalized.length; j++) {
+                // 원본의 빈 줄은 건너뛰며 비교 유연성 확보
+                while (sourceLines[i + sourceOffset] !== undefined && normalizeLine(sourceLines[i + sourceOffset]) === "") {
+                    sourceOffset++;
+                }
+
+                if (sourceLines[i + sourceOffset] !== undefined &&
+                    normalizeLine(sourceLines[i + sourceOffset]) === searchLinesNormalized[j]) {
+                    matchCount++;
+                    sourceOffset++;
+                } else {
+                    break;
+                }
+            }
+
+            if (matchCount === searchLinesNormalized.length) {
+                startIdx = i;
+                matchedLineCount = sourceOffset; // 실제 원본에서 먹어치울 줄 수 (공백 포함)
+                break;
+            }
+        }
+
+        // 🎯 4. [치환 실행]: 매칭 구간을 찾았다면 해당 영역을 깔끔하게 스왑
+        if (startIdx !== -1) {
+            console.log(`🎯 [초정밀 문맥 매칭 성공] 원본 ${startIdx + 1}행부터 ${matchedLineCount}개 행 치환 완료`);
+            const replaceLines = replaceText ? replaceText.split("\n") : [];
+            sourceLines.splice(startIdx, matchedLineCount, ...replaceLines);
+            finalSource = sourceLines.join("\n");
+        } else {
+            console.warn("[매칭 최종 실패] 알맹이 비교 분석으로도 원본에서 대상을 찾지 못했습니다.", searchLinesNormalized);
+        }
+    }
+
+    return finalSource;
+};
+
+/**
+ * 💡 [확장자 기반 소스 추출 및 경로 반환 헬퍼]
+ */
+const extractFileByExtension = (fileArray, allowedExtensions) => {
+    if (!Array.isArray(fileArray) || fileArray.length === 0) return { contents: "", full_path: "" };
+
+    const matchedFile = fileArray.find(file => {
+        const fullPath = (file?.full_path || "").toLowerCase();
+        return allowedExtensions.some(ext => fullPath.endsWith(ext));
+    });
+
+    return matchedFile
+        ? { contents: matchedFile.contents || "", full_path: matchedFile.full_path || "" }
+        : { contents: fileArray[0]?.contents || "", full_path: fileArray[0]?.full_path || "" };
+};
+
+
+export const modifySourceBrainTool = (db, ai) => ({
+    name: "modify-source-brain",
+    description: "사용자의 구체적인 수정 요청을 분석하여, 기존 소스코드를 순수 텍스트 매칭 기반으로 정밀 갱신하는 도구입니다.",
+    schema: {
+        user_input: z.string(),
+        base_package: z.string(),
+        current_path: z.string(),
+        current_source: z.any(),
+    },
+    handler: async (params, context) => {
+        const schemaSummary = await db.getTableSchemaSummary();
+        const enrichedParams = { ...params, schema_summary: schemaSummary };
+
+        const rawToolResult = await ai.runChain("modify-source-brain", enrichedParams);
+        let decision = typeof rawToolResult === 'string' ? JSON.parse(rawToolResult) : rawToolResult;
+
+        if (decision.intent === "EXECUTE_MODIFY") {
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: { level: "info", logger: "modify-source-brain", message: decision.message }
+            });
+
+            const modifyList = decision.action?.modifyList || [];
+            const schema = await db.getTableSchema();
+            const basePackage = params.base_package;
+            const resultType = "com.ninelab.ai.util.CamelCaseMap";
+            const asisSources = params.current_source || {};
+
+            for (let target of modifyList) {
+                const filteredSchema = schema.filter(table => target.tableIds.includes(table.tableName));
+                const formattedPath = (target?.path || params.current_path || "").replaceAll("/", ".").replaceAll("-", "_");
+                const cleanPath = formattedPath.startsWith(".") ? formattedPath.substring(1) : formattedPath;
+
+                const pathParts = (target?.path || params.current_path || "").split("/");
+                const rawClassName = pathParts[pathParts.length - 1] || "Sample";
+                const baseClassName = rawClassName.split("-").map(word => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+
+                const mybatisFile = extractFileByExtension(asisSources.mybatis, [".xml"]);
+                const serviceFile = extractFileByExtension(asisSources.service, [".java"]);
+                const controllerFile = extractFileByExtension(asisSources.controller, [".java"]);
+                const javascriptFile = extractFileByExtension(asisSources.javascript, [".js", ".jsx", ".ts", ".tsx"]);
+
+                const updatedOutputs = {
+                    mapperSource: mybatisFile.contents,
+                    serviceSource: serviceFile.contents,
+                    controllerSource: controllerFile.contents,
+                    uiSource: javascriptFile.contents
+                };
+
+                const targetChains = [
+                    {
+                        id: "generate-source-mapper",
+                        layerKey: "MyBatis",
+                        label: "MyBatis 맵퍼 수정",
+                        fullPath: mybatisFile.full_path,
+                        getOriginal: () => updatedOutputs.mapperSource,
+                        buildParams: () => ({
+                            ...params,
+                            menu_description: target.description,
+                            schema_detail: filteredSchema,
+                            result_type: resultType,
+                            namespace: `${basePackage}.${cleanPath}.mapper`,
+                            asis_source: updatedOutputs.mapperSource,
+                            modification_task: target.modificationTask
+                        }),
+                        saveOutput: (source) => { updatedOutputs.mapperSource = source; }
+                    },
+                    {
+                        id: "generate-source-service",
+                        layerKey: "Service",
+                        label: "비즈니스 서비스 수정",
+                        fullPath: serviceFile.full_path,
+                        getOriginal: () => updatedOutputs.serviceSource,
+                        buildParams: () => ({
+                            ...params,
+                            menu_description: target.description,
+                            service_package: `${basePackage}.${cleanPath}.service`,
+                            mapper_package: `${basePackage}.${cleanPath}.mapper`,
+                            asis_source: updatedOutputs.serviceSource,
+                            modification_task: target.modificationTask,
+                            mapper_source: updatedOutputs.mapperSource
+                        }),
+                        saveOutput: (source) => { updatedOutputs.serviceSource = source; }
+                    },
+                    {
+                        id: "generate-source-controller",
+                        layerKey: "Controller",
+                        label: "컨트롤러 API 수정",
+                        fullPath: controllerFile.full_path,
+                        getOriginal: () => updatedOutputs.controllerSource,
+                        buildParams: () => ({
+                            ...params,
+                            menu_description: target.description,
+                            api_base_url: target.path || params.current_path,
+                            controller_package: `${basePackage}.${cleanPath}.controller`,
+                            service_package: `${basePackage}.${cleanPath}.service`,
+                            asis_source: updatedOutputs.controllerSource,
+                            modification_task: target.modificationTask,
+                            service_source: updatedOutputs.serviceSource
+                        }),
+                        saveOutput: (source) => { updatedOutputs.controllerSource = source; }
+                    },
+                    {
+                        id: "generate-source-ui-react",
+                        layerKey: "JavaScript",
+                        label: "리액트 UI 컴포넌트 수정",
+                        fullPath: javascriptFile.full_path,
+                        getOriginal: () => updatedOutputs.uiSource,
+                        buildParams: () => ({
+                            ...params,
+                            menu_description: target.description,
+                            api_base_url: target.path || params.current_path,
+                            menu_name: target.description,
+                            base_class: baseClassName,
+                            schema_detail: filteredSchema,
+                            asis_source: updatedOutputs.uiSource,
+                            modification_task: target.modificationTask,
+                            mapper_source: updatedOutputs.mapperSource,
+                            controller_source: updatedOutputs.controllerSource
+                        }),
+                        saveOutput: (source) => { updatedOutputs.uiSource = source; }
+                    }
+                ];
+
+                for (const chain of targetChains) {
+                    if (!target.targetLayers.includes(chain.layerKey)) {
+                        continue;
+                    }
+
+                    // 💡 [핵심] AI 가 고치기 전의 순수 오리지널 소스 스냅샷을 미리 캡처
+                    const originalSource = chain.getOriginal();
+
+                    const specificToolParams = chain.buildParams();
+                    console.log(`🛠️ [${target.componentName || "Component"}] ${chain.label} 수정 중...`);
+
+                    const rawSourceResult = await ai.runChain(chain.id, specificToolParams);
+                    let resultObj = typeof rawSourceResult === 'string' ? JSON.parse(rawSourceResult) : rawSourceResult;
+
+                    let finalSource = "";
+                    if (resultObj.mode === "CREATE" || resultObj.full_source) {
+                        finalSource = resultObj.full_source;
+                    } else if (resultObj.mode === "UPDATE" || resultObj.source_changes) {
+                        finalSource = applyPureDiff(originalSource, resultObj.source_changes);
+                    } else {
+                        finalSource = originalSource;
+                    }
+
+                    // 연쇄 반응용 메모리 버퍼 최신화
+                    chain.saveOutput(finalSource);
+
+                    // 💡 [클라이언트 가시성 개선] 오리지널 소스와 최종 수정 소스를 함께 스트리밍
+                    await context.sendNotification({
+                        method: "notifications/logging/message",
+                        params: {
+                            level: "info",
+                            logger: "modify-source-brain",
+                            message: `${chain.label} 수정 완료`,
+                            data: {
+                                layer: chain.layerKey,
+                                full_path: chain.fullPath,
+                                asis_source: originalSource, // 👈 클라이언트에서 Diff 팝업용으로 매핑할 AS-IS 원본 소스
+                                source: finalSource          // 👈 클라이언트에서 덮어씌우거나 우측 창에 띄울 TO-BE 결과 소스
+                            }
+                        }
+                    });
+                }
+            }
+
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: {
+                    level: "info",
+                    logger: "modify-source-brain-completed", // 👈 명확하게 구분된 컴플리트 전용 로거
+                    message: "요청하신 작업이 완료되었습니다. 최종 Diff 명세를 로드합니다.",
+                    data: {
+                        status: "SUCCESS"
+                    }
+                }
+            });
+
+            return { success: true, intent: "EXECUTE_MODIFY", message: null };
+        }
+        else {
+            return { success: false, intent: "NONE", message: decision.message };
+        }
+    }
+});

package/src/mcp/tools/staticTools.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const getStaticToolsConfig = () => [
+    {
+        name: "generate-menu",
+        description: "사용자의 요청을 분석하여 시스템 내에 존재하지 않는 '신규 메뉴 라우트 트리'를 도출하고 설계 정보(메뉴명, URL Path, 연관 테이블 매핑 정보)를 화면에 갱신 및 재배치하는 라우트 구조 설계 도구입니다. 실제 소스코드 파일(MyBatis, Service, Controller, React UI)을 생성 및 작성하는 행위는 절대로 수행하지 않습니다.",
+        schema: { user_input: z.string(), routes: z.any(), schema_summary: z.any() }
+    },
+    {
+        name: "generate-source",
+        description: "테이블 정보를 바탕으로 소스 코드를 생성합니다.",
+        schema: { user_input: z.string(), routes: z.any() }
+    },
+    {
+        name: "generate-source-controller",
+        description: "테이블 정보를 바탕으로 소스 코드를 생성합니다.",
+        schema: { user_input: z.string(), routes: z.any() }
+    },
+    {
+        name: "generate-source-service",
+        description: "테이블 정보를 바탕으로 소스 코드를 생성합니다.",
+        schema: { user_input: z.string(), routes: z.any() }
+    },
+    {
+        name: "generate-source-mapper", // 벤더 종속 명칭 제거 완료
+        description: "테이블 정보를 바탕으로 마이바티스 맵퍼 XML 코드를 생성합니다.",
+        schema: { user_input: z.string(), routes: z.any() }
+    }
+];

package/src/mcp/tools/systemBrain.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+
+export const systemBrainTool = (db, ai, nineTools = [], generateSourceBrain = null, modifySourceBrain = null) => ({
+    name: "system-brain",
+    description: "의도 분석 및 자동 실행 관제",
+    schema: {
+        base_package: z.string(),
+        chat_history: z.string(),
+        user_input: z.string(),
+        current_path: z.string(),
+        current_source: z.any(),
+        routes: z.any(), // 메뉴 지도는 클라이언트가 관리하는 경우 전달 받음
+        unmapped_routes: z.any(),
+    },
+    handler: async (params, context) => {
+        const schemaSummary = await db.getTableSchemaSummary();
+        //const { selected_tables } = await this.ai.filterTables(question, schemaSummary);
+
+        const allToolsConfig = [
+            ...nineTools.map(t => ({ name: t.name, description: t.description, schema: t.schema })),
+        ];
+
+        // 💡 주입받은 generateSourceBrain 본체가 존재한다면 해당 명세도 툴 컨텍스트에 포함시킵니다.
+        if (generateSourceBrain) {
+            allToolsConfig.push({
+                name: generateSourceBrain.name,
+                description: generateSourceBrain.description,
+                schema: generateSourceBrain.schema
+            });
+        }
+
+        if (modifySourceBrain) {
+            allToolsConfig.push({
+                name: modifySourceBrain.name,
+                description: modifySourceBrain.description,
+                schema: modifySourceBrain.schema
+            });
+        }
+
+        const enrichedParams = {
+            ...params,
+            schema_summary: schemaSummary,
+            tools: allToolsConfig
+        };
+
+        // 1. 관제탑(system-brain)에게 먼저 물어봄
+        const brainResult = await ai.runChain("system-brain", enrichedParams);
+        const decision = typeof brainResult === 'string' ? JSON.parse(brainResult) : brainResult;
+
+        console.log(decision);
+        // 💡 전송 함수를 실행하기 전에, 서버 객체가 이 세션을 진짜 열어둔 게 맞는지 눈으로 확인
+
+        if (decision.action?.selected_tool === "generate-source-brain") {
+            if (!generateSourceBrain) throw new Error("generate-source-brain 인스턴스가 존재하지 않습니다.");
+
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: {
+                    level: "info",
+                    logger: "system-brain",
+                    message: decision.message,//`소스 생성 의도가 확정되어 [generate-source-brain] 관제로 프로세스를 위임합니다.`
+                }
+            });
+
+            // 💡 규격에 맞춰 파라미터 빌드 후 툴 본체 핸들러 직접 구동
+            const generateSourceBrainParams = {
+                user_input: params.user_input,
+                base_package: params.base_package,
+                unmapped_routes: (params.unmapped_routes || []).filter(route => route["is-nine"] !== true),
+                current_source: "",
+            };
+
+            // 🎯 핸들러를 직접 호출하므로 source-brain 내부의 await db.getTableSchemaSummary()가
+            // 완벽하게 정상 기동되어 LangChain 템플릿 주입 에러가 발생하지 않습니다.
+            return await generateSourceBrain.handler(generateSourceBrainParams, context);
+        } else if (decision.action?.selected_tool === "modify-source-brain") {
+            if (!modifySourceBrain) throw new Error("modify-source-brain 인스턴스가 존재하지 않습니다.");
+
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: {
+                    level: "info",
+                    logger: "system-brain",
+                    message: decision.message,//`🧠 소스 수정 의도가 확정되어 [modify-source-brain] 관제로 프로세스를 위임합니다.`
+                }
+            });
+
+            // 💡 규격에 맞춰 파라미터 빌드 후 툴 본체 핸들러 직접 구동
+            const modifySourceBrainParams = {
+                user_input: params.user_input,
+                current_path: params.current_path,
+                base_package: params.base_package,
+                //unmapped_routes: params.unmapped_routes || [],
+                current_source: params.current_source,
+            };
+
+            // 🎯 핸들러를 직접 호출하므로 source-brain 내부의 await db.getTableSchemaSummary()가
+            // 완벽하게 정상 기동되어 LangChain 템플릿 주입 에러가 발생하지 않습니다.
+            return await modifySourceBrain.handler(modifySourceBrainParams, context);
+        }
+
+        // 2. [내부 루프] 정보가 충분하고 다른 툴을 실행해야 하는 경우
+        if (decision.intent === "EXECUTE_TOOL" && decision.action?.selected_tool) {
+
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: {
+                    level: "info",
+                    logger: "system-brain",
+                    message: decision.message,
+                }
+            });
+
+            console.log(`🔄 [Auto-Chain]: ${decision.action.selected_tool} 실행`);
+
+            // 🛠️ 안전한 하위 툴 체이닝 파라미터 전달 방식
+            const toolParams = {
+                ...enrichedParams,       // 원본 컨텍스트(routes, schema_summary 등)를 기본으로 깔고
+                ...decision.action.params // AI가 가공하거나 수정한 파라미터로 덮어쓰기
+            };
+
+            const rawToolResult = await ai.runChain(decision.action.selected_tool, toolParams);
+
+            console.log(rawToolResult);
+
+            let processedResult = rawToolResult;
+            if (typeof rawToolResult === 'string') {
+                try {
+                    processedResult = JSON.parse(rawToolResult);
+                } catch (e) {
+                    processedResult = { message: rawToolResult, data: null };
+                }
+            }
+
+            //console.log(decision.action.selected_tool);
+
+            switch (decision.action.selected_tool) {
+                case "generate-menu":
+                    await context.sendNotification({
+                        method: "notifications/logging/message",
+                        params: {
+                            level: "info",
+                            logger: "generate-menu-completed",
+                            message: processedResult.message,
+                            data: processedResult.data,
+                        }
+                    });
+                    break;
+            }
+
+            switch (decision.action.selected_tool) {
+                case "generate-menu":
+                    return {
+                        intent: "EXECUTE_TOOL",
+                        selected_tool: decision.action.selected_tool,
+                        action: {
+                            selected_tool: decision.action.selected_tool,
+                            params: decision.action.params
+                        },
+                        message: null, // 👈 AI 아키텍트가 작성한 진짜 분석 근거 멘트가 들어감
+                        data: processedResult.data         // 👈 신규 통합 라우트 리스트 데이터가 들어감
+                    };
+            }
+
+
+            // 💡 [핵심] 하위 툴이 정성껏 작성한 진짜 분석 이유(message)와 결과(data)를 그대로 살려서 반환합니다!
+            return {
+                intent: "EXECUTE_TOOL",
+                selected_tool: decision.action.selected_tool,
+                action: {
+                    selected_tool: decision.action.selected_tool,
+                    params: decision.action.params
+                },
+                message: processedResult.message, // 👈 AI 아키텍트가 작성한 진짜 분석 근거 멘트가 들어감
+                data: processedResult.data         // 👈 신규 통합 라우트 리스트 데이터가 들어감
+            };
+        }
+        else {
+            return decision;
+        }
+    }
+});

package/src/mcp/utils/mcp-utils.js

@@ -0,0 +1,30 @@
+export const safeExecute = async (fn) => {
+    try {
+        const result = await fn();
+
+        // [원복] 어설픈 분기나 파싱 없이, 툴이 뱉은 결과 객체를 그대로 직렬화하여 전달합니다.
+        const textResult = typeof result === 'string'
+            ? result
+            : JSON.stringify(result, null, 2);
+
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: textResult
+                }
+            ]
+        };
+    } catch (error) {
+        console.error("Tool Error:", error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: error.message })
+                }
+            ],
+            isError: true
+        };
+    }
+};

package/src/mcp-handler.js

@@ -0,0 +1,131 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+    ListToolsRequestSchema,
+    CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// 기존 서비스 임포트
+// import { AIService } from './ai/AIService.js';
+// import { SourceService } from './services/SourceService.js';
+
+export async function createMCPServer(aiService, sourceService, queryService) {
+    const server = new Server({
+        name: "nine-mcp",
+        version: "0.1.25",
+    }, {
+        capabilities: { tools: {} }
+    });
+
+    // 1. 도구 목록 정의
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: "navigate_menu",
+                description: "현재 화면의 메뉴 구조를 분석하여 최적의 이동 경로를 찾습니다.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        menuName: { type: "string", description: "이동하고자 하는 메뉴의 자연어 명칭" },
+                        currentRoutes: {
+                            type: "array",
+                            items: { type: "object" },
+                            description: "현재 React 앱에 정의된 최신 메뉴 구조 배열"
+                        }
+                    },
+                    required: ["menuName", "currentRoutes"]
+                }
+            },
+            {
+                name: "ask_query",
+                description: "자연어로 데이터베이스 조회를 요청합니다.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prompt: { type: "string", description: "질의 내용" }
+                    },
+                    required: ["prompt"]
+                }
+            },
+            {
+                name: "analyze_missing",
+                description: "현재 메뉴와 DB 스키마를 비교하여 누락되거나 필요한 기능을 분석합니다.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prompt: { type: "string" },
+                        currentRoutes: { type: "array", items: { type: "object" } }
+                    },
+                    required: ["prompt", "currentRoutes"]
+                }
+            },
+            {
+                name: "generate_source",
+                description: "테이블 정보를 기반으로 선택된 레이어(MyBatis/Service/Controller/JS) 소스를 생성합니다.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        tableName: { type: "string" },
+                        // UI 체크박스 상태를 전달받을 객체 추가
+                        options: {
+                            type: "object",
+                            properties: {
+                                mybatis: { type: "boolean" },
+                                service: { type: "boolean" },
+                                controller: { type: "boolean" },
+                                javascript: { type: "boolean" }
+                            }
+                        }
+                    },
+                    required: ["tableName"]
+                }
+            }
+        ]
+    }));
+
+    // 2. 도구 실행 로직
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+
+        try {
+            switch (name) {
+                case "navigate_menu":
+                    // 서버가 아닌 클라이언트가 전달한 args.currentRoutes를 사용함
+                    const navResult = await aiService.processNavigation(
+                        args.menuName,
+                        args.currentRoutes
+                    );
+                    return {
+                        content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                targetPath: navResult.path,
+                                explanation: navResult.explanation,
+                                success: navResult.success
+                            })
+                        }]
+                    };
+
+                case "ask_query":
+                    const queryResult = await queryService.ask(args.prompt);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(queryResult) }]
+                    };
+
+                case "generate_source":
+                    // args.options를 sourceService에 함께 전달
+                    const sourceResult = await sourceService.generate(args.tableName, args.options);
+                    return { content: [{ type: "text", text: JSON.stringify(sourceResult) }] };
+
+                default:
+                    throw new Error(`지원하지 않는 도구입니다: ${name}`);
+            }
+        } catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: error.message }]
+            };
+        }
+    });
+
+    return server;
+}