auto-coder 0.1.344__tar.gz → 0.1.346__tar.gz

{auto_coder-0.1.344 → auto_coder-0.1.346}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.344
+Version: 0.1.346
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.344
+Version: 0.1.346
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/auto_coder.egg-info/SOURCES.txt

@@ -121,6 +121,7 @@ src/autocoder/common/v2/agent/agentic_edit.py
 src/autocoder/common/v2/agent/agentic_edit_conversation.py
 src/autocoder/common/v2/agent/agentic_edit_types.py
 src/autocoder/common/v2/agent/agentic_tool_display.py
+src/autocoder/common/v2/agent/ignore_utils.py
 src/autocoder/common/v2/agent/agentic_edit_tools/__init__.py
 src/autocoder/common/v2/agent/agentic_edit_tools/ask_followup_question_tool_resolver.py
 src/autocoder/common/v2/agent/agentic_edit_tools/attempt_completion_tool_resolver.py

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/autocoder/auto_coder_runner.py

@@ -40,7 +40,7 @@ from rich.markdown import Markdown
 from byzerllm.utils.nontext import Image
 import git
 from autocoder.common import git_utils
-from autocoder.chat_auto_coder_lang import get_message
+from autocoder.chat_auto_coder_lang import get_message,get_message_with_format
 from autocoder.agent.auto_guess_query import AutoGuessQuery
 from autocoder.common.mcp_server import get_mcp_server
 from autocoder.common.mcp_server_types import (
@@ -273,8 +273,8 @@ def initialize_system(args:InitializeSystemRequest):
         else:
             print(f"  {message}")
 
-    def init_project():        
-        if not os.path.exists(".auto-coder"):
+    def init_project():           
+        if not os.path.exists(".auto-coder") or not os.path.exists("actions"):
             first_time[0] = True
             print_status(get_message("not_initialized"), "warning")
             init_choice = input(
@@ -295,8 +295,7 @@ def initialize_system(args:InitializeSystemRequest):
 
         if not os.path.exists(base_persist_dir):
             os.makedirs(base_persist_dir, exist_ok=True)
-            print_status(get_message("created_dir").format(
-                base_persist_dir), "success")
+            print_status(get_message_with_format("created_dir",path=base_persist_dir), "success")
 
         if first_time[0]:
             configure_project_type()

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/autocoder/common/v2/agent/agentic_edit.py

@@ -221,7 +221,7 @@ class AgenticEdit:
         {{files}}
         </files>
 
-        ====
+        ====        
 
         TOOL USE
 
@@ -667,7 +667,35 @@ class AgenticEdit:
         You can use the tool  `read_file` to read these description files, which helps you decide exactly which files need detailed attention. Note that the `active.md` file does not contain information about all files within the directory—it only includes information 
         about the files that were recently changed.
         {% endif %}
+
+        {% if extra_docs %}
+        ====
+        
+        RULES PROVIDED BY USER
+
+        The following rules are provided by the user, and you must follow them strictly.
+
+        {% for key, value in extra_docs.items() %}
+        ### {{ key }}
+        {{ value }}
+        {% endfor %}        
+        {% endif %}
         """
+        import os
+        extra_docs = {}
+        rules_dir = os.path.join(self.args.source_dir,".auto-coder", "autocoderrules")
+        if os.path.isdir(rules_dir):
+            for fname in os.listdir(rules_dir):
+                if fname.endswith(".md"):
+                    fpath = os.path.join(rules_dir, fname)
+                    try:
+                        with open(fpath, "r", encoding="utf-8") as f:
+                            content = f.read()
+                            key = os.path.splitext(fname)[0]
+                            extra_docs[key] = content
+                    except Exception:
+                        continue
+
         env_info = detect_env()
         shell_type = "bash"
         if shells.is_running_in_cmd():
@@ -687,6 +715,7 @@ class AgenticEdit:
             "files": self.files.to_str(),
             "mcp_server_info": self.mcp_server_info,
             "enable_active_context": self.args.enable_active_context,
+            "extra_docs": extra_docs,
         }
 
     # Removed _execute_command_result and execute_auto_command methods
@@ -736,8 +765,8 @@ class AgenticEdit:
         Analyzes the user request, interacts with the LLM, parses responses,
         executes tools, and yields structured events for visualization until completion or error.
         """
-        system_prompt = self._analyze.prompt(request)  
-        # print(system_prompt)      
+        system_prompt = self._analyze.prompt(request)
+        # print(system_prompt)
         conversations = [
             {"role": "system", "content": system_prompt},
         ] + self.conversation_manager.get_history()
@@ -747,13 +776,13 @@ class AgenticEdit:
         self.conversation_manager.add_user_message(request.user_input)
         logger.debug(
             f"Initial conversation history size: {len(conversations)}")
-        
+
         tool_executed = False
         while True:
             global_cancel.check_and_raise()
             logger.info(
                 f"Starting LLM interaction cycle. History size: {len(conversations)}")
-            
+
             assistant_buffer = ""
 
             llm_response_gen = stream_chat_with_continue(
@@ -954,10 +983,10 @@ class AgenticEdit:
                                 params['options'])
                         except json.JSONDecodeError:
                             logger.warning(
-                                f"Could not decode JSON options for plan_mode_respond_tool: {params['options']}")                               
+                                f"Could not decode JSON options for plan_mode_respond_tool: {params['options']}")
                     # Handle recursive for list_files
                     if tool_tag == 'list_files' and 'recursive' in params:
-                        params['recursive'] = params['recursive'].lower() == 'true'                    
+                        params['recursive'] = params['recursive'].lower() == 'true'
                     return tool_cls(**params)
                 else:
                     logger.error(f"Tool class not found for tag: {tool_tag}")
@@ -971,6 +1000,7 @@ class AgenticEdit:
             global_cancel.check_and_raise()
 
             meta_holder.meta = metadata
+            logger.info(f"metadata: {metadata.input_tokens_count}")
             if not content_chunk:
                 continue
             buffer += content_chunk
@@ -995,7 +1025,7 @@ class AgenticEdit:
                         break
 
                 # 2. Check for </tool_tag> if inside tool block
-                elif in_tool_block:                    
+                elif in_tool_block:
                     end_tag = f"</{current_tool_tag}>"
                     end_tool_pos = buffer.find(end_tag)
                     if end_tool_pos != -1:
@@ -1155,16 +1185,16 @@ class AgenticEdit:
                     event_manager.write_result(
                         content=content.to_dict(), metadata=metadata.to_dict())
                 elif isinstance(agent_event, PlanModeRespondEvent):
-                    metadata.path = "/agent/edit/plan_mode_respond"                    
+                    metadata.path = "/agent/edit/plan_mode_respond"
                     content = EventContentCreator.create_markdown_result(
                         content=agent_event.completion.response,
                         metadata={}
-                    )                    
+                    )
                     event_manager.write_result(
                         content=content.to_dict(), metadata=metadata.to_dict())
 
-                elif isinstance(agent_event, TokenUsageEvent):                    
-                    last_meta: SingleOutputMeta = agent_event.usage                                                                           
+                elif isinstance(agent_event, TokenUsageEvent):
+                    last_meta: SingleOutputMeta = agent_event.usage
                     # Get model info for pricing
                     from autocoder.utils import llms as llm_utils
                     model_name = ",".join(llm_utils.get_llm_names(self.llm))
@@ -1181,7 +1211,7 @@ class AgenticEdit:
                     # Convert to millions
                     output_cost = (
                         last_meta.generated_tokens_count * output_price) / 1000000
-                                      
+
                     get_event_manager(self.args.event_file).write_result(
                         EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
                             model_name=model_name,
@@ -1191,7 +1221,7 @@ class AgenticEdit:
                             output_tokens=last_meta.generated_tokens_count,
                             input_cost=input_cost,
                             output_cost=output_cost
-                        ).to_dict()),metadata=metadata.to_dict())
+                        ).to_dict()), metadata=metadata.to_dict())
 
                 elif isinstance(agent_event, CompletionEvent):
                     # 在这里完成实际合并
@@ -1236,7 +1266,10 @@ class AgenticEdit:
         except Exception as e:
             logger.exception(
                 "An unexpected error occurred during agent execution:")
-            metadata.path = "/agent/edit/error"
+            metadata = EventMetadata(
+                action_file=self.args.file,
+                is_streaming=False,
+                stream_out_type="/agent/edit/error")
             error_content = EventContentCreator.create_error(
                 error_code="AGENT_FATAL_ERROR",
                 error_message=f"An unexpected error occurred: {str(e)}",
@@ -1250,7 +1283,7 @@ class AgenticEdit:
     def apply_changes(self):
         """
         Apply all tracked file changes to the original project directory.
-        """        
+        """
         for (file_path, change) in self.get_all_file_changes().items():
             with open(file_path, 'w', encoding='utf-8') as f:
                 f.write(change.content)

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/autocoder/common/v2/agent/agentic_edit_tools/ask_followup_question_tool_resolver.py

@@ -29,12 +29,12 @@ class AskFollowupQuestionToolResolver(BaseToolResolver):
         This resolver doesn't directly ask the user but prepares the data for it.
         """
         question = self.tool.question
-        options = self.tool.options
+        options = self.tool.options or []
         options_text = "\n".join([f"{i+1}. {option}" for i, option in enumerate(options)])
         if get_run_context().is_web():
             answer = get_event_manager(
                 self.args.event_file).ask_user(prompt=question)
-            self.result_manager.append(content=answer + "\n" + options_text, meta={
+            self.result_manager.append(content=answer + ("\n" + options_text if options_text else ""), meta={
                 "action": "ask_user",
                 "input": {
                     "question": question

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/autocoder/common/v2/agent/agentic_edit_tools/list_files_tool_resolver.py

@@ -1,11 +1,13 @@
 import os
 from typing import Dict, Any, Optional
 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 autocoder.common.v2.agent.agentic_edit_types import ListFilesTool, ToolResult  # Import ToolResult from types
 from loguru import logger
 import typing
 from autocoder.common import AutoCoderArgs
 
+from autocoder.common.v2.agent.ignore_utils import load_ignore_spec, should_ignore, DEFAULT_IGNORED_DIRS
+
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
 
@@ -13,26 +15,25 @@ if typing.TYPE_CHECKING:
 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.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))
 
+        # Load ignore spec from .autocoderignore if exists
+        ignore_spec = load_ignore_spec(absolute_source_dir)
+
         # Security check: Allow listing outside source_dir IF the original path is outside?
-        # For now, let's restrict to source_dir for safety, unless path explicitly starts absolute
-        # This needs careful consideration based on security requirements.
-        # Let's allow listing anywhere for now, but log a warning if outside source_dir.
-        is_outside_source = not absolute_list_path.startswith(os.path.abspath(source_dir))
+        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}")
-             # Add more checks if needed, e.g., prevent listing sensitive system dirs
+            logger.warning(f"Listing path is outside the project source directory: {list_path_str}")
 
         # Check if shadow directory exists for this path
-        shadow_paths = []
         shadow_exists = False
         shadow_dir_path = None
         if self.shadow_manager:
@@ -57,17 +58,23 @@ class ListFilesToolResolver(BaseToolResolver):
             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), ignore_spec, DEFAULT_IGNORED_DIRS, absolute_source_dir)]
                         for name in files:
                             full_path = os.path.join(root, name)
+                            if should_ignore(full_path, ignore_spec, DEFAULT_IGNORED_DIRS, absolute_source_dir):
+                                continue
                             display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
                             result.add(display_path)
-                        for name in dirs:
-                            full_path = os.path.join(root, name)
+                        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, ignore_spec, DEFAULT_IGNORED_DIRS, absolute_source_dir):
+                            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 + "/")
@@ -87,9 +94,7 @@ class ListFilesToolResolver(BaseToolResolver):
             source_files_set = list_files_in_dir(absolute_list_path)
 
         # Merge results, prioritizing shadow files if exist
-        merged_files = set()
         if shadow_exists:
-            # Use shadow files + source files that are NOT shadowed
             merged_files = shadow_files_set.union(
                 {f for f in source_files_set if f not in shadow_files_set}
             )
@@ -102,4 +107,4 @@ class ListFilesToolResolver(BaseToolResolver):
             return ToolResult(success=True, message=message, content=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)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred while listing files: {str(e)}")

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/autocoder/common/v2/agent/agentic_edit_tools/search_files_tool_resolver.py

@@ -1,13 +1,16 @@
+
 import os
 import re
 import glob
 from typing import Dict, Any, Optional
 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
+from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult  # Import ToolResult from types
 from loguru import logger
 from autocoder.common import AutoCoderArgs
 import typing
 
+from autocoder.common.v2.agent.ignore_utils import load_ignore_spec, should_ignore, DEFAULT_IGNORED_DIRS
+
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit  
 
@@ -15,18 +18,22 @@ if typing.TYPE_CHECKING:
 class SearchFilesToolResolver(BaseToolResolver):
     def __init__(self, agent: Optional['AgenticEdit'], tool: SearchFilesTool, args: AutoCoderArgs):
         super().__init__(agent, tool, args)
-        self.tool: SearchFilesTool = tool # For type hinting
+        self.tool: SearchFilesTool = tool
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
 
     def resolve(self) -> ToolResult:
         search_path_str = self.tool.path
         regex_pattern = self.tool.regex
-        file_pattern = self.tool.file_pattern or "*" # Default to all files
+        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))
 
+        # Load ignore spec from .autocoderignore if exists
+        ignore_spec = load_ignore_spec(absolute_source_dir)
+
         # Security check
-        if not absolute_search_path.startswith(os.path.abspath(source_dir)):
+        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}")
 
         # Determine search base directory: prefer shadow if exists
@@ -54,12 +61,11 @@ class SearchFilesToolResolver(BaseToolResolver):
             compiled_regex = re.compile(regex_pattern)
             search_glob_pattern = os.path.join(search_base_path, "**", file_pattern)
 
-            ignored_dirs = ['.git',".auto-coder", 'node_modules', '.mvn', '.idea', '__pycache__', '.venv', 'venv', 'dist', 'build', '.gradle']
-            logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{search_base_path}' (shadow: {shadow_exists}), ignoring directories: {ignored_dirs}")
+            logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{search_base_path}' (shadow: {shadow_exists}) with ignore rules applied.")
 
             for filepath in glob.glob(search_glob_pattern, recursive=True):
-                normalized_path = filepath.replace("\\", "/")  # Normalize for Windows paths
-                if any(f"/{ignored_dir}/" in normalized_path or normalized_path.endswith(f"/{ignored_dir}") or f"/{ignored_dir}/" in normalized_path for ignored_dir in ignored_dirs):
+                abs_path = os.path.abspath(filepath)
+                if should_ignore(abs_path, ignore_spec, DEFAULT_IGNORED_DIRS, absolute_source_dir):
                     continue
 
                 if os.path.isfile(filepath):
@@ -68,11 +74,9 @@ class SearchFilesToolResolver(BaseToolResolver):
                             lines = f.readlines()
                         for i, line in enumerate(lines):
                             if compiled_regex.search(line):
-                                # Provide context (e.g., line number and surrounding lines)
                                 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)])
-                                # For shadow files, convert to project-relative path
                                 if shadow_exists and self.shadow_manager:
                                     try:
                                         abs_project_path = self.shadow_manager.from_shadow_path(filepath)
@@ -87,10 +91,9 @@ class SearchFilesToolResolver(BaseToolResolver):
                                     "match_line": line.strip(),
                                     "context": context.strip()
                                 })
-                                # Limit results per file? Or overall? For now, collect all.
                     except Exception as e:
                         logger.warning(f"Could not read or process file {filepath}: {e}")
-                        continue # Skip files that can't be read
+                        continue
 
             message = f"Search completed. Found {len(results)} matches."
             logger.info(message)
@@ -101,4 +104,4 @@ class SearchFilesToolResolver(BaseToolResolver):
             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)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")

auto_coder-0.1.346/src/autocoder/common/v2/agent/ignore_utils.py

@@ -0,0 +1,50 @@
+
+import os
+from typing import Optional, List
+import pathspec
+
+DEFAULT_IGNORED_DIRS = ['.git', '.auto-coder', 'node_modules', '.mvn', '.idea', '__pycache__', '.venv', 'venv', 'dist', 'build', '.gradle']
+
+
+def load_ignore_spec(source_dir: str) -> Optional[pathspec.PathSpec]:
+    """
+    Loads .autocoderignore file from the source_dir if it exists.
+    Returns a PathSpec object or None if no ignore file.
+    """
+    ignore_file_path = os.path.join(source_dir, ".autocoderignore")
+    if not os.path.isfile(ignore_file_path):
+        return None
+    try:
+        with open(ignore_file_path, "r") as f:
+            ignore_patterns = f.read().splitlines()
+        spec = pathspec.PathSpec.from_lines("gitwildmatch", ignore_patterns)
+        return spec
+    except Exception:
+        return None
+
+
+def should_ignore(path: str, ignore_spec: Optional[pathspec.PathSpec], ignored_dirs: List[str], source_dir: str) -> bool:
+    """
+    Determine if a given path should be ignored based on ignore_spec and ignored_dirs.
+    - path: absolute path
+    - ignore_spec: PathSpec object or None
+    - ignored_dirs: list of directory names to ignore
+    - source_dir: root source directory absolute path
+    """
+    rel_path = os.path.relpath(path, source_dir)
+    parts = rel_path.split(os.sep)
+
+    # Always ignore if any part matches ignored_dirs
+    for part in parts:
+        if part in ignored_dirs:
+            return True
+
+    # If ignore_spec exists, use it to check
+    if ignore_spec:
+        # pathspec expects posix style paths
+        rel_path_posix = rel_path.replace(os.sep, "/")
+        # Check both file and dir ignoring
+        if ignore_spec.match_file(rel_path_posix):
+            return True
+
+    return False

{auto_coder-0.1.344 → auto_coder-0.1.346}/src/autocoder/rag/long_context_rag.py

@@ -268,6 +268,9 @@ class LongContextRAG:
 
     def _load_ignore_file(self):
         serveignore_path = os.path.join(self.path, ".serveignore")
+        if not os.path.exists(serveignore_path):
+            serveignore_path = os.path.join(self.path, ".autocoderignore")
+        
         gitignore_path = os.path.join(self.path, ".gitignore")
 
         if os.path.exists(serveignore_path):
@@ -838,8 +841,7 @@ class LongContextRAG:
                 self._print_rag_stats(rag_stat)
             else:
 
-                qa_strategy = get_qa_strategy(
-                    self.args.rag_qa_conversation_strategy)
+                qa_strategy = get_qa_strategy(self.args)
                 new_conversations = qa_strategy.create_conversation(
                     documents=[doc.source_code for doc in relevant_docs],
                     conversations=conversations, local_image_host=self.args.local_image_host