aiexecode 1.0.92 → 1.0.96

package/src/system/session.js

@@ -9,6 +9,7 @@ import { CODE_EDITOR_FUNCTIONS } from "../tools/code_editor.js";
 import { WEB_DOWNLOADER_FUNCTIONS } from "../tools/web_downloader.js";
 import { RESPONSE_MESSAGE_FUNCTIONS } from '../tools/response_message.js';
 import { TODO_WRITE_FUNCTIONS } from '../tools/todo_write.js';
+import { SKILL_FUNCTIONS } from '../tools/skill_tool.js';
 import { clampOutput, formatToolStdout } from "../util/output_formatter.js";
 import { buildToolHistoryEntry } from "../util/rag_helper.js";
 import { createSessionData, getLastConversationState, loadPreviousSessions, saveSessionToHistory, saveTodosToSession, restoreTodosFromSession, updateCurrentTodos, getCurrentTodos } from "./session_memory.js";
@@ -21,16 +22,14 @@ import { safeReadFile } from '../util/safe_fs.js';
 import { resolve } from 'path';
 import { createDebugLogger } from '../util/debug_log.js';
 import { ERROR_VERBOSITY } from '../config/feature_flags.js';
+import {
+    MAX_REASONING_ONLY_RESPONSES,
+    DEFAULT_MAX_ITERATIONS,
+    SUB_MISSION_MAX_LENGTH
+} from '../config/constants.js';
 
 const debugLog = createDebugLogger('session.log', 'session');
 
-/**
- * 상수 정의
- */
-const MAX_REASONING_ONLY_RESPONSES = 5;
-const DEFAULT_MAX_ITERATIONS = 50;
-const SUB_MISSION_MAX_LENGTH = 120;
-
 
 /**
  * 서브미션 이름을 추론하는 헬퍼 함수
@@ -391,6 +390,9 @@ async function processOrchestratorResponses(params) {
         );
         debugLog(`Has processable output: ${hasProcessableOutput}`);
 
+        // pendingMessageOutput은 while 루프 스코프에서 유지 (function call 없이 끝날 때 출력용)
+        let pendingMessageOutput = null;
+
         if (!hasProcessableOutput) {
             debugLog(`No processable output, reasoningOnlyResponses: ${reasoningOnlyResponses}`);
             if (reasoningOnlyResponses >= MAX_REASONING_ONLY_RESPONSES) {
@@ -419,7 +421,6 @@ async function processOrchestratorResponses(params) {
         reasoningOnlyResponses = 0;
         let executedFunctionCall = false;
         let lastOutputType = null;
-        let pendingMessageOutput = null; // 출력 대기 중인 MESSAGE 저장
 
         // 각 출력 처리
         for (let outputIndex = 0; outputIndex < outputs.length; outputIndex++) {
@@ -598,8 +599,33 @@ async function processOrchestratorResponses(params) {
 
         // 완료 조건 체크
         debugLog(`Checking completion conditions...`);
-        if (!executedFunctionCall && lastOutputType === 'message') {
-            debugLog(`COMPLETION: No function call + message type - judging if mission is truly complete`);
+        debugLog(`  executedFunctionCall: ${executedFunctionCall}, hadAnyFunctionCall: ${hadAnyFunctionCall}, lastOutputType: ${lastOutputType}`);
+
+        // Case 1: Function call 없이 message만 있는 경우 (단순 대화, 인사 등)
+        // → Completion Judge 없이 바로 message 출력하고 완료
+        if (!executedFunctionCall && lastOutputType === 'message' && !hadAnyFunctionCall) {
+            debugLog(`COMPLETION: No function call at all + message type - completing immediately without Completion Judge`);
+
+            // 대기 중인 메시지 출력
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message immediately`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
+
+            missionSolved = true;
+            break;
+        }
+
+        // Case 2: Function call 실행 후 message로 결과 보고
+        // → message 먼저 출력 → Completion Judge로 추가 작업 판단
+        if (!executedFunctionCall && lastOutputType === 'message' && hadAnyFunctionCall) {
+            debugLog(`COMPLETION: Had function calls + final message - displaying message first, then judging completion`);
+
+            // 먼저 message 출력 (사용자가 바로 결과 확인 가능)
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message before completion judge`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
 
             // 세션 중단 확인 (completion_judge 호출 전)
             if (sessionInterrupted) {
@@ -646,45 +672,30 @@ async function processOrchestratorResponses(params) {
             missionSolved = judgement.shouldComplete;
 
             if (missionSolved) {
-                // 미션이 완료되었다고 판단되면 대기 중인 메시지 출력 후 종료
-                debugLog(`Mission judged as complete, displaying pending message and breaking loop`);
-                if (pendingMessageOutput) {
-                    processMessageOutput(pendingMessageOutput, true); // 이제 출력
-                }
+                // 미션이 완료되었다고 판단 (message는 이미 출력됨)
+                debugLog(`Mission judged as complete, breaking loop`);
                 break;
             } else {
-                // 미션이 완료되지 않았다고 판단되면 메시지를 출력하지 않고 계속 진행
-                debugLog(`Mission not complete, continuing without displaying message`);
-
-                // orchestratorConversation에서 방금 추가된 assistant message에 _internal_only 플래그 추가
-                const conversation = getOrchestratorConversation();
-                for (let i = conversation.length - 1; i >= 0; i--) {
-                    const entry = conversation[i];
-                    if (entry.type === 'message' && entry.role === 'assistant') {
-                        entry._internal_only = true;
-                        debugLog(`[_internal_only] Marked assistant message at index ${i} as internal-only (not for display)`);
-                        break;
-                    }
-                }
+                // 미션이 완료되지 않았다고 판단되면 계속 진행
+                // (message는 이미 출력됨 - 사용자가 진행 상황 확인 가능)
+                debugLog(`Mission not complete, continuing...`);
 
                 // whatUserShouldSay를 새로운 사용자 요구사항으로 처리
                 if (judgement.whatUserShouldSay && judgement.whatUserShouldSay.trim().length > 0) {
                     debugLog(`Treating whatUserShouldSay as new user request: ${judgement.whatUserShouldSay}`);
-                    // 💬 Auto-continuing 메시지 제거
 
                     // whatUserShouldSay를 새로운 mission으로 설정하여 루프를 빠져나감
-                    // 상위 runSession 루프에서 다시 orchestrateMission이 호출될 것임
                     improvementPoints = judgement.whatUserShouldSay;
-                    improvementPointsIsAutoGenerated = true; // auto-generated 플래그 설정
+                    improvementPointsIsAutoGenerated = true;
                     debugLog(`[_internal_only] Set improvementPointsIsAutoGenerated=true for whatUserShouldSay`);
-                    missionSolved = false;  // 완료되지 않았으므로 상위 루프 계속
-                    break;  // processOrchestratorResponses 루프 종료
+                    missionSolved = false;
+                    break;
                 } else {
                     // whatUserShouldSay가 없으면 빈 문자열로 계속 진행
                     improvementPoints = "";
                     debugLog(`Continuing mission without whatUserShouldSay`);
 
-                    // 세션 중단 확인 (continueOrchestratorConversation 호출 전)
+                    // 세션 중단 확인
                     if (sessionInterrupted) {
                         debugLog(`Session interrupted before continueOrchestratorConversation, breaking loop`);
                         break;
@@ -693,7 +704,7 @@ async function processOrchestratorResponses(params) {
                     try {
                         orchestratedResponse = await continueOrchestratorConversation();
                         debugLog(`Received response with ${orchestratedResponse?.output?.length || 0} outputs`);
-                        continue; // 루프 처음으로 돌아가서 새 응답 처리
+                        continue;
                     } catch (err) {
                         if (err.name === 'AbortError' || sessionInterrupted) {
                             debugLog(`Conversation aborted or interrupted: ${err.name}`);
@@ -706,11 +717,23 @@ async function processOrchestratorResponses(params) {
             }
         }
 
+        // Case 3: Function call이 없는 기타 경우
         if (!executedFunctionCall) {
             debugLog(`COMPLETION: No function call executed (other cases), breaking loop`);
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message before completion`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
             break;
         }
 
+        // Function call 실행 후 계속 진행하기 전에 pending message가 있으면 출력
+        // (function_call과 message가 같이 온 경우)
+        if (pendingMessageOutput) {
+            debugLog(`Displaying pending message before continuing (function_call + message case)`);
+            processMessageOutput(pendingMessageOutput, true);
+        }
+
         // continueOrchestratorConversation 호출
         debugLog(`Continuing orchestrator conversation for next iteration...`);
         try {
@@ -899,6 +922,7 @@ export async function runSession(options) {
             ...GLOB_FUNCTIONS,
             ...RESPONSE_MESSAGE_FUNCTIONS,
             ...TODO_WRITE_FUNCTIONS,
+            ...SKILL_FUNCTIONS,  // 스킬 호출 도구
             ...mcpToolFunctions,
             "bash": async (args) => execShellScript(args.script)
         };

package/src/system/skill_loader.js

@@ -0,0 +1,318 @@
+/**
+ * Skill Loader
+ *
+ * Claude Code 스타일의 스킬 시스템 구현
+ * 스킬은 SKILL.md 파일이 포함된 폴더로, AI에게 특정 작업 수행 방법을 가르칩니다.
+ *
+ * 스킬 위치 (우선순위 순):
+ * 1. Project: CWD/.aiexe/skills/<skill-name>/SKILL.md
+ * 2. Personal: ~/.aiexe/skills/<skill-name>/SKILL.md
+ */
+
+import { join, basename, dirname } from 'path';
+import { safeReadFile, safeReaddir, safeStat, safeAccess } from '../util/safe_fs.js';
+import { PERSONAL_SKILLS_DIR, PROJECT_SKILLS_DIR } from '../util/config.js';
+import { createDebugLogger } from '../util/debug_log.js';
+
+const debugLog = createDebugLogger('skill_loader.log', 'skill_loader');
+
+/**
+ * 스킬 정보 객체
+ * @typedef {Object} Skill
+ * @property {string} name - 스킬 이름 (폴더명 또는 frontmatter의 name)
+ * @property {string} description - 스킬 설명
+ * @property {string} path - SKILL.md 파일 경로
+ * @property {string} directory - 스킬 폴더 경로
+ * @property {string} source - 'project' | 'personal'
+ * @property {Object} frontmatter - YAML frontmatter 파싱 결과
+ * @property {string} content - 마크다운 내용 (frontmatter 제외)
+ */
+
+/**
+ * YAML frontmatter를 파싱합니다.
+ * @param {string} content - SKILL.md 파일 내용
+ * @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} skillDir - 스킬 폴더 경로
+ * @param {string} source - 'project' | 'personal'
+ * @returns {Promise<Skill|null>}
+ */
+async function loadSkillFromDirectory(skillDir, source) {
+    const skillMdPath = join(skillDir, 'SKILL.md');
+
+    try {
+        await safeAccess(skillMdPath);
+    } catch {
+        debugLog(`[loadSkillFromDirectory] No SKILL.md found in ${skillDir}`);
+        return null;
+    }
+
+    try {
+        const content = await safeReadFile(skillMdPath, 'utf8');
+        const { frontmatter, content: markdownContent } = parseFrontmatter(content);
+
+        const folderName = basename(skillDir);
+        const name = frontmatter.name || folderName;
+
+        // description이 없으면 마크다운 첫 단락 사용
+        let description = frontmatter.description;
+        if (!description && markdownContent) {
+            const firstParagraph = markdownContent.split('\n\n')[0];
+            description = firstParagraph.replace(/^#.*\n?/, '').trim().substring(0, 200);
+        }
+
+        const skill = {
+            name,
+            description: description || '',
+            path: skillMdPath,
+            directory: skillDir,
+            source,
+            frontmatter,
+            content: markdownContent
+        };
+
+        debugLog(`[loadSkillFromDirectory] Loaded skill: ${name} from ${source}`);
+        return skill;
+    } catch (error) {
+        debugLog(`[loadSkillFromDirectory] Error loading skill from ${skillDir}: ${error.message}`);
+        return null;
+    }
+}
+
+/**
+ * 지정된 디렉토리에서 모든 스킬을 검색합니다.
+ * @param {string} skillsDir - 스킬 폴더 경로
+ * @param {string} source - 'project' | 'personal'
+ * @returns {Promise<Skill[]>}
+ */
+async function discoverSkillsInDirectory(skillsDir, source) {
+    const skills = [];
+
+    try {
+        await safeAccess(skillsDir);
+    } catch {
+        debugLog(`[discoverSkillsInDirectory] Skills directory not found: ${skillsDir}`);
+        return skills;
+    }
+
+    try {
+        const entries = await safeReaddir(skillsDir);
+
+        for (const entry of entries) {
+            const entryPath = join(skillsDir, entry);
+            const stat = await safeStat(entryPath);
+
+            if (stat.isDirectory()) {
+                const skill = await loadSkillFromDirectory(entryPath, source);
+                if (skill) {
+                    skills.push(skill);
+                }
+            }
+        }
+    } catch (error) {
+        debugLog(`[discoverSkillsInDirectory] Error scanning ${skillsDir}: ${error.message}`);
+    }
+
+    return skills;
+}
+
+/**
+ * 모든 스킬을 검색합니다.
+ * Project 스킬이 Personal 스킬보다 우선순위가 높습니다.
+ * @returns {Promise<Skill[]>}
+ */
+export async function discoverAllSkills() {
+    debugLog('[discoverAllSkills] Starting skill discovery...');
+
+    const allSkills = new Map(); // name -> skill (중복 방지, 우선순위 적용)
+
+    // 1. Personal skills (낮은 우선순위)
+    const personalSkills = await discoverSkillsInDirectory(PERSONAL_SKILLS_DIR, 'personal');
+    for (const skill of personalSkills) {
+        allSkills.set(skill.name, skill);
+    }
+    debugLog(`[discoverAllSkills] Found ${personalSkills.length} personal skills`);
+
+    // 2. Project skills (높은 우선순위 - 덮어씀)
+    const projectSkillsDir = join(process.cwd(), PROJECT_SKILLS_DIR);
+    const projectSkills = await discoverSkillsInDirectory(projectSkillsDir, 'project');
+    for (const skill of projectSkills) {
+        allSkills.set(skill.name, skill);
+    }
+    debugLog(`[discoverAllSkills] Found ${projectSkills.length} project skills`);
+
+    const skills = Array.from(allSkills.values());
+    debugLog(`[discoverAllSkills] Total unique skills: ${skills.length}`);
+
+    return skills;
+}
+
+/**
+ * 이름으로 스킬을 찾습니다.
+ * @param {string} skillName - 스킬 이름
+ * @returns {Promise<Skill|null>}
+ */
+export async function findSkillByName(skillName) {
+    debugLog(`[findSkillByName] Looking for skill: ${skillName}`);
+
+    // Project 스킬 먼저 확인 (높은 우선순위)
+    const projectSkillDir = join(process.cwd(), PROJECT_SKILLS_DIR, skillName);
+    const projectSkill = await loadSkillFromDirectory(projectSkillDir, 'project');
+    if (projectSkill) {
+        debugLog(`[findSkillByName] Found project skill: ${skillName}`);
+        return projectSkill;
+    }
+
+    // Personal 스킬 확인
+    const personalSkillDir = join(PERSONAL_SKILLS_DIR, skillName);
+    const personalSkill = await loadSkillFromDirectory(personalSkillDir, 'personal');
+    if (personalSkill) {
+        debugLog(`[findSkillByName] Found personal skill: ${skillName}`);
+        return personalSkill;
+    }
+
+    debugLog(`[findSkillByName] Skill not found: ${skillName}`);
+    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);
+
+    // $ARGUMENTS가 없었으면 끝에 추가
+    if (result === content && args.trim()) {
+        result = content + '\n\nARGUMENTS: ' + args;
+    }
+
+    return result;
+}
+
+/**
+ * 스킬을 로드하고 프롬프트로 변환합니다.
+ * @param {string} skillName - 스킬 이름
+ * @param {string} [args] - 스킬에 전달할 인자
+ * @returns {Promise<{ prompt: string, skill: Skill } | null>}
+ */
+export async function loadSkillAsPrompt(skillName, args = '') {
+    const skill = await findSkillByName(skillName);
+    if (!skill) {
+        return null;
+    }
+
+    let prompt = skill.content;
+
+    // 인자 치환
+    prompt = substituteArguments(prompt, args);
+
+    // 참조 파일 로드 (선택적)
+    // TODO: reference.md, examples.md 등 자동 로드
+
+    debugLog(`[loadSkillAsPrompt] Loaded skill '${skillName}' with ${args ? 'args' : 'no args'}`);
+
+    return {
+        prompt,
+        skill
+    };
+}
+
+/**
+ * 스킬 목록을 포맷팅하여 반환합니다.
+ * @returns {Promise<string>}
+ */
+export async function formatSkillList() {
+    const skills = await discoverAllSkills();
+
+    if (skills.length === 0) {
+        return [
+            'No skills found.',
+            '',
+            'Skill locations:',
+            `  Personal: ~/.aiexe/skills/<skill-name>/SKILL.md`,
+            `  Project:  .aiexe/skills/<skill-name>/SKILL.md`,
+            '',
+            'Create a skill by making a folder with a SKILL.md file.'
+        ].join('\n');
+    }
+
+    const lines = ['Available Skills:', ''];
+
+    // 소스별 그룹화
+    const projectSkills = skills.filter(s => s.source === 'project');
+    const personalSkills = skills.filter(s => s.source === 'personal');
+
+    if (projectSkills.length > 0) {
+        lines.push('Project Skills (.aiexe/skills/):');
+        for (const skill of projectSkills) {
+            const desc = skill.description ? ` - ${skill.description.substring(0, 60)}` : '';
+            lines.push(`  /${skill.name}${desc}`);
+        }
+        lines.push('');
+    }
+
+    if (personalSkills.length > 0) {
+        lines.push('Personal Skills (~/.aiexe/skills/):');
+        for (const skill of personalSkills) {
+            const desc = skill.description ? ` - ${skill.description.substring(0, 60)}` : '';
+            lines.push(`  /${skill.name}${desc}`);
+        }
+        lines.push('');
+    }
+
+    lines.push('Usage: /<skill-name> [arguments]');
+
+    return lines.join('\n');
+}

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/tools/file_reader.js

@@ -1,10 +1,14 @@
-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 { 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 +36,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 +46,28 @@ 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 ==========');
+                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,8 +79,7 @@ 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 ==========');
@@ -172,9 +194,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 +204,27 @@ 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 ==========');
+                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');

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,