aiexecode 1.0.70 → 1.0.72

package/src/tools/ripgrep.js

@@ -5,6 +5,7 @@ import { theme } from '../frontend/design/themeColors.js';
 
 const DEFAULT_TIMEOUT_MS = 120000;
 const DEFAULT_MAX_COUNT = 500;
+const MAX_OUTPUT_SIZE = 30000; // 30KB 출력 크기 제한
 
 /**
  * ripgrep 인수를 구성합니다
@@ -14,11 +15,12 @@ function buildRipgrepArgs({
     path = null,
     glob = null,
     type = null,
-    caseInsensitive = false,
-    outputMode = 'files_with_matches',
-    contextBefore = 0,
-    contextAfter = 0,
-    context = 0,
+    '-i': caseInsensitive = false,
+    output_mode: outputMode = 'files_with_matches',
+    '-B': contextBefore = 0,
+    '-A': contextAfter = 0,
+    '-C': context = 0,
+    '-n': showLineNumbers = false,
     multiline = false,
     maxCount = DEFAULT_MAX_COUNT,
     includeHidden = false
@@ -59,7 +61,7 @@ function buildRipgrepArgs({
         }
     }
 
-    // 최대 매치 수
+    // 최대 매치 수 (파일당)
     args.push('--max-count', String(maxCount));
 
     // 숨김 파일 포함
@@ -111,6 +113,8 @@ function executeRipgrep(args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
         let stdout = '';
         let stderr = '';
         let isTimedOut = false;
+        let isSizeLimitExceeded = false;
+        let outputSize = 0;
         let timeoutId;
         let settled = false;
         let rg;
@@ -164,7 +168,37 @@ function executeRipgrep(args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
         }, timeoutMs);
 
         rg.stdout.on('data', (data) => {
-            stdout += data.toString();
+            const dataStr = data.toString();
+            outputSize += dataStr.length;
+
+            // 출력 크기 제한 체크
+            if (outputSize > MAX_OUTPUT_SIZE && !isSizeLimitExceeded) {
+                isSizeLimitExceeded = true;
+                stdout += dataStr;
+                stdout += '\n[OUTPUT TRUNCATED: exceeded 30KB limit]';
+
+                // 프로세스 종료
+                try {
+                    process.kill(-rg.pid, 'SIGTERM');
+                    setTimeout(() => {
+                        try {
+                            process.kill(-rg.pid, 'SIGKILL');
+                        } catch (_) {}
+                    }, 1000);
+                } catch (_) {
+                    rg.kill('SIGTERM');
+                    setTimeout(() => {
+                        try {
+                            rg.kill('SIGKILL');
+                        } catch (_) {}
+                    }, 1000);
+                }
+                return;
+            }
+
+            if (!isSizeLimitExceeded) {
+                stdout += dataStr;
+            }
         });
 
         rg.stderr.on('data', (data) => {
@@ -181,6 +215,15 @@ function executeRipgrep(args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
                     stderr: `${trimmedStderr}\n[TIMEOUT] ripgrep terminated due to timeout`.trim(),
                     code: 1,
                     timeout: true,
+                    sizeLimitExceeded: isSizeLimitExceeded,
+                });
+            } else if (isSizeLimitExceeded) {
+                settle({
+                    stdout: trimmedStdout,
+                    stderr: trimmedStderr,
+                    code: 0, // 정상 종료로 처리
+                    timeout: false,
+                    sizeLimitExceeded: true,
                 });
             } else {
                 settle({
@@ -188,6 +231,7 @@ function executeRipgrep(args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
                     stderr: trimmedStderr,
                     code,
                     timeout: false,
+                    sizeLimitExceeded: false,
                 });
             }
         });
@@ -198,6 +242,7 @@ function executeRipgrep(args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
                 stderr: isTimedOut ? `[TIMEOUT] ${err.message}` : err.message,
                 code: 1,
                 timeout: isTimedOut,
+                sizeLimitExceeded: isSizeLimitExceeded,
             });
         });
     });
@@ -206,7 +251,7 @@ function executeRipgrep(args, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
 /**
  * JSON 라인 출력을 파싱하여 파일별로 그룹화합니다
  */
-function parseJsonOutput(buffer) {
+function parseJsonOutput(buffer, showLineNumbers = false) {
     const lines = buffer.split('\n').filter(Boolean);
     const fileResults = {};
 
@@ -221,13 +266,19 @@ function parseJsonOutput(buffer) {
 
                 const filePath = data.path.text;
                 const lineContent = data.lines.text;
+                const lineNumber = data.line_number;
 
                 // 파일별로 그룹화
                 if (!fileResults[filePath]) {
                     fileResults[filePath] = [];
                 }
 
-                fileResults[filePath].push(lineContent);
+                // 라인 번호 표시 옵션
+                if (showLineNumbers && lineNumber !== undefined) {
+                    fileResults[filePath].push(`${lineNumber}:${lineContent}`);
+                } else {
+                    fileResults[filePath].push(lineContent);
+                }
             }
         } catch (_) {
             // JSON 파싱 실패 시 무시
@@ -271,15 +322,15 @@ export async function ripgrep({
     path = null,
     glob = null,
     type = null,
-    caseInsensitive = false,
-    outputMode = 'files_with_matches',
-    contextBefore = 0,
-    contextAfter = 0,
-    context = 0,
+    '-i': caseInsensitive = false,
+    output_mode: outputMode = 'files_with_matches',
+    '-B': contextBefore = 0,
+    '-A': contextAfter = 0,
+    '-C': context = 0,
+    '-n': showLineNumbers = false,
     multiline = false,
-    maxCount = DEFAULT_MAX_COUNT,
-    includeHidden = false,
-    headLimit = null
+    head_limit: headLimit = null,
+    includeHidden = false
 }) {
 
     if (typeof pattern !== 'string' || !pattern.trim()) {
@@ -296,22 +347,32 @@ export async function ripgrep({
     // ripgrep에 전달할 검색 경로 (상대 경로 그대로 전달)
     const searchPath = path;
 
+    // maxCount 결정 (output_mode와 head_limit 기반)
+    let maxCount = DEFAULT_MAX_COUNT;
+    if (outputMode === 'content') {
+        maxCount = 100; // content 모드는 기본 100
+    }
+    if (headLimit && headLimit > 0 && headLimit < maxCount) {
+        maxCount = headLimit; // head_limit이 더 작으면 사용
+    }
+
     const args = buildRipgrepArgs({
         pattern: pattern.trim(),
         path: searchPath,
         glob,
         type,
-        caseInsensitive,
-        outputMode,
-        contextBefore,
-        contextAfter,
-        context,
+        '-i': caseInsensitive,
+        output_mode: outputMode,
+        '-B': contextBefore,
+        '-A': contextAfter,
+        '-C': context,
+        '-n': showLineNumbers,
         multiline,
         maxCount,
         includeHidden
     });
 
-    const { stdout, stderr, code, timeout } = await executeRipgrep(args, resolvedCwd);
+    const { stdout, stderr, code, timeout, sizeLimitExceeded } = await executeRipgrep(args, resolvedCwd);
 
     let results = [];
     let totalMatches = 0;
@@ -324,14 +385,37 @@ export async function ripgrep({
         results = parseCountOutput(stdout);
         totalMatches = Object.values(results).reduce((sum, count) => sum + count, 0);
     } else {
-        results = parseJsonOutput(stdout);
+        results = parseJsonOutput(stdout, showLineNumbers);
         // 파일별 그룹화된 결과에서 총 매치 수 계산
         totalMatches = Object.values(results).reduce((sum, matches) => sum + matches.length, 0);
     }
 
-    // headLimit 적용 (files_with_matches 모드에서만 적용)
-    if (headLimit && headLimit > 0 && outputMode === 'files_with_matches') {
-        results = results.slice(0, headLimit);
+    // headLimit 적용 (모든 출력 모드)
+    if (headLimit && headLimit > 0) {
+        if (outputMode === 'files_with_matches') {
+            // 파일 목록 제한
+            results = results.slice(0, headLimit);
+        } else if (outputMode === 'count') {
+            // count 모드: 상위 N개 파일만
+            const entries = Object.entries(results).slice(0, headLimit);
+            results = Object.fromEntries(entries);
+        } else if (outputMode === 'content') {
+            // content 모드: 전체 매칭 라인을 headLimit까지만
+            const limitedResults = {};
+            let lineCount = 0;
+
+            for (const [file, matches] of Object.entries(results)) {
+                if (lineCount >= headLimit) break;
+
+                limitedResults[file] = [];
+                for (const match of matches) {
+                    if (lineCount >= headLimit) break;
+                    limitedResults[file].push(match);
+                    lineCount++;
+                }
+            }
+            results = limitedResults;
+        }
     }
 
     const noResult = !timeout && code === 1 && (
@@ -342,8 +426,12 @@ export async function ripgrep({
     const success = !timeout && (code === 0 || noResult);
 
     let errorMessage = '';
+    let warningMessage = '';
+
     if (timeout) {
         errorMessage = '검색 명령이 제한 시간을 초과했습니다.';
+    } else if (sizeLimitExceeded) {
+        warningMessage = '출력 크기가 30KB를 초과하여 결과가 잘렸습니다. 더 구체적인 검색어나 필터를 사용하세요.';
     } else if (!success) {
         errorMessage = stderr || 'ripgrep 실행 중 오류가 발생했습니다.';
     } else if (noResult) {
@@ -358,6 +446,11 @@ export async function ripgrep({
         pattern_used: pattern.trim(),
     };
 
+    // 경고 메시지 추가
+    if (warningMessage) {
+        response.warning_message = warningMessage;
+    }
+
     // 에러가 있을 경우에만 raw_stderr 포함
     if (stderr) {
         response.raw_stderr = stderr;
@@ -368,63 +461,63 @@ export async function ripgrep({
 
 export const ripgrepSchema = {
     name: 'ripgrep',
-    description: 'ripgrep을 사용하여 프로젝트 전역에서 파일 내용을 검색합니다. 정규식 패턴, 파일 타입 필터링, 다양한 출력 모드를 지원합니다.',
+    description: 'A powerful search tool built on ripgrep. Supports full regex syntax, file filtering with glob/type parameters, and multiple output modes.',
     strict: false,
     parameters: {
         type: 'object',
         properties: {
             pattern: {
                 type: 'string',
-                description: '검색할 정규식 패턴',
+                description: 'The regular expression pattern to search for in file contents',
             },
             path: {
                 type: 'string',
-                description: '검색할 경로 (선택 사항, 생략 시 프로젝트 루트)',
+                description: 'File or directory to search in (rg PATH). Defaults to current working directory.',
             },
             glob: {
                 type: 'string',
-                description: 'Glob 패턴으로 파일 필터링 (선택 사항, 예: "*.js", "**/*.tsx")',
+                description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob',
             },
             type: {
                 type: 'string',
-                description: '파일 타입 필터 (선택 사항, js, py, rust, go, java 등)',
+                description: 'File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types.',
             },
-            caseInsensitive: {
+            '-i': {
                 type: 'boolean',
-                description: '대소문자를 구분하지 않고 검색 (선택 사항, 기본값: false)',
+                description: 'Case insensitive search (rg -i)',
             },
-            outputMode: {
+            output_mode: {
                 type: 'string',
                 enum: ['content', 'files_with_matches', 'count'],
-                description: '출력 모드 (선택 사항, 기본값: files_with_matches): content(매칭된 라인), files_with_matches(파일 경로만), count(매칭 횟수)',
+                description: 'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".',
             },
-            contextBefore: {
+            '-B': {
                 type: 'number',
-                description: '매칭 전 N줄 표시 (선택 사항, content 모드에서만)',
+                description: 'Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.',
             },
-            contextAfter: {
+            '-A': {
                 type: 'number',
-                description: '매칭 후 N줄 표시 (선택 사항, content 모드에서만)',
+                description: 'Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.',
             },
-            context: {
+            '-C': {
                 type: 'number',
-                description: '매칭 전후 N줄 표시 (선택 사항, content 모드에서만)',
+                description: 'Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.',
+            },
+            '-n': {
+                type: 'boolean',
+                description: 'Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise.',
             },
             multiline: {
                 type: 'boolean',
-                description: '멀티라인 검색 활성화 (선택 사항, 여러 줄에 걸친 패턴 매칭)',
+                description: 'Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.',
             },
-            maxCount: {
+            head_limit: {
                 type: 'number',
-                description: '파일당 최대 매칭 수 (선택 사항, 기본값: 500)',
+                description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). When unspecified, shows all results from ripgrep.',
             },
             includeHidden: {
                 type: 'boolean',
-                description: '숨김 파일 포함 여부 (선택 사항, 기본값: false)',
-            },
-            headLimit: {
-                type: 'number',
-                description: '출력 결과 수 제한 (선택 사항, 첫 N개만 반환)',
+                description: 'Include hidden files and directories in the search (rg --hidden). Default: false.',
             },
         },
         required: ['pattern'],

package/src/tools/todo_write.js

@@ -0,0 +1,182 @@
+import { uiEvents } from '../system/ui_events.js';
+import { createDebugLogger } from '../util/debug_log.js';
+import { theme } from '../frontend/design/themeColors.js';
+import { updateCurrentTodos } from '../system/session_memory.js';
+
+const debugLog = createDebugLogger('todo_write.log', 'todo_write');
+
+/**
+ * Todo 관리 도구
+ * 현재 코딩 세션의 작업 목록을 생성하고 관리합니다.
+ */
+
+/**
+ * Todo 리스트를 업데이트합니다
+ * @param {Object} params - 매개변수 객체
+ * @param {Array} params.todos - Todo 항목 배열
+ * @returns {Promise<Object>} 결과 객체
+ */
+export async function todo_write({ todos }) {
+    debugLog('========== todo_write START ==========');
+    debugLog(`Input todos count: ${todos?.length || 0}`);
+
+    try {
+        // todos 배열 유효성 검증
+        if (!Array.isArray(todos)) {
+            debugLog('ERROR: todos is not an array');
+            debugLog('========== todo_write ERROR END ==========');
+            return {
+                operation_successful: false,
+                error_message: 'todos must be an array'
+            };
+        }
+
+        // 각 todo 항목 검증
+        for (let i = 0; i < todos.length; i++) {
+            const todo = todos[i];
+            debugLog(`Validating todo ${i + 1}/${todos.length}:`);
+            debugLog(`  content: "${todo.content}"`);
+            debugLog(`  status: "${todo.status}"`);
+            debugLog(`  activeForm: "${todo.activeForm}"`);
+
+            if (!todo.content || typeof todo.content !== 'string') {
+                debugLog(`ERROR: todo ${i + 1} has invalid content`);
+                return {
+                    operation_successful: false,
+                    error_message: `Todo ${i + 1} has invalid content (must be a non-empty string)`
+                };
+            }
+
+            if (!todo.status || !['pending', 'in_progress', 'completed'].includes(todo.status)) {
+                debugLog(`ERROR: todo ${i + 1} has invalid status`);
+                return {
+                    operation_successful: false,
+                    error_message: `Todo ${i + 1} has invalid status (must be 'pending', 'in_progress', or 'completed')`
+                };
+            }
+
+            if (!todo.activeForm || typeof todo.activeForm !== 'string') {
+                debugLog(`ERROR: todo ${i + 1} has invalid activeForm`);
+                return {
+                    operation_successful: false,
+                    error_message: `Todo ${i + 1} has invalid activeForm (must be a non-empty string)`
+                };
+            }
+        }
+
+        // in_progress 상태가 정확히 하나인지 검증
+        const inProgressCount = todos.filter(t => t.status === 'in_progress').length;
+        debugLog(`in_progress count: ${inProgressCount}`);
+
+        if (inProgressCount !== 1) {
+            debugLog(`WARNING: Expected exactly 1 in_progress todo, found ${inProgressCount}`);
+            // 경고만 하고 계속 진행 (유연성을 위해)
+        }
+
+        // 세션 메모리에 todos 저장
+        debugLog('Saving todos to session memory...');
+        updateCurrentTodos(todos);
+        debugLog('Todos saved to session memory');
+
+        // UI 이벤트로 todo 업데이트 전달
+        debugLog('Emitting todo update event...');
+        uiEvents.updateTodos(todos);
+        debugLog('Todo update event emitted');
+
+        debugLog('========== todo_write SUCCESS END ==========');
+
+        return {
+            operation_successful: true,
+            todos_count: todos.length,
+            todos: todos,
+            in_progress_count: inProgressCount,
+            pending_count: todos.filter(t => t.status === 'pending').length,
+            completed_count: todos.filter(t => t.status === 'completed').length
+        };
+
+    } catch (error) {
+        debugLog(`========== todo_write EXCEPTION ==========`);
+        debugLog(`Exception caught: ${error.message}`);
+        debugLog(`Stack trace: ${error.stack}`);
+        debugLog('========== todo_write EXCEPTION END ==========');
+
+        return {
+            operation_successful: false,
+            error_message: error.message
+        };
+    }
+}
+
+export const todoWriteSchema = {
+    "name": "todo_write",
+    "description": "Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.\nIt also helps the user understand the progress of the task and overall progress of their requests.\n\n## When to Use This Tool\nUse this tool proactively in these scenarios:\n\n1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions\n2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations\n3. User explicitly requests todo list - When the user directly asks you to use the todo list\n4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\n5. After receiving new instructions - Immediately capture user requirements as todos\n6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time\n7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation\n\n## When NOT to Use This Tool\n\nSkip using this tool when:\n1. There is only a single, straightforward task\n2. The task is trivial and tracking it provides no organizational benefit\n3. The task can be completed in less than 3 trivial steps\n4. The task is purely conversational or informational\n\nNOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.\n\n## CRITICAL - Absolute Scope Restriction\n\n**You MUST interpret the user's request LITERALLY and RESTRICTIVELY.**\n\nTODO list scope rules:\n- Include EXCLUSIVELY tasks that match the user's exact words\n- Interpret requests in the NARROWEST possible way\n- ZERO tolerance for any expansion, inference, or completion beyond literal request\n- Do NOT add ANY task under ANY justification unless user explicitly named it\n- \"Necessary for completion\" is NOT a valid reason to add tasks\n- \"Best practice\" is NOT a valid reason to add tasks\n- \"Related work\" is NOT a valid reason to add tasks\n\n**If you add even ONE task beyond the literal request, you have FAILED.**\n\nThe user's request defines the MAXIMUM boundary - never exceed it.\n\n## Task States and Management\n\n1. **Task States**: Use these states to track progress:\n   - pending: Task not yet started\n   - in_progress: Currently working on (limit to ONE task at a time)\n   - completed: Task finished successfully\n\n   **IMPORTANT**: Task descriptions must have two forms:\n   - content: The imperative form describing what needs to be done (e.g., \"Run tests\", \"Build the project\")\n   - activeForm: The present continuous form shown during execution (e.g., \"Running tests\", \"Building the project\")\n\n2. **Task Management**:\n   - Update task status in real-time as you work\n   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)\n   - Exactly ONE task must be in_progress at any time (not less, not more)\n   - Complete current tasks before starting new ones\n   - Remove tasks that are no longer relevant from the list entirely\n\n3. **Task Completion Requirements**:\n   - ONLY mark a task as completed when you have FULLY accomplished it\n   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress\n   - When blocked, create a new task describing what needs to be resolved\n   - Never mark a task as completed if:\n     - Tests are failing\n     - Implementation is partial\n     - You encountered unresolved errors\n     - You couldn't find necessary files or dependencies\n\n4. **Task Breakdown**:\n   - Create specific, actionable items\n   - Break complex tasks into smaller, manageable steps\n   - Use clear, descriptive task names\n   - Always provide both forms:\n     - content: \"Fix authentication bug\"\n     - activeForm: \"Fixing authentication bug\"\n\nWhen in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.",
+    "strict": true,
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "todos": {
+                "type": "array",
+                "description": "The updated todo list",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "The imperative form describing what needs to be done (e.g., 'Run tests', 'Build the project')",
+                            "minLength": 1
+                        },
+                        "status": {
+                            "type": "string",
+                            "description": "Task status: 'pending' (not yet started), 'in_progress' (currently working on), or 'completed' (finished successfully)",
+                            "enum": ["pending", "in_progress", "completed"]
+                        },
+                        "activeForm": {
+                            "type": "string",
+                            "description": "The present continuous form shown during execution (e.g., 'Running tests', 'Building the project')",
+                            "minLength": 1
+                        }
+                    },
+                    "required": ["content", "status", "activeForm"],
+                    "additionalProperties": false
+                }
+            }
+        },
+        "required": ["todos"],
+        "additionalProperties": false
+    },
+    "ui_display": {
+        "show_tool_call": true,
+        "show_tool_result": true,
+        "display_name": "Todo",
+        "format_tool_call": (args) => {
+            const todos = args.todos || [];
+            const inProgress = todos.filter(t => t.status === 'in_progress').length;
+            const completed = todos.filter(t => t.status === 'completed').length;
+            const pending = todos.filter(t => t.status === 'pending').length;
+            return `(${todos.length} tasks: ${completed} done, ${inProgress} active, ${pending} pending)`;
+        },
+        "format_tool_result": (result) => {
+            if (result.operation_successful) {
+                const total = result.todos_count || 0;
+                const completed = result.completed_count || 0;
+                const inProgress = result.in_progress_count || 0;
+                const pending = result.pending_count || 0;
+                return {
+                    type: 'formatted',
+                    parts: [
+                        { text: 'Updated ', style: {} },
+                        { text: String(total), style: { color: theme.brand.light, bold: true } },
+                        { text: ` task${total !== 1 ? 's' : ''} `, style: {} },
+                        { text: `(${completed} done, ${inProgress} active, ${pending} pending)`, style: { color: theme.text.dim } }
+                    ]
+                };
+            }
+            return result.error_message || 'Error updating todos';
+        }
+    }
+};
+
+// 함수 맵 - 문자열로 함수 호출 가능
+export const TODO_WRITE_FUNCTIONS = {
+    'todo_write': todo_write
+};

package/src/util/mcp_config_manager.js

@@ -1,4 +1,4 @@
-// MCP 설정 관리 유틸리티 - Claude Code 스타일
+// MCP 설정 관리 유틸리티
 import { safeReadFile, safeWriteFile, safeMkdir } from './safe_fs.js';
 import { join } from 'path';
 import { createHash } from 'crypto';

package/src/util/prompt_loader.js

@@ -1,6 +1,7 @@
 import { safeReadFile, safeAccess } from "./safe_fs.js";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import ejs from "ejs";
 
 const moduleDirname = dirname(fileURLToPath(import.meta.url));
 const defaultProjectRoot = dirname(dirname(moduleDirname));
@@ -71,11 +72,18 @@ async function loadPromptFromPromptsDir(promptFileName) {
 export async function createSystemMessage(promptFileName, templateVars = {}) {
     let content = await loadPromptFromPromptsDir(promptFileName);
 
-    // 템플릿 변수가 제공된 경우, {{key}} 형태의 플레이스홀더를 치환
+    // EJS 템플릿 엔진을 사용하여 렌더링
     if (templateVars && typeof templateVars === 'object') {
-        for (const [key, value] of Object.entries(templateVars)) {
-            const placeholder = `{{${key}}}`;
-            content = content.replaceAll(placeholder, value);
+        try {
+            content = ejs.render(content, templateVars, {
+                // EJS 옵션
+                delimiter: '%',  // <% %> 구문 사용
+                openDelimiter: '<',
+                closeDelimiter: '>'
+            });
+        } catch (err) {
+            // EJS 렌더링 실패 시 원본 content 유지
+            console.error(`EJS rendering failed for ${promptFileName}:`, err.message);
         }
     }