@ninebone/mcp 0.1.26

package/src/database/core/DatabaseManager.js

@@ -0,0 +1,115 @@
+import PoolManager from './PoolManager.js';
+import Dialects from './Dialects.js'; // 쿼리 사전 임포트
+
+class DatabaseManager {
+    constructor(config) {
+        this.config = config;
+        this.pool = null;
+        this.type = config.type?.toLowerCase();
+        this.dialect = Dialects[this.type];
+
+        if (!this.dialect) {
+            throw new Error(`Unsupported Dialect for: ${this.type}`);
+        }
+    }
+
+    /**
+     * DatabaseFactory의 init() 역할을 수행합니다.
+     */
+    // DatabaseManager.js 내부
+    async connect() {
+        try {
+            //console.info(this.config);
+            // 이제 createPool이 async이므로 await를 붙입니다.
+            this.pool = await PoolManager.createPool(this.config);
+
+            // 연결 확인
+            await this.query(this.dialect.testQuery || 'SELECT 1');
+            console.info(`[${this.type}] Database connection successful.`);
+        } catch (error) {
+            console.error(`[${this.type}] Connection failed:`, error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * DB별 결과 포맷 차이를 여기서 해결합니다. (데이터 배열만 반환)
+     */
+    // DatabaseManager.js 수정
+    async query(sql, params = []) {
+        if (!this.pool) throw new Error("Database not connected.");
+
+        const result = await this.pool.query(sql, params);
+
+        /**
+        if (this.type === 'postgres') {
+            return result.rows;
+        } else {
+            // 만약 result[0]이 또 배열이라면(mysql2 이중 배열), 0번 인덱스를 반환
+            // 아니라면 result를 그대로 반환
+            return (Array.isArray(result) && Array.isArray(result[0]))
+                ? result[0]
+                : result;
+        } */
+        if (this.type === 'postgres' || this.type === 'postgresql') {
+            return result.rows;
+        }
+
+        // MariaDB/MySQL 대응:
+        // DDL(INSERT/UPDATE) 결과와 DQL(SELECT) 결과를 구분해야 함
+        if (Array.isArray(result)) {
+            // mysql2 대응: rows가 0번에 담겨오는 경우
+            if (Array.isArray(result[0])) return result[0];
+            return result;
+        }
+
+        return result;
+    }
+
+    /**
+     * AI 가공을 위해 스키마 데이터를 구조화합니다.
+     * 결과 예시:
+     * {
+     *   "orders": {
+     *      "description": "주문 기본 정보 테이블",
+     *      "columns": [{ "column": "id", "type": "int" }, ...]
+     *   }
+     * }
+     */
+    async getTableSchema() {
+        const rows = await this.query(this.dialect.schemaQuery);
+
+        // 1. 우선 객체 형태로 그룹화 (중복 방지 및 효율적 정리를 위해)
+        const grouped = rows.reduce((acc, row) => {
+            const { table_name, table_comment, column_name, data_type } = row;
+
+            if (!acc[table_name]) {
+                acc[table_name] = {
+                    tableName: table_name, // 배열로 변환 시 식별을 위해 추가
+                    description: table_comment || "",
+                    columns: []
+                };
+            }
+
+            acc[table_name].columns.push({
+                column: column_name,
+                type: data_type
+            });
+
+            return acc;
+        }, {});
+
+        // 2. 최종적으로 객체의 값들만 뽑아서 배열로 변환
+        return Object.values(grouped);
+    }
+
+    async getTableSchemaSummary() {
+        const schema = await this.getTableSchema();
+        return schema.map(table => ({
+            tableName: table.tableName,
+            description: table.description
+        }));
+    }
+}
+
+export default DatabaseManager;

package/src/database/core/Dialects.js

@@ -0,0 +1,66 @@
+const Dialects = {
+    // MySQL 추가 (MariaDB와 동일)
+    mysql: {
+        testQuery: 'SELECT 1',
+        schemaQuery: `
+            SELECT
+                c.TABLE_NAME as table_name,
+                t.TABLE_COMMENT as table_comment,
+                c.COLUMN_NAME as column_name,
+                c.DATA_TYPE as data_type
+            FROM information_schema.columns c
+                     INNER JOIN information_schema.tables t
+                                ON c.TABLE_NAME = t.TABLE_NAME
+                                    AND c.TABLE_SCHEMA = t.TABLE_SCHEMA
+            WHERE c.TABLE_SCHEMA = DATABASE()
+            ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION`
+    },
+    mariadb: {
+        testQuery: 'SELECT 1',
+        schemaQuery: `
+            SELECT
+                c.TABLE_NAME as table_name,
+                t.TABLE_COMMENT as table_comment,
+                c.COLUMN_NAME as column_name,
+                c.DATA_TYPE as data_type
+            FROM information_schema.columns c
+                     INNER JOIN information_schema.tables t
+                                ON c.TABLE_NAME = t.TABLE_NAME
+                                    AND c.TABLE_SCHEMA = t.TABLE_SCHEMA
+            WHERE c.TABLE_SCHEMA = DATABASE()
+            ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION`
+    },
+    postgres: {
+        testQuery: 'SELECT 1',
+        schemaQuery: `
+            SELECT
+                t.table_name,
+                (SELECT obj_description(pgc.oid, 'pg_class')
+                 FROM pg_class pgc
+                 WHERE pgc.relname = t.table_name
+                   AND pgc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = t.table_schema)
+                ) AS table_comment,
+                c.column_name,
+                c.data_type
+            FROM information_schema.tables t
+                     JOIN information_schema.columns c ON t.table_name = c.table_name AND t.table_schema = c.table_schema
+            WHERE t.table_schema = CURRENT_SCHEMA() -- 현재 스키마 자동 대응
+            ORDER BY t.table_name, c.ordinal_position`
+    },
+    oracle: {
+        testQuery: 'SELECT 1 FROM DUAL',
+        schemaQuery: `
+            SELECT 
+                t.TABLE_NAME as table_name, 
+                tc.COMMENTS as table_comment,
+                c.COLUMN_NAME as column_name, 
+                c.DATA_TYPE as data_type
+            FROM ALL_TABLES t
+            JOIN ALL_TAB_COLUMNS c ON t.TABLE_NAME = c.TABLE_NAME AND t.OWNER = c.OWNER
+            LEFT JOIN ALL_TAB_COMMENTS tc ON t.TABLE_NAME = tc.TABLE_NAME AND t.OWNER = tc.OWNER
+            WHERE t.OWNER = (SELECT USER FROM DUAL) -- 현재 접속한 스키마만 조회
+            ORDER BY t.TABLE_NAME, c.COLUMN_ID`
+    }
+};
+
+export default Dialects;

package/src/database/core/PoolManager.js

@@ -0,0 +1,92 @@
+import * as mariadb from 'mariadb';
+import pg from 'pg';
+//import oracledb from 'oracledb';
+
+class PoolManager {
+    /**
+     * DB 타입에 맞는 커넥션 풀을 생성하여 반환합니다.
+     */
+    static createPool(config) {
+        const type = config?.type?.toLowerCase();
+
+        switch (type) {
+            case 'mariadb':
+            case 'mysql':
+                return this.#createMariaDBPool(config);
+            case 'postgres':
+            case 'postgresql':
+                return this.#createPostgresPool(config);
+            case 'oracle':
+                return this.#createOraclePool(config); // 추가
+            default:
+                throw new Error(`[PoolManager] Unsupported DB_TYPE: ${type}`);
+        }
+    }
+
+    static async #createOraclePool(config) {
+        try {
+            const { default: oracledb } = await import('oracledb');
+
+            oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
+            oracledb.autoCommit = true;
+
+            const pool = await oracledb.createPool({
+                user: config.user,
+                password: config.password,
+                connectString: `${config.host}:${config.port}/${config.database}`,
+                poolMax: 10,
+                poolMin: 2,
+                poolIncrement: 1
+            });
+
+            // 다른 DB들과 사용법을 맞추기 위해 래핑(Wrapping)
+            return {
+                query: async (sql, params = []) => {
+                    let conn;
+                    try {
+                        conn = await pool.getConnection();
+                        const result = await conn.execute(sql, params);
+                        return result.rows; // 객체 배열 반환
+                    } finally {
+                        if (conn) await conn.close();
+                    }
+                },
+                close: () => pool.close()
+            };
+        } catch (err) {
+            console.error("Oracle Pool 생성 실패:", err.message);
+            throw err;
+        }
+    }
+
+    static #createMariaDBPool(config) {
+        return mariadb.createPool({
+            host: config.host,
+            port: config.port,
+            user: config.user,
+            password: config.password,
+            database: config.database,
+            connectionLimit: 10,
+            connectTimeout: 10000,
+            //ssl: config.ssl || undefined
+            acquireTimeout: 10000,
+            allowPublicKeyRetrieval: true
+        });
+    }
+
+    static #createPostgresPool(config) {
+        const { Pool } = pg;
+        return new Pool({
+            host: config.host,
+            port: config.port,
+            user: config.user,
+            password: config.password,
+            database: config.database,
+            max: 10,
+            idleTimeoutMillis: 30000,
+            //ssl: config.ssl || undefined
+        });
+    }
+}
+
+export default PoolManager;

package/src/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+/**
+ * Nine MCP Engine Entry Point
+ * mcp-server.js의 bootstrap을 실행하고 초기 설정을 관리합니다.
+ */
+
+import 'dotenv/config'; // 환경 변수(.env) 로드
+import { runInit } from './core/init.js'; // 초기 설정 명령어 처리
+import { bootstrap } from './mcp/mcp-server.js'; // 실제 MCP 서버 로직
+
+const args = process.argv.slice(2);
+
+/**
+ * 실행 시 'init' 인자가 있으면 설정을 진행하고,
+ * 없으면 MCP 서버를 가동합니다.
+ */
+async function main() {
+    try {
+        if (args.includes('init')) {
+            await runInit();
+        } else {
+            console.log("🚀 Nine MCP Engine 시동 중...");
+            // bootstrap이 Promise를 반환하므로 완전히 뜰 때까지 기다림
+            await bootstrap();
+        }
+    } catch (error) {
+        console.error("❌ 실행 중 치명적인 오류가 발생했습니다:");
+        // ⭐️ 에러의 전체 스택과 상세 정보를 출력
+        console.error(error);
+        if (error.stack) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+// 시동!
+main();

package/src/mcp/loaders/promptLoader.js

@@ -0,0 +1,62 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * 애플리케이션 프롬프트 마크다운 파일을 스캔하여 AI 체인에 등록합니다.
+ * @param {object} ai AIProcessor 인스턴스
+ * @param {string} dbType 현재 가동 중인 벤더명 (mysql, oracle, postgresql 등)
+ */
+export function loadApplicationPrompts(ai, dbType) {
+    const promptPath = path.join(process.cwd(), 'prompts');
+    const targetDb = (dbType || '').toLowerCase().trim();
+    const dbSpecificFolder = path.join(promptPath, targetDb);
+
+    const scanAndRegister = (dir) => {
+        const items = fs.readdirSync(dir, { withFileTypes: true });
+
+        items.forEach((item) => {
+            const fullPath = path.join(dir, item.name);
+
+            if (item.isDirectory()) {
+                // DB 예외 격리 타겟 폴더 자체는 중복 스캔을 방지하기 위해 완전히 패스합니다.
+                if (item.name.toLowerCase() === targetDb) return;
+                scanAndRegister(fullPath);
+            } else if (item.isFile() && path.extname(item.name).toLowerCase() === '.md') {
+                const pureName = path.parse(item.name).name;
+
+                let chainName = pureName;
+
+                // 파일 이름 자체에 마침표(.)가 낀 서브 소스 자산들은 자동 스킵합니다.
+                if (pureName.includes('.')) {
+                    if (pureName.includes('.' + dbType)) {
+                        chainName = pureName.split('.')[0];
+                    } else {
+                        return;
+                    }
+                }
+
+                const dbSpecificPath = path.join(dbSpecificFolder, `${pureName}.md`);
+
+                // 전용 격리 폴더 우선 검사 후 텍스트 데이터 로드
+                const finalPath = fs.existsSync(dbSpecificPath) ? dbSpecificPath : fullPath;
+                const prompt = fs.readFileSync(finalPath, 'utf-8');
+
+                // 일관된 JSON 프로토콜 구조 파서 할당 등록
+                ai.registerChain(chainName, prompt, 'json');
+
+                const logTag = finalPath === dbSpecificPath ? `[${dbType.toUpperCase()} Dedicated]` : '[Default]';
+                console.log(`  > [Chain Loaded] ${chainName} ➡️ ${logTag}`);
+            }
+        });
+    };
+
+    try {
+        if (fs.existsSync(promptPath)) {
+            scanAndRegister(promptPath);
+            console.log("✅ 모든 AI 프롬프트 체인이 메모리에 로드되었습니다.");
+        }
+    } catch (err) {
+        console.error("❌ 프롬프트 로드 실패:", err.message);
+        process.exit(1);
+    }
+}

package/src/mcp/mcp-server.js

@@ -0,0 +1,129 @@
+import express from "express";
+import cors from "cors";
+import { WebSocketServer } from "ws";
+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 { modifySourceBrainTool } from './tools/modifySourceBrainTool.js';
+import { systemBrainTool } from './tools/systemBrain.js';
+import { getStaticToolsConfig } from './tools/staticTools.js';
+import { loadApplicationPrompts } from './loaders/promptLoader.js'; // ★ 분리된 로더 임포트
+import { safeExecute } from './utils/mcp-utils.js';
+
+export async function bootstrap() {
+
+    /**
+    try {
+        const result = {
+            full_source: "const reg = /\d+/;"
+        };
+
+        console.log(JSON.stringify(result, null, 2));
+    } catch (e) {
+        console.error(e);
+    } */
+
+    if (!process.env.DB_TYPE) {
+        throw new Error(".env 파일의 DB_TYPE을 읽을 수 없습니다.");
+    }
+
+    // 1. 코어 인프라 자원 초기화
+    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);
+
+    // 📂 2. [분리 완료] 프롬프트 로더 유틸리티로 동적 스캔 및 가로채기 셋업 위임
+    loadApplicationPrompts(ai, db.type);
+
+    // 🌐 3. MCP 프로토콜 컨텍스트 선언
+    const server = new McpServer(
+        { name: "nine-mcp", version: "1.0.0" },
+        { capabilities: { tools: {}, logging: {} } }
+    );
+
+    const generateSourceBrain = generateSourceBrainTool(db, ai);
+    const modifySourceBrain = modifySourceBrainTool(db, ai);
+
+    // 🔧 4. 일반 하위 실무 생성 도구 명세 로드
+    let nineTools = getStaticToolsConfig();
+
+    const coreTools = [
+        generateSourceBrain,
+        modifySourceBrain,
+        systemBrainTool(db, ai, nineTools, generateSourceBrain, modifySourceBrain)
+    ];
+
+    // 🧠 6. 관제탑 도구 MCP 등록
+    coreTools.forEach(tool => {
+        server.tool(tool.name, tool.description, tool.schema, async (params, context) => {
+            return await safeExecute(() => tool.handler(params, context));
+        });
+    });
+
+    // 🔧 7. 일반 하위 실무 생성 도구 MCP 등록
+    nineTools.forEach(tool => {
+        server.tool(tool.name, tool.description, tool.schema, async (params) => {
+            return await safeExecute(async () => {
+                console.log(`🚀 [Tool Execution]: ${tool.name}`, params);
+                return await ai.runChain(tool.name, params);
+            });
+        });
+    });
+
+    // 🗄️ 8. 데이터베이스 연결
+    try {
+        await db.connect();
+        console.log("데이터베이스 연결 성공");
+    } catch (error) {
+        console.error("서버 기동 실패:", error.message);
+        process.exit(1);
+    }
+
+    // 🌐 9. Express & WebSocket 인프라 기동 및 트랜스포트 바인딩
+    const app = express();
+    app.use(cors(), 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("🔌 새로운 클라이언트 연결됨");
+                try {
+                    global.rawSocket = ws;
+                    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/src/mcp/tools/generateSourceBrainTool.js

@@ -0,0 +1,179 @@
+import { z } from "zod";
+
+export const generateSourceBrainTool = (db, ai) => ({
+    name: "generate-source-brain",
+    description: "미매핑 라우터 정보를 전달받아, 해당 메뉴들과 연관된 데이터베이스 테이블 스키마를 정밀 분석한 후 MyBatis Mapper XML ➡️ 비즈니스 Service ➡️ 컨트롤러 API ➡️ React UI 컴포넌트까지 4대 영역의 소스코드를 순차적 의존성 주입 구조로 일괄 생성(EXECUTE_BATCH)하는 소스코드 빌드 전용 도구입니다.",
+    schema: {
+        user_input: z.string(),
+        base_package: z.string(),
+        unmapped_routes: z.any()
+    },
+    handler: async (params, context) => {
+        const schemaSummary = await db.getTableSchemaSummary();
+        const enrichedParams = { ...params, schema_summary: schemaSummary };
+
+        // 1. 코어 일괄 배치 타겟 분석 체인 구동
+        const rawToolResult = await ai.runChain("generate-source-brain", enrichedParams);
+        let decision = typeof rawToolResult === 'string' ? JSON.parse(rawToolResult) : rawToolResult;
+
+        if (decision.intent === "EXECUTE_BATCH") {
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: { level: "info", logger: "generate-source-brain-start", message: decision.message }
+            });
+
+            const batchList = decision.action?.batchList || [];
+            const schema = await db.getTableSchema();
+            const resultType = "com.ninelab.ai.util.CamelCaseMap";
+
+            console.log(batchList)
+
+            let i = 0;
+            for (let batch of batchList) {
+
+                i++;
+                //if (i < 10) continue;
+                //if (i > 1) break;
+
+                const filteredSchema = schema.filter(table => batch.tableIds.includes(table.tableName));
+
+                const formattedPath = (batch?.path || "").replaceAll("/", ".").replaceAll("-", "_");
+                let cleanPath = formattedPath;
+                if (cleanPath.startsWith(".")) cleanPath = cleanPath.substring(1);
+                if (cleanPath.endsWith(".")) cleanPath = cleanPath.substring(0, cleanPath.length - 1);
+
+                // ★ 만약 cleanPath가 빈 문자열(즉, "/" 경로)이라면 "main"으로 대체
+                if (!cleanPath) {
+                    cleanPath = "main";
+                }
+
+                const pathParts = (batch?.path || "").split("/");
+                const rawClassName = pathParts[pathParts.length - 1] || "Sample";
+                const baseClassName = rawClassName
+                    .split("-")
+                    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                    .join("");
+
+                // 💡 [중요] 연쇄 주입을 위해 루프가 돌기 전, 생성된 소스들을 저장할 버퍼 임시 객체 선언
+                const generatedOutputs = {
+                    mapperXml: "",
+                    serviceCode: ""
+                };
+
+                // 2. ⚡ 레이어별 동적 파라미터 빌더 팩토리 (익명 함수가 아닌 런타임에 인자를 받도록 변경)
+                const targetChains = [
+                    {
+                        id: "generate-source-mapper",
+                        label: "MyBatis 맵퍼",
+                        buildParams: () => ({
+                            ...params,
+                            //db_type: db.type,
+                            asis_source: "",
+                            menu_description: batch.description,
+                            schema_detail: filteredSchema,
+                            result_type: resultType,
+                            namespace: `${params.base_package}.${cleanPath}.mapper`
+                        }),
+                        saveOutput: (source) => { generatedOutputs.mapperSource = source; } // 결과물 킵
+                    },
+                    {
+                        id: "generate-source-service",
+                        label: "비즈니스 서비스",
+                        buildParams: () => ({
+                            ...params,
+                            asis_source: "",
+                            menu_description: batch.description,
+                            //schema_detail: filteredSchema,
+                            service_package: `${params.base_package}.${cleanPath}.service`,
+                            mapper_package: `${params.base_package}.${cleanPath}.mapper`,
+                            // ★ [핵심 주입] 앞 단계에서 만들어진 MyBatis Mapper XML 소스를 통째로 프롬프트 컨텍스트에 제공!
+                            mapper_source: generatedOutputs.mapperSource
+                        }),
+                        saveOutput: (source) => { generatedOutputs.serviceSource = source; } // 결과물 킵
+                    },
+                    {
+                        id: "generate-source-controller",
+                        label: "컨트롤러 API",
+                        buildParams: () => ({
+                            ...params,
+                            asis_source: "",
+                            menu_description: batch.description,
+                            //schema_detail: filteredSchema,
+                            api_base_url: batch.path,
+                            controller_package: `${params.base_package}.${cleanPath}.controller`,
+                            service_package: `${params.base_package}.${cleanPath}.service`,
+                            // ★ [핵심 주입] 앞 단계에서 완성된 Service 인터페이스/클래스 명세를 보고 Controller를 조립할 수 있도록 제공!
+                            service_source: generatedOutputs.serviceSource
+                        }),
+                        saveOutput: (source) => { generatedOutputs.controllerSource = source; }
+                    },
+                    {
+                        id: "generate-source-ui-react",
+                        label: "리액트 UI 컴포넌트",
+                        buildParams: () => ({
+                            ...params,
+                            asis_source: "",
+                            menu_description: batch.description,
+                            api_base_url: batch.path,
+                            menu_name: batch.description,
+                            base_class: baseClassName,
+                            schema_detail: filteredSchema, // 스키마 세부 사항 전달
+                            mapper_source: generatedOutputs.mapperSource, // ★ 의존성 연쇄 주입
+                            controller_source: generatedOutputs.controllerSource
+                        }),
+                        saveOutput: () => {} // UI 단은 최종 말단 레이어이므로 세이브 패스
+                    }
+                ];
+
+                // 3. 순차 파라미터 격리 실행 루프
+                for (const chain of targetChains) {
+
+                        const specificToolParams = chain.buildParams();
+
+                        console.log(`🚀 [${batch.description}] ${chain.label} 실행 (연쇄 컨텍스트 주입 완료)`);
+
+                        const rawSourceResult = await ai.runChain(chain.id, specificToolParams);
+
+                        let resultObj = typeof rawSourceResult === 'string' ? JSON.parse(rawSourceResult) : rawSourceResult;
+
+                        console.log(resultObj);
+                        // 💡 현재 레이어에서 생성된 따끈따끈한 소스코드를 메모리 버퍼 객체에 세팅 (다음 레이어가 땡겨 쓸 수 있게)
+                        chain.saveOutput(resultObj.full_source);
+                        //console.log(resultObj.full_source);
+
+                        // 화면 탭 분기를 위한 스트리밍 노티 발송
+                        await context.sendNotification({
+                            method: "notifications/logging/message",
+                            params: {
+                                level: "info",
+                                logger: "generate-source-brain",
+                                message: `${chain.label} 설계 완료`,
+                                data: {
+                                    //status: "PROGRESS",
+                                    //menu: batch.description,
+                                    path: batch.path,
+                                    //layer: chain.id,
+                                    //mode: resultObj.mode,
+                                    //file_name: resultObj.file_name,
+                                    source: resultObj.full_source
+                                }
+                            }
+                        });
+
+                }
+
+                //i++;
+                //if (i > 5) break;
+            }
+
+            await context.sendNotification({
+                method: "notifications/logging/message",
+                params: { level: "info", logger: "generate-source-brain-completed", message: "모든 작업이 완료되었습니다." }
+            });
+
+            return { success: true, intent: "NONE", message: null };
+        } else {
+            return { success: false, intent: "NONE", message: decision.message };
+        }
+    }
+});