aiexecode 1.0.94 → 1.0.98

package/src/system/custom_command_loader.js

@@ -0,0 +1,386 @@
+/**
+ * Custom Command Loader
+ *
+ * Claude Code 스타일의 Custom Commands 시스템 구현
+ * 단일 마크다운 파일로 커맨드를 정의합니다.
+ *
+ * 커맨드 위치 (우선순위 순):
+ * 1. Project: CWD/.aiexe/commands/<command-name>.md
+ * 2. Personal: ~/.aiexe/commands/<command-name>.md
+ *
+ * 사용 예:
+ *   ~/.aiexe/commands/review.md → /review 커맨드
+ *   .aiexe/commands/deploy.md → /deploy 커맨드
+ */
+
+import { join, basename } from 'path';
+import { safeReadFile, safeReaddir, safeStat, safeAccess } from '../util/safe_fs.js';
+import { PERSONAL_COMMANDS_DIR, PROJECT_COMMANDS_DIR } from '../util/config.js';
+import { createDebugLogger } from '../util/debug_log.js';
+
+const debugLog = createDebugLogger('custom_command_loader.log', 'custom_command');
+
+/**
+ * 커맨드 정보 객체
+ * @typedef {Object} CustomCommand
+ * @property {string} name - 커맨드 이름 (파일명 또는 frontmatter의 name)
+ * @property {string} description - 커맨드 설명
+ * @property {string} path - 마크다운 파일 경로
+ * @property {string} source - 'project' | 'personal'
+ * @property {Object} frontmatter - YAML frontmatter 파싱 결과
+ * @property {string} content - 마크다운 내용 (frontmatter 제외)
+ * @property {string} [argumentHint] - 인자 힌트 (예: "[filename]")
+ * @property {boolean} disableModelInvocation - AI 자동 호출 비활성화 여부
+ */
+
+/**
+ * YAML frontmatter를 파싱합니다.
+ * @param {string} content - 마크다운 파일 내용
+ * @returns {{ frontmatter: Object, content: string }}
+ */
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+
+    if (!match) {
+        return {
+            frontmatter: {},
+            content: content.trim()
+        };
+    }
+
+    const yamlContent = match[1];
+    const markdownContent = match[2];
+
+    // 간단한 YAML 파싱 (key: value 형식만 지원)
+    const frontmatter = {};
+    const lines = yamlContent.split('\n');
+
+    for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.substring(0, colonIndex).trim();
+            let value = line.substring(colonIndex + 1).trim();
+
+            // 따옴표 제거
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+
+            // boolean 변환
+            if (value === 'true') value = true;
+            else if (value === 'false') value = false;
+
+            frontmatter[key] = value;
+        }
+    }
+
+    return {
+        frontmatter,
+        content: markdownContent.trim()
+    };
+}
+
+/**
+ * 단일 커맨드 파일을 로드합니다.
+ * @param {string} filePath - 마크다운 파일 경로
+ * @param {string} source - 'project' | 'personal'
+ * @returns {Promise<CustomCommand|null>}
+ */
+async function loadCommandFromFile(filePath, source) {
+    try {
+        const content = await safeReadFile(filePath, 'utf8');
+        const { frontmatter, content: markdownContent } = parseFrontmatter(content);
+
+        // 파일명에서 .md 제거하여 커맨드 이름 추출
+        const fileName = basename(filePath);
+        const nameFromFile = fileName.replace(/\.md$/i, '');
+        const name = frontmatter.name || nameFromFile;
+
+        // description이 없으면 마크다운 첫 단락 사용
+        let description = frontmatter.description;
+        if (!description && markdownContent) {
+            const firstParagraph = markdownContent.split('\n\n')[0];
+            description = firstParagraph.replace(/^#.*\n?/, '').trim().substring(0, 200);
+        }
+
+        const command = {
+            name,
+            description: description || '',
+            path: filePath,
+            source,
+            frontmatter,
+            content: markdownContent,
+            argumentHint: frontmatter['argument-hint'] || frontmatter.argumentHint || null,
+            disableModelInvocation: frontmatter['disable-model-invocation'] === true
+        };
+
+        debugLog(`[loadCommandFromFile] Loaded command: ${name} from ${source}`);
+        return command;
+    } catch (error) {
+        debugLog(`[loadCommandFromFile] Error loading command from ${filePath}: ${error.message}`);
+        return null;
+    }
+}
+
+/**
+ * 지정된 디렉토리에서 모든 커맨드를 검색합니다.
+ * @param {string} commandsDir - 커맨드 폴더 경로
+ * @param {string} source - 'project' | 'personal'
+ * @returns {Promise<CustomCommand[]>}
+ */
+async function discoverCommandsInDirectory(commandsDir, source) {
+    const commands = [];
+
+    try {
+        await safeAccess(commandsDir);
+    } catch {
+        debugLog(`[discoverCommandsInDirectory] Commands directory not found: ${commandsDir}`);
+        return commands;
+    }
+
+    try {
+        const entries = await safeReaddir(commandsDir);
+
+        for (const entry of entries) {
+            // .md 파일만 처리
+            if (!entry.endsWith('.md')) continue;
+
+            const entryPath = join(commandsDir, entry);
+            const stat = await safeStat(entryPath);
+
+            if (stat.isFile()) {
+                const command = await loadCommandFromFile(entryPath, source);
+                if (command) {
+                    commands.push(command);
+                }
+            }
+        }
+    } catch (error) {
+        debugLog(`[discoverCommandsInDirectory] Error scanning ${commandsDir}: ${error.message}`);
+    }
+
+    return commands;
+}
+
+/**
+ * 모든 커스텀 커맨드를 검색합니다.
+ * Project 커맨드가 Personal 커맨드보다 우선순위가 높습니다.
+ * @returns {Promise<CustomCommand[]>}
+ */
+export async function discoverAllCustomCommands() {
+    debugLog('[discoverAllCustomCommands] Starting command discovery...');
+
+    const allCommands = new Map(); // name -> command (중복 방지, 우선순위 적용)
+
+    // 1. Personal commands (낮은 우선순위)
+    const personalCommands = await discoverCommandsInDirectory(PERSONAL_COMMANDS_DIR, 'personal');
+    for (const command of personalCommands) {
+        allCommands.set(command.name, command);
+    }
+    debugLog(`[discoverAllCustomCommands] Found ${personalCommands.length} personal commands`);
+
+    // 2. Project commands (높은 우선순위 - 덮어씀)
+    const projectCommandsDir = join(process.cwd(), PROJECT_COMMANDS_DIR);
+    const projectCommands = await discoverCommandsInDirectory(projectCommandsDir, 'project');
+    for (const command of projectCommands) {
+        allCommands.set(command.name, command);
+    }
+    debugLog(`[discoverAllCustomCommands] Found ${projectCommands.length} project commands`);
+
+    const commands = Array.from(allCommands.values());
+    debugLog(`[discoverAllCustomCommands] Total unique commands: ${commands.length}`);
+
+    return commands;
+}
+
+/**
+ * 이름으로 커스텀 커맨드를 찾습니다.
+ * @param {string} commandName - 커맨드 이름
+ * @returns {Promise<CustomCommand|null>}
+ */
+export async function findCustomCommandByName(commandName) {
+    debugLog(`[findCustomCommandByName] Looking for command: ${commandName}`);
+
+    // Project 커맨드 먼저 확인 (높은 우선순위)
+    const projectCommandPath = join(process.cwd(), PROJECT_COMMANDS_DIR, `${commandName}.md`);
+    try {
+        await safeAccess(projectCommandPath);
+        const command = await loadCommandFromFile(projectCommandPath, 'project');
+        if (command) {
+            debugLog(`[findCustomCommandByName] Found project command: ${commandName}`);
+            return command;
+        }
+    } catch {
+        // Project command not found, try personal
+    }
+
+    // Personal 커맨드 확인
+    const personalCommandPath = join(PERSONAL_COMMANDS_DIR, `${commandName}.md`);
+    try {
+        await safeAccess(personalCommandPath);
+        const command = await loadCommandFromFile(personalCommandPath, 'personal');
+        if (command) {
+            debugLog(`[findCustomCommandByName] Found personal command: ${commandName}`);
+            return command;
+        }
+    } catch {
+        // Personal command not found
+    }
+
+    debugLog(`[findCustomCommandByName] Command not found: ${commandName}`);
+    return null;
+}
+
+/**
+ * 커맨드 내용에서 $ARGUMENTS를 실제 인자로 치환합니다.
+ * @param {string} content - 커맨드 마크다운 내용
+ * @param {string} args - 사용자가 전달한 인자
+ * @returns {string}
+ */
+export function substituteArguments(content, args) {
+    if (!args) return content;
+
+    // $ARGUMENTS 치환
+    let result = content.replace(/\$ARGUMENTS/g, args);
+
+    // ${CLAUDE_SESSION_ID} 등 환경변수 치환
+    result = result.replace(/\$\{([A-Z_][A-Z0-9_]*)\}/g, (match, varName) => {
+        return process.env[varName] || match;
+    });
+
+    // $ARGUMENTS가 없었으면 끝에 추가
+    if (result === content && args.trim()) {
+        result = content + '\n\nARGUMENTS: ' + args;
+    }
+
+    return result;
+}
+
+/**
+ * 쉘 명령어 플레이스홀더를 실행하고 결과로 치환합니다.
+ * 형식: !`command`
+ * @param {string} content - 커맨드 내용
+ * @returns {Promise<string>}
+ */
+export async function executeShellPlaceholders(content) {
+    const shellRegex = /!\`([^`]+)\`/g;
+    const matches = [...content.matchAll(shellRegex)];
+
+    if (matches.length === 0) {
+        return content;
+    }
+
+    let result = content;
+
+    for (const match of matches) {
+        const fullMatch = match[0];
+        const command = match[1];
+
+        try {
+            const { execSync } = await import('child_process');
+            const output = execSync(command, {
+                encoding: 'utf8',
+                timeout: 30000,
+                maxBuffer: 1024 * 1024
+            }).trim();
+
+            result = result.replace(fullMatch, output);
+            debugLog(`[executeShellPlaceholders] Executed: ${command}`);
+        } catch (error) {
+            debugLog(`[executeShellPlaceholders] Failed to execute: ${command} - ${error.message}`);
+            result = result.replace(fullMatch, `[Error executing: ${command}]`);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * 커스텀 커맨드를 로드하고 프롬프트로 변환합니다.
+ * @param {string} commandName - 커맨드 이름
+ * @param {string} [args] - 커맨드에 전달할 인자
+ * @returns {Promise<{ prompt: string, command: CustomCommand } | null>}
+ */
+export async function loadCustomCommandAsPrompt(commandName, args = '') {
+    const command = await findCustomCommandByName(commandName);
+    if (!command) {
+        return null;
+    }
+
+    let prompt = command.content;
+
+    // 인자 치환
+    prompt = substituteArguments(prompt, args);
+
+    // 쉘 명령어 실행 및 치환
+    prompt = await executeShellPlaceholders(prompt);
+
+    debugLog(`[loadCustomCommandAsPrompt] Loaded command '${commandName}' with ${args ? 'args' : 'no args'}`);
+
+    return {
+        prompt,
+        command
+    };
+}
+
+/**
+ * 커스텀 커맨드 목록을 포맷팅하여 반환합니다.
+ * @returns {Promise<string>}
+ */
+export async function formatCustomCommandList() {
+    const commands = await discoverAllCustomCommands();
+
+    if (commands.length === 0) {
+        return [
+            'No custom commands found.',
+            '',
+            'Command locations:',
+            `  Personal: ~/.aiexe/commands/<command-name>.md`,
+            `  Project:  .aiexe/commands/<command-name>.md`,
+            '',
+            'Create a command by making a .md file with optional YAML frontmatter.',
+            '',
+            'Example (~/.aiexe/commands/review.md):',
+            '---',
+            'name: review',
+            'description: Review code for best practices',
+            'argument-hint: [filename]',
+            '---',
+            '',
+            'Review the following code for best practices:',
+            '$ARGUMENTS'
+        ].join('\n');
+    }
+
+    const lines = ['Custom Commands:', ''];
+
+    // 소스별 그룹화
+    const projectCommands = commands.filter(c => c.source === 'project');
+    const personalCommands = commands.filter(c => c.source === 'personal');
+
+    if (projectCommands.length > 0) {
+        lines.push('Project Commands (.aiexe/commands/):');
+        for (const cmd of projectCommands) {
+            const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : '';
+            const desc = cmd.description ? ` - ${cmd.description.substring(0, 50)}` : '';
+            lines.push(`  /${cmd.name}${hint}${desc}`);
+        }
+        lines.push('');
+    }
+
+    if (personalCommands.length > 0) {
+        lines.push('Personal Commands (~/.aiexe/commands/):');
+        for (const cmd of personalCommands) {
+            const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : '';
+            const desc = cmd.description ? ` - ${cmd.description.substring(0, 50)}` : '';
+            lines.push(`  /${cmd.name}${hint}${desc}`);
+        }
+        lines.push('');
+    }
+
+    lines.push('Usage: /<command-name> [arguments]');
+
+    return lines.join('\n');
+}

package/src/system/session.js

@@ -9,6 +9,7 @@ import { CODE_EDITOR_FUNCTIONS } from "../tools/code_editor.js";
 import { WEB_DOWNLOADER_FUNCTIONS } from "../tools/web_downloader.js";
 import { RESPONSE_MESSAGE_FUNCTIONS } from '../tools/response_message.js';
 import { TODO_WRITE_FUNCTIONS } from '../tools/todo_write.js';
+import { SKILL_FUNCTIONS } from '../tools/skill_tool.js';
 import { clampOutput, formatToolStdout } from "../util/output_formatter.js";
 import { buildToolHistoryEntry } from "../util/rag_helper.js";
 import { createSessionData, getLastConversationState, loadPreviousSessions, saveSessionToHistory, saveTodosToSession, restoreTodosFromSession, updateCurrentTodos, getCurrentTodos } from "./session_memory.js";
@@ -21,16 +22,14 @@ import { safeReadFile } from '../util/safe_fs.js';
 import { resolve } from 'path';
 import { createDebugLogger } from '../util/debug_log.js';
 import { ERROR_VERBOSITY } from '../config/feature_flags.js';
+import {
+    MAX_REASONING_ONLY_RESPONSES,
+    DEFAULT_MAX_ITERATIONS,
+    SUB_MISSION_MAX_LENGTH
+} from '../config/constants.js';
 
 const debugLog = createDebugLogger('session.log', 'session');
 
-/**
- * 상수 정의
- */
-const MAX_REASONING_ONLY_RESPONSES = 5;
-const DEFAULT_MAX_ITERATIONS = 50;
-const SUB_MISSION_MAX_LENGTH = 120;
-
 
 /**
  * 서브미션 이름을 추론하는 헬퍼 함수
@@ -391,6 +390,9 @@ async function processOrchestratorResponses(params) {
         );
         debugLog(`Has processable output: ${hasProcessableOutput}`);
 
+        // pendingMessageOutput은 while 루프 스코프에서 유지 (function call 없이 끝날 때 출력용)
+        let pendingMessageOutput = null;
+
         if (!hasProcessableOutput) {
             debugLog(`No processable output, reasoningOnlyResponses: ${reasoningOnlyResponses}`);
             if (reasoningOnlyResponses >= MAX_REASONING_ONLY_RESPONSES) {
@@ -419,7 +421,6 @@ async function processOrchestratorResponses(params) {
         reasoningOnlyResponses = 0;
         let executedFunctionCall = false;
         let lastOutputType = null;
-        let pendingMessageOutput = null; // 출력 대기 중인 MESSAGE 저장
 
         // 각 출력 처리
         for (let outputIndex = 0; outputIndex < outputs.length; outputIndex++) {
@@ -598,8 +599,33 @@ async function processOrchestratorResponses(params) {
 
         // 완료 조건 체크
         debugLog(`Checking completion conditions...`);
-        if (!executedFunctionCall && lastOutputType === 'message') {
-            debugLog(`COMPLETION: No function call + message type - judging if mission is truly complete`);
+        debugLog(`  executedFunctionCall: ${executedFunctionCall}, hadAnyFunctionCall: ${hadAnyFunctionCall}, lastOutputType: ${lastOutputType}`);
+
+        // Case 1: Function call 없이 message만 있는 경우 (단순 대화, 인사 등)
+        // → Completion Judge 없이 바로 message 출력하고 완료
+        if (!executedFunctionCall && lastOutputType === 'message' && !hadAnyFunctionCall) {
+            debugLog(`COMPLETION: No function call at all + message type - completing immediately without Completion Judge`);
+
+            // 대기 중인 메시지 출력
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message immediately`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
+
+            missionSolved = true;
+            break;
+        }
+
+        // Case 2: Function call 실행 후 message로 결과 보고
+        // → message 먼저 출력 → Completion Judge로 추가 작업 판단
+        if (!executedFunctionCall && lastOutputType === 'message' && hadAnyFunctionCall) {
+            debugLog(`COMPLETION: Had function calls + final message - displaying message first, then judging completion`);
+
+            // 먼저 message 출력 (사용자가 바로 결과 확인 가능)
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message before completion judge`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
 
             // 세션 중단 확인 (completion_judge 호출 전)
             if (sessionInterrupted) {
@@ -646,45 +672,30 @@ async function processOrchestratorResponses(params) {
             missionSolved = judgement.shouldComplete;
 
             if (missionSolved) {
-                // 미션이 완료되었다고 판단되면 대기 중인 메시지 출력 후 종료
-                debugLog(`Mission judged as complete, displaying pending message and breaking loop`);
-                if (pendingMessageOutput) {
-                    processMessageOutput(pendingMessageOutput, true); // 이제 출력
-                }
+                // 미션이 완료되었다고 판단 (message는 이미 출력됨)
+                debugLog(`Mission judged as complete, breaking loop`);
                 break;
             } else {
-                // 미션이 완료되지 않았다고 판단되면 메시지를 출력하지 않고 계속 진행
-                debugLog(`Mission not complete, continuing without displaying message`);
-
-                // orchestratorConversation에서 방금 추가된 assistant message에 _internal_only 플래그 추가
-                const conversation = getOrchestratorConversation();
-                for (let i = conversation.length - 1; i >= 0; i--) {
-                    const entry = conversation[i];
-                    if (entry.type === 'message' && entry.role === 'assistant') {
-                        entry._internal_only = true;
-                        debugLog(`[_internal_only] Marked assistant message at index ${i} as internal-only (not for display)`);
-                        break;
-                    }
-                }
+                // 미션이 완료되지 않았다고 판단되면 계속 진행
+                // (message는 이미 출력됨 - 사용자가 진행 상황 확인 가능)
+                debugLog(`Mission not complete, continuing...`);
 
                 // whatUserShouldSay를 새로운 사용자 요구사항으로 처리
                 if (judgement.whatUserShouldSay && judgement.whatUserShouldSay.trim().length > 0) {
                     debugLog(`Treating whatUserShouldSay as new user request: ${judgement.whatUserShouldSay}`);
-                    // 💬 Auto-continuing 메시지 제거
 
                     // whatUserShouldSay를 새로운 mission으로 설정하여 루프를 빠져나감
-                    // 상위 runSession 루프에서 다시 orchestrateMission이 호출될 것임
                     improvementPoints = judgement.whatUserShouldSay;
-                    improvementPointsIsAutoGenerated = true; // auto-generated 플래그 설정
+                    improvementPointsIsAutoGenerated = true;
                     debugLog(`[_internal_only] Set improvementPointsIsAutoGenerated=true for whatUserShouldSay`);
-                    missionSolved = false;  // 완료되지 않았으므로 상위 루프 계속
-                    break;  // processOrchestratorResponses 루프 종료
+                    missionSolved = false;
+                    break;
                 } else {
                     // whatUserShouldSay가 없으면 빈 문자열로 계속 진행
                     improvementPoints = "";
                     debugLog(`Continuing mission without whatUserShouldSay`);
 
-                    // 세션 중단 확인 (continueOrchestratorConversation 호출 전)
+                    // 세션 중단 확인
                     if (sessionInterrupted) {
                         debugLog(`Session interrupted before continueOrchestratorConversation, breaking loop`);
                         break;
@@ -693,7 +704,7 @@ async function processOrchestratorResponses(params) {
                     try {
                         orchestratedResponse = await continueOrchestratorConversation();
                         debugLog(`Received response with ${orchestratedResponse?.output?.length || 0} outputs`);
-                        continue; // 루프 처음으로 돌아가서 새 응답 처리
+                        continue;
                     } catch (err) {
                         if (err.name === 'AbortError' || sessionInterrupted) {
                             debugLog(`Conversation aborted or interrupted: ${err.name}`);
@@ -706,11 +717,23 @@ async function processOrchestratorResponses(params) {
             }
         }
 
+        // Case 3: Function call이 없는 기타 경우
         if (!executedFunctionCall) {
             debugLog(`COMPLETION: No function call executed (other cases), breaking loop`);
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message before completion`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
             break;
         }
 
+        // Function call 실행 후 계속 진행하기 전에 pending message가 있으면 출력
+        // (function_call과 message가 같이 온 경우)
+        if (pendingMessageOutput) {
+            debugLog(`Displaying pending message before continuing (function_call + message case)`);
+            processMessageOutput(pendingMessageOutput, true);
+        }
+
         // continueOrchestratorConversation 호출
         debugLog(`Continuing orchestrator conversation for next iteration...`);
         try {
@@ -899,6 +922,7 @@ export async function runSession(options) {
             ...GLOB_FUNCTIONS,
             ...RESPONSE_MESSAGE_FUNCTIONS,
             ...TODO_WRITE_FUNCTIONS,
+            ...SKILL_FUNCTIONS,  // 스킬 호출 도구
             ...mcpToolFunctions,
             "bash": async (args) => execShellScript(args.script)
         };