aiexecode 1.0.94 → 1.0.98

package/src/util/clone.js

@@ -0,0 +1,174 @@
+/**
+ * 깊은 복사 유틸리티
+ * JSON.parse(JSON.stringify()) 패턴을 대체하는 안전한 깊은 복사 함수들을 제공합니다.
+ */
+
+/**
+ * 값을 깊은 복사합니다.
+ * - 순환 참조를 감지하고 처리합니다.
+ * - Date, RegExp 등의 특수 객체를 올바르게 복사합니다.
+ * - undefined, function, Symbol은 복사되지 않습니다 (JSON.stringify와 동일).
+ *
+ * @param {*} value - 복사할 값
+ * @param {WeakMap} [visited] - 순환 참조 감지용 (내부 사용)
+ * @returns {*} 깊은 복사된 값
+ */
+export function deepClone(value, visited = new WeakMap()) {
+    // 기본 타입은 그대로 반환
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+
+    // 순환 참조 감지
+    if (visited.has(value)) {
+        return visited.get(value);
+    }
+
+    // Date 객체 처리
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+
+    // RegExp 객체 처리
+    if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+
+    // Map 객체 처리
+    if (value instanceof Map) {
+        const clonedMap = new Map();
+        visited.set(value, clonedMap);
+        for (const [key, val] of value) {
+            clonedMap.set(deepClone(key, visited), deepClone(val, visited));
+        }
+        return clonedMap;
+    }
+
+    // Set 객체 처리
+    if (value instanceof Set) {
+        const clonedSet = new Set();
+        visited.set(value, clonedSet);
+        for (const val of value) {
+            clonedSet.add(deepClone(val, visited));
+        }
+        return clonedSet;
+    }
+
+    // 배열 처리
+    if (Array.isArray(value)) {
+        const clonedArray = [];
+        visited.set(value, clonedArray);
+        for (let i = 0; i < value.length; i++) {
+            clonedArray[i] = deepClone(value[i], visited);
+        }
+        return clonedArray;
+    }
+
+    // 일반 객체 처리
+    const clonedObj = {};
+    visited.set(value, clonedObj);
+
+    for (const key of Object.keys(value)) {
+        const val = value[key];
+        // undefined와 function은 스킵 (JSON.stringify 동작과 일치)
+        if (val !== undefined && typeof val !== 'function') {
+            clonedObj[key] = deepClone(val, visited);
+        }
+    }
+
+    return clonedObj;
+}
+
+/**
+ * JSON 직렬화 가능한 값만 깊은 복사합니다.
+ * JSON.parse(JSON.stringify())와 동일한 동작이지만 에러 처리가 추가되었습니다.
+ *
+ * @param {*} value - 복사할 값
+ * @param {*} [fallback] - 복사 실패 시 반환할 기본값 (기본: null)
+ * @returns {*} 깊은 복사된 값 또는 fallback
+ */
+export function jsonClone(value, fallback = null) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    } catch (error) {
+        return fallback;
+    }
+}
+
+/**
+ * 얕은 복사를 수행합니다.
+ * 첫 번째 레벨만 복사하고 중첩된 객체는 참조를 유지합니다.
+ *
+ * @param {*} value - 복사할 값
+ * @returns {*} 얕은 복사된 값
+ */
+export function shallowClone(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+
+    if (Array.isArray(value)) {
+        return [...value];
+    }
+
+    return { ...value };
+}
+
+/**
+ * 두 객체를 깊은 병합합니다.
+ * target에 source의 값을 병합합니다 (source가 우선).
+ *
+ * @param {Object} target - 대상 객체
+ * @param {Object} source - 소스 객체
+ * @returns {Object} 병합된 새 객체
+ */
+export function deepMerge(target, source) {
+    if (source === null || typeof source !== 'object') {
+        return source;
+    }
+
+    if (target === null || typeof target !== 'object') {
+        return deepClone(source);
+    }
+
+    if (Array.isArray(source)) {
+        return deepClone(source);
+    }
+
+    const result = { ...target };
+
+    for (const key of Object.keys(source)) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+
+        if (
+            sourceValue !== null &&
+            typeof sourceValue === 'object' &&
+            !Array.isArray(sourceValue) &&
+            targetValue !== null &&
+            typeof targetValue === 'object' &&
+            !Array.isArray(targetValue)
+        ) {
+            result[key] = deepMerge(targetValue, sourceValue);
+        } else {
+            result[key] = deepClone(sourceValue);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * 객체가 깊은 복사 가능한지 (JSON 직렬화 가능한지) 검사합니다.
+ *
+ * @param {*} value - 검사할 값
+ * @returns {boolean} JSON 직렬화 가능하면 true
+ */
+export function isCloneable(value) {
+    try {
+        JSON.stringify(value);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/util/config.js

@@ -41,10 +41,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 사용 권장)
@@ -74,7 +84,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 +92,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 +148,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 +161,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/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
+    };
+}