aiexecode 1.0.92 → 1.0.96

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);
+}

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');
+}