aiexecode 1.0.94 → 1.0.127

package/src/system/conversation_state.js

@@ -0,0 +1,265 @@
+/**
+ * Conversation State Manager
+ * orchestratorConversation 전역 변수를 클래스로 캡슐화하여 상태 관리를 개선합니다.
+ */
+
+import { deepClone } from '../util/clone.js';
+
+/**
+ * 대화 상태 관리 클래스
+ * 전역 대화 상태를 캡슐화하고 안전한 접근 메서드를 제공합니다.
+ */
+class ConversationStateManager {
+    constructor() {
+        /** @type {Array} 대화 히스토리 */
+        this._conversation = [];
+
+        /** @type {Object|null} 요청 옵션 */
+        this._requestOptions = null;
+
+        /** @type {number} 마지막 수정 타임스탬프 */
+        this._lastModified = Date.now();
+
+        /** @type {string|null} 현재 세션 ID */
+        this._sessionId = null;
+    }
+
+    /**
+     * 대화 히스토리를 가져옵니다.
+     * @param {boolean} clone - true이면 깊은 복사본 반환 (기본: false)
+     * @returns {Array} 대화 히스토리
+     */
+    getConversation(clone = false) {
+        if (clone) {
+            return deepClone(this._conversation);
+        }
+        return this._conversation;
+    }
+
+    /**
+     * 대화 히스토리를 설정합니다.
+     * @param {Array} conversation - 새 대화 히스토리
+     */
+    setConversation(conversation) {
+        if (!Array.isArray(conversation)) {
+            throw new Error('Conversation must be an array');
+        }
+        this._conversation = conversation;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화에 메시지를 추가합니다.
+     * @param {Object} message - 추가할 메시지
+     */
+    addMessage(message) {
+        if (!message || typeof message !== 'object') {
+            throw new Error('Message must be an object');
+        }
+        this._conversation.push(message);
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화에 여러 메시지를 추가합니다.
+     * @param {Array} messages - 추가할 메시지 배열
+     */
+    addMessages(messages) {
+        if (!Array.isArray(messages)) {
+            throw new Error('Messages must be an array');
+        }
+        this._conversation.push(...messages);
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화 히스토리를 초기화합니다.
+     */
+    reset() {
+        this._conversation = [];
+        this._requestOptions = null;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화 히스토리를 복원합니다.
+     * @param {Array} conversation - 복원할 대화 히스토리
+     * @param {Object} requestOptions - 복원할 요청 옵션
+     */
+    restore(conversation, requestOptions = null) {
+        this._conversation = Array.isArray(conversation) ? conversation : [];
+        this._requestOptions = requestOptions;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 요청 옵션을 가져옵니다.
+     * @returns {Object|null} 요청 옵션
+     */
+    getRequestOptions() {
+        return this._requestOptions;
+    }
+
+    /**
+     * 요청 옵션을 설정합니다.
+     * @param {Object} options - 요청 옵션
+     */
+    setRequestOptions(options) {
+        this._requestOptions = options;
+        this._lastModified = Date.now();
+    }
+
+    /**
+     * 대화 히스토리의 길이를 반환합니다.
+     * @returns {number} 메시지 수
+     */
+    get length() {
+        return this._conversation.length;
+    }
+
+    /**
+     * 대화가 비어있는지 확인합니다.
+     * @returns {boolean} 비어있으면 true
+     */
+    isEmpty() {
+        return this._conversation.length === 0;
+    }
+
+    /**
+     * 마지막 수정 시간을 반환합니다.
+     * @returns {number} 타임스탬프
+     */
+    getLastModified() {
+        return this._lastModified;
+    }
+
+    /**
+     * 세션 ID를 설정합니다.
+     * @param {string} sessionId - 세션 ID
+     */
+    setSessionId(sessionId) {
+        this._sessionId = sessionId;
+    }
+
+    /**
+     * 세션 ID를 가져옵니다.
+     * @returns {string|null} 세션 ID
+     */
+    getSessionId() {
+        return this._sessionId;
+    }
+
+    /**
+     * 대화에서 특정 조건을 만족하는 메시지를 찾습니다.
+     * @param {Function} predicate - 검색 조건 함수
+     * @returns {Object|undefined} 찾은 메시지 또는 undefined
+     */
+    findMessage(predicate) {
+        return this._conversation.find(predicate);
+    }
+
+    /**
+     * 대화에서 특정 조건을 만족하는 메시지들을 필터링합니다.
+     * @param {Function} predicate - 필터 조건 함수
+     * @returns {Array} 필터링된 메시지 배열
+     */
+    filterMessages(predicate) {
+        return this._conversation.filter(predicate);
+    }
+
+    /**
+     * 마지막 메시지를 가져옵니다.
+     * @returns {Object|undefined} 마지막 메시지 또는 undefined
+     */
+    getLastMessage() {
+        if (this._conversation.length === 0) {
+            return undefined;
+        }
+        return this._conversation[this._conversation.length - 1];
+    }
+
+    /**
+     * 마지막 N개의 메시지를 가져옵니다.
+     * @param {number} count - 가져올 메시지 수
+     * @returns {Array} 메시지 배열
+     */
+    getLastMessages(count) {
+        if (count <= 0) {
+            return [];
+        }
+        return this._conversation.slice(-count);
+    }
+
+    /**
+     * 대화 히스토리를 트리밍합니다 (오래된 메시지 제거).
+     * @param {number} keepCount - 유지할 메시지 수 (시스템 메시지 제외)
+     * @returns {number} 제거된 메시지 수
+     */
+    trim(keepCount) {
+        const originalLength = this._conversation.length;
+
+        // 시스템 메시지는 유지
+        const systemMessages = this._conversation.filter(m => m.role === 'system');
+        const otherMessages = this._conversation.filter(m => m.role !== 'system');
+
+        // 최근 keepCount개만 유지
+        const keptMessages = otherMessages.slice(-keepCount);
+
+        this._conversation = [...systemMessages, ...keptMessages];
+        this._lastModified = Date.now();
+
+        return originalLength - this._conversation.length;
+    }
+
+    /**
+     * 상태를 직렬화 가능한 객체로 변환합니다.
+     * @returns {Object} 직렬화 가능한 상태 객체
+     */
+    toJSON() {
+        return {
+            conversation: deepClone(this._conversation),
+            requestOptions: this._requestOptions ? deepClone(this._requestOptions) : null,
+            lastModified: this._lastModified,
+            sessionId: this._sessionId
+        };
+    }
+
+    /**
+     * 직렬화된 상태에서 복원합니다.
+     * @param {Object} state - 직렬화된 상태 객체
+     */
+    fromJSON(state) {
+        if (state.conversation) {
+            this._conversation = state.conversation;
+        }
+        if (state.requestOptions !== undefined) {
+            this._requestOptions = state.requestOptions;
+        }
+        if (state.lastModified) {
+            this._lastModified = state.lastModified;
+        }
+        if (state.sessionId) {
+            this._sessionId = state.sessionId;
+        }
+    }
+}
+
+// 싱글톤 인스턴스 생성 및 export
+export const conversationState = new ConversationStateManager();
+
+// 후방 호환성을 위한 개별 함수들 export
+export function getOrchestratorConversation() {
+    return conversationState.getConversation();
+}
+
+export function setOrchestratorConversation(conversation) {
+    conversationState.setConversation(conversation);
+}
+
+export function resetOrchestratorConversation() {
+    conversationState.reset();
+}
+
+export function restoreOrchestratorConversation(conversation, requestOptions) {
+    conversationState.restore(conversation, requestOptions);
+}

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