auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/rulefiles/utils/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+"""
+RuleFiles 工具函数
+
+包含解析器、监控器和其他实用工具。
+"""
+
+from .parser import (
+    parse_rule_file,
+    extract_yaml_metadata,
+    validate_rule_file_format,
+    get_rule_directories,
+    find_existing_rule_directories,
+)
+from .monitor import (
+    setup_file_monitor,
+    is_rule_related_change,
+    cleanup_file_monitor,
+    create_rule_change_callback,
+)
+
+
+__all__ = [
+    'parse_rule_file',
+    'extract_yaml_metadata',
+    'validate_rule_file_format',
+    'get_rule_directories',
+    'find_existing_rule_directories',
+    'setup_file_monitor',
+    'is_rule_related_change',
+    'cleanup_file_monitor',
+    'create_rule_change_callback',
+
+] 

autocoder/common/rulefiles/utils/monitor.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""
+监控工具 - 已弃用
+
+注意：此模块已弃用。RuleFiles 模块现在使用基于文件 MD5 的缓存失效机制，
+不再依赖文件监控。为了保持向后兼容性，此模块提供空的实现。
+"""
+
+import os
+from typing import Optional, List, Callable, Any
+from loguru import logger
+
+
+def setup_file_monitor(
+    project_root: str,
+    monitored_dirs: List[str],
+    callback: Callable[[Any, str], None]
+) -> Optional[Any]:
+    """
+    设置文件监控 - 已弃用
+    
+    注意：此函数已弃用，不再提供实际的监控功能。
+    RuleFiles 模块现在使用基于文件 MD5 的缓存失效机制。
+    
+    Args:
+        project_root: 项目根目录
+        monitored_dirs: 要监控的目录列表
+        callback: 文件变化时的回调函数
+        
+    Returns:
+        None: 不再返回 FileMonitor 实例
+    """
+    logger.warning("setup_file_monitor 已弃用，RuleFiles 模块现在使用基于 MD5 的缓存失效机制")
+    return None
+
+
+def is_rule_related_change(changed_path: str, monitored_dirs: List[str]) -> bool:
+    """
+    检查变更是否与规则相关 - 已弃用
+    
+    注意：此函数已弃用，不再提供实际的检查功能。
+    
+    Args:
+        changed_path: 发生变化的文件路径
+        monitored_dirs: 监控的目录列表
+        
+    Returns:
+        False: 始终返回 False
+    """
+    logger.warning("is_rule_related_change 已弃用")
+    return False
+
+
+def cleanup_file_monitor(file_monitor: Optional[Any], monitored_dirs: List[str]) -> None:
+    """
+    清理文件监控 - 已弃用
+    
+    注意：此函数已弃用，不再提供实际的清理功能。
+    
+    Args:
+        file_monitor: FileMonitor 实例（忽略）
+        monitored_dirs: 监控的目录列表（忽略）
+    """
+    logger.warning("cleanup_file_monitor 已弃用")
+    pass
+
+
+def create_rule_change_callback(reload_rules_func: Callable[[], None]) -> Callable[[Any, str], None]:
+    """
+    创建规则变化回调函数 - 已弃用
+    
+    注意：此函数已弃用，不再提供实际的回调功能。
+    
+    Args:
+        reload_rules_func: 重新加载规则的函数（忽略）
+        
+    Returns:
+        Callable: 空的回调函数
+    """
+    logger.warning("create_rule_change_callback 已弃用")
+    
+    def dummy_callback(change_type: Any, changed_path: str):
+        """空的回调函数"""
+        pass
+    
+    return dummy_callback 

autocoder/common/rulefiles/utils/parser.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+"""
+规则文件解析工具
+
+提供规则文件解析相关的实用工具函数。
+"""
+
+import os
+import re
+import yaml
+from typing import Dict, Any
+from loguru import logger
+
+from ..models.rule_file import RuleFile
+
+# 导入优先级目录查找器
+from autocoder.common.priority_directory_finder import (
+    PriorityDirectoryFinder, FinderConfig, SearchStrategy, 
+    ValidationMode, create_file_filter
+)
+
+
+def parse_rule_file(file_path: str) -> RuleFile:
+    """
+    解析规则文件并返回结构化的Pydantic模型对象
+    
+    Args:
+        file_path: 规则文件的路径
+        
+    Returns:
+        RuleFile: 包含规则文件结构化内容的Pydantic模型
+        
+    Raises:
+        FileNotFoundError: 当文件不存在时
+        ValueError: 当文件格式无效时
+    """
+    if not os.path.exists(file_path):
+        logger.error(f"规则文件不存在: {file_path}")
+        raise FileNotFoundError(f"规则文件不存在: {file_path}")
+        
+    if not file_path.endswith('.md'):
+        logger.error(f"无效的规则文件格式，必须是.md文件: {file_path}")
+        raise ValueError(f"无效的规则文件格式，必须是.md文件: {file_path}")
+        
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # 解析YAML头部和Markdown内容
+        yaml_pattern = re.compile(r'^---\s*\n(.*?)\n---\s*\n', re.DOTALL)
+        yaml_match = yaml_pattern.search(content)
+        
+        metadata = {}
+        markdown_content = content
+        
+        if yaml_match:
+            yaml_content = yaml_match.group(1)
+            try:
+                metadata = yaml.safe_load(yaml_content)
+                # 移除YAML部分，仅保留Markdown内容
+                markdown_content = content[yaml_match.end():]
+            except Exception as e:
+                logger.warning(f"解析规则文件YAML头部时出错: {e}")
+        
+        # 创建并返回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 (FileNotFoundError, ValueError):
+        # 重新抛出已知的异常
+        raise
+    except Exception as e:
+        logger.error(f"解析规则文件时出现未知错误: {file_path}, 错误: {e}")
+        raise RuntimeError(f"解析规则文件失败: {file_path}") from e
+
+
+def extract_yaml_metadata(content: str) -> tuple[Dict[str, Any], str]:
+    """
+    从文件内容中提取 YAML 前置元数据和 Markdown 内容
+    
+    Args:
+        content: 文件内容
+        
+    Returns:
+        tuple: (元数据字典, Markdown内容)
+    """
+    yaml_pattern = re.compile(r'^---\s*\n(.*?)\n---\s*\n', re.DOTALL)
+    yaml_match = yaml_pattern.search(content)
+    
+    metadata = {}
+    markdown_content = content
+    
+    if yaml_match:
+        yaml_content = yaml_match.group(1)
+        try:
+            metadata = yaml.safe_load(yaml_content) or {}
+            # 移除YAML部分，仅保留Markdown内容
+            markdown_content = content[yaml_match.end():]
+        except Exception as e:
+            logger.warning(f"解析YAML头部时出错: {e}")
+    
+    return metadata, markdown_content.strip()
+
+
+def validate_rule_file_format(file_path: str) -> bool:
+    """
+    验证规则文件格式是否正确
+    
+    Args:
+        file_path: 规则文件路径
+        
+    Returns:
+        bool: 是否为有效的规则文件格式
+    """
+    if not os.path.exists(file_path):
+        return False
+        
+    if not file_path.endswith('.md'):
+        return False
+        
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # 检查是否可以正常解析
+        metadata, markdown_content = extract_yaml_metadata(content)
+        
+        # 基本验证：确保有内容
+        if not markdown_content.strip():
+            return False
+            
+        return True
+        
+    except Exception:
+        return False
+
+
+def get_rule_directories(project_root: str) -> list[str]:
+    """
+    获取所有可能的规则目录路径（按优先级排序）
+    
+    Args:
+        project_root: 项目根目录
+        
+    Returns:
+        list[str]: 规则目录路径列表（按优先级排序）
+    """
+    return [
+        os.path.join(project_root, ".autocoderrules"),
+        os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+        os.path.join(project_root, ".auto-coder", "autocoderrules")
+    ]
+
+
+def find_existing_rule_directories(project_root: str) -> list[str]:
+    """
+    使用优先级目录查找器查找实际存在且包含规则文件的目录。
+    
+    Args:
+        project_root: 项目根目录
+        
+    Returns:
+        list[str]: 实际存在且包含规则文件的目录路径列表
+    """
+    try:
+        # 创建文件过滤器，只查找.md文件
+        md_filter = create_file_filter(extensions=[".md"], recursive=True)
+        
+        # 创建查找器配置，使用LIST_ALL策略返回所有有效目录
+        config = FinderConfig(strategy=SearchStrategy.LIST_ALL)
+        
+        # 按优先级添加目录配置
+        config.add_directory(
+            path=os.path.join(project_root, ".autocoderrules"),
+            priority=1,
+            validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+            file_filter=md_filter,
+            description="项目级规则目录"
+        )
+        config.add_directory(
+            path=os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+            priority=2,
+            validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+            file_filter=md_filter,
+            description="项目.auto-coder规则目录"
+        )
+        config.add_directory(
+            path=os.path.join(project_root, ".auto-coder", "autocoderrules"),
+            priority=3,
+            validation_mode=ValidationMode.HAS_SPECIFIC_FILES,
+            file_filter=md_filter,
+            description="项目.auto-coder/autocoderrules目录"
+        )
+        
+        # 执行查找
+        finder = PriorityDirectoryFinder(config)
+        result = finder.find_directories()
+        
+        if result.success:
+            logger.info(f"使用优先级查找器找到 {len(result.selected_directories)} 个有效规则目录")
+            return result.selected_directories
+        else:
+            logger.info("优先级查找器未找到包含规则文件的目录")
+            return []
+            
+    except Exception as e:
+        logger.error(f"使用优先级查找器查找规则目录时出错: {e}")
+        # 回退到传统方法
+        return _find_existing_rule_directories_fallback(project_root)
+
+
+def _find_existing_rule_directories_fallback(project_root: str) -> list[str]:
+    """
+    回退到传统的目录查找方法。
+    
+    Args:
+        project_root: 项目根目录
+        
+    Returns:
+        list[str]: 实际存在的规则目录路径列表
+    """
+    logger.info("回退到传统的规则目录查找方法")
+    potential_dirs = get_rule_directories(project_root)
+    return [d for d in potential_dirs if os.path.isdir(d)] 

autocoder/common/save_formatted_log.py

@@ -4,6 +4,7 @@ import json
 import uuid
 from datetime import datetime
 from loguru import logger # Added import
+from typing import Optional
 
 # New helper function for cleaning up logs
 def _cleanup_logs(logs_dir: str, max_files: int = 100):
@@ -21,9 +22,10 @@ def _cleanup_logs(logs_dir: str, max_files: int = 100):
         if filename.endswith(".md"):
             parts = filename.split('_')
             # Expected format: <YYYYmmdd_HHMMSS>_<uuid>_<suffix>.md
-            # parts[0] should be the full timestamp string "YYYYmmdd_HHMMSS"
-            if len(parts) >= 2: # At least timestamp and uuid part (suffix might be empty or complex)
-                timestamp_str = parts[0]
+            # parts[0] should be date part "YYYYmmdd" and parts[1] should be time part "HHMMSS"
+            if len(parts) >= 3: # At least date, time, and uuid parts
+                # Reconstruct the full timestamp from first two parts
+                timestamp_str = parts[0] + '_' + parts[1]
                 try:
                     # Validate the timestamp format
                     datetime.strptime(timestamp_str, "%Y%m%d_%H%M%S")
@@ -33,7 +35,7 @@ def _cleanup_logs(logs_dir: str, max_files: int = 100):
                     continue
             else:
                 # Log the parts for better debugging if needed
-                logger.debug(f"文件名 {filename} (分割后: {parts}) 不符合预期的下划线分割数量 (至少需要 <timestamp>_<uuid>_...)，跳过。")
+                logger.debug(f"文件名 {filename} (分割后: {parts}) 不符合预期的下划线分割数量 (至少需要 <date>_<time>_<uuid>_...)，跳过。")
 
     # Sort by timestamp (oldest first)
     log_files.sort(key=lambda x: x[0])
@@ -53,18 +55,20 @@ def _cleanup_logs(logs_dir: str, max_files: int = 100):
         logger.debug(f"日志文件数量 ({len(log_files)}) 未超过限制 ({max_files})，无需删除。")
 
 
-def save_formatted_log(project_root, json_text, suffix):
+def save_formatted_log(project_root, json_text, suffix, conversation_id:Optional[str]=None, log_subdir:str="agentic"):
     """
-    Save a JSON log as a formatted markdown file under project_root/.auto-coder/logs/agentic.
+    Save a JSON log as a formatted markdown file under project_root/.auto-coder/logs/{log_subdir}.
     Filename: <YYYYmmdd_HHMMSS>_<uuid>_<suffix>.md
     Also cleans up old logs in the directory, keeping the latest 100.
     Args:
         project_root (str): The root directory of the project.
         json_text (str): The JSON string to be formatted and saved.
         suffix (str): The suffix for the filename.
+        conversation_id (str, optional): If provided, use this as unique_id and search for existing files to overwrite.
+        log_subdir (str): The subdirectory under .auto-coder/logs/ to save the file. Default is "agentic".
     """
     # Prepare directory (logs_dir is needed for cleanup first)
-    logs_dir = os.path.join(project_root, ".auto-coder", "logs", "agentic")
+    logs_dir = os.path.join(project_root, ".auto-coder", "logs", log_subdir)
 
     # Cleanup old logs BEFORE saving the new one
     try:
@@ -82,6 +86,38 @@ def save_formatted_log(project_root, json_text, suffix):
         logger.exception(e) # Log stack trace
         raise ValueError(f"Invalid JSON provided: {e}")
 
+    # Filter out system role entries
+    def filter_system_role(obj):
+        """Recursively filter out entries where role equals 'system'"""
+        if isinstance(obj, dict):
+            # If this dict has role='system', skip it entirely
+            if obj.get('role') == 'system':
+                return None
+            # Otherwise, recursively filter all values
+            filtered_dict = {}
+            for key, value in obj.items():
+                filtered_value = filter_system_role(value)
+                if filtered_value is not None:
+                    filtered_dict[key] = filtered_value
+            return filtered_dict if filtered_dict else None
+        elif isinstance(obj, list):
+            # Filter list items, keeping only non-None results
+            filtered_list = []
+            for item in obj:
+                filtered_item = filter_system_role(item)
+                if filtered_item is not None:
+                    filtered_list.append(filtered_item)
+            return filtered_list if filtered_list else None
+        else:
+            # For primitive types, return as-is
+            return obj
+
+    # Apply the filter
+    data = filter_system_role(data)
+    if data is None:
+        logger.warning("过滤后的数据为空，将保存空日志")
+        data = {}
+
     # Format as markdown with recursive depth
     def to_markdown(obj, level=1):
         lines = []
@@ -108,9 +144,30 @@ def save_formatted_log(project_root, json_text, suffix):
 
     # Prepare filename
     now = datetime.now().strftime("%Y%m%d_%H%M%S")
-    unique_id = str(uuid.uuid4())
-    filename = f"{now}_{unique_id}_{suffix}.md"
-    filepath = os.path.join(logs_dir, filename)
+    
+    # Handle conversation_id logic
+    if conversation_id is not None:
+        unique_id = conversation_id
+        
+        # Search for existing files with this conversation_id
+        existing_file = None
+        if os.path.isdir(logs_dir):
+            for filename in os.listdir(logs_dir):
+                if filename.endswith(".md") and conversation_id in filename and suffix in filename:
+                    existing_file = os.path.join(logs_dir, filename)
+                    logger.info(f"找到包含 conversation_id ({conversation_id}) 的现有文件: {filename}，将覆盖该文件")
+                    break
+        
+        if existing_file:
+            filepath = existing_file
+        else:
+            filename = f"{now}_{unique_id}_{suffix}.md"
+            filepath = os.path.join(logs_dir, filename)
+            logger.info(f"未找到包含 conversation_id ({conversation_id}) 的文件，将创建新文件: {filename}")
+    else:
+        unique_id = str(uuid.uuid4())
+        filename = f"{now}_{unique_id}_{suffix}.md"
+        filepath = os.path.join(logs_dir, filename)
 
     # Save file
     try:

autocoder/common/search_replace.py

@@ -3,7 +3,14 @@
 import sys
 from pathlib import Path
 
-import git
+# 延迟导入git模块以避免启动异常
+try:
+    import git
+    GIT_AVAILABLE = True
+except ImportError:
+    print("Warning: Git module not available. Some git features will be disabled.")
+    GIT_AVAILABLE = False
+    git = None
 from diff_match_patch import diff_match_patch
 from tqdm import tqdm
 import json

autocoder/common/search_replace_patch/__init__.py

@@ -0,0 +1,24 @@
+"""
+Search Replace Patch Module
+
+提供三种文本替换策略：
+1. 正则表达式替换 (RegexReplacer)
+2. 补丁库替换 (PatchReplacer)
+3. 文本相似度替换 (SimilarityReplacer)
+"""
+
+from .base import BaseReplacer, ReplaceResult, ReplaceStrategy
+from .string_replacer import StringReplacer
+from .patch_replacer import PatchReplacer
+from .similarity_replacer import SimilarityReplacer
+from .manager import SearchReplaceManager
+
+__all__ = [
+    'BaseReplacer',
+    'ReplaceResult',
+    'ReplaceStrategy',
+    'StringReplacer',
+    'PatchReplacer',
+    'SimilarityReplacer',
+    'SearchReplaceManager',
+] 

autocoder/common/search_replace_patch/base.py

@@ -0,0 +1,115 @@
+"""
+Base classes for search replace patch operations
+"""
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Optional, Dict, Any, List, Tuple
+from dataclasses import dataclass, field
+
+
+class ReplaceStrategy(Enum):
+    """替换策略枚举"""
+    STRING = "string"
+    PATCH = "patch"
+    SIMILARITY = "similarity"
+
+
+@dataclass
+class ReplaceResult:
+    """替换结果"""
+    success: bool
+    message: str
+    new_content: Optional[str] = None
+    applied_count: int = 0
+    total_count: int = 0
+    errors: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class BaseReplacer(ABC):
+    """文本替换器的抽象基类"""
+    
+    def __init__(self, strategy: ReplaceStrategy):
+        self.strategy = strategy
+    
+    @abstractmethod
+    def replace(self, content: str, search_blocks: List[Tuple[str, str]]) -> ReplaceResult:
+        """
+        执行文本替换操作
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表 [(search_text, replace_text), ...]
+            
+        Returns:
+            ReplaceResult: 替换结果
+        """
+        pass
+    
+    @abstractmethod
+    def can_handle(self, content: str, search_blocks: List[Tuple[str, str]]) -> bool:
+        """
+        检查当前替换器是否能处理给定的内容和搜索块
+        
+        Args:
+            content: 原始文件内容
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            bool: 是否能处理
+        """
+        pass
+    
+    def get_strategy_name(self) -> str:
+        """获取策略名称"""
+        return self.strategy.value
+    
+    def validate_search_blocks(self, search_blocks: List[Tuple[str, str]]) -> bool:
+        """
+        验证搜索替换块的有效性
+        
+        Args:
+            search_blocks: 搜索替换块列表
+            
+        Returns:
+            bool: 是否有效
+        """
+        if not search_blocks:
+            return False
+        
+        for search_text, replace_text in search_blocks:
+            if not isinstance(search_text, str) or not isinstance(replace_text, str):
+                return False
+            
+            # 允许空 search_text，表示"插入"操作（行级插入）
+            if search_text == "":
+                continue
+            
+            # 其他空白搜索文本仍然无效
+            if not search_text.strip():
+                return False
+            
+            # 硬约束：只支持行级替换，不支持行内替换
+            if not self._is_line_level_replacement(search_text):
+                return False
+                
+        return True
+    
+    def _is_line_level_replacement(self, search_text: str) -> bool:
+        """
+        检查是否为行级替换
+        
+        Args:
+            search_text: 搜索文本
+            
+        Returns:
+            bool: 是否为行级替换
+        """
+        # 如果搜索文本包含换行符，认为是多行替换，允许
+        if '\n' in search_text:
+            return True
+        
+        # 如果是单行文本，必须是完整的行（以换行符结尾）
+        # 但我们放宽条件：允许不以换行符结尾的文本，但在实际替换时会按整行处理
+        return True  # 暂时放宽，在具体替换器中实施严格约束