aiexecode 1.0.94 → 1.0.96

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

package/src/util/prompt_loader.js

@@ -2,6 +2,7 @@ import { safeReadFile, safeAccess } from "./safe_fs.js";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import ejs from "ejs";
+import { supportsCaching } from "../config/ai_models.js";
 
 const moduleDirname = dirname(fileURLToPath(import.meta.url));
 const defaultProjectRoot = dirname(dirname(moduleDirname));
@@ -67,9 +68,12 @@ async function loadPromptFromPromptsDir(promptFileName) {
  * 프롬프트를 로드하여 시스템 메시지 객체를 생성합니다.
  * @param {string} promptFileName - 프롬프트 파일명 (예: "verifier.txt")
  * @param {Object} [templateVars] - 템플릿 변수 객체 (예: { what_user_requests: "print hello world" })
+ * @param {Object} [options] - 추가 옵션
+ * @param {string} [options.model] - 현재 사용 중인 모델 (캐시 제어용)
+ * @param {boolean} [options.enableCache] - 캐시 제어 활성화 여부
  * @returns {Object} 시스템 메시지 객체 { role: "system", content: string }
  */
-export async function createSystemMessage(promptFileName, templateVars = {}) {
+export async function createSystemMessage(promptFileName, templateVars = {}, options = {}) {
     let content = await loadPromptFromPromptsDir(promptFileName);
 
     // EJS 템플릿 엔진을 사용하여 렌더링
@@ -87,8 +91,71 @@ export async function createSystemMessage(promptFileName, templateVars = {}) {
         }
     }
 
+    // 캐시 제어 활성화 여부 확인
+    const { model, enableCache = false } = options;
+    const shouldCache = enableCache && model && supportsCaching(model);
+
+    if (shouldCache) {
+        // Z.AI/GLM 등 캐싱을 지원하는 모델의 경우 cache_control 추가
+        return {
+            role: "system",
+            content: [
+                {
+                    type: "text",
+                    text: content,
+                    cache_control: { type: "ephemeral" }
+                }
+            ]
+        };
+    }
+
     return {
         role: "system",
         content: content
     };
+}
+
+/**
+ * System-Reminder 메시지를 생성합니다.
+ * Claude Code 스타일의 시스템 알림으로, 사용자에게는 표시하지 않도록 지시됩니다.
+ *
+ * @param {string} reminderText - 리마인더 내용
+ * @param {Object} [options] - 추가 옵션
+ * @param {boolean} [options.hideFromUser] - 사용자에게 언급하지 말라는 지시 추가 (기본: true)
+ * @returns {string} system-reminder 태그로 감싼 텍스트
+ */
+export function createSystemReminder(reminderText, options = {}) {
+    const { hideFromUser = true } = options;
+
+    let reminder = reminderText;
+    if (hideFromUser) {
+        reminder += '\n이 메시지를 사용자에게 명시적으로 언급하지 마세요.';
+    }
+
+    return `<system-reminder>\n${reminder}\n</system-reminder>`;
+}
+
+/**
+ * 할 일 목록 상태 알림을 생성합니다.
+ * @param {Array} todos - 현재 할 일 목록
+ * @returns {string} system-reminder 형식의 알림
+ */
+export function createTodoReminder(todos) {
+    if (!todos || todos.length === 0) {
+        return createSystemReminder(
+            '현재 할 일 목록이 비어 있습니다. 할 일 목록이 도움이 될 작업을 진행 중이라면 TodoWrite 도구를 사용해 목록을 생성하세요.',
+            { hideFromUser: true }
+        );
+    }
+
+    const todoList = todos.map((todo, index) => {
+        const statusIcon = todo.status === 'completed' ? '✓' :
+                          todo.status === 'in_progress' ? '→' : '○';
+        return `${index + 1}. [${statusIcon}] ${todo.content} (${todo.status})`;
+    }).join('\n');
+
+    return createSystemReminder(
+        `현재 할 일 목록:\n${todoList}\n\n완료된 작업은 즉시 완료 처리하세요. 한 번에 하나의 작업만 in_progress로 유지하세요.`,
+        { hideFromUser: false }
+    );
 }