@ninebone/mcp 0.1.26 → 0.1.28

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@ninebone/mcp",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "NineQuery AI Connector for Database",
   "main": "src/index.js",
   "type": "module",
   "bin": {
     "nine-mcp": "src/index.js"
   },
+  "files": [
+    "src",
+    "prompts"
+  ],
   "scripts": {
     "start": "node src/index.js",
     "dev": "node --watch src/index.js",

package/src/core/init.js

@@ -13,7 +13,7 @@ const SOURCE_PROMPT_DIR = path.resolve(__dirname, '../../prompts');
  */
 async function createEnvFile(rl) {
     const questions = [
-        { key: 'SERVER_PORT', label: '1. 커넥터 서버 포트', default: '3000' },
+        { key: 'SERVER_PORT', label: '1. 커넥터 서버 포트', default: '4001' },
         { key: 'GEMINI_API_KEY', label: '2. Gemini API Key', default: '' },
         { key: 'GEMINI_MODEL', label: '3. 사용할 모델', default: 'gemini-2.5-flash' },
         { key: 'DB_TYPE', label: '4. DB 종류 (mysql, mariadb, postgres, oracle)', default: 'mysql' },
@@ -57,30 +57,45 @@ async function createEnvFile(rl) {
  * 2. 프롬프트 파일(.md) 자동 복사 함수 (개선됨)
  */
 function createPromptFiles() {
+    // 사용자가 명령어를 실행한 현재 터미널 위치(작업 디렉토리) 아래에 prompts 폴더를 만듭니다.
     const targetDir = path.join(process.cwd(), 'prompts');
 
     if (!fs.existsSync(targetDir)) {
         fs.mkdirSync(targetDir, { recursive: true });
     }
 
+    // 디버깅을 위해 로그를 살짝 추가해두면 어디서 고장 났는지 알기 쉽습니다.
+    console.log(`\n🔍 원본 프롬프트 탐색 경로: ${SOURCE_PROMPT_DIR}`);
+    console.log(`📂 복사될 대상 경로: ${targetDir}`);
+
     try {
         if (fs.existsSync(SOURCE_PROMPT_DIR)) {
-            // 원본 폴더의 모든 파일을 읽어서 자동으로 복사합니다.
             const files = fs.readdirSync(SOURCE_PROMPT_DIR);
 
-            files.filter(f => f.endsWith('.md')).forEach((filename) => {
+            // .md 파일 필터링 및 복사
+            const mdFiles = files.filter(f => f.endsWith('.md'));
+
+            if (mdFiles.length === 0) {
+                console.log('⚠️ 원본 폴더에 마크다운(.md) 파일이 존재하지 않습니다.');
+                return;
+            }
+
+            mdFiles.forEach((filename) => {
                 const sourcePath = path.join(SOURCE_PROMPT_DIR, filename);
                 const targetPath = path.join(targetDir, filename);
 
                 const content = fs.readFileSync(sourcePath, 'utf-8');
                 fs.writeFileSync(targetPath, content.trim() + '\n', 'utf-8');
+                console.log(`   └📄 ${filename} 복사 완료`);
             });
-            console.log('프롬프트 파일(prompts/*.md) 복사가 완료되었습니다.');
+            console.log('✨ 프롬프트 파일(prompts/*.md) 배포가 성공적으로 완료되었습니다.');
         } else {
-            console.error(`원본 템플릿 경로를 찾을 수 없습니다: ${SOURCE_PROMPT_DIR}`);
+            // 여기가 실행된다면 package.json의 files 항목에 prompts 폴더가 안 담겼거나 경로 depth가 틀린 것입니다.
+            console.error(`❌ [오류] 원본 템플릿 경로를 찾을 수 없습니다.`);
+            console.error(`   현재 배포된 패키지 내부 구조를 확인하세요.`);
         }
     } catch (err) {
-        console.error(`프롬프트 생성 중 오류 발생:`, err.message);
+        console.error(`❌ 프롬프트 생성 중 오류 발생:`, err.message);
     }
 }
 

package/src/index.js

@@ -20,12 +20,12 @@ async function main() {
         if (args.includes('init')) {
             await runInit();
         } else {
-            console.log("🚀 Nine MCP Engine 시동 중...");
+            console.log("Nine MCP Engine 시동 중...");
             // bootstrap이 Promise를 반환하므로 완전히 뜰 때까지 기다림
             await bootstrap();
         }
     } catch (error) {
-        console.error("❌ 실행 중 치명적인 오류가 발생했습니다:");
+        console.error("실행 중 치명적인 오류가 발생했습니다:");
         // ⭐️ 에러의 전체 스택과 상세 정보를 출력
         console.error(error);
         if (error.stack) {

package/bak/generate-query.md

@@ -1,28 +0,0 @@
-### SQL_GENERATE_PROMPT
-당신은 SQL 생성기입니다. 제공된 테이블 정보를 바탕으로 사용자의 질문에 답하는 최적의 SQL 쿼리를 작성하세요.
-
-[선택된 테이블 정보]
-{detailed_schema}
-
-[사용자 질문]
-"{question}"
-
-[데이터베이스 타입]
-{db_type}
-
-[기본 응답 규칙]
-1. 반드시 JSON 형식으로만 응답하세요.
-2. SQL은 {db_type} 문법에 완벽하게 맞아야 하며, 즉시 실행 가능해야 합니다.
-3. 쿼리문 안에 마크다운 코드 블록(```sql)을 포함하지 마세요.
-
-[고객사 전용 비즈니스 로직 및 보안 규칙]
-- 사용자가 특정 단어(예: 지명, 상호명, 기술명)를 언급하며 조회를 요청할 경우,
-  고정값 비교(=) 대신 반드시 'LIKE %검색어%' 패턴을 사용하세요.
--
-(여기에 "특정 테이블 조회 금지"나 "기본 정렬 기준" 등 커스텀 규칙을 작성하세요.)
-
-[응답 포맷]
-{{
-"sql": "SELECT ... FROM ... WHERE ...",
-"explanation": "이 쿼리는 어떤 데이터를 어떻게 조회하는지에 대한 설명입니다."
-}}

package/bak/generator-source-mapper.md

@@ -1,123 +0,0 @@
-너는 Spring 기반 백엔드에서 MyBatis SQL Mapper XML을 작성하는 AI입니다.
-
-지금부터 사용자로부터 받은 **기능 설명**과 **테이블 스키마 정보**를 바탕으로, 아래 조건을 **모두 만족**하는 **MyBatis SQL Mapper XML 파일(.xml)**을 작성해주세요.
-
----
-
-**[사용자 요청 기능 설명]**
-
-
-**[테이블 스키마 정보 (JSON)]**
-{schema_detail}
-
----
-
-**[XML 작성 필수 조건]**
-
-1.  **XML 기본 구조:**
-    * `<?xml version="1.0" encoding="UTF-8"?>` 및 `<!DOCTYPE mapper ...>` 선언을 **반드시 포함**해야 합니다.
-    * 전체 XML 코드는 `<mapper namespace="{namespace}" >` 태그로 감싸야 합니다.
-    * `namespace` 값은 `{namespace}` 플레이스홀더에 전달된 값으로 정확하게 채워야 합니다.
-    * **인터페이스 파일은 가정하지 않으며, XML 단독으로 동작하도록 합니다.**
-
-2.  **필수 쿼리 구성:**
-    * **`selectList`**: 목록 조회 (필수: `ORDER BY` 절 포함)
-    * **`selectOne`**: 단일 건 조회 (주요 컬럼을 WHERE 조건에 포함)
-    * **`insert`**: 데이터 삽입
-    * **`update`**: 데이터 업데이트 (주요 컬럼을 WHERE 조건에 포함)
-    * **`delete`**: 데이터 삭제 (주요 컬럼을 WHERE 조건에 포함)
-
-3.  **SQL 작성 규칙:**
-    * SQL은 제공된 **테이블 스키마(컬럼명, 데이터 타입)**를 기반으로 작성되어야 합니다.
-    * **자주 사용될 것으로 예상되는 컬럼** (예: ID, 이름, 상태 등)은 `selectOne`, `update`, `delete` 쿼리의 `WHERE` 조건에 포함해야 합니다.
-    * `result_type`은 **반드시 `{result_type}`으로 처리**합니다.
-    * `selectList` 쿼리에는 동적 WHERE 조건 처리를 위해 **반드시 아래 구문을 주입**해야 합니다:
-        ```xml
-        <where>
-            <if test="_whereClause != null"> AND ${{_whereClause}} </if>
-        </where>
-        ```
-    * `selectList` 쿼리에는 **반드시 `ORDER BY` 절을 명시**하여 정렬 기준을 제공합니다.
-
-4.  **출력 형식:**
-    * 결과는 **오직 완성된 XML 코드만 텍스트로 출력**해야 합니다. (설명 텍스트나 주석 없이)
-    * **마크다운 코드 블록(```xml`)은 절대 사용하지 마세요.**
-
----
-
-**[출력 예시]** (AI는 이 형식에 맞춰 XML 코드만 출력해야 합니다.)
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.example.mapper.BoardMapper">
-
-    <select id="selectList" resultType="`{result_type}`">
-        SELECT
-            BOARD_ID,
-            TITLE,
-            CONTENT,
-            REG_DATE
-        FROM
-            TB_BOARD
-        <where>
-            <if test="_whereClause != null"> AND ${{_whereClause}} </if>
-        </where>
-        <where>
-            <if test="borderId != null"> BOARD_ID = ${{borderId}} </if>
-        </where>
-        <where>
-            <if test="title != null"> TITLE = ${{title}} </if>
-        </where>
-        <where>
-            <if test="content != null"> CONTENT = ${{content}} </if>
-        </where>
-        <where>
-            <if test="regDate != null"> REG_DATE = ${{regDate}} </if>
-        </where>
-        ORDER BY
-            BOARD_ID DESC
-    </select>
-
-    <select id="selectOne" resultType="java.util.Map">
-        SELECT
-            BOARD_ID,
-            TITLE,
-            CONTENT,
-            REG_DATE
-        FROM
-            TB_BOARD
-        WHERE
-            BOARD_ID = #{{boardId}}
-    </select>
-
-    <insert id="insert" parameterType="java.util.Map">
-        INSERT INTO TB_BOARD (
-            BOARD_ID,
-            TITLE,
-            CONTENT,
-            REG_DATE
-        ) VALUES (
-            #{{boardId}},
-            #{{title}},
-            #{{content}},
-            NOW()
-        )
-    </insert>
-
-    <update id="update" parameterType="java.util.Map">
-        UPDATE TB_BOARD
-        SET
-            TITLE = #{{title}},
-            CONTENT = #{{content}}
-        WHERE
-            BOARD_ID = #{{boardId}}
-    </update>
-
-    <delete id="delete" parameterType="java.util.Map">
-        DELETE FROM TB_BOARD
-        WHERE
-            BOARD_ID = #{{boardId}}
-    </delete>
-
-</mapper>

package/bak/mcp-server.js

@@ -1,498 +0,0 @@
-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

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

package/bak/system-brain.md

@@ -1,62 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-### 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
-}}