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

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

@@ -0,0 +1,279 @@
+import os
+from typing import Optional, List
+from pydantic import BaseModel
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import ACModListTool, ToolResult
+from autocoder.common.tokens import count_directory_tokens
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore, DEFAULT_EXCLUDES
+from loguru import logger
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class DirectoryInfo(BaseModel):
+    """Directory information model"""
+    file_count: int
+    tokens: int
+
+
+class ACModuleInfo(BaseModel):
+    """Complete AC module information model"""
+    path: str
+    absolute_path: str
+    title: str
+    file_count: int
+    tokens: int
+
+
+class CompactACModuleInfo(BaseModel):
+    """Compact AC module information model for display"""
+    path: str
+    title: str
+    tokens: int
+
+
+class ACModListToolResolver(BaseToolResolver):
+    """
+    Resolver for ACModListTool - lists all directories containing .ac.mod.md files
+    """
+    
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ACModListTool, args):
+        super().__init__(agent, tool, args)
+        self.tool: ACModListTool = tool
+        self._ignore_cache = {}  # Cache for ignore checks to improve performance
+
+    def resolve(self) -> ToolResult:
+        """
+        Lists all directories containing .ac.mod.md files (AC Modules)
+        
+        Returns:
+            ToolResult: Contains list of AC module directories and their information
+        """
+        try:
+            # Determine search root path
+            source_dir = self.args.source_dir or "."
+            search_path = self.tool.path if self.tool.path else source_dir
+            
+            # Make absolute path
+            if not os.path.isabs(search_path):
+                abs_search_path = os.path.abspath(os.path.join(source_dir, search_path))
+            else:
+                abs_search_path = search_path
+            
+            if not os.path.exists(abs_search_path):
+                return ToolResult(
+                    success=False,
+                    message=f"Search path does not exist: {search_path}"
+                )
+            
+            if not os.path.isdir(abs_search_path):
+                return ToolResult(
+                    success=False,
+                    message=f"Search path is not a directory: {search_path}"
+                )
+            
+            logger.info(f"Searching for AC modules in: {abs_search_path}")
+            
+            # Find all AC modules
+            ac_modules = self._find_ac_modules(abs_search_path, source_dir)
+            
+            if not ac_modules:
+                formatted_content = f"Search path: {search_path}\nTotal: 0 modules\n\nNo AC modules found."
+                return ToolResult(
+                    success=True,
+                    message="No AC modules found in the specified path",
+                    content=formatted_content
+                )
+            
+            # Format result message and content
+            module_count = len(ac_modules)
+            message = f"Found {module_count} AC module{'s' if module_count != 1 else ''}"
+            
+            # Create compact module list with only path, title, tokens
+            compact_modules = []
+            for module in ac_modules:
+                compact_modules.append(CompactACModuleInfo(
+                    path=module.path,
+                    title=module.title,
+                    tokens=module.tokens
+                ))
+            
+            # Format as compact text
+            module_lines = []
+            for module in compact_modules:
+                path_display = module.path if module.path != "." else "(root)"
+                # 不显示token数量，因为默认为0
+                module_lines.append(f"  • {path_display} - {module.title}")
+            
+            formatted_content = f"Search path: {search_path}\nTotal: {module_count} modules\n\nModules:\n" + "\n".join(module_lines)
+            
+            logger.info(f"Found {module_count} AC modules")
+            
+            return ToolResult(
+                success=True,
+                message=message,
+                content=formatted_content
+            )
+            
+        except Exception as e:
+            logger.error(f"Error listing AC modules: {e}")
+            return ToolResult(
+                success=False,
+                message=f"Error listing AC modules: {str(e)}"
+            )
+    
+    def _find_ac_modules(self, search_path: str, source_dir: str) -> List[ACModuleInfo]:
+        """
+        Recursively find all directories containing .ac.mod.md files
+        
+        Args:
+            search_path: Absolute path to search in
+            source_dir: Source directory for relative path calculation
+            
+        Returns:
+            List of ACModuleInfo models containing AC module information
+        """
+        ac_modules = []
+        abs_source_dir = os.path.abspath(source_dir)
+        
+        try:
+            for root, dirs, files in os.walk(search_path):
+                # Early exit if current directory should be ignored
+                if self._should_ignore_directory(root, abs_source_dir):
+                    dirs.clear()  # Don't descend into ignored directories
+                    continue
+                    
+                # Filter out ignored directories before descending into them
+                dirs[:] = [d for d in dirs if not self._should_ignore_directory(os.path.join(root, d), abs_source_dir)]
+                
+                if ".ac.mod.md" in files:
+                    # Calculate relative path from source directory
+                    rel_path = os.path.relpath(root, abs_source_dir)
+                    if rel_path == ".":
+                        rel_path = ""
+                    
+                    # Try to read module title from .ac.mod.md file
+                    mod_file_path = os.path.join(root, ".ac.mod.md")
+                    module_title = self._extract_module_title(mod_file_path)
+                    
+                    # Get directory token info (默认返回0以提升性能)
+                    dir_info = self._get_directory_info(root)
+                    
+                    module_info = ACModuleInfo(
+                        path=rel_path if rel_path else ".",
+                        absolute_path=root,
+                        title=module_title,
+                        file_count=dir_info.file_count,
+                        tokens=dir_info.tokens
+                    )
+                    
+                    ac_modules.append(module_info)
+                    logger.debug(f"Found AC module: {rel_path} - {module_title}")
+            
+            # Sort by path for consistent ordering
+            ac_modules.sort(key=lambda x: x.path)
+            
+        except Exception as e:
+            logger.error(f"Error walking directory {search_path}: {e}")
+            raise
+        
+        return ac_modules
+    
+    def _should_ignore_directory(self, dir_path: str, project_root: str) -> bool:
+        """
+        Check if a directory should be ignored during traversal
+        
+        Args:
+            dir_path: Directory path to check
+            project_root: Project root directory for relative path calculation
+            
+        Returns:
+            True if directory should be ignored, False otherwise
+        """
+        # Check cache first for performance
+        cache_key = (dir_path, project_root)
+        if cache_key in self._ignore_cache:
+            return self._ignore_cache[cache_key]
+        
+        # Fast check for common ignore patterns first (performance optimization)
+        dir_name = os.path.basename(dir_path)
+        if dir_name in DEFAULT_EXCLUDES:
+            self._ignore_cache[cache_key] = True
+            return True
+            
+        try:
+            # Use ignorefiles module for more sophisticated filtering
+            result = should_ignore(dir_path, project_root)
+            self._ignore_cache[cache_key] = result
+            return result
+        except Exception as e:
+            # Fallback to basic filtering if ignorefiles module fails
+            logger.warning(f"Error checking ignore status for {dir_path}: {e}")
+            self._ignore_cache[cache_key] = False
+            return False
+    
+    def _extract_module_title(self, mod_file_path: str) -> str:
+        """
+        Extract module title from .ac.mod.md file
+        
+        Args:
+            mod_file_path: Path to .ac.mod.md file
+            
+        Returns:
+            Module title or default name
+        """
+        try:
+            with open(mod_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                # Read first few lines to find the title (markdown h1)
+                for line_num, line in enumerate(f):
+                    line = line.strip()
+                    if line.startswith("# "):
+                        return line[2:].strip()
+                    # Only check first 10 lines
+                    if line_num >= 9:
+                        break
+            
+            # If no title found, return a default
+            return "AC Module"
+            
+        except Exception as e:
+            logger.warning(f"Could not read title from {mod_file_path}: {e}")
+            return "AC Module"
+    
+    def _get_directory_info(self, dir_path: str) -> DirectoryInfo:
+        """
+        Get basic information about directory (file count and tokens)
+        
+        Args:
+            dir_path: Directory path
+            
+        Returns:
+            DirectoryInfo model with file count and token information
+        """
+        try:
+            # 为了提升性能，默认不统计token数量，直接返回0
+            # 只统计文件数量（快速操作），同时应用忽略规则
+            file_count = 0
+            for root, dirs, files in os.walk(dir_path):
+                # Early exit if current directory should be ignored
+                if self._should_ignore_directory(root, dir_path):
+                    dirs.clear()  # Don't descend into ignored directories
+                    continue
+                    
+                # 跳过忽略的目录
+                dirs[:] = [d for d in dirs if not self._should_ignore_directory(os.path.join(root, d), dir_path)]
+                file_count += len(files)
+            
+            return DirectoryInfo(
+                file_count=file_count,
+                tokens=0  # 默认显示0以提升性能
+            )
+            
+        except Exception as e:
+            logger.warning(f"Could not get directory info for {dir_path}: {e}")
+            return DirectoryInfo(
+                file_count=0,
+                tokens=0
+            )

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

@@ -0,0 +1,40 @@
+
+import os
+from typing import Optional
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import ACModReadTool, ToolResult
+from loguru import logger
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+class ACModReadToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ACModReadTool, args):
+        super().__init__(agent, tool, args)
+        self.tool: ACModReadTool = tool
+
+    def resolve(self) -> ToolResult:
+        source_dir = self.args.source_dir or "."        
+        input_path = self.tool.path.strip()
+        abs_input_path = os.path.abspath(os.path.join(source_dir, input_path)) if not os.path.isabs(input_path) else input_path
+
+        # # 校验输入目录是否在项目目录内
+        # if not abs_input_path.startswith(abs_source_dir):
+        #     return ToolResult(success=False, message=f"Error: Access denied. Path outside project: {self.tool.path}")
+
+        # 直接在输入文件夹中查找 .ac.mod.md 文件
+        mod_file_path = os.path.join(abs_input_path, ".ac.mod.md")
+        
+        logger.info(f"Looking for package info at: {mod_file_path}")
+
+        if not os.path.exists(mod_file_path):
+            return ToolResult(success=True, message=f"The path {self.tool.path} is NOT AC module.", content="")
+
+        try:
+            with open(mod_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+            return ToolResult(success=True, message=f"The path {self.tool.path} is AC module.", content=content)
+        except Exception as e:
+            logger.error(f"Error reading package info file: {e}")
+            return ToolResult(success=False, message=f"Error reading {self.tool.path}/.ac.mod.md file: {e}")

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

@@ -0,0 +1,52 @@
+import os
+import re
+from typing import Optional, List, Tuple
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_tools.replace_in_file_tool_resolver import ReplaceInFileToolResolver
+from autocoder.common.v2.agent.agentic_edit_tools.write_to_file_tool_resolver import WriteToFileToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import ACModWriteTool, ToolResult,ReplaceInFileTool, WriteToFileTool
+from loguru import logger
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+class ACModWriteToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ACModWriteTool, args):
+        super().__init__(agent, tool, args)
+        self.tool: ACModWriteTool = tool           
+
+    def resolve(self) -> ToolResult:
+        source_dir = self.args.source_dir or "."
+        input_path = self.tool.path.strip()
+        
+        # Check if the path already contains .ac.mod.md file name
+        if input_path.endswith('.ac.mod.md'):
+            # Path already includes the filename
+            if not os.path.isabs(input_path):
+                mod_file_path = os.path.abspath(os.path.join(source_dir, input_path))
+            else:
+                mod_file_path = input_path
+            
+            # Create the parent directory if it doesn't exist
+            parent_dir = os.path.dirname(mod_file_path)
+            os.makedirs(parent_dir, exist_ok=True)
+        else:
+            # Path is a directory, need to append .ac.mod.md
+            abs_input_path = os.path.abspath(os.path.join(source_dir, input_path)) if not os.path.isabs(input_path) else input_path
+            
+            # Create the directory if it doesn't exist
+            os.makedirs(abs_input_path, exist_ok=True)
+            
+            # Path to the .ac.mod.md file
+            mod_file_path = os.path.join(abs_input_path, ".ac.mod.md")
+        
+        # Check if .ac.mod.md file exists
+        if not os.path.exists(mod_file_path):
+            # Create new .ac.mod.md file with default template            
+            with open(mod_file_path, 'w',encoding='utf-8') as f:
+                f.write("")
+            
+        return ReplaceInFileToolResolver(self.agent, ReplaceInFileTool(path=mod_file_path, diff=self.tool.diff), self.args).resolve()
+    
+    

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

@@ -29,6 +29,14 @@ class AskFollowupQuestionToolResolver(BaseToolResolver):
         Packages the question and options to be handled by the main loop/UI.
         This resolver doesn't directly ask the user but prepares the data for it.
         """
+        # Check if running in CLI mode, if so return immediately with a message
+        # instructing the model to solve the problem on its own
+        if get_run_context().is_cli() or self.agent.args.enable_agentic_auto_approve:
+            return ToolResult(
+                success=False,
+                message="Remember, you cannot ask follow-up questions. Please try to solve the problem on your own using the available information. Do not give up and do your best to find a solution."
+            )
+            
         question = self.tool.question
         options = self.tool.options or []
         options_text = "\n".join([f"{i+1}. {option}" for i, option in enumerate(options)])