@callakrsos/my-ollama-cli 1.0.0

package/cli-agent.js

@@ -0,0 +1,275 @@
+/*******************************************************************************/
+//제작자 : 김영준
+// 오픈소스를 활용한 CLI를 학습 목적으로 만들었습니다.
+// AI는 틀릴 수 있습니다.
+// 생성된 결과에 대한 책임은 본인에게 있습니다.
+// 혹시 저를 본다면 커피라도 한잔~
+/*******************************************************************************/
+import { createAgent } from "langchain";
+import { HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { MemorySaver } from "@langchain/langgraph";
+import inquirer from "inquirer";
+import fs from "fs/promises";
+import 'dotenv/config';
+import chalk from 'chalk';
+import { Command } from 'commander';
+
+import { tools } from './tools/index.js';
+import { getSafePath } from './tools/utils.js';
+import { loadHistory, saveHistory, commandHistory } from './lib/history.js';
+import { logger, LOG_DIR } from './lib/logger.js';
+import { loadSettings, loadMcpToolsFromSettings } from './lib/mcp.js';
+import { getModel, getLlmProvider, normalizeOllamaBaseUrl, normalizeVllmBaseUrl, SYSTEM_PROMPT } from './lib/model.js';
+import { cliPrompt, createSpinner } from './ui/prompt.js';
+import { selectFile, selectMultipleFiles } from './ui/fileSelector.js';
+import { registerCommands } from './commands/register.js';
+
+// =========================================================
+// [1] 에이전트 설정
+// =========================================================
+let currentThreadId = Date.now().toString();
+
+async function createAgentExecutor() {
+    const settings = await loadSettings();
+    const { tools: mcpTools, mcpClient } = await loadMcpToolsFromSettings(settings);
+    const agent = createAgent({
+        model: getModel(),
+        tools: [...tools, ...mcpTools],
+        prompt: SYSTEM_PROMPT,
+        checkpointer: new MemorySaver(),
+    });
+    return { agent, mcpClient };
+}
+
+// =========================================================
+// [2] 메인 CLI 루프
+// =========================================================
+async function startCLI() {
+    await loadHistory();
+    const { agent, mcpClient } = await createAgentExecutor();
+    const program = new Command();
+    program.exitOverride();
+
+    const closeMcp = async () => {
+        if (mcpClient && typeof mcpClient.close === 'function') {
+            try { await mcpClient.close(); } catch (_) {}
+        }
+    };
+    process.on('beforeExit', () => { closeMcp(); });
+    process.on('SIGINT', () => { closeMcp(); });
+
+    // ── 시작 배너 ─────────────────────────────────────
+    console.log(chalk.blue.bold(`
+ _  __ __   __     _   ____ _     ___
+| |/ / \\ \\ / /    | | / ___| |   |_ _|
+| ' /   \\ V /  _  | || |   | |    | |
+| . \\    | |  | |_| || |___| |___ | |
+|_|\\_\\   |_|   \\___/  \\____|_____|___|
+`));
+    const llmProvider = getLlmProvider();
+    const serverUrl = llmProvider === 'vllm'
+        ? normalizeVllmBaseUrl(process.env.VLLM_BASE_URL || process.env.OLLAMA_BASE_URL)
+        : normalizeOllamaBaseUrl(process.env.OLLAMA_BASE_URL);
+    console.log(chalk.green("KYJ CLI에 오신 것을 환영합니다! '/help'를 입력해 명령어를 확인하세요."));
+    console.log(chalk.gray(`   LLM: ${llmProvider} → ${serverUrl}`));
+    if (mcpClient) {
+        const settings = await loadSettings();
+        const mcpServers = Object.keys(settings?.mcp?.mcpServers ?? {});
+        console.log(chalk.gray(`   MCP: ${mcpServers.length}개 서버 연결됨 (${mcpServers.join(', ')})`));
+    }
+    console.log(chalk.gray('   @ : 단일 파일 첨부  |  @@ : 멀티 파일 첨부  |  /skills : 스킬 목록'));
+    console.log(chalk.gray(`   로그: ${LOG_DIR}`));
+    logger.system('startup', { provider: llmProvider, serverUrl });
+
+    // ── AI 채팅 핸들러 ────────────────────────────────
+    const handleChat = async (userInput) => {
+        if (!userInput.trim()) { askQuestion(); return; }
+
+        const controller = new AbortController();
+        const sigintHandler = () => { console.log(chalk.yellow('\n[명령어 실행 취소]')); controller.abort(); };
+        const spinner = createSpinner('AI가 처리 중...');
+        const startTime = Date.now();
+
+        try {
+            process.once('SIGINT', sigintHandler);
+            const result = await agent.invoke(
+                { messages: [new HumanMessage(userInput)] },
+                { configurable: { thread_id: currentThreadId }, signal: controller.signal, recursionLimit: 20 },
+            );
+            spinner.stop();
+            const durationMs = Date.now() - startTime;
+
+            const lastMsg = result.messages.at(-1);
+            const output = typeof lastMsg.content === 'string'
+                ? lastMsg.content
+                : Array.isArray(lastMsg.content)
+                    ? lastMsg.content.filter(c => c.type === 'text').map(c => c.text).join('')
+                    : String(lastMsg.content);
+
+            const toolsCalled = result.messages
+                .filter(m => m instanceof ToolMessage)
+                .map(m => ({ tool: m.name, input: {} }));
+
+            const W = process.stdout.columns || 100;
+            process.stdout.write(chalk.gray('─'.repeat(W)) + '\n');
+            process.stdout.write(
+                chalk.blue.bold('  🤖 AI') +
+                chalk.gray(`  (${(durationMs / 1000).toFixed(1)}초`) +
+                (toolsCalled.length ? chalk.gray(`  ·  툴 ${toolsCalled.map(t => t.tool).join(', ')}`) : '') +
+                chalk.gray(')') + '\n\n'
+            );
+            output.split('\n').forEach(line => process.stdout.write('  ' + line + '\n'));
+            process.stdout.write('\n');
+
+            logger.chat(userInput, output, durationMs, toolsCalled);
+
+        } catch (error) {
+            spinner.stop();
+            if (error.name !== 'AbortError') {
+                console.error(chalk.red('❌ 오류 발생:'), error.message);
+                const body = error.body ?? error.error ?? error.response?.data ?? error.data;
+                if (body != null) {
+                    console.error(chalk.yellow('   API 응답 본문:'), typeof body === 'string' ? body : JSON.stringify(body, null, 2));
+                }
+                if (error.message?.includes('404')) {
+                    if (llmProvider === 'vllm') {
+                        const base = normalizeVllmBaseUrl(process.env.VLLM_BASE_URL || process.env.OLLAMA_BASE_URL);
+                        console.error(chalk.yellow(`   vLLM 주소: ${base}`));
+                        console.error(chalk.gray('   → .env의 VLLM_BASE_URL을 확인하세요.'));
+                    } else {
+                        const base = normalizeOllamaBaseUrl(process.env.OLLAMA_BASE_URL);
+                        console.error(chalk.yellow(`   Ollama 주소: ${base}`));
+                        console.error(chalk.gray('   → .env의 OLLAMA_BASE_URL을 확인하세요.'));
+                    }
+                } else {
+                    console.error(chalk.red('❌ 상세:'), error.stack);
+                }
+                logger.error(error, { userInput: userInput.slice(0, 300), provider: llmProvider, durationMs: Date.now() - startTime });
+            }
+        } finally {
+            process.removeListener('SIGINT', sigintHandler);
+            askQuestion();
+        }
+    };
+
+    // ── @ 단일 파일 첨부 ──────────────────────────────
+    const handleAttach = async (rawInput) => {
+        await saveHistory(rawInput);
+        const parts = rawInput.split(' ');
+        const fileCandidate = parts[0].startsWith('@') ? parts[0].slice(1) : '';
+        const inlineQuestion = parts.slice(1).join(' ').trim();
+
+        let selectedFile = null;
+        if (fileCandidate && (fileCandidate.includes('/') || fileCandidate.includes('\\') || fileCandidate.includes('.'))) {
+            try { await fs.access(getSafePath(fileCandidate)); selectedFile = fileCandidate; } catch (_) {}
+        }
+        if (!selectedFile) {
+            try { selectedFile = await selectFile(fileCandidate); }
+            catch (e) {
+                console.log(e?.name === 'ExitPromptError' ? chalk.yellow('\n[취소]') : chalk.red('파일 첨부 중 오류:') + ' ' + e.message);
+                askQuestion(); return;
+            }
+        }
+        if (!selectedFile) { console.log(chalk.yellow('파일이 선택되지 않았습니다.')); askQuestion(); return; }
+
+        let question = inlineQuestion;
+        if (!question) {
+            try {
+                const { q } = await inquirer.prompt([{ type: 'input', name: 'q', message: chalk.cyan(`'${selectedFile}' 파일에 대해 질문하세요:`) }]);
+                question = q;
+            } catch (e) {
+                if (e?.name === 'ExitPromptError') console.log(chalk.yellow('\n[취소]'));
+                askQuestion(); return;
+            }
+        }
+        if (!question) { console.log(chalk.yellow('질문이 입력되지 않았습니다.')); askQuestion(); return; }
+
+        const normalizedPath = selectedFile.replace(/\\/g, '/');
+        await handleChat(`read_file 도구로 다음 파일을 읽고 질문에 답해주세요.\n\n[파일 경로]\n${normalizedPath}\n\n[질문]\n${question}`);
+    };
+
+    // ── @@ 멀티 파일 첨부 ────────────────────────────
+    const handleMultiAttach = async (rawInput) => {
+        await saveHistory(rawInput);
+        const firstWord = rawInput.split(' ')[0];
+        const initialSearch = firstWord.length > 2 ? firstWord.substring(2).trim() : '';
+
+        try {
+            const selectedFiles = await selectMultipleFiles(initialSearch);
+            if (!selectedFiles?.length) { console.log(chalk.yellow('파일이 선택되지 않았습니다.')); askQuestion(); return; }
+
+            const { question } = await inquirer.prompt([{ type: 'input', name: 'question', message: chalk.cyan(`${selectedFiles.length}개 파일에 대해 질문하세요:`) }]);
+            if (!question) { console.log(chalk.yellow('질문이 입력되지 않았습니다.')); askQuestion(); return; }
+
+            const filePaths = selectedFiles.map(f => f.replace(/\\/g, '/')).join('\n');
+            await handleChat(`read_file 도구로 다음 파일들을 순서대로 읽고 질문에 답해주세요.\n\n[파일 경로 목록]\n${filePaths}\n\n[질문]\n${question}`);
+        } catch (e) {
+            console.log(e?.name === 'ExitPromptError' ? chalk.yellow('\n[취소]') : chalk.red('파일 첨부 중 오류:') + ' ' + e.message);
+            askQuestion();
+        }
+    };
+
+    // ── 슬래시 커맨드 등록 ────────────────────────────
+    registerCommands(program, {
+        agent,
+        getThreadId: () => currentThreadId,
+        resetThread: () => { currentThreadId = Date.now().toString(); },
+        handleChat,
+        askQuestion: () => askQuestion(),
+        closeMcp,
+    });
+
+    // ── 입력 루프 ─────────────────────────────────────
+    const askQuestion = async () => {
+        try {
+            const userInput = await cliPrompt(commandHistory);
+            const trimmed = (userInput || '').trim();
+            if (!trimmed) { askQuestion(); return; }
+
+            await saveHistory(trimmed);
+            const firstArg = trimmed.split(' ')[0];
+
+            if (firstArg.startsWith('/')) {
+                try {
+                    await program.parseAsync(trimmed.split(' '), { from: 'user' });
+                } catch (e) {
+                    if (e.code === 'commander.unknownCommand') {
+                        console.log(chalk.yellow(`알 수 없는 명령어입니다. '/help'를 입력하면 사용 가능한 명령을 볼 수 있습니다.`));
+                    } else if (e.code !== 'commander.executeSubCommandAsync') {
+                        console.error(chalk.red(`명령어 처리 중 오류: ${e.message}`));
+                    }
+                    askQuestion();
+                }
+            } else if (firstArg.startsWith('@@')) {
+                await handleMultiAttach(trimmed);
+            } else if (firstArg.startsWith('@')) {
+                await handleAttach(trimmed);
+            } else {
+                await handleChat(trimmed);
+            }
+        } catch (error) {
+            if (error?.name === 'ExitPromptError') {
+                try {
+                    const { confirmExit } = await inquirer.prompt([{ type: 'confirm', name: 'confirmExit', message: '정말로 종료하시겠습니까?', default: true }]);
+                    if (confirmExit) {
+                        console.log(chalk.yellow('프로그램을 종료합니다. 안녕히 계세요!'));
+                        await closeMcp();
+                        process.exit(0);
+                    }
+                } catch (_) {}
+                askQuestion();
+            } else {
+                console.error(chalk.red('오류 발생:'), error.message);
+                askQuestion();
+            }
+        }
+    };
+
+    if (process.argv.slice(2).length > 0) {
+        await program.parseAsync(process.argv);
+    } else {
+        askQuestion();
+    }
+}
+
+startCLI();

package/commands/register.js

@@ -0,0 +1,238 @@
+import fs from "fs/promises";
+import path from "path";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadSkills } from '../skills/index.js';
+import { loadSettings } from '../lib/mcp.js';
+import { saveHistory } from '../lib/history.js';
+import { logger, LOG_DIR, logDate, ensureLogDir, getTimestamp } from '../lib/logger.js';
+import { getSafePath } from '../tools/utils.js';
+
+/**
+ * Commander program에 모든 슬래시 커맨드를 등록합니다.
+ *
+ * @param {import('commander').Command} program
+ * @param {{
+ *   agent: any,
+ *   getThreadId: () => string,
+ *   resetThread: () => void,
+ *   handleChat: (input: string) => Promise<void>,
+ *   askQuestion: () => Promise<void>,
+ *   closeMcp: () => Promise<void>,
+ * }} ctx
+ */
+export function registerCommands(program, ctx) {
+    const { agent, getThreadId, resetThread, handleChat, askQuestion, closeMcp } = ctx;
+
+    program
+        .command('/help')
+        .description('사용 가능한 명령어 목록을 출력합니다.')
+        .action(() => {
+            const cmds = [
+                ['@<검색어>',      '단일 파일 첨부 후 질문  (예: @index.js)'],
+                ['@@<검색어>',     '멀티 파일 첨부 (Space 선택, Enter 확인)'],
+                ['/skills',       '사용 가능한 스킬 목록 출력'],
+                ['/skill <이름>',  '스킬 실행  (예: /skill commit)'],
+                ['/clear',        '현재 대화 기록 초기화'],
+                ['/list',         '현재 대화 기록 콘솔 출력'],
+                ['/save',         '대화 기록을 Markdown 파일로 저장'],
+                ['/log',          '로그 파일 현황 및 최근 에러 미리보기'],
+                ['/mcp',          '연결된 MCP 서버 목록 출력'],
+                ['/baseDir',      '작업 디렉토리 변경'],
+                ['/help',         '이 도움말 출력'],
+                ['/exit',         '프로그램 종료'],
+            ];
+            console.log(chalk.bold('\n━━━ KYJ CLI 명령어 ━━━'));
+            for (const [cmd, desc] of cmds) {
+                console.log(`  ${chalk.cyan(cmd.padEnd(20))} ${desc}`);
+            }
+            console.log(chalk.gray('\n  Ctrl+C 로도 종료할 수 있습니다.'));
+            console.log(chalk.bold('━━━━━━━━━━━━━━━━━━━━━\n'));
+            askQuestion();
+        });
+
+    program
+        .command('/baseDir')
+        .description('디렉토리 위치를 변경')
+        .action(async () => {
+            const { userInput } = await inquirer.prompt([{
+                type: 'input',
+                name: 'userInput',
+                message: chalk.green.bold('디렉토리 위치'),
+            }]);
+            console.log(userInput);
+            askQuestion();
+        });
+
+    program
+        .command('/mcp')
+        .description('현재 설정된 MCP 서버 리스트를 출력합니다.')
+        .action(async () => {
+            const settings = await loadSettings();
+            const mcp = settings?.mcp;
+            if (!mcp?.mcpServers || Object.keys(mcp.mcpServers).length === 0) {
+                console.log(chalk.yellow('설정된 MCP 서버가 없습니다. settings.json의 mcp.mcpServers를 확인하세요.'));
+            } else {
+                console.log(chalk.bold('\n--- 현재 설정된 MCP 서버 ---'));
+                for (const [name, cfg] of Object.entries(mcp.mcpServers)) {
+                    const type = cfg?.url ? 'url' : (cfg?.command ? 'stdio' : '?');
+                    const desc = cfg?.url ? cfg.url : (cfg?.command ? `${cfg.command} ${(cfg.args || []).join(' ')}` : '');
+                    console.log(chalk.cyan(`  ${name}`), chalk.gray(`(${type})`), desc);
+                }
+                console.log(chalk.bold('---\n'));
+            }
+            askQuestion();
+        });
+
+    program
+        .command('/clear')
+        .description('터미널 화면과 대화 기록을 모두 지웁니다.')
+        .action(() => {
+            resetThread();
+            console.clear();
+            console.log(chalk.yellow('✅ 채팅 기록과 화면이 지워졌습니다.'));
+            askQuestion();
+        });
+
+    program
+        .command('/save')
+        .description('현재까지의 대화 내용을 Markdown 파일로 저장합니다.')
+        .action(async () => {
+            const timestamp = getTimestamp();
+            const fileName = `chathistory_${timestamp}.md`;
+            const state = await agent.getState({ configurable: { thread_id: getThreadId() } });
+            const messages = (state.values?.messages ?? []).filter(m => m._getType() === 'human' || m._getType() === 'ai');
+
+            if (messages.length === 0) {
+                console.log(chalk.yellow('✅ 채팅 기록이 없습니다.'));
+            } else {
+                let md = `# 📝 채팅 기록 (${timestamp})\n\n`;
+                for (const msg of messages) {
+                    const type = msg._getType();
+                    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content, null, 2);
+                    if (type === 'human') md += `**🧑 Human:**\n${content}\n\n---\n\n`;
+                    else if (type === 'ai') md += `**🤖 AI:**\n${content}\n\n---\n\n`;
+                }
+                try {
+                    const safePath = getSafePath(fileName);
+                    await fs.writeFile(safePath, md, 'utf-8');
+                    console.log(chalk.yellow(`✅ 채팅 기록이 '${safePath}' 파일로 저장되었습니다.`));
+                } catch (error) {
+                    console.error(chalk.red('❌ 파일 저장 중 오류:'), error.message);
+                }
+            }
+            await saveHistory('/save');
+            askQuestion();
+        });
+
+    program
+        .command('/list')
+        .description('현재까지의 대화 내용을 콘솔에 출력합니다.')
+        .action(async () => {
+            const state = await agent.getState({ configurable: { thread_id: getThreadId() } });
+            const messages = (state.values?.messages ?? []).filter(m => m._getType() === 'human' || m._getType() === 'ai');
+
+            if (messages.length === 0) {
+                console.log(chalk.yellow('✅ 채팅 기록이 없습니다.'));
+            } else {
+                console.log(chalk.bold('\n--- 📝 채팅 기록 ---'));
+                for (const msg of messages) {
+                    const type = msg._getType();
+                    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content, null, 2);
+                    if (type === 'human') console.log(`\n🧑 Human:\n${content}`);
+                    else if (type === 'ai') console.log(`\n${chalk.blue.bold('🤖 AI:')}\n${content}`);
+                }
+                console.log(chalk.bold('\n--- 기록 끝 ---\n'));
+            }
+            await saveHistory('/list');
+            askQuestion();
+        });
+
+    program
+        .command('/skills')
+        .description('사용 가능한 스킬 목록을 출력합니다.')
+        .action(async () => {
+            const skills = await loadSkills();
+            console.log(chalk.bold('\n--- ✨ 사용 가능한 스킬 ---'));
+            for (const [name, skill] of Object.entries(skills)) {
+                console.log(`  ${chalk.cyan('/skill ' + name.padEnd(12))} ${skill.description}`);
+            }
+            console.log(chalk.gray('\n사용법: /skill <이름> [추가 입력]'));
+            console.log(chalk.gray('커스텀 스킬: skills.json 파일을 만들어 스킬을 추가/수정하세요.'));
+            console.log(chalk.bold('---\n'));
+            askQuestion();
+        });
+
+    program
+        .command('/skill')
+        .description('스킬을 실행합니다. 예: /skill commit')
+        .argument('<name>', '스킬 이름')
+        .argument('[extra...]', '추가 입력 (선택)')
+        .action(async (name, extra) => {
+            const skills = await loadSkills();
+            const skill = skills[name];
+            if (!skill) {
+                console.log(chalk.yellow(`스킬 '${name}'을 찾을 수 없습니다. '/skills'로 목록을 확인하세요.`));
+                askQuestion();
+                return;
+            }
+            const extraText = extra?.length > 0 ? '\n\n추가 지시: ' + extra.join(' ') : '';
+            console.log(chalk.gray(`[스킬 실행] ${name}: ${skill.description}`));
+            await handleChat(skill.prompt + extraText);
+        });
+
+    program
+        .command('/log')
+        .description('로그 파일 현황을 보여줍니다.')
+        .action(async () => {
+            try {
+                await ensureLogDir();
+                const files = await fs.readdir(LOG_DIR);
+                const logFiles = files.filter(f => f.endsWith('.log')).sort().reverse();
+                if (logFiles.length === 0) {
+                    console.log(chalk.yellow('아직 생성된 로그 파일이 없습니다.'));
+                } else {
+                    console.log(chalk.bold(`\n--- 📋 로그 파일 목록 (${LOG_DIR}) ---`));
+                    for (const f of logFiles) {
+                        const stat = await fs.stat(path.join(LOG_DIR, f));
+                        const kb = (stat.size / 1024).toFixed(1);
+                        const color = f.startsWith('error') ? chalk.red : f.startsWith('chat') ? chalk.cyan : chalk.gray;
+                        console.log(`  ${color(f.padEnd(35))} ${chalk.gray(kb + ' KB')}`);
+                    }
+                    const todayError = path.join(LOG_DIR, `error_${logDate()}.log`);
+                    try {
+                        const raw = await fs.readFile(todayError, 'utf-8');
+                        const lines = raw.trim().split('\n').filter(Boolean).slice(-5);
+                        if (lines.length > 0) {
+                            console.log(chalk.bold('\n--- 오늘 최근 에러 (최대 5건) ---'));
+                            for (const line of lines) {
+                                try {
+                                    const entry = JSON.parse(line);
+                                    console.log(chalk.red(`  [${entry.ts}]`), entry.message);
+                                    if (entry.userInput) console.log(chalk.gray(`    입력: ${entry.userInput}`));
+                                } catch (_) {
+                                    console.log(chalk.gray('  ' + line));
+                                }
+                            }
+                        }
+                    } catch (_) {
+                        console.log(chalk.gray('\n  오늘 에러 없음'));
+                    }
+                    console.log(chalk.bold('---\n'));
+                }
+            } catch (err) {
+                console.error(chalk.red('로그 조회 실패:'), err.message);
+            }
+            askQuestion();
+        });
+
+    program
+        .command('/exit')
+        .description('CLI 에이전트를 종료합니다.')
+        .action(async () => {
+            logger.system('shutdown');
+            console.log(chalk.yellow('프로그램을 종료합니다. 안녕히 계세요!'));
+            await closeMcp();
+            process.exit(0);
+        });
+}

package/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI 에이전트 진입점 — cli-agent.js 실행
+ * 사용: node index.js  또는  npm start
+ */
+import './cli-agent.js';

package/lib/history.js

@@ -0,0 +1,30 @@
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import chalk from "chalk";
+
+export const HISTORY_FILE = path.join(os.homedir(), '.kyj_cli_history');
+
+export let commandHistory = [];
+
+export async function loadHistory() {
+    try {
+        const data = await fs.readFile(HISTORY_FILE, 'utf-8');
+        commandHistory = data.split('\n').filter(line => line.trim() !== '');
+    } catch (error) {
+        if (error.code !== 'ENOENT') {
+            console.error(chalk.red('명령어 히스토리 로딩 실패:'), error);
+        }
+        commandHistory = [];
+    }
+}
+
+export async function saveHistory(command) {
+    commandHistory.push(command);
+    if (commandHistory.length > 100) commandHistory.shift();
+    try {
+        await fs.appendFile(HISTORY_FILE, command + '\n', 'utf-8');
+    } catch (error) {
+        console.error(chalk.red('명령어 히스토리 저장 실패:'), error);
+    }
+}

package/lib/logger.js

@@ -0,0 +1,46 @@
+import fs from "fs/promises";
+import path from "path";
+
+const BASE_DIR = process.cwd();
+export const LOG_DIR = path.join(BASE_DIR, 'logs');
+
+export function logDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+
+export function getTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+let _logDirReady = false;
+export async function ensureLogDir() {
+    if (_logDirReady) return;
+    try {
+        await fs.mkdir(LOG_DIR, { recursive: true });
+        _logDirReady = true;
+    } catch (_) {}
+}
+
+async function writeLog(type, data) {
+    try {
+        await ensureLogDir();
+        const file = path.join(LOG_DIR, `${type}_${logDate()}.log`);
+        const line = JSON.stringify({ ts: new Date().toISOString(), ...data }) + '\n';
+        await fs.appendFile(file, line, 'utf-8');
+    } catch (_) {}
+}
+
+export const logger = {
+    chat: (userInput, aiOutput, durationMs, tools = []) =>
+        writeLog('chat', { user: userInput, ai: aiOutput, durationMs, tools }),
+
+    error: (err, context = {}) =>
+        writeLog('error', {
+            message: err?.message ?? String(err),
+            stack: err?.stack ?? null,
+            ...context,
+        }),
+
+    system: (event, data = {}) =>
+        writeLog('system', { event, ...data }),
+};

package/lib/mcp.js

@@ -0,0 +1,63 @@
+import fs from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+
+const BASE_DIR = process.cwd();
+const SETTINGS_PATH = path.join(BASE_DIR, 'settings.json');
+
+export async function loadSettings() {
+    try {
+        const raw = await fs.readFile(SETTINGS_PATH, 'utf-8');
+        return JSON.parse(raw);
+    } catch (e) {
+        if (e.code === 'ENOENT') return {};
+        throw e;
+    }
+}
+
+export async function loadMcpToolsFromSettings(settings) {
+    const mcp = settings?.mcp;
+    if (!mcp?.mcpServers || Object.keys(mcp.mcpServers).length === 0) {
+        return { tools: [], mcpClient: null };
+    }
+    if (mcp.enabled === false) return { tools: [], mcpClient: null };
+
+    try {
+        const { MultiServerMCPClient } = await import('@langchain/mcp-adapters');
+        const serverEntries = {};
+        for (const [name, cfg] of Object.entries(mcp.mcpServers)) {
+            if (!cfg) continue;
+            if (cfg.enabled === false) continue;
+            if (cfg.command && cfg.args) {
+                serverEntries[name] = {
+                    transport: 'stdio',
+                    command: cfg.command,
+                    args: Array.isArray(cfg.args) ? cfg.args : [cfg.args],
+                    ...(cfg.env && { env: cfg.env }),
+                    ...(cfg.restart && { restart: cfg.restart }),
+                };
+            } else if (cfg.url) {
+                serverEntries[name] = {
+                    transport: cfg.transport === 'sse' ? 'sse' : 'http',
+                    url: cfg.url,
+                    ...(cfg.headers && { headers: cfg.headers }),
+                    ...(cfg.reconnect && { reconnect: cfg.reconnect }),
+                };
+            }
+        }
+        if (Object.keys(serverEntries).length === 0) return { tools: [], mcpClient: null };
+
+        const client = new MultiServerMCPClient({
+            throwOnLoadError: false,
+            onConnectionError: mcp.onConnectionError ?? 'ignore',
+            prefixToolNameWithServerName: mcp.prefixToolNameWithServerName ?? false,
+            useStandardContentBlocks: true,
+            mcpServers: serverEntries,
+        });
+        const mcpTools = await client.getTools();
+        return { tools: mcpTools ?? [], mcpClient: client };
+    } catch (err) {
+        console.error(chalk.yellow('MCP 로드 실패 (기본 도구만 사용):'), err.message);
+        return { tools: [], mcpClient: null };
+    }
+}