aiexecode 1.0.157

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/frontend/hooks/useKeypress.js

@@ -0,0 +1,145 @@
+/**
+ * Keypress hook for handling keyboard input
+ */
+
+import { useInput } from 'ink';
+
+export function useKeypress(handler, options = {}) {
+    const { isActive = true } = options;
+
+    useInput((input, key) => {
+        if (!isActive) return;
+
+        // Fix backspace detection - Ink has serious bugs
+        // Workaround: Ignore empty sequence events and wait for valid ones
+        let actualBackspace = false;
+        let actualDelete = false;
+
+        // Check key.name first (most reliable when present)
+        if (key.name === 'backspace') {
+            actualBackspace = true;
+        } else if (key.name === 'delete') {
+            actualDelete = true;
+        }
+        // If key.name is undefined, check the original flags
+        else if (key.backspace === true) {
+            // For backspace, only accept if there's sequence data (Ink bug workaround)
+            if (input && input.length > 0) {
+                actualBackspace = true;
+            } else {
+                // Ignore spurious empty backspace events
+                return;
+            }
+        } else if (key.delete === true) {
+            // WORKAROUND: In some terminals, backspace is mapped to delete with empty input
+            // If delete flag is set but there's no input sequence, treat it as backspace
+            if (!input || input.length === 0) {
+                actualBackspace = true;
+            } else {
+                actualDelete = true;
+            }
+        }
+        // Last resort: check input sequence
+        else if (input && input.length > 0) {
+            const charCode = input.charCodeAt(0);
+            // Backspace: \x7F (127) or \x08 (8)
+            if (charCode === 127 || charCode === 8) {
+                actualBackspace = true;
+            }
+            // Delete: ESC[3~
+            else if (input === '\x1B[3~' || input.startsWith('\x1B[3')) {
+                actualDelete = true;
+            }
+        }
+
+        // Count multiple backspaces/deletes in the sequence (for fast deletion)
+        let repeatCount = 1;
+        if ((actualBackspace || actualDelete) && input && input.length > 1) {
+            // Count how many backspace/delete characters are in the sequence
+            if (actualBackspace) {
+                repeatCount = Array.from(input).filter(c =>
+                    c.charCodeAt(0) === 127 || c.charCodeAt(0) === 8
+                ).length;
+            }
+            // For delete, it's always 1 (escape sequences don't batch)
+        }
+
+        // Detect Ctrl+C/D when name is undefined
+        let detectedName = key.name;
+        if (key.ctrl && !detectedName && input) {
+            // In Ink's raw mode, Ctrl+C comes as input="c" with ctrl=true
+            // not as charCode 3
+            if (input.toLowerCase() === 'c') {
+                detectedName = 'c';
+            } else if (input.toLowerCase() === 'd') {
+                detectedName = 'd';
+            } else {
+                // Fallback: check for actual control characters
+                const charCode = input.charCodeAt(0);
+                if (charCode === 3) {
+                    detectedName = 'c';
+                } else if (charCode === 4) {
+                    detectedName = 'd';
+                }
+            }
+        }
+
+        // Normalize key object to prevent undefined issues
+        const normalizedKey = {
+            ...key,
+            sequence: input,
+            name: key.return ? 'return' : detectedName,
+            ctrl: key.ctrl ?? false,
+            meta: key.meta ?? false,
+            shift: key.shift ?? false,
+            escape: key.escape ?? false,
+            return: key.return ?? false,
+            upArrow: key.upArrow ?? false,
+            downArrow: key.downArrow ?? false,
+            leftArrow: key.leftArrow ?? false,
+            rightArrow: key.rightArrow ?? false,
+            backspace: actualBackspace,  // Use corrected value
+            delete: actualDelete,        // Use corrected value
+            repeatCount: repeatCount,    // NEW: How many times to repeat
+            tab: key.tab ?? false,
+            home: key.home ?? false,
+            end: key.end ?? false,
+            pageUp: key.pageUp ?? false,
+            pageDown: key.pageDown ?? false,
+            paste: key.paste ?? false, // Important for paste detection
+        };
+
+        handler(normalizedKey);
+    }, { isActive });
+}
+
+/**
+ * Key matcher functions
+ */
+export const keyMatchers = {
+    SUBMIT: (key) => key.return && !key.shift && !key.ctrl && !key.meta,
+    NEWLINE: (key) => key.return && key.shift,
+    ESCAPE: (key) => key.escape,
+    NAVIGATION_UP: (key) => key.upArrow && !key.ctrl,
+    NAVIGATION_DOWN: (key) => key.downArrow && !key.ctrl,
+    HISTORY_UP: (key) => key.upArrow && !key.ctrl,
+    HISTORY_DOWN: (key) => key.downArrow && !key.ctrl,
+    COMPLETION_UP: (key) => key.upArrow && key.ctrl,
+    COMPLETION_DOWN: (key) => key.downArrow && key.ctrl,
+    ACCEPT_SUGGESTION: (key) => key.tab,
+    HOME: (key) => (key.name === 'a' && key.ctrl) || key.home,
+    END: (key) => (key.name === 'e' && key.ctrl) || key.end,
+    CLEAR_INPUT: (key) => key.name === 'c' && key.ctrl && !key.meta,
+    CLEAR_SCREEN: (key) => key.name === 'l' && key.ctrl,
+    KILL_LINE_RIGHT: (key) => key.name === 'k' && key.ctrl,
+    KILL_LINE_LEFT: (key) => key.name === 'u' && key.ctrl,
+    DELETE_WORD_BACKWARD: (key) => key.name === 'w' && key.ctrl,
+    QUIT: (key) => key.name === 'c' && key.ctrl,
+    EXIT: (key) => key.name === 'd' && key.ctrl,
+    REVERSE_SEARCH: (key) => key.name === 'r' && key.ctrl,
+};
+
+export const Command = Object.keys(keyMatchers).reduce((acc, key) => {
+    acc[key] = key;
+    return acc;
+}, {});

package/src/frontend/index.js

@@ -0,0 +1,65 @@
+/**
+ * Ink UI entry point
+ */
+
+import React from 'react';
+import { render } from 'ink';
+import { App } from './App.js';
+import { OutputRedirector } from './utils/outputRedirector.js';
+import { createDebugLogger } from '../util/debug_log.js';
+
+const debugLog = createDebugLogger('ui.log', 'index');
+
+export function startUI({ onSubmit, onClearScreen, onExit, commands = [], model = 'gpt-4', version = '1.0.0', initialHistory = [], reasoningEffort = null }) {
+    debugLog(`startUI called - model: ${model}, version: ${version}, commands: ${commands.length}, initialHistory: ${initialHistory.length}`);
+
+    // Patch console methods to prevent interference with Ink rendering
+    const outputRedirector = new OutputRedirector();
+    outputRedirector.patch();
+    debugLog('OutputRedirector patched');
+
+    // Disable terminal line wrapping to reduce rendering artifacts
+    // This prevents the terminal from wrapping lines itself, letting Ink handle all wrapping
+    process.stdout.write('\x1b[?7l');
+    debugLog('Terminal line wrapping disabled');
+
+    const { unmount, waitUntilExit } = render(
+        React.createElement(App, {
+            onSubmit,
+            onClearScreen,
+            onExit,
+            commands,
+            model,
+            version,
+            initialHistory,
+            reasoningEffort
+        }),
+        {
+            // Use patchConsole option to prevent console output from interfering
+            patchConsole: false, // We're handling this manually with OutputRedirector
+            // Don't exit on Ctrl+C - let the app handle it
+            exitOnCtrlC: false,
+            // Debug mode ON - prevents clearing terminal and preserves previous content
+            debug: false
+        }
+    );
+
+    debugLog('UI render completed successfully');
+
+    // Re-enable line wrapping and restore console on cleanup
+    const originalUnmount = unmount;
+    const wrappedUnmount = () => {
+        debugLog('wrappedUnmount called - cleaning up UI');
+        // Re-enable line wrapping
+        process.stdout.write('\x1b[?7h');
+        outputRedirector.cleanup();
+        debugLog('OutputRedirector cleanup completed');
+        originalUnmount();
+        debugLog('UI unmounted');
+    };
+
+    return {
+        unmount: wrappedUnmount,
+        waitUntilExit
+    };
+}