aiexecode 1.0.94 → 1.0.96

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}`);
     }
 
     /**

package/src/system/conversation_state.js

@@ -0,0 +1,265 @@
+/**
+ * Conversation State Manager
+ * orchestratorConversation 전역 변수를 클래스로 캡슐화하여 상태 관리를 개선합니다.
+ */
+
+import { deepClone } from '../util/clone.js';
+
+/**
+ * 대화 상태 관리 클래스
+ * 전역 대화 상태를 캡슐화하고 안전한 접근 메서드를 제공합니다.
+ */
+class ConversationStateManager {
+    constructor() {
+        /** @type {Array} 대화 히스토리 */
+        this._conversation = [];
+
+        /** @type {Object|null} 요청 옵션 */
+        this._requestOptions = null;
+
+        /** @type {number} 마지막 수정 타임스탬프 */
+        this._lastModified = Date.now();
+
+        /** @type {string|null} 현재 세션 ID */
+        this._sessionId = null;
+    }
+
+    /**
+     * 대화 히스토리를 가져옵니다.
+     * @param {boolean} clone - true이면 깊은 복사본 반환 (기본: false)
+     * @returns {Array} 대화 히스토리
+     */
+    getConversation(clone = false) {
+        if (clone) {
+            return deepClone(this._conversation);
+        }
+        return this._conversation;
+    }
+
+    /**
+     * 대화 히스토리를 설정합니다.
+     * @param {Array} conversation - 새 대화 히스토리
+     */
+    setConversation(conversation) {
+        if (!Array.isArray(conversation)) {
+            throw new Error('Conversation must be an array');
+        }
+        this._conversation = conversation;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화에 메시지를 추가합니다.
+     * @param {Object} message - 추가할 메시지
+     */
+    addMessage(message) {
+        if (!message || typeof message !== 'object') {
+            throw new Error('Message must be an object');
+        }
+        this._conversation.push(message);
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화에 여러 메시지를 추가합니다.
+     * @param {Array} messages - 추가할 메시지 배열
+     */
+    addMessages(messages) {
+        if (!Array.isArray(messages)) {
+            throw new Error('Messages must be an array');
+        }
+        this._conversation.push(...messages);
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화 히스토리를 초기화합니다.
+     */
+    reset() {
+        this._conversation = [];
+        this._requestOptions = null;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화 히스토리를 복원합니다.
+     * @param {Array} conversation - 복원할 대화 히스토리
+     * @param {Object} requestOptions - 복원할 요청 옵션
+     */
+    restore(conversation, requestOptions = null) {
+        this._conversation = Array.isArray(conversation) ? conversation : [];
+        this._requestOptions = requestOptions;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 요청 옵션을 가져옵니다.
+     * @returns {Object|null} 요청 옵션
+     */
+    getRequestOptions() {
+        return this._requestOptions;
+    }
+
+    /**
+     * 요청 옵션을 설정합니다.
+     * @param {Object} options - 요청 옵션
+     */
+    setRequestOptions(options) {
+        this._requestOptions = options;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화 히스토리의 길이를 반환합니다.
+     * @returns {number} 메시지 수
+     */
+    get length() {
+        return this._conversation.length;
+    }
+
+    /**
+     * 대화가 비어있는지 확인합니다.
+     * @returns {boolean} 비어있으면 true
+     */
+    isEmpty() {
+        return this._conversation.length === 0;
+    }
+
+    /**
+     * 마지막 수정 시간을 반환합니다.
+     * @returns {number} 타임스탬프
+     */
+    getLastModified() {
+        return this._lastModified;
+    }
+
+    /**
+     * 세션 ID를 설정합니다.
+     * @param {string} sessionId - 세션 ID
+     */
+    setSessionId(sessionId) {
+        this._sessionId = sessionId;
+    }
+
+    /**
+     * 세션 ID를 가져옵니다.
+     * @returns {string|null} 세션 ID
+     */
+    getSessionId() {
+        return this._sessionId;
+    }
+
+    /**
+     * 대화에서 특정 조건을 만족하는 메시지를 찾습니다.
+     * @param {Function} predicate - 검색 조건 함수
+     * @returns {Object|undefined} 찾은 메시지 또는 undefined
+     */
+    findMessage(predicate) {
+        return this._conversation.find(predicate);
+    }
+
+    /**
+     * 대화에서 특정 조건을 만족하는 메시지들을 필터링합니다.
+     * @param {Function} predicate - 필터 조건 함수
+     * @returns {Array} 필터링된 메시지 배열
+     */
+    filterMessages(predicate) {
+        return this._conversation.filter(predicate);
+    }
+
+    /**
+     * 마지막 메시지를 가져옵니다.
+     * @returns {Object|undefined} 마지막 메시지 또는 undefined
+     */
+    getLastMessage() {
+        if (this._conversation.length === 0) {
+            return undefined;
+        }
+        return this._conversation[this._conversation.length - 1];
+    }
+
+    /**
+     * 마지막 N개의 메시지를 가져옵니다.
+     * @param {number} count - 가져올 메시지 수
+     * @returns {Array} 메시지 배열
+     */
+    getLastMessages(count) {
+        if (count <= 0) {
+            return [];
+        }
+        return this._conversation.slice(-count);
+    }
+
+    /**
+     * 대화 히스토리를 트리밍합니다 (오래된 메시지 제거).
+     * @param {number} keepCount - 유지할 메시지 수 (시스템 메시지 제외)
+     * @returns {number} 제거된 메시지 수
+     */
+    trim(keepCount) {
+        const originalLength = this._conversation.length;
+
+        // 시스템 메시지는 유지
+        const systemMessages = this._conversation.filter(m => m.role === 'system');
+        const otherMessages = this._conversation.filter(m => m.role !== 'system');
+
+        // 최근 keepCount개만 유지
+        const keptMessages = otherMessages.slice(-keepCount);
+
+        this._conversation = [...systemMessages, ...keptMessages];
+        this._lastModified = Date.now();
+
+        return originalLength - this._conversation.length;
+    }
+
+    /**
+     * 상태를 직렬화 가능한 객체로 변환합니다.
+     * @returns {Object} 직렬화 가능한 상태 객체
+     */
+    toJSON() {
+        return {
+            conversation: deepClone(this._conversation),
+            requestOptions: this._requestOptions ? deepClone(this._requestOptions) : null,
+            lastModified: this._lastModified,
+            sessionId: this._sessionId
+        };
+    }
+
+    /**
+     * 직렬화된 상태에서 복원합니다.
+     * @param {Object} state - 직렬화된 상태 객체
+     */
+    fromJSON(state) {
+        if (state.conversation) {
+            this._conversation = state.conversation;
+        }
+        if (state.requestOptions !== undefined) {
+            this._requestOptions = state.requestOptions;
+        }
+        if (state.lastModified) {
+            this._lastModified = state.lastModified;
+        }
+        if (state.sessionId) {
+            this._sessionId = state.sessionId;
+        }
+    }
+}
+
+// 싱글톤 인스턴스 생성 및 export
+export const conversationState = new ConversationStateManager();
+
+// 후방 호환성을 위한 개별 함수들 export
+export function getOrchestratorConversation() {
+    return conversationState.getConversation();
+}
+
+export function setOrchestratorConversation(conversation) {
+    conversationState.setConversation(conversation);
+}
+
+export function resetOrchestratorConversation() {
+    conversationState.reset();
+}
+
+export function restoreOrchestratorConversation(conversation, requestOptions) {
+    conversationState.restore(conversation, requestOptions);
+}