auto-coder 0.1.353__py3-none-any.whl → 0.1.355__py3-none-any.whl

autocoder/common/ignorefiles/test_ignore_file_utils.py

@@ -0,0 +1,91 @@
+
+import os
+import shutil
+from pathlib import Path
+
+import pytest
+
+from src.autocoder.common.ignorefiles import ignore_file_utils
+
+@pytest.fixture(autouse=True)
+def cleanup_ignore_manager(monkeypatch):
+    """
+    在每个测试前后清理 IgnoreFileManager 的单例状态，保证测试隔离
+    """
+    # 备份原始实例
+    original_instance = ignore_file_utils._ignore_manager
+    # 强制重新加载忽略规则
+    def reset_ignore_manager():
+        ignore_file_utils.IgnoreFileManager._instance = None
+        return ignore_file_utils.IgnoreFileManager()
+
+    monkeypatch.setattr(ignore_file_utils, "_ignore_manager", reset_ignore_manager())
+    yield
+    # 恢复原始实例
+    ignore_file_utils._ignore_manager = original_instance
+
+
+def test_default_excludes(tmp_path, monkeypatch):
+    # 切换当前工作目录
+    monkeypatch.chdir(tmp_path)
+
+    # 不创建任何 .autocoderignore 文件，使用默认排除规则
+    # 创建默认排除目录
+    for dirname in ignore_file_utils.DEFAULT_EXCLUDES:
+        (tmp_path / dirname).mkdir(parents=True, exist_ok=True)
+        # 应该被忽略
+        assert ignore_file_utils.should_ignore(str(tmp_path / dirname)) is True
+
+    # 创建不会被忽略的文件
+    normal_file = tmp_path / "myfile.txt"
+    normal_file.write_text("hello")
+    assert ignore_file_utils.should_ignore(str(normal_file)) is False
+
+
+def test_custom_ignore_file(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    # 创建自定义忽略文件
+    ignore_file = tmp_path / ".autocoderignore"
+    ignore_file.write_text("data/**\nsecret.txt")
+
+    # 重新初始化忽略管理器以加载新规则
+    ignore_file_utils.IgnoreFileManager._instance = None
+    ignore_file_utils._ignore_manager = ignore_file_utils.IgnoreFileManager()
+
+    # 符合忽略规则的路径
+    ignored_dir = tmp_path / "data" / "subdir"
+    ignored_dir.mkdir(parents=True)
+    ignored_file = tmp_path / "secret.txt"
+    ignored_file.write_text("secret")
+
+    assert ignore_file_utils.should_ignore(str(ignored_dir)) is True
+    assert ignore_file_utils.should_ignore(str(ignored_file)) is True
+
+    # 不应被忽略的文件
+    normal_file = tmp_path / "keepme.txt"
+    normal_file.write_text("keep me")
+    assert ignore_file_utils.should_ignore(str(normal_file)) is False
+
+
+def test_nested_ignore_file(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+
+    # 没有根目录的.ignore，创建.auto-coder/.autocoderignore
+    nested_dir = tmp_path / ".auto-coder"
+    nested_dir.mkdir()
+
+    ignore_file = nested_dir / ".autocoderignore"
+    ignore_file.write_text("logs/**")
+
+    # 重新初始化忽略管理器以加载新规则
+    ignore_file_utils.IgnoreFileManager._instance = None
+    ignore_file_utils._ignore_manager = ignore_file_utils.IgnoreFileManager()
+
+    ignored_dir = tmp_path / "logs" / "2024"
+    ignored_dir.mkdir(parents=True)
+    assert ignore_file_utils.should_ignore(str(ignored_dir)) is True
+
+    normal_file = tmp_path / "main.py"
+    normal_file.write_text("# main")
+    assert ignore_file_utils.should_ignore(str(normal_file)) is False

autocoder/common/rulefiles/__init__.py

@@ -0,0 +1,15 @@
+
+# -*- coding: utf-8 -*-
+"""
+AutoCoder 规则文件管理模块
+
+提供读取、解析和监控 AutoCoder 规则文件的功能。
+"""
+
+from .autocoderrules_utils import (
+    get_rules,
+)
+
+__all__ = [
+    'get_rules',
+]

autocoder/common/rulefiles/autocoderrules_utils.py

@@ -0,0 +1,173 @@
+import os
+from pathlib import Path
+from threading import Lock
+import threading
+from typing import Dict, List, Optional
+from loguru import logger
+
+# 尝试导入 FileMonitor
+try:
+    from autocoder.common.file_monitor.monitor import FileMonitor, Change
+except ImportError:
+    # 如果导入失败，提供一个空的实现
+    logger.warning("警告: 无法导入 FileMonitor，规则文件变更监控将不可用")
+    FileMonitor = None
+    Change = None
+
+
+class AutocoderRulesManager:
+    """
+    管理和监控 autocoderrules 目录中的规则文件。
+    
+    实现单例模式，确保全局只有一个规则管理实例。
+    支持监控规则文件变化，当规则文件变化时自动重新加载。
+    """
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, project_root: Optional[str] = None):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(AutocoderRulesManager, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, project_root: Optional[str] = None):
+        if self._initialized:
+            return
+        self._initialized = True
+        
+        self._rules: Dict[str, str] = {}  # 存储规则文件内容: {file_path: content}
+        self._rules_dir: Optional[str] = None  # 当前使用的规则目录
+        self._file_monitor = None  # FileMonitor 实例
+        self._monitored_dirs: List[str] = []  # 被监控的目录列表
+        self._project_root = project_root if project_root is not None else os.getcwd()  # 项目根目录
+        
+        # 加载规则
+        self._load_rules()
+        # 设置文件监控
+        self._setup_file_monitor()
+
+    def _load_rules(self):
+        """
+        按优先级顺序加载规则文件。
+        优先级顺序：
+        1. .autocoderrules/
+        2. .auto-coder/.autocoderrules/
+        3. .auto-coder/autocoderrules/
+        """
+        self._rules = {}
+        project_root = self._project_root
+        
+        # 按优先级顺序定义可能的规则目录
+        rules_dirs = [
+            os.path.join(project_root, ".autocoderrules"),
+            os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+            os.path.join(project_root, ".auto-coder", "autocoderrules")
+        ]
+        
+        # 按优先级查找第一个存在的目录
+        found_dir = None
+        for rules_dir in rules_dirs:
+            if os.path.isdir(rules_dir):
+                found_dir = rules_dir
+                break
+        
+        if not found_dir:
+            logger.info("未找到规则目录")
+            return
+        
+        self._rules_dir = found_dir
+        logger.info(f"使用规则目录: {self._rules_dir}")
+        
+        # 加载目录中的所有 .md 文件
+        try:
+            for fname in os.listdir(self._rules_dir):
+                if fname.endswith(".md"):
+                    fpath = os.path.join(self._rules_dir, fname)
+                    try:
+                        with open(fpath, "r", encoding="utf-8") as f:
+                            content = f.read()
+                            self._rules[fpath] = content
+                            logger.info(f"已加载规则文件: {fpath}")
+                    except Exception as e:
+                        logger.info(f"加载规则文件 {fpath} 时出错: {e}")
+                        continue
+        except Exception as e:
+            logger.info(f"读取规则目录 {self._rules_dir} 时出错: {e}")
+
+    def _setup_file_monitor(self):
+        """设置文件监控，当规则文件或目录变化时重新加载规则"""
+        if FileMonitor is None or not self._rules_dir:
+            return
+        
+        try:
+            # 获取项目根目录
+            project_root = self._project_root
+            
+            # 创建 FileMonitor 实例
+            self._file_monitor = FileMonitor(root_dir=project_root)
+            
+            # 监控所有可能的规则目录
+            self._monitored_dirs = [
+                os.path.join(project_root, ".autocoderrules"),
+                os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+                os.path.join(project_root, ".auto-coder", "autocoderrules")
+            ]
+            
+            # 注册目录监控
+            for dir_path in self._monitored_dirs:
+                # 创建目录（如果不存在）
+                os.makedirs(dir_path, exist_ok=True)
+                # 注册监控
+                self._file_monitor.register(dir_path, self._on_rules_changed)
+                logger.info(f"已注册规则目录监控: {dir_path}")
+            
+            # 启动监控
+            if not self._file_monitor.is_running():
+                self._file_monitor.start()
+                logger.info("规则文件监控已启动")
+                
+        except Exception as e:
+            logger.warning(f"设置规则文件监控时出错: {e}")
+
+    def _on_rules_changed(self, change_type: Change, changed_path: str):
+        """当规则文件或目录发生变化时的回调函数"""
+        # 检查变化是否与规则相关
+        is_rule_related = False
+        
+        # 检查是否是 .md 文件
+        if changed_path.endswith(".md"):
+            # 检查文件是否在监控的目录中
+            for dir_path in self._monitored_dirs:
+                if os.path.abspath(changed_path).startswith(os.path.abspath(dir_path)):
+                    is_rule_related = True
+                    break
+        else:
+            # 检查是否是监控的目录本身
+            for dir_path in self._monitored_dirs:
+                if os.path.abspath(changed_path) == os.path.abspath(dir_path):
+                    is_rule_related = True
+                    break
+        
+        if is_rule_related:
+            logger.info(f"检测到规则相关变化 ({change_type.name}): {changed_path}")
+            # 重新加载规则
+            self._load_rules()
+            logger.info("已重新加载规则")
+
+    def get_rules(self) -> Dict[str, str]:
+        """获取所有规则文件内容"""
+        return self._rules.copy()
+
+
+# 对外提供单例
+_rules_manager = None
+
+def get_rules(project_root: Optional[str] = None) -> Dict[str, str]:
+    """获取所有规则文件内容，可指定项目根目录"""
+    global _rules_manager
+    if _rules_manager is None:
+        _rules_manager = AutocoderRulesManager(project_root=project_root)
+    return _rules_manager.get_rules()

autocoder/common/save_formatted_log.py

@@ -0,0 +1,54 @@
+import os
+import json
+import uuid
+from datetime import datetime
+
+def save_formatted_log(project_root, json_text, suffix):
+    """
+    Save a JSON log as a formatted markdown file under project_root/.cache/logs.
+    Filename: <YYYYmmdd_HHMMSS>_<uuid>_<suffix>.md
+    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.
+    """
+    # Parse JSON
+    try:
+        data = json.loads(json_text)
+    except Exception as e:
+        raise ValueError(f"Invalid JSON provided: {e}")
+
+    # Format as markdown with recursive depth
+    def to_markdown(obj, level=1):
+        lines = []
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                lines.append(f"{'#' * (level + 1)} {key}\n")
+                lines.extend(to_markdown(value, level + 1))
+        elif isinstance(obj, list):
+            for idx, item in enumerate(obj, 1):
+                lines.append(f"{'#' * (level + 1)} Item {idx}\n")
+                lines.extend(to_markdown(item, level + 1))
+        else:
+            lines.append(str(obj) + "\n")
+        return lines
+
+    md_lines = ["# Log Entry\n"]
+    md_lines.extend(to_markdown(data, 1))
+    md_content = "\n".join(md_lines)
+
+    # Prepare directory
+    logs_dir = os.path.join(project_root, ".cache", "logs")
+    os.makedirs(logs_dir, exist_ok=True)
+
+    # 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)
+
+    # Save file
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(md_content)
+
+    return filepath

autocoder/common/v2/agent/agentic_edit.py

@@ -1,6 +1,3 @@
-from autocoder.common.v2.agent.agentic_edit_conversation import AgenticConversation
-from enum import Enum
-from enum import Enum
 import json
 import os
 import time
@@ -55,7 +52,7 @@ from autocoder.common.v2.agent.agentic_edit_tools import (  # Import specific re
     AttemptCompletionToolResolver, PlanModeRespondToolResolver, UseMcpToolResolver,
     ListPackageInfoToolResolver
 )
-
+from autocoder.common.rulefiles.autocoderrules_utils import get_rules
 from autocoder.common.v2.agent.agentic_edit_types import (AgenticEditRequest, ToolResult,
                                                           MemoryConfig, CommandConfig, BaseTool,
                                                           ExecuteCommandTool, ReadFileTool,
@@ -119,12 +116,7 @@ class AgenticEdit:
         self.memory_config = memory_config
         self.command_config = command_config  # Note: command_config might be unused now
         self.project_type_analyzer = ProjectTypeAnalyzer(
-            args=args, llm=self.llm)
-
-        self.conversation_manager = AgenticConversation(
-            args, self.conversation_history, conversation_name=conversation_name)
-        # 当前不开启历史记录，所以清空
-        self.conversation_manager.clear_history()
+            args=args, llm=self.llm)        
 
         self.shadow_manager = ShadowManager(
             args.source_dir, args.event_file, args.ignore_clean_shadows)
@@ -687,21 +679,8 @@ class AgenticEdit:
         {% endif %}
         """
         import os
-        extra_docs = {}
-        rules_dir = os.path.join(self.args.source_dir,
-                                 ".auto-coder", "autocoderrules")
-        if os.path.isdir(rules_dir):
-            for fname in os.listdir(rules_dir):
-                if fname.endswith(".md"):
-                    fpath = os.path.join(rules_dir, fname)
-                    try:
-                        with open(fpath, "r", encoding="utf-8") as f:
-                            content = f.read()
-                            key = fpath
-                            extra_docs[key] = content
-                    except Exception:
-                        continue
-
+        extra_docs = get_rules()
+        
         env_info = detect_env()
         shell_type = "bash"
         if shells.is_running_in_cmd():
@@ -793,12 +772,10 @@ Below are some files the user is focused on, and the content is up to date. Thes
             "role":"assistant","content":"Ok"
         })
         
-        logger.info("Adding conversation history")
-        conversations.extend(self.conversation_manager.get_history())        
+        logger.info("Adding conversation history")        
         conversations.append({
             "role": "user", "content": request.user_input
-        })
-        self.conversation_manager.add_user_message(request.user_input)
+        })        
         
         logger.info(
             f"Initial conversation history size: {len(conversations)}")
@@ -808,7 +785,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
         while True:
             iteration_count += 1            
             logger.info(f"Starting LLM interaction cycle #{iteration_count}")
-            global_cancel.check_and_raise()
+            global_cancel.check_and_raise(token=self.args.event_file)
             last_message = conversations[-1]
             if last_message["role"] == "assistant":
                 logger.info(f"Last message is assistant, skipping LLM interaction cycle")
@@ -838,7 +815,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
             for event in parsed_events:
                 event_count += 1
                 logger.info(f"Processing event #{event_count}: {type(event).__name__}")
-                global_cancel.check_and_raise()
+                global_cancel.check_and_raise(token=self.args.event_file)
                 if isinstance(event, (LLMOutputEvent, LLMThinkingEvent)):
                     assistant_buffer += event.text
                     logger.debug(f"Accumulated {len(assistant_buffer)} chars in assistant buffer")
@@ -856,9 +833,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
                     conversations.append({
                         "role": "assistant",
                         "content": assistant_buffer + tool_xml
-                    })
-                    self.conversation_manager.add_assistant_message(
-                        assistant_buffer + tool_xml)
+                    })                    
                     assistant_buffer = ""  # Reset buffer after tool call
 
                     yield event  # Yield the ToolCallEvent for display
@@ -941,7 +916,6 @@ Below are some files the user is focused on, and the content is up to date. Thes
                         "role": "user",  # Simulating the user providing the tool result
                         "content": error_xml
                     })
-                    self.conversation_manager.add_user_message(error_xml)
                     logger.info(
                         f"Added tool result to conversations for tool {type(tool_obj).__name__}")
                     logger.info(f"Breaking LLM cycle after executing tool: {tool_name}")
@@ -968,12 +942,9 @@ Below are some files the user is focused on, and the content is up to date. Thes
                         logger.info("Adding new assistant message")
                         conversations.append(
                             {"role": "assistant", "content": assistant_buffer})
-                        self.conversation_manager.add_assistant_message(
-                            assistant_buffer)
                     elif last_message["role"] == "assistant":
                         logger.info("Appending to existing assistant message")
                         last_message["content"] += assistant_buffer
-                        self.conversation_manager.append_to_last_message(assistant_buffer)                        
                 # If the loop ends without AttemptCompletion, it means the LLM finished talking
                 # without signaling completion. We might just stop or yield a final message.
                 # Let's assume it stops here.
@@ -1062,7 +1033,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
                 return None
 
         for content_chunk, metadata in generator:
-            global_cancel.check_and_raise()
+            global_cancel.check_and_raise(token=self.args.event_file)
             meta_holder.meta = metadata            
             if not content_chunk:
                 continue

autocoder/common/v2/agent/agentic_edit_tools/list_files_tool_resolver.py

@@ -6,7 +6,7 @@ from loguru import logger
 import typing
 from autocoder.common import AutoCoderArgs
 
-from autocoder.ignorefiles.ignore_file_utils import should_ignore
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit

autocoder/common/v2/agent/agentic_edit_tools/search_files_tool_resolver.py

@@ -1,4 +1,3 @@
-
 import os
 import re
 import glob
@@ -9,7 +8,7 @@ from loguru import logger
 from autocoder.common import AutoCoderArgs
 import typing
 
-from autocoder.ignorefiles.ignore_file_utils import should_ignore
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit  
@@ -33,14 +32,13 @@ class SearchFilesToolResolver(BaseToolResolver):
         if not absolute_search_path.startswith(absolute_source_dir):
             return ToolResult(success=False, message=f"Error: Access denied. Attempted to search outside the project directory: {search_path_str}")
 
-        # Determine search base directory: prefer shadow if exists
-        search_base_path = absolute_search_path
+        # Check if shadow directory exists
         shadow_exists = False
+        shadow_dir_path = None
         if self.shadow_manager:
             try:
                 shadow_dir_path = self.shadow_manager.to_shadow_path(absolute_search_path)
                 if os.path.exists(shadow_dir_path) and os.path.isdir(shadow_dir_path):
-                    search_base_path = shadow_dir_path
                     shadow_exists = True
             except Exception as e:
                 logger.warning(f"Error checking shadow path for {absolute_search_path}: {e}")
@@ -50,51 +48,83 @@ class SearchFilesToolResolver(BaseToolResolver):
             return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
         if os.path.exists(absolute_search_path) and not os.path.isdir(absolute_search_path):
             return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
-        if shadow_exists and not os.path.isdir(search_base_path):
-            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {search_base_path}")
+        if shadow_exists and not os.path.isdir(shadow_dir_path):
+            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {shadow_dir_path}")
 
-        results = []
         try:
             compiled_regex = re.compile(regex_pattern)
-            search_glob_pattern = os.path.join(search_base_path, "**", file_pattern)
-
-            logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{search_base_path}' (shadow: {shadow_exists}) with ignore rules applied.")
-
-            for filepath in glob.glob(search_glob_pattern, recursive=True):
-                abs_path = os.path.abspath(filepath)
-                if should_ignore(abs_path):
-                    continue
+            
+            # Helper function to search in a directory
+            def search_in_dir(base_dir, is_shadow=False):
+                search_results = []
+                search_glob_pattern = os.path.join(base_dir, "**", file_pattern)
+                
+                logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{base_dir}' (shadow: {is_shadow}) with ignore rules applied.")
+                
+                for filepath in glob.glob(search_glob_pattern, recursive=True):
+                    abs_path = os.path.abspath(filepath)
+                    if should_ignore(abs_path):
+                        continue
 
-                if os.path.isfile(filepath):
-                    try:
-                        with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
-                            lines = f.readlines()
-                        for i, line in enumerate(lines):
-                            if compiled_regex.search(line):
-                                context_start = max(0, i - 2)
-                                context_end = min(len(lines), i + 3)
-                                context = "".join([f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
-                                if shadow_exists and self.shadow_manager:
-                                    try:
-                                        abs_project_path = self.shadow_manager.from_shadow_path(filepath)
-                                        relative_path = os.path.relpath(abs_project_path, source_dir)
-                                    except Exception:
+                    if os.path.isfile(filepath):
+                        try:
+                            with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                                lines = f.readlines()
+                            for i, line in enumerate(lines):
+                                if compiled_regex.search(line):
+                                    context_start = max(0, i - 2)
+                                    context_end = min(len(lines), i + 3)
+                                    context = "".join([f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
+                                    
+                                    if is_shadow and self.shadow_manager:
+                                        try:
+                                            abs_project_path = self.shadow_manager.from_shadow_path(filepath)
+                                            relative_path = os.path.relpath(abs_project_path, source_dir)
+                                        except Exception:
+                                            relative_path = os.path.relpath(filepath, source_dir)
+                                    else:
                                         relative_path = os.path.relpath(filepath, source_dir)
-                                else:
-                                    relative_path = os.path.relpath(filepath, source_dir)
-                                results.append({
-                                    "path": relative_path,
-                                    "line_number": i + 1,
-                                    "match_line": line.strip(),
-                                    "context": context.strip()
-                                })
-                    except Exception as e:
-                        logger.warning(f"Could not read or process file {filepath}: {e}")
-                        continue
+                                    
+                                    search_results.append({
+                                        "path": relative_path,
+                                        "line_number": i + 1,
+                                        "match_line": line.strip(),
+                                        "context": context.strip()
+                                    })
+                        except Exception as e:
+                            logger.warning(f"Could not read or process file {filepath}: {e}")
+                            continue
+                
+                return search_results
+            
+            # Search in both directories and merge results
+            shadow_results = []
+            source_results = []
+            
+            if shadow_exists:
+                shadow_results = search_in_dir(shadow_dir_path, is_shadow=True)
+            
+            if os.path.exists(absolute_search_path) and os.path.isdir(absolute_search_path):
+                source_results = search_in_dir(absolute_search_path, is_shadow=False)
+            
+            # Merge results, prioritizing shadow results
+            # Create a dictionary for quick lookup
+            results_dict = {}
+            for result in source_results:
+                key = (result["path"], result["line_number"])
+                results_dict[key] = result
+            
+            # Override with shadow results
+            for result in shadow_results:
+                key = (result["path"], result["line_number"])
+                results_dict[key] = result
+            
+            # Convert back to list
+            merged_results = list(results_dict.values())
 
-            message = f"Search completed. Found {len(results)} matches."
+            message = f"Search completed. Found {len(merged_results)} matches."
             logger.info(message)
-            return ToolResult(success=True, message=message, content=results)
+            return ToolResult(success=True, message=message, content=merged_results)
 
         except re.error as e:
             logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")