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

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

@@ -1,5 +1,5 @@
 import os
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List, Set, Union
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from autocoder.common.v2.agent.agentic_edit_types import ListFilesTool, ToolResult  # Import ToolResult from types
 from loguru import logger
@@ -18,13 +18,40 @@ class ListFilesToolResolver(BaseToolResolver):
         self.tool: ListFilesTool = tool  # For type hinting
         self.shadow_manager = self.agent.shadow_manager
 
-    def resolve(self) -> ToolResult:
-        list_path_str = self.tool.path
-        recursive = self.tool.recursive or False
-        source_dir = self.args.source_dir or "."
-        absolute_source_dir = os.path.abspath(source_dir)
-        absolute_list_path = os.path.abspath(os.path.join(source_dir, list_path_str))
-
+    def list_files_in_dir(self, base_dir: str, recursive: bool, source_dir: str, is_outside_source: bool) -> Set[str]:
+        """Helper function to list files in a directory"""
+        result = set()
+        try:
+            if recursive:
+                for root, dirs, files in os.walk(base_dir):
+                    # Modify dirs in-place to skip ignored dirs early
+                    dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d))]
+                    for name in files:
+                        full_path = os.path.join(root, name)
+                        if should_ignore(full_path):
+                            continue
+                        display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                        result.add(display_path)
+                    for d in dirs:
+                        full_path = os.path.join(root, d)
+                        display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                        result.add(display_path + "/")
+            else:
+                for item in os.listdir(base_dir):
+                    full_path = os.path.join(base_dir, item)
+                    if should_ignore(full_path):
+                        continue
+                    display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                    if os.path.isdir(full_path):
+                        result.add(display_path + "/")
+                    else:
+                        result.add(display_path)
+        except Exception as e:
+            logger.warning(f"Error listing files in {base_dir}: {e}")
+        return result
+        
+    def list_files_with_shadow(self, list_path_str: str, recursive: bool, source_dir: str, absolute_source_dir: str, absolute_list_path: str) -> Union[ToolResult, List[str]]:
+        """List files using shadow manager for path translation"""
         # Security check: Allow listing outside source_dir IF the original path is outside?
         is_outside_source = not absolute_list_path.startswith(absolute_source_dir)
         if is_outside_source:
@@ -49,46 +76,14 @@ class ListFilesToolResolver(BaseToolResolver):
         if shadow_exists and not os.path.isdir(shadow_dir_path):
             return ToolResult(success=False, message=f"Error: Shadow path is not a directory: {shadow_dir_path}")
 
-        # Helper function to list files in a directory
-        def list_files_in_dir(base_dir: str) -> set:
-            result = set()
-            try:
-                if recursive:
-                    for root, dirs, files in os.walk(base_dir):
-                        # Modify dirs in-place to skip ignored dirs early
-                        dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d))]
-                        for name in files:
-                            full_path = os.path.join(root, name)
-                            if should_ignore(full_path):
-                                continue
-                            display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
-                            result.add(display_path)
-                        for d in dirs:
-                            full_path = os.path.join(root, d)
-                            display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
-                            result.add(display_path + "/")
-                else:
-                    for item in os.listdir(base_dir):
-                        full_path = os.path.join(base_dir, item)
-                        if should_ignore(full_path):
-                            continue
-                        display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
-                        if os.path.isdir(full_path):
-                            result.add(display_path + "/")
-                        else:
-                            result.add(display_path)
-            except Exception as e:
-                logger.warning(f"Error listing files in {base_dir}: {e}")
-            return result
-
         # Collect files from shadow and/or source directory
         shadow_files_set = set()
         if shadow_exists:
-            shadow_files_set = list_files_in_dir(shadow_dir_path)
+            shadow_files_set = self.list_files_in_dir(shadow_dir_path, recursive, source_dir, is_outside_source)
 
         source_files_set = set()
         if os.path.exists(absolute_list_path) and os.path.isdir(absolute_list_path):
-            source_files_set = list_files_in_dir(absolute_list_path)
+            source_files_set = self.list_files_in_dir(absolute_list_path, recursive, source_dir, is_outside_source)
 
         # Merge results, prioritizing shadow files if exist
         if shadow_exists:
@@ -101,7 +96,52 @@ class ListFilesToolResolver(BaseToolResolver):
         try:
             message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(merged_files)} items."
             logger.info(message)
-            return ToolResult(success=True, message=message, content=sorted(merged_files))
+            return sorted(merged_files)
+        except Exception as e:
+            logger.error(f"Error listing files in '{list_path_str}': {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred while listing files: {str(e)}")
+
+    def list_files_normal(self, list_path_str: str, recursive: bool, source_dir: str, absolute_source_dir: str, absolute_list_path: str) -> Union[ToolResult, List[str]]:
+        """List files directly without using shadow manager"""
+        # Security check: Allow listing outside source_dir IF the original path is outside?
+        is_outside_source = not absolute_list_path.startswith(absolute_source_dir)
+        if is_outside_source:
+            logger.warning(f"Listing path is outside the project source directory: {list_path_str}")
+
+        # Validate that the directory exists
+        if not os.path.exists(absolute_list_path):
+            return ToolResult(success=False, message=f"Error: Path not found: {list_path_str}")
+        if not os.path.isdir(absolute_list_path):
+            return ToolResult(success=False, message=f"Error: Path is not a directory: {list_path_str}")
+
+        # Collect files from the directory
+        files_set = self.list_files_in_dir(absolute_list_path, recursive, source_dir, is_outside_source)
+
+        try:
+            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(files_set)} items."
+            logger.info(message)
+            return sorted(files_set)
         except Exception as e:
             logger.error(f"Error listing files in '{list_path_str}': {str(e)}")
             return ToolResult(success=False, message=f"An unexpected error occurred while listing files: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the list files tool by calling the appropriate implementation"""
+        list_path_str = self.tool.path
+        recursive = self.tool.recursive or False
+        source_dir = self.args.source_dir or "."
+        absolute_source_dir = os.path.abspath(source_dir)
+        absolute_list_path = os.path.abspath(os.path.join(source_dir, list_path_str))
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            result = self.list_files_with_shadow(list_path_str, recursive, source_dir, absolute_source_dir, absolute_list_path)
+        else:
+            result = self.list_files_normal(list_path_str, recursive, source_dir, absolute_source_dir, absolute_list_path)
+
+        # Handle the case where the implementation returns a sorted list instead of a ToolResult
+        if isinstance(result, list):
+            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(result)} items."
+            return ToolResult(success=True, message=message, content=result)
+        else:
+            return result

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

@@ -1,10 +1,18 @@
 import os
 from typing import Dict, Any, Optional
-from autocoder.common import AutoCoderArgs
+from autocoder.common import AutoCoderArgs,SourceCode
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
-from autocoder.common.v2.agent.agentic_edit_types import ReadFileTool, ToolResult  # Import ToolResult from types
+from autocoder.common.v2.agent.agentic_edit_types import ReadFileTool, ToolResult
+from autocoder.common.context_pruner import PruneContext
+from autocoder.common import SourceCode
+from autocoder.rag.token_counter import count_tokens
 from loguru import logger
 import typing
+from autocoder.rag.loaders import (
+    extract_text_from_pdf,
+    extract_text_from_docx,
+    extract_text_from_ppt
+)
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
@@ -15,40 +23,119 @@ class ReadFileToolResolver(BaseToolResolver):
         super().__init__(agent, tool, args)
         self.tool: ReadFileTool = tool  # For type hinting
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
+        self.context_pruner = PruneContext(
+            max_tokens=self.args.context_prune_safe_zone_tokens,
+            args=self.args,
+            llm=self.agent.context_prune_llm
+        )
 
-    def resolve(self) -> ToolResult:
-        file_path = self.tool.path
-        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))
+    def _prune_file_content(self, content: str, file_path: str) -> str:
+        """对文件内容进行剪枝处理"""
+        if not self.context_pruner:
+            return content
+
+        # 计算 token 数量
+        tokens = count_tokens(content)
+        if tokens <= self.args.context_prune_safe_zone_tokens:
+            return content
+
+        # 创建 SourceCode 对象
+        source_code = SourceCode(
+            module_name=file_path,
+            source_code=content,
+            tokens=tokens
+        )
+
+        # 使用 context_pruner 进行剪枝
+        pruned_sources = self.context_pruner.handle_overflow(
+            file_sources=[source_code],
+            conversations=self.agent.current_conversations if self.agent else [],
+            strategy=self.args.context_prune_strategy
+        )
 
-        # # 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 read file outside the project directory: {file_path}")
+        if not pruned_sources:
+            return content
 
+        return pruned_sources[0].source_code
+
+    def _read_file_content(self, file_path_to_read: str) -> str:
+        content = ""
+        ext = os.path.splitext(file_path_to_read)[1].lower()
+
+        if ext == '.pdf':
+            logger.info(f"Extracting text from PDF: {file_path_to_read}")
+            content = extract_text_from_pdf(file_path_to_read)
+        elif ext == '.docx':
+            logger.info(f"Extracting text from DOCX: {file_path_to_read}")
+            content = extract_text_from_docx(file_path_to_read)
+        elif ext in ('.pptx', '.ppt'):
+            logger.info(f"Extracting text from PPT/PPTX: {file_path_to_read}")
+            slide_texts = []
+            for slide_identifier, slide_text_content in extract_text_from_ppt(file_path_to_read):
+                slide_texts.append(f"--- Slide {slide_identifier} ---\n{slide_text_content}")
+            content = "\n\n".join(slide_texts) if slide_texts else ""
+        else:
+            logger.info(f"Reading plain text file: {file_path_to_read}")
+            with open(file_path_to_read, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+
+        # 对内容进行剪枝处理
+        return self._prune_file_content(content, file_path_to_read)
+
+    def read_file_with_shadow(self, file_path: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Read file using shadow manager for path translation"""
         try:
-            try:
-                if self.shadow_manager:
-                    shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                    # If shadow file exists, read from it
-                    if os.path.exists(shadow_path) and os.path.isfile(shadow_path):
-                        with open(shadow_path, 'r', encoding='utf-8', errors='replace') as f:
-                            content = f.read()
-                        logger.info(f"[Shadow] Successfully read shadow file: {shadow_path}")
-                        return ToolResult(success=True, message=f"Successfully read file (shadow): {file_path}", content=content)
-            except Exception as e:
-                pass
-            # else fallback to original file
-            # Fallback to original file
+            # Check if shadow file exists
+            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+            if os.path.exists(shadow_path) and os.path.isfile(shadow_path):
+                try:
+                    content = self._read_file_content(shadow_path)
+                    logger.info(f"[Shadow] Successfully processed shadow file: {shadow_path}")
+                    return ToolResult(success=True, message=f"{file_path}", content=content)
+                except Exception as e_shadow:
+                    logger.warning(f"Failed to read shadow file {shadow_path} with _read_file_content: {str(e_shadow)}. Falling back to original file.")
+
+            # If shadow file doesn't exist or reading failed, try original file
             if not os.path.exists(abs_file_path):
                 return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
             if not os.path.isfile(abs_file_path):
                 return ToolResult(success=False, message=f"Error: Path is not a file: {file_path}")
 
-            with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
-                content = f.read()
-            logger.info(f"Successfully read file: {file_path}")
-            return ToolResult(success=True, message=f"Successfully read file: {file_path}", content=content)
+            content = self._read_file_content(abs_file_path)
+            logger.info(f"Successfully processed file: {file_path}")
+            return ToolResult(success=True, message=f"{file_path}", content=content)
+
         except Exception as e:
-            logger.error(f"Error reading file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=f"An error occurred while reading the file: {str(e)}")
+            logger.warning(f"Error processing file '{file_path}': {str(e)}")
+            logger.exception(e)
+            return ToolResult(success=False, message=f"An error occurred while processing the file '{file_path}': {str(e)}")
+
+    def read_file_normal(self, file_path: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Read file directly without using shadow manager"""
+        try:
+            if not os.path.exists(abs_file_path):
+                return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
+            if not os.path.isfile(abs_file_path):
+                return ToolResult(success=False, message=f"Error: Path is not a file: {file_path}")
+
+            content = self._read_file_content(abs_file_path)
+            logger.info(f"Successfully processed file: {file_path}")
+            return ToolResult(success=True, message=f"{file_path}", content=content)
+
+        except Exception as e:
+            logger.warning(f"Error processing file '{file_path}': {str(e)}")
+            logger.exception(e)
+            return ToolResult(success=False, message=f"An error occurred while processing the file '{file_path}': {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the read file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        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))
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            return self.read_file_with_shadow(file_path, source_dir, abs_project_dir, abs_file_path)
+        else:
+            return self.read_file_normal(file_path, source_dir, abs_project_dir, abs_file_path)

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

@@ -4,7 +4,9 @@ from typing import Dict, Any, Optional, List, Tuple
 import typing
 from autocoder.common import AutoCoderArgs
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
-from autocoder.common.v2.agent.agentic_edit_types import ReplaceInFileTool, ToolResult  # Import ToolResult from types
+from autocoder.common.v2.agent.agentic_edit_types import ReplaceInFileTool, ToolResult
+from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
 from loguru import logger
 from autocoder.common.auto_coder_lang import get_message_with_format
 if typing.TYPE_CHECKING:
@@ -84,30 +86,18 @@ class ReplaceInFileToolResolver(BaseToolResolver):
         
         return "\n".join(formatted_issues)
 
-    def resolve(self) -> ToolResult:
-        file_path = self.tool.path
-        diff_content = self.tool.diff
-        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
-        if not abs_file_path.startswith(abs_project_dir):
-            return ToolResult(success=False, message=get_message_with_format("replace_in_file.access_denied", file_path=file_path))
-
-        # Determine target path: shadow file if shadow_manager exists
-        target_path = abs_file_path
-        if self.shadow_manager:
+    def replace_in_file_with_shadow(self, file_path: str, diff_content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Replace content in file using shadow manager for path translation"""
+        try:
+            # Determine target path: shadow file
             target_path = self.shadow_manager.to_shadow_path(abs_file_path)
 
-        # If shadow file does not exist yet, but original file exists, copy original content into shadow first? No, just treat as normal file.
-        # For now, read from shadow if exists, else fallback to original file
-        try:
+            # Read original content
             if os.path.exists(target_path) and os.path.isfile(target_path):
                 with open(target_path, 'r', encoding='utf-8', errors='replace') as f:
                     original_content = f.read()
-            elif self.shadow_manager and os.path.exists(abs_file_path) and os.path.isfile(abs_file_path):
-                # If shadow doesn't exist, but original exists, read original content (create shadow implicitly later)
+            elif os.path.exists(abs_file_path) and os.path.isfile(abs_file_path):
+                # If shadow doesn't exist, but original exists, read original content
                 with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
                     original_content = f.read()
                 # create parent dirs of shadow if needed
@@ -118,43 +108,40 @@ class ReplaceInFileToolResolver(BaseToolResolver):
                 logger.info(f"[Shadow] Initialized shadow file from original: {target_path}")
             else:
                 return ToolResult(success=False, message=get_message_with_format("replace_in_file.file_not_found", file_path=file_path))
-        except Exception as e:
-            logger.error(f"Error reading file for replace '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=get_message_with_format("replace_in_file.read_error", error=str(e)))
 
-        parsed_blocks = self.parse_diff(diff_content)
-        if not parsed_blocks:
-            return ToolResult(success=False, message=get_message_with_format("replace_in_file.no_valid_blocks"))
+            parsed_blocks = self.parse_diff(diff_content)
+            if not parsed_blocks:
+                return ToolResult(success=False, message=get_message_with_format("replace_in_file.no_valid_blocks"))
 
-        current_content = original_content
-        applied_count = 0
-        errors = []
+            current_content = original_content
+            applied_count = 0
+            errors = []
 
-        # Apply blocks sequentially
-        for i, (search_block, replace_block) in enumerate(parsed_blocks):
-            start_index = current_content.find(search_block)
+            # Apply blocks sequentially
+            for i, (search_block, replace_block) in enumerate(parsed_blocks):
+                start_index = current_content.find(search_block)
 
-            if start_index != -1:
-                current_content = current_content[:start_index] + replace_block + current_content[start_index + len(search_block):]
-                applied_count += 1
-                logger.info(f"Applied SEARCH/REPLACE block {i+1} in file {file_path}")
-            else:
-                error_message = f"SEARCH block {i+1} not found in the current file content. Content to search:\n---\n{search_block}\n---"
-                logger.warning(error_message)
-                context_start = max(0, original_content.find(search_block[:20]) - 100)
-                context_end = min(len(original_content), context_start + 200 + len(search_block[:20]))
-                logger.warning(f"Approximate context in file:\n---\n{original_content[context_start:context_end]}\n---")
-                errors.append(error_message)
-                # continue applying remaining blocks
+                if start_index != -1:
+                    current_content = current_content[:start_index] + replace_block + current_content[start_index + len(search_block):]
+                    applied_count += 1
+                    logger.info(f"Applied SEARCH/REPLACE block {i+1} in file {file_path}")
+                else:
+                    error_message = f"SEARCH block {i+1} not found in the current file content. Content to search:\n---\n{search_block}\n---"
+                    logger.warning(error_message)
+                    context_start = max(0, original_content.find(search_block[:20]) - 100)
+                    context_end = min(len(original_content), context_start + 200 + len(search_block[:20]))
+                    logger.warning(f"Approximate context in file:\n---\n{original_content[context_start:context_end]}\n---")
+                    errors.append(error_message)
 
-        if applied_count == 0 and errors:
-            return ToolResult(success=False, message=get_message_with_format("replace_in_file.apply_failed", errors="\n".join(errors)))
+            if applied_count == 0 and errors:
+                return ToolResult(success=False, message=get_message_with_format("replace_in_file.apply_failed", errors="\n".join(errors)))
 
-        try:
+            # Write the modified content back to shadow file
             os.makedirs(os.path.dirname(target_path), exist_ok=True)
             with open(target_path, 'w', encoding='utf-8') as f:
                 f.write(current_content)
-            logger.info(f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to file: {file_path}")
+            
+            logger.info(f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to shadow file: {file_path}")
 
             # 新增：执行代码质量检查
             lint_results = None
@@ -212,6 +199,132 @@ class ReplaceInFileToolResolver(BaseToolResolver):
                 "content": current_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 replaced content to shadow file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=get_message_with_format("replace_in_file.write_error", error=str(e)))
+
+    def replace_in_file_normal(self, file_path: str, diff_content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Replace content in file directly without using shadow manager"""
+        try:
+            # Read original content
+            if not os.path.exists(abs_file_path):
+                return ToolResult(success=False, message=get_message_with_format("replace_in_file.file_not_found", file_path=file_path))
+            if not os.path.isfile(abs_file_path):
+                return ToolResult(success=False, message=get_message_with_format("replace_in_file.not_a_file", file_path=file_path))
+
+            with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                original_content = f.read()
+
+            parsed_blocks = self.parse_diff(diff_content)
+            if not parsed_blocks:
+                return ToolResult(success=False, message=get_message_with_format("replace_in_file.no_valid_blocks"))
+
+            current_content = original_content
+            applied_count = 0
+            errors = []
+
+            # Apply blocks sequentially
+            for i, (search_block, replace_block) in enumerate(parsed_blocks):
+                start_index = current_content.find(search_block)
+
+                if start_index != -1:
+                    current_content = current_content[:start_index] + replace_block + current_content[start_index + len(search_block):]
+                    applied_count += 1
+                    logger.info(f"Applied SEARCH/REPLACE block {i+1} in file {file_path}")
+                else:
+                    error_message = f"SEARCH block {i+1} not found in the current file content. Content to search:\n---\n{search_block}\n---"
+                    logger.warning(error_message)
+                    context_start = max(0, original_content.find(search_block[:20]) - 100)
+                    context_end = min(len(original_content), context_start + 200 + len(search_block[:20]))
+                    logger.warning(f"Approximate context in file:\n---\n{original_content[context_start:context_end]}\n---")
+                    errors.append(error_message)
+
+            if applied_count == 0 and errors:
+                return ToolResult(success=False, message=get_message_with_format("replace_in_file.apply_failed", errors="\n".join(errors)))
+
+            # Write the modified content back to file
+            if self.agent and self.agent.checkpoint_manager:
+                changes = {
+                    file_path: CheckpointFileChange(
+                        file_path=file_path,
+                        content=current_content,
+                        is_deletion=False,
+                        is_new=True
+                    )
+                }
+                change_group_id = self.args.event_file
+                
+                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(current_content)
+            
+            logger.info(f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to file: {file_path}")
+
+            # 新增：执行代码质量检查
+            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.agent.linter:
+                        lint_results = self.agent.linter.lint_file(file_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}"
+                except Exception as e:
+                    logger.error(f"Lint 检查失败: {str(e)}")
+                    lint_message = "\n\n尝试进行代码质量检查时出错。"
+            else:
+                logger.info("代码质量检查已禁用")
+
+            # 构建包含 lint 结果的返回消息
+            if errors:
+                message = get_message_with_format("replace_in_file.apply_success_with_warnings", 
+                                                  applied=applied_count, 
+                                                  total=len(parsed_blocks), 
+                                                  file_path=file_path,
+                                                  errors="\n".join(errors))
+            else:
+                message = get_message_with_format("replace_in_file.apply_success", 
+                                                  applied=applied_count, 
+                                                  total=len(parsed_blocks), 
+                                                  file_path=file_path)
+            
+            # 将 lint 消息添加到结果中，如果启用了Lint
+            if enable_lint:
+                message += lint_message
+
+            # 变更跟踪，回调AgenticEdit
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "modified", diff=diff_content, content=current_content)
+
+            # 附加 lint 结果到返回内容
+            result_content = {
+                "content": current_content,
+            }
+            
             # 只有在启用Lint时才添加Lint结果
             if enable_lint:
                 result_content["lint_results"] = {
@@ -223,3 +336,21 @@ class ReplaceInFileToolResolver(BaseToolResolver):
         except Exception as e:
             logger.error(f"Error writing replaced content to file '{file_path}': {str(e)}")
             return ToolResult(success=False, message=get_message_with_format("replace_in_file.write_error", error=str(e)))
+
+    def resolve(self) -> ToolResult:
+        """Resolve the replace in file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        diff_content = self.tool.diff
+        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
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(success=False, message=get_message_with_format("replace_in_file.access_denied", file_path=file_path))
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            return self.replace_in_file_with_shadow(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)
+        else:
+            return self.replace_in_file_normal(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)