aiexecode 1.0.96 → 1.0.100

package/src/frontend/components/CurrentModelView.js

@@ -8,11 +8,11 @@ import { theme } from '../design/themeColors.js';
 
 export function CurrentModelView({ provider, modelId, modelInfo }) {
     const providerColors = {
-        openai: 'cyan'
+        zai: 'cyan'
     };
 
     const providerEmojis = {
-        openai: '🤖'
+        zai: '🤖'
     };
 
     return React.createElement(Box, {

package/src/frontend/components/Input.js

@@ -7,6 +7,7 @@ import { Box, Text } from 'ink';
 import { theme } from '../design/themeColors.js';
 import { useKeypress, keyMatchers, Command } from '../hooks/useKeypress.js';
 import { useCompletion } from '../hooks/useCompletion.js';
+import { useFileCompletion } from '../hooks/useFileCompletion.js';
 import { AutocompleteMenu } from './AutocompleteMenu.js';
 import { cpSlice, cpLen } from '../utils/inputBuffer.js';
 import { uiEvents } from '../../system/ui_events.js';
@@ -48,18 +49,31 @@ function InputPromptComponent({ buffer, onSubmit, onClearScreen, onExit, command
     // placeholder가 제공되지 않으면 무작위로 선택 (컴포넌트 마운트 시 한 번만)
     const defaultPlaceholder = useMemo(() => placeholder || getRandomPlaceholder(), []);
 
-    const completionRaw = useCompletion(buffer, commands);
+    const commandCompletionRaw = useCompletion(buffer, commands);
+    const fileCompletionRaw = useFileCompletion(buffer);
+
+    // Stabilize completion objects to prevent handleInput from being recreated
+    const commandCompletion = useMemo(() => commandCompletionRaw, [
+        commandCompletionRaw.showSuggestions,
+        commandCompletionRaw.suggestions.length,
+        commandCompletionRaw.activeSuggestionIndex,
+        commandCompletionRaw.handleAutocomplete,
+        commandCompletionRaw.navigateUp,
+        commandCompletionRaw.navigateDown
+    ]);
 
-    // Stabilize completion object to prevent handleInput from being recreated
-    const completion = useMemo(() => completionRaw, [
-        completionRaw.showSuggestions,
-        completionRaw.suggestions.length,
-        completionRaw.activeSuggestionIndex,
-        completionRaw.handleAutocomplete,
-        completionRaw.navigateUp,
-        completionRaw.navigateDown
+    const fileCompletion = useMemo(() => fileCompletionRaw, [
+        fileCompletionRaw.showSuggestions,
+        fileCompletionRaw.suggestions.length,
+        fileCompletionRaw.activeSuggestionIndex,
+        fileCompletionRaw.handleAutocomplete,
+        fileCompletionRaw.navigateUp,
+        fileCompletionRaw.navigateDown
     ]);
 
+    // 파일 자동완성 우선, 그 다음 명령어 자동완성
+    const completion = fileCompletion.showSuggestions ? fileCompletion : commandCompletion;
+
 
     const handleSubmitAndClear = useCallback((submittedValue) => {
         buffer.setText('');
@@ -139,9 +153,17 @@ function InputPromptComponent({ buffer, onSubmit, onClearScreen, onExit, command
             // If suggestions are shown, accept the active suggestion
             if (completion.showSuggestions && completion.suggestions.length > 0) {
                 const targetIndex = completion.activeSuggestionIndex === -1 ? 0 : completion.activeSuggestionIndex;
+                const suggestion = completion.suggestions[targetIndex];
+
+                // 파일 자동완성인 경우 (@로 시작) 완성만 하고 submit하지 않음
+                if (suggestion.value.startsWith('@')) {
+                    completion.handleAutocomplete(targetIndex);
+                    return;
+                }
+
+                // 명령어 자동완성인 경우 완성 후 바로 실행
                 completion.handleAutocomplete(targetIndex);
-                // Execute the command immediately
-                const completedCommand = completion.suggestions[targetIndex].value;
+                const completedCommand = suggestion.value;
                 handleSubmitAndClear(completedCommand);
                 return;
             }

package/src/frontend/components/ModelListView.js

@@ -40,7 +40,7 @@ export function ModelListView({ modelsByProvider }) {
         React.createElement(Text, { key: 'spacer2' }, null),
         React.createElement(Text, { key: 'usage', bold: true }, 'Usage:'),
         React.createElement(Text, { key: 'usage-cmd' }, '  /model <model-id>'),
-        React.createElement(Text, { key: 'usage-example', dimColor: true }, '  Example: /model gpt-5')
+        React.createElement(Text, { key: 'usage-example', dimColor: true }, '  Example: /model glm-4.5')
     );
 
     return React.createElement(Box, {

package/src/frontend/components/SetupWizard.js

@@ -15,10 +15,8 @@ import { AI_MODELS, getAllModelIds, getModelsByProvider, DEFAULT_MODEL } from '.
 function detectProviderFromApiKey(apiKey) {
     if (!apiKey || typeof apiKey !== 'string') return null;
 
-    if (apiKey.startsWith('sk-proj-')) {
-        return 'openai';
-    } else if (/^[a-f0-9]{32}\.[A-Za-z0-9]{16}$/.test(apiKey)) {
-        // Z.AI API 키 형식: 32자리 hex + '.' + 16자리 영숫자
+    // Z.AI API 키 형식: 32자리 hex + '.' + 16자리 영숫자
+    if (/^[a-f0-9]{32}\.[A-Za-z0-9]{16}$/.test(apiKey)) {
         return 'zai';
     }
     return null;
@@ -73,7 +71,7 @@ export function SetupWizard({ onComplete, onCancel }) {
                 const provider = detectProviderFromApiKey(apiKey);
                 if (!provider) {
                     // 유효하지 않은 API 키 형식
-                    setErrorMessage('Invalid API key. Please use OpenAI (sk-proj-...) or Z.AI format.');
+                    setErrorMessage('Invalid API key format. Please use Z.AI API key.');
                     setTextInput('');
                     return;
                 }
@@ -188,7 +186,7 @@ export function SetupWizard({ onComplete, onCancel }) {
             case STEPS.API_KEY:
                 return React.createElement(Box, { flexDirection: 'column' },
                     React.createElement(Text, { bold: true, color: theme.text.accent }, '1. API Key:'),
-                    React.createElement(Text, { color: theme.text.secondary }, '   Get your API key from: https://platform.openai.com/account/api-keys or https://z.ai/manage-apikey/apikey-list'),
+                    React.createElement(Text, { color: theme.text.secondary }, '   Get your API key from: https://z.ai/manage-apikey/apikey-list'),
                     React.createElement(Text, null),
                     React.createElement(Box, {
                         borderStyle: 'round',

package/src/frontend/hooks/useFileCompletion.js

@@ -0,0 +1,467 @@
+/**
+ * File Completion Hook
+ *
+ * @ 문자 감지 시 파일/디렉토리 자동완성을 제공합니다.
+ * - 경로 모드: @src/ → src 디렉토리 내용 표시
+ * - 검색 모드: @glob → 프로젝트 전체에서 "glob" 포함 파일 검색
+ */
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { resolve, dirname, basename, join, relative } from 'path';
+import { safeReaddir, safeStat, safeExists } from '../../util/safe_fs.js';
+
+// 검색에서 제외할 디렉토리 (성능 최적화)
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'dist',
+    'build',
+    'out',
+    'output',
+    'target',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '__pycache__',
+    '.pytest_cache',
+    '.mypy_cache',
+    '.tox',
+    'venv',
+    '.venv',
+    'env',
+    '.virtualenv',
+    '.cache',
+    '.temp',
+    '.tmp',
+    'coverage',
+    '.nyc_output',
+    '.turbo',
+    '.parcel-cache',
+    '.sass-cache',
+    '.idea',
+    '.vscode',
+    '.vs',
+    'vendor',
+    'Pods',
+    '.bundle',
+    'bower_components',
+    'jspm_packages',
+    'bin',
+    'obj',
+    'logs'
+]);
+
+// 검색 최대 깊이
+const MAX_SEARCH_DEPTH = 5;
+
+// 검색 최대 결과 수
+const MAX_SEARCH_RESULTS = 20;
+
+// 디바운스 시간 (ms)
+const SEARCH_DEBOUNCE_MS = 150;
+
+/**
+ * 텍스트에서 @ 참조를 파싱합니다.
+ * @param {string} text - 전체 텍스트
+ * @param {number} cursorPosition - 커서 위치
+ * @returns {Object} { isActive, prefix, startIndex, isSearchMode }
+ */
+function parseAtReference(text, cursorPosition) {
+    const textBeforeCursor = text.slice(0, cursorPosition);
+    const match = textBeforeCursor.match(/@([^\s@]*)$/);
+
+    if (!match) {
+        return { isActive: false, prefix: '', startIndex: -1, isSearchMode: false };
+    }
+
+    const prefix = match[1];
+
+    // 검색 모드 판단: /가 없고 2글자 이상이면 검색 모드
+    const isSearchMode = prefix.length >= 2 && !prefix.includes('/');
+
+    return {
+        isActive: true,
+        prefix,
+        startIndex: match.index,
+        isSearchMode
+    };
+}
+
+/**
+ * 재귀적으로 파일을 검색합니다.
+ * @param {string} dirPath - 검색할 디렉토리
+ * @param {string} searchTerm - 검색어 (소문자)
+ * @param {string} basePath - 기준 경로 (상대 경로 계산용)
+ * @param {number} depth - 현재 깊이
+ * @param {Array} results - 결과 배열 (mutation)
+ * @param {number} maxResults - 최대 결과 수
+ */
+async function searchFilesRecursive(dirPath, searchTerm, basePath, depth, results, maxResults) {
+    // 깊이 제한 또는 결과 수 제한 도달
+    if (depth > MAX_SEARCH_DEPTH || results.length >= maxResults) {
+        return;
+    }
+
+    try {
+        const entries = await safeReaddir(dirPath, { withFileTypes: true });
+
+        for (const entry of entries) {
+            if (results.length >= maxResults) break;
+
+            const name = entry.name;
+
+            // 숨김 파일/폴더 제외
+            if (name.startsWith('.')) continue;
+
+            // 제외 디렉토리 체크
+            if (entry.isDirectory() && EXCLUDED_DIRS.has(name)) continue;
+
+            const fullPath = join(dirPath, name);
+            const relativePath = relative(basePath, fullPath);
+            const nameLower = name.toLowerCase();
+
+            // 이름에 검색어가 포함되면 결과에 추가
+            if (nameLower.includes(searchTerm)) {
+                const isDirectory = entry.isDirectory();
+                results.push({
+                    value: '@' + relativePath + (isDirectory ? '/' : ''),
+                    displayValue: relativePath,
+                    icon: isDirectory ? '📁' : '📄',
+                    isDirectory,
+                    description: isDirectory ? 'Directory' : 'File',
+                    // 정렬용 점수: 이름이 검색어로 시작하면 높은 점수
+                    score: nameLower.startsWith(searchTerm) ? 2 : (nameLower === searchTerm ? 3 : 1)
+                });
+            }
+
+            // 디렉토리면 재귀 탐색
+            if (entry.isDirectory() && results.length < maxResults) {
+                await searchFilesRecursive(fullPath, searchTerm, basePath, depth + 1, results, maxResults);
+            }
+        }
+    } catch (error) {
+        // 접근 불가능한 디렉토리는 무시
+    }
+}
+
+/**
+ * 프로젝트 전체에서 파일을 검색합니다.
+ * @param {string} searchTerm - 검색어
+ * @returns {Promise<Array>} 검색 결과
+ */
+async function searchFiles(searchTerm) {
+    const basePath = process.cwd();
+    const searchTermLower = searchTerm.toLowerCase();
+    const results = [];
+
+    await searchFilesRecursive(basePath, searchTermLower, basePath, 0, results, MAX_SEARCH_RESULTS);
+
+    // 점수순 정렬 (높은 점수 우선), 같은 점수면 경로 길이 짧은 것 우선
+    results.sort((a, b) => {
+        if (b.score !== a.score) return b.score - a.score;
+        if (a.displayValue.length !== b.displayValue.length) {
+            return a.displayValue.length - b.displayValue.length;
+        }
+        return a.displayValue.localeCompare(b.displayValue);
+    });
+
+    return results.slice(0, MAX_SEARCH_RESULTS);
+}
+
+/**
+ * 디렉토리 내용을 가져와 필터링합니다.
+ * @param {string} prefix - @ 뒤의 경로 prefix
+ * @returns {Promise<Array>} 자동완성 항목 목록
+ */
+async function fetchDirectoryContents(prefix) {
+    try {
+        let dirPath;
+        let filterPrefix;
+
+        if (!prefix) {
+            dirPath = process.cwd();
+            filterPrefix = '';
+        } else if (prefix.endsWith('/')) {
+            dirPath = resolve(process.cwd(), prefix);
+            filterPrefix = '';
+        } else {
+            const parentDir = dirname(prefix);
+            filterPrefix = basename(prefix).toLowerCase();
+
+            if (parentDir === '.' || parentDir === '') {
+                dirPath = process.cwd();
+            } else {
+                dirPath = resolve(process.cwd(), parentDir);
+            }
+        }
+
+        const exists = await safeExists(dirPath);
+        if (!exists) return [];
+
+        const stat = await safeStat(dirPath);
+        if (!stat.isDirectory()) return [];
+
+        const entries = await safeReaddir(dirPath, { withFileTypes: true });
+        const results = [];
+
+        for (const entry of entries) {
+            const name = entry.name;
+
+            if (name.startsWith('.')) continue;
+
+            if (filterPrefix && !name.toLowerCase().startsWith(filterPrefix)) continue;
+
+            const isDirectory = entry.isDirectory();
+
+            let completePath;
+            if (!prefix) {
+                completePath = name;
+            } else if (prefix.endsWith('/')) {
+                completePath = prefix + name;
+            } else {
+                const parentDir = dirname(prefix);
+                if (parentDir === '.' || parentDir === '') {
+                    completePath = name;
+                } else {
+                    completePath = join(parentDir, name);
+                }
+            }
+
+            results.push({
+                value: '@' + completePath + (isDirectory ? '/' : ''),
+                displayValue: name,
+                icon: isDirectory ? '📁' : '📄',
+                isDirectory,
+                description: isDirectory ? 'Directory' : 'File'
+            });
+        }
+
+        results.sort((a, b) => {
+            if (a.isDirectory && !b.isDirectory) return -1;
+            if (!a.isDirectory && b.isDirectory) return 1;
+            return a.displayValue.localeCompare(b.displayValue);
+        });
+
+        return results.slice(0, 20);
+
+    } catch (error) {
+        return [];
+    }
+}
+
+/**
+ * 파일 자동완성 훅
+ * @param {Object} buffer - Input buffer 객체
+ * @returns {Object} 자동완성 상태 및 핸들러
+ */
+export function useFileCompletion(buffer) {
+    const [suggestions, setSuggestions] = useState([]);
+    const [activeSuggestionIndex, setActiveSuggestionIndex] = useState(-1);
+    const [showSuggestions, setShowSuggestions] = useState(false);
+    const [atReference, setAtReference] = useState({ isActive: false, prefix: '', startIndex: -1, isSearchMode: false });
+    const lastTextRef = useRef('');
+    const fetchingRef = useRef(false);
+    const debounceTimerRef = useRef(null);
+    const lastSearchTermRef = useRef('');
+
+    useEffect(() => {
+        const text = buffer.text;
+
+        if (text === lastTextRef.current) {
+            return;
+        }
+        lastTextRef.current = text;
+
+        // 커서 위치 계산
+        const [row, col] = buffer.cursor;
+        const lines = buffer.lines;
+        let cursorPosition = 0;
+        for (let i = 0; i < row; i++) {
+            cursorPosition += lines[i].length + 1;
+        }
+        cursorPosition += col;
+
+        const ref = parseAtReference(text, cursorPosition);
+        setAtReference(ref);
+
+        if (!ref.isActive) {
+            if (showSuggestions) {
+                setSuggestions([]);
+                setShowSuggestions(false);
+                setActiveSuggestionIndex(-1);
+            }
+            // 디바운스 타이머 정리
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+                debounceTimerRef.current = null;
+            }
+            return;
+        }
+
+        // 검색 모드
+        if (ref.isSearchMode) {
+            // 같은 검색어면 스킵
+            if (ref.prefix === lastSearchTermRef.current) {
+                return;
+            }
+
+            // 기존 타이머 취소
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+
+            // 디바운스 적용
+            debounceTimerRef.current = setTimeout(async () => {
+                if (fetchingRef.current) return;
+
+                fetchingRef.current = true;
+                lastSearchTermRef.current = ref.prefix;
+
+                try {
+                    const results = await searchFiles(ref.prefix);
+
+                    // 텍스트가 변경되었으면 무시
+                    if (buffer.text !== lastTextRef.current) {
+                        fetchingRef.current = false;
+                        return;
+                    }
+
+                    setSuggestions(results);
+                    setShowSuggestions(results.length > 0);
+                    setActiveSuggestionIndex(results.length > 0 ? 0 : -1);
+                } catch (error) {
+                    // 에러 무시
+                } finally {
+                    fetchingRef.current = false;
+                }
+            }, SEARCH_DEBOUNCE_MS);
+
+            return;
+        }
+
+        // 경로 모드 (기존 로직)
+        lastSearchTermRef.current = '';
+
+        if (fetchingRef.current) {
+            return;
+        }
+
+        fetchingRef.current = true;
+        fetchDirectoryContents(ref.prefix).then(results => {
+            fetchingRef.current = false;
+
+            if (buffer.text !== lastTextRef.current) {
+                return;
+            }
+
+            setSuggestions(results);
+            setShowSuggestions(results.length > 0);
+            setActiveSuggestionIndex(results.length > 0 ? 0 : -1);
+        }).catch(() => {
+            fetchingRef.current = false;
+        });
+
+    }, [buffer.text, buffer.cursor, buffer.lines, showSuggestions]);
+
+    // 컴포넌트 언마운트 시 타이머 정리
+    useEffect(() => {
+        return () => {
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+    }, []);
+
+    const navigateUp = useCallback(() => {
+        setActiveSuggestionIndex(prev =>
+            prev > 0 ? prev - 1 : suggestions.length - 1
+        );
+    }, [suggestions.length]);
+
+    const navigateDown = useCallback(() => {
+        setActiveSuggestionIndex(prev =>
+            prev < suggestions.length - 1 ? prev + 1 : 0
+        );
+    }, [suggestions.length]);
+
+    const handleAutocomplete = useCallback((index) => {
+        if (index >= 0 && index < suggestions.length) {
+            const suggestion = suggestions[index];
+            const text = buffer.text;
+
+            const beforeAt = text.slice(0, atReference.startIndex);
+
+            const [row, col] = buffer.cursor;
+            const lines = buffer.lines;
+            let cursorPosition = 0;
+            for (let i = 0; i < row; i++) {
+                cursorPosition += lines[i].length + 1;
+            }
+            cursorPosition += col;
+            const afterCursor = text.slice(cursorPosition);
+
+            let newValue = suggestion.value;
+
+            if (!suggestion.isDirectory) {
+                newValue += ' ';
+            }
+
+            const newText = beforeAt + newValue + afterCursor;
+            buffer.setText(newText);
+
+            const newCursorPos = beforeAt.length + newValue.length;
+
+            let pos = 0;
+            let targetRow = 0;
+            let targetCol = 0;
+            const newLines = newText.split('\n');
+            for (let i = 0; i < newLines.length; i++) {
+                if (pos + newLines[i].length >= newCursorPos) {
+                    targetRow = i;
+                    targetCol = newCursorPos - pos;
+                    break;
+                }
+                pos += newLines[i].length + 1;
+            }
+
+            if (typeof buffer.setCursor === 'function') {
+                buffer.setCursor(targetRow, targetCol);
+            } else {
+                buffer.move('end');
+            }
+
+            if (suggestion.isDirectory) {
+                // 디렉토리 선택 시 검색 모드 해제
+                lastSearchTermRef.current = '';
+            } else {
+                setSuggestions([]);
+                setShowSuggestions(false);
+                setActiveSuggestionIndex(-1);
+            }
+        }
+    }, [buffer, suggestions, atReference]);
+
+    const resetCompletionState = useCallback(() => {
+        setSuggestions([]);
+        setShowSuggestions(false);
+        setActiveSuggestionIndex(-1);
+        setAtReference({ isActive: false, prefix: '', startIndex: -1, isSearchMode: false });
+        lastSearchTermRef.current = '';
+        if (debounceTimerRef.current) {
+            clearTimeout(debounceTimerRef.current);
+            debounceTimerRef.current = null;
+        }
+    }, []);
+
+    return {
+        suggestions,
+        activeSuggestionIndex,
+        showSuggestions,
+        navigateUp,
+        navigateDown,
+        handleAutocomplete,
+        resetCompletionState
+    };
+}

package/src/system/ai_request.js

@@ -704,21 +704,46 @@ export async function request(taskName, requestPayload) {
  *
  * @see https://platform.openai.com/docs/guides/error-codes
  */
+/*
+ * Z.AI/GLM 컨텍스트 초과 에러 샘플:
+ * {
+ *   "error": {
+ *     "code": "1210",
+ *     "message": "Invalid API parameter, please check the documentation.Request 320006 input tokens exceeds the model's maximum context length 202750"
+ *   },
+ *   "request_id": "20260124000100026f0914d2e744f5"
+ * }
+ * HTTP_STATUS: 400
+ */
 export function shouldRetryWithTrim(error) {
     if (!error) return false;
 
-    // OpenAI SDK의 공식 에러 코드 확인
+    // 에러 코드 및 메시지 추출
     const errorCode = error?.code || error?.error?.code;
+    const errorMessage = error?.message || error?.error?.message || '';
 
+    // OpenAI: context_length_exceeded
     if (errorCode === 'context_length_exceeded') {
-        debugLog('[shouldRetryWithTrim] Detected: context_length_exceeded');
+        debugLog('[shouldRetryWithTrim] Detected: context_length_exceeded (OpenAI)');
+        return true;
+    }
+
+    // Z.AI/GLM: code "1210" (context length exceeded)
+    if (errorCode === '1210' || errorCode === 1210) {
+        debugLog('[shouldRetryWithTrim] Detected: code 1210 (GLM context exceeded)');
+        return true;
+    }
+
+    // 메시지에서 컨텍스트 초과 패턴 감지 (다양한 API 대응)
+    const contextExceededPattern = /exceeds.*(?:context|token).*(?:length|limit|maximum)/i;
+    if (contextExceededPattern.test(errorMessage)) {
+        debugLog(`[shouldRetryWithTrim] Detected context exceeded in message: ${errorMessage.substring(0, 100)}`);
         return true;
     }
 
     // 400 에러도 trim 후 재시도 대상
     if (error?.status === 400 || error?.response?.status === 400) {
         const errorType = error?.type || error?.error?.type;
-        const errorMessage = error?.message || error?.error?.message || '';
         debugLog(
             `[shouldRetryWithTrim] Detected 400 error - ` +
             `Type: ${errorType}, Code: ${errorCode}, ` +