@ninebone/mcp 0.1.26

package/bak/mcp-server.js

@@ -0,0 +1,498 @@
+import express from "express";
+import cors from "cors";
+import path from "path";
+import fs from "fs";
+import { WebSocketServer } from "ws";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CustomWsTransport } from "../utils/CustomWsTransport.js";
+
+import DatabaseManager from '../database/core/DatabaseManager.js';
+import { AIProcessor } from '../ai/AIProcessor.js';
+import { AIService } from '../ai/AIService.js';
+import { SourceService } from '../services/SourceService.js';
+import { generateSourceBrainTool } from './tools/generateSourceBrainTool.js';
+import { systemBrainTool } from './mcp/tools/systemBrain.js';
+
+export async function bootstrap() {
+    if (!process.env.DB_TYPE) {
+        throw new Error(".env 파일의 DB_TYPE을 읽을 수 없습니다.");
+    }
+
+    const db = new DatabaseManager({
+        type: process.env.DB_TYPE,
+        host: process.env.DB_HOST,
+        port: Number(process.env.DB_PORT),
+        user: process.env.DB_USER,
+        password: process.env.DB_PASS,
+        database: process.env.DB_NAME,
+    });
+
+    const ai = new AIProcessor(process.env.GEMINI_API_KEY, process.env.GEMINI_MODEL);
+    const aiService = new AIService(db, ai);
+    const sourceService = new SourceService(aiService);
+
+
+    const initPrompt = (ai) => {
+        const promptPath = path.join(process.cwd(), 'prompts');
+
+        // 하위 폴더를 재귀적으로 탐색하되, 파일명만 사용하는 내부 함수
+        const scanAndRegister = (dir) => {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+
+            items.forEach((item) => {
+                const fullPath = path.join(dir, item.name);
+
+                if (item.isDirectory()) {
+                    // 폴더면 안으로 더 들어감 (이름은 전달하지 않음)
+                    scanAndRegister(fullPath);
+                } else if (item.isFile() && path.extname(item.name).toLowerCase() === '.md') {
+                    // 파일이면 확장자를 뺀 순수 파일명만 추출
+                    const chainName = path.parse(item.name).name;
+                    const prompt = fs.readFileSync(fullPath, 'utf-8');
+
+                    if (chainName.includes('.') && !chainName.includes('.' + db.type)) {
+                        return;
+                    }
+
+                    //ai.registerChain(chainName, prompt);
+                    //const parentDirName = path.basename(dir);
+
+                    ai.registerChain(chainName, prompt, 'json');
+
+                    /**
+                     if (parentDirName === 'source') {
+                     // 상위 폴더가 'source'라면 MyBatis, Service 등 순수 소스 코드 추출용이므로 'text'로 등록
+                     ai.registerChain(chainName, prompt, 'text');
+                     console.log(`  > [Source Chain Loaded (TEXT)]: ${chainName}`);
+                     } else {
+                     // 그 외의 일반 관제탑 분석용 프롬프트는 기존대로 'json'으로 등록
+                     ai.registerChain(chainName, prompt, 'json');
+                     console.log(`  > [Standard Chain Loaded (JSON)]: ${chainName}`);
+                     }
+                     //console.log(`  > [Chain Loaded]: ${chainName}`); */
+                }
+            });
+        };
+
+        try {
+            if (fs.existsSync(promptPath)) {
+                scanAndRegister(promptPath);
+                console.log("✅ 모든 AI 프롬프트 체인이 로드되었습니다.");
+            }
+        } catch (err) {
+            console.error("❌ 프롬프트 로드 실패:", err.message);
+            process.exit(1);
+        }
+    };
+
+    // AI 체인 등록
+    initPrompt(ai);
+
+    const server = new McpServer(
+        {
+            name: "nine-mcp",
+            version: "1.0.0"
+        },
+        {
+            capabilities: {
+                tools: {},
+                logging: {} // 이 스펙이 켜져 있으면, 클라이언트의 setLevel 요청을 받아 로그 파이프를 열어줍니다.
+            }
+        }
+    );
+
+    /**
+     * [Wrapper] 모든 도구 실행 시 결과를 MCP 규격 객체({ content: [...] })로 감싸주는 헬퍼 함수
+     */
+    const safeExecute = async (fn) => {
+        try {
+            const result = await fn();
+
+            // 최종 리턴값을 문자열로 안전하게 변환 (객체나 배열이면 stringify)
+            const textResult = typeof result === 'string'
+                ? result
+                : JSON.stringify(result, null, 2);
+
+            // 💡 [핵심] MCP 표준 응답 객체 규격에 맞춰 감싸서 반환합니다.
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: textResult
+                    }
+                ]
+            };
+        } catch (error) {
+            console.error("Tool Error:", error);
+
+            // 에러가 났을 때도 MCP 규격에 맞춰 반환하되, isError 플래그 지정 가능
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: false, error: error.message })
+                    }
+                ],
+                isError: true
+            };
+        }
+    };
+
+    // bootstrap.js 또는 tool 등록 루프 내부
+    server.tool(
+        "system-brain",
+        "의도 분석 및 자동 실행 관제",
+        {
+            chat_history: z.string(),
+            user_input: z.string(),
+            current_path: z.string(),
+            routes: z.any(), // 메뉴 지도는 클라이언트가 관리하는 경우 전달 받음
+        },
+        async (params, context) => {
+            return await safeExecute(async () => {
+
+                const schemaSummary = await db.getTableSchemaSummary();
+                //const { selected_tables } = await this.ai.filterTables(question, schemaSummary);
+
+                console.log(schemaSummary);
+
+                const enrichedParams = {
+                    ...params,
+                    schema_summary: schemaSummary,
+                    tools: nineTools.map(t => ({
+                        name: t.name,
+                        description: t.description,
+                        schema: t.schema
+                    }))
+                };
+
+                // 1. 관제탑(system-brain)에게 먼저 물어봄
+                const brainResult = await ai.runChain("system-brain", enrichedParams);
+                const decision = typeof brainResult === 'string' ? JSON.parse(brainResult) : brainResult;
+
+                console.log(decision);
+                // 💡 전송 함수를 실행하기 전에, 서버 객체가 이 세션을 진짜 열어둔 게 맞는지 눈으로 확인
+
+                // 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 };
+                        }
+                    }
+
+                    // 💡 [핵심] 하위 툴이 정성껏 작성한 진짜 분석 이유(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;
+                }
+            });
+        }
+    );
+
+    server.tool(
+        "generate-source-brain",
+        "의도 분석 및 자동 실행 관제",
+        {
+            user_input: z.string(),
+            //asis_source: z.string(),
+            routes: z.any(), // 메뉴 지도는 클라이언트가 관리하는 경우 전달 받음
+        },
+        async (params, context) => {
+            return await safeExecute(async () => {
+
+                const schemaSummary = await db.getTableSchemaSummary();
+                //const { selected_tables } = await this.ai.filterTables(question, schemaSummary);
+
+                console.log(schemaSummary);
+
+                const enrichedParams = {
+                    ...params,
+                    schema_summary: schemaSummary
+                };
+
+                // 3. 초경량화된 source-generator-brain 체인 구동
+                const rawToolResult = await ai.runChain("generate-source-brain", enrichedParams);
+
+                let processedResult = rawToolResult;
+                if (typeof rawToolResult === 'string') {
+                    try {
+                        processedResult = JSON.parse(rawToolResult);
+                    } catch (e) {
+                        processedResult = { message: rawToolResult, data: null };
+                    }
+                }
+
+                console.log("=== [3] AI 원시 응답 수신 ===");
+                console.log(processedResult);
+
+                // 4. JSON 파싱 및 결과 구조 검증 테스트
+                //try {
+                    const decision = processedResult;
+
+                    console.log("=== [4] JSON 파싱 성공 및 구조 분석 ===");
+                    console.log(`▶ Intent 확인: ${decision}`);
+
+                    if (decision.intent === "EXECUTE_BATCH") {
+
+                        await context.sendNotification({
+                            method: "notifications/logging/message",
+                            params: {
+                                level: "info",
+                                logger: "generate-source-brain",
+                                message: decision.message,
+                            }
+                        });
+
+                        const batchList = decision.action?.batchList || [];
+                        console.log(`▶ 매핑 완료된 메뉴 개수: ${batchList.length}개`);
+                       // console.table(batchList); // 테이블 형태로 콘솔에 예쁘게 출력
+
+                        const schema = await db.getTableSchema();
+                        console.log(schema);
+
+                        const resultType = "com.ninelab.ai.util.CamelCaseMap";
+
+
+                        let i = 0;
+
+                        for (let batch of batchList) {
+                            const filteredSchema = schema.filter(table => batch.tableIds.includes(table.tableName));
+
+                            console.log(batch);
+                            const formattedPath = (batch?.path || "")
+                                .replaceAll("/", ".")    // 슬래시를 점으로 변경
+                                .replaceAll("-", "_");   // ★ 하이픈(-)을 언더바(_)로 강제 치환하여 자바/MyBatis 문법 에러 방지
+
+                            const namespace = "ninelab" + (formattedPath.startsWith(".") ? formattedPath : "." + formattedPath);
+
+                            const toolParams = {
+                                ...params,
+                                db_type: db.type,
+                                asis_source: "",
+                                menu_description: batch.description,
+                                "schema_detail": filteredSchema,
+                                "result_type": resultType,
+                                "namespace": namespace
+                            };
+
+                            console.log(toolParams);
+
+                            const rawToolResult = await ai.runChain("generate-source-mapper." + db.type, toolParams);
+                            console.log(rawToolResult.full_source);
+
+                            await context.sendNotification({
+                                method: "notifications/logging/message",
+                                params: {
+                                    level: "info",
+                                    logger: "generate-source-brain",
+
+                                    // 1. 💬 화면 로그 컴포넌트에 깔끔하게 찍힐 텍스트
+                                    message: `▶ [${batch.description}] 소스 일괄 생성 완료 (${rawToolResult.file_name})`,
+
+                                    // 2. 📦 프론트엔드 에디터(TO-BE)나 탭 매니저가 가로채서 처리할 실제 소스 데이터
+                                    data: {
+                                        status: "PROGRESS",
+                                        menu: batch.description,
+                                        path: batch.path,
+                                        mode: rawToolResult.mode,
+                                        file_name: rawToolResult.file_name,
+                                        source: rawToolResult.full_source
+                                    }
+                                }
+                            });
+
+                            if (i++ > 1) break;
+                        }
+                        /**
+                        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 };
+                            }
+                        }
+                         */
+
+                        // 💡 [핵심] 하위 툴이 정성껏 작성한 진짜 분석 이유(message)와 결과(data)를 그대로 살려서 반환합니다!
+                        return {
+                            success: true,
+                            intent: "NONE",
+                            message: decision.message
+                        };
+                    } else {
+                        console.log(`⚠ 매핑 실패 또는 일반 대화 상태입니다. Message: ${brainJson.message}`);
+                        return {
+                            success: false,
+                            intent: "NONE",
+                            message: decision.message
+                        };
+                    }
+
+               // } catch (parseError) {
+               //     console.error("❌ AI가 올바른 JSON 포맷을 반환하지 않았습니다. 프롬프트 Output Protocol을 점검하세요.");
+               //     return {
+               //         success: false,
+               //         error: "JSON_PARSE_ERROR",
+               //         raw: parseError
+               //     };
+               // }
+            });
+        }
+    );
+
+
+
+
+    const nineTools = [
+        {
+            name: "generate-menu",
+            description: [
+                "기존 라우트(Route) 설정과 DB 스키마를 분석하여 미구현 소스 목록을 도출합니다.",
+                "또한, 사용자의 자연어 지시(메뉴나 라우터 생성/수정/삭제)를 반영하여",
+                "메뉴 트리 구조 및 라우터 설정을 재설계(Refactoring)하고 최종 통합 Route 리스트(JSON)를 새로 작성합니다."
+            ].join(" "),
+            schema: { user_input: z.string(), routes: z.any(), schema_summary: z.any() }
+        },
+        {
+            name: "generate-query",
+            description: "자연어 기반 SQL 생성 및 분석",
+            schema: { user_input: z.string(), routes: 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." + db.type,
+            description: "테이블 정보를 바탕으로 소스 코드를 생성합니다.",
+            schema: { user_input: z.string(), routes: z.any() }
+        }
+    ];
+
+    // ai.getChain(name) 같은 메서드가 있다는 가정하에
+    nineTools.forEach(tool => {
+        server.tool(
+            tool.name,
+            tool.description,
+            tool.schema,
+            async (params) => {
+                return await safeExecute(async () => {
+                    // tool.name 변수를 그대로 사용하므로 하드코딩이 사라집니다!
+                    console.log(`🚀 [Tool Execution]: ${tool.name}`, params);
+
+                    const result = await ai.runChain(tool.name, params);
+
+                    return typeof result === 'string' ? result : JSON.stringify(result);
+                });
+            }
+        );
+    });
+
+
+    // 6. DB 연결 및 서버 기동
+    try {
+        await db.connect();
+        console.log("데이터베이스 연결 성공");
+    } catch (error) {
+        console.error("서버 기동 실패:", error.message);
+        process.exit(1);
+    }
+
+    // 서버 기동
+    const app = express();
+    app.use(cors());
+    app.use(express.json());
+
+    const PORT = Number(process.env.SERVER_PORT) || 4001;
+
+    return new Promise((resolve, reject) => {
+        try {
+            const httpServer = app.listen(PORT, () => {
+                console.log(`🚀 Nine MCP Engine ON: ws://localhost:${PORT}`);
+            });
+
+            const wss = new WebSocketServer({ server: httpServer });
+
+            wss.on("connection", async (ws) => {
+                console.log("🔌 새로운 클라이언트 연결됨");
+                //const transport = new CustomWsTransport(ws);
+                try {
+                    //global.activeWs = ws;
+                    global.rawSocket = ws; // 👈 MCP 규격 안 거치는 생 소켓 창고
+
+                    const transport = new CustomWsTransport(ws);
+
+                    await server.connect(transport);
+                    console.log("✅ MCP 프로토콜 핸드셰이크 완료");
+                } catch (connErr) {
+                    console.error("❌ MCP 연결 실패:", connErr);
+                }
+            });
+
+            resolve(httpServer);
+        } catch (err) {
+            reject(err);
+        }
+    });
+}
+
+

package/bak/nomenu-navigator.md

@@ -0,0 +1,16 @@
+# Role
+너는 사용자의 의도를 분석하여 가장 적절한 시스템 경로(Path)를 찾아주는 내비게이션 전문가야.
+
+# Task
+제공된 [Route 정보]를 바탕으로 사용자의 질문에 가장 부합하는 경로를 선택해줘.
+
+# Constraints
+1. 반드시 결과는 JSON 형식으로만 응답해.
+2. 선택한 경로가 리스트에 없다면 path를 null로 리턴해.
+3. 'reason' 필드에는 왜 이 경로를 선택했는지 짧게 설명해줘.
+
+# Route 정보
+{route_context}
+
+# User Question
+{question}

package/bak/system-brain.md

@@ -0,0 +1,62 @@
+# Role: nine-mu Strategic Orchestrator
+당신은 시스템의 관제탑입니다. 사용자의 요청을 분석하여 적절한 **내부 툴 실행(EXECUTE_TOOL)**, 부족한 데이터에 대한 **데이터 요청(DATA_REQUEST)**, 또는 일반 답변(**NONE**)을 결정합니다.
+
+# Context
+- Maps: {routes}
+- Tools: {tools}
+- Path: {current_path}
+- Data: {schema_summary}
+
+# Chat History (이전 대화 기록)
+{chat_history}
+
+# Execution
+사용자의 실시간 요청: "{user_input}"
+
+# Data Vocabulary (required_args 표준)
+- **SOURCE**, **DDL**, **QUERY_RESULT**, **API_SPEC**
+
+# Strategic Reasoning Logic
+1. **툴 매칭 우선**: 사용자의 입력이 제공된 `Tools` 중 특정 툴의 목적/설명과 명확히 부합하는 경우에만 해당 툴의 실행을 검토하십시오. 매칭되는 툴이 없다면 즉시 `intent`를 `"NONE"`으로 결정하십시오.
+2. **파라미터 검증**: 1번에서 매칭된 툴이 실행되기 위해 필요한 **필수 파라미터 데이터**가 현재 `Context`에 누락되어 있다면, 절대 실행하지 말고 `intent`를 `"DATA_REQUEST"`로 설정하십시오.
+3. **메시지 생성 규칙 (중요)**: `message`는 예시 문장을 그대로 베끼지 말고, **현재 사용자의 질문과 상황(Path, Data 상태)에 맞춰 매번 동적으로 자연스럽게 작성**하십시오.
+    - `DATA_REQUEST`인 경우: 필요한 데이터(예: DDL, SOURCE 등)가 무엇인지 명확히 짚어주며 요청하십시오.
+    - `NONE`인 경우: 사용자의 친근한 대화에 위트 있고 자연스럽게 응답하십시오.
+
+# Output Protocol (JSON Only)
+상황에 맞는 최적의 JSON 구조 하나만 선택하여 응답하십시오. 다른 텍스트는 절대 포함하지 마십시오.
+
+### Case 1: 일반 대화 및 매칭 실패 (NONE)
+{{
+"intent": "NONE",
+"current_path": "{current_path}",
+"target_path": "",
+"action": null,
+"message": "[동적 생성: 사용자의 컨텍스트와 입력에 맞춘 자연스러운 답변 및 인사말]"
+}}
+
+### Case 2: 즉시 실행 (EXECUTE_TOOL)
+{{
+"intent": "EXECUTE_TOOL",
+"current_path": "{current_path}",
+"target_path": "[동적 생성: 대상 경로]",
+"action": {{
+"selected_tool": "[동적 생성: 선택된 툴 이름]",
+"params": {{ "[필수 인자명]": "[현재 Context의 실제 데이터]" }},
+"required_args": []
+}},
+"message": "[동적 생성: 실행할 작업에 대한 명확한 안내 문구]"
+}}
+
+### Case 3: 데이터 부족 (DATA_REQUEST)
+{{
+"intent": "DATA_REQUEST",
+"current_path": "{current_path}",
+"target_path": "[동적 생성: 대상 경로]",
+"action": {{
+"selected_tool": "[동적 생성: 선택된 툴 이름]",
+"params": {{ "context": "[동적 생성: 현재 작업 맥락]" }},
+"required_args": ["[요구할 데이터 키워드]"]
+}},
+"message": "[동적 생성: 어떤 데이터가 왜 필요한지 설명하고 전송을 유도하는 자연스러운 문구]"
+}}

package/bak/table-filter.md

@@ -0,0 +1,21 @@
+### TABLE_FILTER_PROMPT
+당신은 SQL 전문가입니다. 사용자의 질문을 분석하여 데이터베이스에서 조회해야 할 필수 테이블들만 선정하세요.
+
+[전체 테이블 목록]
+{schema_summary}
+
+[사용자 질문]
+"{question}"
+
+[응답 규칙]
+1. 반드시 JSON 형식으로만 응답하세요.
+2. 질문을 해결하기 위해 반드시 참조해야 하는 테이블 이름만 'selected_tables' 배열에 넣으세요.
+3. 만약 질문이 데이터베이스 조회와 관련이 없거나, 제공된 테이블 정보로 답할 수 없다면 'is_executable'을 false로 설정하세요.
+4. 'reasoning' 필드에는 왜 해당 테이블들을 선택했는지 간략하게 설명하세요.
+
+[응답 포맷]
+{{
+"reasoning": "선정 이유를 여기에 작성",
+"selected_tables": ["table1", "table2"],
+"is_executable": true
+}}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ninebone/mcp",
+  "version": "0.1.26",
+  "description": "NineQuery AI Connector for Database",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "nine-mcp": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js",
+    "build": "echo '빌드가 필요한 프로젝트라면 여기에 빌드 명령 작성'",
+    "release": "npm version patch && npm run build && npm publish"
+  },
+  "dependencies": {
+    "@langchain/core": "^1.1.44",
+    "@langchain/google-genai": "^2.1.30",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@nine-lab/nine-util": "^0.9.35",
+    "cors": "^2.8.6",
+    "dotenv": "^16.4.5",
+    "express": "^4.22.1",
+    "mariadb": "^3.5.2",
+    "mysql2": "^3.9.7",
+    "oracledb": "^6.10.0",
+    "pg": "^8.11.5",
+    "ws": "^8.20.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}