auto-coder 0.1.374__py3-none-any.whl → 0.1.375__py3-none-any.whl

autocoder/agent/base_agentic/tools/list_files_tool_resolver.py

@@ -1,7 +1,7 @@
 import os
 from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
 from autocoder.agent.base_agentic.types import ListFilesTool, ToolResult  # Import ToolResult from types
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any, List, Set, Union
 import fnmatch
 import re
 import json
@@ -21,13 +21,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:
@@ -52,46 +79,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:
@@ -104,7 +99,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/agent/base_agentic/tools/read_file_tool_resolver.py

@@ -5,6 +5,16 @@ from autocoder.agent.base_agentic.types import ReadFileTool, ToolResult  # Impor
 from loguru import logger
 import typing
 from autocoder.common import AutoCoderArgs
+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 ..base_agent import BaseAgent
@@ -15,40 +25,93 @@ 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
+        )
+
+        if not pruned_sources:
+            return content
+
+        return pruned_sources[0].source_code
 
-        # # 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}")
+    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_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:
-            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
+            # 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}")
+
+            # Check if file exists
             if not os.path.exists(abs_file_path):
-                return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
+                return ToolResult(success=False, message=f"Error: File not found: {file_path}")
             if not os.path.isfile(abs_file_path):
-                return ToolResult(success=False, message=f"Error: Path is not a file: {file_path}")
+                return ToolResult(success=False, message=f"Error: Not a file: {file_path}")
 
-            with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
-                content = f.read()
+            # Read file content
+            content = self._read_file_content(abs_file_path)
             logger.info(f"Successfully read file: {file_path}")
             return ToolResult(success=True, message=f"Successfully read file: {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)}")
+
+    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))
+        
+        return self.read_file_normal(file_path, source_dir, abs_project_dir, abs_file_path)
+            

autocoder/agent/base_agentic/tools/replace_in_file_tool_resolver.py

@@ -10,6 +10,9 @@ from autocoder.common.printer import Printer
 from autocoder.common import AutoCoderArgs
 from loguru import logger
 from autocoder.common.auto_coder_lang import get_message_with_format
+from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
+from autocoder.linters.models import IssueSeverity, FileLintResult
 if typing.TYPE_CHECKING:
     from ..base_agent import BaseAgent
 
@@ -17,7 +20,9 @@ class ReplaceInFileToolResolver(BaseToolResolver):
     def __init__(self, agent: Optional['BaseAgent'], tool: ReplaceInFileTool, args: AutoCoderArgs):
         super().__init__(agent, tool, args)
         self.tool: ReplaceInFileTool = tool  # For type hinting
+        self.args = args
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
+        self.shadow_linter = self.agent.shadow_linter if self.agent else None
 
     def parse_diff(self, diff_content: str) -> List[Tuple[str, str]]:
         """
@@ -61,78 +66,155 @@ class ReplaceInFileToolResolver(BaseToolResolver):
             logger.warning(f"Could not parse any SEARCH/REPLACE blocks from diff: {diff_content}")
         return blocks
 
-    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))
+    def _filter_lint_issues(self, lint_result:FileLintResult, levels: List[IssueSeverity] = [IssueSeverity.ERROR, IssueSeverity.WARNING]):
+        """
+        过滤 lint 结果，只保留指定级别的问题
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            levels: 要保留的问题级别列表，默认保留 ERROR 和 WARNING 级别
+            
+        返回:
+            过滤后的 lint 结果对象（原对象的副本）
+        """
+        if not lint_result or not lint_result.issues:
+            return lint_result
+            
+        # 创建一个新的 issues 列表，只包含指定级别的问题
+        filtered_issues = []
+        for issue in lint_result.issues:
+            if issue.severity in levels:                
+                filtered_issues.append(issue)
+                
+        # 更新 lint_result 的副本
+        filtered_result = lint_result
+        filtered_result.issues = filtered_issues
+        
+        # 更新计数
+        filtered_result.error_count = sum(1 for issue in filtered_result.issues if issue.severity == IssueSeverity.ERROR)
+        filtered_result.warning_count = sum(1 for issue in filtered_result.issues if issue.severity == IssueSeverity.WARNING)
+        filtered_result.info_count = sum(1 for issue in filtered_result.issues if issue.severity == IssueSeverity.INFO)
+        
+        return filtered_result
+        
+    def _format_lint_issues(self, lint_result:FileLintResult):
+        """
+        将 lint 结果格式化为可读的文本格式
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            
+        返回:
+            str: 格式化的问题描述
+        """
+        formatted_issues = []
+        
+        for issue in lint_result.issues:
+            severity = "错误" if issue.severity.value == 3 else "警告" if issue.severity.value == 2 else "信息"
+            line_info = f"第{issue.position.line}行"
+            if issue.position.column:
+                line_info += f", 第{issue.position.column}列"
+            
+            formatted_issues.append(
+                f"  - [{severity}] {line_info}: {issue.message} (规则: {issue.code})"
+            )
+        
+        return "\n".join(formatted_issues)
 
-        # Determine target path: shadow file if shadow_manager exists
-        target_path = abs_file_path
-        if self.shadow_manager:
-            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
+    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:
-            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)
-                with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
-                    original_content = f.read()
-                # create parent dirs of shadow if needed
-                os.makedirs(os.path.dirname(target_path), exist_ok=True)
-                # write original content into shadow file as baseline
-                with open(target_path, 'w', encoding='utf-8') as f:
-                    f.write(original_content)
-                logger.info(f"[Shadow] Initialized shadow file from original: {target_path}")
-            else:
+            # 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))
-        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)))
+            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))
 
-        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"))
+            with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                original_content = f.read()
 
-        current_content = original_content
-        applied_count = 0
-        errors = []
+            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"))
 
-        # Apply blocks sequentially
-        for i, (search_block, replace_block) in enumerate(parsed_blocks):
-            start_index = current_content.find(search_block)
+            current_content = original_content
+            applied_count = 0
+            errors = []
 
-            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
+            # Apply blocks sequentially
+            for i, (search_block, replace_block) in enumerate(parsed_blocks):
+                start_index = current_content.find(search_block)
 
-        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 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)
 
-        try:
-            os.makedirs(os.path.dirname(target_path), exist_ok=True)
-            with open(target_path, 'w', encoding='utf-8') as f:
-                f.write(current_content)
+            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
+            logger.info(f"检查Lint功能状态: enable_lint={enable_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:
+                            # 过滤 lint 结果，只保留 ERROR 和 WARNING 级别的问题
+                            filtered_results = self._filter_lint_issues(lint_results)
+                            if filtered_results.issues:
+                                has_lint_issues = True
+                                # 格式化 lint 问题
+                                formatted_issues = self._format_lint_issues(filtered_results)
+                                lint_message = f"\n\n代码质量检查发现 {len(filtered_results.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, 
@@ -143,14 +225,41 @@ class ReplaceInFileToolResolver(BaseToolResolver):
                 message = get_message_with_format("replace_in_file.apply_success", 
                                                   applied=applied_count, 
                                                   total=len(parsed_blocks), 
-                                                  file_path=file_path)
+                                                  file_path=file_path)                        
 
             # 变更跟踪，回调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:
+                message = message + "\n" + lint_message
+                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=current_content)
+            return ToolResult(success=True, message=message, content=result_content)
         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))
+                
+        return self.replace_in_file_normal(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)