aiexecode 1.0.92 → 1.0.96

package/src/system/agents_loader.js

@@ -0,0 +1,289 @@
+/**
+ * AGENTS.md Loader
+ *
+ * AGENTS.md는 AI 코딩 에이전트를 위한 오픈 표준 포맷입니다.
+ * README.md가 인간을 위한 것이라면, AGENTS.md는 AI 에이전트를 위한 것입니다.
+ *
+ * 파일 위치 및 우선순위 (높은 순):
+ * 1. CWD/AGENTS.md - 현재 작업 디렉토리
+ * 2. CWD/.aiexe/AGENTS.md - 프로젝트별 설정
+ * 3. ~/.aiexe/AGENTS.md - 글로벌 설정
+ *
+ * 하위 디렉토리 지원:
+ * - 하위 디렉토리에 AGENTS.md가 있으면 해당 디렉토리 작업 시 추가로 로드
+ * - 가장 가까운 AGENTS.md가 우선순위를 가짐
+ *
+ * 참조: https://agents.md/
+ */
+
+import { join, dirname, resolve } from 'path';
+import { safeReadFile, safeAccess, safeStat } from '../util/safe_fs.js';
+import { CONFIG_DIR } from '../util/config.js';
+import { createDebugLogger } from '../util/debug_log.js';
+
+const debugLog = createDebugLogger('agents_loader.log', 'agents_loader');
+
+// AGENTS.md 파일명 (대소문자 구분)
+const AGENTS_MD_FILENAME = 'AGENTS.md';
+
+// 권장 최대 줄 수 (GitHub 분석 기반)
+const RECOMMENDED_MAX_LINES = 150;
+
+/**
+ * 파일이 존재하는지 확인합니다.
+ * @param {string} filePath - 확인할 파일 경로
+ * @returns {Promise<boolean>}
+ */
+async function fileExists(filePath) {
+    try {
+        await safeAccess(filePath);
+        const stat = await safeStat(filePath);
+        return stat.isFile();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * AGENTS.md 파일을 로드합니다.
+ * @param {string} filePath - AGENTS.md 파일 경로
+ * @returns {Promise<{path: string, content: string}|null>}
+ */
+async function loadAgentsMd(filePath) {
+    try {
+        if (!await fileExists(filePath)) {
+            return null;
+        }
+        const content = await safeReadFile(filePath, 'utf8');
+        const trimmedContent = content.trim();
+        const lineCount = trimmedContent.split('\n').length;
+
+        debugLog(`[loadAgentsMd] Loaded: ${filePath} (${trimmedContent.length} chars, ${lineCount} lines)`);
+
+        // 권장 크기 초과 시 경고
+        if (lineCount > RECOMMENDED_MAX_LINES) {
+            debugLog(`[loadAgentsMd] WARNING: ${filePath} has ${lineCount} lines (recommended: <=${RECOMMENDED_MAX_LINES})`);
+        }
+
+        return {
+            path: filePath,
+            content: trimmedContent,
+            lineCount
+        };
+    } catch (error) {
+        debugLog(`[loadAgentsMd] Error loading ${filePath}: ${error.message}`);
+        return null;
+    }
+}
+
+/**
+ * 디렉토리에서 상위로 올라가며 AGENTS.md를 찾습니다.
+ * @param {string} startDir - 시작 디렉토리
+ * @param {string} [stopAt] - 여기까지만 탐색 (기본: 루트)
+ * @returns {Promise<{path: string, content: string}|null>}
+ */
+async function findAgentsMdUpward(startDir, stopAt = '/') {
+    let currentDir = resolve(startDir);
+    const stopDir = resolve(stopAt);
+
+    while (currentDir && currentDir !== stopDir) {
+        const agentsMdPath = join(currentDir, AGENTS_MD_FILENAME);
+
+        const result = await loadAgentsMd(agentsMdPath);
+        if (result) {
+            return result;
+        }
+
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            break; // 루트에 도달
+        }
+        currentDir = parentDir;
+    }
+
+    return null;
+}
+
+/**
+ * 모든 관련 AGENTS.md 파일을 수집합니다.
+ * 우선순위 순서로 반환 (높은 우선순위가 먼저)
+ *
+ * @param {string} [cwd] - 현재 작업 디렉토리 (기본: process.cwd())
+ * @returns {Promise<Array<{path: string, content: string, source: string}>>}
+ */
+export async function discoverAllAgentsMd(cwd = process.cwd()) {
+    debugLog(`[discoverAllAgentsMd] Starting discovery from: ${cwd}`);
+
+    const results = [];
+
+    // 1. CWD/AGENTS.md (최고 우선순위)
+    const cwdAgentsMd = await loadAgentsMd(join(cwd, AGENTS_MD_FILENAME));
+    if (cwdAgentsMd) {
+        results.push({
+            ...cwdAgentsMd,
+            source: 'project'
+        });
+    }
+
+    // 2. CWD/.aiexe/AGENTS.md (프로젝트별 설정)
+    const projectAgentsMd = await loadAgentsMd(join(cwd, '.aiexe', AGENTS_MD_FILENAME));
+    if (projectAgentsMd) {
+        results.push({
+            ...projectAgentsMd,
+            source: 'project-config'
+        });
+    }
+
+    // 3. 상위 디렉토리 탐색 (CWD가 아닌 상위에서)
+    const parentAgentsMd = await findAgentsMdUpward(dirname(cwd));
+    if (parentAgentsMd && !results.some(r => r.path === parentAgentsMd.path)) {
+        results.push({
+            ...parentAgentsMd,
+            source: 'parent'
+        });
+    }
+
+    // 4. ~/.aiexe/AGENTS.md (글로벌 설정 - 가장 낮은 우선순위)
+    const globalAgentsMd = await loadAgentsMd(join(CONFIG_DIR, AGENTS_MD_FILENAME));
+    if (globalAgentsMd && !results.some(r => r.path === globalAgentsMd.path)) {
+        results.push({
+            ...globalAgentsMd,
+            source: 'global'
+        });
+    }
+
+    debugLog(`[discoverAllAgentsMd] Found ${results.length} AGENTS.md files`);
+    return results;
+}
+
+/**
+ * 특정 파일/디렉토리에 가장 가까운 AGENTS.md를 찾습니다.
+ * 하위 디렉토리 작업 시 해당 디렉토리의 AGENTS.md를 우선 사용
+ *
+ * @param {string} targetPath - 대상 파일 또는 디렉토리 경로
+ * @returns {Promise<{path: string, content: string}|null>}
+ */
+export async function findNearestAgentsMd(targetPath) {
+    const resolvedPath = resolve(targetPath);
+
+    // 파일인지 디렉토리인지 확인
+    let startDir;
+    try {
+        const stat = await safeStat(resolvedPath);
+        startDir = stat.isDirectory() ? resolvedPath : dirname(resolvedPath);
+    } catch {
+        startDir = dirname(resolvedPath);
+    }
+
+    debugLog(`[findNearestAgentsMd] Searching from: ${startDir}`);
+    return await findAgentsMdUpward(startDir);
+}
+
+/**
+ * AGENTS.md 내용을 시스템 프롬프트용 텍스트로 포맷팅합니다.
+ * @param {Array<{path: string, content: string, source: string}>} agentsMdFiles
+ * @returns {string}
+ */
+export function formatAgentsMdForPrompt(agentsMdFiles) {
+    if (!agentsMdFiles || agentsMdFiles.length === 0) {
+        return '';
+    }
+
+    const sections = [];
+
+    for (const file of agentsMdFiles) {
+        const sourceLabel = {
+            'project': 'Project Root',
+            'project-config': 'Project Config (.aiexe/)',
+            'parent': 'Parent Directory',
+            'global': 'Global (~/.aiexe/)'
+        }[file.source] || file.source;
+
+        sections.push(`## AGENTS.md (${sourceLabel})\n**Path:** ${file.path}\n\n${file.content}`);
+    }
+
+    return `\n\n# Agent Instructions (AGENTS.md)\n\n` +
+           `The following instructions are from AGENTS.md files in the project.\n` +
+           `These provide project-specific guidance for AI coding agents.\n\n` +
+           sections.join('\n\n---\n\n') +
+           '\n';
+}
+
+/**
+ * 현재 프로젝트의 AGENTS.md를 로드하고 포맷팅합니다.
+ * 시스템 프롬프트에 추가할 때 사용
+ *
+ * @param {string} [cwd] - 현재 작업 디렉토리
+ * @returns {Promise<string>} 포맷팅된 AGENTS.md 내용 (없으면 빈 문자열)
+ */
+export async function loadAgentsMdForPrompt(cwd = process.cwd()) {
+    const agentsMdFiles = await discoverAllAgentsMd(cwd);
+    return formatAgentsMdForPrompt(agentsMdFiles);
+}
+
+/**
+ * AGENTS.md 정보를 요약하여 반환합니다.
+ * /agents 명령어용
+ *
+ * @param {string} [cwd] - 현재 작업 디렉토리
+ * @returns {Promise<string>}
+ */
+export async function formatAgentsMdSummary(cwd = process.cwd()) {
+    const agentsMdFiles = await discoverAllAgentsMd(cwd);
+
+    if (agentsMdFiles.length === 0) {
+        return [
+            'No AGENTS.md files found.',
+            '',
+            'AGENTS.md is an open standard for guiding AI coding agents.',
+            '',
+            'File locations (in priority order):',
+            '  1. CWD/AGENTS.md - Project root',
+            '  2. CWD/.aiexe/AGENTS.md - Project config',
+            '  3. ~/.aiexe/AGENTS.md - Global config',
+            '',
+            'Create an AGENTS.md file to provide project-specific instructions.',
+            '',
+            'Recommended sections:',
+            '  - Commands (build, test)',
+            '  - Testing guidelines',
+            '  - Project structure',
+            '  - Code style',
+            '  - Git workflow',
+            '  - Boundaries (what not to touch)',
+            '',
+            'Learn more: https://agents.md/'
+        ].join('\n');
+    }
+
+    const lines = ['AGENTS.md Files:', ''];
+
+    for (const file of agentsMdFiles) {
+        const sourceLabel = {
+            'project': 'Project Root',
+            'project-config': 'Project Config',
+            'parent': 'Parent Directory',
+            'global': 'Global'
+        }[file.source] || file.source;
+
+        const lineCount = file.lineCount || file.content.split('\n').length;
+        const charCount = file.content.length;
+        const sizeWarning = lineCount > RECOMMENDED_MAX_LINES
+            ? ` (exceeds recommended ${RECOMMENDED_MAX_LINES} lines)`
+            : '';
+
+        lines.push(`${sourceLabel}:`);
+        lines.push(`  Path: ${file.path}`);
+        lines.push(`  Size: ${lineCount} lines, ${charCount} chars${sizeWarning}`);
+
+        // 첫 3줄 미리보기
+        const preview = file.content.split('\n').slice(0, 3).join('\n');
+        lines.push(`  Preview:`);
+        lines.push(`    ${preview.replace(/\n/g, '\n    ')}`);
+        lines.push('');
+    }
+
+    lines.push('Use /agents <path> to view full content of a specific file.');
+
+    return lines.join('\n');
+}

package/src/system/ai_request.js

@@ -7,9 +7,30 @@ import { getReasoningModels, supportsReasoningEffort, DEFAULT_MODEL, getModelInf
 import { createDebugLogger } from "../util/debug_log.js";
 import { formatReadFileStdout } from "../util/output_formatter.js";
 import { UnifiedLLMClient } from "../LLMClient/index.js";
+import { uiEvents } from "./ui_events.js";
 
 const debugLog = createDebugLogger('ai_request.log', 'ai_request');
 
+/**
+ * 안전한 JSON 파싱 헬퍼 함수
+ * 파싱 실패 시 에러를 던지지 않고 기본값 반환
+ * @param {string} jsonString - 파싱할 JSON 문자열
+ * @param {*} defaultValue - 파싱 실패 시 반환할 기본값
+ * @returns {*} 파싱된 객체 또는 기본값
+ */
+function safeJsonParse(jsonString, defaultValue = null) {
+    if (typeof jsonString !== 'string') {
+        return defaultValue;
+    }
+    try {
+        return JSON.parse(jsonString);
+    } catch (error) {
+        debugLog(`[safeJsonParse] JSON parsing failed: ${error.message}`);
+        debugLog(`[safeJsonParse] Input (first 200 chars): ${jsonString.substring(0, 200)}`);
+        return defaultValue;
+    }
+}
+
 // OpenAI SDK를 사용하기 위한 환경변수를 불러옵니다.
 dotenv.config({ quiet: true });
 
@@ -55,15 +76,24 @@ async function getLLMClient() {
     const currentModel = process.env.MODEL || settings?.MODEL || DEFAULT_MODEL;
     const modelInfo = getModelInfo(currentModel);
     const provider = modelInfo?.provider || 'openai';
+    const baseUrl = process.env.BASE_URL || settings?.BASE_URL || null;
 
-    debugLog('[getLLMClient] Initializing UnifiedLLMClient with API key (first 10 chars): ' + process.env.API_KEY.substring(0, 10) + '...');
-    debugLog(`[getLLMClient] Model: ${currentModel}, Provider: ${provider}`);
-    llmClient = new UnifiedLLMClient({
+    debugLog('[getLLMClient] Initializing UnifiedLLMClient with API key: [PRESENT]');
+    debugLog(`[getLLMClient] Model: ${currentModel}, Provider: ${provider}, BaseURL: ${baseUrl || '(default)'}`);
+
+    const clientConfig = {
         apiKey: process.env.API_KEY,
         model: currentModel,
         provider: provider,
         logDir: PAYLOAD_LLM_LOG_DIR
-    });
+    };
+
+    // 커스텀 BASE_URL이 설정되어 있으면 추가
+    if (baseUrl) {
+        clientConfig.baseUrl = baseUrl;
+    }
+
+    llmClient = new UnifiedLLMClient(clientConfig);
 
     debugLog('[getLLMClient] Client created successfully');
     return llmClient;
@@ -181,6 +211,21 @@ function toAbsolutePath(anyPath) {
 // 모든 AI 요청 과정에서 요청/응답 로그를 남기고 결과를 돌려줍니다.
 export async function request(taskName, requestPayload) {
     debugLog(`[request] ========== START: ${taskName} ==========`);
+
+    // 설정에서 API payload 표시 여부 확인
+    const settings = await loadSettings();
+    const showApiPayload = settings?.SHOW_API_PAYLOAD === true;
+
+    // 화면에 요청 시작 표시 (설정이 켜져 있을 때만)
+    if (showApiPayload) {
+        const taskDisplayNames = {
+            'orchestrator': '🤖 Orchestrator',
+            'completion_judge': '✅ Completion Judge'
+        };
+        const displayName = taskDisplayNames[taskName] || taskName;
+        uiEvents.addSystemMessage(`📡 API Request: ${displayName}`);
+    }
+
     const provider = await getCurrentProvider();
     debugLog(`[request] Provider: ${provider}`);
 
@@ -218,8 +263,8 @@ export async function request(taskName, requestPayload) {
             const msg = payloadCopy.input[i];
             const { type, call_id, output } = msg;
             if (type !== 'function_call_output') continue;
-            const parsedOutput = JSON.parse(output);
-            if (!isValidJSON(parsedOutput.stdout)) {
+            const parsedOutput = safeJsonParse(output, { stdout: output });
+            if (!parsedOutput || !isValidJSON(parsedOutput.stdout)) {
                 // stdout와 stderr를 모두 포함하는 형식으로 변환
                 const hasStdout = parsedOutput.stdout;
                 const hasStderr = parsedOutput.stderr;
@@ -235,7 +280,10 @@ export async function request(taskName, requestPayload) {
                     msg.output = parsedOutput.stdout;
                 }
             } else {
-                parsedOutput.stdout = JSON.parse(parsedOutput.stdout);
+                const parsedStdout = safeJsonParse(parsedOutput.stdout, null);
+                if (parsedStdout !== null) {
+                    parsedOutput.stdout = parsedStdout;
+                }
                 if (parsedOutput.original_result) {
                     parsedOutput.stdout = ({ ...parsedOutput.original_result, ...(parsedOutput.stdout) });
                     delete parsedOutput.original_result;
@@ -496,16 +544,24 @@ export async function request(taskName, requestPayload) {
         debugLog(`[request] Request prepared - logging to file`);
 
         // 로그는 원본 포맷으로 저장 (API 호출 전)
+        const logStartTime = Date.now();
         await logger(`${taskName}_REQ`, originalRequest, provider);
-        debugLog(`[request] Request logged - calling LLM API`);
+        debugLog(`[request] Request logged (${Date.now() - logStartTime}ms) - calling LLM API`);
 
         // AbortController의 signal을 options로 전달
         const requestOptions = {
             signal: currentAbortController.signal
         };
-        debugLog(`[request] Calling client.response with abort signal`);
+
+        // ===== API 호출 시작 =====
+        const apiCallStartTime = Date.now();
+        debugLog(`[request] >>>>> API CALL START: ${new Date(apiCallStartTime).toISOString()}`);
 
         response = await client.response(originalRequest, requestOptions);
+
+        const apiCallEndTime = Date.now();
+        const apiCallDuration = apiCallEndTime - apiCallStartTime;
+        debugLog(`[request] <<<<< API CALL END: ${apiCallDuration}ms (${new Date(apiCallEndTime).toISOString()})`);
         debugLog(`[request] Response received - id: ${response?.id}, status: ${response?.status}, output items: ${response?.output?.length || 0}`);
 
         // 원본 응답을 깊은 복사로 보존 (이후 수정으로부터 보호)
@@ -549,6 +605,88 @@ export async function request(taskName, requestPayload) {
     // 로그는 원본 포맷으로 저장
     debugLog(`[request] Logging response to file`);
     await logger(`${taskName}_RES`, originalResponse, provider);
+
+    // 화면에 응답 결과 표시 (raw JSON)
+    // 캐시 토큰 정보 추출
+    const cacheTokens = response.usage?.cache_read_input_tokens || response.usage?.input_tokens_details?.cached_tokens || 0;
+    const inputTokens = response.usage?.input_tokens || 0;
+    const cacheRatio = inputTokens > 0 ? Math.round(cacheTokens / inputTokens * 100) : 0;
+
+    const rawOutput = {
+        status: response.status,
+        output: (response.output || []).map(o => {
+            if (o.type === 'reasoning') {
+                // thinking/reasoning 블록 표시
+                const thinking = o.content?.[0]?.thinking || '';
+                return {
+                    type: 'thinking',
+                    content: thinking.length > 150 ? thinking.substring(0, 150) + `... (${thinking.length} chars)` : thinking
+                };
+            } else if (o.type === 'function_call') {
+                return {
+                    type: o.type,
+                    name: o.name,
+                    arguments: (() => {
+                        try {
+                            const args = JSON.parse(o.arguments || '{}');
+                            // 긴 인자값은 축약
+                            const truncated = {};
+                            for (const [k, v] of Object.entries(args)) {
+                                if (typeof v === 'string' && v.length > 100) {
+                                    truncated[k] = v.substring(0, 100) + `... (${v.length} chars)`;
+                                } else {
+                                    truncated[k] = v;
+                                }
+                            }
+                            return truncated;
+                        } catch {
+                            return o.arguments;
+                        }
+                    })()
+                };
+            } else if (o.type === 'message') {
+                const text = response.output_text || '';
+                return {
+                    type: o.type,
+                    text: text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text
+                };
+            }
+            return { type: o.type };
+        }),
+        // 토큰 사용량 정보 추가
+        tokens: {
+            input: inputTokens,
+            output: response.usage?.output_tokens || 0,
+            cached: cacheTokens > 0 ? `${cacheTokens} (${cacheRatio}%)` : 0
+        },
+        output_text: (() => {
+            const text = response.output_text || '';
+            if (taskName === 'completion_judge') {
+                // GLM 모델 대응: 텍스트 끝에 붙은 JSON 추출
+                try {
+                    return JSON.parse(text);
+                } catch {
+                    // 텍스트에서 JSON 추출 시도
+                    const jsonMatch = text.match(/\{[^{}]*"should_complete"\s*:\s*(true|false)[^{}]*\}/);
+                    if (jsonMatch) {
+                        try {
+                            return JSON.parse(jsonMatch[0]);
+                        } catch {
+                            return text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text;
+                        }
+                    }
+                    return text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text;
+                }
+            }
+            return text.length > 200 ? text.substring(0, 200) + `... (${text.length} chars)` : text;
+        })()
+    };
+
+    // 화면에 응답 내용 표시 (설정이 켜져 있을 때만)
+    if (showApiPayload) {
+        uiEvents.addSystemMessage(`   └─ Response:\n${JSON.stringify(rawOutput, null, 2)}`);
+    }
+
     debugLog(`[request] ========== END: ${taskName} ==========`);
 
     return response;

package/src/system/command_parser.js

@@ -1,6 +1,9 @@
 // 간단한 슬래시 커맨드 파서
 // 사용자가 입력한 문자열에서 커맨드와 인자를 분리합니다.
 
+import { loadSkillAsPrompt } from './skill_loader.js';
+import { loadCustomCommandAsPrompt } from './custom_command_loader.js';
+
 /**
  * 슬래시 커맨드를 파싱합니다.
  * @param {string} input - 사용자 입력 문자열 (예: "/help", "/exit", "/clear history")
@@ -65,6 +68,7 @@ export class CommandRegistry {
 
     /**
      * 커맨드를 실행합니다.
+     * 등록된 명령어가 없으면 스킬에서 찾아봅니다.
      * @param {string} input - 사용자 입력
      * @returns {Promise<any>} 커맨드 실행 결과
      */
@@ -77,11 +81,37 @@ export class CommandRegistry {
 
         const commandConfig = this.commands.get(parsed.command);
 
-        if (!commandConfig) {
-            throw new Error(`Unknown command: ${parsed.command}`);
+        if (commandConfig) {
+            return await commandConfig.handler(parsed.args, parsed);
+        }
+
+        // 등록된 명령어가 없으면 커스텀 커맨드에서 찾아봅니다
+        const customCommandResult = await loadCustomCommandAsPrompt(parsed.command, parsed.args.join(' '));
+
+        if (customCommandResult) {
+            // 커스텀 커맨드를 찾았으면 커맨드 정보 반환
+            return {
+                type: 'custom_command',
+                commandName: customCommandResult.command.name,
+                prompt: customCommandResult.prompt,
+                command: customCommandResult.command
+            };
+        }
+
+        // 커스텀 커맨드가 없으면 스킬에서 찾아봅니다
+        const skillResult = await loadSkillAsPrompt(parsed.command, parsed.args.join(' '));
+
+        if (skillResult) {
+            // 스킬을 찾았으면 스킬 정보 반환
+            return {
+                type: 'skill',
+                skillName: skillResult.skill.name,
+                prompt: skillResult.prompt,
+                skill: skillResult.skill
+            };
         }
 
-        return await commandConfig.handler(parsed.args, parsed);
+        throw new Error(`Unknown command: ${parsed.command}`);
     }
 
     /**