auto-coder 0.1.347__py3-none-any.whl → 0.1.349__py3-none-any.whl

autocoder/common/test_run_cmd.py

@@ -0,0 +1,110 @@
+
+import sys
+import platform
+from unittest import mock
+import io
+
+import pytest
+
+from autocoder.common.run_cmd import (
+    run_cmd,
+    run_cmd_subprocess,
+    run_cmd_subprocess_generator,
+    run_cmd_pexpect,
+    get_windows_parent_process_name,
+)
+
+def test_run_cmd_basic():
+    """
+    测试run_cmd函数，确保其正确执行命令并返回预期结果。
+    """
+    cmd = "echo hello"
+    exit_code, output = run_cmd(cmd)
+    assert exit_code == 0, f"命令退出码非零: {exit_code}"
+    assert "hello" in output, f"输出不包含hello: {output}"
+
+def test_run_cmd_subprocess_normal():
+    """
+    测试run_cmd_subprocess正常执行命令，逐步输出。
+    """
+    cmd = "echo hello_subprocess"
+    gen = run_cmd_subprocess_generator(cmd)
+    output = ""
+    try:
+        for chunk in gen:
+            output += chunk
+    except Exception as e:
+        pytest.fail(f"run_cmd_subprocess异常: {e}")
+    assert "hello_subprocess" in output
+
+def test_run_cmd_subprocess_error():
+    """
+    测试run_cmd_subprocess执行错误命令时能否正确返回异常信息。
+    """
+    cmd = "non_existing_command_xyz"
+    gen = run_cmd_subprocess_generator(cmd)
+    output = ""
+    for chunk in gen:
+        output += chunk
+    # 应该包含错误提示
+    assert "[run_cmd_subprocess error]" in output or "not found" in output or "无法" in output or "未找到" in output
+
+def test_run_cmd_pexpect_mock():
+    """
+    测试run_cmd_pexpect函数，mock pexpect交互行为。
+    """
+    with mock.patch("pexpect.spawn") as mock_spawn:
+        mock_child = mock.MagicMock()
+        mock_child.exitstatus = 0
+        mock_child.interact.side_effect = lambda output_filter=None: output_filter(b"mock output\n")
+        mock_child.close.return_value = None
+        mock_child.exitstatus = 0
+        mock_child.getvalue = lambda: b"mock output\n"
+        mock_spawn.return_value = mock_child
+
+        # 由于run_cmd_pexpect内部会decode BytesIO内容
+        exit_code, output = run_cmd_pexpect("echo hello", verbose=False)
+        assert exit_code == 0
+        assert "mock output" in output
+
+def test_get_windows_parent_process_name_mocked():
+    """
+    测试get_windows_parent_process_name，模拟不同父进程
+    """
+    if platform.system() != "Windows":
+        # 非Windows系统跳过
+        return
+
+    # 构造mock进程树
+    class FakeProcess:
+        def __init__(self, name, parent=None):
+            self._name = name
+            self._parent = parent
+
+        def name(self):
+            return self._name
+
+        def parent(self):
+            return self._parent
+
+    powershell_proc = FakeProcess("powershell.exe")
+    cmd_proc = FakeProcess("cmd.exe")
+    other_proc = FakeProcess("python.exe")
+
+    # 模拟powershell父进程
+    with mock.patch("psutil.Process") as MockProcess:
+        MockProcess.return_value = FakeProcess("python.exe", powershell_proc)
+        assert get_windows_parent_process_name() == "powershell.exe"
+
+    # 模拟cmd父进程
+    with mock.patch("psutil.Process") as MockProcess:
+        MockProcess.return_value = FakeProcess("python.exe", cmd_proc)
+        assert get_windows_parent_process_name() == "cmd.exe"
+
+    # 模拟无匹配父进程
+    with mock.patch("psutil.Process") as MockProcess:
+        MockProcess.return_value = FakeProcess("python.exe", other_proc)
+        assert get_windows_parent_process_name() is None
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__]))

autocoder/common/v2/agent/agentic_edit.py

@@ -212,18 +212,7 @@ class AgenticEdit:
     @byzerllm.prompt()
     def _analyze(self, request: AgenticEditRequest) -> str:
         """        
-        You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
-
-        ====
-
-        FILES CONTEXT
-
-        The following files are provided to you as context for the user's task. You can use these files to understand the project structure and codebase, and to make informed decisions about which files to modify.
-        If you need to read more files, you can use the tools to find and read more files.
-
-        <files>
-        {{files}}
-        </files>
+        You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.        
 
         ====        
 
@@ -690,8 +679,10 @@ class AgenticEdit:
         The following rules are provided by the user, and you must follow them strictly.
 
         {% for key, value in extra_docs.items() %}
-        ### {{ key }}
+        <user_rule>
+        ##File: {{ key }}
         {{ value }}
+        </user_rule>
         {% endfor %}        
         {% endif %}
         """
@@ -706,7 +697,7 @@ class AgenticEdit:
                     try:
                         with open(fpath, "r", encoding="utf-8") as f:
                             content = f.read()
-                            key = os.path.splitext(fname)[0]
+                            key = fpath
                             extra_docs[key] = content
                     except Exception:
                         continue
@@ -780,26 +771,57 @@ class AgenticEdit:
         Analyzes the user request, interacts with the LLM, parses responses,
         executes tools, and yields structured events for visualization until completion or error.
         """
+        logger.info(f"Starting analyze method with user input: {request.user_input[:50]}...")
         system_prompt = self._analyze.prompt(request)
+        logger.info(f"Generated system prompt with length: {len(system_prompt)}")
+        
         # print(system_prompt)
         conversations = [
             {"role": "system", "content": system_prompt},
-        ] + self.conversation_manager.get_history()
+        ] 
+        
+        logger.info("Adding initial files context to conversation")
+        conversations.append({
+            "role":"user","content":f'''
+Below are some files the user is focused on, and the content is up to date. These entries show the file paths along with their full text content, which can help you better understand the user's needs. If the information is insufficient, you can use tools such as read_file to retrieve more details.
+<files>
+{self.files.to_str()}
+</files>'''
+        })
+
+        conversations.append({
+            "role":"assistant","content":"Ok"
+        })
+        
+        logger.info("Adding conversation history")
+        conversations.extend(self.conversation_manager.get_history())        
         conversations.append({
             "role": "user", "content": request.user_input
         })
         self.conversation_manager.add_user_message(request.user_input)
-        logger.debug(
+        
+        logger.info(
             f"Initial conversation history size: {len(conversations)}")
 
+        iteration_count = 0
         tool_executed = False
         while True:
+            iteration_count += 1            
+            logger.info(f"Starting LLM interaction cycle #{iteration_count}")
             global_cancel.check_and_raise()
+            last_message = conversations[-1]
+            if last_message["role"] == "assistant":
+                logger.info(f"Last message is assistant, skipping LLM interaction cycle")
+                yield CompletionEvent(completion=AttemptCompletionTool(
+                    result=last_message["content"],
+                    command=""
+                ), completion_xml="")
+                break
             logger.info(
                 f"Starting LLM interaction cycle. History size: {len(conversations)}")
 
             assistant_buffer = ""
-
+            logger.info("Initializing stream chat with LLM")
             llm_response_gen = stream_chat_with_continue(
                 llm=self.llm,
                 conversations=conversations,
@@ -808,21 +830,29 @@ class AgenticEdit:
             )
 
             meta_holder = byzerllm.MetaHolder()
+            logger.info("Starting to parse LLM response stream")
             parsed_events = self.stream_and_parse_llm_response(
                 llm_response_gen, meta_holder)
 
+            event_count = 0
             for event in parsed_events:
+                event_count += 1
+                logger.info(f"Processing event #{event_count}: {type(event).__name__}")
                 global_cancel.check_and_raise()
                 if isinstance(event, (LLMOutputEvent, LLMThinkingEvent)):
                     assistant_buffer += event.text
-                    yield event  # Yield text/thinking immediately for display
+                    logger.debug(f"Accumulated {len(assistant_buffer)} chars in assistant buffer")
+                    yield event  # Yield text/thinking immediately for display                    
 
                 elif isinstance(event, ToolCallEvent):
                     tool_executed = True
                     tool_obj = event.tool
+                    tool_name = type(tool_obj).__name__
+                    logger.info(f"Tool call detected: {tool_name}")
                     tool_xml = event.tool_xml  # Already reconstructed by parser
 
                     # Append assistant's thoughts and the tool call to history
+                    logger.info(f"Adding assistant message with tool call to conversation history")
                     conversations.append({
                         "role": "assistant",
                         "content": assistant_buffer + tool_xml
@@ -832,11 +862,13 @@ class AgenticEdit:
                     assistant_buffer = ""  # Reset buffer after tool call
 
                     yield event  # Yield the ToolCallEvent for display
+                    logger.info("Yielded ToolCallEvent")
 
                     # Handle AttemptCompletion separately as it ends the loop
                     if isinstance(tool_obj, AttemptCompletionTool):
                         logger.info(
                             "AttemptCompletionTool received. Finalizing session.")
+                        logger.info(f"Completion result: {tool_obj.result[:50]}...")
                         yield CompletionEvent(completion=tool_obj, completion_xml=tool_xml)
                         logger.info(
                             "AgenticEdit analyze loop finished due to AttemptCompletion.")
@@ -845,6 +877,7 @@ class AgenticEdit:
                     if isinstance(tool_obj, PlanModeRespondTool):
                         logger.info(
                             "PlanModeRespondTool received. Finalizing session.")
+                        logger.info(f"Plan mode response: {tool_obj.response[:50]}...")
                         yield PlanModeRespondEvent(completion=tool_obj, completion_xml=tool_xml)
                         logger.info(
                             "AgenticEdit analyze loop finished due to PlanModeRespond.")
@@ -862,6 +895,7 @@ class AgenticEdit:
                         error_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>Error: Tool resolver not implemented.</message><content></content></tool_result>"
                     else:
                         try:
+                            logger.info(f"Creating resolver for tool: {tool_name}")
                             resolver = resolver_cls(
                                 agent=self, tool=tool_obj, args=self.args)
                             logger.info(
@@ -873,6 +907,7 @@ class AgenticEdit:
                                 tool_obj).__name__, result=tool_result)
 
                             # Prepare XML for conversation history
+                            logger.info("Preparing XML for conversation history")
                             escaped_message = xml.sax.saxutils.escape(
                                 tool_result.message)
                             content_str = str(
@@ -897,40 +932,55 @@ class AgenticEdit:
                                 error_message)
                             error_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>{escaped_error}</message><content></content></tool_result>"
 
-                    yield result_event  # Yield the ToolResultEvent for display
+                    yield result_event  # Yield the ToolResultEvent for display    
+                    logger.info("Yielded ToolResultEvent")
 
                     # Append the tool result (as user message) to history
+                    logger.info("Adding tool result to conversation history")
                     conversations.append({
                         "role": "user",  # Simulating the user providing the tool result
                         "content": error_xml
                     })
                     self.conversation_manager.add_user_message(error_xml)
-                    logger.debug(
+                    logger.info(
                         f"Added tool result to conversations for tool {type(tool_obj).__name__}")
+                    logger.info(f"Breaking LLM cycle after executing tool: {tool_name}")
                     break  # After tool execution and result, break to start a new LLM cycle
 
                 elif isinstance(event, ErrorEvent):
+                    logger.error(f"Error event occurred: {event.message}")
                     yield event  # Pass through errors
                     # Optionally stop the process on parsing errors
                     # logger.error("Stopping analyze loop due to parsing error.")
                     # return
 
+            logger.info("Yielding token usage event")
             yield TokenUsageEvent(usage=meta_holder.meta)
+            
             if not tool_executed:
                 # No tool executed in this LLM response cycle
-                logger.info("LLM response finished without executing a tool.")
+                logger.info("LLM response finished without executing a tool.")                
                 # Append any remaining assistant buffer to history if it wasn't followed by a tool
                 if assistant_buffer:
-                    conversations.append(
-                        {"role": "assistant", "content": assistant_buffer})
-                    self.conversation_manager.add_assistant_message(
-                        assistant_buffer)
+                    logger.info(f"Appending assistant buffer to history: {len(assistant_buffer)} chars")
+                    last_message = conversations[-1]
+                    if last_message["role"] != "assistant":
+                        logger.info("Adding new assistant message")
+                        conversations.append(
+                            {"role": "assistant", "content": assistant_buffer})
+                        self.conversation_manager.add_assistant_message(
+                            assistant_buffer)
+                    elif last_message["role"] == "assistant":
+                        logger.info("Appending to existing assistant message")
+                        last_message["content"] += assistant_buffer
+                        self.conversation_manager.append_to_last_message(assistant_buffer)                        
                 # If the loop ends without AttemptCompletion, it means the LLM finished talking
                 # without signaling completion. We might just stop or yield a final message.
                 # Let's assume it stops here.
+                logger.info("No tool executed and LLM finished. Breaking out of main loop.")
                 break
 
-        logger.info("AgenticEdit analyze loop finished.")
+        logger.info(f"AgenticEdit analyze loop finished after {iteration_count} iterations.")
 
     def stream_and_parse_llm_response(
         self, generator: Generator[Tuple[str, Any], None, None], meta_holder: byzerllm.MetaHolder
@@ -1013,9 +1063,7 @@ class AgenticEdit:
 
         for content_chunk, metadata in generator:
             global_cancel.check_and_raise()
-
-            meta_holder.meta = metadata
-            logger.info(f"metadata: {metadata.input_tokens_count}")
+            meta_holder.meta = metadata            
             if not content_chunk:
                 continue
             buffer += content_chunk
@@ -1320,6 +1368,11 @@ class AgenticEdit:
         Apply all tracked file changes to the original project directory.
         """
         for (file_path, change) in self.get_all_file_changes().items():
+            # Ensure the directory exists before writing the file
+            dir_path = os.path.dirname(file_path)
+            if dir_path: # Ensure dir_path is not empty (for files in root)
+                 os.makedirs(dir_path, exist_ok=True)
+
             with open(file_path, 'w', encoding='utf-8') as f:
                 f.write(change.content)
 

autocoder/common/v2/agent/agentic_edit_conversation.py

@@ -68,6 +68,15 @@ class AgenticConversation:
         """Adds an assistant message (potentially containing text response)."""
         self.add_message(role="assistant", content=content)
 
+    def append_to_last_message(self, content: str, role: str = "assistant"):
+        """Appends content to the last message."""
+        if self._history:
+            last_message = self._history[-1]  
+            if role and last_message["role"] == role:
+                last_message["content"] += content   
+            elif not role:
+                last_message["content"] += content
+
     def add_assistant_tool_call_message(self, tool_calls: List[Dict[str, Any]], content: Optional[str] = None):
          """
          Adds a message representing one or more tool calls from the assistant.

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

@@ -1,6 +1,7 @@
 import subprocess
 import os
 from typing import Dict, Any, Optional
+from autocoder.common.run_cmd import run_cmd_subprocess
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from autocoder.common.v2.agent.agentic_edit_types import ExecuteCommandTool, ToolResult # Import ToolResult from types
 from autocoder.common import shells
@@ -8,7 +9,8 @@ from autocoder.common.printer import Printer
 from loguru import logger
 import typing   
 from autocoder.common import AutoCoderArgs
-
+from autocoder.events.event_manager_singleton import get_event_manager
+from autocoder.run_context import get_run_context
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
 
@@ -39,45 +41,28 @@ class ExecuteCommandToolResolver(BaseToolResolver):
              pass
 
         printer.print_str_in_terminal(f"Executing command: {command} in {os.path.abspath(source_dir)}")
-        try:
-            # Determine shell based on OS
-            shell = True
-            executable = None
-            if shells.is_windows():
-                # Decide between cmd and powershell if needed, default is cmd
-                pass # shell=True uses default shell
-            else:
-                # Use bash or zsh? Default is usually fine.
-                pass # shell=True uses default shell
-
-            # Execute the command
-            process = subprocess.Popen(
-                command,
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                cwd=source_dir,
-                text=True,
-                encoding=shells.get_terminal_encoding(),
-                errors='replace' # Handle potential decoding errors
-            )
-
-            stdout, stderr = process.communicate()
-            returncode = process.returncode
+        try:            
+            # 使用封装的run_cmd方法执行命令
+            if get_run_context().is_web():
+                answer = get_event_manager(
+                    self.args.event_file).ask_user(prompt=f"Allow to execute the `{command}`?",options=["yes","no"])
+                if answer == "yes":
+                    pass
+                else:
+                    return ToolResult(success=False, message=f"Command '{command}' execution denied by user.")
+            
+            exit_code, output = run_cmd_subprocess(command, verbose=True, cwd=source_dir)
 
             logger.info(f"Command executed: {command}")
-            logger.info(f"Return Code: {returncode}")
-            if stdout:
-                logger.info(f"stdout:\n{stdout}")
-            if stderr:
-                logger.info(f"stderr:\n{stderr}")
-
+            logger.info(f"Return Code: {exit_code}")
+            if output:
+                logger.info(f"Output:\n{output}")
 
-            if returncode == 0:
-                return ToolResult(success=True, message="Command executed successfully.", content=stdout)
+            if exit_code == 0:
+                return ToolResult(success=True, message="Command executed successfully.", content=output)
             else:
-                error_message = f"Command failed with return code {returncode}.\nStderr:\n{stderr}\nStdout:\n{stdout}"
-                return ToolResult(success=False, message=error_message, content={"stdout": stdout, "stderr": stderr, "returncode": returncode})
+                error_message = f"Command failed with return code {exit_code}.\nOutput:\n{output}"
+                return ToolResult(success=False, message=error_message, content={"output": output, "returncode": exit_code})
 
         except FileNotFoundError:
             return ToolResult(success=False, message=f"Error: The command '{command.split()[0]}' was not found. Please ensure it is installed and in the system's PATH.")

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

@@ -6,7 +6,7 @@ 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
+from autocoder.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
@@ -25,9 +25,6 @@ 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))
 
-        # 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?
         is_outside_source = not absolute_list_path.startswith(absolute_source_dir)
         if is_outside_source:
@@ -59,10 +56,10 @@ class ListFilesToolResolver(BaseToolResolver):
                 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)]
+                        dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d))]
                         for name in files:
                             full_path = os.path.join(root, name)
-                            if should_ignore(full_path, ignore_spec, DEFAULT_IGNORED_DIRS, absolute_source_dir):
+                            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)
@@ -73,7 +70,7 @@ class ListFilesToolResolver(BaseToolResolver):
                 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):
+                        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):

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

@@ -9,7 +9,7 @@ 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
+from autocoder.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit  
@@ -29,9 +29,6 @@ class SearchFilesToolResolver(BaseToolResolver):
         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(absolute_source_dir):
             return ToolResult(success=False, message=f"Error: Access denied. Attempted to search outside the project directory: {search_path_str}")
@@ -65,7 +62,7 @@ class SearchFilesToolResolver(BaseToolResolver):
 
             for filepath in glob.glob(search_glob_pattern, recursive=True):
                 abs_path = os.path.abspath(filepath)
-                if should_ignore(abs_path, ignore_spec, DEFAULT_IGNORED_DIRS, absolute_source_dir):
+                if should_ignore(abs_path):
                     continue
 
                 if os.path.isfile(filepath):

autocoder/helper/rag_doc_creator.py

@@ -0,0 +1,141 @@
+
+import os
+from loguru import logger
+
+def create_sample_files(base_dir: str):
+    """创建示例代码文件用于演示"""
+    os.makedirs(base_dir, exist_ok=True)
+
+    calculator_content = """
+class Calculator:
+    def __init__(self):
+        self.history = []
+        
+    def add(self, a: int, b: int) -> int:
+        '''加法函数'''
+        result = a + b
+        self.history.append(f"{a} + {b} = {result}")
+        return result
+        
+    def subtract(self, a: int, b: int) -> int:
+        '''减法函数'''
+        result = a - b
+        self.history.append(f"{a} - {b} = {result}")
+        return result
+        
+    def multiply(self, a: int, b: int) -> int:
+        '''乘法函数'''
+        result = a * b
+        self.history.append(f"{a} * {b} = {result}")
+        return result
+        
+    def divide(self, a: int, b: int) -> float:
+        '''除法函数'''
+        if b == 0:
+            raise ValueError("Cannot divide by zero")
+        result = a / b
+        self.history.append(f"{a} / {b} = {result}")
+        return result
+"""
+
+    string_processor_content = """
+class StringProcessor:
+    @staticmethod
+    def reverse(text: str) -> str:
+        '''反转字符串'''
+        return text[::-1]
+    
+    @staticmethod
+    def capitalize(text: str) -> str:
+        '''首字母大写'''
+        return text.capitalize()
+    
+    @staticmethod
+    def count_words(text: str) -> int:
+        '''计算单词数量'''
+        return len(text.split())
+    
+    @staticmethod
+    def format_name(first_name: str, last_name: str) -> str:
+        '''格式化姓名'''
+        return f"{last_name}, {first_name}"
+"""
+
+    data_processor_content = """
+import statistics
+from typing import List, Dict, Any
+
+class DataProcessor:
+    @staticmethod
+    def calculate_average(numbers: List[float]) -> float:
+        '''计算平均值'''
+        return sum(numbers) / len(numbers)
+    
+    @staticmethod
+    def find_median(numbers: List[float]) -> float:
+        '''计算中位数'''
+        sorted_numbers = sorted(numbers)
+        n = len(sorted_numbers)
+        if n % 2 == 0:
+            return (sorted_numbers[n//2-1] + sorted_numbers[n//2]) / 2
+        else:
+            return sorted_numbers[n//2]
+    
+    @staticmethod
+    def find_mode(numbers: List[float]) -> List[float]:
+        '''查找众数'''
+        try:
+            return statistics.mode(numbers)
+        except statistics.StatisticsError:
+            # 没有唯一众数的情况
+            count_dict = {}
+            for num in numbers:
+                if num in count_dict:
+                    count_dict[num] += 1
+                else:
+                    count_dict[num] = 1
+            max_count = max(count_dict.values())
+            return [num for num, count in count_dict.items() if count == max_count]
+"""
+
+    with open(os.path.join(base_dir, "calculator.py"), "w", encoding="utf-8") as f:
+        f.write(calculator_content)
+
+    with open(os.path.join(base_dir, "string_processor.py"), "w", encoding="utf-8") as f:
+        f.write(string_processor_content)
+
+    with open(os.path.join(base_dir, "data_processor.py"), "w", encoding="utf-8") as f:
+        f.write(data_processor_content)
+
+    logger.info(f"示例代码文件已创建在: {base_dir}")
+
+
+def update_sample_file(base_dir: str, filename: str, content: str):
+    """更新指定示例文件内容"""
+    file_path = os.path.join(base_dir, filename)
+    if not os.path.exists(file_path):
+        logger.warning(f"文件 {file_path} 不存在，无法更新")
+        return
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(content)
+    logger.info(f"已更新文件: {file_path}")
+
+
+def add_sample_file(base_dir: str, filename: str, content: str):
+    """新增示例文件，若存在则覆盖"""
+    file_path = os.path.join(base_dir, filename)
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(content)
+    logger.info(f"已新增文件: {file_path}")
+
+
+def delete_sample_file(base_dir: str, filename: str):
+    """删除指定示例文件"""
+    file_path = os.path.join(base_dir, filename)
+    try:
+        os.remove(file_path)
+        logger.info(f"已删除文件: {file_path}")
+    except FileNotFoundError:
+        logger.warning(f"文件 {file_path} 不存在，无法删除")
+    except Exception as e:
+        logger.error(f"删除文件 {file_path} 失败: {e}")