aiexecode 1.0.94 → 1.0.98

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,

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';