aiexecode 1.0.94 → 1.0.127

package/src/system/tool_approval.js

@@ -102,6 +102,11 @@ async function willDefinitelyFail(toolName, args) {
  * @returns {Promise<boolean|{skipApproval: true, reason: string}>} 승인 필요 여부 또는 스킵 정보
  */
 export async function requiresApproval(toolName, args = {}) {
+    // --dangerously-skip-permissions 플래그가 설정된 경우 모든 승인 건너뛰기
+    if (process.app_custom?.dangerouslySkipPermissions) {
+        return false;
+    }
+
     if (alwaysAllowedTools.has(toolName)) {
         return false;
     }
@@ -123,6 +128,11 @@ export async function requiresApproval(toolName, args = {}) {
  * 사용자에게 도구 실행 승인 요청
  */
 export async function requestApproval(toolName, args) {
+    // --dangerously-skip-permissions 플래그가 설정된 경우 즉시 승인
+    if (process.app_custom?.dangerouslySkipPermissions) {
+        return true;
+    }
+
     // 항상 허용된 도구는 즉시 승인
     if (alwaysAllowedTools.has(toolName)) {
         return true;

package/src/system/tool_registry.js

@@ -11,6 +11,19 @@ import { RESPONSE_MESSAGE_FUNCTIONS, responseMessageSchema } from '../tools/resp
 import { TODO_WRITE_FUNCTIONS, todoWriteSchema } from '../tools/todo_write.js';
 import { runPythonCodeSchema, bashSchema } from '../system/code_executer.js';
 
+// invoke_skill UI 표시 설정
+const invokeSkillDisplayConfig = {
+    ui_display: {
+        show_tool_call: true,
+        show_tool_result: false,
+        display_name: 'Skill',
+        format_tool_call: (args) => {
+            const skillName = args?.skill_name || 'unknown';
+            return `(${skillName})`;
+        }
+    }
+};
+
 // 도구 스키마 레지스트리
 const TOOL_SCHEMAS = {
     'response_message': responseMessageSchema,
@@ -24,7 +37,8 @@ const TOOL_SCHEMAS = {
     'ripgrep': ripgrepSchema,
     'run_python_code': runPythonCodeSchema,
     'bash': bashSchema,
-    'todo_write': todoWriteSchema
+    'todo_write': todoWriteSchema,
+    'invoke_skill': invokeSkillDisplayConfig
 };
 
 /**

package/src/system/ui_events.js

@@ -45,6 +45,17 @@ class UIEventEmitter extends EventEmitter {
         });
     }
 
+    /**
+     * 스킬 실행 알림
+     */
+    addSkillInvoked(skillName) {
+        this.emit('history:add', {
+            type: 'skill_invoked',
+            text: `/${skillName}`,
+            timestamp: Date.now()
+        });
+    }
+
     /**
      * 도구 실행 시작
      */

package/src/tools/code_editor.js

@@ -3,7 +3,7 @@ import { dirname, resolve, join } from 'path';
 import * as diff from 'diff';
 import { assertFileIntegrity, trackFileRead, saveFileSnapshot } from '../system/file_integrity.js';
 import { createDebugLogger } from '../util/debug_log.js';
-import { DEBUG_LOG_DIR } from '../util/config.js';
+import { DEBUG_LOG_DIR, isDebugModeEnabled } from '../util/config.js';
 import { toDisplayPath } from '../util/path_helper.js';
 import { theme } from '../frontend/design/themeColors.js';
 
@@ -105,9 +105,11 @@ export async function write_file({ file_path, content }) {
             } catch (integrityError) {
                 internalDebugLog.push(`[${timestamp}] assertFileIntegrity FAILED: ${integrityError.message}`);
                 debugLog(`ERROR: assertFileIntegrity FAILED: ${integrityError.message}`);
-                const logFile = getLogFile();
-                await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
-                await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n');
+                if (isDebugModeEnabled()) {
+                    const logFile = getLogFile();
+                    await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+                    await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n');
+                }
                 throw integrityError;
             }
         }
@@ -130,9 +132,11 @@ export async function write_file({ file_path, content }) {
         saveFileSnapshot(absolutePath, content);
         debugLog(`Snapshot saved`);
 
-        const logFile = getLogFile();
-        await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
-        await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n');
+        if (isDebugModeEnabled()) {
+            const logFile = getLogFile();
+            await safeMkdir(dirname(logFile), { recursive: true }).catch(() => {});
+            await safeAppendFile(logFile, internalDebugLog.join('\n') + '\n');
+        }
 
         // diff 생성 (기존 파일이 있었을 경우에만, 절대경로 사용)
         let diffInfo = null;
@@ -176,9 +180,11 @@ export async function write_file({ file_path, content }) {
         debugLog(`Exception caught: ${error.message}`);
         debugLog(`Stack trace: ${error.stack}`);
         debugLog('========== write_file EXCEPTION END ==========');
-        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(() => {});
+        }
 
         // 에러 시에도 절대경로로 반환
         const absolutePath = resolve(file_path);

package/src/tools/file_reader.js

@@ -1,10 +1,15 @@
-import { safeReadFile } from '../util/safe_fs.js';
+import { safeReadFile, safeStat } from '../util/safe_fs.js';
 import { resolve } from 'path';
 import { createHash } from 'crypto';
 import { trackFileRead, saveFileSnapshot } from '../system/file_integrity.js';
+import { markFileAsReRead } from '../system/conversation_trimmer.js';
 import { createDebugLogger } from '../util/debug_log.js';
 import { toDisplayPath } from '../util/path_helper.js';
 import { theme } from '../frontend/design/themeColors.js';
+import {
+    FILE_READER_MAX_LINES as MAX_LINES,
+    FILE_READER_MAX_SIZE_BYTES as MAX_FILE_SIZE_BYTES
+} from '../config/constants.js';
 
 const debugLog = createDebugLogger('file_reader.log', 'file_reader');
 
@@ -32,9 +37,6 @@ export async function read_file({ filePath }) {
     debugLog(`  - filePath starts with '../': ${filePath?.startsWith('../') || false}`);
     debugLog(`  - Current Working Directory: ${process.cwd()}`);
 
-    // Intentional delay for testing pending state
-    await new Promise(resolve => setTimeout(resolve, 13));
-
     try {
         // 경로를 절대경로로 정규화
         const absolutePath = resolve(filePath);
@@ -45,6 +47,30 @@ export async function read_file({ filePath }) {
         debugLog(`  - Absolute path starts with '/': ${absolutePath.startsWith('/')}`);
         debugLog(`  - Absolute path length: ${absolutePath.length}`);
 
+        // 파일 크기 제한 검사 (보안)
+        debugLog(`Checking file size...`);
+        try {
+            const stat = await safeStat(absolutePath);
+            const fileSizeBytes = stat.size;
+            debugLog(`File size: ${fileSizeBytes} bytes (${(fileSizeBytes / 1024 / 1024).toFixed(2)} MB)`);
+
+            if (fileSizeBytes > MAX_FILE_SIZE_BYTES) {
+                debugLog(`ERROR: File exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB size limit`);
+                debugLog('========== read_file ERROR END ==========');
+                // trim된 파일 목록에서 제거 (재읽기 시도했으므로 알림 불필요)
+                markFileAsReRead(absolutePath);
+                return {
+                    operation_successful: false,
+                    error_message: `File exceeds 10MB size limit (actual: ${(fileSizeBytes / 1024 / 1024).toFixed(2)}MB). Large files cannot be read for security reasons.`,
+                    target_file_path: absolutePath,
+                    file_size_bytes: fileSizeBytes
+                };
+            }
+        } catch (statError) {
+            // stat 실패 시 파일이 존재하지 않을 수 있음 - 읽기에서 처리
+            debugLog(`Stat failed (file may not exist): ${statError.message}`);
+        }
+
         debugLog(`Reading file...`);
         const content = await safeReadFile(absolutePath, 'utf8');
         debugLog(`File read successful: ${content.length} bytes`);
@@ -56,11 +82,12 @@ export async function read_file({ filePath }) {
             (content.endsWith('\n') ? lines.length - 1 : lines.length);
         debugLog(`Total lines: ${totalLines}`);
 
-        // 2000줄 제한 체크
-        const MAX_LINES = 2000;
+        // 줄 수 제한 체크
         if (totalLines > MAX_LINES) {
             debugLog(`ERROR: File exceeds ${MAX_LINES} lines limit`);
             debugLog('========== read_file ERROR END ==========');
+            // trim된 파일 목록에서 제거 (재읽기 시도했으므로 알림 불필요)
+            markFileAsReRead(absolutePath);
             return {
                 operation_successful: false,
                 error_message: `File exceeds ${MAX_LINES} lines (actual: ${totalLines} lines). Use read_file_range to read specific sections of this large file.`,
@@ -76,6 +103,9 @@ export async function read_file({ filePath }) {
         await trackFileRead(absolutePath, content);
         debugLog(`File read tracked`);
 
+        // trim된 파일 목록에서 제거 (다시 읽었으므로 알림 불필요)
+        markFileAsReRead(absolutePath);
+
         // 스냅샷 저장 (UI 미리보기용)
         debugLog(`Saving file snapshot...`);
         saveFileSnapshot(absolutePath, content);
@@ -103,6 +133,8 @@ export async function read_file({ filePath }) {
 
         // 에러 시에도 절대경로로 반환
         const absolutePath = resolve(filePath);
+        // trim된 파일 목록에서 제거 (재읽기 시도했으므로 알림 불필요)
+        markFileAsReRead(absolutePath);
         return {
             operation_successful: false,
             error_message: error.message,
@@ -172,9 +204,6 @@ export async function read_file_range({ filePath, startLine, endLine }) {
     debugLog(`  endLine: ${endLine}`);
     debugLog(`  - Current Working Directory: ${process.cwd()}`);
 
-    // Intentional delay for testing pending state
-    await new Promise(resolve => setTimeout(resolve, 13));
-
     try {
         // 경로를 절대경로로 정규화
         const absolutePath = resolve(filePath);
@@ -185,6 +214,29 @@ export async function read_file_range({ filePath, startLine, endLine }) {
         debugLog(`  - Absolute path starts with '/': ${absolutePath.startsWith('/')}`);
         debugLog(`  - Absolute path length: ${absolutePath.length}`);
 
+        // 파일 크기 제한 검사 (보안)
+        debugLog(`Checking file size...`);
+        try {
+            const stat = await safeStat(absolutePath);
+            const fileSizeBytes = stat.size;
+            debugLog(`File size: ${fileSizeBytes} bytes (${(fileSizeBytes / 1024 / 1024).toFixed(2)} MB)`);
+
+            if (fileSizeBytes > MAX_FILE_SIZE_BYTES) {
+                debugLog(`ERROR: File exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB size limit`);
+                debugLog('========== read_file_range ERROR END ==========');
+                // trim된 파일 목록에서 제거 (재읽기 시도했으므로 알림 불필요)
+                markFileAsReRead(absolutePath);
+                return {
+                    operation_successful: false,
+                    error_message: `File exceeds 10MB size limit (actual: ${(fileSizeBytes / 1024 / 1024).toFixed(2)}MB). Large files cannot be read for security reasons.`,
+                    target_file_path: absolutePath,
+                    file_size_bytes: fileSizeBytes
+                };
+            }
+        } catch (statError) {
+            debugLog(`Stat failed (file may not exist): ${statError.message}`);
+        }
+
         // 파일 전체를 읽고 범위만 추출
         debugLog(`Reading file...`);
         const content = await safeReadFile(absolutePath, 'utf8');
@@ -206,6 +258,9 @@ export async function read_file_range({ filePath, startLine, endLine }) {
         await trackFileRead(absolutePath, content);
         debugLog(`File read tracked`);
 
+        // trim된 파일 목록에서 제거 (다시 읽었으므로 알림 불필요)
+        markFileAsReRead(absolutePath);
+
         // 스냅샷 저장 (UI 미리보기용)
         debugLog(`Saving file snapshot...`);
         saveFileSnapshot(absolutePath, content);
@@ -263,6 +318,8 @@ export async function read_file_range({ filePath, startLine, endLine }) {
 
         // 에러 시에도 절대경로로 반환
         const absolutePath = resolve(filePath);
+        // trim된 파일 목록에서 제거 (재읽기 시도했으므로 알림 불필요)
+        markFileAsReRead(absolutePath);
         return {
             operation_successful: false,
             error_message: error.message,

package/src/tools/glob.js

@@ -40,9 +40,6 @@ export async function globSearch({
     debugLog(`  maxResults: ${maxResults}`);
     debugLog(`  - Current Working Directory: ${process.cwd()}`);
 
-    // Intentional delay for testing pending state
-    await new Promise(resolve => setTimeout(resolve, 13));
-
     try {
         if (typeof pattern !== 'string' || !pattern.trim()) {
             debugLog(`ERROR: Invalid pattern`);

package/src/tools/ripgrep.js

@@ -1,12 +1,13 @@
 import { spawn } from 'child_process';
 import { theme } from '../frontend/design/themeColors.js';
+import {
+    RIPGREP_DEFAULT_TIMEOUT_MS as DEFAULT_TIMEOUT_MS,
+    RIPGREP_DEFAULT_MAX_COUNT as DEFAULT_MAX_COUNT,
+    RIPGREP_MAX_OUTPUT_SIZE as MAX_OUTPUT_SIZE
+} from '../config/constants.js';
 
 // 파일 내용 검색, 파일 경로 필터링, 다양한 출력 모드 등을 지원합니다.
 
-const DEFAULT_TIMEOUT_MS = 120000;
-const DEFAULT_MAX_COUNT = 500;
-const MAX_OUTPUT_SIZE = 30000; // 30KB 출력 크기 제한
-
 /**
  * ripgrep 인수를 구성합니다
  */
@@ -332,9 +333,6 @@ export async function ripgrep({
     head_limit: headLimit = null,
     includeHidden = false
 }) {
-    // Intentional delay for testing pending state
-    await new Promise(resolve => setTimeout(resolve, 13));
-
     if (typeof pattern !== 'string' || !pattern.trim()) {
         return {
             operation_successful: false,

package/src/tools/skill_tool.js

@@ -0,0 +1,122 @@
+/**
+ * Skill Tool
+ * AI Agent가 스킬을 호출할 수 있는 도구
+ */
+
+import { discoverAllSkills, loadSkillAsPrompt } from '../system/skill_loader.js';
+import { createDebugLogger } from '../util/debug_log.js';
+
+const debugLog = createDebugLogger('skill_tool.log', 'skill_tool');
+
+/**
+ * 스킬 호출 도구 스키마
+ */
+export const skillSchema = {
+    type: "function",
+    function: {
+        name: "invoke_skill",
+        description: `스킬을 호출하여 특정 작업을 수행합니다.
+스킬은 특정 작업에 대한 전문화된 지침을 제공합니다.
+사용 가능한 스킬 목록은 시스템 프롬프트의 "Available Skills" 섹션을 참조하세요.
+
+사용 시점:
+- 사용자가 슬래시 커맨드(/skill-name)를 요청할 때
+- 특정 작업에 적합한 스킬이 있을 때
+- 코드 리뷰, 설명 등 전문화된 작업이 필요할 때`,
+        parameters: {
+            type: "object",
+            properties: {
+                skill_name: {
+                    type: "string",
+                    description: "호출할 스킬 이름 (예: 'code-review', 'explain')"
+                },
+                arguments: {
+                    type: "string",
+                    description: "스킬에 전달할 인자 (예: 파일 경로, 설명할 대상 등)"
+                }
+            },
+            required: ["skill_name"]
+        }
+    }
+};
+
+/**
+ * 스킬 호출 함수
+ * @param {Object} params - 스킬 호출 파라미터
+ * @param {string} params.skill_name - 스킬 이름
+ * @param {string} [params.arguments] - 스킬 인자
+ * @returns {Promise<Object>} 스킬 실행 결과
+ */
+export async function invokeSkill({ skill_name, arguments: args = '' }) {
+    debugLog(`[invokeSkill] Invoking skill: ${skill_name} with args: ${args}`);
+
+    const result = await loadSkillAsPrompt(skill_name, args);
+
+    if (!result) {
+        debugLog(`[invokeSkill] Skill not found: ${skill_name}`);
+        return {
+            success: false,
+            error: `Skill not found: ${skill_name}`,
+            available_skills: await getAvailableSkillNames()
+        };
+    }
+
+    debugLog(`[invokeSkill] Skill loaded successfully: ${skill_name}`);
+
+    return {
+        success: true,
+        skill_name: result.skill.name,
+        skill_description: result.skill.description,
+        skill_instructions: result.prompt,
+        source: result.skill.source
+    };
+}
+
+/**
+ * 사용 가능한 스킬 이름 목록 반환
+ * @returns {Promise<string[]>}
+ */
+async function getAvailableSkillNames() {
+    const skills = await discoverAllSkills();
+    return skills.map(s => s.name);
+}
+
+/**
+ * 시스템 프롬프트에 추가할 스킬 목록 텍스트 생성
+ * @returns {Promise<string>}
+ */
+export async function generateSkillListForPrompt() {
+    const skills = await discoverAllSkills();
+
+    if (skills.length === 0) {
+        return '';
+    }
+
+    const lines = [
+        '',
+        '## Available Skills',
+        '',
+        '다음 스킬들을 사용하여 특정 작업을 수행할 수 있습니다.',
+        '스킬을 사용하려면 invoke_skill 도구를 호출하세요.',
+        ''
+    ];
+
+    for (const skill of skills) {
+        const desc = skill.description || '(설명 없음)';
+        lines.push(`- **${skill.name}**: ${desc}`);
+    }
+
+    lines.push('');
+    lines.push('사용자가 슬래시 커맨드(예: /code-review)를 요청하거나,');
+    lines.push('위 스킬이 도움이 될 수 있는 작업을 요청하면 해당 스킬을 호출하세요.');
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+/**
+ * 스킬 도구 함수 맵
+ */
+export const SKILL_FUNCTIONS = {
+    invoke_skill: invokeSkill
+};

package/src/tools/web_downloader.js

@@ -19,9 +19,6 @@ import { theme } from '../frontend/design/themeColors.js';
  * @returns {Promise<{operation_successful: boolean, url: string, content: string, error_message: string|null}>} 결과 객체
  */
 export async function fetch_web_page({ url }) {
-    // Intentional delay for testing pending state
-    await new Promise(resolve => setTimeout(resolve, 13));
-
     const timeout = 30;
     const user_agent = 'Mozilla/5.0 (compatible; WebFetcher/1.0)';
     const encoding = 'utf-8';

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