auto-coder 0.1.399__py3-none-any.whl → 1.0.0__py3-none-any.whl

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

@@ -12,7 +12,10 @@ from .attempt_completion_tool_resolver import AttemptCompletionToolResolver
 from .plan_mode_respond_tool_resolver import PlanModeRespondToolResolver
 from .use_mcp_tool_resolver import UseMcpToolResolver
 from .use_rag_tool_resolver import UseRAGToolResolver
-from .list_package_info_tool_resolver import ListPackageInfoToolResolver
+from .todo_read_tool_resolver import TodoReadToolResolver
+from .todo_write_tool_resolver import TodoWriteToolResolver
+from .ac_mod_read_tool_resolver import ACModReadToolResolver
+from .ac_mod_write_tool_resolver import ACModWriteToolResolver
 
 __all__ = [
     "BaseToolResolver",
@@ -29,4 +32,8 @@ __all__ = [
     "UseMcpToolResolver",
     "UseRAGToolResolver",
     "ListPackageInfoToolResolver",
+    "TodoReadToolResolver",
+    "TodoWriteToolResolver",
+    "ACModReadToolResolver",
+    "ACModWriteToolResolver",
 ]

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,43 @@
+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_types import ACModWriteTool, ToolResult,ReplaceInFileTool
+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")
+        
+        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)])

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

@@ -9,7 +9,7 @@ from autocoder.common import shells
 from autocoder.common.printer import Printer
 from loguru import logger
 import typing   
-from autocoder.common.context_pruner import PruneContext
+from autocoder.common.pruner.context_pruner import PruneContext
 from autocoder.rag.token_counter import count_tokens
 from autocoder.common import SourceCode
 from autocoder.common import AutoCoderArgs

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

@@ -3,7 +3,7 @@ from typing import Dict, Any, Optional
 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
-from autocoder.common.context_pruner import PruneContext
+from autocoder.common.pruner.context_pruner import PruneContext
 from autocoder.common import SourceCode
 from autocoder.rag.token_counter import count_tokens
 from loguru import logger

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

@@ -3,7 +3,8 @@ import re
 import glob
 from typing import Dict, Any, Optional, List, Union
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
-from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult  # Import ToolResult from types
+# Import ToolResult from types
+from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult
 from loguru import logger
 from autocoder.common import AutoCoderArgs
 import typing
@@ -11,7 +12,7 @@ import typing
 from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
-    from autocoder.common.v2.agent.agentic_edit import AgenticEdit  
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
 
 
 class SearchFilesToolResolver(BaseToolResolver):
@@ -24,12 +25,13 @@ class SearchFilesToolResolver(BaseToolResolver):
         """Helper function to search in a directory"""
         search_results = []
         search_glob_pattern = os.path.join(base_dir, "**", file_pattern)
-        
-        logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{base_dir}' (shadow: {is_shadow}) with ignore rules applied.")
-        
+
+        logger.info(
+            f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{base_dir}' (shadow: {is_shadow}) with ignore rules applied.")
+
         if compiled_regex is None:
             compiled_regex = re.compile(regex_pattern)
-            
+
         for filepath in glob.glob(search_glob_pattern, recursive=True):
             abs_path = os.path.abspath(filepath)
             if should_ignore(abs_path):
@@ -43,17 +45,22 @@ class SearchFilesToolResolver(BaseToolResolver):
                         if compiled_regex.search(line):
                             context_start = max(0, i - 2)
                             context_end = min(len(lines), i + 3)
-                            context = "".join([f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
-                            
+                            context = "".join(
+                                [f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
+
                             if is_shadow and self.shadow_manager:
                                 try:
-                                    abs_project_path = self.shadow_manager.from_shadow_path(filepath)
-                                    relative_path = os.path.relpath(abs_project_path, source_dir)
+                                    abs_project_path = self.shadow_manager.from_shadow_path(
+                                        filepath)
+                                    relative_path = os.path.relpath(
+                                        abs_project_path, source_dir)
                                 except Exception:
-                                    relative_path = os.path.relpath(filepath, source_dir)
+                                    relative_path = os.path.relpath(
+                                        filepath, source_dir)
                             else:
-                                relative_path = os.path.relpath(filepath, source_dir)
-                            
+                                relative_path = os.path.relpath(
+                                    filepath, source_dir)
+
                             search_results.append({
                                 "path": relative_path,
                                 "line_number": i + 1,
@@ -61,73 +68,12 @@ class SearchFilesToolResolver(BaseToolResolver):
                                 "context": context.strip()
                             })
                 except Exception as e:
-                    logger.warning(f"Could not read or process file {filepath}: {e}")
+                    logger.warning(
+                        f"Could not read or process file {filepath}: {e}")
                     continue
-        
-        return search_results
-
-    def search_files_with_shadow(self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str, absolute_source_dir: str, absolute_search_path: str) -> Union[ToolResult, List[Dict[str, Any]]]:
-        """Search files using shadow manager for path translation"""
-        # Security check
-        if not absolute_search_path.startswith(absolute_source_dir):
-            return ToolResult(success=False, message=f"Error: Access denied. Attempted to search outside the project directory: {search_path_str}")
-
-        # Check if shadow directory exists
-        shadow_exists = False
-        shadow_dir_path = None
-        if self.shadow_manager:
-            try:
-                shadow_dir_path = self.shadow_manager.to_shadow_path(absolute_search_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_search_path}: {e}")
-
-        # Validate that at least one of the directories exists
-        if not os.path.exists(absolute_search_path) and not shadow_exists:
-            return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
-        if os.path.exists(absolute_search_path) and not os.path.isdir(absolute_search_path):
-            return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
-        if shadow_exists and not os.path.isdir(shadow_dir_path):
-            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {shadow_dir_path}")
 
-        try:
-            compiled_regex = re.compile(regex_pattern)
-            
-            # Search in both directories and merge results
-            shadow_results = []
-            source_results = []
-            
-            if shadow_exists:
-                shadow_results = self.search_in_dir(shadow_dir_path, regex_pattern, file_pattern, source_dir, is_shadow=True, compiled_regex=compiled_regex)
-            
-            if os.path.exists(absolute_search_path) and os.path.isdir(absolute_search_path):
-                source_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
-            
-            # Merge results, prioritizing shadow results
-            # Create a dictionary for quick lookup
-            results_dict = {}
-            for result in source_results:
-                key = (result["path"], result["line_number"])
-                results_dict[key] = result
-            
-            # Override with shadow results
-            for result in shadow_results:
-                key = (result["path"], result["line_number"])
-                results_dict[key] = result
-            
-            # Convert back to list
-            merged_results = list(results_dict.values())
-
-            return merged_results
+        return search_results
 
-        except re.error as e:
-            logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")
-            return ToolResult(success=False, message=f"Invalid regex pattern: {e}")
-        except Exception as e:
-            logger.error(f"Error during file search: {str(e)}")
-            return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")
-    
     def search_files_normal(self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str, absolute_source_dir: str, absolute_search_path: str) -> Union[ToolResult, List[Dict[str, Any]]]:
         """Search files directly without using shadow manager"""
         # Security check
@@ -142,10 +88,11 @@ class SearchFilesToolResolver(BaseToolResolver):
 
         try:
             compiled_regex = re.compile(regex_pattern)
-            
+
             # Search in the directory
-            search_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
-            
+            search_results = self.search_in_dir(
+                absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
+
             return search_results
 
         except re.error as e:
@@ -162,21 +109,19 @@ class SearchFilesToolResolver(BaseToolResolver):
         file_pattern = self.tool.file_pattern or "*"
         source_dir = self.args.source_dir or "."
         absolute_source_dir = os.path.abspath(source_dir)
-        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+        absolute_search_path = os.path.abspath(
+            os.path.join(source_dir, search_path_str))
 
-        # Choose the appropriate implementation based on whether shadow_manager is available
-        if self.shadow_manager:
-            result = self.search_files_with_shadow(search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
-        else:
-            result = self.search_files_normal(search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
+        result = self.search_files_normal(
+            search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
 
         # Handle the case where the implementation returns a list instead of a ToolResult
         if isinstance(result, list):
-            total_results = len(result)            
+            total_results = len(result)
             # Limit results to 200 if needed
             if total_results > 200:
                 truncated_results = result[:200]
-                message = f"Search completed. Found {total_results} matches, showing only the first 200."                
+                message = f"Search completed. Found {total_results} matches, showing only the first 200."
                 logger.info(message)
                 return ToolResult(success=True, message=message, content=truncated_results)
             else:

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

@@ -110,7 +110,7 @@ def test_create_new_file(test_args, temp_test_dir, mock_agent_no_shadow):
     result = resolver.resolve()
 
     assert result.success is True
-    assert "成功写入文件" in result.message or "Successfully wrote file" in result.message
+    assert "Successfully wrote file" in result.message
     
     expected_file_abs_path = os.path.join(temp_test_dir, file_path)
     assert os.path.exists(expected_file_abs_path)
@@ -135,7 +135,7 @@ def test_overwrite_existing_file(test_args, temp_test_dir, mock_agent_no_shadow)
 
     assert result.success is True
     assert os.path.exists(abs_file_path)
-    with open(abs_file_path, "r", encoding="utf-f8") as f:
+    with open(abs_file_path, "r", encoding="utf-8") as f:
         assert f.read() == new_content
     mock_agent_no_shadow.record_file_change.assert_called_once_with(file_path, "modified", content=new_content, diffs=None)
 
@@ -202,7 +202,7 @@ def test_path_outside_project_root_fails(test_args, temp_test_dir, mock_agent_no
     result = resolver.resolve()
 
     assert result.success is False
-    assert "访问被拒绝" in result.message or "Access denied" in result.message
+    assert "Access denied" in result.message
     assert not os.path.exists(outside_abs_path)
     
     # shutil.rmtree(another_temp_dir) # Clean up the other temp dir if created by this test
@@ -226,8 +226,8 @@ def test_linting_not_called_if_disabled(test_args, temp_test_dir, mock_agent_no_
     if mock_agent_no_shadow and hasattr(mock_agent_no_shadow, 'shadow_linter') and mock_agent_no_shadow.shadow_linter:
         mock_agent_no_shadow.shadow_linter.lint_shadow_file.assert_not_called()
     
-    # Check if "代码质量检查已禁用" or "Linting is disabled" is in message
-    assert "代码质量检查已禁用" in result.message or "Linting is disabled" in result.message or "成功写入文件" in result.message
+    # Check if "Linting is disabled" or "Successfully wrote file" is in message
+    assert "Linting is disabled" in result.message or "Successfully wrote file" in result.message
 
 
 def test_linting_called_if_enabled(test_args, temp_test_dir, mock_agent_with_shadow):
@@ -251,7 +251,7 @@ def test_linting_called_if_enabled(test_args, temp_test_dir, mock_agent_with_sha
     # The actual path passed to lint_shadow_file will be the shadow path
     shadow_path = mock_agent_with_shadow.shadow_manager.to_shadow_path(os.path.join(temp_test_dir, file_path))
     mock_agent_with_shadow.shadow_linter.lint_shadow_file.assert_called_with(shadow_path)
-    assert "代码质量检查通过" in result.message or "Linting passed" in result.message
+    assert "Linting passed" in result.message
 
 
 def test_create_file_with_shadow_manager(test_args, temp_test_dir, mock_agent_with_shadow):
@@ -311,12 +311,12 @@ def test_linting_error_message_propagation(test_args, temp_test_dir, mock_agent_
     
     # Temporarily patch _format_lint_issues within the resolver instance for this test
     # to ensure consistent output for assertion.
-    formatted_issue_text = f"文件: {mock_agent_with_shadow.shadow_manager.to_shadow_path(os.path.join(temp_test_dir, file_path))}\n  - [错误] 第1行, 第0列: SyntaxError: Missing parentheses in call to 'print' (规则: E999)\n"
+    formatted_issue_text = f"File: {mock_agent_with_shadow.shadow_manager.to_shadow_path(os.path.join(temp_test_dir, file_path))}\n  - [ERROR] Line 1, Column 0: SyntaxError: Missing parentheses in call to 'print' (Rule: E999)\n"
     with patch.object(resolver, '_format_lint_issues', return_value=formatted_issue_text) as mock_format:
         result = resolver.resolve()
 
     assert result.success is True # Write itself is successful
     mock_format.assert_called_once_with(mock_lint_result)
-    assert "代码质量检查发现 1 个问题" in result.message or "Linting found 1 issue(s)" in result.message
+    assert "Linting found 1 issue(s)" in result.message
     assert "SyntaxError: Missing parentheses in call to 'print'" in result.message
 

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

@@ -0,0 +1,118 @@
+from typing import Dict, Any, Optional, List
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import TodoReadTool, ToolResult
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+import os
+import json
+from datetime import datetime
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class TodoReadToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: TodoReadTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: TodoReadTool = tool  # For type hinting
+        
+    def _get_todo_file_path(self) -> str:
+        """Get the path to the todo file for this session."""
+        source_dir = self.args.source_dir or "."
+        todo_dir = os.path.join(source_dir, ".auto-coder", "todos")
+        os.makedirs(todo_dir, exist_ok=True)
+        return os.path.join(todo_dir, "current_session.json")
+    
+    def _load_todos(self) -> List[Dict[str, Any]]:
+        """Load todos from the session file."""
+        todo_file = self._get_todo_file_path()
+        if not os.path.exists(todo_file):
+            return []
+        
+        try:
+            with open(todo_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                return data.get('todos', [])
+        except Exception as e:
+            logger.warning(f"Failed to load todos: {e}")
+            return []
+    
+    def _format_todo_display(self, todos: List[Dict[str, Any]]) -> str:
+        """Format todos for display."""
+        if not todos:
+            return "No todos found for this session."
+        
+        output = []
+        output.append("=== Current Session Todo List ===\n")
+        
+        # Group by status
+        pending = [t for t in todos if t.get('status') == 'pending']
+        in_progress = [t for t in todos if t.get('status') == 'in_progress']
+        completed = [t for t in todos if t.get('status') == 'completed']
+        
+        if in_progress:
+            output.append("🔄 In Progress:")
+            for todo in in_progress:
+                priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(todo.get('priority', 'medium'), "⚪")
+                output.append(f"  {priority_icon} [{todo['id']}] {todo['content']}")
+                if todo.get('notes'):
+                    output.append(f"     📝 {todo['notes']}")
+            output.append("")
+        
+        if pending:
+            output.append("⏳ Pending:")
+            for todo in pending:
+                priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(todo.get('priority', 'medium'), "⚪")
+                output.append(f"  {priority_icon} [{todo['id']}] {todo['content']}")
+                if todo.get('notes'):
+                    output.append(f"     📝 {todo['notes']}")
+            output.append("")
+        
+        if completed:
+            output.append("✅ Completed:")
+            for todo in completed:
+                priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(todo.get('priority', 'medium'), "⚪")
+                output.append(f"  {priority_icon} [{todo['id']}] {todo['content']}")
+                if todo.get('notes'):
+                    output.append(f"     📝 {todo['notes']}")
+            output.append("")
+        
+        # Add summary
+        total = len(todos)
+        pending_count = len(pending)
+        in_progress_count = len(in_progress)
+        completed_count = len(completed)
+        
+        output.append(f"📊 Summary: Total {total} items | Pending {pending_count} | In Progress {in_progress_count} | Completed {completed_count}")
+        
+        return "\n".join(output)
+
+    def resolve(self) -> ToolResult:
+        """
+        Read the current todo list and return it in a formatted display.
+        """
+        try:
+            logger.info("Reading current todo list")
+            
+            # Load todos from file
+            todos = self._load_todos()
+            
+            # Format for display
+            formatted_display = self._format_todo_display(todos)
+            
+            logger.info(f"Found {len(todos)} todos in current session")
+            
+            return ToolResult(
+                success=True,
+                message="Todo list retrieved successfully.",
+                content=formatted_display
+            )
+            
+        except Exception as e:
+            logger.error(f"Error reading todo list: {e}")
+            return ToolResult(
+                success=False,
+                message=f"Failed to read todo list: {str(e)}",
+                content=None
+            )