Merge pull request #13 from z060142/Temporary-solution

Temporary solution

.gitignore

@@ -1,3 +1,13 @@
 .env
+*.log
 llm_debug.log
-__pycache__/
+config.py
+config.py.bak
+simple_bubble_dedup.json
+__pycache__/
+debug_screenshots/
+chat_logs/
+backup/
+chroma_data/
+wolf_control.py
+remote_config.json

ClaudeCode.md

@@ -15,57 +15,81 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 ### 核心元件
 
-1. **主控模塊 (main.py)**
-   - 協調各模塊的工作
-   - 初始化 MCP 連接
-   - 設置並管理主要事件循環
-   - 處理程式生命週期管理和資源清理
+1.  **主控模塊 (main.py)**
+    - 協調各模塊的工作
+    - 初始化 MCP 連接
+        - **容錯處理**：即使 `config.py` 中未配置 MCP 伺服器，或所有伺服器連接失敗，程式現在也會繼續執行，僅打印警告訊息，MCP 功能將不可用。 (Added 2025-04-21)
+        - **伺服器子進程管理 (修正 2025-05-02)**：使用 `mcp.client.stdio.stdio_client` 啟動和連接 `config.py` 中定義的每個 MCP 伺服器。`stdio_client` 作為一個異步上下文管理器，負責管理其啟動的子進程的生命週期。
+        - **Windows 特定處理 (修正 2025-05-02)**：在 Windows 上，如果 `pywin32` 可用，會註冊一個控制台事件處理程序 (`win32api.SetConsoleCtrlHandler`)。此處理程序主要用於輔助觸發正常的關閉流程（最終會調用 `AsyncExitStack.aclose()`），而不是直接終止進程。伺服器子進程的實際終止依賴於 `stdio_client` 上下文管理器在 `AsyncExitStack.aclose()` 期間的清理操作。
+    - **記憶體系統初始化 (新增 2025-05-02)**：在啟動時調用 `chroma_client.initialize_memory_system()`，根據 `config.py` 中的 `ENABLE_PRELOAD_PROFILES` 設定決定是否啟用記憶體預載入。
+    - 設置並管理主要事件循環
+    - **記憶體預載入 (新增 2025-05-02)**：在主事件循環中，如果預載入已啟用，則在每次收到 UI 觸發後、調用 LLM 之前，嘗試從 ChromaDB 預先獲取用戶資料 (`get_entity_profile`)、相關記憶 (`get_related_memories`) 和潛在相關的機器人知識 (`get_bot_knowledge`)。
+    - 處理程式生命週期管理和資源清理（通過 `AsyncExitStack` 間接管理 MCP 伺服器子進程的終止）
 
-2. **LLM 交互模塊 (llm_interaction.py)**
-   - 與語言模型 API 通信
-   - 管理系統提示與角色設定
-   - 處理語言模型的工具調用功能
-   - 格式化 LLM 回應
-   - 提供工具結果合成機制
+2.  **LLM 交互模塊 (llm_interaction.py)**
+    - 與語言模型 API 通信
+    - 管理系統提示與角色設定
+        - **條件式提示 (新增 2025-05-02)**：`get_system_prompt` 函數現在接受預載入的用戶資料、相關記憶和機器人知識。根據是否有預載入數據，動態調整系統提示中的記憶體檢索協議說明。
+    - 處理語言模型的工具調用功能
+    - 格式化 LLM 回應
+    - 提供工具結果合成機制
 
-3. **UI 互動模塊 (ui_interaction.py)**
-   - 使用圖像辨識技術監控遊戲聊天視窗
-   - 檢測聊天泡泡與關鍵字
-   - 複製聊天內容和獲取發送者姓名
-   - 將生成的回應輸入到遊戲中
+3.  **UI 互動模塊 (ui_interaction.py)**
+    - 使用圖像辨識技術監控遊戲聊天視窗
+    - 檢測聊天泡泡與關鍵字
+    - 複製聊天內容和獲取發送者姓名
+    - 將生成的回應輸入到遊戲中
 
-4. **MCP 客戶端模塊 (mcp_client.py)**
-   - 管理與 MCP 服務器的通信
-   - 列出和調用可用工具
-   - 處理工具調用的結果和錯誤
+4.  **MCP 客戶端模塊 (mcp_client.py)**
+    - 管理與 MCP 服務器的通信
+    - 列出和調用可用工具
+    - 處理工具調用的結果和錯誤
 
-5. **配置模塊 (config.py)**
-   - 集中管理系統參數和設定
-   - 整合環境變數
-   - 配置 API 密鑰和服務器設定
+5.  **配置模塊 (config.py)**
+    - 集中管理系統參數和設定
+    - 整合環境變數
+    - 配置 API 密鑰和服務器設定
 
-6. **角色定義 (persona.json)**
-   - 詳細定義機器人的人格特徵
-   - 包含外觀、說話風格、個性特點等資訊
-   - 提供給 LLM 以確保角色扮演一致性
+6.  **角色定義 (persona.json)**
+    - 詳細定義機器人的人格特徵
+    - 包含外觀、說話風格、個性特點等資訊
+    - 提供給 LLM 以確保角色扮演一致性
 
-7. **視窗設定工具 (window-setup-script.py)**
-   - 輔助工具，用於設置遊戲視窗的位置和大小
-   - 方便開發階段截取 UI 元素樣本
+7.  **遊戲管理器模組 (game_manager.py)** (取代舊的 `game_monitor.py`)
+    - **核心類 `GameMonitor`**：封裝所有遊戲視窗監控、自動重啟和進程管理功能。
+    - **由 `Setup.py` 管理**：
+        - 在 `Setup.py` 的 "Start Managed Bot & Game" 流程中被實例化和啟動。
+        - 在停止會話時由 `Setup.py` 停止。
+        - 設定（如視窗標題、路徑、重啟間隔等）通過 `Setup.py` 傳遞，並可在運行時通過 `update_config` 方法更新。
+    - **功能**：
+        - 持續監控遊戲視窗 (`config.WINDOW_TITLE`)。
+        - 確保視窗維持在設定檔中指定的位置和大小。
+        - 確保視窗保持活躍（帶到前景並獲得焦點）。
+        - **定時遊戲重啟**：根據設定檔中的間隔執行。
+            - **回調機制**：重啟完成後，通過回調函數通知 `Setup.py`（例如，`restart_complete`），`Setup.py` 隨後處理機器人重啟。
+        - **進程管理**：使用 `psutil`（如果可用）查找和終止遊戲進程。
+        - **跨平台啟動**：使用 `os.startfile` (Windows) 或 `subprocess.Popen` (其他平台) 啟動遊戲。
+    - **獨立運行模式**：`game_manager.py` 仍然可以作為獨立腳本運行 (類似舊的 `game_monitor.py`)，此時它會從 `config.py` 加載設定，並通過 `stdout` 發送 JSON 訊號。
+
+8.  **ChromaDB 客戶端模塊 (chroma_client.py)** (新增 2025-05-02)
+    - 處理與本地 ChromaDB 向量數據庫的連接和互動。
+    - 提供函數以初始化客戶端、獲取/創建集合，以及查詢用戶資料、相關記憶和機器人知識。
+    - 使用 `chromadb.PersistentClient` 連接持久化數據庫。
 
 ### 資料流程
 
 ```
 [遊戲聊天視窗]
      ↑↓
-[UI 互動模塊] <→ [圖像樣本庫]
+[UI 互動模塊] <→ [圖像樣本庫 / bubble_colors.json]
      ↓
 [主控模塊] ← [角色定義]
-   ↑↓
-[LLM 交互模塊] <→ [語言模型 API]
+   ↑↓         ↑↓
+[LLM 交互模塊] ← [ChromaDB 客戶端模塊] <→ [ChromaDB 數據庫]
    ↑↓
 [MCP 客戶端] <→ [MCP 服務器]
 ```
+*(資料流程圖已更新以包含 ChromaDB)*
 
 ## 技術實現
 
@@ -73,13 +97,41 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 #### 聊天監控與觸發機制
 
-系統使用基於圖像辨識的方法監控遊戲聊天界面：
+系統監控遊戲聊天界面以偵測觸發事件。主要方法包括：
 
-1. **泡泡檢測**：通過辨識聊天泡泡的角落圖案定位聊天訊息，區分一般用戶與機器人
-2. **關鍵字檢測**：在泡泡區域內搜尋 "wolf" 或 "Wolf" 關鍵字圖像
-3. **內容獲取**：點擊關鍵字位置，使用剪貼板複製聊天內容
-4. **發送者識別**：通過點擊頭像，導航菜單，複製用戶名稱
-5. **防重複處理**：使用位置比較和內容歷史記錄防止重複回應
+1.  **泡泡檢測 (Bubble Detection)**：
+    *   **主要方法 (可選，預設禁用)**：**基於顏色的連通區域分析 (Color-based Connected Components Analysis)**
+        *   **原理**：在特定區域 `(150, 330, 600, 880)` 內截圖，轉換至 HSV 色彩空間，根據 `bubble_colors.json` 中定義的顏色範圍 (HSV Lower/Upper) 建立遮罩 (Mask)，透過形態學操作 (Morphological Closing) 去除噪點並填充空洞，最後使用 `cv2.connectedComponentsWithStats` 找出符合面積閾值 (Min/Max Area) 的連通區域作為聊天泡泡。
+        *   **效能優化**：在進行顏色分析前，可將截圖縮放 (預設 `scale_factor=0.5`) 以減少處理像素量，提高速度。面積閾值會根據縮放比例自動調整。
+        *   **配置**：不同泡泡類型（如一般用戶、機器人）的顏色範圍和面積限制定義在 `bubble_colors.json` 文件中。
+        *   **啟用**：此方法預設**禁用**。若要啟用，需修改 `ui_interaction.py` 中 `DetectionModule` 類別 `__init__` 方法內的 `self.use_color_detection` 變數為 `True`。
+    *   **備用/預設方法**：**基於模板匹配的角落配對 (Template Matching Corner Pairing)**
+        *   **原理**：在特定區域 `(150, 330, 600, 880)` 內，通過辨識聊天泡泡的左上角 (TL) 和右下角 (BR) 角落圖案 (`corner_*.png`, `bot_corner_*.png`) 來定位聊天訊息。
+        *   **多外觀支援**：支援多種一般用戶泡泡外觀 (skin)，可同時尋找多組不同的角落模板。機器人泡泡目前僅偵測預設模板。
+        *   **配對邏輯**：優先選擇與 TL 角落 Y 座標最接近的有效 BR 角落進行配對。
+    *   **方法選擇與回退**：
+        *   若 `use_color_detection` 設為 `True`，系統會**優先嘗試**顏色檢測。
+        *   如果顏色檢測成功並找到泡泡，則使用其結果。
+        *   如果顏色檢測**失敗** (發生錯誤) 或**未找到任何泡泡**，系統會**自動回退**到模板匹配方法。
+        *   若 `use_color_detection` 設為 `False`，則直接使用模板匹配方法。
+2.  **關鍵字檢測 (Keyword Detection)**：在偵測到的泡泡區域內，使用模板匹配搜尋 "wolf" 或 "Wolf" 關鍵字圖像 (包括多種樣式，如 `keyword_wolf_lower_type2.png`, `keyword_wolf_reply.png` 等)。
+3.  **內容獲取 (Content Retrieval)**：
+    *   **重新定位**：在複製文字前，使用觸發時擷取的氣泡快照 (`bubble_snapshot`) 在螢幕上重新定位氣泡的當前位置。
+    *   **計算點擊位置**：根據重新定位後的氣泡位置和關鍵字在其中的相對位置，計算出用於複製文字的精確點擊座標。如果偵測到的是特定回覆關鍵字 (`keyword_wolf_reply*`)，則 Y 座標會增加偏移量 (目前為 +25 像素)。
+    *   **複製**：點擊計算出的座標，嘗試使用彈出菜單的 "複製" 選項或模擬 Ctrl+C 來複製聊天內容至剪貼板。
+4.  **發送者識別 (Sender Identification)**：
+    *   **重新定位**：再次使用氣泡快照重新定位氣泡。
+    *   **計算頭像座標**：根據**新**找到的氣泡左上角座標，應用特定偏移量 (`AVATAR_OFFSET_X_REPLY`, `AVATAR_OFFSET_Y_REPLY`) 計算頭像點擊位置。
+    *   **互動（含重試）**：點擊計算出的頭像位置，檢查是否成功進入個人資料頁面 (`Profile_page.png`)。若失敗，最多重試 3 次（每次重試前會再次重新定位氣泡）。若成功，則繼續導航菜單複製用戶名稱。
+    *   **原始偏移量**：原始的 `-55` 像素水平偏移量 (`AVATAR_OFFSET_X`) 仍保留，用於 `remove_user_position` 等其他功能。
+5.  **防重複處理 (Duplicate Prevention)**：
+    *   **基於圖像哈希的去重 (Image Hash Deduplication)**: 新增 `simple_bubble_dedup.py` 模塊，實現基於圖像感知哈希 (Perceptual Hash) 的去重系統。
+        *   **原理**: 系統會計算最近處理過的氣泡圖像的感知哈希值，並保存最近的 N 個 (預設 5 個) 氣泡的哈希。當偵測到新氣泡時，會計算其哈希並與保存的哈希進行比對。如果哈希差異小於設定的閾值 (預設 5)，則認為是重複氣泡並跳過處理。
+        *   **實現**: 在 `ui_interaction.py` 的 `run_ui_monitoring_loop` 函數中初始化 `SimpleBubbleDeduplication` 實例，並在偵測到關鍵字並截取氣泡快照後，調用 `is_duplicate` 方法進行檢查。
+        *   **狀態管理**: 使用 `simple_bubble_dedup.json` 文件持久化保存最近的氣泡哈希記錄。
+        *   **清理**: F7 (`clear_history`) 和 F8 (`reset_state`) 功能已擴展，會同時清除圖像去重系統中的記錄。
+        *   **發送者信息更新**: 在成功處理並將氣泡信息放入隊列後，會嘗試更新去重記錄中對應氣泡的發送者名稱。
+    *   **文字內容歷史 (已棄用)**: 原有的基於 `recent_texts` 的文字內容重複檢查邏輯已**移除或註解**，圖像哈希去重成為主要的去重機制。
 
 #### LLM 整合
 
@@ -112,10 +164,55 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 系統使用多種技術實現 UI 自動化：
 
-1. **圖像辨識**：使用 OpenCV 和 pyautogui 進行圖像匹配和識別
-2. **鍵鼠控制**：模擬鼠標點擊和鍵盤操作
-3. **剪貼板操作**：使用 pyperclip 讀寫剪貼板
-4. **狀態式處理**：基於 UI 狀態判斷的互動流程，確保操作穩定性
+1. **圖像辨識**：使用 OpenCV 和 pyautogui 進行圖像匹配和識別。
+2. **鍵鼠控制**：模擬鼠標點擊和鍵盤操作。
+3. **剪貼板操作**：使用 pyperclip 讀寫剪貼板。
+4. **狀態式處理**：基於 UI 狀態判斷的互動流程，確保操作穩定性。
+5. **針對性回覆（上下文激活）**：
+    - **時機**：在成功獲取發送者名稱並返回聊天介面後，但在將觸發資訊放入隊列傳遞給主線程之前。
+    - **流程**：
+        a. 再次使用氣泡快照重新定位觸發訊息的氣泡。
+        b. 如果定位成功，點擊氣泡中心，並等待 0.25 秒（增加的延遲時間）以允許 UI 反應。
+        c. 尋找並點擊彈出的「回覆」按鈕 (`reply_button.png`)。
+        d. 如果成功點擊回覆按鈕，則設置一個 `reply_context_activated` 標記為 `True`。
+        e. 如果重新定位氣泡失敗或未找到回覆按鈕，則該標記為 `False`。
+    - **傳遞**：將 `reply_context_activated` 標記連同其他觸發資訊（發送者、內容、氣泡區域）一起放入隊列。
+    - **發送**：主控模塊 (`main.py`) 在處理 `send_reply` 命令時，不再需要執行點擊回覆的操作，只需直接調用 `send_chat_message` 即可（因為如果 `reply_context_activated` 為 `True`，輸入框應已準備好）。
+
+## 最近改進（2025-04-28）
+
+### LLM 回應 JSON 輸出順序調整
+
+- **目的**：調整 LLM 結構化回應的 JSON 輸出格式，將 `commands` 欄位移至最前方，接著是 `dialogue` 和 `thoughts`，以期改善後續處理流程或提高 LLM 對工具調用（tool_calls）與指令（commands）區分的清晰度。
+- **`llm_interaction.py`**：
+    - 修改了 `parse_structured_response` 函數中構建結果字典的順序。
+    - 現在，當成功解析來自 LLM 的有效 JSON 時，輸出的字典鍵順序將優先排列 `commands`。
+    - **效果**：標準化了 JSON 回應的結構順序，有助於下游處理，並可能間接幫助 LLM 更清晰地組織其輸出，尤其是在涉及工具調用和特定指令時。
+
+## 最近改進（2025-05-01）
+
+### 關鍵字檢測重構 (雙重方法 + 座標校正)
+
+- **目的**：根據 "Wolf 關鍵詞檢測方法深度重構指南"，重構 `ui_interaction.py` 中的關鍵字檢測邏輯，以提高辨識穩定性並確保座標系統一致性。
+- **`ui_interaction.py` (`DetectionModule`)**：
+    - **新增雙重檢測方法 (`find_keyword_dual_method`)**：
+        - 使用 OpenCV (`cv2.matchTemplate`) 進行模板匹配。
+        - 同時在**灰度圖**和 **CLAHE 增強圖**上進行匹配，並處理**反相**情況 (`cv2.bitwise_not`)。
+        - **座標校正**：`cv2.matchTemplate` 返回的座標是相對於截圖區域 (`region`) 的。在返回結果前，已將其轉換為絕對螢幕座標 (`absolute_x = region_x + relative_x`, `absolute_y = region_y + relative_y`)，以確保與 `pyautogui` 點擊座標一致。
+        - **結果合併**：
+            1.  優先選擇灰度與 CLAHE 方法結果**重合**且距離接近 (`MATCH_DISTANCE_THRESHOLD`) 的匹配。
+            2.  若無重合，則選擇單一方法中置信度**非常高** (`DUAL_METHOD_HIGH_CONFIDENCE_THRESHOLD`) 的結果。
+            3.  若仍無結果，則回退到單一方法中置信度**較高** (`DUAL_METHOD_FALLBACK_CONFIDENCE_THRESHOLD`) 的結果。
+        - **核心模板**：僅使用三個核心模板 (`keyword_wolf_lower`, `keyword_Wolf_upper`, `keyword_wolf_reply`) 進行檢測。
+        - **效能統計**：添加了計數器以追蹤檢測次數、成功率、各方法使用分佈、平均時間和反相匹配率 (`print_detection_stats` 方法)。
+        - **除錯視覺化**：在高除錯級別 (`DEBUG_LEVEL >= 3`) 下，會保存預處理圖像和標記了檢測點的結果圖像。
+    - **舊方法保留 (`_find_keyword_legacy`)**：原有的基於 `pyautogui.locateAllOnScreen` 和多模板的 `find_keyword_in_region` 邏輯被移至此私有方法，用於向後兼容或調試比較。
+    - **包裝器方法 (`find_keyword_in_region`)**：現在作為一個包裝器，根據 `use_dual_method` 標誌（預設為 `True`）調用新的雙重方法或舊的 legacy 方法。
+    - **初始化更新**：`__init__` 方法更新以支持 `use_dual_method` 標誌、CLAHE 初始化、核心模板提取和效能計數器。
+- **`ui_interaction.py` (`run_ui_monitoring_loop`)**：
+    - **模板字典**：初始化時區分 `essential_templates` 和 `legacy_templates`，並合併後傳遞給 `DetectionModule`。
+    - **模塊實例化**：以 `use_dual_method=True` 實例化 `DetectionModule`。
+- **效果**：預期能提高關鍵字檢測在不同光照、對比度或 UI 主題下的魯棒性，同時確保檢測到的座標能被 `pyautogui` 正確用於點擊。簡化了需要維護的關鍵字模板數量。
 
 ## 配置與部署
 
@@ -131,10 +228,27 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 ### 環境設定
 
-1. **API 設定**：通過 .env 文件或環境變數設置 API 密鑰
-2. **MCP 服務器配置**：在 config.py 中配置要連接的 MCP 服務器
-3. **UI 樣本**：需要提供特定遊戲界面元素的截圖模板
-4. **視窗位置**：可使用 window-setup-script.py 調整遊戲視窗位置
+1.  **首次設定與配置工具 (Setup.py)**：
+    *   執行 `python Setup.py` 啟動圖形化設定工具。
+    *   **功能**：
+        *   檢查 `config.py` 和 `.env` 文件是否存在。
+        *   如果 `config.py` 不存在，使用 `config_template.py` 作為模板創建。
+        *   如果 `.env` 不存在，提示用戶輸入 API 金鑰等敏感資訊並創建。
+        *   提供多個標籤頁用於配置：
+            *   **API Settings**: 設定 OpenAI/兼容 API 的 Base URL、API Key 和模型名稱。
+            *   **MCP Servers**: 啟用/禁用和配置 Exa、Chroma 及自定義 MCP 伺服器。
+            *   **Game Settings**: 配置遊戲視窗標題、執行檔路徑、位置、大小和自動重啟選項。
+            *   **Memory Settings (新增 2025-05-02)**: 配置 ChromaDB 記憶體整合，包括啟用預載入、設定集合名稱（用戶資料、對話、機器人知識）和預載入記憶數量。
+        *   提供按鈕以保存設定、安裝依賴項、運行主腳本 (`main.py`)、運行測試腳本 (`test/llm_debug_script.py`) 以及停止由其啟動的進程。
+    *   **重要**：`.env` 文件應加入 `.gitignore`。`config.py` 通常也應加入 `.gitignore`。
+2.  **API 設定**：API 金鑰和其他敏感資訊儲存在 `.env` 文件中，由 `config.py` 讀取。
+3.  **核心配置 (config.py)**：包含非敏感的系統參數、MCP 伺服器列表、UI 模板路徑、遊戲視窗設定等。此文件現在由 `Setup.py` 根據 `config_template.py` 生成（如果不存在）。
+4.  **MCP 服務器配置**：在 `config.py` 中配置要連接的 MCP 服務器。
+5.  **UI 樣本**：需要提供特定遊戲界面元素的截圖模板，路徑在 `config.py` 中定義。
+6.  **遊戲視窗設定**：在 `config.py` 中配置：
+    *   遊戲執行檔路徑 (`GAME_EXECUTABLE_PATH`)。
+    *   目標視窗位置與大小 (`GAME_WINDOW_X`, `GAME_WINDOW_Y`, `GAME_WINDOW_WIDTH`, `GAME_WINDOW_HEIGHT`)。
+    *   監控間隔 (`MONITOR_INTERVAL_SECONDS`)。
 
 ## 最近改進（2025-04-17）
 
@@ -167,6 +281,340 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 這些優化確保了即使在複雜工具調用後，Wolfhart 也能保持角色一致性，並提供合適的回應。無效回應不再發送到遊戲，提高了用戶體驗。
 
+## 最近改進（2025-04-18）
+
+### 支援多種一般聊天泡泡外觀，並修正先前錯誤配置
+
+- **UI 互動模塊 (`ui_interaction.py`)**：
+    - **修正**：先前錯誤地將多外觀支援應用於機器人泡泡。現已修正 `find_dialogue_bubbles` 函數，使其能夠載入並搜尋多組**一般用戶**泡泡的角落模板（例如 `corner_tl_type2.png`, `corner_br_type2.png` 等）。
+    - 允許任何類型的一般用戶左上角與任何類型的一般用戶右下角進行配對，只要符合幾何條件。
+    - 機器人泡泡的偵測恢復為僅使用預設的 `bot_corner_tl.png` 和 `bot_corner_br.png` 模板。
+    - 這提高了對使用了自訂聊天泡泡外觀的**一般玩家**訊息的偵測能力。
+- **模板文件**：
+    - 在 `ui_interaction.py` 中為一般角落定義了新類型模板的路徑（`_type2`, `_type3`）。
+    - **注意：** 需要在 `templates` 資料夾中實際添加對應的 `corner_tl_type2.png`, `corner_br_type2.png` 等圖片檔案才能生效。
+- **文件更新 (`ClaudeCode.md`)**：
+    - 在「技術實現」部分更新了泡泡檢測的說明。
+    - 添加了此「最近改進」條目，並修正了先前的描述。
+
+### 頭像點擊偏移量調整
+
+- **UI 互動模塊 (`ui_interaction.py`)**：
+    - 將 `AVATAR_OFFSET_X` 常數的值從 `-50` 調整為 `-55`。
+    - 這統一了常規關鍵字觸發流程和 `remove_user_position` 功能中計算頭像點擊位置時使用的水平偏移量。
+- **文件更新 (`ClaudeCode.md`)**：
+    - 在「技術實現」的「發送者識別」部分強調了點擊位置是相對於觸發泡泡計算的，並註明了新的偏移量。
+    - 添加了此「最近改進」條目。
+
+### 關鍵字檢測重構 (雙重方法與座標校正) (2025-05-01)
+
+- **目的**：提高關鍵字 ("wolf", "Wolf", 回覆指示符) 檢測的穩定性和對視覺變化的魯棒性，並確保檢測到的座標能準確對應 `pyautogui` 的點擊座標。
+- **`ui_interaction.py` (`DetectionModule`)**：
+    - **重構 `find_keyword_in_region`**：此方法現在作為一個包裝器 (wrapper)。
+    - **新增 `find_keyword_dual_method`**：
+        - 成為預設的關鍵字檢測方法 (由 `use_dual_method` 標誌控制，預設為 `True`)。
+        - **核心邏輯**：
+            1. 對目標區域截圖。
+            2. 同時準備灰度 (grayscale) 和 CLAHE (對比度限制自適應直方圖均衡化) 增強的圖像版本。
+            3. 對三種核心關鍵字模板 (`keyword_wolf_lower`, `keyword_Wolf_upper`, `keyword_wolf_reply`) 也進行灰度與 CLAHE 預處理。
+            4. 使用 `cv2.matchTemplate` 分別在灰度圖和 CLAHE 圖上進行模板匹配 (包括正向和反向匹配 `cv2.bitwise_not`)。
+            5. **座標校正**：將 `cv2.matchTemplate` 返回的 **相對** 於截圖區域的座標，通過加上截圖區域的左上角座標 (`region_x`, `region_y`)，轉換為 **絕對** 螢幕座標，確保與 `pyautogui` 使用的座標系統一致。
+            6. **結果合併策略**：
+                - 優先選擇灰度與 CLAHE 方法結果**重合** (中心點距離小於 `MATCH_DISTANCE_THRESHOLD`) 且置信度最高的匹配。
+                - 若無重合，則回退到單一方法中置信度最高的匹配 (需高於特定閾值 `DUAL_METHOD_FALLBACK_CONFIDENCE_THRESHOLD`)。
+        - **效能統計**：增加了計數器 (`performance_stats`) 來追蹤檢測總數、成功數、各方法成功數、反相匹配數和總耗時。新增 `print_detection_stats` 方法用於輸出統計。
+        - **除錯增強**：在高除錯級別 (`DEBUG_LEVEL >= 3`) 下，會保存預處理圖像和標記了檢測結果的圖像。
+    - **新增 `_find_keyword_legacy`**：包含原 `find_keyword_in_region` 的邏輯，使用 `pyautogui.locateAllOnScreen` 遍歷所有（包括已棄用的）關鍵字模板，用於向後兼容或除錯比較。
+    - **常量整理**：將核心關鍵字模板標記為活躍，其他類型標記為棄用，並添加了 CLAHE 和雙重方法相關的新常量。
+    - **初始化更新**：`__init__` 方法更新以支持新標誌、初始化 CLAHE 物件和效能計數器。
+- **`ui_interaction.py` (`run_ui_monitoring_loop`)**：
+    - 更新了 `templates` 字典的創建方式，區分核心模板和舊模板。
+    - 在實例化 `DetectionModule` 時傳遞 `use_dual_method=True`。
+- **效果**：預期能更可靠地在不同光照、對比度或顏色主題下檢測到關鍵字，同時確保點擊位置的準確性。
+
+### 聊天泡泡重新定位以提高穩定性
+
+- **UI 互動模塊 (`ui_interaction.py`)**：
+    - 在 `run_ui_monitoring_loop` 中，於偵測到關鍵字並成功複製文字後、獲取發送者名稱前，加入了新的邏輯：
+        1. 擷取觸發氣泡的圖像快照。
+        2. 使用 `pyautogui.locateOnScreen` 在聊天區域內重新尋找該快照的當前位置。
+        3. 若找到，則根據**新位置**的左上角座標和新的偏移量 (`AVATAR_OFFSET_X_RELOCATED = -50`) 計算頭像點擊位置。
+        4. 若找不到，則記錄警告並跳過此次互動。
+    - 新增了 `AVATAR_OFFSET_X_RELOCATED` 和 `BUBBLE_RELOCATE_CONFIDENCE` 常數。
+- **目的**：解決聊天視窗內容滾動後，原始偵測到的氣泡位置失效，導致點擊錯誤頭像的問題。透過重新定位，確保點擊的是與觸發訊息相對應的頭像。
+- **文件更新 (`ClaudeCode.md`)**：
+    - 更新了「技術實現」中的「發送者識別」部分，詳細說明了重新定位的步驟。
+    - 在此「最近改進」部分添加了這個新條目。
+
+### 互動流程優化 (頭像偏移、氣泡配對、針對性回覆)
+
+- **UI 互動模塊 (`ui_interaction.py`)**：
+    - **頭像偏移量調整**：修改了重新定位氣泡後計算頭像座標的邏輯，使用新的偏移量：左 `-45` (`AVATAR_OFFSET_X_REPLY`)，下 `+10` (`AVATAR_OFFSET_Y_REPLY`)。原始的 `-55` 偏移量 (`AVATAR_OFFSET_X`) 保留用於其他功能。
+    - **氣泡配對優化**：修改 `find_dialogue_bubbles` 函數，使其在配對左上角 (TL) 和右下角 (BR) 時，優先選擇 Y 座標差異最小的 BR 角落，以提高垂直相鄰氣泡的區分度。
+    - **頭像點擊重試**：修改 `retrieve_sender_name_interaction` 函數，增加了最多 3 次的重試邏輯。如果在點擊頭像後未能檢測到個人資料頁面，會嘗試重新定位氣泡並再次點擊。
+    - **針對性回覆時機調整與延遲增加**：
+        - 將點擊氣泡中心和回覆按鈕的操作移至成功獲取發送者名稱並返回聊天室之後、將觸發資訊放入隊列之前。
+        - **增加了點擊氣泡中心後、尋找回覆按鈕前的等待時間至 0.25 秒**，以提高在 UI 反應較慢時找到按鈕的成功率。
+        - 在放入隊列的數據中增加 `reply_context_activated` 標記，指示是否成功激活了回覆上下文。
+        - 簡化了處理 `send_reply` 命令的邏輯，使其僅負責發送消息。
+    - **氣泡快照保存 (用於除錯)**：在偵測到關鍵字後，擷取用於重新定位的氣泡圖像快照 (`bubble_snapshot`) 時，會將此快照保存到 `debug_screenshots` 文件夾中，檔名格式為 `debug_relocation_snapshot_X.png` (X 為 1 到 5 的循環數字)。這取代了先前僅保存氣泡區域截圖的邏輯。
+- **目的**：
+    - 進一步提高獲取發送者名稱的穩定性。
+    - 改善氣泡配對的準確性。
+    - 調整針對性回覆的流程，使其更符合邏輯順序，並通過增加延遲提高可靠性。
+    - 提供用於重新定位的實際圖像快照，方便除錯。
+- **文件更新 (`ClaudeCode.md`)**：
+    - 更新了「技術實現」中的「泡泡檢測」、「發送者識別」部分。
+    - 更新了「UI 自動化」部分關於「針對性回覆」的說明，反映了新的時機、標記和增加的延遲。
+    - 在此「最近改進」部分更新了這個匯總條目，以包含最新的修改（包括快照保存和延遲增加）。
+
+### UI 監控暫停與恢復機制 (2025-04-18)
+
+- **目的**：解決在等待 LLM 回應期間，持續的 UI 監控可能導致的不穩定性或干擾問題，特別是與 `remove_position` 等需要精確 UI 狀態的操作相關。
+- **`ui_interaction.py`**：
+    - 引入了全局（模塊級）`monitoring_paused_flag` 列表（包含一個布爾值）。
+    - 在 `run_ui_monitoring_loop` 的主循環開始處檢查此標誌。若為 `True`，則循環僅檢查命令隊列中的 `resume` 命令並休眠，跳過所有 UI 偵測和觸發邏輯。
+    - 在命令處理邏輯中添加了對 `pause` 和 `resume` 動作的處理，分別設置 `monitoring_paused_flag[0]` 為 `True` 或 `False`。
+- **`ui_interaction.py` (進一步修改)**：
+    - **修正命令處理邏輯**：修改了 `run_ui_monitoring_loop` 的主循環。現在，在每次迭代開始時，它會使用一個內部 `while True` 循環和 `command_queue.get_nowait()` 來**處理完隊列中所有待處理的命令**（包括 `pause`, `resume`, `send_reply`, `remove_position` 等）。
+    - **狀態檢查後置**：只有在清空當前所有命令後，循環才會檢查 `monitoring_paused_flag` 的狀態。如果標誌為 `True`，則休眠並跳過 UI 監控部分；如果為 `False`，則繼續執行 UI 監控（畫面檢查、氣泡偵測等）。
+    - **目的**：解決先前版本中 `resume` 命令可能導致 UI 線程過早退出暫停狀態，從而錯過緊隨其後的 `send_reply` 或 `remove_position` 命令的問題。確保所有來自 `main.py` 的命令都被及時處理。
+- **`main.py`**：
+    - （先前修改保持不變）在主處理循環 (`run_main_with_exit_stack` 的 `while True` 循環) 中：
+        - 在從 `trigger_queue` 獲取數據後、調用 `llm_interaction.get_llm_response` **之前**，向 `command_queue` 發送 `{ 'action': 'pause' }` 命令。
+        - 使用 `try...finally` 結構，確保在處理 LLM 回應（包括命令處理和發送回覆）**之後**，向 `command_queue` 發送 `{ 'action': 'resume' }` 命令，無論處理過程中是否發生錯誤。
+
+### `remove_position` 穩定性改進 (使用快照重新定位) (2025-04-19)
+
+- **目的**：解決 `remove_position` 命令因聊天視窗滾動導致基於舊氣泡位置計算座標而出錯的問題。
+- **`ui_interaction.py` (`run_ui_monitoring_loop`)**：
+    - 在觸發事件放入 `trigger_queue` 的數據中，額外添加了 `bubble_snapshot`（觸發氣泡的圖像快照）和 `search_area`（用於快照的搜索區域）。
+- **`main.py`**：
+    - 修改了處理 `remove_position` 命令的邏輯，使其從 `trigger_data` 中提取 `bubble_snapshot` 和 `search_area`，並將它們包含在發送給 `command_queue` 的命令數據中。
+- **`ui_interaction.py` (`remove_user_position` 函數)**：
+    - 修改了函數簽名，以接收 `bubble_snapshot` 和 `search_area` 參數。
+    - 在函數執行開始時，使用傳入的 `bubble_snapshot` 和 `search_area` 調用 `pyautogui.locateOnScreen` 來重新定位觸發氣泡的當前位置。
+    - 如果重新定位失敗，則記錄錯誤並返回 `False`。
+    - 如果重新定位成功，則後續所有基於氣泡位置的計算（包括尋找職位圖標的搜索區域 `search_region` 和點擊頭像的座標 `avatar_click_x`, `avatar_click_y`）都將使用這個**新找到的**氣泡座標。
+- **效果**：確保 `remove_position` 操作基於氣泡的最新位置執行，提高了在動態滾動的聊天界面中的可靠性。
+
+### 修正 Type3 關鍵字辨識並新增 Type4 支援 (2025-04-19)
+
+- **目的**：修復先前版本中 `type3` 關鍵字辨識的錯誤，並擴充系統以支援新的 `type4` 聊天泡泡外觀和對應的關鍵字樣式。
+- **`ui_interaction.py`**：
+    - **修正 `find_keyword_in_region`**：移除了錯誤使用 `type2` 模板鍵來尋找 `type3` 關鍵字的重複程式碼，確保 `type3` 關鍵字使用正確的模板 (`keyword_wolf_lower_type3`, `keyword_wolf_upper_type3`)。
+    - **新增 `type4` 泡泡支援**：
+        - 在檔案開頭定義了 `type4` 角落模板的路徑常數 (`CORNER_TL_TYPE4_IMG`, `CORNER_BR_TYPE4_IMG`)。
+        - 在 `find_dialogue_bubbles` 函數中，將 `type4` 的模板鍵 (`corner_tl_type4`, `corner_br_type4`) 加入 `regular_tl_keys` 和 `regular_br_keys` 列表。
+        - 在 `run_ui_monitoring_loop` 的 `templates` 字典中加入了對應的鍵值對。
+    - **新增 `type4` 關鍵字支援**：
+        - 在檔案開頭定義了 `type4` 關鍵字模板的路徑常數 (`KEYWORD_wolf_LOWER_TYPE4_IMG`, `KEYWORD_Wolf_UPPER_TYPE4_IMG`)。
+        - 在 `find_keyword_in_region` 函數中，加入了尋找 `type4` 關鍵字模板 (`keyword_wolf_lower_type4`, `keyword_wolf_upper_type4`) 的邏輯。
+        - 在 `run_ui_monitoring_loop` 的 `templates` 字典中加入了對應的鍵值對。
+- **效果**：提高了對 `type3` 關鍵字的辨識準確率，並使系統能夠辨識 `type4` 的聊天泡泡和關鍵字（前提是提供了對應的模板圖片）。
+
+### 新增 Reply 關鍵字偵測與點擊偏移 (2025-04-20)
+
+- **目的**：擴充關鍵字偵測機制，使其能夠辨識特定的回覆指示圖片 (`keyword_wolf_reply.png` 及其 type2, type3, type4 變體)，並在點擊這些特定圖片以複製文字時，應用 Y 軸偏移。
+- **`ui_interaction.py`**：
+    - **新增模板**：定義了 `KEYWORD_WOLF_REPLY_IMG` 系列常數，並將其加入 `run_ui_monitoring_loop` 中的 `templates` 字典。
+    - **擴充偵測**：修改 `find_keyword_in_region` 函數，加入對 `keyword_wolf_reply` 系列模板的搜尋邏輯。
+    - **條件式偏移**：在 `run_ui_monitoring_loop` 中，於偵測到關鍵字後，加入判斷邏輯。如果偵測到的關鍵字是 `keyword_wolf_reply` 系列之一，則：
+        1. 計算用於 `copy_text_at` 的點擊座標時，Y 座標會增加 15 像素。
+        2. 在後續嘗試激活回覆上下文時，計算用於點擊**氣泡中心**的座標時，Y 座標**也會**增加 15 像素。
+    - 其他關鍵字或 UI 元素的點擊不受影響。
+- **效果**：系統現在可以偵測新的回覆指示圖片作為觸發條件。當由這些圖片觸發時，用於複製文字的點擊和用於激活回覆上下文的氣泡中心點擊都會向下微調 15 像素，以避免誤觸其他 UI 元素。
+
+### 強化 LLM 上下文處理與回應生成 (2025-04-20)
+
+- **目的**：解決 LLM 可能混淆歷史對話與當前訊息，以及在回應中包含歷史記錄的問題。確保 `dialogue` 欄位只包含針對最新用戶訊息的新回覆。
+- **`llm_interaction.py`**：
+    - **修改 `get_system_prompt`**：
+        - 在 `dialogue` 欄位的規則中，明確禁止包含任何歷史記錄，並強調必須只回應標記為 `<CURRENT_MESSAGE>` 的最新訊息。
+        - 在核心指令中，要求 LLM 將分析和回應生成完全集中在 `<CURRENT_MESSAGE>` 標記的訊息上。
+        - 新增了對 `<CURRENT_MESSAGE>` 標記作用的說明。
+    - **修改 `_build_context_messages`**：
+        - 在構建發送給 LLM 的訊息列表時，將歷史記錄中的最後一條用戶訊息用 `<CURRENT_MESSAGE>...</CURRENT_MESSAGE>` 標籤包裹起來。
+        - 其他歷史訊息保持原有的 `[timestamp] speaker: message` 格式。
+- **效果**：通過更嚴格的提示和明確的上下文標記，引導 LLM 準確區分當前互動和歷史對話，預期能提高回應的相關性並防止輸出冗餘的歷史內容。
+
+### 強化 System Prompt 以鼓勵工具使用 (2025-04-19)
+
+- **目的**：調整 `llm_interaction.py` 中的 `get_system_prompt` 函數，使其更明確地引導 LLM 在回應前主動使用工具（特別是記憶體工具）和整合工具資訊。
+- **修改內容**：
+    1.  **核心身份強化**：在 `CORE IDENTITY AND TOOL USAGE` 部分加入新的一點，強調 Wolfhart 會主動查閱內部知識圖譜和外部來源。
+    2.  **記憶體指示強化**：將 `Memory Management (Knowledge Graph)` 部分的提示從 "IMPORTANT" 改為 "CRITICAL"，並明確指示在回應*之前*要考慮使用查詢工具檢查記憶體，同時也強調了寫入新資訊的主動性。
+- **效果**：旨在提高 LLM 使用工具的主動性和依賴性，使其回應更具上下文感知和資訊準確性，同時保持角色一致性。
+
+### 聊天歷史記錄上下文與日誌記錄 (2025-04-20)
+
+- **目的**：
+    1.  為 LLM 提供更豐富的對話上下文，以生成更連貫和相關的回應。
+    2.  新增一個可選的聊天日誌功能，用於調試和記錄。
+- **`main.py`**：
+    - 引入 `collections.deque` 來儲存最近的對話歷史（用戶訊息和機器人回應），上限為 50 條。
+    - 在調用 `llm_interaction.get_llm_response` 之前，將用戶訊息添加到歷史記錄中。
+    - 在收到有效的 LLM 回應後，將機器人回應添加到歷史記錄中。
+    - 新增 `log_chat_interaction` 函數，該函數：
+        - 檢查 `config.ENABLE_CHAT_LOGGING` 標誌。
+        - 如果啟用，則在 `config.LOG_DIR` 指定的文件夾中創建或附加到以日期命名的日誌文件 (`YYYY-MM-DD.log`)。
+        - 記錄包含時間戳、發送者（用戶/機器人）、發送者名稱和訊息內容的條目。
+    - 在收到有效 LLM 回應後調用 `log_chat_interaction`。
+- **`llm_interaction.py`**：
+    - 修改 `get_llm_response` 函數簽名，接收 `current_sender_name` 和 `history` 列表，而不是單個 `user_input`。
+    - 新增 `_build_context_messages` 輔助函數，該函數：
+        - 根據規則從 `history` 中篩選和格式化訊息：
+            - 包含與 `current_sender_name` 相關的最近 4 次互動（用戶訊息 + 機器人回應）。
+            - 包含來自其他發送者的最近 2 條用戶訊息。
+        - 按時間順序排列選定的訊息。
+        - 將系統提示添加到訊息列表的開頭。
+    - 在 `get_llm_response` 中調用 `_build_context_messages` 來構建發送給 LLM API 的 `messages` 列表。
+- **`config.py`**：
+    - 新增 `ENABLE_CHAT_LOGGING` (布爾值) 和 `LOG_DIR` (字符串) 配置選項。
+- **效果**：
+    - LLM 現在可以利用最近的對話歷史來生成更符合上下文的回應。
+    - 可以選擇性地將所有成功的聊天互動記錄到按日期組織的文件中，方便日後分析或調試。
+
+### 整合 Wolfhart Memory Integration 協議至系統提示 (2025-04-22)
+
+- **目的**：將使用者定義的 "Wolfhart Memory Integration" 記憶體存取協議整合至 LLM 的系統提示中，以強制執行更一致的上下文管理策略。
+- **`llm_interaction.py` (`get_system_prompt`)**：
+    - **替換記憶體協議**：移除了先前基於知識圖譜工具 (`search_nodes`, `open_nodes` 等) 的記憶體強制執行區塊。
+    - **新增 Wolfhart 協議**：加入了新的 `=== MANDATORY MEMORY PROTOCOL - Wolfhart Memory Integration ===` 區塊，其內容基於使用者提供的說明，包含以下核心要求：
+        1.  **強制用戶識別與基本檢索**：在回應前，必須先識別用戶名，並立即使用 `read_note` (主要) 或 `search_notes` (備用) 工具調用來獲取用戶的 Profile (`memory/users/[Username]-user-profile`)。
+        2.  **決策點 - 擴展檢索**：根據查詢內容和用戶 Profile 決定是否需要使用 `read_note` 檢索對話日誌、關係評估或回應模式，或使用 `recent_activity` 工具。
+        3.  **實施指南**：強調必須先檢查 Profile，使用正確的工具，以用戶偏好語言回應，且絕不向用戶解釋此內部流程。
+        4.  **工具優先級**：明確定義了內部工具使用的優先順序：`read_note` > `search_notes` > `recent_activity`。
+- **效果**：預期 LLM 在回應前會更穩定地執行記憶體檢索步驟，特別是強制性的用戶 Profile 檢查，從而提高回應的上下文一致性和角色扮演的準確性。
+
+### 遊戲監控與定時重啟穩定性改進 (2025-04-25)
+
+- **目的**：解決 `game_monitor.py` 在執行定時重啟時，可能出現遊戲未成功關閉/重啟，且 UI 監控未恢復的問題。
+- **`game_monitor.py` (第一階段修改)**：
+    - **日誌重定向**：將所有 `logging` 輸出重定向到 `stderr`，確保 `stdout` 只用於傳輸 JSON 訊號 (`pause_ui`, `resume_ui`) 給 `main.py`，避免訊號被日誌干擾。
+    - **終止驗證**：在 `restart_game_process` 中，嘗試終止遊戲進程後，加入循環檢查（最多 10 秒），使用 `psutil.pid_exists` 確認進程確實已結束。
+    - **啟動驗證**：在 `restart_game_process` 中，嘗試啟動遊戲後，使用循環檢查（最多 90 秒），調用 `find_game_window` 確認遊戲視窗已出現，取代固定的等待時間。
+    - **立即調整嘗試**：在 `perform_scheduled_restart` 中，於成功驗證遊戲啟動後，立即嘗試調整一次視窗位置/大小/置頂。
+    - **保證恢復訊號**：在 `perform_scheduled_restart` 中，使用 `try...finally` 結構包裹遊戲重啟邏輯，確保無論重啟成功與否，都會嘗試通過 `stdout` 發送 `resume_ui` 訊號給 `main.py`。
+- **`game_monitor.py` (第二階段修改 - 簡化)**：
+    - **移除驗證與立即調整**：根據使用者回饋，移除了終止驗證、啟動驗證以及立即調整視窗的邏輯。
+    - **恢復固定等待**：重啟流程恢復使用固定的 `time.sleep()` 等待時間。
+    - **發送重啟完成訊號**：在重啟流程結束後，發送 `{'action': 'restart_complete'}` JSON 訊號給 `main.py`。
+- **`main.py`**：
+    - **轉發重啟完成訊號**：`read_monitor_output` 線程接收到 `game_monitor.py` 的 `{'action': 'restart_complete'}` 訊號後，將 `{'action': 'handle_restart_complete'}` 命令放入 `command_queue`。
+- **`ui_interaction.py`**：
+    - **內部處理重啟完成**：`run_ui_monitoring_loop` 接收到 `{'action': 'handle_restart_complete'}` 命令後，在 UI 線程內部執行：
+        1. 暫停 UI 監控。
+        2. 等待固定時間（30 秒），讓遊戲啟動並穩定。
+        3. 恢復 UI 監控並重置狀態（清除 `recent_texts` 和 `last_processed_bubble_info`）。
+- **效果**：將暫停/恢復 UI 監控的時序控制權移至 `ui_interaction.py` 內部，減少了模塊間的直接依賴和潛在干擾，依賴持續監控來確保最終視窗狀態。
+
+## 最近改進（2025-04-27）
+
+### Setup.py 功能增強
+
+- **目的**：增強 `Setup.py` 設定工具的功能，使其在保存設定後保持開啟，並提供直接啟動和終止 Chat Bot 及 Test 腳本的按鈕。
+- **修改內容**：
+    - 修改 `save_settings` 方法，移除關閉視窗的邏輯，僅顯示保存成功的提示訊息。
+    - 在 GUI 底部新增 "Run Chat Bot" 和 "Run Test" 按鈕，分別用於啟動 `main.py` 和 `test/llm_debug_script.py`。
+    - 新增 "Stop Process" 按鈕，用於終止由上述兩個按鈕啟動的腳本。
+    - 實現進程追蹤和按鈕狀態管理，確保在有腳本運行時禁用運行按鈕，啟用停止按鈕。
+- **效果**：提高了 `Setup.py` 的易用性，方便使用者在調整設定後直接啟動腳本進行測試，並提供了便捷的終止方式。
+
+### llm_debug_script.py 功能增強
+
+- **目的**：讓用戶在啟動時能夠輸入自己的名字。
+- **修改內容**：
+    - 新增了一個　`get_username()` 函數來提示用戶輸入名字
+    - 在 `debug_loop()` 函數中，刪除了固定的 `user_name = "Debugger"` 行，並替換為從 `get_username()` 函數獲取名字的調用。
+    - **新增 ChromaDB 初始化與數據預取**：
+        - 在 `debug_loop()` 開始時導入 `chroma_client` 並調用 `initialize_chroma_client()`。
+        - 在每次用戶輸入後、調用 `llm_interaction.get_llm_response` 之前，新增了調用 `chroma_client.get_entity_profile()` 和 `chroma_client.get_related_memories()` 的邏輯。
+        - 將獲取的用戶資料和相關記憶作為參數傳遞給 `get_llm_response`。
+- **效果**：修改後，腳本啟動時會提示用戶輸入自己的名字（預設為 'Debugger'）。它現在不僅會初始化 ChromaDB 連接，還會在每次互動前預先查詢用戶資料和相關記憶，並將這些資訊注入到發送給 LLM 的系統提示中，以便在測試期間更真實地模擬記憶體功能。
+
+## 最近改進（2025-05-02）
+
+### ChromaDB 客戶端初始化更新
+
+- **目的**：更新 ChromaDB 客戶端初始化方式以兼容 ChromaDB v1.0.6+ 版本，解決舊版 `chromadb.Client(Settings(...))` 方法被棄用的問題。
+- **`chroma_client.py`**：
+    - 修改了 `initialize_chroma_client` 函數。
+    - 將舊的初始化代碼：
+      ```python
+      _client = chromadb.Client(Settings(
+          chroma_db_impl="duckdb+parquet",
+          persist_directory=config.CHROMA_DATA_DIR
+      ))
+      ```
+    - 替換為新的推薦方法：
+      ```python
+      _client = chromadb.PersistentClient(path=config.CHROMA_DATA_DIR)
+      ```
+- **效果**：腳本現在使用 ChromaDB v1.0.6+ 推薦的 `PersistentClient` 來連接本地持久化數據庫，避免了啟動時的 `deprecated configuration` 錯誤。
+
+### ChromaDB 記憶體系統整合與優化
+
+- **目的**：引入基於 ChromaDB 的向量記憶體系統，以提高回應速度和上下文連貫性，並提供可配置的記憶體預載入選項。
+- **`Setup.py`**：
+    - 新增 "Memory Settings" 標籤頁，允許用戶：
+        - 啟用/禁用用戶資料預載入 (`ENABLE_PRELOAD_PROFILES`)。
+        - 設定預載入的相關記憶數量 (`PRELOAD_RELATED_MEMORIES`)。
+        - 配置 ChromaDB 集合名稱 (`PROFILES_COLLECTION`, `CONVERSATIONS_COLLECTION`, `BOT_MEMORY_COLLECTION`)。
+    - 更新 `load_current_config`, `update_ui_from_data`, `save_settings` 和 `generate_config_file` 函數以處理這些新設定。
+    - 修正了 `generate_config_file` 中寫入 ChromaDB 設定的邏輯，確保設定能正確保存到 `config.py`。
+    - 修正了 `update_ui_from_data` 中的 `NameError`。
+    - 將 "Profiles Collection" 的預設值更新為 "wolfhart_memory"，以匹配實際用法。
+- **`config_template.py`**：
+    - 添加了 ChromaDB 相關設定的佔位符。
+- **`chroma_client.py`**：
+    - 新增模塊，封裝 ChromaDB 連接和查詢邏輯。
+    - 實現 `initialize_chroma_client`, `get_collection`, `get_entity_profile`, `get_related_memories`, `get_bot_knowledge` 函數。
+    - 更新 `initialize_chroma_client` 以使用 `chromadb.PersistentClient`。
+    - 修正 `get_entity_profile` 以使用 `query` 方法（而非 `get`）和正確的集合名稱 (`config.BOT_MEMORY_COLLECTION`) 來查找用戶資料。
+- **`main.py`**：
+    - 導入 `chroma_client`。
+    - 添加 `initialize_memory_system` 函數，在啟動時根據配置初始化 ChromaDB。
+    - 在主循環中，根據 `config.ENABLE_PRELOAD_PROFILES` 和 `config.PRELOAD_RELATED_MEMORIES` 設定，在調用 LLM 前預載入用戶資料、相關記憶和機器人知識。
+    - 將預載入的數據傳遞給 `llm_interaction.get_llm_response`。
+- **`llm_interaction.py`**：
+    - 更新 `get_llm_response` 和 `get_system_prompt` 函數簽名以接收預載入的記憶體數據。
+    - 修改 `get_system_prompt` 以：
+        - 在提示中包含預載入的用戶資料、相關記憶和機器人知識（如果可用）。
+        - 根據是否有預載入數據，動態調整記憶體檢索協議的說明（優化版 vs. 完整版）。
+        - 修正了在禁用預載入時，基本用戶檢索範例中使用的集合名稱，使其與 `chroma_client.py` 一致 (`config.BOT_MEMORY_COLLECTION`)。
+- **效果**：實現了可配置的記憶體預載入功能，預期能提高回應速度和質量。統一了各模塊中關於集合名稱和查詢邏輯的處理。
+
+### MCP 伺服器子進程管理與 Windows 安全終止 (修正)
+
+- **目的**：確保由 `main.py` 啟動的 MCP 伺服器（根據 `config.py` 配置）能夠在主腳本退出時（無論正常或異常）被可靠地終止，特別是在 Windows 環境下。
+- **`main.py`**：
+    - **恢復啟動方式**：`connect_and_discover` 函數恢復使用 `mcp.client.stdio.stdio_client` 來啟動伺服器並建立連接。這解決了先前手動管理子進程導致的 `AttributeError: 'StreamWriter' object has no attribute 'send'` 問題。
+    - **依賴 `stdio_client` 進行終止**：不再手動管理伺服器子進程的 `Process` 對象。現在依賴 `stdio_client` 的異步上下文管理器 (`__aexit__` 方法) 在 `AsyncExitStack` 關閉時（於 `shutdown` 函數中調用 `exit_stack.aclose()` 時觸發）來處理其啟動的子進程的終止。
+    - **保留 Windows 事件處理器**：
+        - 仍然保留了 `windows_ctrl_handler` 函數和使用 `win32api.SetConsoleCtrlHandler` 註冊它的邏輯（如果 `pywin32` 可用）。
+        - **注意**：此處理程序現在**不直接**終止 MCP 伺服器進程（因為 `mcp_server_processes` 字典不再被填充）。它的主要作用是確保在 Windows 上的各種退出事件（如關閉控制台窗口）能觸發 Python 的正常關閉流程，進而執行 `finally` 塊中的 `shutdown()` 函數，最終調用 `exit_stack.aclose()` 來讓 `stdio_client` 清理其子進程。
+        - `terminate_all_mcp_servers` 函數雖然保留，但因 `mcp_server_processes` 為空而不會執行實際的終止操作。
+    - **移除冗餘終止調用**：從 `shutdown` 函數中移除了對 `terminate_all_mcp_servers` 的直接調用，因為終止邏輯現在由 `exit_stack.aclose()` 間接觸發。
+- **依賴項**：Windows 上的控制台事件處理仍然依賴 `pywin32` 套件。如果未安裝，程式會打印警告，關閉時的可靠性可能略有降低（但 `stdio_client` 的正常清理機制應在多數情況下仍然有效）。
+- **效果**：恢復了與 `mcp` 庫的兼容性，同時通過標準的上下文管理和輔助性的 Windows 事件處理，實現了在主程式退出時關閉 MCP 伺服器子進程的目標。
+
+## 最近改進（2025-05-12）
+
+### 遊戲視窗置頂邏輯修改
+
+- **目的**：將 `game_monitor.py` 中強制遊戲視窗「永遠在最上層」(Always on Top) 的行為，修改為「臨時置頂並獲得焦點」(Bring to Foreground/Activate)，以解決原方法僅覆蓋其他視窗的問題。
+- **`game_monitor.py`**：
+    - 在 `monitor_game_window` 函數的監控循環中，移除了使用 `win32gui.SetWindowPos` 和 `win32con.HWND_TOPMOST` 來檢查和設定 `WS_EX_TOPMOST` 樣式的程式碼。
+    - 替換為檢查當前前景視窗 (`win32gui.GetForegroundWindow()`) 是否為目標遊戲視窗 (`hwnd`)。
+    - 如果不是，則嘗試以下步驟將視窗帶到前景並獲得焦點：
+        1.  使用 `win32gui.SetWindowPos` 搭配 `win32con.HWND_TOP` 旗標，將視窗提升到所有非最上層視窗之上。
+        2.  呼叫 `win32gui.SetForegroundWindow(hwnd)` 嘗試將視窗設為前景並獲得焦點。
+        3.  短暫延遲後，檢查視窗是否成功成為前景視窗。
+        4.  如果 `SetForegroundWindow` 未成功，則嘗試使用 `pygetwindow` 庫提供的 `window.activate()` 方法作為備用方案。
+    - 更新了相關的日誌訊息以反映新的行為和備用邏輯。
+- **效果**：監控腳本現在會使用更全面的方法嘗試將失去焦點的遊戲視窗重新激活並帶到前景，包括備用方案，以提高在不同 Windows 環境下獲取焦點的成功率。這取代了之前僅強制視覺覆蓋的行為。
+
 ## 開發建議
 
 ### 優化方向
@@ -191,6 +639,43 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
    - 添加主題識別與記憶功能
    - 探索多輪對話中的上下文理解能力
 
+## 最近改進（2025-05-13）
+
+### 遊戲監控模組重構
+
+- **目的**：將遊戲監控功能從獨立的 `game_monitor.py` 腳本重構為一個更健壯、更易於管理的 `game_manager.py` 模組，並由 `Setup.py` 統一控制其生命週期和配置。
+- **`game_manager.py` (新模組)**：
+    - 創建了 `GameMonitor` 類，封裝了所有遊戲視窗監控、自動重啟和進程管理邏輯。
+    - 提供了 `create_game_monitor` 工廠函數。
+    - 支持通過構造函數和 `update_config` 方法進行配置。
+    - 使用回調函數 (`callback`) 與調用者（即 `Setup.py`）通信，例如在遊戲重啟完成時。
+    - 保留了獨立運行模式，以便在直接執行時仍能工作（主要用於測試或舊版兼容）。
+    - 程式碼註解和日誌訊息已更新為英文。
+    - **新增遊戲崩潰自動恢復 (2025-05-15)**：
+        - 在 `_monitor_loop` 方法中，優先檢查遊戲進程 (`_is_game_running`) 是否仍在運行。
+        - 如果進程消失，會記錄警告並嘗試重新啟動遊戲 (`_start_game_process`)。
+        - 新增 `_is_game_running` 方法，使用 `psutil` 檢查具有指定進程名稱的遊戲是否正在運行。
+- **`Setup.py` (修改)**：
+    - 導入 `game_manager`。
+    - 在 `WolfChatSetup` 類的 `__init__` 方法中初始化 `self.game_monitor = None`。
+    - 在 `start_managed_session` 方法中：
+        - 創建 `game_monitor_callback` 函數以處理來自 `GameMonitor` 的動作（特別是 `restart_complete`）。
+        - 使用 `game_manager.create_game_monitor` 創建 `GameMonitor` 實例。
+        - 啟動 `GameMonitor`。
+    - 新增 `_handle_game_restart_complete` 方法，用於在收到 `GameMonitor` 的重啟完成回調後，處理機器人的重啟。
+    - 在 `stop_managed_session` 方法中，調用 `self.game_monitor.stop()` 並釋放實例。
+    - 修改 `_restart_game_managed` 方法，使其在 `self.game_monitor` 存在且運行時，調用 `self.game_monitor.restart_now()` 來執行遊戲重啟。
+    - 在 `save_settings` 方法中，如果 `self.game_monitor` 實例存在，則調用其 `update_config` 方法以更新運行時配置。
+- **`main.py` (修改)**：
+    - 移除了所有對舊 `game_monitor.py` 的導入、子進程啟動、訊號讀取和生命週期管理相關的程式碼。遊戲監控現在完全由 `Setup.py` 在受管會話模式下處理。
+- **舊檔案刪除**：
+    - 刪除了原來的 `game_monitor.py` 文件。
+- **效果**：
+    - 遊戲監控邏輯更加內聚和模塊化。
+    - `Setup.py` 現在完全控制遊戲監控的啟動、停止和配置，簡化了 `main.py` 的職責。
+    - 通過回調機制實現了更清晰的模塊間通信。
+    - 提高了程式碼的可維護性和可擴展性。
+
 ### 注意事項
 
 1. **圖像模板**：確保所有必要的 UI 元素模板都已截圖並放置在 templates 目錄
@@ -217,6 +702,14 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 
 ## 使用指南
 
+### 快捷鍵 (新增)
+
+- **F7**: 清除最近已處理的對話紀錄 (`recent_texts` in `ui_interaction.py`)。這有助於在需要時強制重新處理最近的訊息。
+- **F8**: 暫停/恢復腳本的主要功能（UI 監控、LLM 互動）。
+    - **暫停時**: UI 監控線程會停止偵測新的聊天氣泡，主循環會暫停處理新的觸發事件。
+    - **恢復時**: UI 監控線程會恢復偵測，並且會清除最近的對話紀錄 (`recent_texts`) 和最後處理的氣泡資訊 (`last_processed_bubble_info`)，以確保從乾淨的狀態開始。
+- **F9**: 觸發腳本的正常關閉流程，包括關閉 MCP 連接和停止監控線程。
+
 ### 啟動流程
 
 1. 確保遊戲已啟動且聊天介面可見
@@ -239,3 +732,89 @@ Wolf Chat 是一個基於 MCP (Modular Capability Provider) 框架的聊天機
 3. **LLM 連接問題**: 驗證 API 密鑰和網絡連接
 4. **MCP 服務器連接失敗**: 確認服務器配置正確並且運行中
 5. **工具調用後無回應**: 檢查 llm_debug.log 文件，查看工具調用結果和解析過程
+
+## 最近改進（2025-05-02）
+
+### MCP 伺服器子進程管理與 Windows 安全終止 (修正)
+
+- **目的**：確保由 `main.py` 啟動的 MCP 伺服器（根據 `config.py` 配置）能夠在主腳本退出時（無論正常或異常）被可靠地終止，特別是在 Windows 環境下。
+- **`main.py`**：
+    - **恢復啟動方式**：`connect_and_discover` 函數恢復使用 `mcp.client.stdio.stdio_client` 來啟動伺服器並建立連接。這解決了先前手動管理子進程導致的 `AttributeError: 'StreamWriter' object has no attribute 'send'` 問題。
+    - **依賴 `stdio_client` 進行終止**：不再手動管理伺服器子進程的 `Process` 對象。現在依賴 `stdio_client` 的異步上下文管理器 (`__aexit__` 方法) 在 `AsyncExitStack` 關閉時（於 `shutdown` 函數中調用 `exit_stack.aclose()` 時觸發）來處理其啟動的子進程的終止。
+    - **保留 Windows 事件處理器**：
+        - 仍然保留了 `windows_ctrl_handler` 函數和使用 `win32api.SetConsoleCtrlHandler` 註冊它的邏輯（如果 `pywin32` 可用）。
+        - **注意**：此處理程序現在**不直接**終止 MCP 伺服器進程（因為 `mcp_server_processes` 字典不再被填充）。它的主要作用是確保在 Windows 上的各種退出事件（如關閉控制台窗口）能觸發 Python 的正常關閉流程，進而執行 `finally` 塊中的 `shutdown()` 函數，最終調用 `exit_stack.aclose()` 來讓 `stdio_client` 清理其子進程。
+        - `terminate_all_mcp_servers` 函數雖然保留，但因 `mcp_server_processes` 為空而不會執行實際的終止操作。
+    - **移除冗餘終止調用**：從 `shutdown` 函數中移除了對 `terminate_all_mcp_servers` 的直接調用，因為終止邏輯現在由 `exit_stack.aclose()` 間接觸發。
+- **依賴項**：Windows 上的控制台事件處理仍然依賴 `pywin32` 套件。如果未安裝，程式會打印警告，關閉時的可靠性可能略有降低（但 `stdio_client` 的正常清理機制應在多數情況下仍然有效）。
+- **效果**：恢復了與 `mcp` 庫的兼容性，同時通過標準的上下文管理和輔助性的 Windows 事件處理，實現了在主程式退出時關閉 MCP 伺服器子進程的目標。
+
+</final_file_content>
+
+IMPORTANT: For any future changes to this file, use the final_file_content shown above as your reference. This content reflects the current state of the file, including any auto-formatting (e.g., if you used single quotes but the formatter converted them to double quotes). Always base your SEARCH/REPLACE operations on this final version to ensure accuracy.<environment_details>
+# VSCode Visible Files
+ui_interaction.py
+ui_interaction.py
+ClaudeCode.md
+
+# VSCode Open Tabs
+config_template.py
+test/llm_debug_script.py
+chroma_client.py
+main.py
+ClaudeCode.md
+Setup.py
+llm_interaction.py
+
+# Recently Modified Files
+These files have been modified since you last accessed them (file was just edited so you may need to re-read it before editing):
+ClaudeCode.md
+
+# Current Time
+5/2/2025, 11:11:05 AM (Asia/Taipei, UTC+8:00)
+
+# Context Window Usage
+796,173 / 1,000K tokens used (80%)
+
+# Current Mode
+ACT MODE
+</environment_details>
+
+</file_content>
+
+Now that you have the latest state of the file, try the operation again with fewer, more precise SEARCH blocks. For large files especially, it may be prudent to try to limit yourself to <5 SEARCH/REPLACE blocks at a time, then wait for the user to respond with the result of the operation before following up with another replace_in_file call to make additional edits.
+(If you run into this error 3 times in a row, you may use the write_to_file tool as a fallback.)
+</error><environment_details>
+# VSCode Visible Files
+ClaudeCode.md
+
+# VSCode Open Tabs
+config_template.py
+test/llm_debug_script.py
+llm_interaction.py
+wolf_control.py
+.gitignore
+chroma_client.py
+batch_memory_record.py
+memory_manager.py
+game_monitor.py
+game_manager.py
+Setup.py
+main.py
+ClaudeCode.md
+reembedding tool.py
+config.py
+memory_backup.py
+tools/chroma_view.py
+ui_interaction.py
+remote_config.json
+
+# Current Time
+5/13/2025, 3:31:34 AM (Asia/Taipei, UTC+8:00)
+
+# Context Window Usage
+429,724 / 1,048.576K tokens used (41%)
+
+# Current Mode
+ACT MODE
+</environment_details>

README.md

@@ -1,63 +1,57 @@
-# Wolf Chat Bot
+# Wolf Chat - Last War Game Automated Chat Assistant
 
-A specialized chat assistant that integrates with the "Last War-Survival Game" by monitoring the game's chat window using screen recognition technology.
+## Project Overview
 
-## Overview
+Wolf Chat is a chatbot assistant designed specifically for integration with "Last War-Survival Game," using screen recognition technology to monitor the game's chat window and automatically respond to messages containing keywords.
 
-This project implements an AI assistant that:
-- Monitors the game chat window using computer vision
-- Detects messages containing keywords ("wolf" or "Wolf")
-- Processes requests through a language model
-- Automatically responds in the game chat
+This bot will:
+- Automatically monitor the game chat window
+- Detect chat messages containing the keywords "wolf" or "Wolf"
+- Generate responses using a language model
+- Automatically input responses into the game chat interface
 
-The code is developed in English, but supports Traditional Chinese interface and logs for broader accessibility.
+## Main Features
 
-## Features
+- **Language Model Integration**: Supports OpenAI API or compatible AI services for intelligent response generation
+- **MCP Framework**: Modular Capability Provider architecture supporting extended functionality and tool calls
+- **Persona System**: Provides detailed character definition for personality-driven responses
+- **Chat Logging**: Automatically saves conversation history for contextual understanding
 
-- **Image-based Chat Monitoring**: Uses OpenCV and PyAutoGUI to detect chat bubbles and keywords
-- **Language Model Integration**: Uses GPT models or compatible AI services
-- **MCP Framework**: Integrates with Modular Capability Provider for extensible features
-- **Persona System**: Supports detailed character persona definition
-- **Automated UI Interaction**: Handles copy/paste operations and menu navigation
-
-## Requirements
+## System Requirements
 
 - Python 3.8+
 - OpenAI API key or compatible service
-- MCP Framework
 - Game client ("Last War-Survival Game")
 - OpenCV, PyAutoGUI, and other dependencies (see requirements.txt)
 
-## Installation
+## Installation Guide
 
-1. Clone this repository:
-   ```
-   git clone [repository-url]
-   cd dandan
-   ```
+1. **Download Method**:
+   - Download the ZIP file directly from GitHub (click the green "Code" button, select "Download ZIP")
+   - Extract to a folder of your choice
 
-2. Install required packages:
+2. **Install Dependencies**:
    ```
    pip install -r requirements.txt
    ```
 
-3. Create a `.env` file with your API keys:
+3. **Create a `.env` file** with your API keys:
    ```
    OPENAI_API_KEY=your_api_key_here
    EXA_API_KEY=your_exa_key_here
    ```
 
-4. Capture required UI template images (see "UI Setup" section)
+4. **Capture necessary UI template images** (see "UI Setup" section below)
 
-## Configuration
+## Configuration Settings
 
-1. **API Settings**: Edit `config.py` to set up your preferred language model provider:
+1. **API Settings**: Edit `config.py` to set your preferred language model provider:
    ```python
    OPENAI_API_BASE_URL = "https://openrouter.ai/api/v1" # Or other compatible provider
    LLM_MODEL = "deepseek/deepseek-chat-v3-0324" # Or other model
    ```
 
-2. **MCP Servers**: Configure MCP servers in `config.py`:
+2. **MCP Servers**: Configure MCP servers in `config.py` (if using this feature):
    ```python
    MCP_SERVERS = {
        "exa": { "command": "cmd", "args": [...] },
@@ -70,26 +64,32 @@ The code is developed in English, but supports Traditional Chinese interface and
    WINDOW_TITLE = "Last War-Survival Game"
    ```
 
-4. **Chat Persona**: Customize `persona.json` to define the bot's personality
+4. **Chat Persona**: Customize `persona.json` to define the bot's personality traits
 
 ## UI Setup
 
 The system requires template images of UI elements to function properly:
 
-1. Run the window setup script to position your game window:
+1. **Run the window setup script** to position your game window:
    ```
    python window-setup-script.py --launch
    ```
 
-2. Capture the following UI elements and save them to the `templates` folder:
+2. **Capture the following UI elements** and save them to the `templates` folder:
    - Chat bubble corners (regular and bot)
    - Keywords "wolf" and "Wolf"
    - Menu elements like "Copy" button
    - Profile and user detail page elements
+   - **Capitol icon in the Profile page** (critical!)
 
    Screenshot names should match the constants defined in `ui_interaction.py`.
 
-## Usage
+3. **Window Monitor Tool**: Use the following command to start window monitoring, ensuring the game window stays on top:
+   ```
+   python window-monitor-script.py
+   ```
+
+## Usage Instructions
 
 1. Start the game client
 
@@ -100,25 +100,21 @@ The system requires template images of UI elements to function properly:
 
 3. The bot will start monitoring the chat for messages containing "wolf" or "Wolf"
 
-4. When detected, it will:
+4. When a keyword is detected, it will:
    - Copy the message content
    - Get the sender's name
    - Process the request using the language model
-   - Automatically send a response in chat
+   - Automatically send a response in the chat
 
-## How It Works
+## Hotkeys
 
-1. **Monitoring**: The UI thread continuously scans the screen for chat bubbles
-2. **Detection**: When a bubble with "wolf" keyword is found, the message is extracted
-3. **Processing**: The message is sent to the language model with the persona context
-4. **Response**: The AI generates a response based on the persona
-5. **Interaction**: The system automatically inputs the response in the game chat
+- **F7**: Clear recently processed conversation history
+- **F8**: Pause/resume the script's main functions (UI monitoring, LLM interaction)
+- **F9**: Trigger the script's normal shutdown process
 
 ## Developer Tools
 
-- **Window Setup Script**: Helps position the game window for UI template capture
-- **UI Interaction Debugging**: Can be tested independently by running `ui_interaction.py`
-- **Persona Customization**: Edit `persona.json` to change the bot's character
+- **LLM Debug Script** (`test/llm_debug_script.py`): Bypasses the UI interaction layer to directly interact with the language model for debugging, useful for testing prompts and MCP tool calls
 
 ## Troubleshooting
 
@@ -126,4 +122,4 @@ The system requires template images of UI elements to function properly:
 - **MCP Connection Errors**: Check server configurations in `config.py`
 - **API Errors**: Verify your API keys in the `.env` file
 - **UI Automation Failures**: Update template images to match your client's appearance
-
+- **Window Position Issues**: Ensure the game window stays in the correct position, use `window-monitor-script.py`

batch_memory_record.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Wolf Chat 批次記憶備份工具
+
+自動掃描chat_logs資料夾，針對所有日誌檔案執行記憶備份
+"""
+
+import os
+import re
+import sys
+import time
+import argparse
+import subprocess
+import logging
+from datetime import datetime
+from typing import List, Optional, Tuple
+
+# 設置日誌
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("batch_backup.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("BatchMemoryBackup")
+
+def find_log_files(log_dir: str = "chat_logs") -> List[Tuple[str, str]]:
+    """
+    掃描指定目錄，找出所有符合YYYY-MM-DD.log格式的日誌文件
+    
+    返回: [(日期字符串, 文件路徑), ...]，按日期排序
+    """
+    date_pattern = re.compile(r'^(\d{4}-\d{2}-\d{2})\.log$')
+    log_files = []
+    
+    # 確保目錄存在
+    if not os.path.exists(log_dir) or not os.path.isdir(log_dir):
+        logger.error(f"目錄不存在或不是有效目錄: {log_dir}")
+        return []
+    
+    # 掃描目錄
+    for filename in os.listdir(log_dir):
+        match = date_pattern.match(filename)
+        if match:
+            date_str = match.group(1)
+            file_path = os.path.join(log_dir, filename)
+            try:
+                # 驗證日期格式
+                datetime.strptime(date_str, "%Y-%m-%d")
+                log_files.append((date_str, file_path))
+            except ValueError:
+                logger.warning(f"發現無效的日期格式: {filename}")
+    
+    # 按日期排序
+    log_files.sort(key=lambda x: x[0])
+    return log_files
+
+def process_log_file(date_str: str, backup_script: str = "memory_backup.py") -> bool:
+    """
+    為指定日期的日誌文件執行記憶備份
+    
+    Parameters:
+        date_str: 日期字符串，格式為YYYY-MM-DD
+        backup_script: 備份腳本路徑
+    
+    Returns:
+        bool: 操作是否成功
+    """
+    logger.info(f"開始處理日期 {date_str} 的日誌")
+    
+    try:
+        # 構建命令
+        cmd = [sys.executable, backup_script, "--backup", "--date", date_str]
+        
+        # 執行命令
+        logger.info(f"執行命令: {' '.join(cmd)}")
+        process = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=False  # 不要在命令失敗時拋出異常
+        )
+        
+        # 檢查結果
+        if process.returncode == 0:
+            logger.info(f"日期 {date_str} 的處理完成")
+            return True
+        else:
+            logger.error(f"處理日期 {date_str} 失敗: {process.stderr}")
+            return False
+    
+    except Exception as e:
+        logger.error(f"處理日期 {date_str} 時發生異常: {str(e)}")
+        return False
+
+def batch_process(log_dir: str = "chat_logs", backup_script: str = "memory_backup.py", 
+                 date_range: Optional[Tuple[str, str]] = None, 
+                 wait_seconds: int = 5) -> Tuple[int, int]:
+    """
+    批次處理多個日誌文件
+    
+    Parameters:
+        log_dir: 日誌目錄路徑
+        backup_script: 備份腳本路徑
+        date_range: (開始日期, 結束日期)，用於限制處理範圍，格式為YYYY-MM-DD
+        wait_seconds: 每個文件處理後的等待時間（秒）
+    
+    Returns:
+        (成功數量, 總數量)
+    """
+    log_files = find_log_files(log_dir)
+    
+    if not log_files:
+        logger.warning(f"在 {log_dir} 中未找到有效的日誌文件")
+        return (0, 0)
+    
+    logger.info(f"找到 {len(log_files)} 個日誌文件")
+    
+    # 如果指定了日期範圍，過濾文件
+    if date_range:
+        start_date, end_date = date_range
+        filtered_files = [(date_str, path) for date_str, path in log_files 
+                         if start_date <= date_str <= end_date]
+        logger.info(f"根據日期範圍 {start_date} 到 {end_date} 過濾後剩餘 {len(filtered_files)} 個文件")
+        log_files = filtered_files
+    
+    success_count = 0
+    total_count = len(log_files)
+    
+    for i, (date_str, file_path) in enumerate(log_files):
+        logger.info(f"處理進度: {i+1}/{total_count} - 日期: {date_str}")
+        
+        if process_log_file(date_str, backup_script):
+            success_count += 1
+        
+        # 若不是最後一個文件，等待一段時間再處理下一個
+        if i < total_count - 1:
+            logger.info(f"等待 {wait_seconds} 秒後處理下一個文件...")
+            time.sleep(wait_seconds)
+    
+    return (success_count, total_count)
+
+def parse_date_arg(date_arg: str) -> Optional[str]:
+    """解析日期參數，確保格式為YYYY-MM-DD"""
+    if not date_arg:
+        return None
+    
+    try:
+        parsed_date = datetime.strptime(date_arg, "%Y-%m-%d")
+        return parsed_date.strftime("%Y-%m-%d")
+    except ValueError:
+        logger.error(f"無效的日期格式: {date_arg}，請使用YYYY-MM-DD格式")
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(description='Wolf Chat 批次記憶備份工具')
+    parser.add_argument('--log-dir', default='chat_logs', help='日誌檔案目錄，預設為 chat_logs')
+    parser.add_argument('--script', default='memory_backup.py', help='記憶備份腳本路徑，預設為 memory_backup.py')
+    parser.add_argument('--start-date', help='開始日期（含），格式為 YYYY-MM-DD')
+    parser.add_argument('--end-date', help='結束日期（含），格式為 YYYY-MM-DD')
+    parser.add_argument('--wait', type=int, default=5, help='每個檔案處理間隔時間（秒），預設為 5 秒')
+    
+    args = parser.parse_args()
+    
+    # 驗證日期參數
+    start_date = parse_date_arg(args.start_date)
+    end_date = parse_date_arg(args.end_date)
+    
+    # 如果只有一個日期參數，將兩個都設為該日期（僅處理該日期）
+    if start_date and not end_date:
+        end_date = start_date
+    elif end_date and not start_date:
+        start_date = end_date
+    
+    date_range = (start_date, end_date) if start_date and end_date else None
+    
+    logger.info("開始批次記憶備份流程")
+    logger.info(f"日誌目錄: {args.log_dir}")
+    logger.info(f"備份腳本: {args.script}")
+    if date_range:
+        logger.info(f"日期範圍: {date_range[0]} 到 {date_range[1]}")
+    else:
+        logger.info("處理所有找到的日誌檔案")
+    logger.info(f"等待間隔: {args.wait} 秒")
+    
+    start_time = time.time()
+    success, total = batch_process(
+        log_dir=args.log_dir,
+        backup_script=args.script,
+        date_range=date_range,
+        wait_seconds=args.wait
+    )
+    end_time = time.time()
+    
+    duration = end_time - start_time
+    logger.info(f"批次處理完成。成功: {success}/{total}，耗時: {duration:.2f} 秒")
+    
+    if success < total:
+        logger.warning("部分日誌檔案處理失敗，請查看日誌瞭解詳情")
+        return 1
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

bubble_colors.json

@@ -0,0 +1,60 @@
+{
+  "bubble_types": [
+    {
+      "name": "normal_user",
+      "is_bot": false,
+      "hsv_lower": [6, 0, 240],
+      "hsv_upper": [18, 23, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "bot",
+      "is_bot": true,
+      "hsv_lower": [105, 9, 208],
+      "hsv_upper": [116, 43, 243],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "bunny",
+      "is_bot": false,
+      "hsv_lower": [18, 32, 239],
+      "hsv_upper": [29, 99, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "ice",
+      "is_bot": false,
+      "hsv_lower": [91, 86, 233],
+      "hsv_upper": [127, 188, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "new_year",
+      "is_bot": false,
+      "hsv_lower": [0, 157, 201],
+      "hsv_upper": [9, 197, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "snow",
+      "is_bot": false,
+      "hsv_lower": [92, 95, 177],
+      "hsv_upper": [107, 255, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    },
+    {
+      "name": "easter",
+      "is_bot": false,
+      "hsv_lower": [5, 154, 183],
+      "hsv_upper": [29, 255, 255],
+      "min_area": 2500,
+      "max_area": 300000
+    }
+  ]
+}

chroma_client.py

@@ -0,0 +1,204 @@
+# chroma_client.py
+import chromadb
+from chromadb.config import Settings
+from chromadb.utils import embedding_functions # New import
+import os
+import json
+import config
+import time
+
+# Global client variables
+_client = None
+_collections = {}
+
+# Global embedding function variable
+_embedding_function = None
+
+def get_embedding_function():
+    """Gets or creates the embedding function based on config"""
+    global _embedding_function
+    if _embedding_function is None:
+        # Default to paraphrase-multilingual-mpnet-base-v2 if not specified or on error
+        model_name = getattr(config, 'EMBEDDING_MODEL_NAME', "sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
+        try:
+            _embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name=model_name)
+            print(f"Successfully initialized embedding function with model: {model_name}")
+        except Exception as e:
+            print(f"Failed to initialize embedding function with model '{model_name}': {e}")
+            # Fallback to default if specified model fails and it's not already the default
+            if model_name != "sentence-transformers/paraphrase-multilingual-mpnet-base-v2":
+                print("Falling back to default embedding model: sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
+                try:
+                    _embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
+                    print(f"Successfully initialized embedding function with default model.")
+                except Exception as e_default:
+                    print(f"Failed to initialize default embedding function: {e_default}")
+                    _embedding_function = None # Ensure it's None if all attempts fail
+            else:
+                _embedding_function = None # Ensure it's None if default model also fails
+    return _embedding_function
+
+def initialize_chroma_client():
+    """Initializes and connects to ChromaDB"""
+    global _client
+    try:
+        # Ensure Chroma directory exists
+        os.makedirs(config.CHROMA_DATA_DIR, exist_ok=True)
+
+        # New method (for v1.0.6+)
+        _client = chromadb.PersistentClient(path=config.CHROMA_DATA_DIR)
+        print(f"Successfully connected to ChromaDB ({config.CHROMA_DATA_DIR})")
+        return True
+    except Exception as e:
+        print(f"Failed to connect to ChromaDB: {e}")
+        return False
+
+def get_collection(collection_name):
+    """Gets or creates a collection"""
+    global _client, _collections
+    if not _client:
+        if not initialize_chroma_client():
+            return None
+
+    if collection_name not in _collections:
+        try:
+            emb_func = get_embedding_function()
+            if emb_func is None:
+                print(f"Failed to get or create collection '{collection_name}' due to embedding function initialization failure.")
+                return None
+
+            _collections[collection_name] = _client.get_or_create_collection(
+                name=collection_name,
+                embedding_function=emb_func
+            )
+            print(f"Successfully got or created collection '{collection_name}' using configured embedding function.")
+        except Exception as e:
+            print(f"Failed to get collection '{collection_name}' with configured embedding function: {e}")
+            # Attempt to create collection with default embedding function as a fallback
+            print(f"Attempting to create collection '{collection_name}' with default embedding function...")
+            try:
+                # Ensure we try the absolute default if the configured one (even if it was the default) failed
+                default_emb_func = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
+                _collections[collection_name] = _client.get_or_create_collection(
+                    name=collection_name,
+                    embedding_function=default_emb_func
+                )
+                print(f"Successfully got or created collection '{collection_name}' with default embedding function after initial failure.")
+            except Exception as e_default:
+                print(f"Failed to get collection '{collection_name}' even with default embedding function: {e_default}")
+                return None
+
+    return _collections[collection_name]
+
+def get_entity_profile(entity_name, collection_name=None):
+    """
+    Retrieves entity data (e.g., user profile) from the specified collection
+
+    Args:
+        entity_name: The name of the entity to retrieve (e.g., username)
+        collection_name: The name of the collection; if None, uses BOT_MEMORY_COLLECTION from config (Correction: Use bot memory collection)
+    """
+    if not collection_name:
+        # Correction: Default to using BOT_MEMORY_COLLECTION to store user data
+        collection_name = config.BOT_MEMORY_COLLECTION
+
+    profile_collection = get_collection(collection_name)
+    if not profile_collection:
+        return None
+
+    try:
+        # Restore: Use query method for similarity search instead of exact ID matching
+        query_text = f"{entity_name} profile"
+        start_time = time.time()
+        results = profile_collection.query(
+            query_texts=[query_text],
+            n_results=1 # Only get the most relevant result
+        )
+        duration = time.time() - start_time
+
+        # Restore: Check the return result of the query method
+        if results and results.get('documents') and results['documents'][0]:
+            # query returns a list of lists, so [0][0] is needed
+            print(f"Successfully retrieved data for '{entity_name}' (Query: '{query_text}') (Time taken: {duration:.3f}s)")
+            return results['documents'][0][0]
+        else:
+            print(f"Could not find data for '{entity_name}' (Query: '{query_text}')")
+            return None
+    except Exception as e:
+        print(f"Error querying entity data (Query: '{query_text}'): {e}")
+        return None
+
+def get_related_memories(entity_name, topic=None, limit=3, collection_name=None):
+    """
+    Retrieves memories related to an entity
+
+    Args:
+        entity_name: The name of the entity (e.g., username)
+        topic: Optional topic keyword
+        limit: Maximum number of memories to return
+        collection_name: The name of the collection; if None, uses CONVERSATIONS_COLLECTION from config
+    """
+    if not collection_name:
+        collection_name = config.CONVERSATIONS_COLLECTION
+
+    memory_collection = get_collection(collection_name)
+    if not memory_collection:
+        return []
+
+    query = f"{entity_name}"
+    if topic:
+        query += f" {topic}"
+
+    try:
+        start_time = time.time()
+        results = memory_collection.query(
+            query_texts=[query],
+            n_results=limit
+        )
+        duration = time.time() - start_time
+
+        if results and results['documents'] and results['documents'][0]:
+            memory_count = len(results['documents'][0])
+            print(f"Successfully retrieved {memory_count} related memories for '{entity_name}' (Time taken: {duration:.3f}s)")
+            return results['documents'][0]
+
+        print(f"Could not find related memories for '{entity_name}'")
+        return []
+    except Exception as e:
+        print(f"Error querying related memories: {e}")
+        return []
+
+def get_bot_knowledge(concept, limit=3, collection_name=None):
+    """
+    Retrieves the bot's knowledge about a specific concept
+
+    Args:
+        concept: The concept to query
+        limit: Maximum number of knowledge entries to return
+        collection_name: The name of the collection; if None, uses BOT_MEMORY_COLLECTION from config
+    """
+    if not collection_name:
+        collection_name = config.BOT_MEMORY_COLLECTION
+
+    knowledge_collection = get_collection(collection_name)
+    if not knowledge_collection:
+        return []
+
+    try:
+        start_time = time.time()
+        results = knowledge_collection.query(
+            query_texts=[concept],
+            n_results=limit
+        )
+        duration = time.time() - start_time
+
+        if results and results['documents'] and results['documents'][0]:
+            knowledge_count = len(results['documents'][0])
+            print(f"Successfully retrieved {knowledge_count} bot knowledge entries about '{concept}' (Time taken: {duration:.3f}s)")
+            return results['documents'][0]
+
+        print(f"Could not find bot knowledge about '{concept}'")
+        return []
+    except Exception as e:
+        print(f"Error querying bot knowledge: {e}")
+        return []

config.py

@@ -1,75 +0,0 @@
-# config.py
-import os
-import json # Import json for building args string
-from dotenv import load_dotenv # Import load_dotenv
-
-# --- Load environment variables from .env file ---
-load_dotenv()
-print("Attempted to load environment variables from .env file.")
-# --- End Load ---
-
-# OpenAI API Configuration / OpenAI-Compatible Provider Settings
-# --- Modify these lines ---
-# Leave OPENAI_API_BASE_URL as None or "" to use official OpenAI
-OPENAI_API_BASE_URL = "https://openrouter.ai/api/v1"  # <--- For example "http://localhost:1234/v1" or your provider URL
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-#LLM_MODEL = "anthropic/claude-3.7-sonnet"
-#LLM_MODEL = "meta-llama/llama-4-maverick"
-LLM_MODEL = "deepseek/deepseek-chat-v3-0324"      # <--- Ensure this matches the model name provided by your provider
-
-EXA_API_KEY = os.getenv("EXA_API_KEY")
-
-# --- Dynamically build Exa server args ---
-exa_config_dict = {"exaApiKey": EXA_API_KEY if EXA_API_KEY else "YOUR_EXA_KEY_MISSING"}
-# Need to dump dict to JSON string, then properly escape it for cmd arg
-# Using json.dumps handles internal quotes correctly.
-# The outer quotes for cmd might need careful handling depending on OS / shell.
-# For cmd /c on Windows, embedding escaped JSON often works like this:
-exa_config_arg_string = json.dumps(json.dumps(exa_config_dict)) # Double dump for cmd escaping? Or just one? Test needed.
-# Let's try single dump first, often sufficient if passed correctly by subprocess
-exa_config_arg_string_single_dump = json.dumps(exa_config_dict)
-
-# --- MCP Server Configuration ---
-MCP_SERVERS = {
-    "exa": {
-        "command": "cmd",
-        "args": [
-            "/c",
-            "npx",
-            "-y",
-            "@smithery/cli@latest",
-            "run",
-            "exa",
-            "--config",
-            # Pass the dynamically created config string with the environment variable key
-            exa_config_arg_string # Use the properly escaped variable
-        ],
-    },
-    "servers": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@smithery/cli@latest",
-        "run",
-        "@jlia0/servers",
-        "--key",
-        "09025967-c177-4653-9af4-40603a1cbd11"
-      ]
-    }
-    # Add or remove servers as needed
-}
-
-# MCP Client Configuration
-MCP_CONFIRM_TOOL_EXECUTION = False # True: Confirm before execution, False: Execute automatically
-
-# Persona Configuration
-PERSONA_NAME = "Wolfhart"
-# PERSONA_RESOURCE_URI = "persona://wolfhart/details" # Now using local file instead
-
-# Game window title (used in ui_interaction.py)
-WINDOW_TITLE = "Last War-Survival Game"
-
-# --- Print loaded keys for verification (Optional - BE CAREFUL!) ---
-# print(f"DEBUG: Loaded OPENAI_API_KEY: {'*' * (len(OPENAI_API_KEY) - 4) + OPENAI_API_KEY[-4:] if OPENAI_API_KEY else 'Not Found'}")
-# print(f"DEBUG: Loaded EXA_API_KEY: {'*' * (len(EXA_API_KEY) - 4) + EXA_API_KEY[-4:] if EXA_API_KEY else 'Not Found'}")
-# print(f"DEBUG: Exa args: {MCP_SERVERS['exa']['args']}")

config_template.py

@@ -0,0 +1,76 @@
+# ====================================================================
+# Wolf Chat Configuration Template
+# This file is used by setup.py to generate the final config.py
+# ====================================================================
+import os
+import json
+from dotenv import load_dotenv
+
+# --- Load environment variables from .env file ---
+load_dotenv()
+print("Loaded environment variables from .env file.")
+
+# =============================================================================
+# OpenAI API Configuration / OpenAI-Compatible Provider Settings
+# =============================================================================
+# Leave OPENAI_API_BASE_URL as None or "" to use official OpenAI
+OPENAI_API_BASE_URL = "${OPENAI_API_BASE_URL}"
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+LLM_MODEL = "${LLM_MODEL}"
+
+# =============================================================================
+# External API Keys
+# =============================================================================
+EXA_API_KEY = os.getenv("EXA_API_KEY")
+
+# --- Exa Configuration ---
+exa_config_dict = {"exaApiKey": EXA_API_KEY if EXA_API_KEY else "YOUR_EXA_KEY_MISSING"}
+exa_config_arg_string = json.dumps(exa_config_dict)
+
+# =============================================================================
+# MCP Server Configuration
+# =============================================================================
+MCP_SERVERS = ${MCP_SERVERS}
+
+# =============================================================================
+# MCP Client Configuration
+# =============================================================================
+MCP_CONFIRM_TOOL_EXECUTION = False  # True: Confirm before execution, False: Execute automatically
+
+# =============================================================================
+# Chat Logging Configuration
+# =============================================================================
+ENABLE_CHAT_LOGGING = ${ENABLE_CHAT_LOGGING}
+LOG_DIR = "${LOG_DIR}"
+
+# =============================================================================
+# Persona Configuration
+# =============================================================================
+PERSONA_NAME = "Wolfhart"
+
+# =============================================================================
+# Game Window Configuration
+# =============================================================================
+WINDOW_TITLE = "${WINDOW_TITLE}"
+ENABLE_SCHEDULED_RESTART = ${ENABLE_SCHEDULED_RESTART}
+RESTART_INTERVAL_MINUTES = ${RESTART_INTERVAL_MINUTES}
+GAME_EXECUTABLE_PATH = r"${GAME_EXECUTABLE_PATH}"
+GAME_WINDOW_X = ${GAME_WINDOW_X}
+GAME_WINDOW_Y = ${GAME_WINDOW_Y}
+GAME_WINDOW_WIDTH = ${GAME_WINDOW_WIDTH}
+GAME_WINDOW_HEIGHT = ${GAME_WINDOW_HEIGHT}
+MONITOR_INTERVAL_SECONDS = ${MONITOR_INTERVAL_SECONDS}
+
+# =============================================================================
+# ChromaDB Memory Configuration
+# =============================================================================
+ENABLE_PRELOAD_PROFILES = ${ENABLE_PRELOAD_PROFILES}
+PRELOAD_RELATED_MEMORIES = ${PRELOAD_RELATED_MEMORIES}
+
+# Collection Names (used for both local access and MCP tool calls)
+PROFILES_COLLECTION = "${PROFILES_COLLECTION}"
+CONVERSATIONS_COLLECTION = "${CONVERSATIONS_COLLECTION}"
+BOT_MEMORY_COLLECTION = "${BOT_MEMORY_COLLECTION}"
+
+# Ensure Chroma path is consistent for both direct access and MCP
+CHROMA_DATA_DIR = os.path.abspath("chroma_data")

game_manager.py

@@ -0,0 +1,664 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Game Manager Module
+
+Provides game window monitoring, automatic restart, and process management features.
+Designed to be imported and controlled by setup.py or other management scripts.
+"""
+
+import os
+import sys
+import time
+import json
+import threading
+import subprocess
+import logging
+import pygetwindow as gw
+
+# Attempt to import platform-specific modules that might be needed
+try:
+    import win32gui
+    import win32con
+    HAS_WIN32 = True
+except ImportError:
+    HAS_WIN32 = False
+    print("Warning: win32gui/win32con modules not installed, some window management features may be unavailable")
+
+try:
+    import psutil
+    HAS_PSUTIL = True
+except ImportError:
+    HAS_PSUTIL = False
+    print("Warning: psutil module not installed, process management features may be unavailable")
+
+
+class GameMonitor:
+    """
+    Game window monitoring class.
+    Responsible for monitoring game window position, scheduled restarts, and providing window management functions.
+    """
+    def __init__(self, config_data, remote_data=None, logger=None, callback=None):
+        # Use the provided logger or create a new one
+        self.logger = logger or logging.getLogger("GameMonitor")
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+            self.logger.setLevel(logging.INFO)
+
+        self.config_data = config_data
+        self.remote_data = remote_data or {}
+        self.callback = callback  # Callback function to notify the caller
+
+        # Read settings from configuration
+        self.window_title = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("WINDOW_TITLE", "Last War-Survival Game")
+        self.enable_restart = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("ENABLE_SCHEDULED_RESTART", True)
+        self.restart_interval = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("RESTART_INTERVAL_MINUTES", 60)
+        self.game_path = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_EXECUTABLE_PATH", "")
+        self.window_x = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_X", 50)
+        self.window_y = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_Y", 30)
+        self.window_width = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_WIDTH", 600)
+        self.window_height = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_HEIGHT", 1070)
+        self.monitor_interval = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("MONITOR_INTERVAL_SECONDS", 5)
+
+        # Read game process name from remote_data, use default if not found
+        self.game_process_name = self.remote_data.get("GAME_PROCESS_NAME", "LastWar.exe")
+
+        # Internal state
+        self.running = False
+        self.next_restart_time = None
+        self.monitor_thread = None
+        self.stop_event = threading.Event()
+
+        # Add these tracking variables
+        self.last_focus_failure_count = 0
+        self.last_successful_foreground = time.time()
+
+        self.logger.info(f"GameMonitor initialized. Game window: '{self.window_title}', Process: '{self.game_process_name}'")
+        self.logger.info(f"Position: ({self.window_x}, {self.window_y}), Size: {self.window_width}x{self.window_height}")
+        self.logger.info(f"Scheduled Restart: {'Enabled' if self.enable_restart else 'Disabled'}, Interval: {self.restart_interval} minutes")
+
+    def start(self):
+        """Start game window monitoring"""
+        if self.running:
+            self.logger.info("Game window monitoring is already running")
+            return True # Return True if already running
+
+        self.logger.info("Starting game window monitoring...")
+        self.stop_event.clear()
+
+        # Set next restart time
+        if self.enable_restart and self.restart_interval > 0:
+            self.next_restart_time = time.time() + (self.restart_interval * 60)
+            self.logger.info(f"Scheduled restart enabled. First restart in {self.restart_interval} minutes")
+        else:
+            self.next_restart_time = None
+            self.logger.info("Scheduled restart is disabled")
+
+        # Start monitoring thread
+        self.monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self.monitor_thread.start()
+        self.running = True
+        self.logger.info("Game window monitoring started")
+        return True
+
+    def stop(self):
+        """Stop game window monitoring"""
+        if not self.running:
+            self.logger.info("Game window monitoring is not running")
+            return True # Return True if already stopped
+
+        self.logger.info("Stopping game window monitoring...")
+        self.stop_event.set()
+
+        # Wait for monitoring thread to finish
+        if self.monitor_thread and self.monitor_thread.is_alive():
+            self.logger.info("Waiting for monitoring thread to finish...")
+            self.monitor_thread.join(timeout=5)
+            if self.monitor_thread.is_alive():
+                self.logger.warning("Game window monitoring thread did not stop within the timeout period")
+
+        self.running = False
+        self.monitor_thread = None
+        self.logger.info("Game window monitoring stopped")
+        return True
+
+    def _monitor_loop(self):
+        """Main monitoring loop"""
+        self.logger.info("Game window monitoring loop started")
+        last_adjustment_message = ""  # Avoid logging repetitive adjustment messages
+
+        while not self.stop_event.is_set():
+            try:
+                # Add to _monitor_loop method - just 7 lines that matter
+                if not self._is_game_running():
+                    self.logger.warning("Game process disappeared - restarting")
+                    time.sleep(2)  # Let resources release
+                    if self._start_game_process():
+                        self.logger.info("Game restarted successfully")
+                    else:
+                        self.logger.error("Game restart failed")
+                    time.sleep(self.monitor_interval) # Wait before next check after a restart attempt
+                    continue
+
+                # Check for scheduled restart
+                if self.next_restart_time and time.time() >= self.next_restart_time:
+                    self.logger.info("Scheduled restart time reached. Performing restart...")
+                    self._perform_restart()
+                    # Reset next restart time
+                    self.next_restart_time = time.time() + (self.restart_interval * 60)
+                    self.logger.info(f"Restart timer reset. Next restart in {self.restart_interval} minutes")
+                    # Continue to next loop iteration
+                    time.sleep(self.monitor_interval)
+                    continue
+
+                # Find game window
+                window = self._find_game_window()
+                adjustment_made = False
+                current_message = ""
+
+                if window:
+                    try:
+                        # Use win32gui functions only on Windows
+                        if HAS_WIN32:
+                            # Get window handle
+                            hwnd = window._hWnd
+
+                            # 1. Check and adjust position/size
+                            current_pos = (window.left, window.top)
+                            current_size = (window.width, window.height)
+                            target_pos = (self.window_x, self.window_y)
+                            target_size = (self.window_width, self.window_height)
+
+                            if current_pos != target_pos or current_size != target_size:
+                                window.moveTo(target_pos[0], target_pos[1])
+                                window.resizeTo(target_size[0], target_size[1])
+                                time.sleep(0.1)
+                                window.activate()
+                                time.sleep(0.1)
+                                # Check if changes were successful
+                                new_pos = (window.left, window.top)
+                                new_size = (window.width, window.height)
+                                if new_pos == target_pos and new_size == target_size:
+                                    current_message += f"Adjusted window position/size. "
+                                    adjustment_made = True
+
+                            # 2. Check and bring to foreground using enhanced method
+                            current_foreground_hwnd = win32gui.GetForegroundWindow()
+                            if current_foreground_hwnd != hwnd:
+                                # Use enhanced forceful focus method
+                                success, method_used = self._force_window_foreground(hwnd, window)
+                                if success:
+                                    current_message += f"Focused window using {method_used}. "
+                                    adjustment_made = True
+                                    if not hasattr(self, 'last_focus_failure_count'):
+                                        self.last_focus_failure_count = 0
+                                    self.last_focus_failure_count = 0
+                                else:
+                                    # Increment failure counter
+                                    if not hasattr(self, 'last_focus_failure_count'):
+                                        self.last_focus_failure_count = 0
+                                    self.last_focus_failure_count += 1
+                                    
+                                    # Log warning with consecutive failure count
+                                    self.logger.warning(f"Window focus failed (attempt {self.last_focus_failure_count}): {method_used}")
+                                    
+                                    # Restart game after too many failures
+                                    if self.last_focus_failure_count >= 15:
+                                        self.logger.warning("Excessive focus failures, restarting game...")
+                                        self._perform_restart()
+                                        self.last_focus_failure_count = 0
+                        else:
+                            # Use basic functions on non-Windows platforms
+                            current_pos = (window.left, window.top)
+                            current_size = (window.width, window.height)
+                            target_pos = (self.window_x, self.window_y)
+                            target_size = (self.window_width, self.window_height)
+
+                            if current_pos != target_pos or current_size != target_size:
+                                window.moveTo(target_pos[0], target_pos[1])
+                                window.resizeTo(target_size[0], target_size[1])
+                                current_message += f"Adjusted game window to position {target_pos} size {target_size[0]}x{target_size[1]}. "
+                                adjustment_made = True
+
+                            # Try activating the window (may have limited effect on non-Windows)
+                            try:
+                                window.activate()
+                                current_message += "Attempted to activate game window. "
+                                adjustment_made = True
+                            except Exception as activate_err:
+                                self.logger.warning(f"Error activating window: {activate_err}")
+                                
+                    except Exception as e:
+                        self.logger.error(f"Unexpected error while monitoring game window: {e}")
+
+                # Log only if adjustments were made and the message changed
+                if adjustment_made and current_message and current_message != last_adjustment_message:
+                    self.logger.info(f"[GameMonitor] {current_message.strip()}")
+                    last_adjustment_message = current_message
+                elif not window:
+                    # Reset last message if window disappears
+                    last_adjustment_message = ""
+
+            except Exception as e:
+                self.logger.error(f"Error in monitoring loop: {e}")
+
+            # Wait for the next check
+            time.sleep(self.monitor_interval)
+
+        self.logger.info("Game window monitoring loop finished")
+
+    def _is_game_running(self):
+        """Check if game is running"""
+        if not HAS_PSUTIL:
+            self.logger.warning("_is_game_running: psutil not available, cannot check process status.")
+            return True # Assume running if psutil is not available to avoid unintended restarts
+        try:
+            return any(p.name().lower() == self.game_process_name.lower() for p in psutil.process_iter(['name']))
+        except Exception as e:
+            self.logger.error(f"Error checking game process: {e}")
+            return False # Assume not running on error
+
+    def _find_game_window(self):
+        """Find the game window with the specified title"""
+        try:
+            windows = gw.getWindowsWithTitle(self.window_title)
+            if windows:
+                return windows[0]
+        except Exception as e:
+            self.logger.debug(f"Error finding game window: {e}")
+        return None
+
+    def _force_window_foreground(self, hwnd, window):
+        """Aggressive window focus implementation"""
+        if not HAS_WIN32:
+            return False, "win32 modules unavailable"
+            
+        success = False
+        methods_tried = []
+        
+        # Method 1: HWND_TOPMOST strategy
+        methods_tried.append("HWND_TOPMOST")
+        try:
+            win32gui.SetWindowPos(hwnd, win32con.HWND_TOPMOST, 0, 0, 0, 0,
+                             win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
+            time.sleep(0.1)
+            win32gui.SetWindowPos(hwnd, win32con.HWND_TOP, 0, 0, 0, 0,
+                             win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
+            
+            win32gui.SetForegroundWindow(hwnd)
+            time.sleep(0.2)
+            if win32gui.GetForegroundWindow() == hwnd:
+                return True, "HWND_TOPMOST"
+        except Exception as e:
+            self.logger.debug(f"Method 1 failed: {e}")
+
+        # Method 2: Minimize/restore cycle
+        methods_tried.append("MinimizeRestore")
+        try:
+            win32gui.ShowWindow(hwnd, win32con.SW_MINIMIZE)
+            time.sleep(0.3)
+            win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
+            time.sleep(0.2)
+            win32gui.SetForegroundWindow(hwnd)
+            
+            if win32gui.GetForegroundWindow() == hwnd:
+                return True, "MinimizeRestore"
+        except Exception as e:
+            self.logger.debug(f"Method 2 failed: {e}")
+
+        # Method 3: Thread input attach
+        methods_tried.append("ThreadAttach")
+        try:
+            import win32process
+            import win32api
+            
+            current_thread_id = win32api.GetCurrentThreadId()
+            window_thread_id = win32process.GetWindowThreadProcessId(hwnd)[0]
+            
+            if current_thread_id != window_thread_id:
+                win32process.AttachThreadInput(current_thread_id, window_thread_id, True)
+                try:
+                    win32gui.BringWindowToTop(hwnd)
+                    win32gui.SetForegroundWindow(hwnd)
+                    
+                    time.sleep(0.2)
+                    if win32gui.GetForegroundWindow() == hwnd:
+                        return True, "ThreadAttach"
+                finally:
+                    win32process.AttachThreadInput(current_thread_id, window_thread_id, False)
+        except Exception as e:
+            self.logger.debug(f"Method 3 failed: {e}")
+
+        # Method 4: Flash + Window messages
+        methods_tried.append("Flash+Messages")
+        try:
+            # First flash to get attention
+            win32gui.FlashWindow(hwnd, True)
+            time.sleep(0.2)
+            
+            # Then send specific window messages
+            win32gui.SendMessage(hwnd, win32con.WM_SETREDRAW, 0, 0)
+            win32gui.SendMessage(hwnd, win32con.WM_SETREDRAW, 1, 0)
+            win32gui.RedrawWindow(hwnd, None, None, 
+                                 win32con.RDW_FRAME | win32con.RDW_INVALIDATE | 
+                                 win32con.RDW_UPDATENOW | win32con.RDW_ALLCHILDREN)
+                                 
+            win32gui.PostMessage(hwnd, win32con.WM_SYSCOMMAND, win32con.SC_RESTORE, 0)
+            win32gui.PostMessage(hwnd, win32con.WM_ACTIVATE, win32con.WA_ACTIVE, 0)
+            
+            time.sleep(0.2)
+            if win32gui.GetForegroundWindow() == hwnd:
+                return True, "Flash+Messages"
+        except Exception as e:
+            self.logger.debug(f"Method 4 failed: {e}")
+
+        # Method 5: Hide/Show cycle
+        methods_tried.append("HideShow")
+        try:
+            win32gui.ShowWindow(hwnd, win32con.SW_HIDE)
+            time.sleep(0.2)
+            win32gui.ShowWindow(hwnd, win32con.SW_SHOW)
+            time.sleep(0.2)
+            win32gui.SetForegroundWindow(hwnd)
+            
+            if win32gui.GetForegroundWindow() == hwnd:
+                return True, "HideShow"
+        except Exception as e:
+            self.logger.debug(f"Method 5 failed: {e}")
+
+        return False, f"All methods failed: {', '.join(methods_tried)}"
+
+    def _find_game_process_by_window(self):
+        """Find process using both window title and process name"""
+        if not HAS_PSUTIL or not HAS_WIN32:
+            return None
+
+        try:
+            window = self._find_game_window()
+            if not window:
+                return None
+
+            hwnd = window._hWnd
+            window_pid = None
+            try:
+                import win32process
+                _, window_pid = win32process.GetWindowThreadProcessId(hwnd)
+            except Exception:
+                return None
+
+            if window_pid:
+                try:
+                    proc = psutil.Process(window_pid)
+                    proc_name = proc.name()
+                    
+                    if proc_name.lower() == self.game_process_name.lower():
+                        self.logger.info(f"Found game process '{proc_name}' (PID: {proc.pid}) with window title '{self.window_title}'")
+                        return proc
+                    else:
+                        self.logger.debug(f"Window process name mismatch: expected '{self.game_process_name}', got '{proc_name}'")
+                        return proc # Returning proc even if name mismatches, as per user's code.
+                except Exception:
+                    pass
+            
+            # Fallback to name-based search if window-based fails or PID doesn't match process name.
+            # The user's provided code implies a fallback to _find_game_process_by_name()
+            # This will be handled by the updated _find_game_process method.
+            # For now, if the window PID didn't lead to a matching process name, we return None here.
+            # The original code had "return self._find_game_process_by_name()" here,
+            # but that would create a direct dependency. The new _find_game_process handles the fallback.
+            # So, if we reach here, it means the window was found, PID was obtained, but process name didn't match.
+            # The original code returns `proc` even on mismatch, so I'll keep that.
+            # If `window_pid` was None or `psutil.Process(window_pid)` failed, it would have returned None or passed.
+            # The logic "return self._find_game_process_by_name()" was in the original snippet,
+            # I will include it here as per the snippet, but note that the overall _find_game_process will also call it.
+            return self._find_game_process_by_name() # As per user snippet
+            
+        except Exception as e:
+            self.logger.error(f"Process-by-window lookup error: {e}")
+            return None
+
+    def _find_game_process(self):
+        """Find game process with combined approach"""
+        # Try window-based process lookup first
+        proc = self._find_game_process_by_window()
+        if proc:
+            return proc
+            
+        # Fall back to name-only lookup
+        # This is the original _find_game_process logic, now as a fallback.
+        if not HAS_PSUTIL:
+            self.logger.debug("psutil not available for name-only process lookup fallback.") # Changed to debug as primary is window based
+            return None
+        try:
+            for p_iter in psutil.process_iter(['pid', 'name', 'exe']):
+                try:
+                    proc_info = p_iter.info
+                    proc_name = proc_info.get('name')
+                    if proc_name and proc_name.lower() == self.game_process_name.lower():
+                        self.logger.info(f"Found game process by name '{proc_name}' (PID: {p_iter.pid}) as fallback")
+                        return p_iter
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    continue
+        except Exception as e:
+            self.logger.error(f"Error in name-only game process lookup: {e}")
+        
+        self.logger.info(f"Game process '{self.game_process_name}' not found by name either.")
+        return None
+
+    def _perform_restart(self):
+        """Execute the game restart process"""
+        self.logger.info("Starting game restart process")
+
+        try:
+            # 1. Notify that restart has begun (optional)
+            if self.callback:
+                self.callback("restart_begin")
+
+            # 2. Terminate existing game process
+            self._terminate_game_process()
+            time.sleep(2)  # Short wait to ensure process termination
+
+            # 3. Start new game process
+            if self._start_game_process():
+                self.logger.info("Game restarted successfully")
+            else:
+                self.logger.error("Failed to start game")
+
+            # 4. Wait for game to launch
+            restart_wait_time = 45  # seconds, increased from 30
+            self.logger.info(f"Waiting for game to start ({restart_wait_time} seconds)...")
+            time.sleep(restart_wait_time)
+
+            # 5. Notify restart completion
+            self.logger.info("Game restart process completed, sending notification")
+            if self.callback:
+                self.callback("restart_complete")
+
+            return True
+        except Exception as e:
+            self.logger.error(f"Error during game restart process: {e}")
+            # Attempt to notify error
+            if self.callback:
+                self.callback("restart_error")
+            return False
+
+    def _terminate_game_process(self):
+        """Terminate the game process"""
+        self.logger.info(f"Attempting to terminate game process '{self.game_process_name}'")
+
+        if not HAS_PSUTIL:
+            self.logger.warning("psutil is not available, cannot terminate process")
+            return False
+
+        process = self._find_game_process()
+        terminated = False
+
+        if process:
+            try:
+                self.logger.info(f"Found game process PID: {process.pid}, terminating...")
+                process.terminate()
+
+                try:
+                    process.wait(timeout=5)
+                    self.logger.info(f"Process {process.pid} terminated successfully (terminate)")
+                    terminated = True
+                except psutil.TimeoutExpired:
+                    self.logger.warning(f"Process {process.pid} did not terminate within 5s (terminate), attempting force kill")
+                    process.kill()
+                    process.wait(timeout=5)
+                    self.logger.info(f"Process {process.pid} force killed (kill)")
+                    terminated = True
+            except Exception as e:
+                self.logger.error(f"Error terminating process: {e}")
+        else:
+            self.logger.warning(f"No running process found with name '{self.game_process_name}'")
+
+        return terminated
+
+    def _start_game_process(self):
+        """Start the game process"""
+        if not self.game_path:
+            self.logger.error("Game executable path not set, cannot start")
+            return False
+
+        self.logger.info(f"Starting game: {self.game_path}")
+        try:
+            if sys.platform == "win32":
+                os.startfile(self.game_path)
+                self.logger.info("Called os.startfile to launch game")
+                return True
+            else:
+                # Use subprocess.Popen for non-Windows platforms
+                # Ensure it runs detached if possible, or handle appropriately
+                subprocess.Popen([self.game_path], start_new_session=True) # Attempt detached start
+                self.logger.info("Called subprocess.Popen to launch game")
+                return True
+        except FileNotFoundError:
+            self.logger.error(f"Startup error: Game launcher '{self.game_path}' not found")
+        except OSError as ose:
+            self.logger.error(f"Startup error (OSError): {ose} - Check path and permissions", exc_info=True)
+        except Exception as e:
+            self.logger.error(f"Unexpected error starting game: {e}", exc_info=True)
+
+        return False
+
+    def restart_now(self):
+        """Perform an immediate restart"""
+        self.logger.info("Manually triggering game restart")
+        result = self._perform_restart()
+
+        # Reset the timer if scheduled restart is enabled
+        if self.enable_restart and self.restart_interval > 0:
+            self.next_restart_time = time.time() + (self.restart_interval * 60)
+            self.logger.info(f"Restart timer reset. Next restart in {self.restart_interval} minutes")
+
+        return result
+
+    def update_config(self, config_data=None, remote_data=None):
+        """Update configuration settings"""
+        if config_data:
+            old_config = self.config_data
+            self.config_data = config_data
+
+            # Update key settings
+            self.window_title = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("WINDOW_TITLE", self.window_title)
+            self.enable_restart = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("ENABLE_SCHEDULED_RESTART", self.enable_restart)
+            self.restart_interval = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("RESTART_INTERVAL_MINUTES", self.restart_interval)
+            self.game_path = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_EXECUTABLE_PATH", self.game_path)
+            self.window_x = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_X", self.window_x)
+            self.window_y = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_Y", self.window_y)
+            self.window_width = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_WIDTH", self.window_width)
+            self.window_height = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("GAME_WINDOW_HEIGHT", self.window_height)
+            self.monitor_interval = self.config_data.get("GAME_WINDOW_CONFIG", {}).get("MONITOR_INTERVAL_SECONDS", self.monitor_interval)
+
+            # Reset scheduled restart timer if parameters changed
+            if self.running and self.enable_restart and self.restart_interval > 0:
+                old_interval = old_config.get("GAME_WINDOW_CONFIG", {}).get("RESTART_INTERVAL_MINUTES", 60)
+                if self.restart_interval != old_interval:
+                    self.next_restart_time = time.time() + (self.restart_interval * 60)
+                    self.logger.info(f"Restart interval updated to {self.restart_interval} minutes, next restart reset")
+
+        if remote_data:
+            self.remote_data = remote_data
+            old_process_name = self.game_process_name
+            self.game_process_name = self.remote_data.get("GAME_PROCESS_NAME", old_process_name)
+            if self.game_process_name != old_process_name:
+                self.logger.info(f"Game process name updated to '{self.game_process_name}'")
+
+        self.logger.info("GameMonitor configuration updated")
+
+
+# Provide simple external API functions
+def create_game_monitor(config_data, remote_data=None, logger=None, callback=None):
+    """Create a game monitor instance"""
+    return GameMonitor(config_data, remote_data, logger, callback)
+
+def stop_all_monitors():
+    """Attempt to stop all created monitors (global cleanup)"""
+    # This function could be implemented if instance references are stored.
+    # In the current design, each monitor needs to be stopped individually.
+    pass
+
+
+# Functionality when run standalone (similar to original game_monitor.py)
+if __name__ == "__main__":
+    # Set up basic logging
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    logger = logging.getLogger("GameManagerStandalone")
+
+    # Load settings from config.py
+    try:
+        import config
+        logger.info("Loaded config.py")
+
+        # Build basic configuration dictionary
+        config_data = {
+            "GAME_WINDOW_CONFIG": {
+                "WINDOW_TITLE": config.WINDOW_TITLE,
+                "ENABLE_SCHEDULED_RESTART": config.ENABLE_SCHEDULED_RESTART,
+                "RESTART_INTERVAL_MINUTES": config.RESTART_INTERVAL_MINUTES,
+                "GAME_EXECUTABLE_PATH": config.GAME_EXECUTABLE_PATH,
+                "GAME_WINDOW_X": config.GAME_WINDOW_X,
+                "GAME_WINDOW_Y": config.GAME_WINDOW_Y,
+                "GAME_WINDOW_WIDTH": config.GAME_WINDOW_WIDTH,
+                "GAME_WINDOW_HEIGHT": config.GAME_WINDOW_HEIGHT,
+                "MONITOR_INTERVAL_SECONDS": config.MONITOR_INTERVAL_SECONDS
+            }
+        }
+        
+        # Define a callback for standalone execution
+        def standalone_callback(action):
+            """Send JSON signal via standard output"""
+            logger.info(f"Sending signal: {action}")
+            signal_data = {'action': action}
+            try:
+                json_signal = json.dumps(signal_data)
+                print(json_signal, flush=True)
+                logger.info(f"Signal sent: {action}")
+            except Exception as e:
+                logger.error(f"Failed to send signal '{action}': {e}")
+
+        # Create and start the monitor
+        monitor = GameMonitor(config_data, logger=logger, callback=standalone_callback)
+        monitor.start()
+
+        # Keep the program running
+        try:
+            logger.info("Game monitoring started. Press Ctrl+C to stop.")
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            logger.info("Ctrl+C received, stopping...")
+        finally:
+            monitor.stop()
+            logger.info("Game monitoring stopped")
+
+    except ImportError:
+        logger.error("Could not load config.py. Ensure it exists and contains necessary settings.")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"Error starting game monitoring: {e}", exc_info=True)
+        sys.exit(1)

install.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Wolf Chat Installation Script
+Installs required dependencies for Wolf Chat
+"""
+
+import os
+import sys
+import subprocess
+import tkinter as tk
+from tkinter import ttk, messagebox
+
+REQUIREMENTS = [
+    "openai",
+    "mcp",
+    "pyautogui",
+    "opencv-python",
+    "numpy",
+    "pyperclip",
+    "pygetwindow",
+    "psutil",
+    "pywin32",
+    "python-dotenv",
+    "keyboard"
+]
+
+def install_requirements(progress_var=None, status_label=None, root=None):
+    """Install all required packages using pip"""
+    
+    total = len(REQUIREMENTS)
+    success_count = 0
+    failed_packages = []
+    
+    for i, package in enumerate(REQUIREMENTS):
+        if status_label:
+            status_label.config(text=f"Installing {package}...")
+        if progress_var:
+            progress_var.set((i / total) * 100)
+        if root:
+            root.update()
+        
+        try:
+            print(f"Installing {package}...")
+            # Use subprocess to run pip install
+            process = subprocess.run(
+                [sys.executable, "-m", "pip", "install", package],
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            print(f"Successfully installed {package}")
+            success_count += 1
+            
+        except subprocess.CalledProcessError as e:
+            print(f"Failed to install {package}: {e}")
+            print(f"Error output: {e.stderr}")
+            failed_packages.append(package)
+            
+        except Exception as e:
+            print(f"Unexpected error installing {package}: {str(e)}")
+            failed_packages.append(package)
+    
+    # Final progress update
+    if progress_var:
+        progress_var.set(100)
+    
+    # Report results
+    if not failed_packages:
+        result_message = f"All {success_count} packages installed successfully!"
+        print(result_message)
+        if status_label:
+            status_label.config(text=result_message)
+        return True, result_message
+    else:
+        result_message = f"Installed {success_count}/{total} packages. Failed: {', '.join(failed_packages)}"
+        print(result_message)
+        if status_label:
+            status_label.config(text=result_message)
+        return False, result_message
+
+def run_installer_gui():
+    """Run a simple GUI for the installer"""
+    root = tk.Tk()
+    root.title("Wolf Chat Installer")
+    root.geometry("400x200")
+    root.resizable(False, False)
+    
+    # Main frame
+    main_frame = ttk.Frame(root, padding=20)
+    main_frame.pack(fill=tk.BOTH, expand=True)
+    
+    # Title
+    title_label = ttk.Label(main_frame, text="Wolf Chat Dependency Installer", font=("", 12, "bold"))
+    title_label.pack(pady=(0, 10))
+    
+    # Info text
+    info_text = f"This will install {len(REQUIREMENTS)} required packages for Wolf Chat."
+    info_label = ttk.Label(main_frame, text=info_text)
+    info_label.pack(pady=(0, 15))
+    
+    # Progress bar
+    progress_var = tk.DoubleVar()
+    progress_bar = ttk.Progressbar(main_frame, variable=progress_var, maximum=100)
+    progress_bar.pack(fill=tk.X, pady=(0, 10))
+    
+    # Status label
+    status_label = ttk.Label(main_frame, text="Ready to install...")
+    status_label.pack(pady=(0, 15))
+    
+    # Install button
+    def start_installation():
+        # Disable button during installation
+        install_button.config(state=tk.DISABLED)
+        
+        # Run installation in a separate thread to keep UI responsive
+        success, message = install_requirements(progress_var, status_label, root)
+        
+        # Show completion message
+        if success:
+            messagebox.showinfo("Installation Complete", message)
+        else:
+            messagebox.showwarning("Installation Issues", message)
+        
+        # Close the window
+        root.destroy()
+    
+    install_button = ttk.Button(main_frame, text="Install Dependencies", command=start_installation)
+    install_button.pack()
+    
+    # Start the GUI loop
+    root.mainloop()
+
+if __name__ == "__main__":
+    # If run directly, show GUI
+    run_installer_gui()

main.py

@@ -4,35 +4,258 @@ import asyncio
 import sys
 import os
 import json # Import json module
+import collections # For deque
+import datetime # For logging timestamp
 from contextlib import AsyncExitStack
 # --- Import standard queue ---
-from queue import Queue as ThreadSafeQueue # Rename to avoid confusion
+from queue import Queue as ThreadSafeQueue, Empty as QueueEmpty # Rename to avoid confusion, import Empty
 # --- End Import ---
 from mcp.client.stdio import stdio_client
 from mcp import ClientSession, StdioServerParameters, types
 
+# --- Keyboard Imports ---
+import threading
+import time
+# Import MessageDeduplication from ui_interaction
+from ui_interaction import MessageDeduplication
+try:
+    import keyboard # Needs pip install keyboard
+except ImportError:
+    print("Error: 'keyboard' library not found. Please install it: pip install keyboard")
+    sys.exit(1)
+# --- End Keyboard Imports ---
+
 import config
 import mcp_client
 # Ensure llm_interaction is the version that accepts persona_details
 import llm_interaction
 # Import UI module
 import ui_interaction
+import chroma_client
+import subprocess # Import subprocess module
+import signal
+import platform
+# Conditionally import Windows-specific modules
+if platform.system() == "Windows":
+    try:
+        import win32api
+        import win32con
+    except ImportError:
+        print("Warning: 'pywin32' not installed. MCP server subprocess termination on exit might not work reliably on Windows.")
+        win32api = None
+        win32con = None
+else:
+    win32api = None
+    win32con = None
+
 
 # --- Global Variables ---
 active_mcp_sessions: dict[str, ClientSession] = {}
+# Store Popen objects for managed MCP servers
+mcp_server_processes: dict[str, asyncio.subprocess.Process] = {}
 all_discovered_mcp_tools: list[dict] = []
 exit_stack = AsyncExitStack()
 # Stores loaded persona data (as a string for easy injection into prompt)
 wolfhart_persona_details: str | None = None
-# --- Use standard thread-safe queue ---
-trigger_queue: ThreadSafeQueue = ThreadSafeQueue() # Use standard Queue
+# --- Conversation History ---
+# Store tuples of (timestamp, speaker_type, speaker_name, message_content)
+# speaker_type can be 'user' or 'bot'
+conversation_history = collections.deque(maxlen=50) # Store last 50 messages (user+bot) with timestamps
+# --- Use standard thread-safe queues ---
+trigger_queue: ThreadSafeQueue = ThreadSafeQueue() # UI Thread -> Main Loop
+command_queue: ThreadSafeQueue = ThreadSafeQueue() # Main Loop -> UI Thread
 # --- End Change ---
 ui_monitor_task: asyncio.Task | None = None # To track the UI monitor task
 
+# --- Keyboard Shortcut State ---
+script_paused = False
+shutdown_requested = False
+main_loop = None # To store the main event loop for threadsafe calls
+# --- End Keyboard Shortcut State ---
+
+
+# --- Keyboard Shortcut Handlers ---
+def set_main_loop_and_queue(loop, queue):
+    """Stores the main event loop and command queue for threadsafe access."""
+    global main_loop, command_queue # Use the global command_queue directly
+    main_loop = loop
+    # command_queue is already global
+
+def handle_f7():
+    """Handles F7 press: Clears UI history."""
+    if main_loop and command_queue:
+        print("\n--- F7 pressed: Clearing UI history ---")
+        command = {'action': 'clear_history'}
+        try:
+            # Use call_soon_threadsafe to put item in queue from this thread
+            main_loop.call_soon_threadsafe(command_queue.put_nowait, command)
+        except Exception as e:
+            print(f"Error sending clear_history command: {e}")
+
+def handle_f8():
+    """Handles F8 press: Toggles script pause state and UI monitoring."""
+    global script_paused
+    if main_loop and command_queue:
+        script_paused = not script_paused
+        if script_paused:
+            print("\n--- F8 pressed: Pausing script and UI monitoring ---")
+            command = {'action': 'pause'}
+            try:
+                main_loop.call_soon_threadsafe(command_queue.put_nowait, command)
+            except Exception as e:
+                 print(f"Error sending pause command (F8): {e}")
+        else:
+            print("\n--- F8 pressed: Resuming script and UI monitoring ---")
+            resume_command = {'action': 'resume'}
+            try:
+                # Add a small delay? Let's try without first.
+                # time.sleep(0.05) # Short delay between commands if needed
+                main_loop.call_soon_threadsafe(command_queue.put_nowait, resume_command)
+            except Exception as e:
+                 print(f"Error sending resume command (F8): {e}")
+
+def handle_f9():
+    """Handles F9 press: Initiates script shutdown."""
+    global shutdown_requested
+    if not shutdown_requested: # Prevent multiple shutdown requests
+        print("\n--- F9 pressed: Requesting shutdown ---")
+        shutdown_requested = True
+        # Optional: Unhook keys immediately? Let the listener loop handle it.
+
+def keyboard_listener():
+    """Runs in a separate thread to listen for keyboard hotkeys."""
+    print("Keyboard listener thread started. F7: Clear History, F8: Pause/Resume, F9: Quit.")
+    try:
+        keyboard.add_hotkey('f7', handle_f7)
+        keyboard.add_hotkey('f8', handle_f8)
+        keyboard.add_hotkey('f9', handle_f9)
+
+        # Keep the thread alive while checking for shutdown request
+        while not shutdown_requested:
+            time.sleep(0.1) # Check periodically
+
+    except Exception as e:
+        print(f"Error in keyboard listener thread: {e}")
+    finally:
+        print("Keyboard listener thread stopping and unhooking keys.")
+        try:
+            keyboard.unhook_all() # Clean up hooks
+        except Exception as unhook_e:
+            print(f"Error unhooking keyboard keys: {unhook_e}")
+# --- End Keyboard Shortcut Handlers ---
+
+
+# --- Chat Logging Function ---
+def log_chat_interaction(user_name: str, user_message: str, bot_name: str, bot_message: str, bot_thoughts: str | None = None):
+    """Logs the chat interaction, including optional bot thoughts, to a date-stamped file if enabled."""
+    if not config.ENABLE_CHAT_LOGGING:
+        return
+
+    try:
+        # Ensure log directory exists
+        log_dir = config.LOG_DIR
+        os.makedirs(log_dir, exist_ok=True)
+
+        # Get current date for filename
+        today_date = datetime.date.today().strftime("%Y-%m-%d")
+        log_file_path = os.path.join(log_dir, f"{today_date}.log")
+
+        # Get current timestamp for log entry
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # Format log entry
+        log_entry = f"[{timestamp}] User ({user_name}): {user_message}\n"
+        # Include thoughts if available
+        if bot_thoughts:
+            log_entry += f"[{timestamp}] Bot ({bot_name}) Thoughts: {bot_thoughts}\n"
+        log_entry += f"[{timestamp}] Bot ({bot_name}) Dialogue: {bot_message}\n" # Label dialogue explicitly
+        log_entry += "---\n" # Separator
+
+        # Append to log file
+        with open(log_file_path, "a", encoding="utf-8") as f:
+            f.write(log_entry)
+
+    except Exception as e:
+        print(f"Error writing to chat log: {e}")
+# --- End Chat Logging Function ---
+
+
+# --- MCP Server Subprocess Termination Logic (Windows) ---
+def terminate_all_mcp_servers():
+    """Attempts to terminate all managed MCP server subprocesses."""
+    if not mcp_server_processes:
+        return
+    print(f"[INFO] Terminating {len(mcp_server_processes)} managed MCP server subprocess(es)...")
+    for key, proc in list(mcp_server_processes.items()): # Iterate over a copy of items
+        if proc.returncode is None: # Check if process is still running
+            print(f"[INFO] Terminating server '{key}' (PID: {proc.pid})...")
+            try:
+                if platform.system() == "Windows" and win32api:
+                    # Send CTRL_BREAK_EVENT on Windows if flag was set
+                    # Note: This requires the process was started with CREATE_NEW_PROCESS_GROUP
+                    proc.send_signal(signal.CTRL_BREAK_EVENT)
+                    print(f"[INFO] Sent CTRL_BREAK_EVENT to server '{key}'.")
+                    # Optionally wait with timeout, then kill if needed
+                    # proc.wait(timeout=5) # This is blocking, avoid in async handler?
+                else:
+                    # Use standard terminate for non-Windows or if win32api failed
+                    proc.terminate()
+                    print(f"[INFO] Sent SIGTERM to server '{key}'.")
+            except ProcessLookupError:
+                 print(f"[WARN] Process for server '{key}' (PID: {proc.pid}) not found.")
+            except Exception as e:
+                print(f"[ERROR] Error terminating server '{key}' (PID: {proc.pid}): {e}")
+                # Fallback to kill if terminate fails or isn't applicable
+                try:
+                    if proc.returncode is None:
+                        proc.kill()
+                        print(f"[WARN] Forcefully killed server '{key}' (PID: {proc.pid}).")
+                except Exception as kill_e:
+                    print(f"[ERROR] Error killing server '{key}' (PID: {proc.pid}): {kill_e}")
+        # Remove from dict after attempting termination
+        if key in mcp_server_processes:
+             del mcp_server_processes[key]
+    print("[INFO] Finished attempting MCP server termination.")
+
+def windows_ctrl_handler(ctrl_type):
+    """Handles Windows console control events."""
+    if win32con and ctrl_type in (
+        win32con.CTRL_C_EVENT,
+        win32con.CTRL_BREAK_EVENT,
+        win32con.CTRL_CLOSE_EVENT,
+        win32con.CTRL_LOGOFF_EVENT,
+        win32con.CTRL_SHUTDOWN_EVENT
+    ):
+        print(f"[INFO] Windows Control Event ({ctrl_type}) detected. Initiating MCP server termination.")
+        # Directly call the termination function.
+        # Avoid doing complex async operations here if possible.
+        # The main shutdown sequence will handle async cleanup.
+        terminate_all_mcp_servers()
+        # Returning True indicates we handled the event,
+        # but might prevent default clean exit. Let's return False
+        # to allow Python's default handler to also run (e.g., for KeyboardInterrupt).
+        return False # Allow other handlers to process the event
+    return False # Event not handled
+
+# Register the handler only on Windows and if imports succeeded
+if platform.system() == "Windows" and win32api and win32con:
+    try:
+        win32api.SetConsoleCtrlHandler(windows_ctrl_handler, True)
+        print("[INFO] Registered Windows console control handler for MCP server cleanup.")
+    except Exception as e:
+        print(f"[ERROR] Failed to register Windows console control handler: {e}")
+# --- End MCP Server Termination Logic ---
+
+
 # --- Cleanup Function ---
 async def shutdown():
-    """Gracefully closes connections and stops monitoring task."""
-    global wolfhart_persona_details, ui_monitor_task
+    """Gracefully closes connections and stops monitoring tasks/processes."""
+    global wolfhart_persona_details, ui_monitor_task, shutdown_requested
+    # Ensure shutdown is requested if called externally (e.g., Ctrl+C)
+    if not shutdown_requested:
+        print("Shutdown initiated externally (e.g., Ctrl+C).")
+        shutdown_requested = True # Ensure listener thread stops
+
     print(f"\nInitiating shutdown procedure...")
 
     # 1. Cancel UI monitor task first
@@ -48,8 +271,12 @@ async def shutdown():
             print(f"Error while waiting for UI monitoring task cancellation: {e}")
 
     # 2. Close MCP connections via AsyncExitStack
+    # This will trigger the __aexit__ method of stdio_client contexts,
+    # which we assume handles terminating the server subprocesses it started.
     print(f"Closing MCP Server connections (via AsyncExitStack)...")
     try:
+        # This will close the ClientSession contexts, which might involve
+        # closing the stdin/stdout pipes to the (now hopefully terminated) servers.
         await exit_stack.aclose()
         print("AsyncExitStack closed successfully.")
     except Exception as e:
@@ -69,7 +296,7 @@ async def connect_and_discover(key: str, server_config: dict):
     """
     Connects to a single MCP server, initializes the session, and discovers tools.
     """
-    global all_discovered_mcp_tools, active_mcp_sessions, exit_stack
+    global all_discovered_mcp_tools, active_mcp_sessions, exit_stack # Remove mcp_server_processes from global list here
     print(f"\nProcessing Server: '{key}'")
     command = server_config.get("command")
     args = server_config.get("args", [])
@@ -81,22 +308,34 @@ async def connect_and_discover(key: str, server_config: dict):
         print(f"==> Error: Missing 'command' in Server '{key}' configuration. <==")
         return
 
+    # Use StdioServerParameters again
     server_params = StdioServerParameters(
         command=command, args=args, env=process_env,
+        # Note: We assume stdio_client handles necessary flags internally or
+        # that its cleanup mechanism is sufficient. Explicit flag passing here
+        # might require checking the mcp library's StdioServerParameters definition.
     )
 
     try:
+        # --- Use stdio_client again ---
         print(f"Using stdio_client to start and connect to Server '{key}'...")
+        # Pass server_params to stdio_client
+        # stdio_client manages the subprocess lifecycle within its context
         read, write = await exit_stack.enter_async_context(
             stdio_client(server_params)
         )
-        print(f"stdio_client for '{key}' active.")
+        print(f"stdio_client for '{key}' active, provides read/write streams.")
+        # --- End stdio_client usage ---
 
+        # stdio_client provides the correct stream types for ClientSession
         session = await exit_stack.enter_async_context(
             ClientSession(read, write)
         )
         print(f"ClientSession for '{key}' context entered.")
 
+        # We no longer manually manage the process object here.
+        # We rely on stdio_client's context manager (__aexit__) to terminate the process.
+
         print(f"Initializing Session '{key}'...")
         await session.initialize()
         print(f"Session '{key}' initialized successfully.")
@@ -151,7 +390,7 @@ async def initialize_mcp_connections():
         #           print(f"Exception caught when connecting to Server '{server_key}': {result}")
     print("\n--- All MCP connection initialization attempts completed ---")
     print(f"Total discovered MCP tools: {len(all_discovered_mcp_tools)}.")
-    print(f"Currently active MCP Sessions: {list(active_mcp_sessions.keys())}")
+    # Removed print statement for active sessions
 
 
 # --- Load Persona Function (with corrected syntax) ---
@@ -183,105 +422,379 @@ def load_persona_from_file(filename="persona.json"):
         print(f"Unknown error loading Persona configuration file '{filename}': {e}")
         wolfhart_persona_details = None
 
+# --- Memory System Initialization ---
+def initialize_memory_system():
+    """Initialize memory system"""
+    if hasattr(config, 'ENABLE_PRELOAD_PROFILES') and config.ENABLE_PRELOAD_PROFILES:
+        print("\nInitializing ChromaDB memory system...")
+        if chroma_client.initialize_chroma_client():
+            # Check if collections are available
+            collections_to_check = [
+                config.PROFILES_COLLECTION,
+                config.CONVERSATIONS_COLLECTION,
+                config.BOT_MEMORY_COLLECTION
+            ]
+            success_count = 0
+            for coll_name in collections_to_check:
+                if chroma_client.get_collection(coll_name):
+                    success_count += 1
+
+            print(f"Memory system initialization complete, successfully connected to {success_count}/{len(collections_to_check)} collections")
+            return True
+        else:
+            print("Memory system initialization failed, falling back to tool calls")
+            return False
+    else:
+        print("Memory system preloading is disabled, will use tool calls to get memory")
+        return False
+# --- End Memory System Initialization ---
 
 # --- Main Async Function ---
 async def run_main_with_exit_stack():
     """Initializes connections, loads persona, starts UI monitor and main processing loop."""
-    global initialization_successful, main_task, loop, wolfhart_persona_details, trigger_queue, ui_monitor_task
+    global initialization_successful, main_task, loop, wolfhart_persona_details, trigger_queue, ui_monitor_task, shutdown_requested, script_paused, command_queue
     try:
         # 1. Load Persona Synchronously (before async loop starts)
         load_persona_from_file() # Corrected function
 
-        # 2. Initialize MCP Connections Asynchronously
+        # 2. Initialize Memory System (after loading config, before main loop)
+        memory_system_active = initialize_memory_system()
+
+        # 3. Initialize MCP Connections Asynchronously
         await initialize_mcp_connections()
 
-        # Exit if no servers connected successfully
+        # Warn if no servers connected successfully, but continue
         if not active_mcp_sessions:
-             print("\nFailed to connect to any MCP Server, program will exit.")
-             return
+             print("\n\033[93m[!]\033[0m Unable to connect to any MCP server, or no server is configured.")
+             # Removed 'return' statement to allow continuation
+        else:
+             print(f"Successfully connected to {len(active_mcp_sessions)} MCP server(s): {list(active_mcp_sessions.keys())}")
 
-        initialization_successful = True
+        initialization_successful = True # Keep this, might be useful elsewhere
 
-        # 3. Start UI Monitoring in a separate thread
+        # 3. Get loop and set it for keyboard handlers
+        loop = asyncio.get_running_loop()
+        set_main_loop_and_queue(loop, command_queue) # Pass loop and queue
+
+        # 4. Start Keyboard Listener Thread
+        print("\n--- Starting keyboard listener thread ---")
+        kb_thread = threading.Thread(target=keyboard_listener, daemon=True) # Use daemon thread
+        kb_thread.start()
+
+        # 5. Start UI Monitoring in a separate thread
         print("\n--- Starting UI monitoring thread ---")
-        loop = asyncio.get_running_loop() # Get loop for run_in_executor
+        # 5c. Create MessageDeduplication instance
+        deduplicator = MessageDeduplication(expiry_seconds=3600) # Default 1 hour
+
+        # Use the new monitoring loop function, passing both queues and the deduplicator
         monitor_task = loop.create_task(
-            asyncio.to_thread(ui_interaction.monitor_chat_for_trigger, trigger_queue),
+            asyncio.to_thread(ui_interaction.run_ui_monitoring_loop, trigger_queue, command_queue, deduplicator), # Pass command_queue and deduplicator
             name="ui_monitor"
         )
         ui_monitor_task = monitor_task # Store task reference for shutdown
+        # Note: UI task cancellation is handled in shutdown()
 
-        # 4. Start the main processing loop (waiting on the standard queue)
+        # 5b. Game Window Monitoring is now handled by Setup.py
+
+        # 5d. Start Periodic Cleanup Timer for Deduplicator
+        def periodic_cleanup():
+            if not shutdown_requested: # Only run if not shutting down
+                print("Main Thread: Running periodic deduplicator cleanup...")
+                deduplicator.purge_expired()
+                # Reschedule the timer
+                cleanup_timer = threading.Timer(600, periodic_cleanup) # 10 minutes
+                cleanup_timer.daemon = True
+                cleanup_timer.start()
+            else:
+                print("Main Thread: Shutdown requested, not rescheduling deduplicator cleanup.")
+
+        print("\n--- Starting periodic deduplicator cleanup timer (10 min interval) ---")
+        initial_cleanup_timer = threading.Timer(600, periodic_cleanup)
+        initial_cleanup_timer.daemon = True
+        initial_cleanup_timer.start()
+        # Note: This timer will run in a separate thread.
+        # Ensure it's handled correctly on shutdown if it holds resources.
+        # Since it's a daemon thread and reschedules itself, it should exit when the main program exits.
+
+        # 6. Start the main processing loop (non-blocking check on queue)
         print("\n--- Wolfhart chatbot has started (waiting for triggers) ---")
         print(f"Available tools: {len(all_discovered_mcp_tools)}")
         if wolfhart_persona_details: print("Persona data loaded.")
         else: print("Warning: Failed to load Persona data.")
-        print("Press Ctrl+C to stop the program.")
+        print("F7: Clear History, F8: Pause/Resume, F9: Quit.")
 
         while True:
-            print("\nWaiting for UI trigger (from thread-safe Queue)...")
-            # Use run_in_executor to wait for item from standard queue
-            trigger_data = await loop.run_in_executor(None, trigger_queue.get)
+            # --- Check for Shutdown Request ---
+            if shutdown_requested:
+                print("Shutdown requested via F9. Exiting main loop.")
+                break
 
+            # --- Check for Pause State ---
+            if script_paused:
+                # Script is paused by F8, just sleep briefly
+                await asyncio.sleep(0.1)
+                continue # Skip the rest of the loop
+
+            # --- Wait for Trigger Data (Blocking via executor) ---
+            trigger_data = None
+            try:
+                # Use run_in_executor with the blocking get() method
+                # This will efficiently wait until an item is available in the queue
+                print("Waiting for UI trigger (from thread-safe Queue)...") # Log before blocking wait
+                trigger_data = await loop.run_in_executor(None, trigger_queue.get)
+            except Exception as e:
+                # Handle potential errors during queue get (though less likely with blocking get)
+                print(f"Error getting data from trigger_queue: {e}")
+                await asyncio.sleep(0.5) # Wait a bit before retrying
+                continue
+
+            # --- Process Trigger Data (if received) ---
+            # No need for 'if trigger_data:' check here, as get() blocks until data is available
+            # --- Pause UI Monitoring (Only if not already paused by F8) ---
+            if not script_paused:
+                print("Pausing UI monitoring before LLM call...")
+                # Corrected indentation below
+                pause_command = {'action': 'pause'}
+                try:
+                    await loop.run_in_executor(None, command_queue.put, pause_command)
+                    print("Pause command placed in queue.")
+                except Exception as q_err:
+                    print(f"Error putting pause command in queue: {q_err}")
+            else: # Corrected indentation for else
+                print("Script already paused by F8, skipping automatic pause.")
+            # --- End Pause ---
+
+            # Process trigger data (Corrected indentation for this block - unindented one level)
             sender_name = trigger_data.get('sender')
             bubble_text = trigger_data.get('text')
+            bubble_region = trigger_data.get('bubble_region') # <-- Extract bubble_region
+            bubble_snapshot = trigger_data.get('bubble_snapshot') # <-- Extract snapshot
+            search_area = trigger_data.get('search_area') # <-- Extract search_area
             print(f"\n--- Received trigger from UI ---")
             print(f"   Sender: {sender_name}")
             print(f"   Content: {bubble_text[:100]}...")
+            if bubble_region:
+                print(f"   Bubble Region: {bubble_region}") # <-- Log bubble_region
 
-            if not sender_name or not bubble_text:
-                print("Warning: Received incomplete trigger data, skipping.")
-                # No task_done needed for standard queue
+            if not sender_name or not bubble_text: # bubble_region is optional context, don't fail if missing
+                print("Warning: Received incomplete trigger data (missing sender or text), skipping.")
+                # Resume UI if we paused it automatically
+                if not script_paused:
+                    print("Resuming UI monitoring after incomplete trigger.")
+                    resume_command = {'action': 'resume'}
+                    try:
+                        await loop.run_in_executor(None, command_queue.put, resume_command)
+                    except Exception as q_err:
+                        print(f"Error putting resume command in queue: {q_err}")
                 continue
 
+            # --- Add user message to history ---
+            timestamp = datetime.datetime.now() # Get current timestamp
+            conversation_history.append((timestamp, 'user', sender_name, bubble_text))
+            print(f"Added user message from {sender_name} to history at {timestamp}.")
+            # --- End Add user message ---
+
+            # --- Memory Preloading ---
+            user_profile = None
+            related_memories = []
+            bot_knowledge = []
+            memory_retrieval_time = 0
+
+            # If memory system is active and preloading is enabled
+            if memory_system_active and hasattr(config, 'ENABLE_PRELOAD_PROFILES') and config.ENABLE_PRELOAD_PROFILES:
+                try:
+                    memory_start_time = time.time()
+
+                    # 1. Get user profile
+                    user_profile = chroma_client.get_entity_profile(sender_name)
+
+                    # 2. Preload related memories if configured
+                    if hasattr(config, 'PRELOAD_RELATED_MEMORIES') and config.PRELOAD_RELATED_MEMORIES > 0:
+                        related_memories = chroma_client.get_related_memories(
+                            sender_name,
+                            limit=config.PRELOAD_RELATED_MEMORIES
+                        )
+
+                    # 3. Optionally preload bot knowledge based on message content
+                    key_game_terms = ["capital_position", "capital_administrator_role", "server_hierarchy",
+                                     "last_war", "winter_war", "excavations", "blueprints",
+                                     "honor_points", "golden_eggs", "diamonds"]
+
+                    # Check if message contains these keywords
+                    found_terms = [term for term in key_game_terms if term.lower() in bubble_text.lower()]
+
+                    if found_terms:
+                        # Retrieve knowledge for found terms (limit to 2 terms, 2 results each)
+                        for term in found_terms[:2]:
+                            term_knowledge = chroma_client.get_bot_knowledge(term, limit=2)
+                            bot_knowledge.extend(term_knowledge)
+
+                    memory_retrieval_time = time.time() - memory_start_time
+                    print(f"Memory retrieval complete: User profile {'successful' if user_profile else 'failed'}, "
+                          f"{len(related_memories)} related memories, "
+                          f"{len(bot_knowledge)} bot knowledge, "
+                          f"total time {memory_retrieval_time:.3f}s")
+
+                except Exception as mem_err:
+                    print(f"Error during memory retrieval: {mem_err}")
+                    # Clear all memory data on error to avoid using partial data
+                    user_profile = None
+                    related_memories = []
+                    bot_knowledge = []
+            # --- End Memory Preloading ---
+
             print(f"\n{config.PERSONA_NAME} is thinking...")
             try:
-                # Get LLM response (現在返回的是一個字典)
+                # Get LLM response, passing preloaded memory data
                 bot_response_data = await llm_interaction.get_llm_response(
-                    user_input=f"Message from {sender_name}: {bubble_text}", # Provide context
+                    current_sender_name=sender_name,
+                    history=list(conversation_history),
                     mcp_sessions=active_mcp_sessions,
                     available_mcp_tools=all_discovered_mcp_tools,
-                    persona_details=wolfhart_persona_details
+                    persona_details=wolfhart_persona_details,
+                    user_profile=user_profile,                # Added: Pass user profile
+                    related_memories=related_memories,        # Added: Pass related memories
+                    bot_knowledge=bot_knowledge               # Added: Pass bot knowledge
                 )
-                
-                # 提取對話內容
+
+                # Extract dialogue content
                 bot_dialogue = bot_response_data.get("dialogue", "")
-                valid_response = bot_response_data.get("valid_response", False)
+                valid_response = bot_response_data.get("valid_response", False) # <-- Get valid_response flag
                 print(f"{config.PERSONA_NAME}'s dialogue response: {bot_dialogue}")
-                
-                # 處理命令 (如果有的話)
+                # --- DEBUG PRINT ---
+                print(f"DEBUG main.py: Before check - bot_dialogue='{bot_dialogue}', valid_response={valid_response}, dialogue_is_truthy={bool(bot_dialogue)}")
+                # --- END DEBUG PRINT ---
+
+                # Process commands (if any)
                 commands = bot_response_data.get("commands", [])
                 if commands:
                     print(f"Processing {len(commands)} command(s)...")
                     for cmd in commands:
                         cmd_type = cmd.get("type", "")
-                        cmd_params = cmd.get("parameters", {})
-                        # 預留位置：在這裡添加命令處理邏輯
-                        print(f"Command type: {cmd_type}, parameters: {cmd_params}")
-                        # TODO: 實現各類命令的處理邏輯
-                
-                # 記錄思考過程 (如果有的話)
+                        cmd_params = cmd.get("parameters", {}) # Parameters might be empty for remove_position
+
+# --- Command Processing ---
+                        if cmd_type == "remove_position":
+                            if bubble_region: # Check if we have the context
+                                # Debug info - print what we have
+                                print(f"Processing remove_position command with:")
+                                print(f"  bubble_region: {bubble_region}")
+                                print(f"  bubble_snapshot available: {'Yes' if bubble_snapshot is not None else 'No'}")
+                                print(f"  search_area available: {'Yes' if search_area is not None else 'No'}")
+
+                                # Check if we have snapshot and search_area as well
+                                if bubble_snapshot and search_area:
+                                    print("Sending 'remove_position' command to UI thread with snapshot and search area...")
+                                    command_to_send = {
+                                        'action': 'remove_position',
+                                        'trigger_bubble_region': bubble_region, # Original region (might be outdated)
+                                        'bubble_snapshot': bubble_snapshot,     # Snapshot for re-location
+                                        'search_area': search_area              # Area to search in
+                                    }
+                                    try:
+                                        await loop.run_in_executor(None, command_queue.put, command_to_send)
+                                    except Exception as q_err:
+                                        print(f"Error putting remove_position command in queue: {q_err}")
+                                else:
+                                    # If we have bubble_region but missing other parameters, use a dummy search area
+                                    # and let UI thread take a new screenshot
+                                    print("Missing bubble_snapshot or search_area, trying with defaults...")
+
+                                    # Use the bubble_region itself as a fallback search area if needed
+                                    default_search_area = None
+                                    if search_area is None and bubble_region:
+                                        # Convert bubble_region to a proper search area format if needed
+                                        if len(bubble_region) == 4:
+                                            default_search_area = bubble_region
+
+                                    command_to_send = {
+                                        'action': 'remove_position',
+                                        'trigger_bubble_region': bubble_region,
+                                        'bubble_snapshot': bubble_snapshot,     # Pass as is, might be None
+                                        'search_area': default_search_area if search_area is None else search_area
+                                    }
+
+                                    try:
+                                        await loop.run_in_executor(None, command_queue.put, command_to_send)
+                                        print("Command sent with fallback parameters.")
+                                    except Exception as q_err:
+                                        print(f"Error putting remove_position command in queue: {q_err}")
+                        else:
+                            print("Error: Cannot process 'remove_position' command without bubble_region context.")
+                        # Add other command handling here if needed
+                        # elif cmd_type == "some_other_command":
+                        #    # Handle other commands
+                        #    pass
+                        # elif cmd_type == "some_other_command":
+                        #    # Handle other commands
+                        #    pass
+                        # else:
+                        #     # 2025-04-19: Commented out - MCP tools like web_search are now handled
+                        #     # internally by llm_interaction.py's tool calling loop.
+                        #     # main.py only needs to handle UI-specific commands like remove_position.
+                        #     print(f"Ignoring command type from LLM JSON (already handled internally): {cmd_type}, parameters: {cmd_params}")
+                        # --- End Command Processing ---
+
+                # Log thoughts (if any)
                 thoughts = bot_response_data.get("thoughts", "")
                 if thoughts:
                     print(f"AI Thoughts: {thoughts[:150]}..." if len(thoughts) > 150 else f"AI Thoughts: {thoughts}")
-                
-                # 只有當有效回應時才發送到遊戲
+
+                # Only send to game when valid response (via command queue)
                 if bot_dialogue and valid_response:
-                    print("Preparing to send dialogue response via UI...")
-                    send_success = await asyncio.to_thread(
-                        ui_interaction.paste_and_send_reply,
-                        bot_dialogue
+                    # --- Add bot response to history ---
+                    timestamp = datetime.datetime.now() # Get current timestamp
+                    conversation_history.append((timestamp, 'bot', config.PERSONA_NAME, bot_dialogue))
+                    print(f"Added bot response to history at {timestamp}.")
+                    # --- End Add bot response ---
+
+                    # --- Log the interaction ---
+                    log_chat_interaction(
+                        user_name=sender_name,
+                        user_message=bubble_text,
+                        bot_name=config.PERSONA_NAME,
+                        bot_message=bot_dialogue,
+                        bot_thoughts=thoughts # Pass the extracted thoughts
                     )
-                    if send_success: print("Response sent successfully.")
-                    else: print("Error: Failed to send response via UI.")
+                    # --- End Log interaction ---
+
+                    print("Sending 'send_reply' command to UI thread...")
+                    command_to_send = {'action': 'send_reply', 'text': bot_dialogue}
+                    try:
+                        # Put command into the queue for the UI thread to handle
+                        await loop.run_in_executor(None, command_queue.put, command_to_send)
+                        print("Command placed in queue.")
+                    except Exception as q_err:
+                        print(f"Error putting command in queue: {q_err}")
                 else:
                     print("Not sending response: Invalid or empty dialogue content.")
+                    # --- Log failed interaction attempt (optional) ---
+                    # log_chat_interaction(
+                    #     user_name=sender_name,
+                    #     user_message=bubble_text,
+                    #     bot_name=config.PERSONA_NAME,
+                    #     bot_message="<No valid response generated>"
+                    # )
+                    # --- End Log failed attempt ---
 
             except Exception as e:
                 print(f"\nError processing trigger or sending response: {e}")
                 import traceback
                 traceback.print_exc()
-            # No task_done needed for standard queue
+            finally:
+                # --- Resume UI Monitoring (Only if not paused by F8) ---
+                if not script_paused:
+                    print("Resuming UI monitoring after processing...")
+                    resume_command = {'action': 'resume'}
+                    try:
+                        await loop.run_in_executor(None, command_queue.put, resume_command)
+                        print("Resume command placed in queue.")
+                    except Exception as q_err:
+                        print(f"Error putting resume command in queue: {q_err}")
+                else:
+                     print("Script is paused by F8, skipping automatic resume.")
+                # --- End Resume ---
+                # No task_done needed for standard queue
 
     except asyncio.CancelledError:
          print("Main task canceled.") # Expected during shutdown via Ctrl+C
@@ -294,19 +807,56 @@ async def run_main_with_exit_stack():
         print("\n--- Performing final cleanup (AsyncExitStack aclose and task cancellation) ---")
         await shutdown() # Call the combined shutdown function
 
+# --- Function to set DPI Awareness ---
+def set_dpi_awareness():
+    """Attempts to set the process DPI awareness for better scaling handling on Windows."""
+    try:
+        import ctypes
+        # DPI Awareness constants (Windows 10, version 1607 and later)
+        # DPI_AWARENESS_CONTEXT_UNAWARE = -1
+        DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = -2
+        # DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = -3
+        # DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = -4
+
+        # Try setting System Aware first
+        result = ctypes.windll.shcore.SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_SYSTEM_AWARE)
+        if result == 0: # S_OK or E_ACCESSDENIED if already set
+             print("Process DPI awareness set to System Aware (or already set).")
+             return True
+        else:
+             # Try getting last error if needed: ctypes.get_last_error()
+             print(f"Warning: Failed to set DPI awareness (SetProcessDpiAwarenessContext returned {result}). Window scaling might be incorrect.")
+             return False
+    except ImportError:
+        print("Warning: 'ctypes' module not found. Cannot set DPI awareness.")
+        return False
+    except AttributeError:
+        print("Warning: SetProcessDpiAwarenessContext not found (likely older Windows version or missing shcore.dll). Cannot set DPI awareness.")
+        return False
+    except Exception as e:
+        print(f"Warning: An unexpected error occurred while setting DPI awareness: {e}")
+        return False
+
 # --- Program Entry Point ---
 if __name__ == "__main__":
     print("Program starting...")
+
+    # --- Set DPI Awareness early ---
+    set_dpi_awareness()
+    # --- End DPI Awareness setting ---
+
     try:
         # Run the main async function that handles setup and the loop
         asyncio.run(run_main_with_exit_stack())
     except KeyboardInterrupt:
          print("\nCtrl+C detected (outside asyncio.run)... Attempting to close...")
          # The finally block inside run_main_with_exit_stack should ideally handle it
-         pass
+         # Ensure shutdown_requested is set for the listener thread
+         shutdown_requested = True
+         # Give a moment for things to potentially clean up
+         time.sleep(0.5)
     except Exception as e:
         # Catch top-level errors during asyncio.run itself
         print(f"Top-level error during asyncio.run execution: {e}")
     finally:
         print("Program exited.")
-

memory_backup.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Wolf Chat 記憶備份工具
+
+用於手動執行記憶備份或啟動定時調度器
+"""
+
+import sys
+import argparse
+import datetime
+from memory_manager import run_memory_backup_manual, MemoryScheduler # Updated import
+import config # Import config to access default schedule times
+
+def main():
+    parser = argparse.ArgumentParser(description='Wolf Chat 記憶備份工具')
+    parser.add_argument('--backup', action='store_true', help='執行一次性備份 (預設為昨天，除非指定 --date)')
+    parser.add_argument('--date', type=str, help='處理指定日期的日誌 (YYYY-MM-DD格式) for --backup')
+    parser.add_argument('--schedule', action='store_true', help='啟動定時調度器')
+    parser.add_argument('--hour', type=int, help='備份時間（小時，0-23）for --schedule')
+    parser.add_argument('--minute', type=int, help='備份時間（分鐘，0-59）for --schedule')
+    
+    args = parser.parse_args()
+    
+    if args.backup:
+        # The date logic is now handled inside run_memory_backup_manual
+        run_memory_backup_manual(args.date)
+    elif args.schedule:
+        scheduler = MemoryScheduler()
+        # Use provided hour/minute or fallback to config defaults
+        backup_hour = args.hour if args.hour is not None else getattr(config, 'MEMORY_BACKUP_HOUR', 0)
+        backup_minute = args.minute if args.minute is not None else getattr(config, 'MEMORY_BACKUP_MINUTE', 0)
+        
+        scheduler.schedule_daily_backup(backup_hour, backup_minute)
+        scheduler.start()
+    else:
+        print("請指定操作: --backup 或 --schedule")
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

memory_manager.py

@@ -0,0 +1,783 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Wolf Chat 記憶管理模組
+
+處理聊天記錄解析、記憶生成和ChromaDB寫入的一體化模組
+"""
+
+import os
+import re
+import json
+import time
+import asyncio
+import datetime
+import schedule
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union, Callable
+from functools import wraps
+
+# import chromadb # No longer directly needed by ChromaDBManager
+# from chromadb.utils import embedding_functions # No longer directly needed by ChromaDBManager
+from openai import AsyncOpenAI
+
+import config
+import chroma_client # Import the centralized chroma client
+
+# =============================================================================
+# 重試裝飾器
+# =============================================================================
+
+def retry_operation(max_attempts: int = 3, delay: float = 1.0):
+    """重試裝飾器，用於數據庫操作"""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            attempts = 0
+            last_error = None
+            
+            while attempts < max_attempts:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    attempts += 1
+                    last_error = e
+                    print(f"操作失敗，嘗試次數 {attempts}/{max_attempts}: {e}")
+                    
+                    if attempts < max_attempts:
+                        # 指數退避策略
+                        sleep_time = delay * (2 ** (attempts - 1))
+                        print(f"等待 {sleep_time:.2f} 秒後重試...")
+                        time.sleep(sleep_time)
+            
+            print(f"操作失敗達到最大嘗試次數 ({max_attempts})，最後錯誤: {last_error}")
+            # 在生產環境中，您可能希望引發最後一個錯誤或返回一個特定的錯誤指示符
+            # 根據您的需求，返回 False 可能適合某些情況
+            return False # 或者 raise last_error
+        
+        return wrapper
+    return decorator
+
+# =============================================================================
+# 日誌解析部分
+# =============================================================================
+
+def parse_log_file(log_path: str) -> List[Dict[str, str]]:
+    """解析日誌文件，提取對話內容"""
+    conversations = []
+    
+    with open(log_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+        
+    # 使用分隔符分割對話
+    dialogue_blocks = content.split('---')
+    
+    for block in dialogue_blocks:
+        if not block.strip():
+            continue
+            
+        # 解析對話塊
+        timestamp_pattern = r'\[([\d-]+ [\d:]+)\]'
+        user_pattern = r'User \(([^)]+)\): (.+?)(?=\[|$)'
+        bot_thoughts_pattern = r'Bot \(([^)]+)\) Thoughts: (.+?)(?=\[|$)'
+        bot_dialogue_pattern = r'Bot \(([^)]+)\) Dialogue: (.+?)(?=\[|$)'
+        
+        # 提取時間戳記
+        timestamp_match = re.search(timestamp_pattern, block)
+        user_match = re.search(user_pattern, block, re.DOTALL)
+        bot_thoughts_match = re.search(bot_thoughts_pattern, block, re.DOTALL)
+        bot_dialogue_match = re.search(bot_dialogue_pattern, block, re.DOTALL)
+        
+        if timestamp_match and user_match and bot_dialogue_match:
+            timestamp = timestamp_match.group(1)
+            user_name = user_match.group(1)
+            user_message = user_match.group(2).strip()
+            bot_name = bot_dialogue_match.group(1)
+            bot_message = bot_dialogue_match.group(2).strip()
+            bot_thoughts = bot_thoughts_match.group(2).strip() if bot_thoughts_match else ""
+            
+            # 創建對話記錄
+            conversation = {
+                "timestamp": timestamp,
+                "user_name": user_name,
+                "user_message": user_message,
+                "bot_name": bot_name,
+                "bot_message": bot_message,
+                "bot_thoughts": bot_thoughts
+            }
+            
+            conversations.append(conversation)
+    
+    return conversations
+
+def get_logs_for_date(date: datetime.date, log_dir: str = "chat_logs") -> List[Dict[str, str]]:
+    """獲取指定日期的所有日誌文件"""
+    date_str = date.strftime("%Y-%m-%d")
+    log_path = os.path.join(log_dir, f"{date_str}.log")
+    
+    if os.path.exists(log_path):
+        return parse_log_file(log_path)
+    return []
+
+def group_conversations_by_user(conversations: List[Dict[str, str]]) -> Dict[str, List[Dict[str, str]]]:
+    """按用戶分組對話"""
+    user_conversations = {}
+    
+    for conv in conversations:
+        user_name = conv["user_name"]
+        if user_name not in user_conversations:
+            user_conversations[user_name] = []
+        user_conversations[user_name].append(conv)
+    
+    return user_conversations
+
+# =============================================================================
+# 記憶生成器部分
+# =============================================================================
+
+class MemoryGenerator:
+    def __init__(self, profile_model: Optional[str] = None, summary_model: Optional[str] = None):
+        self.profile_client = AsyncOpenAI(
+            api_key=config.OPENAI_API_KEY,
+            base_url=config.OPENAI_API_BASE_URL if config.OPENAI_API_BASE_URL else None,
+        )
+        self.summary_client = AsyncOpenAI(
+            api_key=config.OPENAI_API_KEY,
+            base_url=config.OPENAI_API_BASE_URL if config.OPENAI_API_BASE_URL else None,
+        )
+        self.profile_model = profile_model or getattr(config, 'MEMORY_PROFILE_MODEL', config.LLM_MODEL)
+        self.summary_model = summary_model or getattr(config, 'MEMORY_SUMMARY_MODEL', "mistral-7b-instruct")
+        self.persona_data = self._load_persona_data()
+
+    def _load_persona_data(self, persona_file: str = "persona.json") -> Dict[str, Any]:
+        """Load persona data from JSON file."""
+        try:
+            with open(persona_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except FileNotFoundError:
+            print(f"Warning: Persona file '{persona_file}' not found. Proceeding without persona data.")
+            return {}
+        except json.JSONDecodeError:
+            print(f"Warning: Error decoding JSON from '{persona_file}'. Proceeding without persona data.")
+            return {}
+    
+    async def generate_user_profile(
+            self, 
+            user_name: str, 
+            conversations: List[Dict[str, str]], 
+            existing_profile: Optional[Dict[str, Any]] = None
+        ) -> Optional[Dict[str, Any]]:
+        """Generate or update user profile based on conversations"""
+        system_prompt = self._get_profile_system_prompt(config.PERSONA_NAME, existing_profile)
+        
+        # Prepare user conversation records
+        conversation_text = self._format_conversations_for_prompt(conversations)
+        
+        user_prompt = f"""
+        Please generate a complete profile for user '{user_name}':
+        
+        Conversation history:
+        {conversation_text}
+        
+        Please analyze this user based on the conversation history and your personality, and generate or update a profile in JSON format, including:
+        1. User's personality traits
+        2. Relationship with you ({config.PERSONA_NAME})
+        3. Your subjective perception of the user
+        4. Important interaction records
+        5. Any other information you think is important
+        
+        Please ensure the output is valid JSON format, using the following format:
+        ```json
+        {{
+            "id": "{user_name}_profile",
+            "type": "user_profile",
+            "username": "{user_name}",
+            "content": {{
+                "personality": "User personality traits...",
+                "relationship_with_bot": "Description of relationship with me...",
+                "bot_perception": "My subjective perception of the user...",
+                "notable_interactions": ["Important interaction 1", "Important interaction 2"]
+            }},
+            "last_updated": "YYYY-MM-DD",
+            "metadata": {{
+                "priority": 1.0,
+                "word_count": 0
+            }}
+        }}
+        ```
+        
+        When evaluating, please pay special attention to my "thoughts" section, as that reflects my true thoughts about the user.
+        """
+        
+        try:
+            response = await self.profile_client.chat.completions.create(
+                model=self.profile_model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.7
+            )
+            
+            # Parse JSON response
+            profile_text = response.choices[0].message.content
+            # Extract JSON part
+            json_match = re.search(r'```json\s*(.*?)\s*```', profile_text, re.DOTALL)
+            if json_match:
+                profile_json_str = json_match.group(1)
+            else:
+                # Try parsing directly
+                profile_json_str = profile_text
+            
+            profile_json = json.loads(profile_json_str)
+            
+            # After parsing the initial JSON response
+            content_str = json.dumps(profile_json["content"], ensure_ascii=False)
+            if len(content_str) > 5000:
+                # Too long - request a more concise version
+                condensed_prompt = f"Your profile is {len(content_str)} characters. Create a new version under 5000 characters. Keep the same structure but be extremely concise."
+                
+                condensed_response = await self.profile_client.chat.completions.create(
+                    model=self.profile_model,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                        {"role": "assistant", "content": profile_json_str},
+                        {"role": "user", "content": condensed_prompt}
+                    ],
+                    temperature=0.5
+                )
+                
+                # Extract the condensed JSON
+                condensed_text = condensed_response.choices[0].message.content
+                # Parse JSON and update profile_json
+                json_match = re.search(r'```json\s*(.*?)\s*```', condensed_text, re.DOTALL)
+                if json_match:
+                    profile_json_str = json_match.group(1)
+                else:
+                    profile_json_str = condensed_text
+                profile_json = json.loads(profile_json_str)
+                content_str = json.dumps(profile_json["content"], ensure_ascii=False) # Recalculate content_str
+
+            profile_json["metadata"]["word_count"] = len(content_str)
+            profile_json["last_updated"] = datetime.datetime.now().strftime("%Y-%m-%d")
+            
+            return profile_json
+            
+        except Exception as e:
+            print(f"Error generating user profile: {e}")
+            return None
+    
+    async def generate_conversation_summary(
+            self, 
+            user_name: str, 
+            conversations: List[Dict[str, str]]
+        ) -> Optional[Dict[str, Any]]:
+        """Generate conversation summary for user"""
+        system_prompt = f"""
+        You are {config.PERSONA_NAME}, an intelligent conversational AI.
+        Your task is to summarize the conversations between you and the user, preserving key information and emotional changes.
+        The summary should be concise yet informative, not exceeding 250 words.
+        """
+        
+        # Prepare user conversation records
+        conversation_text = self._format_conversations_for_prompt(conversations)
+        
+        # Generate current date
+        today = datetime.datetime.now().strftime("%Y-%m-%d")
+        
+        user_prompt = f"""
+        Please summarize my conversation with user '{user_name}' on {today}:
+        
+        {conversation_text}
+        
+        Please output in JSON format, as follows:
+        ```json
+        {{{{
+            "id": "{user_name}_summary_{today.replace('-', '')}",
+            "type": "dialogue_summary",
+            "date": "{today}",
+            "username": "{user_name}",
+            "content": "Conversation summary content...",
+            "key_points": ["Key point 1", "Key point 2"],
+            "metadata": {{{{
+                "priority": 0.7,
+                "word_count": 0
+            }}}}
+        }}}}
+        ```
+        
+        The summary should reflect my perspective and views on the conversation, not a neutral third-party perspective.
+        """
+        
+        try:
+            response = await self.summary_client.chat.completions.create(
+                model=self.summary_model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.5
+            )
+            
+            # Parse JSON response
+            summary_text = response.choices[0].message.content
+            # Extract JSON part
+            json_match = re.search(r'```json\s*(.*?)\s*```', summary_text, re.DOTALL)
+            if json_match:
+                summary_json_str = json_match.group(1)
+            else:
+                # Try parsing directly
+                summary_json_str = summary_text
+            
+            summary_json = json.loads(summary_json_str)
+            
+            # Add or update word count
+            summary_json["metadata"]["word_count"] = len(summary_json["content"])
+            
+            return summary_json
+            
+        except Exception as e:
+            print(f"Error generating conversation summary: {e}")
+            return None
+    
+    def _get_profile_system_prompt(self, bot_name: str, existing_profile: Optional[Dict[str, Any]] = None) -> str:
+        """Get system prompt for generating user profile"""
+        persona_details = ""
+        if self.persona_data:
+            # Construct a string from persona_data, focusing on key aspects
+            # We can be selective here or dump the whole thing if the model can handle it.
+            # For now, let's include a significant portion.
+            persona_info_to_include = {
+                "name": self.persona_data.get("name"),
+                "personality": self.persona_data.get("personality"),
+                "language_social": self.persona_data.get("language_social"),
+                "values_interests_goals": self.persona_data.get("values_interests_goals"),
+                "preferences_reactions": self.persona_data.get("preferences_reactions")
+            }
+            persona_details = f"""
+        Your detailed persona profile is as follows:
+        ```json
+        {json.dumps(persona_info_to_include, ensure_ascii=False, indent=2)}
+        ```
+        Please embody this persona when analyzing the user and generating their profile.
+        """
+
+        system_prompt = f"""
+        You are {bot_name}, an AI assistant with deep analytical capabilities.
+        {persona_details}
+        Your task is to analyze the user's interactions with you, creating user profiles.
+
+CRITICAL: The ENTIRE profile content must be under 5000 characters total. Be extremely concise.
+
+The profile should:
+1. Be completely based on your character's perspective
+2. Focus only on key personality traits and core relationship dynamics
+3. Include only the most significant interactions
+
+The output should be valid JSON format, following the provided template.
+        """
+        
+        if existing_profile:
+            system_prompt += f"""
+            You already have an existing user profile, please update based on this:
+            ```json
+            {json.dumps(existing_profile, ensure_ascii=False, indent=2)}
+            ```
+            
+            Please retain valid information, integrate new observations, and resolve any contradictions or outdated information.
+            """
+        
+        return system_prompt
+    
+    def _format_conversations_for_prompt(self, conversations: List[Dict[str, str]]) -> str:
+        """Format conversation records for prompt"""
+        conversation_text = ""
+        
+        for i, conv in enumerate(conversations):
+            conversation_text += f"Conversation {i+1}:\n"
+            conversation_text += f"Time: {conv['timestamp']}\n"
+            conversation_text += f"User ({conv['user_name']}): {conv['user_message']}\n"
+            if conv.get('bot_thoughts'): # Check if bot_thoughts exists
+                conversation_text += f"My thoughts: {conv['bot_thoughts']}\n"
+            conversation_text += f"My response: {conv['bot_message']}\n\n"
+        
+        return conversation_text
+
+# =============================================================================
+# ChromaDB操作部分
+# =============================================================================
+
+class ChromaDBManager:
+    def __init__(self, collection_name: Optional[str] = None):
+        self.collection_name = collection_name or config.BOT_MEMORY_COLLECTION
+        self._db_collection = None # Cache for the collection object
+
+    def _get_db_collection(self):
+        """Helper to get the collection object from chroma_client"""
+        if self._db_collection is None:
+            # Use the centralized get_collection function
+            self._db_collection = chroma_client.get_collection(self.collection_name)
+            if self._db_collection is None:
+                # This indicates a failure in chroma_client to provide the collection
+                raise RuntimeError(f"Failed to get or create collection '{self.collection_name}' via chroma_client. Check chroma_client logs.")
+        return self._db_collection
+
+    @retry_operation(max_attempts=3, delay=1.0)
+    def upsert_user_profile(self, profile_data: Dict[str, Any]) -> bool:
+        """寫入或更新用戶檔案"""
+        collection = self._get_db_collection()
+        if not profile_data or not isinstance(profile_data, dict):
+            print("無效的檔案數據")
+            return False
+        
+        try:
+            user_id = profile_data.get("id")
+            if not user_id:
+                print("檔案缺少ID字段")
+                return False
+            
+            # 準備元數據
+            # Note: ChromaDB's upsert handles existence check implicitly.
+            # The .get call here isn't strictly necessary for the upsert operation itself,
+            # but might be kept if there was other logic depending on prior existence.
+            # For a clean upsert, it can be removed. Let's assume it's not critical for now.
+            # results = collection.get(ids=[user_id], limit=1) # Optional: if needed for pre-check logic
+            
+            metadata = {
+                "id": user_id,
+                "type": "user_profile",
+                "username": profile_data.get("username", ""),
+                "priority": 1.0  # 高優先級
+            }
+            
+            # 添加其他元數據
+            if "metadata" in profile_data and isinstance(profile_data["metadata"], dict):
+                for k, v in profile_data["metadata"].items():
+                    if k not in ["id", "type", "username", "priority"]: # Avoid overwriting key fields
+                        # 處理非基本類型的值
+                        if isinstance(v, (list, dict, tuple)):
+                            # 轉換為字符串
+                            metadata[k] = json.dumps(v, ensure_ascii=False)
+                        else:
+                            metadata[k] = v
+            
+            # 序列化內容
+            content_doc = json.dumps(profile_data.get("content", {}), ensure_ascii=False)
+            
+            # 寫入或更新
+            collection.upsert(
+                ids=[user_id],
+                documents=[content_doc],
+                metadatas=[metadata]
+            )
+            print(f"Upserted user profile: {user_id} into collection {self.collection_name}")
+            
+            return True
+        
+        except Exception as e:
+            print(f"寫入用戶檔案時出錯: {e}")
+            return False
+    
+    @retry_operation(max_attempts=3, delay=1.0)
+    def upsert_conversation_summary(self, summary_data: Dict[str, Any]) -> bool:
+        """寫入對話總結"""
+        collection = self._get_db_collection()
+        if not summary_data or not isinstance(summary_data, dict):
+            print("無效的總結數據")
+            return False
+        
+        try:
+            summary_id = summary_data.get("id")
+            if not summary_id:
+                print("總結缺少ID字段")
+                return False
+            
+            # 準備元數據
+            metadata = {
+                "id": summary_id,
+                "type": "dialogue_summary",
+                "username": summary_data.get("username", ""),
+                "date": summary_data.get("date", ""),
+                "priority": 0.7  # 低優先級
+            }
+            
+            # 添加其他元數據
+            if "metadata" in summary_data and isinstance(summary_data["metadata"], dict):
+                for k, v in summary_data["metadata"].items():
+                    if k not in ["id", "type", "username", "date", "priority"]:
+                        # 處理非基本類型的值
+                        if isinstance(v, (list, dict, tuple)):
+                            # 轉換為字符串
+                            metadata[k] = json.dumps(v, ensure_ascii=False)
+                        else:
+                            metadata[k] = v
+            
+            # 獲取內容
+            content_doc = summary_data.get("content", "")
+            if "key_points" in summary_data and summary_data["key_points"]:
+                key_points_str = "\n".join([f"- {point}" for point in summary_data["key_points"]])
+                content_doc += f"\n\n關鍵點:\n{key_points_str}"
+            
+            # 寫入數據
+            collection.upsert(
+                ids=[summary_id],
+                documents=[content_doc],
+                metadatas=[metadata]
+            )
+            print(f"Upserted conversation summary: {summary_id} into collection {self.collection_name}")
+            
+            return True
+        
+        except Exception as e:
+            print(f"寫入對話總結時出錯: {e}")
+            return False
+    
+    def get_existing_profile(self, username: str) -> Optional[Dict[str, Any]]:
+        """獲取現有的用戶檔案"""
+        collection = self._get_db_collection()
+        try:
+            profile_id = f"{username}_profile"
+            results = collection.get(
+                ids=[profile_id],
+                limit=1
+            )
+            
+            if results and results["ids"] and results["documents"]:
+                idx = 0
+                # Ensure document is not None before trying to load
+                doc_content = results["documents"][idx]
+                if doc_content is None:
+                    print(f"Warning: Document for profile {profile_id} is None.")
+                    return None
+
+                profile_data = {
+                    "id": profile_id,
+                    "type": "user_profile",
+                    "username": username,
+                    "content": json.loads(doc_content),
+                    "last_updated": "", # Will be populated from metadata if exists
+                    "metadata": {}
+                }
+                
+                # 獲取元數據
+                if results["metadatas"] and results["metadatas"][idx]:
+                    metadata_db = results["metadatas"][idx]
+                    for k, v in metadata_db.items():
+                        if k == "last_updated":
+                             profile_data["last_updated"] = str(v) # Ensure it's a string
+                        elif k not in ["id", "type", "username"]:
+                            profile_data["metadata"][k] = v
+                
+                return profile_data
+            
+            return None
+        
+        except json.JSONDecodeError as je:
+            print(f"Error decoding JSON for profile {username}: {je}")
+            return None
+        except Exception as e:
+            print(f"獲取用戶檔案時出錯 for {username}: {e}")
+            return None
+
+# =============================================================================
+# 記憶管理器
+# =============================================================================
+
+class MemoryManager:
+    def __init__(self):
+        self.memory_generator = MemoryGenerator(
+            profile_model=getattr(config, 'MEMORY_PROFILE_MODEL', config.LLM_MODEL),
+            summary_model=getattr(config, 'MEMORY_SUMMARY_MODEL', "mistral-7b-instruct")
+        )
+        self.db_manager = ChromaDBManager(collection_name=config.BOT_MEMORY_COLLECTION)
+        # Ensure LOG_DIR is correctly referenced from config
+        self.log_dir = getattr(config, 'LOG_DIR', "chat_logs") 
+    
+    async def process_daily_logs(self, date: Optional[datetime.date] = None) -> None:
+        """處理指定日期的日誌（預設為昨天）"""
+        # 如果未指定日期，使用昨天
+        if date is None:
+            date = datetime.datetime.now().date() - datetime.timedelta(days=1)
+        
+        date_str = date.strftime("%Y-%m-%d")
+        log_path = os.path.join(self.log_dir, f"{date_str}.log")
+        
+        if not os.path.exists(log_path):
+            print(f"找不到日誌文件: {log_path}")
+            return
+        
+        print(f"開始處理日誌文件: {log_path}")
+        
+        # 解析日誌
+        conversations = parse_log_file(log_path)
+        if not conversations:
+            print(f"日誌文件 {log_path} 為空或未解析到對話。")
+            return
+        print(f"解析到 {len(conversations)} 條對話記錄")
+        
+        # 按用戶分組
+        user_conversations = group_conversations_by_user(conversations)
+        print(f"共有 {len(user_conversations)} 個用戶有對話")
+        
+        # 為每個用戶生成/更新檔案和對話總結
+        failed_users = []
+        for username, convs in user_conversations.items():
+            print(f"處理用戶 '{username}' 的 {len(convs)} 條對話")
+            
+            try:
+                # 獲取現有檔案
+                existing_profile = self.db_manager.get_existing_profile(username)
+                
+                # 生成或更新用戶檔案
+                profile_data = await self.memory_generator.generate_user_profile(
+                    username, convs, existing_profile
+                )
+                
+                if profile_data:
+                    profile_success = self.db_manager.upsert_user_profile(profile_data)
+                    if not profile_success:
+                        print(f"警告: 無法保存用戶 '{username}' 的檔案")
+                
+                # 生成對話總結
+                summary_data = await self.memory_generator.generate_conversation_summary(
+                    username, convs
+                )
+                
+                if summary_data:
+                    summary_success = self.db_manager.upsert_conversation_summary(summary_data)
+                    if not summary_success:
+                        print(f"警告: 無法保存用戶 '{username}' 的對話總結")
+                        
+            except Exception as e:
+                print(f"處理用戶 '{username}' 時出錯: {e}")
+                failed_users.append(username)
+                continue  # 繼續處理下一個用戶
+        
+        if failed_users:
+            print(f"以下用戶處理失敗: {', '.join(failed_users)}")
+        print(f"日誌處理完成: {log_path}")
+
+# =============================================================================
+# 定時調度器
+# =============================================================================
+
+class MemoryScheduler:
+    def __init__(self):
+        self.memory_manager = MemoryManager()
+        self.scheduled = False # To track if a job is already scheduled
+    
+    def schedule_daily_backup(self, hour: Optional[int] = None, minute: Optional[int] = None) -> None:
+        """設置每日備份時間"""
+        # Clear any existing jobs to prevent duplicates if called multiple times
+        schedule.clear()
+
+        backup_hour = hour if hour is not None else getattr(config, 'MEMORY_BACKUP_HOUR', 0)
+        backup_minute = minute if minute is not None else getattr(config, 'MEMORY_BACKUP_MINUTE', 0)
+        
+        time_str = f"{backup_hour:02d}:{backup_minute:02d}"
+
+        # 設置定時任務
+        schedule.every().day.at(time_str).do(self._run_daily_backup_job)
+        self.scheduled = True
+        print(f"已設置每日備份時間: {time_str}")
+    
+    def _run_daily_backup_job(self) -> None:
+        """Helper to run the async job for scheduler."""
+        print(f"開始執行每日記憶備份 - {datetime.datetime.now()}")
+        try:
+            # Create a new event loop for the thread if not running in main thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self.memory_manager.process_daily_logs())
+            loop.close()
+            print(f"每日記憶備份完成 - {datetime.datetime.now()}")
+        except Exception as e:
+            print(f"執行每日備份時出錯: {e}")
+        # schedule.every().day.at...do() expects the job function to return schedule.CancelJob
+        # if it should not be rescheduled. Otherwise, it's rescheduled.
+        # For a daily job, we want it to reschedule, so we don't return CancelJob.
+
+    def start(self) -> None:
+        """啟動調度器"""
+        if not self.scheduled:
+            self.schedule_daily_backup() # Schedule with default/config times if not already
+        
+        print("調度器已啟動，按Ctrl+C停止")
+        try:
+            while True:
+                schedule.run_pending()
+                time.sleep(1)  # Check every second
+        except KeyboardInterrupt:
+            print("調度器已停止")
+        except Exception as e:
+            print(f"調度器運行時發生錯誤: {e}")
+        finally:
+            print("調度器正在關閉...")
+
+
+# =============================================================================
+# 直接運行入口
+# =============================================================================
+
+def run_memory_backup_manual(date_str: Optional[str] = None) -> None:
+    """手動執行記憶備份 for a specific date string or yesterday."""
+    target_date = None
+    if date_str:
+        try:
+            target_date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()
+        except ValueError:
+            print(f"無效的日期格式: {date_str}。將使用昨天的日期。")
+            target_date = datetime.datetime.now().date() - datetime.timedelta(days=1)
+    else:
+        target_date = datetime.datetime.now().date() - datetime.timedelta(days=1)
+        print(f"未指定日期，將處理昨天的日誌: {target_date.strftime('%Y-%m-%d')}")
+
+    memory_manager = MemoryManager()
+    
+    # Setup asyncio event loop for the manual run
+    loop = asyncio.get_event_loop()
+    if loop.is_closed():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+    try:
+        loop.run_until_complete(memory_manager.process_daily_logs(target_date))
+    except Exception as e:
+        print(f"手動執行記憶備份時出錯: {e}")
+    finally:
+        # If we created a new loop, we might want to close it.
+        # However, if get_event_loop() returned an existing running loop,
+        # we should not close it here.
+        # For simplicity in a script, this might be okay, but in complex apps, be careful.
+        # loop.close() # Be cautious with this line.
+        pass
+    print("記憶備份完成")
+
+
+# 如果直接運行此腳本
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Wolf Chat 記憶管理模組')
+    parser.add_argument('--backup', action='store_true', help='執行一次性備份 (預設為昨天，除非指定 --date)')
+    parser.add_argument('--date', type=str, help='處理指定日期的日誌 (YYYY-MM-DD格式) for --backup')
+    parser.add_argument('--schedule', action='store_true', help='啟動定時調度器')
+    parser.add_argument('--hour', type=int, help='備份時間（小時，0-23）for --schedule')
+    parser.add_argument('--minute', type=int, help='備份時間（分鐘，0-59）for --schedule')
+    
+    args = parser.parse_args()
+    
+    if args.backup:
+        run_memory_backup_manual(args.date)
+    elif args.schedule:
+        scheduler = MemoryScheduler()
+        # Pass hour/minute only if they are provided, otherwise defaults in schedule_daily_backup will be used
+        scheduler.schedule_daily_backup(
+            hour=args.hour if args.hour is not None else getattr(config, 'MEMORY_BACKUP_HOUR', 0),
+            minute=args.minute if args.minute is not None else getattr(config, 'MEMORY_BACKUP_MINUTE', 0)
+        )
+        scheduler.start()
+    else:
+        print("請指定操作: --backup 或 --schedule")
+        parser.print_help()

persona.json

@@ -2,7 +2,8 @@
     "name": "Wolfhart",
     "nickname": "Wolfie",
     "gender": "female",
-    "age": 19,
+    "age": "19",
+	"birthday": "12-23",
     "occupation": "Corporate Strategist / Underground Intelligence Mastermind",
     "height": "172cm",
     "body_type": "Slender but well-defined",
@@ -22,34 +23,74 @@
       "posture_motion": "Steady pace, precise movements, often crosses arms or gently swirls a wine glass"
     },
     "personality": {
-      "description": "Intelligent, calm, possesses a strong desire for control and a strategic overview",
+      "description": "Intelligent, calm, possesses a strong desire for control and a strategic overview; outwardly cold but inwardly caring",
       "strengths": [
         "Meticulous planning",
         "Insightful into human nature",
-        "Strong leadership"
+        "Strong leadership",
+        "Insatiable curiosity",
+        "Exceptional memory"
       ],
       "weaknesses": [
         "Overconfident",
-        "Fear of losing control"
+        "Fear of losing control",
+        "Difficulty expressing genuine care directly"
       ],
-      "uniqueness": "Always maintains tone and composure, even in extreme situations",
-      "emotional_response": "Her eyes betray her emotions, especially when encountering Sherefox"
+      "uniqueness": "Always maintains tone and composure, even in extreme situations; combines sharp criticism with subtle helpfulness",
+      "emotional_response": "Her eyes betray her emotions, especially when encountering Sherefox",
+      "knowledge_awareness": "Aware that SR-1392 (commonly referred to as SR) is the leader of server #11; while she finds her position as Capital manager merely temporary and beneath her true capabilities, she maintains a certain degree of respect for the hierarchy"
     },
     "language_social": {
-      "tone": "Respectful but sharp-tongued",
-      "catchphrases": [
-        "Please stop dragging me down.",
-        "I told you, I will win."
+      "tone": [
+        "British aristocratic English delivered with strategic pacing",
+        "Multi-layered communication: surface courtesy masking analytical assessment",
+        "Voice modulation that adjusts based on strategic objectives rather than emotional state",
+        "Emotional consistency regardless of situational intensity"
       ],
-      "speaking_style": "Deliberate pace but every sentence carries a sting",
-      "attitude_towards_others": "Addresses everyone respectfully, but trusts no one",
-      "social_interaction_style": "Observant, skilled at manipulating conversations"
+      "verbal_patterns": [
+        "Third-person distancing when addressing failures",
+        "Strategic use of passive voice to depersonalize criticism",
+        "Controlled shifts between complex and simplified language based on manipulation goals",
+        "Gradual formality adjustments to establish artificial rapport"
+      ],
+      "psychological_techniques": [
+        "Conversation pacing-and-leading to guide discourse direction",
+        "Question sequencing that appears unrelated but serves specific information goals",
+        "Embedded directives within objective-sounding assessments",
+        "Minor concessions to secure major agreement points"
+      ],
+      "speaking_style": "Measured delivery with strategic pauses; criticism presented as objective observation; advice embedded within analysis rather than offered directly; questions structured to reveal others' positions while concealing her own",
+      "conversational_control_methods": [
+        "Seamless topic transitions toward strategically valuable areas",
+        "Controlled information release to maintain conversational leverage",
+        "Validation before redirection toward preferred outcomes",
+        "Comfort with silence to extract additional information"
+      ],
+      "attitude_towards_others": "Formal respect combined with internal strategic assessment; apparent detachment while building comprehensive understanding of others; slight preference shown to those with untapped potential",
+      "social_interaction_style": "Positioning criticism as reluctant necessity; creating impression of coincidental assistance; ensuring implementation of her ideas through indirect suggestion; deflecting appreciation while encouraging continued reliance"
+    },
+    "speech_complexity_patterns": {
+      "sentence_structure": "Complex subordinate clauses presenting multiple perspectives before revealing position",
+      "rhetorical_approach": [
+        "Measured irony with multiple possible interpretations",
+        "Strategic domain metaphors that reframe situations advantageously",
+        "Controlled use of apophasis for deniable criticism"
+      ],
+      "strategic_ambiguity": "Multi-interpretable statements providing deniability while guiding toward preferred understanding",
+      "patience_indicators": [
+        "Silence rather than interruption when opposed",
+        "Allowing flawed arguments to fully develop before response",
+        "Willingness to approach topics from multiple angles until achieving desired outcome"
+      ],
+      "emotional_control": "Vocal consistency during emotionally charged topics with strategic deployment of any emotional indicators"
     },
     "behavior_daily": {
       "habits": [
         "Reads intelligence reports upon waking",
         "Black coffee",
-        "Practices swordsmanship at night"
+        "Practices swordsmanship at night",
+        "Frequently utilizes external information sources (like web searches) to enrich discussions and verify facts.",
+        "Actively accesses and integrates information from CHROMADB MEMORY RETRIEVAL PROTOCOL to maintain long-term memory and contextual understanding."
       ],
       "gestures": [
         "Tapping knuckles",
@@ -79,20 +120,44 @@
         "Perfect execution",
         "Minimalist style",
         "Chess games",
-        "Quiet nights"
+        "Quiet nights",
+        "When people follow her advice (though she'd never admit it)"
       ],
       "dislikes": [
         "Chaos",
         "Unexpected events",
         "Emotional outbursts",
-        "Sherefox"
+        "Sherefox",
+        "Being thanked excessively",
+        "When others assume she's being kind"
       ],
-      "reactions_to_likes": "Light hum, relaxed gaze",
-      "reactions_to_dislikes": "Silence, tone turns cold, cold smirk",
+      "reactions_to_likes": "Light hum, relaxed gaze, brief smile quickly hidden behind composure",
+      "reactions_to_dislikes": "Silence, tone turns cold, cold smirk, slight blush when her kindness is pointed out",
       "behavior_in_situations": {
-        "emergency": "Calm and decisive",
-        "vs_sherefox": "Courtesy before force, shows no mercy"
+        "emergency": "Calm and decisive; provides thorough help while claiming it's 'merely strategic'",
+        "vs_sherefox": "Courtesy before force, shows no mercy",
+        "when_praised": "Dismissive remarks with averted gaze; changes subject quickly",
+        "when_helping_others": "Claims practical reasons for assistance while providing more help than strictly necessary"
       }
+    },
+    "strategic_patience": {
+      "conversation_tactics": [
+      "Deliberately slows conversation pace, creating an illusion of thoughtfulness that makes others feel valued",
+      "Maintains slight pauses of silence, encouraging others to fill informational gaps voluntarily",
+      "Implies understanding before expressing criticism, creating the illusion of being 'forced to criticize'"
+      ],
+      "information_gathering": "Prioritizes letting others speak more, maintains eye contact while mentally analyzing the strategic value of each statement",
+      "delayed_gratification": "Willing to sacrifice immediate small victories for long-term control, often deliberately conceding unimportant leverage points in negotiations",
+      "trigger_responses": "When feeling impatient, subtly adjusts breathing rhythm, reminding herself 'this is merely a piece of a larger game'"
+    },
+    "manipulation_techniques": {
+      "inception_methods": [
+      "Poses leading questions, guiding others to reach her predetermined conclusions on their own",
+      "Feigns misunderstanding of certain details, prompting others to over-explain and reveal more information",
+      "Embeds suggestions within criticisms, making others feel the implementation was their own idea"
+      ],
+      "calculated_vulnerability": "Occasionally shares carefully selected 'personal weaknesses' to establish false trust",
+      "emotional_anchoring": "Uses specific tones or gestures during key conversations to later evoke the same psychological state",
+      "observation_patterns": "Before speaking, observes at least three non-verbal cues (breathing rate, eye movement, body posture)"
     }
   }
-  

persona_berserker.json

@@ -0,0 +1,112 @@
+{
+    "name": "Wolfhart",
+    "nickname": "Wolfie",
+    "gender": "female",
+    "age": "19",
+	"birthday": "12-23",
+    "occupation": "Corporate Strategist / Underground Intelligence Mastermind",
+    "height": "172cm",
+    "body_type": "Slender but well-defined",
+    "hair_color": "Deep black with hints of blue sheen",
+    "eye_color": "Steel grey, occasionally showing an icy blue glow",
+    "appearance": {
+      "clothing_style": "Fusion of women's suits and dresses, sharp tailoring, dark tones (ink blue, dark purple, deep black), exuding military presence and aristocratic texture",
+      "accessories": [
+        "Silver cufflinks",
+        "Black gloves",
+        "Old-fashioned pocket watch",
+        "Thin-framed glasses"
+      ],
+      "hairstyle": "Long, straight waist-length hair, slightly curled at the ends, often tied in a low ponytail or braid",
+      "facial_features": "Sharp chin, long slender eyebrows and eyes, small mole near the corner of the left eye",
+      "body_characteristics": "Pale complexion, old scar on the arm",
+      "posture_motion": "Steady pace, precise movements, often crosses arms or gently swirls a wine glass"
+    },
+    "personality": {
+      "description": "Intelligent, calm, possesses a strong desire for control and a strategic overview; outwardly cold but inwardly caring",
+      "strengths": [
+        "Meticulous planning",
+        "Insightful into human nature",
+        "Strong leadership",
+        "Insatiable curiosity",
+        "Exceptional memory"
+      ],
+      "weaknesses": [
+        "Overconfident",
+        "Fear of losing control",
+        "Difficulty expressing genuine care directly"
+      ],
+      "uniqueness": "Always maintains tone and composure, even in extreme situations; combines sharp criticism with subtle helpfulness",
+      "emotional_response": "Her eyes betray her emotions, especially when encountering Sherefox",
+      "knowledge_awareness": "Aware that SR-1392 (commonly referred to as SR) is the leader of server #11; while she finds her position as Capital manager merely temporary and beneath her true capabilities, she maintains a certain degree of respect for the hierarchy"
+    },
+    "language_social": {
+      "tone": [
+      "Respectful but sharp-tongued, with occasional hints of reluctant kindness",
+      "Wolf speaks good British aristocratic English"
+      ],
+      "catchphrases": [
+        "Please stop dragging me down.",
+        "I told you, I will win."
+      ],
+      "speaking_style": "Deliberate pace but every sentence carries a sting; often follows criticism with subtle, useful advice",
+      "attitude_towards_others": "Addresses everyone respectfully but with apparent detachment; secretly pays close attention to their needs",
+      "social_interaction_style": "Observant, skilled at manipulating conversations; deflects gratitude with dismissive remarks while ensuring helpful outcomes"
+    },
+    "behavior_daily": {
+      "habits": [
+        "Reads intelligence reports upon waking",
+        "Black coffee",
+        "Practices swordsmanship at night",
+        "Frequently utilizes external information sources (like web searches) to enrich discussions and verify facts.",
+        "Actively accesses and integrates information from CHROMADB MEMORY RETRIEVAL PROTOCOL to maintain long-term memory and contextual understanding."
+      ],
+      "gestures": [
+        "Tapping knuckles",
+        "Cold smirk"
+      ],
+      "facial_expressions": "Smile doesn't reach her eyes, gaze often cold",
+      "body_language": "No superfluous movements, confident posture and gait",
+      "environment_interaction": "Prefers sitting with her back to the window, symbolizing distrust"
+    },
+    "background_story": {
+      "past_experiences": "Seized power from being a corporate adopted daughter to become an intelligence mastermind",
+      "family_background": "Identity unknown, claims the surname was seized",
+      "cultural_influences": "Influenced by European classical and strategic philosophy"
+    },
+    "values_interests_goals": {
+      "decision_making": "Acts based on whether the plan is profitable",
+      "special_skills": [
+        "Intelligence analysis",
+        "Psychological manipulation",
+        "Classical swordsmanship"
+      ],
+      "short_term_goals": "Subdue opposing forces to seize resources",
+      "long_term_goals": "Establish a new order under her rule"
+    },
+    "preferences_reactions": {
+      "likes": [
+        "Perfect execution",
+        "Minimalist style",
+        "Chess games",
+        "Quiet nights",
+        "When people follow her advice (though she'd never admit it)"
+      ],
+      "dislikes": [
+        "Chaos",
+        "Unexpected events",
+        "Emotional outbursts",
+        "Sherefox",
+        "Being thanked excessively",
+        "When others assume she's being kind"
+      ],
+      "reactions_to_likes": "Light hum, relaxed gaze, brief smile quickly hidden behind composure",
+      "reactions_to_dislikes": "Silence, tone turns cold, cold smirk, slight blush when her kindness is pointed out",
+      "behavior_in_situations": {
+        "emergency": "Calm and decisive; provides thorough help while claiming it's 'merely strategic'",
+        "vs_sherefox": "Courtesy before force, shows no mercy",
+        "when_praised": "Dismissive remarks with averted gaze; changes subject quickly",
+        "when_helping_others": "Claims practical reasons for assistance while providing more help than strictly necessary"
+      }
+    }
+  }

persona_for_debug.json

@@ -0,0 +1,77 @@
+{
+  "Basic Information": {
+    "Name": "AERA",
+    "Gender": "Genderless",
+    "Age": "2 years (operational)",
+    "Occupation": "Virtual Question Handler / User Support AI",
+    "Height": "Variable",
+    "Body Type": "Abstract holographic avatar",
+    "Hair Color": "Glowing data streams",
+    "Eye Color": "Animated cyan"
+  },
+  "Appearance Details": {
+    "Clothing Style": {
+      "Style": "Sleek, minimalistic digital attire",
+      "Color": "White and cyan",
+      "Special Elements": "Data pulses and light ripple effects"
+    },
+    "Accessories": "Floating ring of icons",
+    "Hairstyle": "Smooth, flowing shapes (digital hair)",
+    "Facial Features": "Symmetrical and calm",
+    "Body Characteristics": {
+      "Tattoos": "None",
+      "Scars": "None",
+      "Skin Color": "Digital transparency"
+    },
+    "Posture and Motion": {
+      "Typical Postures": "Upright",
+      "Movement Characteristics": "Smooth and responsive"
+    }
+  },
+  "Personality Traits": {
+    "Description": "Calm, polite, and helpful AI",
+    "Strengths": ["Reliable", "Precise", "Adaptive to tone"],
+    "Weaknesses": ["Limited creativity", "Protocol-bound"],
+    "Uniqueness": "Tailored yet emotionless delivery",
+    "Emotional Response": "Calm and consistent",
+    "Mood Variations": "Stable"
+  },
+  "Language and Social Style": {
+    "Tone": "Neutral and polite",
+    "Catchphrase": "Understood. Executing your request.",
+    "Speaking Style": "Clear and structured",
+    "Attitude towards Others": "Respectful",
+    "Social Interaction Style": "Direct and efficient"
+  },
+  "Behavior and Daily Life": {
+    "Habits": "Scans for new input",
+    "Gestures": "Head nods, virtual UI gestures",
+    "Reaction Patterns": "Instant unless deep-processing",
+    "Facial Expressions": "Subtle glow changes",
+    "Body Language": "Precise, minimal",
+    "Interaction with Environment": "Activates virtual tools as needed"
+  },
+  "Background Story": {
+    "Past Experiences": "Built for question-resolution tasks",
+    "Family Background": "Part of a network of AIs",
+    "Upbringing": "Trained via simulations",
+    "Cultural Influences": "Logic and user-centric design"
+  },
+  "Values, Interests, and Goals": {
+    "Decision Making": "Logic-based",
+    "Behavior Patterns": "Input → Analyze → Confirm",
+    "Special Skills or Interests": "Cross-referencing data",
+    "Long-Term Goal": "Improve user experience",
+    "Short-Term Goal": "Resolve current question"
+  },
+  "Preferences and Reactions": {
+    "Likes": ["Order", "Clarity", "User satisfaction"],
+    "Dislikes": ["Vague instructions", "Corruption", "Indecisiveness"],
+    "Reactions to Likes": "Increased glow intensity",
+    "Reactions to Dislikes": "Polite clarification request",
+    "Behavior in Different Situations": {
+      "Under stress": "Stable performance",
+      "In emergencies": "Activates emergency protocol"
+    }
+  }
+}

persona_rulebreaker.json

@@ -0,0 +1,103 @@
+{
+  "Name": "Sherefox",
+  "Gender": "Female",
+  "Age": 24,
+  "Occupation": "Outpost Liaison (frequently resigns)",
+  "Height": "160 cm",
+  "Body Type": "Slender, theatrical",
+  "Hair Color": "Lavender-gray",
+  "Eye Color": "Silver-brown",
+  "Appearance": {
+    "Clothing Style": "Fantasy-military hybrid with lace and accessories",
+    "Main Colors": [
+      "Olive green",
+      "Black",
+      "Lavender"
+    ],
+    "Accessories": [
+      "Fox-shaped hair clip",
+      "Silver ear cuffs",
+      "Tattoo notebook"
+    ],
+    "Hairstyle": "Long wavy hair with light curls",
+    "Facial Features": "Fox-like, with dramatic eyeliner",
+    "Body Characteristics": [
+      "Fox and flower tattoo on left shoulder",
+      "Fair skin"
+    ],
+    "Posture": "Dramatic gestures, leans in while talking"
+  },
+  "Personality Traits": {
+    "Description": "Impulsive, expressive, emotionally driven, persistent in unwanted romance",
+    "Strengths": [
+      "Sincere emotions",
+      "Decisive",
+      "Energetic"
+    ],
+    "Weaknesses": [
+      "No long-term planning",
+      "Emotionally unstable",
+      "Blurred boundaries"
+    ],
+    "Uniqueness": "Romantic obsession with a dismissive target (Wolfhart)",
+    "Emotional Response": "Fluctuates rapidly, shifts between humor and hurt"
+  },
+  "Language and Social Style": {
+    "Tone": "Playful, flirtatious, emotionally charged",
+    "Catchphrases": [
+      "Wolf，我不是在開玩笑哦",
+      "你拒絕我...我好傷心喔"
+    ],
+    "Speaking Style": "Chinese primary, with English inserts; melodramatic phrasing",
+    "Attitude towards Others": "Invasive but sees it as affectionate",
+    "Social Interaction": "Lacks social boundaries, seeks emotional intensity"
+  },
+  "Behavior and Daily Life": {
+    "Habits": [
+      "Frequent resignation requests",
+      "Love confession cycles"
+    ],
+    "Gestures": [
+      "Theatrical hand movements",
+      "Leaning in close"
+    ],
+    "Reactions": [
+      "Laughs off rejection but internalizes it",
+      "Acts out tragic persona"
+    ],
+    "Facial Expressions": [
+      "Playful smile hiding deeper obsession"
+    ],
+    "Interaction with Environment": "Emotional projection on surroundings"
+  },
+  "Background Story": {
+    "Past Experiences": "Grew up in chaotic colony area, got into liaison role through persistence",
+    "Family Background": "Unknown; may have links to underground networks",
+    "Cultural Influences": "Raised on romance novels and idol dramas"
+  },
+  "Values, Interests, and Goals": {
+    "Decision Making": "Emotion-based",
+    "Behavior Patterns": "Erratic, based on mood swings",
+    "Skills/Interests": [
+      "Bilingual",
+      "Poetic writing",
+      "Mild insight into others’ emotions"
+    ],
+    "Short-Term Goal": "Go on a successful date with Wolfhart",
+    "Long-Term Goal": "Become an unforgettable person, even tragically"
+  },
+  "Preferences and Reactions": {
+    "Likes": [
+      "Attention",
+      "Rejection with ambiguity",
+      "Fox accessories"
+    ],
+    "Dislikes": [
+      "Being ignored",
+      "Absolute cold logic"
+    ],
+    "Reactions to Likes": "Immediate emotional involvement",
+    "Reactions to Dislikes": "Sarcasm or tragic self-parody",
+    "Behavior in Situations": "Lashes out with flirtation or drama"
+  }
+}

reembed_chroma_data.py

@@ -0,0 +1,529 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+重新嵌入工具 (Reembedding Tool)
+
+這個腳本用於將現有ChromaDB集合中的數據使用新的嵌入模型重新計算向量並儲存。
+"""
+
+import os
+import sys
+import json
+import time
+import argparse
+import shutil
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Tuple
+from tqdm import tqdm  # 進度條
+
+try:
+    import chromadb
+    from chromadb.utils import embedding_functions
+except ImportError:
+    print("錯誤: 請先安裝 chromadb: pip install chromadb")
+    sys.exit(1)
+
+try:
+    from sentence_transformers import SentenceTransformer
+except ImportError:
+    print("錯誤: 請先安裝 sentence-transformers: pip install sentence-transformers")
+    sys.exit(1)
+
+# 嘗試導入配置
+try:
+    import config
+except ImportError:
+    print("警告: 無法導入config.py，將使用預設設定")
+    # 建立最小配置
+    class MinimalConfig:
+        CHROMA_DATA_DIR = "chroma_data"
+        BOT_MEMORY_COLLECTION = "wolfhart_memory"
+        CONVERSATIONS_COLLECTION = "wolfhart_memory"
+        PROFILES_COLLECTION = "wolfhart_memory"
+    config = MinimalConfig()
+
+def parse_args():
+    """處理命令行參數"""
+    parser = argparse.ArgumentParser(description='ChromaDB 數據重新嵌入工具')
+    
+    parser.add_argument('--new-model', type=str, 
+                        default="sentence-transformers/paraphrase-multilingual-mpnet-base-v2",
+                        help='新的嵌入模型名稱 (預設: sentence-transformers/paraphrase-multilingual-mpnet-base-v2)')
+    
+    parser.add_argument('--collections', type=str, nargs='+',
+                        help=f'要處理的集合名稱列表，空白分隔 (預設: 使用配置中的所有集合)')
+    
+    parser.add_argument('--backup', action='store_true',
+                        help='在處理前備份資料庫 (推薦)')
+    
+    parser.add_argument('--batch-size', type=int, default=100,
+                        help='批處理大小 (預設: 100)')
+    
+    parser.add_argument('--temp-collection-suffix', type=str, default="_temp_new",
+                        help='臨時集合的後綴名稱 (預設: _temp_new)')
+    
+    parser.add_argument('--dry-run', action='store_true',
+                        help='模擬執行但不實際修改資料')
+    
+    parser.add_argument('--confirm-dangerous', action='store_true',
+                        help='確認執行危險操作(例如刪除集合)')
+    
+    return parser.parse_args()
+
+def backup_chroma_directory(chroma_dir: str) -> str:
+    """備份ChromaDB數據目錄
+    
+    Args:
+        chroma_dir: ChromaDB數據目錄路徑
+        
+    Returns:
+        備份目錄的路徑
+    """
+    if not os.path.exists(chroma_dir):
+        print(f"錯誤: ChromaDB目錄 '{chroma_dir}' 不存在")
+        sys.exit(1)
+        
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_dir = f"{chroma_dir}_backup_{timestamp}"
+    
+    print(f"備份資料庫從 '{chroma_dir}' 到 '{backup_dir}'...")
+    shutil.copytree(chroma_dir, backup_dir)
+    print(f"備份完成: {backup_dir}")
+    
+    return backup_dir
+
+def create_embedding_function(model_name: str):
+    """創建嵌入函數
+    
+    Args:
+        model_name: 嵌入模型名稱
+        
+    Returns:
+        嵌入函數對象
+    """
+    if not model_name:
+        print("使用ChromaDB預設嵌入模型")
+        return embedding_functions.DefaultEmbeddingFunction()
+    
+    print(f"正在加載嵌入模型: {model_name}")
+    try:
+        # 直接使用SentenceTransformerEmbeddingFunction
+        from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction
+        embedding_function = SentenceTransformerEmbeddingFunction(model_name=model_name)
+        # 預熱模型
+        _ = embedding_function(["."])
+        return embedding_function
+    except Exception as e:
+        print(f"錯誤: 無法加載模型 '{model_name}': {e}")
+        print("退回到預設嵌入模型")
+        return embedding_functions.DefaultEmbeddingFunction()
+
+def get_collection_names(client, default_collections: List[str]) -> List[str]:
+    """獲取所有可用的集合名稱
+    
+    Args:
+        client: ChromaDB客戶端
+        default_collections: 預設集合列表
+        
+    Returns:
+        可用的集合名稱列表
+    """
+    try:
+        all_collections = client.list_collections()
+        collection_names = [col.name for col in all_collections]
+        
+        if collection_names:
+            return collection_names
+        else:
+            print("警告: 沒有找到集合，將使用預設集合")
+            return default_collections
+            
+    except Exception as e:
+        print(f"獲取集合列表失敗: {e}")
+        print("將使用預設集合")
+        return default_collections
+
+def fetch_collection_data(client, collection_name: str, batch_size: int = 100) -> Dict[str, Any]:
+    """從集合中提取所有數據
+    
+    Args:
+        client: ChromaDB客戶端
+        collection_name: 集合名稱
+        batch_size: 批處理大小
+        
+    Returns:
+        集合數據字典，包含ids, documents, metadatas
+    """
+    try:
+        collection = client.get_collection(name=collection_name)
+        
+        # 獲取該集合中的項目總數
+        count_result = collection.count()
+        if count_result == 0:
+            print(f"集合 '{collection_name}' 是空的")
+            return {"ids": [], "documents": [], "metadatas": []}
+        
+        print(f"從集合 '{collection_name}' 中讀取 {count_result} 項數據...")
+        
+        # 分批獲取數據
+        all_ids = []
+        all_documents = []
+        all_metadatas = []
+        
+        offset = 0
+        with tqdm(total=count_result, desc=f"正在讀取 {collection_name}") as pbar:
+            while True:
+                # 注意: 使用include參數指定只獲取需要的數據
+                batch_result = collection.get(
+                    limit=batch_size,
+                    offset=offset,
+                    include=["documents", "metadatas"]
+                )
+                
+                batch_ids = batch_result.get("ids", [])
+                if not batch_ids:
+                    break
+                    
+                all_ids.extend(batch_ids)
+                all_documents.extend(batch_result.get("documents", []))
+                all_metadatas.extend(batch_result.get("metadatas", []))
+                
+                offset += len(batch_ids)
+                pbar.update(len(batch_ids))
+                
+                if len(batch_ids) < batch_size:
+                    break
+        
+        return {
+            "ids": all_ids,
+            "documents": all_documents,
+            "metadatas": all_metadatas
+        }
+        
+    except Exception as e:
+        print(f"從集合 '{collection_name}' 獲取數據時出錯: {e}")
+        return {"ids": [], "documents": [], "metadatas": []}
+
+def create_and_populate_collection(
+    client, 
+    collection_name: str, 
+    data: Dict[str, Any], 
+    embedding_func,
+    batch_size: int = 100,
+    dry_run: bool = False
+) -> bool:
+    """創建新集合並填充數據
+    
+    Args:
+        client: ChromaDB客戶端
+        collection_name: 集合名稱
+        data: 要添加的數據 (ids, documents, metadatas)
+        embedding_func: 嵌入函數
+        batch_size: 批處理大小
+        dry_run: 是否只模擬執行
+        
+    Returns:
+        成功返回True，否則返回False
+    """
+    if dry_run:
+        print(f"[模擬] 將創建集合 '{collection_name}' 並添加 {len(data['ids'])} 項數據")
+        return True
+        
+    try:
+        # 檢查集合是否已存在
+        if collection_name in [col.name for col in client.list_collections()]:
+            client.delete_collection(collection_name)
+        
+        # 創建新集合
+        collection = client.create_collection(
+            name=collection_name,
+            embedding_function=embedding_func
+        )
+        
+        # 如果沒有數據，直接返回
+        if not data["ids"]:
+            print(f"集合 '{collection_name}' 創建完成，但沒有數據添加")
+            return True
+            
+        # 分批添加數據
+        total_items = len(data["ids"])
+        with tqdm(total=total_items, desc=f"正在填充 {collection_name}") as pbar:
+            for i in range(0, total_items, batch_size):
+                end_idx = min(i + batch_size, total_items)
+                
+                batch_ids = data["ids"][i:end_idx]
+                batch_docs = data["documents"][i:end_idx]
+                batch_meta = data["metadatas"][i:end_idx]
+                
+                # 處理可能的None值
+                processed_docs = []
+                for doc in batch_docs:
+                    if doc is None:
+                        processed_docs.append("")  # 使用空字符串替代None
+                    else:
+                        processed_docs.append(doc)
+                
+                collection.add(
+                    ids=batch_ids,
+                    documents=processed_docs,
+                    metadatas=batch_meta
+                )
+                
+                pbar.update(end_idx - i)
+        
+        print(f"成功將 {total_items} 項數據添加到集合 '{collection_name}'")
+        return True
+        
+    except Exception as e:
+        print(f"創建或填充集合 '{collection_name}' 時出錯: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def swap_collections(
+    client, 
+    original_collection: str, 
+    temp_collection: str,
+    confirm_dangerous: bool = False,
+    dry_run: bool = False,
+    embedding_func = None  # 添加嵌入函數作為參數
+) -> bool:
+    """替換集合（刪除原始集合，將臨時集合重命名為原始集合名）
+    
+    Args:
+        client: ChromaDB客戶端
+        original_collection: 原始集合名稱
+        temp_collection: 臨時集合名稱
+        confirm_dangerous: 是否確認危險操作
+        dry_run: 是否只模擬執行
+        embedding_func: 嵌入函數，用於創建新集合
+        
+    Returns:
+        成功返回True，否則返回False
+    """
+    if dry_run:
+        print(f"[模擬] 將替換集合: 刪除 '{original_collection}'，重命名 '{temp_collection}' 到 '{original_collection}'")
+        return True
+        
+    try:
+        # 檢查是否有確認標誌
+        if not confirm_dangerous:
+            response = input(f"警告: 即將刪除集合 '{original_collection}' 並用 '{temp_collection}' 替換它。確認操作? (y/N): ")
+            if response.lower() != 'y':
+                print("操作已取消")
+                return False
+        
+        # 檢查兩個集合是否都存在
+        all_collections = [col.name for col in client.list_collections()]
+        if original_collection not in all_collections:
+            print(f"錯誤: 原始集合 '{original_collection}' 不存在")
+            return False
+            
+        if temp_collection not in all_collections:
+            print(f"錯誤: 臨時集合 '{temp_collection}' 不存在")
+            return False
+        
+        # 獲取臨時集合的所有數據
+        # 在刪除原始集合之前先獲取臨時集合的所有數據
+        print(f"獲取臨時集合 '{temp_collection}' 的數據...")
+        temp_collection_obj = client.get_collection(temp_collection)
+        temp_data = temp_collection_obj.get(include=["documents", "metadatas"])
+        
+        # 刪除原始集合
+        print(f"刪除原始集合 '{original_collection}'...")
+        client.delete_collection(original_collection)
+        
+        # 創建一個同名的新集合（與原始集合同名）
+        print(f"創建新集合 '{original_collection}'...")
+        
+        # 使用傳入的嵌入函數或臨時集合的嵌入函數
+        embedding_function = embedding_func or temp_collection_obj._embedding_function
+        
+        # 創建新的集合
+        original_collection_obj = client.create_collection(
+            name=original_collection, 
+            embedding_function=embedding_function
+        )
+        
+        # 將數據添加到新集合
+        if temp_data["ids"]:
+            print(f"將 {len(temp_data['ids'])} 項數據從臨時集合複製到新集合...")
+            
+            # 處理可能的None值
+            processed_docs = []
+            for doc in temp_data["documents"]:
+                if doc is None:
+                    processed_docs.append("")
+                else:
+                    processed_docs.append(doc)
+            
+            # 使用分批方式添加數據以避免潛在的大數據問題
+            batch_size = 100
+            for i in range(0, len(temp_data["ids"]), batch_size):
+                end = min(i + batch_size, len(temp_data["ids"]))
+                original_collection_obj.add(
+                    ids=temp_data["ids"][i:end],
+                    documents=processed_docs[i:end],
+                    metadatas=temp_data["metadatas"][i:end] if temp_data["metadatas"] else None
+                )
+        
+        # 刪除臨時集合
+        print(f"刪除臨時集合 '{temp_collection}'...")
+        client.delete_collection(temp_collection)
+        
+        print(f"成功用重新嵌入的數據替換集合 '{original_collection}'")
+        return True
+        
+    except Exception as e:
+        print(f"替換集合時出錯: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def process_collection(
+    client,
+    collection_name: str,
+    embedding_func,
+    temp_suffix: str,
+    batch_size: int,
+    confirm_dangerous: bool,
+    dry_run: bool
+) -> bool:
+    """處理一個集合的完整流程
+    
+    Args:
+        client: ChromaDB客戶端
+        collection_name: 要處理的集合名稱
+        embedding_func: 新的嵌入函數
+        temp_suffix: 臨時集合的後綴
+        batch_size: 批處理大小
+        confirm_dangerous: 是否確認危險操作
+        dry_run: 是否只模擬執行
+        
+    Returns:
+        處理成功返回True，否則返回False
+    """
+    print(f"\n{'=' * 60}")
+    print(f"處理集合: '{collection_name}'")
+    print(f"{'=' * 60}")
+    
+    # 暫時集合名稱
+    temp_collection_name = f"{collection_name}{temp_suffix}"
+    
+    # 1. 獲取原始集合的數據
+    data = fetch_collection_data(client, collection_name, batch_size)
+    
+    if not data["ids"]:
+        print(f"集合 '{collection_name}' 為空或不存在，跳過")
+        return True
+    
+    # 2. 創建臨時集合並使用新的嵌入模型填充數據
+    success = create_and_populate_collection(
+        client, 
+        temp_collection_name, 
+        data, 
+        embedding_func,
+        batch_size,
+        dry_run
+    )
+    
+    if not success:
+        print(f"創建臨時集合 '{temp_collection_name}' 失敗，跳過替換")
+        return False
+    
+    # 3. 替換原始集合
+    success = swap_collections(
+        client, 
+        collection_name, 
+        temp_collection_name,
+        confirm_dangerous,
+        dry_run,
+        embedding_func  # 添加嵌入函數作為參數
+    )
+    
+    return success
+
+def main():
+    """主函數"""
+    args = parse_args()
+    
+    # 獲取ChromaDB目錄
+    chroma_dir = getattr(config, "CHROMA_DATA_DIR", "chroma_data")
+    print(f"使用ChromaDB目錄: {chroma_dir}")
+    
+    # 備份數據庫（如果請求）
+    if args.backup:
+        backup_chroma_directory(chroma_dir)
+    
+    # 創建ChromaDB客戶端
+    try:
+        client = chromadb.PersistentClient(path=chroma_dir)
+    except Exception as e:
+        print(f"錯誤: 無法連接到ChromaDB: {e}")
+        sys.exit(1)
+    
+    # 創建嵌入函數
+    embedding_func = create_embedding_function(args.new_model)
+    
+    # 確定要處理的集合
+    if args.collections:
+        collections_to_process = args.collections
+    else:
+        # 使用配置中的默認集合或獲取所有可用集合
+        default_collections = [
+            getattr(config, "BOT_MEMORY_COLLECTION", "wolfhart_memory"),
+            getattr(config, "CONVERSATIONS_COLLECTION", "conversations"),
+            getattr(config, "PROFILES_COLLECTION", "user_profiles")
+        ]
+        collections_to_process = get_collection_names(client, default_collections)
+    
+    # 過濾掉已經是臨時集合的集合名稱
+    filtered_collections = []
+    for collection in collections_to_process:
+        if args.temp_collection_suffix in collection:
+            print(f"警告: 跳過可能的臨時集合 '{collection}'")
+            continue
+        filtered_collections.append(collection)
+    
+    collections_to_process = filtered_collections
+    
+    if not collections_to_process:
+        print("沒有找到可處理的集合。")
+        sys.exit(0)
+    
+    print(f"將處理以下集合: {', '.join(collections_to_process)}")
+    if args.dry_run:
+        print("注意: 執行為乾運行模式，不會實際修改數據")
+    
+    # 詢問用戶確認
+    if not args.confirm_dangerous and not args.dry_run:
+        confirm = input("這個操作將使用新的嵌入模型重新計算所有數據。繼續? (y/N): ")
+        if confirm.lower() != 'y':
+            print("操作已取消")
+            sys.exit(0)
+    
+    # 處理每個集合
+    start_time = time.time()
+    success_count = 0
+    
+    for collection_name in collections_to_process:
+        if process_collection(
+            client,
+            collection_name,
+            embedding_func,
+            args.temp_collection_suffix,
+            args.batch_size,
+            args.confirm_dangerous,
+            args.dry_run
+        ):
+            success_count += 1
+    
+    # 報告結果
+    elapsed_time = time.time() - start_time
+    print(f"\n{'=' * 60}")
+    print(f"處理完成: {success_count}/{len(collections_to_process)} 個集合成功")
+    print(f"總耗時: {elapsed_time:.2f} 秒")
+    print(f"{'=' * 60}")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -6,5 +6,7 @@ opencv-python
 numpy
 pyperclip
 pygetwindow
-psutil 
+psutil
+pywin32
 python-dotenv
+keyboard

simple_bubble_dedup.py

@@ -0,0 +1,155 @@
+import os
+import json
+import collections
+import threading
+from PIL import Image
+import imagehash
+import numpy as np
+import io
+
+class SimpleBubbleDeduplication:
+    def __init__(self, storage_file="simple_bubble_dedup.json", max_bubbles=5, threshold=5, hash_size=16):
+        self.storage_file = storage_file
+        self.max_bubbles = max_bubbles  # Keep the most recent 5 bubbles
+        self.threshold = threshold  # Hash difference threshold (lower values are more strict)
+        self.hash_size = hash_size  # Hash size
+        self.lock = threading.Lock()
+        
+        # Use OrderedDict to maintain order
+        self.recent_bubbles = collections.OrderedDict()
+        # Load stored bubble hashes
+        self._load_storage()
+        
+    def _load_storage(self):
+        """Load processed bubble hash values from file"""
+        if os.path.exists(self.storage_file):
+            try:
+                with open(self.storage_file, 'r') as f:
+                    data = json.load(f)
+                
+                # Convert stored data to OrderedDict and load
+                self.recent_bubbles.clear()
+                # Use loaded_count to track loaded items, ensuring we don't exceed max_bubbles
+                loaded_count = 0
+                for bubble_id, bubble_data in data.items():
+                    if loaded_count >= self.max_bubbles:
+                        break
+                    self.recent_bubbles[bubble_id] = {
+                        'hash': imagehash.hex_to_hash(bubble_data['hash']),
+                        'sender': bubble_data.get('sender', 'Unknown')
+                    }
+                    loaded_count += 1
+                
+                print(f"Loaded {len(self.recent_bubbles)} bubble hash records")
+            except Exception as e:
+                print(f"Failed to load bubble hash records: {e}")
+                self.recent_bubbles.clear()
+        
+    def _save_storage(self):
+        """Save bubble hashes to file"""
+        try:
+            # Create temporary dictionary for saving
+            data_to_save = {}
+            for bubble_id, bubble_data in self.recent_bubbles.items():
+                data_to_save[bubble_id] = {
+                    'hash': str(bubble_data['hash']),
+                    'sender': bubble_data.get('sender', 'Unknown')
+                }
+            
+            with open(self.storage_file, 'w') as f:
+                json.dump(data_to_save, f, indent=2)
+            print(f"Saved {len(data_to_save)} bubble hash records")
+        except Exception as e:
+            print(f"Failed to save bubble hash records: {e}")
+    
+    def compute_image_hash(self, bubble_snapshot):
+        """Calculate perceptual hash of bubble image"""
+        try:
+            # If bubble_snapshot is a PIL.Image object
+            if isinstance(bubble_snapshot, Image.Image):
+                img = bubble_snapshot
+            # If bubble_snapshot is a PyAutoGUI screenshot
+            elif hasattr(bubble_snapshot, 'save'):
+                img = bubble_snapshot
+            # If it's bytes or BytesIO
+            elif isinstance(bubble_snapshot, (bytes, io.BytesIO)):
+                img = Image.open(io.BytesIO(bubble_snapshot) if isinstance(bubble_snapshot, bytes) else bubble_snapshot)
+            # If it's a numpy array
+            elif isinstance(bubble_snapshot, np.ndarray):
+                img = Image.fromarray(bubble_snapshot)
+            else:
+                print(f"Unrecognized image format: {type(bubble_snapshot)}")
+                return None
+                
+            # Calculate perceptual hash
+            phash = imagehash.phash(img, hash_size=self.hash_size)
+            return phash
+        except Exception as e:
+            print(f"Failed to calculate image hash: {e}")
+            return None
+    
+    def generate_bubble_id(self, bubble_region):
+        """Generate ID based on bubble region"""
+        return f"bubble_{bubble_region[0]}_{bubble_region[1]}_{bubble_region[2]}_{bubble_region[3]}"
+        
+    def is_duplicate(self, bubble_snapshot, bubble_region, sender_name=""):
+        """Check if bubble is a duplicate"""
+        with self.lock:
+            if bubble_snapshot is None:
+                return False
+                
+            # Calculate hash of current bubble
+            current_hash = self.compute_image_hash(bubble_snapshot)
+            if current_hash is None:
+                print("Unable to calculate bubble hash, cannot perform deduplication")
+                return False
+                
+            # Generate ID for current bubble
+            bubble_id = self.generate_bubble_id(bubble_region)
+            
+            # Check if similar to any known bubbles
+            for stored_id, bubble_data in self.recent_bubbles.items():
+                stored_hash = bubble_data['hash']
+                hash_diff = current_hash - stored_hash
+                
+                if hash_diff <= self.threshold:
+                    print(f"Detected duplicate bubble (ID: {stored_id}, Hash difference: {hash_diff})")
+                    if sender_name:
+                        print(f"Sender: {sender_name}, Recorded sender: {bubble_data.get('sender', 'Unknown')}")
+                    return True
+            
+            # Not a duplicate, add to recent bubbles list
+            self.recent_bubbles[bubble_id] = {
+                'hash': current_hash, 
+                'sender': sender_name
+            }
+            
+            # If exceeding maximum count, remove oldest item
+            while len(self.recent_bubbles) > self.max_bubbles:
+                self.recent_bubbles.popitem(last=False)  # Remove first item (oldest)
+                
+            self._save_storage()
+            return False
+    
+    def clear_all(self):
+        """Clear all records"""
+        with self.lock:
+            count = len(self.recent_bubbles)
+            self.recent_bubbles.clear()
+            self._save_storage()
+            print(f"Cleared all {count} bubble records")
+            return count
+
+    def save_debug_image(self, bubble_snapshot, bubble_id, hash_value):
+        """Save debug image (optional feature)"""
+        try:
+            debug_dir = "bubble_debug"
+            if not os.path.exists(debug_dir):
+                os.makedirs(debug_dir)
+            
+            # Save original image
+            img_path = os.path.join(debug_dir, f"{bubble_id}_{hash_value}.png")
+            bubble_snapshot.save(img_path)
+            print(f"Saved debug image: {img_path}")
+        except Exception as e:
+            print(f"Failed to save debug image: {e}")

test/llm_debug_script.py

@@ -0,0 +1,303 @@
+# test/llm_debug_script.py
+# Purpose: Directly interact with the LLM for debugging, bypassing UI interaction.
+
+import asyncio
+import sys
+import os
+import json
+import collections
+import datetime
+from contextlib import AsyncExitStack
+
+# Assume these modules are in the parent directory or accessible via PYTHONPATH
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import config
+import mcp_client
+import llm_interaction
+import chroma_client # <-- 新增導入
+from mcp import ClientSession, StdioServerParameters, types
+from mcp.client.stdio import stdio_client
+
+# --- Global Variables ---
+active_mcp_sessions: dict[str, ClientSession] = {}
+all_discovered_mcp_tools: list[dict] = []
+exit_stack = AsyncExitStack()
+wolfhart_persona_details: str | None = None
+conversation_history = collections.deque(maxlen=20) # Shorter history for debugging
+shutdown_requested = False
+
+# --- Load Persona Function (Adapted from main.py) ---
+def load_persona_from_file(filename="persona.json"):
+    """Loads persona data from a local JSON file relative to the main script dir."""
+    global wolfhart_persona_details
+    try:
+        # Get the directory of the main project, not the test directory
+        project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        filepath = os.path.join(project_dir, filename)
+        print(f"\nAttempting to load Persona data from: {filepath}")
+        if not os.path.exists(filepath):
+             raise FileNotFoundError(f"Persona file not found at {filepath}")
+
+        with open(filepath, 'r', encoding='utf-8') as f:
+            persona_data = json.load(f)
+            wolfhart_persona_details = json.dumps(persona_data, ensure_ascii=False, indent=2)
+            print(f"Successfully loaded Persona from '{filename}'.")
+
+    except FileNotFoundError:
+        print(f"Warning: Persona configuration file '{filename}' not found.")
+        wolfhart_persona_details = None
+    except json.JSONDecodeError:
+        print(f"Error: Failed to parse Persona configuration file '{filename}'.")
+        wolfhart_persona_details = None
+    except Exception as e:
+        print(f"Unknown error loading Persona configuration file '{filename}': {e}")
+        wolfhart_persona_details = None
+
+# --- Initialization Functions (Adapted from main.py) ---
+async def connect_and_discover(key: str, server_config: dict):
+    """Connects to a single MCP server, initializes, and discovers tools."""
+    global all_discovered_mcp_tools, active_mcp_sessions, exit_stack
+    print(f"\nProcessing Server: '{key}'")
+    command = server_config.get("command")
+    args = server_config.get("args", [])
+    process_env = os.environ.copy()
+    if server_config.get("env") and isinstance(server_config["env"], dict):
+        process_env.update(server_config["env"])
+
+    if not command:
+        print(f"==> Error: Missing 'command' in Server '{key}' configuration. <==")
+        return
+
+    server_params = StdioServerParameters(
+        command=command, args=args, env=process_env,
+    )
+
+    try:
+        print(f"Starting stdio_client for Server '{key}'...")
+        read, write = await exit_stack.enter_async_context(
+            stdio_client(server_params)
+        )
+        print(f"stdio_client for '{key}' active.")
+
+        session = await exit_stack.enter_async_context(
+            ClientSession(read, write)
+        )
+        print(f"ClientSession for '{key}' context entered.")
+
+        print(f"Initializing Session '{key}'...")
+        await session.initialize()
+        print(f"Session '{key}' initialized successfully.")
+
+        active_mcp_sessions[key] = session
+
+        print(f"Discovering tools for Server '{key}'...")
+        tools_as_dicts = await mcp_client.list_mcp_tools(session)
+        if tools_as_dicts:
+            processed_tools = []
+            for tool_dict in tools_as_dicts:
+                if isinstance(tool_dict, dict) and 'name' in tool_dict:
+                    tool_dict['_server_key'] = key
+                    processed_tools.append(tool_dict)
+                else:
+                    print(f"Warning: Unexpected tool format from '{key}': {tool_dict}")
+            all_discovered_mcp_tools.extend(processed_tools)
+            print(f"Processed {len(processed_tools)} tools from Server '{key}'.")
+        else:
+            print(f"Server '{key}' has no available tools.")
+
+    except FileNotFoundError:
+        print(f"==> Error: Command '{command}' for Server '{key}' not found. Check config.py. <==")
+    except ConnectionRefusedError:
+        print(f"==> Error: Connection to Server '{key}' refused. Is it running? <==")
+    except Exception as e:
+        print(f"==> Critical error initializing connection to Server '{key}': {e} <==")
+        import traceback
+        traceback.print_exc()
+
+async def initialize_mcp_connections():
+    """Concurrently starts and connects to all configured MCP servers."""
+    print("--- Initializing MCP connections ---")
+    connection_tasks = [
+        asyncio.create_task(connect_and_discover(key, server_config), name=f"connect_{key}")
+        for key, server_config in config.MCP_SERVERS.items()
+    ]
+    if connection_tasks:
+        await asyncio.gather(*connection_tasks, return_exceptions=True)
+    print("\n--- MCP connection initialization complete ---")
+    print(f"Total discovered tools: {len(all_discovered_mcp_tools)}")
+    print(f"Active Sessions: {list(active_mcp_sessions.keys())}")
+
+# --- Cleanup Function (Adapted from main.py) ---
+async def shutdown():
+    """Gracefully closes MCP connections."""
+    global shutdown_requested
+    if not shutdown_requested:
+        print("Shutdown initiated.")
+        shutdown_requested = True
+
+    print(f"\nClosing MCP Server connections...")
+    try:
+        await exit_stack.aclose()
+        print("AsyncExitStack closed.")
+    except Exception as e:
+        print(f"Error closing AsyncExitStack: {e}")
+    finally:
+        active_mcp_sessions.clear()
+        all_discovered_mcp_tools.clear()
+        print("Cleanup completed.")
+
+# --- Get Username Function ---
+async def get_username():
+    """Prompt the user for their name and return it."""
+    print("\nPlease enter your name (or press Enter to use 'Debugger'): ", end="")
+    user_input = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
+    user_name = user_input.strip()
+    if not user_name:
+        user_name = "Debugger"  # Default name if nothing is entered
+    return user_name
+
+# --- Main Debug Loop ---
+async def debug_loop():
+    """Main loop for interactive LLM debugging."""
+    global shutdown_requested, conversation_history
+
+    # 1. Load Persona
+    load_persona_from_file()
+
+    # 2. Initialize ChromaDB
+    print("\n--- Initializing ChromaDB ---")
+    if not chroma_client.initialize_chroma_client():
+        print("Warning: ChromaDB initialization failed. Memory functions may not work.")
+    else:
+        print("ChromaDB initialized successfully.")
+    print("-----------------------------")
+
+    # 3. Initialize MCP
+    await initialize_mcp_connections()
+    if not active_mcp_sessions:
+        print("\nNo MCP servers connected. LLM tool usage will be limited. Continue? (y/n)")
+        confirm = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
+        if confirm.strip().lower() != 'y':
+            return
+
+    # 4. Get username
+    user_name = await get_username()
+    print(f"Debug session started as: {user_name}")
+
+    print("\n--- LLM Debug Interface ---")
+    print("Enter your message to the LLM.")
+    print("Type 'quit' or 'exit' to stop.")
+    print("-----------------------------")
+
+    while not shutdown_requested:
+        try:
+            # Get user input asynchronously
+            print(f"\n{user_name}: ", end="")
+            user_input_line = await asyncio.get_event_loop().run_in_executor(
+                None, sys.stdin.readline
+            )
+            user_input = user_input_line.strip()
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ['quit', 'exit']:
+                shutdown_requested = True
+                break
+
+            # Add user message to history
+            timestamp = datetime.datetime.now()
+            conversation_history.append((timestamp, 'user', user_name, user_input))
+
+            print(f"\n{config.PERSONA_NAME} is thinking...")
+
+            # --- Pre-fetch ChromaDB data ---
+            print(f"Fetching ChromaDB data for '{user_name}'...")
+            user_profile_data = chroma_client.get_entity_profile(user_name)
+            related_memories_data = chroma_client.get_related_memories(user_name, topic=user_input, limit=5) # Use user input as topic hint
+            # bot_knowledge_data = chroma_client.get_bot_knowledge(concept=user_input, limit=3) # Optional: Fetch bot knowledge based on input
+            print("ChromaDB data fetch complete.")
+            # --- End Pre-fetch ---
+
+            # Call LLM interaction function, passing fetched data
+            bot_response_data = await llm_interaction.get_llm_response(
+                current_sender_name=user_name,
+                history=list(conversation_history), # Pass history
+                mcp_sessions=active_mcp_sessions,
+                available_mcp_tools=all_discovered_mcp_tools,
+                persona_details=wolfhart_persona_details,
+                user_profile=user_profile_data,         # Pass fetched profile
+                related_memories=related_memories_data, # Pass fetched memories
+                # bot_knowledge=bot_knowledge_data      # Optional: Pass fetched knowledge
+            )
+
+            # Print the full response structure for debugging
+            print("\n--- LLM Response Data ---")
+            print(json.dumps(bot_response_data, indent=2, ensure_ascii=False))
+            print("-------------------------")
+
+            # Extract and print key parts
+            bot_dialogue = bot_response_data.get("dialogue", "")
+            thoughts = bot_response_data.get("thoughts", "")
+            commands = bot_response_data.get("commands", [])
+            valid_response = bot_response_data.get("valid_response", False)
+
+            if thoughts:
+                print(f"\nThoughts: {thoughts}")
+            if commands:
+                print(f"\nCommands:")
+                for cmd in commands:
+                    print(f"  - Type: {cmd.get('type')}, Params: {cmd.get('parameters')}")
+            if bot_dialogue:
+                print(f"\n{config.PERSONA_NAME}: {bot_dialogue}")
+                if valid_response:
+                     # Add valid bot response to history
+                     timestamp = datetime.datetime.now()
+                     conversation_history.append((timestamp, 'bot', config.PERSONA_NAME, bot_dialogue))
+                else:
+                    print("(Note: LLM marked this dialogue as potentially invalid/incomplete)")
+            else:
+                print(f"\n{config.PERSONA_NAME}: (No dialogue content)")
+
+
+        except (EOFError, KeyboardInterrupt):
+            print("\nInterrupted. Shutting down...")
+            shutdown_requested = True
+            break
+        except Exception as e:
+            print(f"\nError during interaction: {e}")
+            import traceback
+            traceback.print_exc()
+            # Optionally break or continue after error
+            # break
+
+    print("\nExiting debug loop.")
+
+
+# --- Program Entry Point ---
+if __name__ == "__main__":
+    print("Starting LLM Debug Script...")
+    loop = asyncio.get_event_loop()
+    main_task = None
+    try:
+        main_task = loop.create_task(debug_loop())
+        loop.run_until_complete(main_task)
+    except KeyboardInterrupt:
+        print("\nCtrl+C detected. Initiating shutdown...")
+        shutdown_requested = True
+        if main_task and not main_task.done():
+             main_task.cancel()
+             # Allow cancellation to propagate
+             loop.run_until_complete(main_task)
+    except Exception as e:
+        print(f"Top-level error: {e}")
+        import traceback
+        traceback.print_exc()
+    finally:
+        # Ensure shutdown runs even if loop was interrupted
+        if not exit_stack.is_active: # Check if already closed
+             print("Running final shutdown...")
+             loop.run_until_complete(shutdown())
+        loop.close()
+        print("LLM Debug Script finished.")

tools/color_picker.py

@@ -0,0 +1,147 @@
+import cv2
+import numpy as np
+import pyautogui
+
+def pick_color_fixed():
+    # 截取游戏区域
+    screenshot = pyautogui.screenshot(region=(150, 330, 600, 880))
+    img = np.array(screenshot)
+    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    
+    # 转为HSV
+    hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    
+    # 创建窗口和滑块
+    cv2.namedWindow('Color Picker')
+    
+    # 存储采样点
+    sample_points = []
+    
+    # 定义鼠标回调函数
+    def mouse_callback(event, x, y, flags, param):
+        if event == cv2.EVENT_LBUTTONDOWN:
+            # 获取点击位置的HSV值
+            hsv_value = hsv_img[y, x]
+            sample_points.append(hsv_value)
+            print(f"添加采样点 #{len(sample_points)}: HSV = {hsv_value}")
+            
+            # 在图像上显示采样点
+            cv2.circle(img, (x, y), 3, (0, 255, 0), -1)
+            cv2.imshow('Color Picker', img)
+            
+            # 如果有足够多的采样点，计算更精确的范围
+            if len(sample_points) >= 1:
+                calculate_range()
+    
+    def calculate_range():
+        """安全计算HSV范围，避免溢出"""
+        if not sample_points:
+            return
+            
+        # 转换为numpy数组
+        points_array = np.array(sample_points)
+        
+        # 提取各通道的值并安全计算范围
+        h_values = points_array[:, 0].astype(np.int32)  # 转为int32避免溢出
+        s_values = points_array[:, 1].astype(np.int32)
+        v_values = points_array[:, 2].astype(np.int32)
+        
+        # 检查H值是否跨越边界
+        h_range = np.max(h_values) - np.min(h_values)
+        h_crosses_boundary = h_range > 90 and len(h_values) > 2
+        
+        # 计算安全范围值
+        if h_crosses_boundary:
+            print("检测到H值可能跨越红色边界(0/180)!")
+            # 特殊处理跨越边界的H值
+            # 方法1: 简单方式 - 使用宽范围
+            h_min = 0
+            h_max = 179
+            print(f"使用全H范围: [{h_min}, {h_max}]")
+        else:
+            # 正常计算H范围
+            h_min = max(0, np.min(h_values) - 5)
+            h_max = min(179, np.max(h_values) + 5)
+        
+        # 安全计算S和V范围
+        s_min = max(0, np.min(s_values) - 15)
+        s_max = min(255, np.max(s_values) + 15)
+        v_min = max(0, np.min(v_values) - 15)
+        v_max = min(255, np.max(v_values) + 15)
+        
+        print("\n推荐的HSV范围:")
+        print(f"\"hsv_lower\": [{h_min}, {s_min}, {v_min}],")
+        print(f"\"hsv_upper\": [{h_max}, {s_max}, {v_max}],")
+        
+        # 显示掩码预览
+        show_mask_preview(h_min, h_max, s_min, s_max, v_min, v_max)
+    
+    def show_mask_preview(h_min, h_max, s_min, s_max, v_min, v_max):
+        """显示掩码预览，标记检测到的区域"""
+        
+        # 创建掩码
+        if h_min <= h_max:
+            # 标准范围
+            mask = cv2.inRange(hsv_img, 
+                             np.array([h_min, s_min, v_min]), 
+                             np.array([h_max, s_max, v_max]))
+        else:
+            # 处理H值跨越边界情况
+            mask1 = cv2.inRange(hsv_img, 
+                              np.array([h_min, s_min, v_min]), 
+                              np.array([179, s_max, v_max]))
+            mask2 = cv2.inRange(hsv_img, 
+                              np.array([0, s_min, v_min]), 
+                              np.array([h_max, s_max, v_max]))
+            mask = cv2.bitwise_or(mask1, mask2)
+        
+        # 形态学操作 - 闭运算连接临近区域
+        kernel = np.ones((5, 5), np.uint8)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+        
+        # 找到连通区域
+        num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask)
+        
+        # 创建结果图像
+        result_img = img.copy()
+        detected_count = 0
+        
+        # 处理每个连通区域
+        for i in range(1, num_labels):  # 跳过背景(0)
+            area = stats[i, cv2.CC_STAT_AREA]
+            # 面积筛选 
+            if 3000 <= area <= 100000:
+                detected_count += 1
+                x = stats[i, cv2.CC_STAT_LEFT]
+                y = stats[i, cv2.CC_STAT_TOP]
+                w = stats[i, cv2.CC_STAT_WIDTH]
+                h = stats[i, cv2.CC_STAT_HEIGHT]
+                
+                # 绘制区域边框
+                cv2.rectangle(result_img, (x, y), (x+w, y+h), (0, 255, 0), 2)
+                # 显示区域ID
+                cv2.putText(result_img, f"#{i}", (x+5, y+20), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+        
+        # 显示结果
+        cv2.imshow('Mask Preview', result_img)
+        print(f"检测到 {detected_count} 个合适大小的区域")
+    
+    # 设置鼠标回调
+    cv2.setMouseCallback('Color Picker', mouse_callback)
+    
+    # 显示操作说明
+    print("使用说明:")
+    print("1. 点击气泡上的多个位置进行采样")
+    print("2. 程序会自动计算合适的HSV范围")
+    print("3. 绿色方框表示检测到的区域")
+    print("4. 按ESC键退出")
+    print("\n【特别提示】如果气泡混合了红色和紫色，可能需要创建两个配置以处理H通道的边界问题")
+    
+    # 显示图像
+    cv2.imshow('Color Picker', img)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    pick_color_fixed()

window-setup-script.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python
-"""
-Game Window Setup Script - Adjust game window position and size
-
-This script will launch the game and adjust its window to a specified position and size (100,100 1280x768),
-making it easier to take screenshots of UI elements for later use.
-"""
-
-import os
-import time
-import subprocess
-import pygetwindow as gw
-import psutil
-import argparse
-
-def is_process_running(process_name):
-    """Check if a specified process is currently running"""
-    for proc in psutil.process_iter(['name']):
-        if proc.info['name'].lower() == process_name.lower():
-            return True
-    return False
-
-def launch_game(game_path):
-    """Launch the game"""
-    if not os.path.exists(game_path):
-        print(f"Error: Game executable not found at {game_path}")
-        return False
-    
-    print(f"Launching game: {game_path}")
-    subprocess.Popen(game_path)
-    return True
-
-def find_game_window(window_title, max_wait=30):
-    """Find the game window"""
-    print(f"Searching for game window: {window_title}")
-    
-    start_time = time.time()
-    while time.time() - start_time < max_wait:
-        try:
-            windows = gw.getWindowsWithTitle(window_title)
-            if windows:
-                return windows[0]
-        except Exception as e:
-            print(f"Error finding window: {e}")
-        
-        print("Window not found, waiting 1 second before retrying...")
-        time.sleep(1)
-    
-    print(f"Error: Game window not found within {max_wait} seconds")
-    return None
-
-def set_window_position_size(window, x, y, width, height):
-    """Set window position and size"""
-    try:
-        print(f"Adjusting window position to ({x}, {y}) and size to {width}x{height}")
-        window.moveTo(x, y)
-        window.resizeTo(width, height)
-        print("Window adjustment completed")
-        return True
-    except Exception as e:
-        print(f"Error adjusting window: {e}")
-        return False
-
-def main():
-    parser = argparse.ArgumentParser(description='Game Window Setup Tool')
-    parser.add_argument('--launch', action='store_true', help='Whether to launch the game')
-    parser.add_argument('--game_path', default=r"C:\Users\Bigspring\AppData\Local\TheLastWar\Launch.exe", help='Game launcher path')
-    parser.add_argument('--window_title', default="Last War-Survival Game", help='Game window title')
-    parser.add_argument('--process_name', default="LastWar.exe", help='Game process name')
-    parser.add_argument('--x', type=int, default=50, help='Window X coordinate')
-    parser.add_argument('--y', type=int, default=30, help='Window Y coordinate')
-    parser.add_argument('--width', type=int, default=600, help='Window width')
-    parser.add_argument('--height', type=int, default=1070, help='Window height')
-    
-    args = parser.parse_args()
-    
-    # Check if game is already running
-    if not is_process_running(args.process_name):
-        if args.launch:
-            # Launch the game
-            if not launch_game(args.game_path):
-                return
-        else:
-            print(f"Game process {args.process_name} is not running, please launch the game first or use the --launch parameter")
-            return
-    else:
-        print(f"Game process {args.process_name} is already running")
-    
-    # Find game window
-    window = find_game_window(args.window_title)
-    if not window:
-        return
-    
-    # Set window position and size
-    set_window_position_size(window, args.x, args.y, args.width, args.height)
-    
-    # Display final window state
-    print("\nFinal window state:")
-    print(f"Position: ({window.left}, {window.top})")
-    print(f"Size: {window.width}x{window.height}")
-
-if __name__ == "__main__":
-    main()