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

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

@@ -0,0 +1,189 @@
+"""
+Linter-enabled tool resolver that extends BaseToolResolver with linting capabilities.
+"""
+
+from typing import Optional, List
+from autocoder.common.v2.agent.agentic_edit_types import BaseTool, ToolResult
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_tools.linter_config_models import LinterConfig
+from autocoder.common import AutoCoderArgs
+from autocoder.common.linter_core.config_loader import load_linter_config
+import typing
+import os
+import json
+from loguru import logger
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+    from autocoder.common.linter_core.linter_manager import LinterManager
+    from autocoder.common.v2.agent.agentic_edit_tools.lint_report import LintReport
+
+
+class LinterEnabledToolResolver(BaseToolResolver):
+    """
+    Tool resolver with integrated linter support.
+    
+    This class extends BaseToolResolver to provide linting capabilities
+    for tools that modify files.
+    """
+    
+    def __init__(self, agent: Optional['AgenticEdit'], tool: BaseTool, args: AutoCoderArgs):
+        """
+        Initializes the resolver with linter support.
+
+        Args:
+            agent: The AutoCoder agent instance.
+            tool: The Pydantic model instance representing the tool call.
+            args: Additional arguments needed for execution (e.g., source_dir).
+        """
+        super().__init__(agent, tool, args)
+        
+        # Initialize linter
+        self.linter_manager: Optional['LinterManager'] = None
+        self.linter_config: Optional[LinterConfig] = None
+        self._init_linter()
+
+    def _init_linter(self):
+        """初始化 Linter 管理器"""
+        try:
+            # Load and validate linter configuration using the centralized loader
+            source_dir = getattr(self.args, 'source_dir', None)
+            linter_config_path = getattr(self.args, 'linter_config_path', None)
+            
+            raw_config = load_linter_config(
+                config_path=linter_config_path,
+                source_dir=source_dir
+            )
+            
+            self.linter_config = LinterConfig.from_dict(raw_config)
+            
+            # Check if linter is enabled
+            if not self.linter_config.enabled:
+                logger.debug("Linter is disabled in configuration")
+                return
+            
+            # Import and initialize LinterManager
+            from autocoder.common.linter_core.linter_manager import LinterManager
+            
+            # Convert to manager-compatible config
+            manager_config = self.linter_config.to_manager_config()
+            
+            self.linter_manager = LinterManager(manager_config, source_dir=source_dir)
+            logger.info("Linter manager initialized successfully with validated configuration")
+            
+        except ImportError as e:
+            logger.warning(f"Linter module not available: {e}")
+        except ValueError as e:
+            logger.error(f"Invalid linter configuration: {e}")
+            # Use default disabled config on validation error
+            self.linter_config = LinterConfig(enabled=False)
+        except Exception as e:
+            logger.error(f"Failed to initialize linter: {e}")
+            # Use default disabled config on error
+            self.linter_config = LinterConfig(enabled=False)
+    
+
+    def should_lint(self, file_path: str) -> bool:
+        """判断文件是否需要 lint 检查"""
+        if not self.linter_manager or not self.linter_config:
+            return False
+        
+        # Use the Pydantic model's method
+        should_lint = self.linter_config.should_lint_file(file_path)
+        
+        if not should_lint:
+            logger.debug(f"File {file_path} excluded from linting")
+        
+        return should_lint
+    
+    def lint_files(self, file_paths: List[str]) -> Optional['LintReport']:
+        """对文件运行 linter 检查"""
+        if not self.linter_manager:
+            return None
+        
+        try:
+            from autocoder.common.v2.agent.agentic_edit_tools.lint_report import LintReport
+            
+            # Convert relative paths to absolute paths
+            abs_file_paths = []
+            source_dir = self.args.source_dir or "."
+            for file_path in file_paths:
+                if not os.path.isabs(file_path):
+                    abs_path = os.path.abspath(os.path.join(source_dir, file_path))
+                else:
+                    abs_path = file_path
+                abs_file_paths.append(abs_path)
+            
+            # Run linter
+            results = self.linter_manager.lint_files(abs_file_paths, parallel=False)
+            
+            # Create report
+            report = LintReport.from_linter_results(results, self.linter_manager)
+            
+            return report
+            
+        except Exception as e:
+            logger.error(f"Error running linter: {e}")
+            return None
+    
+    def handle_lint_results(self, original_result: ToolResult, lint_report: Optional['LintReport']) -> ToolResult:
+        """处理 lint 结果并更新 ToolResult"""
+        if not lint_report or not self.linter_config:
+            return original_result
+        
+        # Get configuration from Pydantic model
+        mode = self.linter_config.mode
+        report_format = self.linter_config.report.format
+        include_in_result = self.linter_config.report.include_in_result
+        
+        # Generate report text based on format
+        if report_format == 'detailed':
+            report_text = lint_report.to_markdown()
+        elif report_format == 'json':
+            report_text = json.dumps(lint_report.to_json(), indent=2)
+        else:  # simple
+            report_text = lint_report.to_simple_text()
+        
+        # Handle based on mode
+        if mode == 'blocking' and lint_report.has_issues():
+            # Blocking mode - fail the operation
+            return ToolResult(
+                success=False,
+                message=f"Operation blocked due to lint issues:\n{report_text}",
+                content={'lint_report': lint_report.to_json()} if include_in_result else None
+            )
+        elif mode == 'silent':
+            # Silent mode - don't modify the result
+            if include_in_result and original_result.content:
+                if isinstance(original_result.content, dict):
+                    original_result.content['lint_report'] = lint_report.to_json()
+            return original_result
+        else:  # warning mode (default)
+            # Warning mode - append lint results to message
+            if lint_report.has_issues():
+                new_message = f"{original_result.message}\n\n{report_text}"
+            else:
+                new_message = f"{original_result.message}\n✅ Lint check passed - No issues found"
+            
+            # Create new result with updated message and content
+            new_content = original_result.content or {}
+            if include_in_result:
+                if isinstance(new_content, dict):
+                    new_content['lint_report'] = lint_report.to_json()
+                else:
+                    new_content = {'lint_report': lint_report.to_json()}
+            
+            return ToolResult(
+                success=original_result.success,
+                message=new_message,
+                content=new_content if new_content else None
+            )
+    
+    def resolve(self) -> ToolResult:
+        """
+        Must be implemented by subclasses.
+        
+        Returns:
+            A ToolResult object indicating success or failure and a message.
+        """
+        raise NotImplementedError("Subclasses must implement the resolve method")

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

@@ -1,5 +1,7 @@
 import os
 from typing import Dict, Any, Optional, List, Set, Union
+
+from pydantic import BaseModel, Field
 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
@@ -12,97 +14,148 @@ if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
 
 
+class ListErrorInfo(BaseModel):
+    """Information about errors encountered during list operations."""
+    file_path: str = Field(..., description="Path to the file/directory that caused the error")
+    error_type: str = Field(..., description="Type of error (e.g., 'PermissionError', 'FileNotFoundError')")
+    error_message: str = Field(..., description="Detailed error message")
+    
+    class Config:
+        """Pydantic configuration."""
+        frozen = True
+        extra = "forbid"
+
+
+class ListResultContent(BaseModel):
+    """Content structure for list operation results."""
+    files: List[str] = Field(..., description="List of files and directories found")
+    errors: List[ListErrorInfo] = Field(..., description="List of errors encountered during listing")
+    
+    class Config:
+        """Pydantic configuration."""
+        frozen = True
+        extra = "forbid"
+
+
 class ListFilesToolResolver(BaseToolResolver):
     def __init__(self, agent: Optional['AgenticEdit'], tool: ListFilesTool, args: AutoCoderArgs):
         super().__init__(agent, tool, args)
         self.tool: ListFilesTool = tool  # For type hinting
-        self.shadow_manager = self.agent.shadow_manager
 
-    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"""
+    def list_files_in_dir(self, base_dir: str, recursive: bool, source_dir: str, is_outside_source: bool) -> tuple[Set[str], List[ListErrorInfo]]:
+        """Helper function to list files in a directory with error collection.
+        
+        Returns:
+            Tuple of (file set, error information list)
+        """
         result = set()
+        errors = []
+        
         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)
+                    try:
+                        # Modify dirs in-place to skip ignored dirs early
+                        accessible_dirs = []
+                        for d in dirs:
+                            dir_path = os.path.join(root, d)
+                            if should_ignore(dir_path):
+                                continue
+                            try:
+                                # Test if we can access the directory
+                                os.listdir(dir_path)
+                                accessible_dirs.append(d)
+                            except (PermissionError, OSError) as e:
+                                error_info = ListErrorInfo(
+                                    file_path=dir_path,
+                                    error_type=type(e).__name__,
+                                    error_message=f"Cannot access directory: {str(e)}"
+                                )
+                                errors.append(error_info)
+                                logger.warning(f"Cannot access directory {dir_path}: {e}")
+                        dirs[:] = accessible_dirs
+                        
+                        # Process files in current directory
+                        for name in files:
+                            full_path = os.path.join(root, name)
+                            if should_ignore(full_path):
+                                continue
+                            try:
+                                # Test if we can access the file
+                                os.stat(full_path)
+                                display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                                result.add(display_path)
+                            except (PermissionError, OSError) as e:
+                                error_info = ListErrorInfo(
+                                    file_path=full_path,
+                                    error_type=type(e).__name__,
+                                    error_message=f"Cannot access file: {str(e)}"
+                                )
+                                errors.append(error_info)
+                                logger.warning(f"Cannot access file {full_path}: {e}")
+                        
+                        # Add accessible directories to result
+                        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 + "/")
+                            
+                    except (PermissionError, OSError) as e:
+                        error_info = ListErrorInfo(
+                            file_path=root,
+                            error_type=type(e).__name__,
+                            error_message=f"Cannot access directory during walk: {str(e)}"
+                        )
+                        errors.append(error_info)
+                        logger.warning(f"Cannot access directory {root} during walk: {e}")
+                        break  # Stop walking this branch
+            else:
+                try:
+                    items = os.listdir(base_dir)
+                    for item in items:
+                        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
-                        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)
+                        try:
+                            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 (PermissionError, OSError) as e:
+                            error_info = ListErrorInfo(
+                                file_path=full_path,
+                                error_type=type(e).__name__,
+                                error_message=f"Cannot access item: {str(e)}"
+                            )
+                            errors.append(error_info)
+                            logger.warning(f"Cannot access item {full_path}: {e}")
+                except (PermissionError, OSError) as e:
+                    error_info = ListErrorInfo(
+                        file_path=base_dir,
+                        error_type=type(e).__name__,
+                        error_message=f"Cannot list directory: {str(e)}"
+                    )
+                    errors.append(error_info)
+                    logger.warning(f"Cannot list directory {base_dir}: {e}")
         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:
-            logger.warning(f"Listing path is outside the project source directory: {list_path_str}")
-
-        # Check if shadow directory exists for this path
-        shadow_exists = False
-        shadow_dir_path = None
-        if self.shadow_manager:
-            try:
-                shadow_dir_path = self.shadow_manager.to_shadow_path(absolute_list_path)
-                if os.path.exists(shadow_dir_path) and os.path.isdir(shadow_dir_path):
-                    shadow_exists = True
-            except Exception as e:
-                logger.warning(f"Error checking shadow path for {absolute_list_path}: {e}")
-
-        # Validate that at least one of the directories exists
-        if not os.path.exists(absolute_list_path) and not shadow_exists:
-            return ToolResult(success=False, message=f"Error: Path not found: {list_path_str}")
-        if os.path.exists(absolute_list_path) and not os.path.isdir(absolute_list_path):
-            return ToolResult(success=False, message=f"Error: Path is not a directory: {list_path_str}")
-        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}")
-
-        # Collect files from shadow and/or source directory
-        shadow_files_set = set()
-        if shadow_exists:
-            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 = self.list_files_in_dir(absolute_list_path, recursive, source_dir, is_outside_source)
-
-        # Merge results, prioritizing shadow files if exist
-        if shadow_exists:
-            merged_files = shadow_files_set.union(
-                {f for f in source_files_set if f not in shadow_files_set}
+            error_info = ListErrorInfo(
+                file_path=base_dir,
+                error_type=type(e).__name__,
+                error_message=f"Unexpected error: {str(e)}"
             )
-        else:
-            merged_files = source_files_set
-
-        try:
-            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(merged_files)} items."
-            logger.info(message)
-            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)}")
+            errors.append(error_info)
+            logger.warning(f"Unexpected error listing files in {base_dir}: {e}")
+            
+        return result, errors
+        
 
-    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"""
+    def list_files_normal(self, list_path_str: str, recursive: bool, source_dir: str, absolute_source_dir: str, absolute_list_path: str) -> Union[ToolResult, tuple[List[str], List[ListErrorInfo]]]:
+        """List files directly without using shadow manager with error collection.
+        
+        Returns:
+            ToolResult on error, or tuple of (file list, error information) on success
+        """
         # 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:
@@ -115,14 +168,13 @@ class ListFilesToolResolver(BaseToolResolver):
             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)
+        files_set, errors = 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)
+            sorted_files = sorted(files_set)
+            return sorted_files, errors
         except Exception as e:
-            logger.error(f"Error listing files in '{list_path_str}': {str(e)}")
+            logger.error(f"Error sorting 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:
@@ -133,23 +185,39 @@ class ListFilesToolResolver(BaseToolResolver):
         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):
-            total_items = len(result)
-            # Limit results to 200 if needed
-            if total_items > 200:
-                truncated_result = result[:200]
-                message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {total_items} items, showing only the first 200."
-                logger.info(message)
-                return ToolResult(success=True, message=message, content=truncated_result)
-            else:
-                message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {total_items} items."
-                return ToolResult(success=True, message=message, content=result)
-        else:
+        # Use the normal implementation since shadow_manager is no longer available
+        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 ToolResult (error case)
+        if isinstance(result, ToolResult):
             return result
+            
+        # Handle successful results (tuple of files and errors)
+        files_list, errors = result
+        total_items = len(files_list)
+        total_errors = len(errors)
+        
+        # Prepare error summary for message
+        error_summary = ""
+        if total_errors > 0:
+            error_types = {}
+            for error in errors:
+                error_types[error.error_type] = error_types.get(error.error_type, 0) + 1
+            error_summary = f" Encountered {total_errors} errors: " + ", ".join([f"{count} {error_type}" for error_type, count in error_types.items()])
+        
+        # Prepare content with both results and errors using Pydantic model
+        truncated_files = files_list[:200] if total_items > 200 else files_list
+        content_model = ListResultContent(
+            files=truncated_files,
+            errors=errors
+        )
+        content = content_model.model_dump()
+        
+        # Limit results to 200 if needed
+        if total_items > 200:
+            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {total_items} items, showing only the first 200.{error_summary}"
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=content)
+        else:
+            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {total_items} items.{error_summary}"
+            return ToolResult(success=True, message=message, content=content)