aiexecode 1.0.94 → 1.0.127

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/file_integrity.js

@@ -5,7 +5,7 @@ import { safeReadFile, safeMkdir, safeAppendFile } from '../util/safe_fs.js';
 import crypto from 'crypto';
 import { dirname, join } from 'path';
 import { createDebugLogger } from '../util/debug_log.js';
-import { DEBUG_LOG_DIR } from '../util/config.js';
+import { DEBUG_LOG_DIR, isDebugModeEnabled } from '../util/config.js';
 
 const debugLog = createDebugLogger('file_integrity.log', 'file_integrity');
 
@@ -92,9 +92,11 @@ class FileIntegrityTracker {
         debugLog(`Hash stored in session map`);
         debugLog(`Total files tracked in this session: ${sessionFiles.size}`);
         internalDebugLog.push(`[${timestamp}] Hash stored successfully`);
-        const logFile = getLogFile();
-        await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
-        await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n').catch(() => {});
+        if (isDebugModeEnabled()) {
+            const logFile = getLogFile();
+            await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+            await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n').catch(() => {});
+        }
 
         debugLog(`========== trackRead END ==========`);
         debugLog(`[FileIntegrity] Tracked read: ${sessionID}:${filePath} (hash: ${hash.slice(0, 8)}...)`);
@@ -112,6 +114,38 @@ class FileIntegrityTracker {
         return sessionFiles.get(filePath) || null;
     }
 
+    /**
+     * 파일 콘텐츠 해시를 삭제합니다
+     * 대화가 trim되어 에이전트가 파일 내용을 알 수 없게 되었을 때 호출됩니다.
+     * 이렇게 하면 에이전트가 파일을 다시 읽기 전까지 편집할 수 없습니다.
+     * @param {string} sessionID - 세션 ID
+     * @param {string} filePath - 파일 경로
+     * @returns {boolean} 삭제 성공 여부
+     */
+    clearContentHash(sessionID, filePath) {
+        debugLog(`========== clearContentHash START ==========`);
+        debugLog(`sessionID: ${sessionID}`);
+        debugLog(`filePath: ${filePath}`);
+
+        const sessionFiles = this.contentHashes.get(sessionID);
+        if (!sessionFiles) {
+            debugLog(`No session map found for session: ${sessionID}`);
+            debugLog(`========== clearContentHash END (NO SESSION) ==========`);
+            return false;
+        }
+
+        const existed = sessionFiles.has(filePath);
+        if (existed) {
+            sessionFiles.delete(filePath);
+            debugLog(`Hash deleted for file: ${filePath}`);
+        } else {
+            debugLog(`No hash found for file: ${filePath}`);
+        }
+
+        debugLog(`========== clearContentHash END ==========`);
+        return existed;
+    }
+
     /**
      * 파일 편집 전 무결성을 검증합니다
      * @param {string} sessionID - 세션 ID
@@ -148,18 +182,22 @@ class FileIntegrityTracker {
             assertDebugLog.push(`[${timestamp}] ERROR: No saved hash found`);
             debugLog(`ERROR: No saved hash found for this file in session ${sessionID}`);
             debugLog('========== assertIntegrity ERROR END ==========');
-            const logFile = getLogFile();
-            await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
-            await safeAppendFile(logFile, assertDebugLog.join('\n') + '\n').catch(() => {});
+            if (isDebugModeEnabled()) {
+                const logFile = getLogFile();
+                await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+                await safeAppendFile(logFile, assertDebugLog.join('\n') + '\n').catch(() => {});
+            }
 
             throw new Error(
                 `You must read the file ${filePath} before editing it. Use a file reading tool first.`
             );
         }
 
-        const logFile = getLogFile();
-        await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
-        await safeAppendFile(logFile, assertDebugLog.join('\n') + '\n').catch(() => {});
+        if (isDebugModeEnabled()) {
+            const logFile = getLogFile();
+            await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+            await safeAppendFile(logFile, assertDebugLog.join('\n') + '\n').catch(() => {});
+        }
 
         debugLog(`Reading current file content for comparison...`);
         debugLog(`  - Reading from path: ${filePath}`);
@@ -347,6 +385,31 @@ export async function assertFileIntegrity(filePath) {
     debugLog('========== assertFileIntegrity (export wrapper) END ==========');
 }
 
+/**
+ * 파일 콘텐츠 해시를 삭제합니다 (현재 세션 기준)
+ * 대화가 trim되어 에이전트가 파일 내용을 알 수 없게 되었을 때 호출됩니다.
+ * @param {string} filePath - 파일 경로
+ * @returns {boolean} 삭제 성공 여부
+ */
+export function clearFileContentHash(filePath) {
+    debugLog(`========== clearFileContentHash (export wrapper) START ==========`);
+    debugLog(`filePath: ${filePath}`);
+
+    const sessionID = fileIntegrityTracker.getCurrentSession();
+    debugLog(`Current session ID: ${sessionID || 'NULL'}`);
+
+    if (!sessionID) {
+        debugLog(`ERROR: No current session set, cannot clear hash`);
+        debugLog('========== clearFileContentHash (export wrapper) END ==========');
+        return false;
+    }
+
+    const result = fileIntegrityTracker.clearContentHash(sessionID, filePath);
+    debugLog(`Hash clear result: ${result}`);
+    debugLog('========== clearFileContentHash (export wrapper) END ==========');
+    return result;
+}
+
 /**
  * 파일 스냅샷을 저장합니다 (현재 세션 기준)
  * @param {string} filePath - 파일 경로

package/src/system/log.js

@@ -1,9 +1,10 @@
 import { safeWriteFile, safeAccess, safeMkdir } from '../util/safe_fs.js';
 import { join } from 'path';
-import { PAYLOAD_LOG_DIR } from '../util/config.js';
+import { PAYLOAD_LOG_DIR, loadSettings } from '../util/config.js';
 
 // 이 파일은 AI 요청과 응답을 보기 쉬운 로그 파일로 저장합니다.
 // Planner·Orchestrator·Verifier의 대화 흐름을 모두 같은 위치에 남겨 재현성과 디버깅을 확보합니다.
+// /debug on 설정 시에만 로그가 기록됩니다.
 const LOG_DIR = PAYLOAD_LOG_DIR;
 
 // 로그 폴더가 없으면 만들어서 나중에 파일을 쓸 수 있게 합니다.
@@ -41,14 +42,21 @@ function generateLogFileName(taskName) {
 
 /**
  * 로그 저장
+ * SHOW_API_PAYLOAD 설정이 true일 때만 로그를 기록합니다.
  * @param {string} taskName - 태스크 이름
  * @param {Object} data - JSON 데이터
  * @param {string} provider - AI provider ('openai')
- * @returns {Promise<string>} 생성된 로그 파일 경로
+ * @returns {Promise<string|null>} 생성된 로그 파일 경로 또는 null (디버그 모드 꺼짐)
  */
 // 요청과 응답을 기록용 파일로 남기고 파일 경로를 되돌려줍니다.
 export async function saveLog(taskName, data, provider = null) {
     try {
+        // 디버그 모드가 꺼져있으면 로그를 기록하지 않음
+        const settings = await loadSettings();
+        if (settings?.SHOW_API_PAYLOAD !== true) {
+            return null;
+        }
+
         await ensureLogDirectory();
 
         const fileName = generateLogFileName(taskName);

package/src/system/output_helper.js

@@ -1,35 +1,70 @@
 /**
  * Output Helper - UI 이벤트 발생
+ * Pipe mode에서는 stderr로 출력하거나 무시
  */
 
 import { uiEvents } from './ui_events.js';
 
+// Pipe mode 감지
+const isPipeMode = () => process.app_custom?.pipeMode === true;
+
 export function logSystem(message) {
-    uiEvents.addSystemMessage(message);
+    if (isPipeMode()) {
+        console.error(`[SYSTEM] ${message}`);
+    } else {
+        uiEvents.addSystemMessage(message);
+    }
 }
 
 export function logError(message) {
-    uiEvents.addErrorMessage(message);
+    if (isPipeMode()) {
+        console.error(`[ERROR] ${message}`);
+    } else {
+        uiEvents.addErrorMessage(message);
+    }
 }
 
 export function logAssistantMessage(message) {
-    uiEvents.addAssistantMessage(message);
+    if (isPipeMode()) {
+        console.error(`[ASSISTANT] ${message}`);
+    } else {
+        uiEvents.addAssistantMessage(message);
+    }
 }
 
 export function logToolCall(toolName, args) {
-    uiEvents.startToolExecution(toolName, args);
+    if (isPipeMode()) {
+        console.error(`[TOOL] ${toolName}`);
+    } else {
+        uiEvents.startToolExecution(toolName, args);
+    }
 }
 
 export function logToolResult(toolName, stdout, originalResult = null, toolInput = null, fileSnapshot = null) {
-    uiEvents.addToolResult(toolName, { stdout, originalResult, fileSnapshot }, toolInput);
+    if (isPipeMode()) {
+        // Pipe mode에서는 도구 결과를 간략하게 stderr로
+        const preview = stdout?.substring(0, 200) || '';
+        console.error(`[TOOL_RESULT] ${toolName}: ${preview}${stdout?.length > 200 ? '...' : ''}`);
+    } else {
+        uiEvents.addToolResult(toolName, { stdout, originalResult, fileSnapshot }, toolInput);
+    }
 }
 
 export function logCodeExecution(language, code) {
-    uiEvents.startCodeExecution(language, code);
+    if (isPipeMode()) {
+        console.error(`[CODE] ${language}`);
+    } else {
+        uiEvents.startCodeExecution(language, code);
+    }
 }
 
 export function logCodeResult(stdout, stderr, exitCode) {
-    uiEvents.addCodeResult(stdout, stderr, exitCode);
+    if (isPipeMode()) {
+        if (stdout) console.error(`[CODE_STDOUT] ${stdout.substring(0, 200)}${stdout.length > 200 ? '...' : ''}`);
+        if (stderr) console.error(`[CODE_STDERR] ${stderr.substring(0, 200)}${stderr.length > 200 ? '...' : ''}`);
+    } else {
+        uiEvents.addCodeResult(stdout, stderr, exitCode);
+    }
 }
 
 export function logIteration(iterationNumber) {
@@ -38,9 +73,17 @@ export function logIteration(iterationNumber) {
 }
 
 export function logMissionComplete() {
-    uiEvents.missionCompleted(0);
+    if (isPipeMode()) {
+        console.error('[COMPLETE] Mission completed');
+    } else {
+        uiEvents.missionCompleted(0);
+    }
 }
 
 export function logConversationRestored(count) {
-    uiEvents.conversationRestored(count);
+    if (isPipeMode()) {
+        console.error(`[RESTORED] ${count} conversation(s) restored`);
+    } else {
+        uiEvents.conversationRestored(count);
+    }
 }