auto-coder 0.1.362__py3-none-any.whl → 0.1.364__py3-none-any.whl

autocoder/common/file_checkpoint/test_utils.py

@@ -0,0 +1,297 @@
+import pytest
+import os
+import tempfile
+import shutil
+import json
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from autocoder.common.file_checkpoint.utils import (
+    apply_shadow_changes, undo_last_changes, get_change_history
+)
+from autocoder.common.file_checkpoint.models import FileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager
+
+@pytest.fixture
+def temp_test_dir():
+    """提供一个临时的测试目录"""
+    temp_dir = tempfile.mkdtemp()
+    yield temp_dir
+    shutil.rmtree(temp_dir)
+
+@pytest.fixture
+def sample_file(temp_test_dir):
+    """创建一个用于测试的样例文件"""
+    file_path = os.path.join(temp_test_dir, "sample.txt")
+    with open(file_path, 'w', encoding='utf-8') as f:
+        f.write("这是一个测试文件的内容")
+    return file_path
+
+class TestApplyShadowChanges:
+    """apply_shadow_changes函数的单元测试"""
+    
+    def test_apply_new_file(self, temp_test_dir):
+        """测试应用新文件变更"""
+        # 准备影子系统变更
+        changes = {
+            "new_file.txt": {
+                "content": "这是新文件内容"
+            }
+        }
+        
+        # 应用变更
+        result = apply_shadow_changes(temp_test_dir, changes)
+        
+        # 检查结果
+        assert result['success'] is True
+        assert len(result['change_ids']) == 1
+        assert not result['errors']
+        assert "new_file.txt" in result['changed_files']
+        
+        # 检查文件是否被创建
+        new_file_path = os.path.join(temp_test_dir, "new_file.txt")
+        assert os.path.exists(new_file_path)
+        
+        # 检查文件内容
+        with open(new_file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "这是新文件内容"
+    
+    def test_apply_modify_file(self, temp_test_dir, sample_file):
+        """测试应用修改文件变更"""
+        # 获取相对路径
+        rel_path = os.path.relpath(sample_file, temp_test_dir)
+        
+        # 准备影子系统变更
+        changes = {
+            rel_path: {
+                "content": "修改后的内容"
+            }
+        }
+        
+        # 应用变更
+        result = apply_shadow_changes(temp_test_dir, changes)
+        
+        # 检查结果
+        assert result['success'] is True
+        assert len(result['change_ids']) == 1
+        assert not result['errors']
+        assert rel_path in result['changed_files']
+        
+        # 检查文件内容
+        with open(sample_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "修改后的内容"
+    
+    def test_apply_delete_file(self, temp_test_dir, sample_file):
+        """测试应用删除文件变更"""
+        # 获取相对路径
+        rel_path = os.path.relpath(sample_file, temp_test_dir)
+        
+        # 准备影子系统变更
+        changes = {
+            rel_path: {
+                "content": "",
+                "is_deletion": True
+            }
+        }
+        
+        # 应用变更
+        result = apply_shadow_changes(temp_test_dir, changes)
+        
+        # 检查结果
+        assert result['success'] is True
+        assert len(result['change_ids']) == 1
+        assert not result['errors']
+        assert rel_path in result['changed_files']
+        
+        # 检查文件是否被删除
+        assert not os.path.exists(sample_file)
+    
+    def test_apply_multiple_changes(self, temp_test_dir, sample_file):
+        """测试应用多个文件变更"""
+        # 获取相对路径
+        rel_path = os.path.relpath(sample_file, temp_test_dir)
+        
+        # 准备影子系统变更
+        changes = {
+            rel_path: {
+                "content": "修改后的内容"
+            },
+            "new_file.txt": {
+                "content": "新文件内容"
+            }
+        }
+        
+        # 应用变更
+        result = apply_shadow_changes(temp_test_dir, changes)
+        
+        # 检查结果
+        assert result['success'] is True
+        assert len(result['change_ids']) == 2
+        assert not result['errors']
+        assert rel_path in result['changed_files']
+        assert "new_file.txt" in result['changed_files']
+        
+        # 检查文件内容
+        with open(sample_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "修改后的内容"
+        
+        new_file_path = os.path.join(temp_test_dir, "new_file.txt")
+        assert os.path.exists(new_file_path)
+        with open(new_file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "新文件内容"
+
+
+class TestUndoLastChanges:
+    """undo_last_changes函数的单元测试"""
+    
+    def test_undo_single_change(self, temp_test_dir, sample_file):
+        """测试撤销单个变更"""
+        # 获取相对路径
+        rel_path = os.path.relpath(sample_file, temp_test_dir)
+        
+        # 先应用变更
+        changes = {
+            rel_path: {
+                "content": "修改后的内容"
+            }
+        }
+        apply_result = apply_shadow_changes(temp_test_dir, changes)
+        assert apply_result['success'] is True
+        
+        # 检查文件已被修改
+        with open(sample_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "修改后的内容"
+        
+        # 撤销变更
+        undo_result = undo_last_changes(temp_test_dir)
+        
+        # 检查撤销结果
+        assert undo_result['success'] is True
+        assert len(undo_result['restored_files']) == 1
+        assert rel_path in undo_result['restored_files']
+        
+        # 检查文件内容是否被恢复
+        with open(sample_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "这是一个测试文件的内容"
+    
+    def test_undo_multiple_steps(self, temp_test_dir, sample_file):
+        """测试撤销多个步骤"""
+        # 获取相对路径
+        rel_path = os.path.relpath(sample_file, temp_test_dir)
+        
+        # 应用第一个变更
+        changes1 = {
+            rel_path: {
+                "content": "第一次修改"
+            }
+        }
+        apply_result1 = apply_shadow_changes(temp_test_dir, changes1)
+        assert apply_result1['success'] is True
+        
+        # 应用第二个变更
+        changes2 = {
+            rel_path: {
+                "content": "第二次修改"
+            }
+        }
+        apply_result2 = apply_shadow_changes(temp_test_dir, changes2)
+        assert apply_result2['success'] is True
+        
+        # 检查文件内容
+        with open(sample_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "第二次修改"
+        
+        # 撤销两个步骤
+        undo_result = undo_last_changes(temp_test_dir, steps=2)
+        
+        # 检查撤销结果
+        assert undo_result['success'] is True
+        assert len(undo_result['restored_files']) == 2
+        
+        # 检查文件内容是否被恢复到原始状态
+        with open(sample_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        assert content == "这是一个测试文件的内容"
+    
+    def test_undo_with_error(self, temp_test_dir):
+        """测试撤销出错的情况"""
+        # 模拟FileChangeManager的undo_last_change方法返回错误
+        with patch.object(FileChangeManager, 'undo_last_change') as mock_undo:
+            from autocoder.common.file_checkpoint.models import UndoResult
+            error_result = UndoResult(success=False)
+            error_result.add_error("test.txt", "文件不存在")
+            mock_undo.return_value = error_result
+            
+            # 尝试撤销变更
+            undo_result = undo_last_changes(temp_test_dir)
+            
+            # 检查撤销结果
+            assert undo_result['success'] is False
+            assert "test.txt" in undo_result['errors']
+            assert undo_result['errors']["test.txt"] == "文件不存在"
+
+
+class TestGetChangeHistory:
+    """get_change_history函数的单元测试"""
+    
+    def test_get_history(self, temp_test_dir, sample_file):
+        """测试获取变更历史"""
+        # 获取相对路径
+        rel_path = os.path.relpath(sample_file, temp_test_dir)
+        
+        # 应用两个变更
+        changes1 = {
+            rel_path: {
+                "content": "第一次修改"
+            }
+        }
+        changes2 = {
+            "new_file.txt": {
+                "content": "新文件内容"
+            }
+        }
+        
+        apply_shadow_changes(temp_test_dir, changes1)
+        apply_shadow_changes(temp_test_dir, changes2)
+        
+        # 获取变更历史
+        history = get_change_history(temp_test_dir)
+        
+        # 检查历史记录
+        assert len(history) >= 2
+        
+        # 检查第一条记录（最新的，是new_file.txt）
+        assert history[0]['file_path'] == "new_file.txt"
+        assert history[0]['is_new'] is True
+        
+        # 检查第二条记录（较早的，是修改的sample_file）
+        assert history[1]['file_path'] == rel_path
+        assert history[1]['is_new'] is False
+    
+    def test_get_history_with_limit(self, temp_test_dir):
+        """测试限制历史记录数量"""
+        # 使用模拟的FileChangeManager
+        with patch.object(FileChangeManager, 'get_change_history') as mock_get_history:
+            # 创建模拟的返回值
+            from autocoder.common.file_checkpoint.models import ChangeRecord
+            mock_records = [
+                ChangeRecord.create(file_path=f"file{i}.txt", backup_id=f"backup{i}")
+                for i in range(5)
+            ]
+            mock_get_history.return_value = mock_records
+            
+            # 请求限制为3条记录
+            history = get_change_history(temp_test_dir, limit=3)
+            
+            # 检查参数调用
+            mock_get_history.assert_called_once_with(3)
+            
+            # 检查结果
+            assert len(history) == 5  # 模拟返回了5条记录 

autocoder/common/file_checkpoint/utils.py

@@ -0,0 +1,119 @@
+"""
+文件变更管理模块的工具函数
+
+提供一些常用的工具函数，简化文件变更管理模块的使用。
+"""
+
+import os
+import json
+from typing import Dict, List, Optional, Any
+
+from autocoder.common.file_checkpoint.models import FileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager
+
+
+def apply_shadow_changes(source_dir: str, changes: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    将影子系统的变更应用到用户项目中
+    
+    Args:
+        source_dir: 用户项目的根目录
+        changes: 影子系统的变更字典，格式为 {file_path: {content: str}}
+        
+    Returns:
+        Dict: 应用结果，包含成功和失败的信息
+    """
+    # 创建文件变更管理器
+    manager = FileChangeManager(source_dir)
+    
+    # 将影子系统的变更转换为 FileChange 对象
+    file_changes = {}
+    for file_path, change in changes.items():
+        # 确定文件是否是新文件
+        abs_file_path = os.path.join(source_dir, file_path)
+        is_new = not os.path.exists(abs_file_path)
+        
+        file_changes[file_path] = FileChange(
+            file_path=file_path,
+            content=change.get('content', ''),
+            is_new=is_new,
+            is_deletion=change.get('is_deletion', False)
+        )
+    
+    # 应用变更
+    result = manager.apply_changes(file_changes)
+    
+    # 返回结果
+    return {
+        'success': result.success,
+        'change_ids': result.change_ids,
+        'errors': result.errors,
+        'changed_files': list(file_changes.keys())
+    }
+
+
+def undo_last_changes(source_dir: str, steps: int = 1) -> Dict[str, Any]:
+    """
+    撤销最近的变更
+    
+    Args:
+        source_dir: 用户项目的根目录
+        steps: 要撤销的步骤数
+        
+    Returns:
+        Dict: 撤销结果，包含成功和失败的信息
+    """
+    # 创建文件变更管理器
+    manager = FileChangeManager(source_dir)
+    
+    # 执行多步撤销
+    all_restored_files = []
+    all_errors = {}
+    success = True
+    
+    for _ in range(steps):
+        result = manager.undo_last_change()
+        if not result.success:
+            success = False
+            all_errors.update(result.errors)
+            break
+        
+        all_restored_files.extend(result.restored_files)
+    
+    # 返回结果
+    return {
+        'success': success,
+        'restored_files': all_restored_files,
+        'errors': all_errors
+    }
+
+
+def get_change_history(source_dir: str, limit: int = 10) -> List[Dict[str, Any]]:
+    """
+    获取变更历史记录
+    
+    Args:
+        source_dir: 用户项目的根目录
+        limit: 返回的历史记录数量限制
+        
+    Returns:
+        List[Dict]: 变更记录列表
+    """
+    # 创建文件变更管理器
+    manager = FileChangeManager(source_dir)
+    
+    # 获取变更历史
+    changes = manager.get_change_history(limit)
+    
+    # 转换为字典列表
+    return [
+        {
+            'change_id': change.change_id,
+            'timestamp': change.timestamp,
+            'file_path': change.file_path,
+            'is_new': change.is_new,
+            'is_deletion': change.is_deletion,
+            'group_id': change.group_id
+        }
+        for change in changes
+    ]

autocoder/common/rulefiles/autocoderrules_utils.py

@@ -10,6 +10,7 @@ import byzerllm # Added import
 from pydantic import BaseModel, Field
 from typing import List, Dict, Optional, Any # Added Any
 from autocoder.common import AutoCoderArgs
+import concurrent.futures  # 添加线程池导入
 
 # 尝试导入 FileMonitor
 try:
@@ -25,7 +26,7 @@ class RuleFile(BaseModel):
     """规则文件的Pydantic模型"""
     description: str = Field(default="", description="规则的描述")
     globs: List[str] = Field(default_factory=list, description="文件匹配模式列表")
-    always_apply: bool = Field(default=False, alias="alwaysApply", description="是否总是应用规则")
+    always_apply: bool = Field(default=False, description="是否总是应用规则")
     content: str = Field(default="", description="规则文件的正文内容")
     file_path: str = Field(default="", description="规则文件的路径")
 
@@ -206,15 +207,14 @@ class AutocoderRulesManager:
                 except Exception as e:
                     logger.warning(f"解析规则文件YAML头部时出错: {e}")
             
-            # 创建并返回Pydantic模型
+            # 创建并返回Pydantic模型            
             rule = RuleFile(
                 description=metadata.get('description', ''),
                 globs=metadata.get('globs', []),
                 always_apply=metadata.get('alwaysApply', False),
                 content=markdown_content.strip(),
                 file_path=file_path
-            )
-            
+            )                                    
             return rule
             
         except Exception as e:
@@ -233,6 +233,25 @@ class AutocoderRulesManager:
             parsed_rules.append(parsed_rule)
         return parsed_rules
 
+    @classmethod
+    def reset_instance(cls):
+        """
+        重置单例实例。
+        如果当前实例正在运行，则先取消注册监控的目录，然后重置实例。
+        """
+        with cls._lock:
+            if cls._instance is not None:
+                # 取消注册监控的目录
+                if cls._instance._file_monitor:
+                    for dir_path in cls._instance._monitored_dirs:
+                        try:
+                            cls._instance._file_monitor.unregister(dir_path)
+                            logger.info(f"已取消注册目录监控: {dir_path}")
+                        except Exception as e:
+                            logger.warning(f"取消注册目录 {dir_path} 时出错: {e}")
+                cls._instance = None
+                logger.info("AutocoderRulesManager单例已被重置")
+
 
 # 对外提供单例
 _rules_manager = None
@@ -258,6 +277,11 @@ def parse_rule_file(file_path: str, project_root: Optional[str] = None) -> RuleF
         _rules_manager = AutocoderRulesManager(project_root=project_root)
     return _rules_manager.parse_rule_file(file_path)
 
+def reset_rules_manager():
+    """重置AutocoderRulesManager单例实例"""
+    AutocoderRulesManager.reset_instance()
+    global _rules_manager
+    _rules_manager = None
 
 # 添加用于返回类型的Pydantic模型
 class RuleRelevance(BaseModel):
@@ -313,10 +337,49 @@ class RuleSelector:
             "rule": rule,
             "context": context
         }
+        
+    def _evaluate_rule(self, rule: RuleFile, context: str) -> tuple[RuleFile, bool, Optional[str]]:
+        """
+        评估单个规则是否适用于当前上下文。
+        
+        Args:
+            rule: 要评估的规则
+            context: 上下文信息
+            
+        Returns:
+            tuple: (规则, 是否选中, 理由)
+        """
+        # 如果规则设置为总是应用，直接返回选中
+        if rule.always_apply:
+            return (rule, True, "规则设置为总是应用")
+            
+        # 如果没有LLM，无法评估non-always规则
+        if self.llm is None:
+            return (rule, False, "未提供LLM，无法评估non-always规则")
+            
+        try:
+            prompt = self._build_selection_prompt.prompt(rule=rule, context=context)
+            logger.debug(f"为规则 '{os.path.basename(rule.file_path)}' 生成的判断 Prompt (片段): {prompt[:200]}...")
+            
+            result = None
+            try:
+                # 使用with_return_type方法获取结构化结果
+                result = self._build_selection_prompt.with_llm(self.llm).with_return_type(RuleRelevance).run(rule=rule, context=context)
+                if result and result.is_relevant:
+                    return (rule, True, result.reason)
+                else:
+                    return (rule, False, result.reason if result else "未提供理由")
+            except Exception as e:
+                logger.warning(f"LLM 未能为规则 '{os.path.basename(rule.file_path)}' 提供有效响应: {e}")
+                return (rule, False, f"LLM评估出错: {str(e)}")
+                
+        except Exception as e:
+            logger.error(f"评估规则 '{os.path.basename(rule.file_path)}' 时出错: {e}", exc_info=True)
+            return (rule, False, f"评估过程出错: {str(e)}")
 
-    def select_rules(self, context: str, rules: List[RuleFile]) -> List[RuleFile]:
+    def select_rules(self, context: str) -> List[RuleFile]:
         """
-        选择适用于当前上下文的规则。
+        选择适用于当前上下文的规则。使用线程池并发评估规则。
 
         Args:
             context: 可选的字典，包含用于规则选择的上下文信息 (例如，用户指令、目标文件等)。
@@ -324,56 +387,47 @@ class RuleSelector:
         Returns:
             List[RuleFile]: 选定的规则列表。
         """
+        rules = get_parsed_rules()
         selected_rules: List[RuleFile] = []
         logger.info(f"开始选择规则，总规则数: {len(rules)}")
-
+        
+        # 预先分类处理always_apply规则
+        always_apply_rules = []
+        need_llm_rules = []
+        
         for rule in rules:
             if rule.always_apply:
-                selected_rules.append(rule)
-                logger.debug(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=True) 已自动选择。")
-                continue
-
-            if self.llm is None:
-                 logger.debug(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=False) 已跳过，因为未提供 LLM。")
-                 continue
-
-            # 对于 alwaysApply=False 的规则，使用 LLM 判断
-            try:
-                prompt = self._build_selection_prompt.prompt(rule=rule, context=context)
-                logger.debug(f"为规则 '{os.path.basename(rule.file_path)}' 生成的判断 Prompt (片段): {prompt[:200]}...")
-
-                # **** 实际LLM调用 ****
-                # 确保 self.llm 实例已正确初始化并可用
-                if self.llm: # Check if llm is not None                    
-                    result = None
-                    try:
-                        # 使用with_return_type方法获取结构化结果
-                        result = self._build_selection_prompt.with_llm(self.llm).with_return_type(RuleRelevance).run(rule=rule, context=context)
-                        if result and result.is_relevant:
-                            selected_rules.append(rule)
-                            logger.info(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=False) 已被 LLM 选择，原因: {result.reason}")
-                        else:
-                            logger.debug(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=False) 未被 LLM 选择，原因: {result.reason if result else '未提供'}")
-                    except Exception as e:                    
-                        logger.warning(f"LLM 未能为规则 '{os.path.basename(rule.file_path)}' 提供有效响应。")
-                        # 根据需要决定是否跳过或默认不选
-                        continue # 跳过此规则
-                else: # Handle case where self.llm is None after the initial check
-                    logger.warning(f"LLM instance became None unexpectedly for rule '{os.path.basename(rule.file_path)}'.")
-                    continue
-
-                # **** 模拟LLM调用 (用于测试/开发) ****
-                # 注释掉模拟部分，使用上面的实际调用
-                # simulated_response = "yes" if "always" in rule.description.lower() or "index" in rule.description.lower() else "no"
-                # logger.warning(f"模拟LLM判断规则 '{os.path.basename(rule.file_path)}': {simulated_response}")
-                # response_text = simulated_response
-                # **** 结束模拟 ****
-
-            except Exception as e:
-                logger.error(f"使用 LLM 判断规则 '{os.path.basename(rule.file_path)}' 时出错: {e}", exc_info=True)
-                # 根据策略决定是否包含出错的规则，这里选择跳过
-                continue
-
+                always_apply_rules.append(rule)
+            elif self.llm is not None:
+                need_llm_rules.append(rule)
+        
+        # 添加always_apply规则
+        for rule in always_apply_rules:
+            selected_rules.append(rule)
+            logger.debug(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=True) 已自动选择。")
+            
+        # 如果没有需要LLM评估的规则，直接返回结果
+        if not need_llm_rules:
+            logger.info(f"规则选择完成，选中规则数: {len(selected_rules)}")
+            return selected_rules
+            
+        # 使用线程池并发评估规则
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            # 提交所有评估任务
+            future_to_rule = {
+                executor.submit(self._evaluate_rule, rule, context): rule 
+                for rule in need_llm_rules
+            }
+            
+            # 收集评估结果
+            for future in concurrent.futures.as_completed(future_to_rule):
+                rule, is_selected, reason = future.result()
+                if is_selected:
+                    selected_rules.append(rule)
+                    logger.info(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=False) 已被 LLM 选择，原因: {reason}")
+                else:
+                    logger.debug(f"规则 '{os.path.basename(rule.file_path)}' (AlwaysApply=False) 未被 LLM 选择，原因: {reason}")
+                    
         logger.info(f"规则选择完成，选中规则数: {len(selected_rules)}")
         return selected_rules
 
@@ -393,9 +447,38 @@ class RuleSelector:
         # 保持 file_path 作为 key
         return {rule.file_path: rule.content for rule in selected_rules}
 
-def auto_select_rules(context: str, rules: List[RuleFile], llm: Optional[byzerllm.ByzerLLM] = None,args:Optional[AutoCoderArgs] = None) -> List[RuleFile]:
+def auto_select_rules(context: str, llm: Optional[byzerllm.ByzerLLM] = None,args:Optional[AutoCoderArgs] = None) -> List[Dict[str, str]]:
     """
     根据LLM的判断和规则元数据选择适用的规则。
     """
-    selector = RuleSelector(llm=llm, args=args)
-    return selector.select_rules(context=context, rules=rules)
+    selector = RuleSelector(llm=llm, args=args)    
+    return selector.get_selected_rules_content(context=context)
+
+def get_required_and_index_rules() -> Dict[str, str]:
+    """
+    获取所有必须应用的规则文件(always_apply=True)和Index.md文件。
+    
+    Args:
+        project_root: 可选的项目根目录路径，用于初始化规则管理器。
+        
+    Returns:
+        Dict[str, str]: 包含必须应用的规则和Index.md文件的{file_path: content}字典。
+    """
+    # 获取所有解析后的规则文件
+    parsed_rules = get_parsed_rules()
+    result: Dict[str, str] = {}
+    logger.info(f"获取所有解析后的规则文件完成，总数: {len(parsed_rules)}")
+    
+    for rule in parsed_rules:
+        # 检查是否是always_apply=True的规则
+        if rule.always_apply:
+            result[rule.file_path] = rule.content
+            logger.info(f"添加必须应用的规则: {os.path.basename(rule.file_path)}")
+        
+        # 检查是否是Index.md文件
+        if os.path.basename(rule.file_path).lower() == "index.md":
+            result[rule.file_path] = rule.content
+            logger.info(f"添加Index.md文件: {rule.file_path}")
+    
+    logger.info(f"获取必须应用的规则和Index.md文件完成，总数: {len(result)}")
+    return result