auto-coder 0.1.363__tar.gz → 0.1.365__tar.gz

{auto_coder-0.1.363 → auto_coder-0.1.365}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.363
+Version: 0.1.365
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10
@@ -28,7 +28,7 @@ Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
 Requires-Dist: aiofiles
 Requires-Dist: readerwriterlock
-Requires-Dist: byzerllm[saas]>=0.1.181
+Requires-Dist: byzerllm[saas]>=0.1.182
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.363
+Version: 0.1.365
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10
@@ -28,7 +28,7 @@ Requires-Dist: prompt-toolkit
 Requires-Dist: tokenizers
 Requires-Dist: aiofiles
 Requires-Dist: readerwriterlock
-Requires-Dist: byzerllm[saas]>=0.1.181
+Requires-Dist: byzerllm[saas]>=0.1.182
 Requires-Dist: patch
 Requires-Dist: diff_match_patch
 Requires-Dist: GitPython

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/auto_coder.egg-info/SOURCES.txt

@@ -139,6 +139,19 @@ src/autocoder/common/conversations/example.py
 src/autocoder/common/directory_cache/__init__.py
 src/autocoder/common/directory_cache/cache.py
 src/autocoder/common/directory_cache/test_cache.py
+src/autocoder/common/file_checkpoint/__init__.py
+src/autocoder/common/file_checkpoint/backup.py
+src/autocoder/common/file_checkpoint/conversation_checkpoint.py
+src/autocoder/common/file_checkpoint/examples.py
+src/autocoder/common/file_checkpoint/manager.py
+src/autocoder/common/file_checkpoint/models.py
+src/autocoder/common/file_checkpoint/store.py
+src/autocoder/common/file_checkpoint/test_backup.py
+src/autocoder/common/file_checkpoint/test_manager.py
+src/autocoder/common/file_checkpoint/test_models.py
+src/autocoder/common/file_checkpoint/test_store.py
+src/autocoder/common/file_checkpoint/test_utils.py
+src/autocoder/common/file_checkpoint/utils.py
 src/autocoder/common/file_monitor/__init__.py
 src/autocoder/common/file_monitor/monitor.py
 src/autocoder/common/ignorefiles/__init__.py
@@ -180,6 +193,7 @@ src/autocoder/common/v2/agent/agentic_edit_tools/read_file_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/replace_in_file_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/search_files_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/test_search_files_tool_resolver.py
+src/autocoder/common/v2/agent/agentic_edit_tools/test_write_to_file_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/use_mcp_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/write_to_file_tool_resolver.py
 src/autocoder/compilers/__init__.py
@@ -189,6 +203,7 @@ src/autocoder/compilers/compiler_config_manager.py
 src/autocoder/compilers/compiler_factory.py
 src/autocoder/compilers/java_compiler.py
 src/autocoder/compilers/models.py
+src/autocoder/compilers/normal_compiler.py
 src/autocoder/compilers/provided_compiler.py
 src/autocoder/compilers/python_compiler.py
 src/autocoder/compilers/reactjs_compiler.py
@@ -226,6 +241,7 @@ src/autocoder/linters/__init__.py
 src/autocoder/linters/base_linter.py
 src/autocoder/linters/linter_factory.py
 src/autocoder/linters/models.py
+src/autocoder/linters/normal_linter.py
 src/autocoder/linters/python_linter.py
 src/autocoder/linters/reactjs_linter.py
 src/autocoder/linters/shadow_linter.py

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/auto_coder.egg-info/requires.txt

@@ -18,7 +18,7 @@ prompt-toolkit
 tokenizers
 aiofiles
 readerwriterlock
-byzerllm[saas]>=0.1.181
+byzerllm[saas]>=0.1.182
 patch
 diff_match_patch
 GitPython

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/autocoder/agent/base_agentic/tools/execute_command_tool_resolver.py

@@ -3,13 +3,13 @@ import subprocess
 from typing import Dict, Any, Optional
 from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
 from autocoder.agent.base_agentic.types import ExecuteCommandTool, ToolResult # Import ToolResult from types
-from autocoder.common import shells
 from autocoder.common.printer import Printer
 from loguru import logger
 import typing
 from autocoder.common import AutoCoderArgs
 from autocoder.events.event_manager_singleton import get_event_manager
 from autocoder.run_context import get_run_context
+from autocoder.common.run_cmd import run_cmd_subprocess
 if typing.TYPE_CHECKING:
     from ..base_agent import BaseAgent
 

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/autocoder/auto_coder.py

@@ -376,8 +376,8 @@ def main(input_args: Optional[List[str]] = None):
                 llm.setup_sub_client("inference_model", inference_model)                 
 
             if args.index_filter_model:
-                model_info = models_module.get_model_by_name(args.index_filter_model)
-                model_name = args.index_filter_model
+                model_name = args.index_filter_model.strip()
+                model_info = models_module.get_model_by_name(model_name)                
                 index_filter_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 index_filter_model.deploy(
                     model_path="",
@@ -393,6 +393,41 @@ def main(input_args: Optional[List[str]] = None):
                 )
                 llm.setup_sub_client("index_filter_model", index_filter_model)            
 
+            if args.context_prune_model:
+                model_name = args.context_prune_model.strip()
+                model_info = models_module.get_model_by_name(model_name)                
+                context_prune_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
+                context_prune_model.deploy(
+                    model_path="",
+                    pretrained_model_type=model_info["model_type"],
+                    udf_name=model_name,
+                    infer_params={
+                        "saas.base_url": model_info["base_url"],
+                        "saas.api_key": model_info["api_key"],
+                        "saas.model": model_info["model_name"],
+                        "saas.is_reasoning": model_info["is_reasoning"],
+                        "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
+                    }
+                )
+                llm.setup_sub_client("context_prune_model", context_prune_model)
+
+            if args.conversation_prune_model:
+                model_name = args.conversation_prune_model.strip()
+                model_info = models_module.get_model_by_name(model_name)                
+                conversation_prune_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
+                conversation_prune_model.deploy(
+                    model_path="",
+                    pretrained_model_type=model_info["model_type"],
+                    udf_name=model_name,
+                    infer_params={
+                        "saas.base_url": model_info["base_url"],
+                        "saas.api_key": model_info["api_key"],
+                        "saas.model": model_info["model_name"],
+                        "saas.is_reasoning": model_info["is_reasoning"],
+                        "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
+                    }
+                )
+                llm.setup_sub_client("conversation_prune_model", conversation_prune_model)
 
         if args.product_mode == "pro":
             if args.code_model:
@@ -437,6 +472,15 @@ def main(input_args: Optional[List[str]] = None):
                 index_filter_model.setup_default_model_name(args.index_filter_model)
                 llm.setup_sub_client("index_filter_model", index_filter_model)
             
+            if args.context_prune_model:
+                context_prune_model = byzerllm.ByzerLLM()
+                context_prune_model.setup_default_model_name(args.context_prune_model)
+                llm.setup_sub_client("context_prune_model", context_prune_model)
+
+            if args.conversation_prune_model:
+                conversation_prune_model = byzerllm.ByzerLLM()
+                conversation_prune_model.setup_default_model_name(args.conversation_prune_model)
+                llm.setup_sub_client("conversation_prune_model", conversation_prune_model)
 
         if get_run_context().mode != RunMode.WEB and args.human_as_model:
 

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/autocoder/auto_coder_runner.py

@@ -2850,6 +2850,7 @@ def auto_command(query: str,extra_args: Dict[str,Any]={}):
         else:
             agent.run_in_terminal(AgenticEditRequest(user_input=query))
             
+        completer.refresh_files()
         return
         
     args = get_final_config()  
@@ -2902,3 +2903,4 @@ def auto_command(query: str,extra_args: Dict[str,Any]={}):
         border_style="blue",
         padding=(1, 2)
     ))
+    completer.refresh_files()

{auto_coder-0.1.363 → auto_coder-0.1.365}/src/autocoder/common/__init__.py

@@ -254,6 +254,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     emb_model: Optional[str] = ""
     code_model: Optional[str] = ""
     generate_rerank_model: Optional[str] = ""
+    context_prune_model: Optional[str] = ""
+    conversation_prune_model: Optional[str] = ""
     inference_model: Optional[str] = ""
     system_prompt: Optional[str] = ""
     planner_model: Optional[str] = ""
@@ -399,6 +401,7 @@ class AutoCoderArgs(pydantic.BaseModel):
 
     context_prune_strategy: Optional[str] = "extract"
     context_prune: Optional[bool] = True
+    context_prune_safe_zone_tokens: Optional[int] = 32*1024
     context_prune_sliding_window_size: Optional[int] = 1000
     context_prune_sliding_window_overlap: Optional[int] = 100
 
@@ -432,6 +435,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     auto_fix_lint_max_attempts: Optional[int] = 5
     auto_fix_compile_max_attempts: Optional[int] = 5
     auto_fix_merge_max_attempts: Optional[int] = 5
+
+    enable_auto_select_rules: Optional[bool] = True
     
     ignore_clean_shadows: Optional[bool] = False
 

auto_coder-0.1.365/src/autocoder/common/file_checkpoint/__init__.py

@@ -0,0 +1,21 @@
+"""
+文件变更管理模块
+
+该模块提供了一种可靠的机制来应用、记录和撤销对项目文件的修改。
+主要功能包括：
+1. 将影子系统中的文件变更安全地应用到用户的实际项目中
+2. 记录每次变更的历史，支持多版本撤销功能
+3. 提供简单直观的API，便于集成到现有的编辑流程中
+"""
+
+from autocoder.common.file_checkpoint.models import (
+    FileChange, ChangeRecord, ApplyResult, UndoResult, DiffResult
+)
+from autocoder.common.file_checkpoint.manager import FileChangeManager
+from autocoder.common.file_checkpoint.store import FileChangeStore
+from autocoder.common.file_checkpoint.backup import FileBackupManager
+
+__all__ = [
+    'FileChange', 'ChangeRecord', 'ApplyResult', 'UndoResult', 'DiffResult',
+    'FileChangeManager', 'FileChangeStore', 'FileBackupManager'
+]

auto_coder-0.1.365/src/autocoder/common/file_checkpoint/backup.py

@@ -0,0 +1,264 @@
+"""
+文件备份管理器
+
+负责文件的备份和恢复操作，支持多版本文件备份。
+"""
+
+import os
+import uuid
+import shutil
+import logging
+from typing import Optional, Dict, List, Tuple
+from datetime import datetime
+import json
+import threading
+
+logger = logging.getLogger(__name__)
+
+
+class FileBackupManager:
+    """负责文件的备份和恢复操作"""
+    
+    def __init__(self, backup_dir: Optional[str] = None):
+        """
+        初始化备份管理器
+        
+        Args:
+            backup_dir: 备份文件存储目录，如果为None则使用默认目录
+        """
+        if backup_dir is None:
+            # 默认备份目录为项目根目录下的.auto-coder/checkpoint
+            backup_dir = os.path.join(os.getcwd(), ".auto-coder", "checkpoint")
+        
+        self.backup_dir = backup_dir
+        self.metadata_file = os.path.join(backup_dir, "backup_metadata.json")
+        self.lock = threading.RLock()
+        
+        # 确保备份目录存在
+        os.makedirs(backup_dir, exist_ok=True)
+        
+        # 加载备份元数据
+        self.metadata = self._load_metadata()
+    
+    def backup_file(self, file_path: str) -> Optional[str]:
+        """
+        备份指定文件
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            str: 备份文件ID，如果文件不存在则返回None
+        """
+        if not os.path.exists(file_path):
+            return None
+        
+        with self.lock:
+            # 生成唯一的备份ID
+            backup_id = str(uuid.uuid4())
+            
+            # 构建备份文件路径
+            backup_file_path = os.path.join(self.backup_dir, backup_id)
+            
+            try:
+                # 复制文件到备份目录
+                shutil.copy2(file_path, backup_file_path)
+                
+                # 更新元数据
+                self.metadata[backup_id] = {
+                    "original_path": file_path,
+                    "timestamp": datetime.now().timestamp(),
+                    "size": os.path.getsize(file_path)
+                }
+                
+                # 保存元数据
+                self._save_metadata()
+                
+                logger.debug(f"已备份文件 {file_path} 到 {backup_file_path}")
+                return backup_id
+            
+            except Exception as e:
+                logger.error(f"备份文件 {file_path} 失败: {str(e)}")
+                # 清理可能部分创建的备份文件
+                if os.path.exists(backup_file_path):
+                    os.remove(backup_file_path)
+                return None
+    
+    def restore_file(self, file_path: str, backup_id: str) -> bool:
+        """
+        从备份恢复文件
+        
+        Args:
+            file_path: 目标文件路径
+            backup_id: 备份文件ID
+            
+        Returns:
+            bool: 恢复是否成功
+        """
+        with self.lock:
+            # 检查备份ID是否存在
+            if backup_id not in self.metadata:
+                logger.error(f"备份ID {backup_id} 不存在")
+                return False
+            
+            # 构建备份文件路径
+            backup_file_path = os.path.join(self.backup_dir, backup_id)
+            
+            # 检查备份文件是否存在
+            if not os.path.exists(backup_file_path):
+                logger.error(f"备份文件 {backup_file_path} 不存在")
+                return False
+            
+            try:
+                # 确保目标目录存在
+                os.makedirs(os.path.dirname(file_path), exist_ok=True)
+                
+                # 复制备份文件到目标路径
+                shutil.copy2(backup_file_path, file_path)
+                
+                logger.debug(f"已从 {backup_file_path} 恢复文件到 {file_path}")
+                return True
+            
+            except Exception as e:
+                logger.error(f"恢复文件 {file_path} 失败: {str(e)}")
+                return False
+    
+    def get_backup_content(self, backup_id: str) -> Optional[str]:
+        """
+        获取备份文件的内容
+        
+        Args:
+            backup_id: 备份文件ID
+            
+        Returns:
+            str: 备份文件内容，如果备份不存在则返回None
+        """
+        with self.lock:
+            # 检查备份ID是否存在
+            if backup_id not in self.metadata:
+                logger.error(f"备份ID {backup_id} 不存在")
+                return None
+            
+            # 构建备份文件路径
+            backup_file_path = os.path.join(self.backup_dir, backup_id)
+            
+            # 检查备份文件是否存在
+            if not os.path.exists(backup_file_path):
+                logger.error(f"备份文件 {backup_file_path} 不存在")
+                return None
+            
+            try:
+                # 读取备份文件内容
+                with open(backup_file_path, 'r', encoding='utf-8') as f:
+                    return f.read()
+            
+            except Exception as e:
+                logger.error(f"读取备份文件 {backup_file_path} 失败: {str(e)}")
+                return None
+    
+    def delete_backup(self, backup_id: str) -> bool:
+        """
+        删除指定的备份文件
+        
+        Args:
+            backup_id: 备份文件ID
+            
+        Returns:
+            bool: 删除是否成功
+        """
+        with self.lock:
+            # 检查备份ID是否存在
+            if backup_id not in self.metadata:
+                logger.error(f"备份ID {backup_id} 不存在")
+                return False
+            
+            # 构建备份文件路径
+            backup_file_path = os.path.join(self.backup_dir, backup_id)
+            
+            try:
+                # 删除备份文件
+                if os.path.exists(backup_file_path):
+                    os.remove(backup_file_path)
+                
+                # 更新元数据
+                del self.metadata[backup_id]
+                
+                # 保存元数据
+                self._save_metadata()
+                
+                logger.debug(f"已删除备份 {backup_id}")
+                return True
+            
+            except Exception as e:
+                logger.error(f"删除备份 {backup_id} 失败: {str(e)}")
+                return False
+    
+    def clean_old_backups(self, max_age_days: int = 30) -> int:
+        """
+        清理过旧的备份文件
+        
+        Args:
+            max_age_days: 最大保留天数
+            
+        Returns:
+            int: 清理的备份文件数量
+        """
+        with self.lock:
+            now = datetime.now().timestamp()
+            max_age_seconds = max_age_days * 24 * 60 * 60
+            
+            backup_ids_to_delete = []
+            
+            # 找出过旧的备份
+            for backup_id, metadata in self.metadata.items():
+                if now - metadata["timestamp"] > max_age_seconds:
+                    backup_ids_to_delete.append(backup_id)
+            
+            # 删除过旧的备份
+            deleted_count = 0
+            for backup_id in backup_ids_to_delete:
+                if self.delete_backup(backup_id):
+                    deleted_count += 1
+            
+            return deleted_count
+    
+    def get_backups_for_file(self, file_path: str) -> List[Tuple[str, float]]:
+        """
+        获取指定文件的所有备份
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            List[Tuple[str, float]]: 备份ID和时间戳的列表，按时间戳降序排序
+        """
+        with self.lock:
+            backups = []
+            
+            for backup_id, metadata in self.metadata.items():
+                if metadata["original_path"] == file_path:
+                    backups.append((backup_id, metadata["timestamp"]))
+            
+            # 按时间戳降序排序
+            backups.sort(key=lambda x: x[1], reverse=True)
+            
+            return backups
+    
+    def _load_metadata(self) -> Dict:
+        """加载备份元数据"""
+        if os.path.exists(self.metadata_file):
+            try:
+                with open(self.metadata_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                logger.error(f"加载备份元数据失败: {str(e)}")
+        
+        return {}
+    
+    def _save_metadata(self) -> None:
+        """保存备份元数据"""
+        try:
+            with open(self.metadata_file, 'w', encoding='utf-8') as f:
+                json.dump(self.metadata, f, indent=2)
+        except Exception as e:
+            logger.error(f"保存备份元数据失败: {str(e)}")

auto_coder-0.1.365/src/autocoder/common/file_checkpoint/conversation_checkpoint.py

@@ -0,0 +1,182 @@
+import os
+import json
+import time
+import uuid
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+from loguru import logger
+
+
+class ConversationCheckpoint(BaseModel):
+    """对话检查点，用于保存特定时刻的对话状态"""
+    
+    checkpoint_id: str  # 检查点ID，与变更组ID对应
+    timestamp: float  # 创建时间戳
+    conversations: List[Dict[str, Any]]  # 对话历史
+    metadata: Optional[Dict[str, Any]] = None  # 元数据，可包含额外信息
+
+
+class ConversationCheckpointStore:
+    """对话检查点存储管理器"""
+    
+    def __init__(self, store_dir: Optional[str] = None, max_history: int = 50):
+        """
+        初始化对话检查点存储
+        
+        Args:
+            store_dir: 存储目录，默认为用户主目录下的.autocoder/conversation_checkpoints
+            max_history: 最大保存的历史版本数量
+        """
+        if store_dir is None:
+            home_dir = os.path.expanduser("~")
+            store_dir = os.path.join(home_dir, ".autocoder", "conversation_checkpoints")
+        
+        self.store_dir = os.path.abspath(store_dir)
+        self.max_history = max_history
+        
+        # 确保存储目录存在
+        os.makedirs(self.store_dir, exist_ok=True)
+        logger.info(f"对话检查点存储目录: {self.store_dir}")
+    
+    def save_checkpoint(self, checkpoint: ConversationCheckpoint) -> str:
+        """
+        保存对话检查点
+        
+        Args:
+            checkpoint: 对话检查点对象
+            
+        Returns:
+            str: 检查点ID
+        """
+        # 确保检查点有ID
+        if not checkpoint.checkpoint_id:
+            checkpoint.checkpoint_id = str(uuid.uuid4())
+        
+        # 确保时间戳存在
+        if not checkpoint.timestamp:
+            checkpoint.timestamp = time.time()
+        
+        # 构建文件路径
+        file_path = os.path.join(self.store_dir, f"{checkpoint.checkpoint_id}.json")
+        
+        # 保存为JSON文件
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(checkpoint.json(ensure_ascii=False, indent=2))
+            
+            logger.info(f"已保存对话检查点: {checkpoint.checkpoint_id}")
+            
+            # 检查并清理过期的检查点
+            self._cleanup_old_checkpoints()
+            
+            return checkpoint.checkpoint_id
+        except Exception as e:
+            logger.error(f"保存对话检查点失败: {str(e)}")
+            return ""
+    
+    def get_checkpoint(self, checkpoint_id: str) -> Optional[ConversationCheckpoint]:
+        """
+        获取指定ID的对话检查点
+        
+        Args:
+            checkpoint_id: 检查点ID
+            
+        Returns:
+            Optional[ConversationCheckpoint]: 对话检查点对象，如果不存在则返回None
+        """
+        file_path = os.path.join(self.store_dir, f"{checkpoint_id}.json")
+        
+        if not os.path.exists(file_path):
+            logger.warning(f"对话检查点不存在: {checkpoint_id}")
+            return None
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            return ConversationCheckpoint(**data)
+        except Exception as e:
+            logger.error(f"读取对话检查点失败: {str(e)}")
+            return None
+    
+    def get_latest_checkpoint(self) -> Optional[ConversationCheckpoint]:
+        """
+        获取最新的对话检查点
+        
+        Returns:
+            Optional[ConversationCheckpoint]: 最新的对话检查点对象，如果不存在则返回None
+        """
+        checkpoints = self._get_all_checkpoints()
+        
+        if not checkpoints:
+            return None
+        
+        # 按时间戳降序排序
+        checkpoints.sort(key=lambda x: x.timestamp, reverse=True)
+        
+        return checkpoints[0] if checkpoints else None
+    
+    def delete_checkpoint(self, checkpoint_id: str) -> bool:
+        """
+        删除指定的对话检查点
+        
+        Args:
+            checkpoint_id: 检查点ID
+            
+        Returns:
+            bool: 是否成功删除
+        """
+        file_path = os.path.join(self.store_dir, f"{checkpoint_id}.json")
+        
+        if not os.path.exists(file_path):
+            logger.warning(f"要删除的对话检查点不存在: {checkpoint_id}")
+            return False
+        
+        try:
+            os.remove(file_path)
+            logger.info(f"已删除对话检查点: {checkpoint_id}")
+            return True
+        except Exception as e:
+            logger.error(f"删除对话检查点失败: {str(e)}")
+            return False
+    
+    def _get_all_checkpoints(self) -> List[ConversationCheckpoint]:
+        """
+        获取所有对话检查点
+        
+        Returns:
+            List[ConversationCheckpoint]: 对话检查点列表
+        """
+        checkpoints = []
+        
+        try:
+            for filename in os.listdir(self.store_dir):
+                if filename.endswith('.json'):
+                    file_path = os.path.join(self.store_dir, filename)
+                    
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            data = json.load(f)
+                        
+                        checkpoint = ConversationCheckpoint(**data)
+                        checkpoints.append(checkpoint)
+                    except Exception as e:
+                        logger.error(f"读取对话检查点文件失败 {filename}: {str(e)}")
+        except Exception as e:
+            logger.error(f"获取所有对话检查点失败: {str(e)}")
+        
+        return checkpoints
+    
+    def _cleanup_old_checkpoints(self):
+        """清理过期的检查点，保持历史记录数量在限制范围内"""
+        checkpoints = self._get_all_checkpoints()
+        
+        if len(checkpoints) <= self.max_history:
+            return
+        
+        # 按时间戳降序排序
+        checkpoints.sort(key=lambda x: x.timestamp, reverse=True)
+        
+        # 删除超出限制的旧检查点
+        for checkpoint in checkpoints[self.max_history:]:
+            self.delete_checkpoint(checkpoint.checkpoint_id)