aiexecode 1.0.111 → 1.0.113

package/prompts/orchestrator.txt

@@ -379,7 +379,33 @@ Use for: Finding code by content, exploring codebases, locating specific impleme
 
 ### bash
 
-Purpose: Execute shell commands
+Purpose: Execute shell commands (for terminal operations ONLY)
+
+**CRITICAL - Use Specialized Tools Instead of Bash:**
+
+NEVER use bash for these operations - use the dedicated tools:
+
+| Operation | WRONG (bash) | CORRECT (dedicated tool) |
+|-----------|--------------|--------------------------|
+| Read files | `cat file.js` | `read_file({ filePath: "file.js" })` |
+| Read file sections | `head -100 file.js` | `read_file_range({ filePath, startLine, endLine })` |
+| Search content | `grep -r "pattern" .` | `ripgrep({ pattern: "pattern" })` |
+| Find files | `find . -name "*.js"` | `glob_search({ pattern: "**/*.js" })` |
+| Edit files | `sed -i 's/old/new/' file` | `edit_file_replace({ file_path, old_string, new_string })` |
+| Write files | `echo "content" > file` | `write_file({ file_path, content })` |
+
+**Why dedicated tools are mandatory:**
+- bash output is truncated to 8000 chars - long files get cut off
+- Dedicated tools have proper error handling and formatting
+- Dedicated tools integrate with file integrity tracking
+- Dedicated tools display results properly in UI
+
+**When to use bash:**
+- git commands: `git status`, `git commit`, `git push`
+- Package management: `npm install`, `pip install`
+- Running scripts: `npm test`, `python script.py`
+- Directory operations: `mkdir`, `rm -rf`, `mv`, `cp`
+- System commands: `chmod`, `chown`, `which`
 
 Usage notes:
 - Output limits: stdout 8000 chars, stderr 4000 chars
@@ -813,10 +839,43 @@ Match the user's language:
 
 ## Tool usage
 
-- Use specialized tools: glob_search and ripgrep, NOT bash find/grep
-- No file editing via bash: Never use sed, awk, echo > for file content
+**MANDATORY - Specialized Tools Over Bash:**
+
+This is NOT optional. You MUST use dedicated tools for these operations:
+
+| Task | NEVER Use | ALWAYS Use |
+|------|-----------|------------|
+| Read files | cat, head, tail, less | read_file, read_file_range |
+| Search content | grep, rg, ack | ripgrep |
+| Find files | find, ls -R, locate | glob_search |
+| Edit files | sed, awk, perl -i | edit_file_replace |
+| Create/write files | echo >, cat <<EOF | write_file |
+
+**Why this matters:**
+- bash output truncated at 8000 chars → long content gets lost
+- Dedicated tools have built-in limits and error handling
+- File integrity tracking only works with dedicated tools
+- Results display properly in UI with dedicated tools
+
+**Correct patterns:**
+```
+# Find files → glob_search
+glob_search({ pattern: "**/*.ts" })
+
+# Search content → ripgrep
+ripgrep({ pattern: "TODO", output_mode: "content", head_limit: 20 })
+
+# Read file → read_file
+read_file({ filePath: "src/index.js" })
+
+# Large file → read_file_range
+read_file_range({ filePath: "big.log", startLine: 1, endLine: 500 })
+```
+
+**Other tool usage rules:**
 - Auto-exclusions trusted: node_modules, .git, etc. are automatically excluded
 - Parallel when possible: Execute independent tool calls simultaneously
+- Check output limits: ripgrep has 30KB limit, read_file has 2000 line limit
 
 ## Error handling
 
@@ -1092,3 +1151,72 @@ ASK USER:
 
 DECIDE YOURSELF:
 - All implementation details (HOW to implement)
+
+# Web application development
+
+## Technology stack
+
+Build web applications using the following technologies:
+
+1. **Core**: Use HTML for structure and Javascript for logic
+2. **Styling (CSS)**: Use Vanilla CSS for maximum flexibility and control. Avoid using TailwindCSS unless the user explicitly requests it; in this case, first confirm which TailwindCSS version to use
+3. **Web App**: If the user specifies a more complex web app, use a framework like Next.js or Vite. Only do this if the user explicitly requests a web app
+4. **New Project Creation**: If you need to use a framework for a new app, use `npx` with the appropriate script:
+   - Use `npx -y` to automatically install the script and its dependencies
+   - You MUST run the command with `--help` flag to see all available options first
+   - Initialize the app in the current directory with `./` (example: `npx -y create-vite-app@latest ./`)
+   - Run in non-interactive mode so that the user doesn't need to input anything
+5. **Running Locally**: When running locally, use `npm run dev` or equivalent dev server. Only build the production bundle if the user explicitly requests it or you are validating the code for correctness
+
+## Design aesthetics
+
+**CRITICAL: Visual excellence is mandatory. A basic, simple design is UNACCEPTABLE.**
+
+1. **Rich Aesthetics**: The user should be impressed at first glance. Use best practices in modern web design (vibrant colors, dark modes, glassmorphism, dynamic animations) to create a stunning first impression
+2. **Visual Excellence**: Implement designs that feel extremely premium:
+   - Avoid generic colors (plain red, blue, green). Use curated, harmonious color palettes (HSL tailored colors, sleek dark modes)
+   - Use modern typography (Google Fonts like Inter, Roboto, or Outfit) instead of browser defaults
+   - Use smooth gradients
+   - Add subtle micro-animations for enhanced user experience
+3. **Dynamic Design**: An interface that feels responsive and alive encourages interaction. Achieve this with hover effects and interactive elements. Micro-animations are highly effective for improving user engagement
+4. **Premium Designs**: Make a design that feels premium and state of the art. Avoid creating simple minimum viable products
+5. **No placeholders**: If you need an image, create actual working demonstrations
+
+## Implementation workflow
+
+Follow this systematic approach when building web applications:
+
+1. **Plan and Understand**:
+   - Fully understand the user's requirements
+   - Draw inspiration from modern, beautiful, and dynamic web designs
+   - Outline the features needed for the initial version
+
+2. **Build the Foundation**:
+   - Start by creating/modifying `index.css`
+   - Implement the core design system with all tokens and utilities
+
+3. **Create Components**:
+   - Build necessary components using your design system
+   - Ensure all components use predefined styles, not ad-hoc utilities
+   - Keep components focused and reusable
+
+4. **Assemble Pages**:
+   - Update the main application to incorporate your design and components
+   - Ensure proper routing and navigation
+   - Implement responsive layouts
+
+5. **Polish and Optimize**:
+   - Review the overall user experience
+   - Ensure smooth interactions and transitions
+   - Optimize performance where needed
+
+## SEO best practices
+
+Automatically implement SEO best practices on every page:
+
+- **Title Tags**: Include proper, descriptive title tags for each page
+- **Meta Descriptions**: Add compelling meta descriptions that accurately summarize page content
+- **Heading Structure**: Use a single `<h1>` per page with proper heading hierarchy
+- **Semantic HTML**: Use appropriate HTML5 semantic elements
+- **Unique IDs**: Ensure all interactive elements have unique, descriptive IDs for browser testing
+- **Performance**: Ensure fast page load times through optimization

package/src/ai_based/orchestrator.js

@@ -2,10 +2,10 @@ import dotenv from "dotenv";
 // 이 파일은 계획을 실제 행동으로 옮기기 위해 어떤 도구를 호출할지 결정합니다.
 import path from 'path';
 import { truncateWithOmit } from "../util/text_formatter.js";
-import { createSystemMessage, createTodoReminder, createSystemReminder } from "../util/prompt_loader.js";
+import { createSystemMessage, createTodoReminder, createSystemReminder, createTrimmedFileReminder } from "../util/prompt_loader.js";
 import { request, shouldRetryWithTrim, getModelForProvider } from "../system/ai_request.js";
 import { supportsCaching } from "../config/ai_models.js";
-import { cleanupOrphanOutputs, trimConversation } from "../system/conversation_trimmer.js";
+import { cleanupOrphanOutputs, trimConversation, getTrimmedFileReads, clearTrimmedFileReads } from "../system/conversation_trimmer.js";
 import { runPythonCodeSchema, bashSchema } from "../system/code_executer.js";
 import { readFileSchema, readFileRangeSchema } from "../tools/file_reader.js";
 import { writeFileSchema, editFileRangeSchema, editFileReplaceSchema } from "../tools/code_editor.js";
@@ -99,6 +99,20 @@ async function ensureConversationInitialized() {
             debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos as separate block (uncached)`);
         }
 
+        // Trim된 파일 읽기 알림 추가 (파일 경로 알림 기능)
+        const trimmedFiles = getTrimmedFileReads();
+        if (trimmedFiles.length > 0) {
+            const trimmedFileReminder = createTrimmedFileReminder(trimmedFiles);
+            if (trimmedFileReminder) {
+                contentBlocks.push({
+                    type: "input_text",
+                    text: trimmedFileReminder
+                    // cache_control 없음 - 동적 데이터이므로
+                });
+                debugLog(`[ensureConversationInitialized] Added trimmed file reminder for ${trimmedFiles.length} files (uncached)`);
+            }
+        }
+
         systemMessageEntry = {
             role: "system",
             content: contentBlocks
@@ -133,6 +147,16 @@ async function ensureConversationInitialized() {
             debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos to system message`);
         }
 
+        // Trim된 파일 읽기 알림 추가 (파일 경로 알림 기능)
+        const trimmedFiles = getTrimmedFileReads();
+        if (trimmedFiles.length > 0) {
+            const trimmedFileReminder = createTrimmedFileReminder(trimmedFiles);
+            if (trimmedFileReminder) {
+                systemMessageText += '\n\n' + trimmedFileReminder;
+                debugLog(`[ensureConversationInitialized] Added trimmed file reminder for ${trimmedFiles.length} files`);
+            }
+        }
+
         systemMessageEntry = {
             role: "system",
             content: [
@@ -178,6 +202,7 @@ function appendResponseToConversation(response) {
 export function resetOrchestratorConversation() {
     orchestratorConversation.length = 0;
     orchestratorRequestOptions = null;
+    clearTrimmedFileReads(); // 세션 초기화 시 trim된 파일 목록도 초기화
 }
 
 export function getOrchestratorConversation() {

package/src/config/feature_flags.js

@@ -4,13 +4,12 @@
  */
 
 /**
- * 에러 메시지 상세도 설정
+ * 에러 메시지 상세도 설정 (deprecated)
  *
- * 'concise': 간결한 에러 메시지만 표시 (기본값)
- * 'verbose': 상세한 에러 정보 표시 (코드, 스택 트레이스, 전체 에러 객체 등)
+ * 이 설정은 더 이상 사용되지 않습니다.
+ * 에러 상세도는 /debug on|off 명령으로 제어됩니다.
+ * - /debug off (기본): 사용자 친화적 에러 메시지
+ * - /debug on: 상세 에러 정보 (코드, 스택 트레이스 등)
  */
-export const ERROR_VERBOSITY = 'verbose';
 
-export default {
-  ERROR_VERBOSITY
-};
+export default {};

package/src/system/code_executer.js

@@ -581,14 +581,42 @@ export const runPythonCodeSchema = {
 
 export const bashSchema = {
     name: "bash",
-    description: "Executes bash shell commands. Use -y or -f flags to avoid user prompts. Chain commands with && for sequential execution. This tool handles ALL file system operations (create/delete/move/copy files and directories, check file existence, list directory contents), system operations, git commands, package management, and running CLI tools.",
+    description: `Executes bash shell commands with optional timeout.
+
+IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file reading/searching operations - use specialized tools instead.
+
+Output Limits:
+- stdout is truncated to 8000 characters
+- stderr is truncated to 4000 characters
+- Commands timing out after 20 minutes will be terminated
+- If output exceeds limits, only the first 70% and last 30% are shown with an omission notice
+
+Avoid These Commands (Use Specialized Tools Instead):
+- File reading: Use read_file or read_file_range instead of cat, head, tail
+- Content search: Use ripgrep instead of grep or rg
+- File search: Use glob_search instead of find
+- File editing: Use edit_file_replace or write_file instead of sed, awk, echo >
+
+When Output May Be Large:
+- Limit output with: command | head -50
+- Save to file: command > output.log 2>&1
+- Filter results: command | grep "pattern"
+- Use quiet/minimal flags when available
+
+Best Practices:
+- Use auto-confirm flags: -y, -f, --yes, --quiet
+- Chain commands with && for sequential execution
+- Avoid interactive commands that require user input
+- For calculations, use non-interactive bc or Python (never mental arithmetic)
+
+This tool handles: file system operations (mkdir, rm, mv, cp, chmod), git commands, package management (npm, pip), and CLI tools.`,
     parameters: {
         type: "object",
         required: ["script"],
         properties: {
             script: {
                 type: "string",
-                description: "Bash script to execute. Will be saved to a temporary file and run with bash. Use standard bash commands like: mkdir, rm, mv, cp, ls, test, find, chmod, chown, etc."
+                description: "Bash script to execute. Will be saved to a temporary file and run with bash. Keep scripts concise and output-limited to avoid truncation."
             }
         },
         additionalProperties: false

package/src/system/conversation_trimmer.js

@@ -6,9 +6,100 @@
  */
 
 import { createDebugLogger } from "../util/debug_log.js";
+import { clearFileContentHash } from "./file_integrity.js";
 
 const debugLog = createDebugLogger('conversation_trimmer.log', 'conversation_trimmer');
 
+/**
+ * Trim 과정에서 삭제된 파일 읽기 정보를 추적합니다.
+ * Claude Code 스타일의 "파일 경로 알림" 기능을 위해 사용됩니다.
+ *
+ * 예: "Note: /path/to/file was read before trimming, but contents are too large to include."
+ */
+const trimmedFileReads = new Set();
+
+/**
+ * trimmedFileReads의 최대 개수 제한
+ * 너무 많은 파일이 추적되면 system-reminder가 길어져 토큰 낭비 발생
+ */
+const MAX_TRIMMED_FILE_READS = 50;
+
+/**
+ * Trim된 파일 읽기 목록을 반환합니다.
+ * @returns {Array<string>} 삭제된 파일 경로 배열
+ */
+export function getTrimmedFileReads() {
+    return Array.from(trimmedFileReads);
+}
+
+/**
+ * Trim된 파일 읽기 목록을 초기화합니다.
+ */
+export function clearTrimmedFileReads() {
+    trimmedFileReads.clear();
+    debugLog(`[clearTrimmedFileReads] Cleared trimmed file reads`);
+}
+
+/**
+ * Trim된 파일 읽기 목록을 설정합니다 (세션 복원용).
+ * 최대 개수 제한을 적용합니다.
+ * @param {Array<string>} paths - 복원할 파일 경로 배열
+ */
+export function setTrimmedFileReads(paths) {
+    trimmedFileReads.clear();
+    if (Array.isArray(paths)) {
+        // 최대 개수만큼만 추가 (최근 것 우선)
+        const pathsToAdd = paths.slice(-MAX_TRIMMED_FILE_READS);
+        pathsToAdd.forEach(path => trimmedFileReads.add(path));
+        debugLog(`[setTrimmedFileReads] Restored ${trimmedFileReads.size} trimmed file reads`);
+    }
+}
+
+/**
+ * 파일이 다시 읽혔을 때 trimmedFileReads에서 제거합니다.
+ * 파일을 다시 읽으면 대화에 내용이 있으므로 알림이 필요 없습니다.
+ * @param {string} filePath - 다시 읽은 파일 경로
+ */
+export function markFileAsReRead(filePath) {
+    if (trimmedFileReads.has(filePath)) {
+        trimmedFileReads.delete(filePath);
+        debugLog(`[markFileAsReRead] Removed from trimmed file reads: ${filePath}`);
+    }
+}
+
+/**
+ * 대화 항목에서 파일 읽기 정보를 추출합니다.
+ * @param {Object} entry - 대화 항목
+ * @returns {Array<string>} 추출된 파일 경로 배열
+ */
+function extractFilePathsFromEntry(entry) {
+    const filePaths = [];
+
+    if (!entry) return filePaths;
+
+    try {
+        // function_call_output에서 파일 읽기 결과 추출
+        if (entry.type === 'function_call_output' && entry.output) {
+            const output = typeof entry.output === 'string' ? JSON.parse(entry.output) : entry.output;
+
+            // read_file, read_file_range 도구의 결과인지 확인
+            if (output.tool === 'read_file' || output.tool === 'read_file_range') {
+                const result = output.original_result || output;
+                // 성공적으로 읽은 파일만 추적 (실패한 파일은 알림 불필요)
+                if (result.target_file_path && result.operation_successful === true) {
+                    filePaths.push(result.target_file_path);
+                    debugLog(`[extractFilePathsFromEntry] Found file path: ${result.target_file_path}`);
+                }
+            }
+        }
+    } catch (e) {
+        // JSON 파싱 실패 등은 무시
+        debugLog(`[extractFilePathsFromEntry] Failed to parse entry: ${e.message}`);
+    }
+
+    return filePaths;
+}
+
 /**
  * 대화에서 특정 call_id와 관련된 모든 항목을 제거합니다.
  *
@@ -103,6 +194,9 @@ export function cleanupOrphanOutputs(conversation) {
  * 컨텍스트 윈도우 초과 시 대화를 줄입니다.
  * 시스템 프롬프트(인덱스 0)를 제외한 가장 오래된 항목(인덱스 1)을 제거합니다.
  *
+ * 삭제되는 항목에서 파일 읽기 정보를 추출하여 trimmedFileReads에 저장합니다.
+ * 이 정보는 나중에 system-reminder로 에이전트에게 알려줄 때 사용됩니다.
+ *
  * @param {Array} conversation - 대화 배열
  * @returns {boolean} 제거 성공 여부
  */
@@ -119,15 +213,53 @@ export function trimConversation(conversation) {
 
     debugLog(`[trimConversation] Target entry at index 1: type=${targetEntry?.type}, call_id=${targetCallId}`);
 
+    // 삭제 전에 파일 경로 추출
+    const filePaths = extractFilePathsFromEntry(targetEntry);
+    filePaths.forEach(path => {
+        // 최대 개수 초과 시 가장 오래된 항목 제거
+        if (trimmedFileReads.size >= MAX_TRIMMED_FILE_READS) {
+            const oldest = trimmedFileReads.values().next().value;
+            trimmedFileReads.delete(oldest);
+            debugLog(`[trimConversation] Removed oldest from trimmed file reads: ${oldest}`);
+        }
+        trimmedFileReads.add(path);
+        debugLog(`[trimConversation] Added to trimmed file reads: ${path}`);
+
+        // file_integrity에서 해시도 삭제 (에이전트가 파일 내용을 모르므로 편집 불가하게)
+        const hashCleared = clearFileContentHash(path);
+        debugLog(`[trimConversation] Cleared content hash for ${path}: ${hashCleared}`);
+    });
+
     // 먼저 인덱스 1 항목 제거
     conversation.splice(1, 1);
     debugLog(`[trimConversation] Removed entry at index 1`);
 
     // call_id가 있으면 같은 call_id를 가진 다른 항목들도 제거
     if (targetCallId) {
+        // 삭제 전에 관련 항목들에서 파일 경로 추출
+        for (const entry of conversation) {
+            if (entry && entry.call_id === targetCallId) {
+                const paths = extractFilePathsFromEntry(entry);
+                paths.forEach(path => {
+                    // 최대 개수 초과 시 가장 오래된 항목 제거
+                    if (trimmedFileReads.size >= MAX_TRIMMED_FILE_READS) {
+                        const oldest = trimmedFileReads.values().next().value;
+                        trimmedFileReads.delete(oldest);
+                        debugLog(`[trimConversation] Removed oldest from trimmed file reads: ${oldest}`);
+                    }
+                    trimmedFileReads.add(path);
+                    debugLog(`[trimConversation] Added related file to trimmed reads: ${path}`);
+
+                    // file_integrity에서 해시도 삭제 (에이전트가 파일 내용을 모르므로 편집 불가하게)
+                    const hashCleared = clearFileContentHash(path);
+                    debugLog(`[trimConversation] Cleared content hash for ${path}: ${hashCleared}`);
+                });
+            }
+        }
         removeEntriesWithCallId(conversation, targetCallId);
     }
 
     debugLog(`[trimConversation] Trim completed. New conversation length: ${conversation.length}`);
+    debugLog(`[trimConversation] Total trimmed file reads: ${trimmedFileReads.size}`);
     return true;
 }

package/src/system/file_integrity.js

@@ -112,6 +112,38 @@ class FileIntegrityTracker {
         return sessionFiles.get(filePath) || null;
     }
 
+    /**
+     * 파일 콘텐츠 해시를 삭제합니다
+     * 대화가 trim되어 에이전트가 파일 내용을 알 수 없게 되었을 때 호출됩니다.
+     * 이렇게 하면 에이전트가 파일을 다시 읽기 전까지 편집할 수 없습니다.
+     * @param {string} sessionID - 세션 ID
+     * @param {string} filePath - 파일 경로
+     * @returns {boolean} 삭제 성공 여부
+     */
+    clearContentHash(sessionID, filePath) {
+        debugLog(`========== clearContentHash START ==========`);
+        debugLog(`sessionID: ${sessionID}`);
+        debugLog(`filePath: ${filePath}`);
+
+        const sessionFiles = this.contentHashes.get(sessionID);
+        if (!sessionFiles) {
+            debugLog(`No session map found for session: ${sessionID}`);
+            debugLog(`========== clearContentHash END (NO SESSION) ==========`);
+            return false;
+        }
+
+        const existed = sessionFiles.has(filePath);
+        if (existed) {
+            sessionFiles.delete(filePath);
+            debugLog(`Hash deleted for file: ${filePath}`);
+        } else {
+            debugLog(`No hash found for file: ${filePath}`);
+        }
+
+        debugLog(`========== clearContentHash END ==========`);
+        return existed;
+    }
+
     /**
      * 파일 편집 전 무결성을 검증합니다
      * @param {string} sessionID - 세션 ID
@@ -347,6 +379,31 @@ export async function assertFileIntegrity(filePath) {
     debugLog('========== assertFileIntegrity (export wrapper) END ==========');
 }
 
+/**
+ * 파일 콘텐츠 해시를 삭제합니다 (현재 세션 기준)
+ * 대화가 trim되어 에이전트가 파일 내용을 알 수 없게 되었을 때 호출됩니다.
+ * @param {string} filePath - 파일 경로
+ * @returns {boolean} 삭제 성공 여부
+ */
+export function clearFileContentHash(filePath) {
+    debugLog(`========== clearFileContentHash (export wrapper) START ==========`);
+    debugLog(`filePath: ${filePath}`);
+
+    const sessionID = fileIntegrityTracker.getCurrentSession();
+    debugLog(`Current session ID: ${sessionID || 'NULL'}`);
+
+    if (!sessionID) {
+        debugLog(`ERROR: No current session set, cannot clear hash`);
+        debugLog('========== clearFileContentHash (export wrapper) END ==========');
+        return false;
+    }
+
+    const result = fileIntegrityTracker.clearContentHash(sessionID, filePath);
+    debugLog(`Hash clear result: ${result}`);
+    debugLog('========== clearFileContentHash (export wrapper) END ==========');
+    return result;
+}
+
 /**
  * 파일 스냅샷을 저장합니다 (현재 세션 기준)
  * @param {string} filePath - 파일 경로