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

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

@@ -1,7 +1,7 @@
 import os
 import re
 import glob
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List, Union
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult  # Import ToolResult from types
 from loguru import logger
@@ -20,14 +20,54 @@ class SearchFilesToolResolver(BaseToolResolver):
         self.tool: SearchFilesTool = tool
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
 
-    def resolve(self) -> ToolResult:
-        search_path_str = self.tool.path
-        regex_pattern = self.tool.regex
-        file_pattern = self.tool.file_pattern or "*"
-        source_dir = self.args.source_dir or "."
-        absolute_source_dir = os.path.abspath(source_dir)
-        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+    def search_in_dir(self, base_dir: str, regex_pattern: str, file_pattern: str, source_dir: str, is_shadow: bool = False, compiled_regex: Optional[re.Pattern] = None) -> List[Dict[str, Any]]:
+        """Helper function to search in a directory"""
+        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.")
+        
+        if compiled_regex is None:
+            compiled_regex = re.compile(regex_pattern)
+            
+        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 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)
+                            
+                            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
+
+    def search_files_with_shadow(self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str, absolute_source_dir: str, absolute_search_path: str) -> Union[ToolResult, List[Dict[str, Any]]]:
+        """Search files using shadow manager for path translation"""
         # Security check
         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}")
@@ -54,58 +94,15 @@ class SearchFilesToolResolver(BaseToolResolver):
         try:
             compiled_regex = re.compile(regex_pattern)
             
-            # 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 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)
-                                    
-                                    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)
+                shadow_results = self.search_in_dir(shadow_dir_path, regex_pattern, file_pattern, source_dir, is_shadow=True, compiled_regex=compiled_regex)
             
             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)
+                source_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
             
             # Merge results, prioritizing shadow results
             # Create a dictionary for quick lookup
@@ -122,9 +119,34 @@ class SearchFilesToolResolver(BaseToolResolver):
             # Convert back to list
             merged_results = list(results_dict.values())
 
-            message = f"Search completed. Found {len(merged_results)} matches."
-            logger.info(message)
-            return ToolResult(success=True, message=message, content=merged_results)
+            return merged_results
+
+        except re.error as e:
+            logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")
+            return ToolResult(success=False, message=f"Invalid regex pattern: {e}")
+        except Exception as e:
+            logger.error(f"Error during file search: {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")
+    
+    def search_files_normal(self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str, absolute_source_dir: str, absolute_search_path: str) -> Union[ToolResult, List[Dict[str, Any]]]:
+        """Search files directly without using shadow manager"""
+        # Security check
+        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}")
+
+        # Validate that the directory exists
+        if not os.path.exists(absolute_search_path):
+            return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
+        if not os.path.isdir(absolute_search_path):
+            return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
+
+        try:
+            compiled_regex = re.compile(regex_pattern)
+            
+            # Search in the directory
+            search_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
+            
+            return search_results
 
         except re.error as e:
             logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")
@@ -132,3 +154,26 @@ class SearchFilesToolResolver(BaseToolResolver):
         except Exception as e:
             logger.error(f"Error during file search: {str(e)}")
             return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the search files tool by calling the appropriate implementation"""
+        search_path_str = self.tool.path
+        regex_pattern = self.tool.regex
+        file_pattern = self.tool.file_pattern or "*"
+        source_dir = self.args.source_dir or "."
+        absolute_source_dir = os.path.abspath(source_dir)
+        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            result = self.search_files_with_shadow(search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
+        else:
+            result = self.search_files_normal(search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
+
+        # Handle the case where the implementation returns a list instead of a ToolResult
+        if isinstance(result, list):
+            message = f"Search completed. Found {len(result)} matches."
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=result)
+        else:
+            return result

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

@@ -1,6 +1,6 @@
 import os
 from typing import Dict, Any, Optional
-from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolResult  # Import ToolResult from types
+from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolResult
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from loguru import logger
 from autocoder.common import AutoCoderArgs
@@ -44,82 +44,77 @@ class WriteToFileToolResolver(BaseToolResolver):
         
         return "\n".join(formatted_issues)
 
-    def resolve(self) -> ToolResult:
-        file_path = self.tool.path
-        content = self.tool.content
-        source_dir = self.args.source_dir or "."
-        abs_project_dir = os.path.abspath(source_dir)
-        abs_file_path = os.path.abspath(os.path.join(source_dir, file_path))
-
-        # Security check: ensure the path is within the source directory
-        if not abs_file_path.startswith(abs_project_dir):
-            return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
-
+    def write_file_with_shadow(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Write file using shadow manager for path translation"""
         try:
-            if self.shadow_manager:
-                shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                # Ensure shadow directory exists
-                os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
-                with open(shadow_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
+            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+            # Ensure shadow directory exists
+            os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
+            with open(shadow_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
 
-                # 回调AgenticEdit，记录变更
-                if self.agent:
-                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
-                
-                # 新增：执行代码质量检查
-                lint_results = None
-                lint_message = ""
-                formatted_issues = ""
-                has_lint_issues = False
-                
-                # 检查是否启用了Lint功能
-                enable_lint = self.args.enable_auto_fix_lint
-                
-                if enable_lint:
-                    try:
-                        if self.shadow_linter and self.shadow_manager:
-                            # 对新创建的文件进行 lint 检查
-                            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                            lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
-                            
-                            if lint_results and lint_results.issues:
-                                has_lint_issues = True
-                                # 格式化 lint 问题
-                                formatted_issues = self._format_lint_issues(lint_results)
-                                lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
-                            else:
-                                lint_message = "\n\n代码质量检查通过，未发现问题。"
-                    except Exception as e:
-                        logger.error(f"Lint 检查失败: {str(e)}")
-                        lint_message = "\n\n尝试进行代码质量检查时出错。"
-                else:
-                    logger.info("代码质量检查已禁用")
-                
-                # 构建包含 lint 结果的返回消息
-                message = f"Successfully wrote to file (shadow): {file_path}"
-                
-                # 将 lint 消息添加到结果中，如果启用了Lint
-                if enable_lint:
-                    message += lint_message
-                
-                # 附加 lint 结果到返回内容
-                result_content = {
-                    "content": content,
-                }
-                
-                # 只有在启用Lint时才添加Lint结果
-                if enable_lint:
-                    result_content["lint_results"] = {
-                        "has_issues": has_lint_issues,
-                        "issues": formatted_issues if has_lint_issues else None
-                    }
-                
-                return ToolResult(success=True, message=message, content=result_content)
+            # 回调AgenticEdit，记录变更
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "added", diff=None, content=content)
+            
+            # 新增：执行代码质量检查
+            lint_results = None
+            lint_message = ""
+            formatted_issues = ""
+            has_lint_issues = False
+            
+            # 检查是否启用了Lint功能
+            enable_lint = self.args.enable_auto_fix_lint
+            
+            if enable_lint:
+                try:
+                    if self.shadow_linter and self.shadow_manager:
+                        # 对新创建的文件进行 lint 检查
+                        shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+                        lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
                         
-            # No shadow manager fallback to original file
+                        if lint_results and lint_results.issues:
+                            has_lint_issues = True
+                            # 格式化 lint 问题
+                            formatted_issues = self._format_lint_issues(lint_results)
+                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
+                        else:
+                            lint_message = "\n\n代码质量检查通过，未发现问题。"
+                except Exception as e:
+                    logger.error(f"Lint 检查失败: {str(e)}")
+                    lint_message = "\n\n尝试进行代码质量检查时出错。"
+            else:
+                logger.info("代码质量检查已禁用")
+            
+            # 构建包含 lint 结果的返回消息
+            message = f"Successfully wrote to file (shadow): {file_path}"
+            
+            # 将 lint 消息添加到结果中，如果启用了Lint
+            if enable_lint:
+                message += lint_message
+            
+            # 附加 lint 结果到返回内容
+            result_content = {
+                "content": content,
+            }
+            
+            # 只有在启用Lint时才添加Lint结果
+            if enable_lint:
+                result_content["lint_results"] = {
+                    "has_issues": has_lint_issues,
+                    "issues": formatted_issues if has_lint_issues else None
+                }
+            
+            return ToolResult(success=True, message=message, content=result_content)
+        except Exception as e:
+            logger.error(f"Error writing to shadow file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the shadow file: {str(e)}")
+
+    def write_file_normal(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Write file directly without using shadow manager"""
+        try:
             os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)            
 
             if self.agent:
@@ -136,7 +131,13 @@ class WriteToFileToolResolver(BaseToolResolver):
                     )
                 }
                 change_group_id = self.args.event_file
-                self.agent.checkpoint_manager.apply_changes(changes,change_group_id)                    
+                                                              
+                self.agent.checkpoint_manager.apply_changes_with_conversation(
+                            changes=changes,
+                            conversations=self.agent.current_conversations,
+                            change_group_id=change_group_id,
+                            metadata={"event_file": self.args.event_file}
+                        )                    
             else:
                 with open(abs_file_path, 'w', encoding='utf-8') as f:
                     f.write(content)
@@ -205,4 +206,22 @@ class WriteToFileToolResolver(BaseToolResolver):
             return ToolResult(success=True, message=message, content=result_content)
         except Exception as e:
             logger.error(f"Error writing to file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the write file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        content = self.tool.content
+        source_dir = self.args.source_dir or "."
+        abs_project_dir = os.path.abspath(source_dir)
+        abs_file_path = os.path.abspath(os.path.join(source_dir, file_path))
+
+        # Security check: ensure the path is within the source directory
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            return self.write_file_with_shadow(file_path, content, source_dir, abs_project_dir, abs_file_path)
+        else:
+            return self.write_file_normal(file_path, content, source_dir, abs_project_dir, abs_file_path)

autocoder/common/v2/agent/agentic_edit_types.py

@@ -96,6 +96,10 @@ class ErrorEvent(BaseModel):
     """Represents an error during the process."""
     message: str
 
+class WindowLengthChangeEvent(BaseModel):
+    """Represents the token usage in the conversation window."""
+    tokens_used: int
+
 # Deprecated: Will be replaced by specific Event types
 # class PlainTextOutput(BaseModel):
 #     text: str

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.364"
+__version__ = "0.1.365"