aiexecode 1.0.94 → 1.0.127

package/src/util/config.js

@@ -1,6 +1,7 @@
 // 설정 파일 및 환경 관리 유틸리티
 import { homedir } from 'os';
 import { join, dirname } from 'path';
+import { readFileSync } from 'fs';
 import { safeReadFile, safeWriteFile, safeMkdir, safeReaddir, safeStat, safeCopyFile } from './safe_fs.js';
 import { fileURLToPath } from 'url';
 import { DEFAULT_MODEL } from '../config/ai_models.js';
@@ -41,10 +42,20 @@ export const PAYLOAD_LOG_DIR = join(CONFIG_DIR, 'payload_log');
 export const PAYLOAD_LLM_LOG_DIR = join(CONFIG_DIR, 'payload_LLM_log');
 export const DEBUG_LOG_DIR = join(CONFIG_DIR, 'debuglog');
 export const DEBUG_LOG_FILE = join(CONFIG_DIR, 'debug.txt'); // Deprecated: 호환성을 위해 유지
+// Skill 시스템 경로
+export const PERSONAL_SKILLS_DIR = join(CONFIG_DIR, 'skills'); // ~/.aiexe/skills/
+export const PROJECT_SKILLS_DIR = '.aiexe/skills'; // CWD/.aiexe/skills/ (상대경로)
+
+// Custom Commands 시스템 경로 (Claude Code 스타일)
+export const PERSONAL_COMMANDS_DIR = join(CONFIG_DIR, 'commands'); // ~/.aiexe/commands/
+export const PROJECT_COMMANDS_DIR = '.aiexe/commands'; // CWD/.aiexe/commands/ (상대경로)
 const DEFAULT_SETTINGS = {
     API_KEY: '',
     MODEL: DEFAULT_MODEL,
+    BASE_URL: '', // 커스텀 API 엔드포인트 (비어있으면 기본값 사용)
     REASONING_EFFORT: 'medium', // 'minimal', 'low', 'medium', 'high'
+    // API 요청/응답 내용 화면 표시 여부
+    SHOW_API_PAYLOAD: false, // true: 요청/응답 내용을 화면에 표시, false: 표시하지 않음
     // 도구 활성화 옵션
     TOOLS_ENABLED: {
         edit_file_range: false,  // 기본적으로 비활성화 (edit_file_replace 사용 권장)
@@ -61,6 +72,22 @@ const DEFAULT_SETTINGS = {
     }
 };
 
+/**
+ * 디버그 모드(SHOW_API_PAYLOAD) 활성화 여부 확인 (동기)
+ * 로깅 함수에서 사용하기 위한 동기 버전
+ * @returns {boolean} 디버그 모드 활성화 여부
+ */
+export function isDebugModeEnabled() {
+    try {
+        const data = readFileSync(SETTINGS_FILE, 'utf8');
+        const parsed = JSON.parse(data);
+        return parsed?.SHOW_API_PAYLOAD === true;
+    } catch {
+        // 설정 파일이 없거나 읽기 실패 시 기본값 false
+        return false;
+    }
+}
+
 /**
  * 설정 디렉토리를 생성하고 템플릿 파일을 복사
  * @returns {Promise<void>}
@@ -74,7 +101,7 @@ export async function ensureConfigDirectory() {
         if (!templateDir) return;
 
         const templateFiles = await safeReaddir(templateDir);
-        await Promise.all(
+        const copyResults = await Promise.allSettled(
             templateFiles.map(async (fileName) => {
                 const sourcePath = join(templateDir, fileName);
                 const stat = await safeStat(sourcePath);
@@ -82,8 +109,15 @@ export async function ensureConfigDirectory() {
                     const destPath = join(CONFIG_DIR, fileName);
                     await safeCopyFile(sourcePath, destPath);
                 }
+                return fileName;
             })
         );
+        // 실패한 복사 작업은 조용히 무시 (설정 디렉토리 초기화 실패가 앱 전체를 막으면 안됨)
+        const failedCopies = copyResults.filter(r => r.status === 'rejected');
+        if (failedCopies.length > 0) {
+            // 로깅만 하고 에러는 던지지 않음
+            console.error(`[config] ${failedCopies.length} template file(s) failed to copy`);
+        }
     } catch (error) {
         // Failed to ensure config directory - silently ignore
         throw error;
@@ -131,7 +165,7 @@ export async function saveSettings(settings) {
 /**
  * API 키의 접두어를 기반으로 발급처를 판단합니다.
  * @param {string} apiKey - API 키 문자열
- * @returns {string|null} 발급처 이름 ("Google", "OpenAI", "Anthropic") 또는 null (알 수 없는 경우)
+ * @returns {string|null} 발급처 이름 ("Google", "OpenAI", "Anthropic", "Z.AI") 또는 null (알 수 없는 경우)
  */
 export function APIKeyIssuedFrom(apiKey) {
     if (!apiKey || typeof apiKey !== 'string') {
@@ -144,7 +178,26 @@ export function APIKeyIssuedFrom(apiKey) {
         return 'OpenAI';
     } else if (apiKey.startsWith('sk-ant-')) {
         return 'Anthropic';
+    } else if (/^[a-f0-9]{32}\.[A-Za-z0-9]{16}$/.test(apiKey)) {
+        // Z.AI API 키 형식: 32자리 hex + '.' + 16자리 영숫자
+        return 'Z.AI';
     }
 
     return null;
 }
+
+/**
+ * Provider별 기본 BASE_URL 반환
+ * @param {string} provider - 프로바이더 이름 ('openai', 'claude', 'zai', 'gemini')
+ * @returns {string|null} 기본 BASE_URL 또는 null
+ */
+export function getDefaultBaseUrlForProvider(provider) {
+    const baseUrls = {
+        'zai': 'https://api.z.ai/api/anthropic',
+        // 다른 프로바이더는 SDK 기본값 사용
+        'openai': null,
+        'claude': null,
+        'gemini': null
+    };
+    return baseUrls[provider] || null;
+}

package/src/util/config_migration.js

@@ -0,0 +1,174 @@
+/**
+ * Configuration Migration Utility
+ * 설정 버전 관리 및 자동 마이그레이션을 제공합니다.
+ */
+
+import { safeReadFile, safeWriteFile, safeExists } from './safe_fs.js';
+import { CONFIG_DIR, SETTINGS_FILE } from './config.js';
+import { deepMerge } from './clone.js';
+
+/** 현재 설정 버전 */
+export const CURRENT_CONFIG_VERSION = 2;
+
+/**
+ * 설정 마이그레이션 정의
+ * 각 버전에서 다음 버전으로의 마이그레이션 함수를 정의합니다.
+ */
+const migrations = {
+    /**
+     * 버전 1 → 2 마이그레이션
+     * - TOOLS_ENABLED 구조 추가
+     * - REASONING_EFFORT 기본값 추가
+     */
+    1: (settings) => {
+        const migrated = { ...settings };
+
+        // TOOLS_ENABLED가 없으면 추가
+        if (!migrated.TOOLS_ENABLED) {
+            migrated.TOOLS_ENABLED = {
+                edit_file_range: false,
+                edit_file_replace: true,
+                write_file: true,
+                read_file: true,
+                read_file_range: true,
+                bash: true,
+                run_python_code: false,
+                fetch_web_page: true,
+                response_message: true,
+                ripgrep: true,
+                glob_search: true
+            };
+        }
+
+        // REASONING_EFFORT가 없으면 추가
+        if (!migrated.REASONING_EFFORT) {
+            migrated.REASONING_EFFORT = 'medium';
+        }
+
+        migrated._config_version = 2;
+        return migrated;
+    }
+};
+
+/**
+ * 설정 버전을 확인합니다.
+ * @param {Object} settings - 설정 객체
+ * @returns {number} 설정 버전 (없으면 1 반환)
+ */
+export function getConfigVersion(settings) {
+    return settings?._config_version || 1;
+}
+
+/**
+ * 설정이 마이그레이션이 필요한지 확인합니다.
+ * @param {Object} settings - 설정 객체
+ * @returns {boolean} 마이그레이션이 필요하면 true
+ */
+export function needsMigration(settings) {
+    const version = getConfigVersion(settings);
+    return version < CURRENT_CONFIG_VERSION;
+}
+
+/**
+ * 설정을 최신 버전으로 마이그레이션합니다.
+ * @param {Object} settings - 설정 객체
+ * @returns {{settings: Object, migrated: boolean, fromVersion: number, toVersion: number}}
+ */
+export function migrateSettings(settings) {
+    const fromVersion = getConfigVersion(settings);
+    let currentSettings = { ...settings };
+    let currentVersion = fromVersion;
+
+    // 순차적으로 마이그레이션 적용
+    while (currentVersion < CURRENT_CONFIG_VERSION) {
+        const migrationFn = migrations[currentVersion];
+        if (migrationFn) {
+            currentSettings = migrationFn(currentSettings);
+            currentVersion++;
+        } else {
+            // 마이그레이션 함수가 없으면 버전만 업데이트
+            currentSettings._config_version = currentVersion + 1;
+            currentVersion++;
+        }
+    }
+
+    return {
+        settings: currentSettings,
+        migrated: fromVersion !== currentVersion,
+        fromVersion,
+        toVersion: currentVersion
+    };
+}
+
+/**
+ * 설정 파일을 마이그레이션하고 저장합니다.
+ * @param {string} settingsPath - 설정 파일 경로 (선택, 기본값: SETTINGS_FILE)
+ * @returns {Promise<{migrated: boolean, fromVersion: number, toVersion: number}>}
+ */
+export async function migrateSettingsFile(settingsPath = SETTINGS_FILE) {
+    try {
+        // 설정 파일 존재 확인
+        if (!(await safeExists(settingsPath))) {
+            return { migrated: false, fromVersion: CURRENT_CONFIG_VERSION, toVersion: CURRENT_CONFIG_VERSION };
+        }
+
+        // 설정 파일 읽기
+        const content = await safeReadFile(settingsPath, 'utf8');
+        const settings = JSON.parse(content);
+
+        // 마이그레이션 필요 여부 확인
+        if (!needsMigration(settings)) {
+            return { migrated: false, fromVersion: getConfigVersion(settings), toVersion: CURRENT_CONFIG_VERSION };
+        }
+
+        // 마이그레이션 수행
+        const result = migrateSettings(settings);
+
+        // 마이그레이션된 설정 저장
+        await safeWriteFile(settingsPath, JSON.stringify(result.settings, null, 2), 'utf8');
+
+        return {
+            migrated: result.migrated,
+            fromVersion: result.fromVersion,
+            toVersion: result.toVersion
+        };
+    } catch (error) {
+        console.error(`[config_migration] Migration failed: ${error.message}`);
+        return { migrated: false, fromVersion: 0, toVersion: 0, error: error.message };
+    }
+}
+
+/**
+ * 새 설정 객체를 기본값과 병합합니다.
+ * @param {Object} settings - 사용자 설정
+ * @param {Object} defaults - 기본 설정
+ * @returns {Object} 병합된 설정
+ */
+export function mergeWithDefaults(settings, defaults) {
+    const merged = deepMerge(defaults, settings);
+    merged._config_version = CURRENT_CONFIG_VERSION;
+    return merged;
+}
+
+/**
+ * 설정 백업을 생성합니다.
+ * @param {string} settingsPath - 설정 파일 경로
+ * @returns {Promise<string>} 백업 파일 경로
+ */
+export async function createSettingsBackup(settingsPath = SETTINGS_FILE) {
+    try {
+        if (!(await safeExists(settingsPath))) {
+            return null;
+        }
+
+        const content = await safeReadFile(settingsPath, 'utf8');
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = settingsPath.replace('.json', `.backup-${timestamp}.json`);
+
+        await safeWriteFile(backupPath, content, 'utf8');
+        return backupPath;
+    } catch (error) {
+        console.error(`[config_migration] Backup failed: ${error.message}`);
+        return null;
+    }
+}

package/src/util/debug_log.js

@@ -1,21 +1,27 @@
 /**
  * Debug logging utility
  * 프로젝트 전역에서 사용할 수 있는 디버그 로깅 함수를 제공합니다.
+ * /debug on 설정 시에만 로그가 기록됩니다.
  */
 
-import { DEBUG_LOG_DIR } from './config.js';
+import { DEBUG_LOG_DIR, isDebugModeEnabled } from './config.js';
 import { join, dirname } from 'path';
 import { safeMkdirSync, safeAppendFileSync } from './safe_fs.js';
 
 /**
  * 디버그 로그를 파일에 기록합니다.
- * 모든 환경에서 로그를 기록합니다.
+ * SHOW_API_PAYLOAD 설정이 true일 때만 로그를 기록합니다.
  * @param {string} logFileName - 로그 파일 이름 (예: 'ui.log', 'session.log')
  * @param {string} context - 로그 컨텍스트 (예: 'MainContent', 'AppContext')
  * @param {string} message - 로그 메시지
  */
 export function debugLog(logFileName, context, message) {
     try {
+        // 디버그 모드가 꺼져있으면 로그를 기록하지 않음
+        if (!isDebugModeEnabled()) {
+            return;
+        }
+
         const LOG_FILE = join(DEBUG_LOG_DIR, logFileName);
         const logDir = dirname(LOG_FILE);
 

package/src/util/exit_handler.js

@@ -1,4 +1,6 @@
 import { uiEvents } from '../system/ui_events.js';
+import { closePersistentShell } from '../system/code_executer.js';
+import { killAllBackgroundProcesses } from '../system/background_process.js';
 
 /**
  * Unified exit handler for the application
@@ -17,6 +19,12 @@ export async function performExit(options = {}) {
         uiEvents.addSystemMessage(`Goodbye! Session ID: ${sessionID}`);
     }
 
+    // 백그라운드 프로세스 정리
+    await killAllBackgroundProcesses();
+
+    // PersistentShell 정리
+    await closePersistentShell();
+
     // MCP Integration 정리
     if (mcpIntegration) {
         await mcpIntegration.cleanup();

package/src/util/file_reference_parser.js

@@ -0,0 +1,132 @@
+/**
+ * File Reference Parser
+ *
+ * 메시지에서 @경로 형태의 파일/디렉토리 참조를 파싱하고 변환합니다.
+ */
+
+import { resolve } from 'path';
+import { safeStat, safeExists } from './safe_fs.js';
+
+/**
+ * 메시지에서 @참조를 파싱하여 파일/디렉토리 목록과 변환된 메시지를 반환합니다.
+ *
+ * @param {string} message - 사용자 입력 메시지
+ * @returns {Promise<Object>} 파싱 결과
+ * @example
+ * // 입력: "@src/index.js @package.json 분석해줘"
+ * // 출력: {
+ * //   hasReferences: true,
+ * //   files: ['src/index.js', 'package.json'],
+ * //   directories: [],
+ * //   transformedMessage: "참조된 파일:\n- src/index.js (파일)\n- package.json (파일)\n\n분석해줘"
+ * // }
+ */
+export async function parseFileReferences(message) {
+    if (!message || typeof message !== 'string') {
+        return {
+            hasReferences: false,
+            files: [],
+            directories: [],
+            transformedMessage: message || ''
+        };
+    }
+
+    // @ 뒤에 경로 문자열이 오는 패턴 매칭
+    // 경로: 알파벳, 숫자, /, ., _, -, ~로 구성
+    const atPattern = /@([^\s@]+)/g;
+    const matches = [...message.matchAll(atPattern)];
+
+    if (matches.length === 0) {
+        return {
+            hasReferences: false,
+            files: [],
+            directories: [],
+            transformedMessage: message
+        };
+    }
+
+    const files = [];
+    const directories = [];
+    const validReferences = [];
+
+    // 각 @참조 검증
+    for (const match of matches) {
+        const refPath = match[1];
+
+        // 경로 유효성 검사 (최소한의 검증)
+        if (!refPath || refPath.length === 0) {
+            continue;
+        }
+
+        // 절대 경로로 변환
+        const absolutePath = resolve(process.cwd(), refPath);
+
+        try {
+            const exists = await safeExists(absolutePath);
+            if (!exists) {
+                continue;
+            }
+
+            const stat = await safeStat(absolutePath);
+
+            if (stat.isDirectory()) {
+                directories.push(refPath);
+                validReferences.push({
+                    original: match[0],
+                    path: refPath,
+                    type: 'directory'
+                });
+            } else if (stat.isFile()) {
+                files.push(refPath);
+                validReferences.push({
+                    original: match[0],
+                    path: refPath,
+                    type: 'file'
+                });
+            }
+        } catch (error) {
+            // 존재하지 않거나 접근 불가능한 경로는 무시
+            continue;
+        }
+    }
+
+    // 유효한 참조가 없으면 원본 메시지 반환
+    if (validReferences.length === 0) {
+        return {
+            hasReferences: false,
+            files: [],
+            directories: [],
+            transformedMessage: message
+        };
+    }
+
+    // 메시지에서 @참조 제거
+    let cleanedMessage = message;
+    for (const ref of validReferences) {
+        cleanedMessage = cleanedMessage.replace(ref.original, '').trim();
+    }
+
+    // 연속된 공백 정리
+    cleanedMessage = cleanedMessage.replace(/\s+/g, ' ').trim();
+
+    // 변환된 메시지 생성
+    const referenceLines = validReferences.map(ref => {
+        const suffix = ref.type === 'directory' ? '/' : '';
+        const typeLabel = ref.type === 'directory' ? '디렉토리' : '파일';
+        return `- ${ref.path}${suffix} (${typeLabel})`;
+    });
+
+    const transformedMessage = [
+        '참조된 파일:',
+        ...referenceLines,
+        '',
+        cleanedMessage
+    ].join('\n');
+
+    return {
+        hasReferences: true,
+        files,
+        directories,
+        transformedMessage
+    };
+}

package/src/util/path_validator.js

@@ -0,0 +1,178 @@
+/**
+ * 경로 검증 유틸리티
+ * 파일 및 디렉토리 경로의 유효성을 검사하는 통합 유틸리티입니다.
+ */
+
+import { resolve, isAbsolute, normalize, dirname, basename } from 'path';
+import { safeStat, safeAccess } from './safe_fs.js';
+
+/**
+ * 경로를 절대경로로 변환합니다
+ * @param {string} inputPath - 변환할 경로
+ * @returns {string} 절대경로
+ */
+export function toAbsolutePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        throw new Error('Invalid path: path must be a non-empty string');
+    }
+
+    if (isAbsolute(inputPath)) {
+        return normalize(inputPath);
+    }
+
+    return resolve(process.cwd(), inputPath);
+}
+
+/**
+ * 경로 문자열의 기본 유효성을 검사합니다
+ * @param {string} inputPath - 검증할 경로
+ * @returns {{valid: boolean, error?: string}} 검증 결과
+ */
+export function validatePathString(inputPath) {
+    if (!inputPath) {
+        return { valid: false, error: 'Path is required' };
+    }
+
+    if (typeof inputPath !== 'string') {
+        return { valid: false, error: 'Path must be a string' };
+    }
+
+    if (inputPath.trim() === '') {
+        return { valid: false, error: 'Path cannot be empty' };
+    }
+
+    // null 바이트 검사 (보안)
+    if (inputPath.includes('\0')) {
+        return { valid: false, error: 'Path cannot contain null bytes' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 파일 경로의 유효성을 비동기로 검증합니다
+ * @param {string} filePath - 검증할 파일 경로
+ * @param {Object} options - 옵션
+ * @param {boolean} options.mustExist - 파일이 반드시 존재해야 하는지 여부 (기본: false)
+ * @param {boolean} options.allowDirectory - 디렉토리 경로를 허용할지 여부 (기본: false)
+ * @returns {Promise<{valid: boolean, absolutePath: string, error?: string}>}
+ */
+export async function validateFilePath(filePath, options = {}) {
+    const { mustExist = false, allowDirectory = false } = options;
+
+    // 기본 문자열 검증
+    const stringValidation = validatePathString(filePath);
+    if (!stringValidation.valid) {
+        return { valid: false, absolutePath: null, error: stringValidation.error };
+    }
+
+    // 절대경로 변환
+    let absolutePath;
+    try {
+        absolutePath = toAbsolutePath(filePath);
+    } catch (error) {
+        return { valid: false, absolutePath: null, error: error.message };
+    }
+
+    // 존재 여부 검사 (필요 시)
+    if (mustExist) {
+        try {
+            const stat = await safeStat(absolutePath);
+            if (!allowDirectory && stat.isDirectory()) {
+                return { valid: false, absolutePath, error: 'Path is a directory, not a file' };
+            }
+        } catch (error) {
+            return { valid: false, absolutePath, error: `File does not exist: ${absolutePath}` };
+        }
+    }
+
+    return { valid: true, absolutePath };
+}
+
+/**
+ * 디렉토리 경로의 유효성을 비동기로 검증합니다
+ * @param {string} dirPath - 검증할 디렉토리 경로
+ * @param {Object} options - 옵션
+ * @param {boolean} options.mustExist - 디렉토리가 반드시 존재해야 하는지 여부 (기본: false)
+ * @returns {Promise<{valid: boolean, absolutePath: string, error?: string}>}
+ */
+export async function validateDirectoryPath(dirPath, options = {}) {
+    const { mustExist = false } = options;
+
+    // 기본 문자열 검증
+    const stringValidation = validatePathString(dirPath);
+    if (!stringValidation.valid) {
+        return { valid: false, absolutePath: null, error: stringValidation.error };
+    }
+
+    // 절대경로 변환
+    let absolutePath;
+    try {
+        absolutePath = toAbsolutePath(dirPath);
+    } catch (error) {
+        return { valid: false, absolutePath: null, error: error.message };
+    }
+
+    // 존재 여부 검사 (필요 시)
+    if (mustExist) {
+        try {
+            const stat = await safeStat(absolutePath);
+            if (!stat.isDirectory()) {
+                return { valid: false, absolutePath, error: 'Path is not a directory' };
+            }
+        } catch (error) {
+            return { valid: false, absolutePath, error: `Directory does not exist: ${absolutePath}` };
+        }
+    }
+
+    return { valid: true, absolutePath };
+}
+
+/**
+ * 경로가 특정 디렉토리 내에 있는지 검사합니다
+ * @param {string} targetPath - 검사할 경로
+ * @param {string} basePath - 기준 디렉토리 경로
+ * @returns {boolean} 기준 디렉토리 내에 있으면 true
+ */
+export function isWithinDirectory(targetPath, basePath) {
+    const normalizedTarget = normalize(resolve(targetPath));
+    const normalizedBase = normalize(resolve(basePath));
+
+    return normalizedTarget.startsWith(normalizedBase + '/') ||
+        normalizedTarget === normalizedBase;
+}
+
+/**
+ * 파일 확장자를 검증합니다
+ * @param {string} filePath - 파일 경로
+ * @param {string[]} allowedExtensions - 허용된 확장자 목록 (예: ['.js', '.ts'])
+ * @returns {boolean} 허용된 확장자이면 true
+ */
+export function hasAllowedExtension(filePath, allowedExtensions) {
+    if (!filePath || !Array.isArray(allowedExtensions)) {
+        return false;
+    }
+
+    const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase();
+    return allowedExtensions.some(allowed =>
+        allowed.toLowerCase() === ext
+    );
+}
+
+/**
+ * 경로에서 파일명 추출
+ * @param {string} filePath - 파일 경로
+ * @returns {string} 파일명
+ */
+export function getFileName(filePath) {
+    return basename(filePath);
+}
+
+/**
+ * 경로에서 디렉토리 추출
+ * @param {string} filePath - 파일 경로
+ * @returns {string} 디렉토리 경로
+ */
+export function getDirectory(filePath) {
+    return dirname(filePath);
+}