aiexecode 1.0.157

package/src/commands/agents.js

@@ -0,0 +1,18 @@
+import { uiEvents } from '../system/ui_events.js';
+import { formatAgentsMdSummary } from '../system/agents_loader.js';
+
+/**
+ * /agents 커맨드 - AGENTS.md 파일 조회
+ *
+ * 사용법:
+ *   /agents - 작업 디렉토리 루트의 AGENTS.md 내용 표시
+ */
+export default {
+    name: 'agents',
+    description: 'Show AGENTS.md file content',
+    usage: '/agents',
+    handler: async (args, context) => {
+        const summary = await formatAgentsMdSummary();
+        uiEvents.addSystemMessage(summary);
+    }
+};

package/src/commands/apikey.js

@@ -0,0 +1,55 @@
+import { uiEvents } from '../system/ui_events.js';
+import { loadSettings, saveSettings, SETTINGS_FILE } from '../util/config.js';
+import { resetAIClients } from '../system/ai_request.js';
+
+/**
+ * /apikey 커맨드 - API 키 설정
+ */
+export default {
+    name: 'apikey',
+    description: 'Set API key',
+    usage: '/apikey <api-key>',
+    handler: async (args, context) => {
+        // 인자 확인
+        if (!args || args.length < 1) {
+            uiEvents.addSystemMessage(
+                `Please enter API key.\n\n` +
+                `Usage:\n` +
+                `  /apikey <your-zai-api-key>`
+            );
+            return;
+        }
+
+        try {
+            // 현재 설정 로드
+            const settings = await loadSettings();
+
+            const apiKey = args[0];
+
+            // API 키 업데이트
+            settings.API_KEY = apiKey;
+            process.env.API_KEY = apiKey;
+
+            // 설정 저장
+            await saveSettings(settings);
+
+            // AI 클라이언트 캐시 초기화 (다음 요청 시 새 설정 적용)
+            resetAIClients();
+
+            // 성공 메시지
+            const maskedKey = apiKey.length > 20
+                ? `${apiKey.slice(0, 10)}...${apiKey.slice(-4)}`
+                : `${apiKey.slice(0, 6)}...`;
+
+            uiEvents.addSystemMessage(
+                `API configuration complete\n\n` +
+                `API Key: ${maskedKey}\n` +
+                `Saved to: ${SETTINGS_FILE}`
+            );
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            uiEvents.addErrorMessage(`API key configuration failed: ${errorMessage}`);
+        }
+    }
+};
+

package/src/commands/bg.js

@@ -0,0 +1,140 @@
+import { listBackgroundProcesses, killBackgroundProcess, getBackgroundProcess } from '../system/background_process.js';
+import { uiEvents } from '../system/ui_events.js';
+
+/**
+ * /bg 커맨드 - 백그라운드 프로세스 관리
+ *
+ * 사용법:
+ *   /bg          - 프로세스 목록 표시
+ *   /bg list     - 프로세스 목록 표시
+ *   /bg kill <id> - 프로세스 종료
+ *   /bg killall  - 모든 실행 중인 프로세스 종료
+ */
+export default {
+    name: 'bg',
+    description: 'Manage background processes',
+    usage: '/bg [list|kill <id>|killall]',
+    handler: async (args, context) => {
+        const subcommand = args[0]?.toLowerCase() || 'list';
+
+        switch (subcommand) {
+            case 'list':
+            case 'ls': {
+                const processes = listBackgroundProcesses({ running: true });
+                if (processes.length === 0) {
+                    uiEvents.addSystemMessage('No running background processes');
+                    return;
+                }
+
+                const lines = [
+                    '**Background Processes**',
+                    '| Status | ID | PID | Duration | Command |',
+                    '|--------|-----|-----|----------|---------|'
+                ];
+                for (const proc of processes) {
+                    const status = proc.status === 'running' ? 'running' :
+                                   proc.status === 'completed' ? 'completed' :
+                                   proc.status === 'failed' ? 'failed' : 'cancelled';
+                    const duration = formatDuration(proc.startedAt, proc.endedAt);
+                    const cmd = proc.command.substring(0, 40) + (proc.command.length > 40 ? '...' : '');
+                    lines.push(`| ${status} | ${proc.id} | ${proc.pid} | ${duration} | \`${cmd}\` |`);
+                }
+                const hasRunning = processes.some(p => p.status === 'running');
+                if (hasRunning) {
+                    lines.push('To stop: `/bg kill <id>` or `/bg killall`');
+                }
+                uiEvents.addSystemMessage(lines.join('\n'));
+                break;
+            }
+
+            case 'kill': {
+                const id = args[1];
+                if (!id) {
+                    uiEvents.addErrorMessage('**Usage:** `/bg kill <process_id>`');
+                    return;
+                }
+
+                const proc = getBackgroundProcess(id);
+                if (!proc) {
+                    uiEvents.addErrorMessage(`Process not found: \`${id}\``);
+                    return;
+                }
+
+                if (proc.status !== 'running') {
+                    uiEvents.addSystemMessage(`Process \`${id}\` is already ${proc.status}`);
+                    return;
+                }
+
+                const killed = killBackgroundProcess(id);
+                if (killed) {
+                    uiEvents.addSystemMessage(`Killed process: \`${id}\` (pid: ${proc.pid})`);
+                } else {
+                    uiEvents.addErrorMessage(`Failed to kill process: \`${id}\``);
+                }
+                break;
+            }
+
+            case 'killall': {
+                const processes = listBackgroundProcesses({ running: true });
+                if (processes.length === 0) {
+                    uiEvents.addSystemMessage('No running background processes');
+                    return;
+                }
+
+                let killedCount = 0;
+                for (const proc of processes) {
+                    if (killBackgroundProcess(proc.id)) {
+                        killedCount++;
+                    }
+                }
+                uiEvents.addSystemMessage(`Killed **${killedCount}** background process(es)`);
+                break;
+            }
+
+            case 'show': {
+                const id = args[1];
+                if (!id) {
+                    uiEvents.addErrorMessage('**Usage:** `/bg show <process_id>`');
+                    return;
+                }
+
+                const proc = getBackgroundProcess(id);
+                if (!proc) {
+                    uiEvents.addErrorMessage(`Process not found: \`${id}\``);
+                    return;
+                }
+
+                const lines = [
+                    `## Process: \`${proc.id}\``,
+                    '',
+                    `- **PID:** ${proc.pid}`,
+                    `- **Status:** ${proc.status}`,
+                    `- **Command:** \`${proc.command}\``,
+                    `- **Started:** ${proc.startedAt.toISOString()}`,
+                    proc.endedAt ? `- **Ended:** ${proc.endedAt.toISOString()}` : null,
+                    proc.exitCode !== null ? `- **Exit Code:** ${proc.exitCode}` : null,
+                    '',
+                    proc.stdout ? `**Stdout (last 200 chars):**\n\`\`\`\n${proc.stdout.slice(-200)}\n\`\`\`` : null,
+                    proc.stderr ? `**Stderr (last 200 chars):**\n\`\`\`\n${proc.stderr.slice(-200)}\n\`\`\`` : null,
+                ].filter(Boolean);
+
+                uiEvents.addSystemMessage(lines.join('\n'));
+                break;
+            }
+
+            default:
+                uiEvents.addErrorMessage(`Unknown subcommand: \`${subcommand}\`\n\n**Usage:** \`/bg [list|kill <id>|killall|show <id>]\``);
+        }
+    }
+};
+
+function formatDuration(startedAt, endedAt) {
+    const end = endedAt ? new Date(endedAt) : new Date();
+    const start = new Date(startedAt);
+    const diffMs = end - start;
+
+    if (diffMs < 1000) return `${diffMs}ms`;
+    if (diffMs < 60000) return `${Math.round(diffMs / 1000)}s`;
+    if (diffMs < 3600000) return `${Math.round(diffMs / 60000)}m`;
+    return `${Math.round(diffMs / 3600000)}h`;
+}

package/src/commands/commands.js

@@ -0,0 +1,56 @@
+import { uiEvents } from '../system/ui_events.js';
+import {
+    formatCustomCommandList,
+    findCustomCommandByName
+} from '../system/custom_command_loader.js';
+
+/**
+ * /commands 커맨드 - 커스텀 커맨드 목록 조회 및 정보 확인
+ *
+ * 사용법:
+ *   /commands           - 모든 커스텀 커맨드 목록 표시
+ *   /commands <name>    - 특정 커맨드 상세 정보 표시
+ */
+export default {
+    name: 'commands',
+    description: 'List custom commands or show command details',
+    usage: '/commands [command-name]',
+    handler: async (args, context) => {
+        if (!args || args.length === 0) {
+            // 커맨드 목록 표시
+            const commandList = await formatCustomCommandList();
+            uiEvents.addSystemMessage(commandList);
+            return;
+        }
+
+        // 특정 커맨드 정보 표시
+        const commandName = args[0];
+        const command = await findCustomCommandByName(commandName);
+
+        if (!command) {
+            uiEvents.addSystemMessage(`Custom command not found: \`${commandName}\`\n\nUse \`/commands\` to see available commands.`);
+            return;
+        }
+
+        const info = [
+            `## Command: \`${command.name}\``,
+            '',
+            `- **Source:** ${command.source}`,
+            `- **Path:** \`${command.path}\``,
+            command.argumentHint ? `- **Argument Hint:** ${command.argumentHint}` : null,
+            command.disableModelInvocation ? '- **Model Invocation:** Disabled (manual only)' : null,
+            '',
+            '### Frontmatter',
+            '```json',
+            JSON.stringify(command.frontmatter, null, 2),
+            '```',
+            '',
+            '### Content Preview',
+            '```',
+            command.content.substring(0, 500) + (command.content.length > 500 ? '...' : ''),
+            '```'
+        ].filter(Boolean).join('\n');
+
+        uiEvents.addSystemMessage(info);
+    }
+};

package/src/commands/debug.js

@@ -0,0 +1,54 @@
+import { uiEvents } from '../system/ui_events.js';
+import { loadSettings, saveSettings, SETTINGS_FILE } from '../util/config.js';
+
+/**
+ * /debug 커맨드 - API 요청/응답 내용 표시 설정
+ *
+ * 사용법:
+ *   /debug         - 현재 설정 상태 표시
+ *   /debug on      - API payload 표시 켜기
+ *   /debug off     - API payload 표시 끄기
+ */
+export default {
+    name: 'debug',
+    description: 'Toggle API request/response payload display',
+    usage: '/debug [on|off]',
+    handler: async (args, context) => {
+        const settings = await loadSettings();
+        const currentValue = settings?.SHOW_API_PAYLOAD === true;
+
+        if (!args || args.length === 0) {
+            // 현재 상태 표시
+            const status = currentValue ? '**ON**' : '**OFF**';
+            const message = [
+                '## API Payload Display',
+                '',
+                `**Status:** ${status}`,
+                '',
+                '### Usage',
+                '- `/debug` - Show current status',
+                '- `/debug on` - Enable API payload display',
+                '- `/debug off` - Disable API payload display',
+                '',
+                `**Settings file:** \`${SETTINGS_FILE}\``
+            ].join('\n');
+
+            uiEvents.addSystemMessage(message);
+            return;
+        }
+
+        const action = args[0]?.toLowerCase();
+
+        if (action === 'on' || action === 'true' || action === '1') {
+            settings.SHOW_API_PAYLOAD = true;
+            await saveSettings(settings);
+            uiEvents.addSystemMessage('API Payload Display: **ON**\n\nAI request/response content will now be displayed.');
+        } else if (action === 'off' || action === 'false' || action === '0') {
+            settings.SHOW_API_PAYLOAD = false;
+            await saveSettings(settings);
+            uiEvents.addSystemMessage('API Payload Display: **OFF**\n\nAI request/response content will be hidden.');
+        } else {
+            uiEvents.addSystemMessage(`Unknown option: \`${action}\`\n\n**Usage:** \`/debug [on|off]\``);
+        }
+    }
+};

package/src/commands/exit.js

@@ -0,0 +1,19 @@
+import { performExit } from '../util/exit_handler.js';
+
+/**
+ * /exit 커맨드 - 프로그램 종료
+ */
+export default {
+    name: 'exit',
+    description: 'Exit the program',
+    usage: '/exit',
+    handler: async (args, context) => {
+        const { mcpIntegration, uiInstance } = context;
+
+        await performExit({
+            mcpIntegration,
+            uiInstance,
+            showMessages: true
+        });
+    }
+};

package/src/commands/help.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import { uiEvents } from '../system/ui_events.js';
+import { renderInkComponent } from '../frontend/utils/renderInkComponent.js';
+import { HelpView } from '../frontend/components/HelpView.js';
+import { discoverAllCustomCommands } from '../system/custom_command_loader.js';
+import { discoverAllSkills } from '../system/skill_loader.js';
+
+/**
+ * /help 커맨드 - 사용 가능한 커맨드 목록 표시
+ */
+export default {
+    name: 'help',
+    description: 'Show available commands',
+    usage: '/help',
+    handler: async (args, context) => {
+        const { commandRegistry } = context;
+
+        const commands = commandRegistry.getCommands();
+
+        // 커스텀 커맨드 로드
+        const customCommands = await discoverAllCustomCommands();
+
+        // 스킬 로드
+        const skills = await discoverAllSkills();
+
+        const component = React.createElement(HelpView, {
+            commands,
+            customCommands,
+            skills
+        });
+
+        const output = await renderInkComponent(component);
+        uiEvents.addSystemMessage(output);
+    }
+};

package/src/commands/mcp.js

@@ -0,0 +1,128 @@
+import { uiEvents } from '../system/ui_events.js';
+import chalk from 'chalk';
+
+/**
+ * /mcp 커맨드 - AI Agent 세션 내에서 MCP 서버 상태 조회
+ *
+ * AI Agent 실행 중 사용자가 입력하는 대화형 명령어
+ * 현재 연결된 MCP 서버 목록과 사용 가능한 도구들을 표시
+ *
+ * 사용법:
+ *   /mcp              - 모든 MCP 서버 목록 표시
+ *   /mcp <서버이름>   - 특정 서버의 도구 목록 상세 표시
+ */
+export default {
+    name: 'mcp',
+    description: 'Show connected MCP servers, tools, and configuration',
+    usage: '/mcp [server-name]',
+    handler: async (args, context) => {
+        const { mcpIntegration } = context;
+
+        // MCP Integration이 초기화되지 않은 경우 (설정된 서버가 없거나 초기화 실패)
+        if (!mcpIntegration) {
+            uiEvents.addSystemMessage('MCP Integration not available');
+            return;
+        }
+
+        // 현재 연결된 MCP 서버 목록 조회
+        const servers = mcpIntegration.getConnectedServers();
+
+        if (servers.length === 0) {
+            uiEvents.addSystemMessage('No MCP servers configured');
+            uiEvents.addSystemMessage('Use CLI: aiexecode mcp add --transport stdio <name> -- <cmd>');
+            return;
+        }
+
+        // 인자로 특정 서버 이름이 전달된 경우 해당 서버 상세 정보 표시
+        const serverName = args[0];
+        if (serverName) {
+            showServerDetail(mcpIntegration, servers, serverName);
+        } else {
+            // 인자 없이 /mcp만 입력한 경우 전체 서버 목록 표시
+            showServerList(servers);
+        }
+    }
+};
+
+/**
+ * 연결된 모든 MCP 서버 목록을 간략하게 표시
+ */
+function showServerList(servers) {
+    let output = '# MCP Servers\n\n';
+
+    servers.forEach(server => {
+        const statusIcon = server.status === 'connected' ? '✓' : '✗';
+        const statusText = server.status === 'connected' ? 'Connected' : 'Disconnected';
+        output += `- **${server.name}** ${statusIcon} ${statusText} • ${server.toolCount} tools\n`;
+    });
+
+    output += '\n> Use `/mcp <server-name>` to see tools';
+
+    uiEvents.addSystemMessage(output);
+}
+
+/**
+ * 특정 MCP 서버의 상세 정보 및 도구 목록 표시
+ * 각 도구의 이름, 설명, 필수/선택 파라미터 정보 포함
+ */
+function showServerDetail(mcpIntegration, servers, serverName) {
+    const server = servers.find(s => s.name === serverName);
+
+    if (!server) {
+        uiEvents.addSystemMessage(`Server '${serverName}' not found`);
+        return;
+    }
+
+    // 전체 도구 스키마 조회
+    const toolSchemas = mcpIntegration.getToolSchemas();
+
+    // 설명 문자열에서 서버 이름을 추출하여 해당 서버의 도구만 필터링
+    // 형식: "[서버이름 MCP] - 설명"
+    const serverTools = toolSchemas.filter(tool => {
+        const match = tool.description?.match(/^\[(.+?) MCP\]/);
+        return match && match[1] === serverName;
+    });
+
+    const statusIcon = server.status === 'connected' ? '✓' : '✗';
+    const statusText = server.status === 'connected' ? 'Connected' : 'Disconnected';
+
+    let output = `# ${server.name}\n\n`;
+    output += `**Status:** ${statusIcon} ${statusText}\n`;
+    output += `**Tools:** ${serverTools.length}\n\n`;
+
+    if (serverTools.length > 0) {
+        output += '## Available Tools\n\n';
+
+        serverTools.forEach((tool, idx) => {
+            // 도구 설명에서 "[서버이름 MCP] - " 접두사 제거
+            const desc = tool.description?.replace(/^\[.+?\] - /, '') || '';
+            output += `### ${idx + 1}. \`${tool.name}\`\n\n`;
+
+            if (desc) {
+                output += `${desc}\n\n`;
+            }
+
+            // 도구의 파라미터 정보 표시
+            const params = tool.parameters?.properties || {};
+            const required = tool.parameters?.required || [];
+            const paramNames = Object.keys(params);
+
+            if (paramNames.length > 0) {
+                const requiredParams = paramNames.filter(p => required.includes(p));
+                const optionalParams = paramNames.filter(p => !required.includes(p));
+
+                if (requiredParams.length > 0) {
+                    output += `**Required:** \`${requiredParams.join('`, `')}\`\n`;
+                }
+                if (optionalParams.length > 0) {
+                    output += `**Optional:** \`${optionalParams.join('`, `')}\`\n`;
+                }
+            }
+
+            output += '\n';
+        });
+    }
+
+    // UI 시스템에 메시지 전달하여 사용자에게 표시
+    uiEvents.addSystemMessage(output);
+}

package/src/commands/model.js

@@ -0,0 +1,176 @@
+import React from 'react';
+import { uiEvents } from '../system/ui_events.js';
+import { loadSettings, saveSettings, SETTINGS_FILE, getDefaultBaseUrlForProvider } from '../util/config.js';
+import { resetAIClients } from '../system/ai_request.js';
+import { AI_MODELS, getModelsByProvider, DEFAULT_MODEL, ENABLED_PROVIDERS, isModelEnabled } from '../config/ai_models.js';
+import { renderInkComponent } from '../frontend/utils/renderInkComponent.js';
+import { ModelListView } from '../frontend/components/ModelListView.js';
+import { CurrentModelView } from '../frontend/components/CurrentModelView.js';
+import { ModelUpdatedView } from '../frontend/components/ModelUpdatedView.js';
+
+// 모델 ID로 provider 찾기
+function getProviderForModel(modelId) {
+    const modelInfo = AI_MODELS[modelId];
+    return modelInfo ? modelInfo.provider : null;
+}
+
+// 모든 모델 목록 표시 (공식 지원 provider만)
+async function listAllModels() {
+    // 공식 지원 provider만 사용
+    const providers = ENABLED_PROVIDERS;
+
+    // provider별로 모델 그룹화
+    const modelsByProvider = {};
+    providers.forEach(provider => {
+        const modelIds = getModelsByProvider(provider);
+        modelsByProvider[provider] = modelIds.map(id => ({
+            id,
+            ...AI_MODELS[id]
+        }));
+    });
+
+    const component = React.createElement(ModelListView, {
+        modelsByProvider
+    });
+
+    const output = await renderInkComponent(component);
+    return output;
+}
+
+// 현재 설정된 모델 표시
+async function showCurrentModel() {
+    try {
+        const settings = await loadSettings();
+        const currentModel = settings?.MODEL || DEFAULT_MODEL;
+        const modelInfo = AI_MODELS[currentModel];
+        const provider = modelInfo?.provider || 'unknown';
+
+        const component = React.createElement(CurrentModelView, {
+            provider,
+            modelId: currentModel,
+            modelInfo
+        });
+
+        const output = await renderInkComponent(component);
+        return output;
+    } catch (error) {
+        return `Failed to retrieve current model information: ${error.message}`;
+    }
+}
+
+/**
+ * /model 커맨드 - AI 모델 선택
+ */
+export default {
+    name: 'model',
+    description: 'Select AI model',
+    usage: '/model [model-id] or /model list',
+    handler: async (args, context) => {
+        // 인자가 없으면 현재 모델 표시
+        if (!args || args.length === 0) {
+            const message = await showCurrentModel();
+            uiEvents.addSystemMessage(message);
+            return;
+        }
+
+        const command = args[0].toLowerCase();
+
+        // list 명령어
+        if (command === 'list' || command === 'ls') {
+            const message = await listAllModels();
+            uiEvents.addSystemMessage(message);
+            return;
+        }
+
+        // 모델 선택
+        const modelId = args[0];
+        const provider = getProviderForModel(modelId);
+
+        if (!provider) {
+            uiEvents.addSystemMessage(
+                `Unsupported model: ${modelId}\n\n` +
+                `Use \`/model list\` to see available models.`
+            );
+            return;
+        }
+
+        // 공식 지원 provider 확인
+        if (!isModelEnabled(modelId)) {
+            uiEvents.addSystemMessage(
+                `Model not available: ${modelId}\n\n` +
+                `This model is not officially supported.\n` +
+                `Use \`/model list\` to see available models.`
+            );
+            return;
+        }
+
+        try {
+            // 현재 설정 로드
+            const settings = await loadSettings();
+
+            // 모델 업데이트
+            settings.MODEL = modelId;
+            process.env.MODEL = modelId;
+
+            // Provider별 BASE_URL 자동 설정
+            const defaultBaseUrl = getDefaultBaseUrlForProvider(provider);
+            if (defaultBaseUrl) {
+                // Z.AI 등 특정 provider는 BASE_URL 자동 설정
+                settings.BASE_URL = defaultBaseUrl;
+                process.env.BASE_URL = defaultBaseUrl;
+            } else if (provider !== 'zai') {
+                // 다른 provider로 변경 시 BASE_URL 초기화 (Z.AI에서 다른 모델로 변경)
+                if (settings.BASE_URL === 'https://api.z.ai/api/anthropic') {
+                    settings.BASE_URL = '';
+                    delete process.env.BASE_URL;
+                }
+            }
+
+            // 설정 저장
+            await saveSettings(settings);
+
+            // AI 클라이언트 캐시 초기화 (다음 요청 시 새 설정 적용)
+            resetAIClients();
+
+            // UI 모델 표시 업데이트
+            uiEvents.emit('model:changed', { model: modelId });
+
+            // 성공 메시지
+            const modelInfo = AI_MODELS[modelId];
+
+            // Provider별 경고 메시지 구성
+            let warning = null;
+            if (!settings.API_KEY) {
+                // Provider별 API 키 안내 (공식 지원 provider만)
+                const apiKeyHints = {
+                    'zai': 'Set your Z.AI API key with: `/apikey <your-key>`'
+                };
+                warning = {
+                    message: 'API key is not configured.',
+                    hint: apiKeyHints[provider] || 'Set your API key with: `/apikey <your-key>`'
+                };
+            } else if (provider === 'zai') {
+                // Z.AI 모델 선택 시 추가 안내
+                warning = {
+                    message: `BASE_URL automatically set to: ${defaultBaseUrl}`,
+                    hint: 'Ensure your API key is valid for Z.AI service.'
+                };
+            }
+
+            const component = React.createElement(ModelUpdatedView, {
+                provider,
+                modelId,
+                modelInfo,
+                settingsFile: SETTINGS_FILE,
+                warning
+            });
+
+            const message = await renderInkComponent(component);
+            uiEvents.addSystemMessage(message);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            uiEvents.addErrorMessage(`Failed to update model: ${errorMessage}`);
+        }
+    }
+};
+