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

autocoder/common/text.py

@@ -1,30 +0,0 @@
-from difflib import SequenceMatcher
-
-class TextSimilarity:
-    def __init__(self, text_a, text_b):
-        self.text_a = text_a
-        self.text_b = text_b
-        self.lines_a = self._split_into_lines(text_a)
-        self.lines_b = self._split_into_lines(text_b)
-        self.m = len(self.lines_a)
-        self.n = len(self.lines_b)
-
-    def _split_into_lines(self, text):
-        return text.splitlines()
-
-    def _levenshtein_ratio(self, s1, s2):
-        return SequenceMatcher(None, s1, s2).ratio()
-
-    def get_best_matching_window(self):
-        best_similarity = 0
-        best_window = []
-
-        for i in range(self.n - self.m + 1):  # 滑动窗口
-            window_b = self.lines_b[i:i + self.m]
-            similarity = self._levenshtein_ratio("\n".join(self.lines_a), "\n".join(window_b))
-            
-            if similarity > best_similarity:
-                best_similarity = similarity
-                best_window = window_b
-
-        return best_similarity, "\n".join(best_window)

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

@@ -1,42 +0,0 @@
-
-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 ListPackageInfoTool, ToolResult
-from loguru import logger
-import typing
-
-if typing.TYPE_CHECKING:
-    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
-
-class ListPackageInfoToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional['AgenticEdit'], tool: ListPackageInfoTool, args):
-        super().__init__(agent, tool, args)
-        self.tool: ListPackageInfoTool = tool
-
-    def resolve(self) -> ToolResult:
-        source_dir = self.args.source_dir or "."
-        abs_source_dir = os.path.abspath(source_dir)
-
-        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}")
-
-        rel_package_path = os.path.relpath(abs_input_path, abs_source_dir)
-        active_md_path = os.path.join(abs_source_dir, ".auto-coder", "active-context", rel_package_path, "active.md")
-
-        logger.info(f"Looking for package info at: {active_md_path}")
-
-        if not os.path.exists(active_md_path):
-            return ToolResult(success=True, message="No package info found for this path.", content="没有相关包信息。")
-
-        try:
-            with open(active_md_path, 'r', encoding='utf-8', errors='replace') as f:
-                content = f.read()
-            return ToolResult(success=True, message="Successfully retrieved package info.", content=content)
-        except Exception as e:
-            logger.error(f"Error reading package info file: {e}")
-            return ToolResult(success=False, message=f"Error reading package info file: {e}")

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

@@ -1,70 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch
-from autocoder.common.v2.agent.agentic_edit_tools \
-    .execute_command_tool_resolver import ExecuteCommandToolResolver
-from autocoder.common.v2.agent.agentic_edit_types import ExecuteCommandTool
-from autocoder.common import AutoCoderArgs
-
-
-class TestExecuteCommandToolResolver:
-    @pytest.fixture
-    def mock_agent(self):
-        agent = MagicMock()
-        agent.args = AutoCoderArgs()
-        agent.args.context_prune_safe_zone_tokens = 1000
-        agent.context_prune_llm = None
-        agent.current_conversations = []
-        return agent
-
-    @pytest.fixture
-    def mock_tool(self):
-        return ExecuteCommandTool(
-            command="echo 'test output'", 
-            requires_approval=False
-        )
-
-
-    def test_command_execution_with_token_count(self, mock_agent, mock_tool):
-        """测试命令执行并验证token统计功能"""
-        resolver = ExecuteCommandToolResolver(mock_agent, mock_tool, mock_agent.args)
-        
-        # 模拟命令执行返回大量输出
-        with patch("autocoder.common.run_cmd.run_cmd_subprocess") as mock_run_cmd:
-            mock_run_cmd.return_value = (0, "test output " * 500)  # 生成大量输出
-            
-            result = resolver.resolve()
-            
-            assert result.success
-            assert "test output" in result.content
-            
-            # 验证token统计功能
-            # 这里需要修改ExecuteCommandToolResolver来添加token统计功能
-            # 测试将失败，符合TDD的红色阶段
-
-    def test_output_pruning_when_exceeds_token_limit(self, mock_agent, mock_tool):
-        """测试当输出超过token限制时的裁剪功能"""
-        resolver = ExecuteCommandToolResolver(mock_agent, mock_tool, mock_agent.args)
-        
-        # 模拟命令执行返回大量输出
-        with patch("autocoder.common.run_cmd.run_cmd_subprocess") as mock_run_cmd:
-            mock_run_cmd.return_value = (0, "test output " * 500)  # 生成大量输出
-            
-            result = resolver.resolve()
-            
-            assert result.success
-            # 验证输出是否被裁剪
-            # 这里需要修改ExecuteCommandToolResolver来添加裁剪功能
-            # 测试将失败，符合TDD的红色阶段
-
-    def test_command_execution_failure(self, mock_agent, mock_tool):
-        """测试命令执行失败的情况"""
-        resolver = ExecuteCommandToolResolver(mock_agent, mock_tool, mock_agent.args)
-        
-        # 模拟命令执行失败
-        with patch("autocoder.common.run_cmd.run_cmd_subprocess") as mock_run_cmd:
-            mock_run_cmd.return_value = (1, "command failed")
-            
-            result = resolver.resolve()
-            
-            assert not result.success
-            assert "command failed" in result.message

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

@@ -1,163 +0,0 @@
-import pytest
-import os
-import tempfile
-import shutil
-from unittest.mock import patch, MagicMock
-
-from autocoder.common.v2.agent.agentic_edit_tools.search_files_tool_resolver import SearchFilesToolResolver
-from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult
-from autocoder.common import AutoCoderArgs
-
-# Helper function to create a directory structure with files for testing
-def create_test_files(base_dir, structure):
-    """
-    Creates a directory structure with files based on the provided dictionary.
-    Keys are filenames (relative to base_dir), values are file contents.
-    Directories are created automatically.
-    """
-    for path, content in structure.items():
-        full_path = os.path.join(base_dir, path)
-        os.makedirs(os.path.dirname(full_path), exist_ok=True)
-        with open(full_path, 'w') as f:
-            f.write(content)
-
-@pytest.fixture
-def search_tool_resolver(temp_search_dir):
-    """Fixture to provide an instance of SearchFilesToolResolver."""
-    # Create AutoCoderArgs with the temp directory as source_dir to allow the security check to pass
-    args = AutoCoderArgs()
-    args.source_dir = temp_search_dir  # Set the source_dir to our temp directory
-    return SearchFilesToolResolver(None, SearchFilesTool(path="", regex=""), args)
-
-@pytest.fixture(scope="function")
-def temp_search_dir():
-    """Fixture to create a temporary directory with test files for searching."""
-    temp_dir = tempfile.mkdtemp()
-    test_structure = {
-        "file1.txt": "Hello world\nThis is a test file.",
-        "subdir/file2.py": "import sys\n\ndef main():\n    print('Python script')\n",
-        "subdir/another.txt": "Another text file with world.",
-        ".hiddenfile": "This should be ignored by default",
-        "no_match.md": "Markdown file."
-    }
-    create_test_files(temp_dir, test_structure)
-    yield temp_dir # Provide the path to the test function
-    shutil.rmtree(temp_dir) # Cleanup after test
-
-# --- Test Cases ---
-
-def test_resolve_finds_matches(search_tool_resolver, temp_search_dir):
-    """Test that resolve finds matches correctly."""
-    # Set up the tool with the pattern we want to search for
-    tool = SearchFilesTool(
-        path="",  # Use empty path to search in the source_dir itself
-        regex="world",
-        file_pattern="*.txt"
-    )
-    search_tool_resolver.tool = tool
-
-    # Call the resolve method directly
-    response = search_tool_resolver.resolve()
-
-    # Check the response
-    assert isinstance(response, ToolResult)
-    assert response.success
-    assert "Search completed. Found 2 matches" in response.message
-    
-    # Check that the correct files were found
-    assert len(response.content) == 2
-    paths = [result["path"] for result in response.content]
-    assert any("file1.txt" in path for path in paths)
-    assert any("another.txt" in path for path in paths)
-    
-    # Check that the match lines contain our search pattern
-    for result in response.content:
-        assert "world" in result["match_line"]
-
-def test_resolve_no_matches(search_tool_resolver, temp_search_dir):
-    """Test that resolve handles no matches correctly."""
-    tool = SearchFilesTool(
-        path="",  # Use empty path to search in the source_dir itself
-        regex="nonexistent_pattern",
-        file_pattern="*"
-    )
-    search_tool_resolver.tool = tool
-
-    response = search_tool_resolver.resolve()
-
-    assert isinstance(response, ToolResult)
-    assert response.success  # Still success, just no results
-    assert "Search completed. Found 0 matches" in response.message
-    assert len(response.content) == 0
-
-def test_resolve_file_pattern(search_tool_resolver, temp_search_dir):
-    """Test that the file_pattern is correctly applied."""
-    # Test .txt pattern
-    tool_txt = SearchFilesTool(
-        path="",  # Use empty path to search in the source_dir itself
-        regex="world",
-        file_pattern="*.txt"  # Only search .txt files
-    )
-    search_tool_resolver.tool = tool_txt
-    
-    response_txt = search_tool_resolver.resolve()
-    
-    assert isinstance(response_txt, ToolResult)
-    assert response_txt.success
-    assert "Search completed. Found 2 matches" in response_txt.message
-    # Ensure only .txt files were matched
-    for result in response_txt.content:
-        assert result["path"].endswith(".txt")
-    
-    # Test .py pattern
-    tool_py = SearchFilesTool(
-        path="",  # Use empty path to search in the source_dir itself
-        regex="print",
-        file_pattern="*.py"  # Only search .py files
-    )
-    search_tool_resolver.tool = tool_py
-    
-    response_py = search_tool_resolver.resolve()
-    
-    assert isinstance(response_py, ToolResult)
-    assert response_py.success
-    assert "Search completed. Found 1 matches" in response_py.message
-    # Ensure only .py files were matched
-    for result in response_py.content:
-        assert result["path"].endswith(".py")
-
-def test_invalid_regex(search_tool_resolver, temp_search_dir):
-    """Test that an invalid regex pattern is properly handled."""
-    tool = SearchFilesTool(
-        path="",  # Use empty path to search in the source_dir itself
-        regex="[invalid regex",  # Invalid regex pattern
-        file_pattern="*"
-    )
-    search_tool_resolver.tool = tool
-
-    response = search_tool_resolver.resolve()
-
-    assert isinstance(response, ToolResult)
-    assert not response.success
-    assert "Invalid regex pattern" in response.message
-
-def test_nonexistent_path(search_tool_resolver, temp_search_dir):
-    """Test that a nonexistent path is properly handled."""
-    # Create a path that we know doesn't exist under temp_search_dir
-    nonexistent_path = "nonexistent_subdirectory"
-    
-    tool = SearchFilesTool(
-        path=nonexistent_path,  # This path doesn't exist in our temp directory
-        regex="pattern",
-        file_pattern="*"
-    )
-    search_tool_resolver.tool = tool
-
-    response = search_tool_resolver.resolve()
-
-    assert isinstance(response, ToolResult)
-    assert not response.success
-    assert "Error: Search path not found" in response.message
-
-# Add more tests as needed
-

autocoder/common/v2/agent/agentic_tool_display.py

@@ -1,183 +0,0 @@
-import json
-from typing import Dict, Callable, Type
-from autocoder.common.auto_coder_lang import get_system_language, format_str_jinja2
-from autocoder.common.v2.agent.agentic_edit_types import (
-    BaseTool,
-    ReadFileTool, WriteToFileTool, ReplaceInFileTool, ExecuteCommandTool,
-    ListFilesTool, SearchFilesTool, ListCodeDefinitionNamesTool,
-    AskFollowupQuestionTool, UseMcpTool, AttemptCompletionTool
-)
-
-# Define message templates for each tool in English and Chinese
-TOOL_DISPLAY_MESSAGES: Dict[Type[BaseTool], Dict[str, str]] = {
-    ReadFileTool: {
-        "en": "AutoCoder wants to read this file:\n[bold cyan]{{ path }}[/]",
-        "zh": "AutoCoder 想要读取此文件：\n[bold cyan]{{ path }}[/]"
-    },
-    WriteToFileTool: {
-        "en": (
-            "AutoCoder wants to write to this file:\n[bold cyan]{{ path }}[/]\n\n"
-            "[dim]Content Snippet:[/dim]\n{{ content_snippet }}{{ ellipsis }}"
-        ),
-        "zh": (
-            "AutoCoder 想要写入此文件：\n[bold cyan]{{ path }}[/]\n\n"
-            "[dim]内容片段：[/dim]\n{{ content_snippet }}{{ ellipsis }}"
-        )
-    },
-    ReplaceInFileTool: {
-        "en": (
-            "AutoCoder wants to replace content in this file:\n[bold cyan]{{ path }}[/]\n\n"
-            "[dim]Diff Snippet:[/dim]\n{{ diff_snippet }}{{ ellipsis }}"
-        ),
-        "zh": (
-            "AutoCoder 想要替换此文件中的内容：\n[bold cyan]{{ path }}[/]\n\n"
-            "[dim]差异片段：[/dim]\n{{ diff_snippet }}{{ ellipsis }}"
-        )
-    },
-    ExecuteCommandTool: {
-        "en": (
-            "AutoCoder wants to execute this command:\n[bold yellow]{{ command }}[/]\n"
-            "[dim](Requires Approval: {{ requires_approval }})[/]"
-        ),
-        "zh": (
-            "AutoCoder 想要执行此命令：\n[bold yellow]{{ command }}[/]\n"
-            "[dim](需要批准：{{ requires_approval }})[/]"
-        )
-    },
-    ListFilesTool: {
-        "en": (
-            "AutoCoder wants to list files in:\n[bold green]{{ path }}[/] "
-            "{{ recursive_text }}"
-        ),
-        "zh": (
-            "AutoCoder 想要列出此目录中的文件：\n[bold green]{{ path }}[/] "
-            "{{ recursive_text }}"
-        )
-    },
-    SearchFilesTool: {
-        "en": (
-            "AutoCoder wants to search files in:\n[bold green]{{ path }}[/]\n"
-            "[dim]File Pattern:[/dim] [yellow]{{ file_pattern }}[/]\n"
-            "[dim]Regex:[/dim] [yellow]{{ regex }}[/]"
-        ),
-        "zh": (
-            "AutoCoder 想要在此目录中搜索文件：\n[bold green]{{ path }}[/]\n"
-            "[dim]文件模式：[/dim] [yellow]{{ file_pattern }}[/]\n"
-            "[dim]正则表达式：[/dim] [yellow]{{ regex }}[/]"
-        )
-    },
-    ListCodeDefinitionNamesTool: {
-        "en": "AutoCoder wants to list definitions in:\n[bold green]{{ path }}[/]",
-        "zh": "AutoCoder 想要列出此路径中的定义：\n[bold green]{{ path }}[/]"
-    },
-    AskFollowupQuestionTool: {
-        "en": (
-            "AutoCoder is asking a question:\n[bold magenta]{{ question }}[/]\n"
-            "{{ options_text }}"
-        ),
-        "zh": (
-            "AutoCoder 正在提问：\n[bold magenta]{{ question }}[/]\n"
-            "{{ options_text }}"
-        )
-    },
-    UseMcpTool: {
-        "en": (
-            "AutoCoder wants to use an MCP tool:\n"
-            "[dim]Server:[/dim] [blue]{{ server_name }}[/]\n"
-            "[dim]Tool:[/dim] [blue]{{ tool_name }}[/]\n"
-            "[dim]Args:[/dim] {{ arguments_snippet }}{{ ellipsis }}"
-        ),
-        "zh": (
-            "AutoCoder 想要使用 MCP 工具：\n"
-            "[dim]服务器：[/dim] [blue]{{ server_name }}[/]\n"
-            "[dim]工具：[/dim] [blue]{{ tool_name }}[/]\n"
-            "[dim]参数：[/dim] {{ arguments_snippet }}{{ ellipsis }}"
-        )
-    }
-}
-
-def get_tool_display_message(tool: BaseTool) -> str:
-    """
-    Generates a user-friendly, internationalized string representation for a tool call.
-
-    Args:
-        tool: The tool instance (Pydantic model).
-
-    Returns:
-        A formatted string for display in the terminal.
-    """
-    lang = get_system_language()
-    tool_type = type(tool)
-
-    if tool_type not in TOOL_DISPLAY_MESSAGES:
-        # Fallback for unknown tools
-        return f"Unknown tool type: {tool_type.__name__}\nData: {tool.model_dump_json(indent=2)}"
-
-    templates = TOOL_DISPLAY_MESSAGES[tool_type]
-    template = templates.get(lang, templates.get("en", "Tool display template not found")) # Fallback to English
-
-    # Prepare context specific to each tool type
-    context = {}
-    if isinstance(tool, ReadFileTool):
-        context = {"path": tool.path}
-    elif isinstance(tool, WriteToFileTool):
-        snippet = tool.content[:150]
-        context = {
-            "path": tool.path,
-            "content_snippet": snippet,
-            "ellipsis": '...' if len(tool.content) > 150 else ''
-        }
-    elif isinstance(tool, ReplaceInFileTool):
-        snippet = tool.diff
-        context = {
-            "path": tool.path,
-            "diff_snippet": snippet,
-            "ellipsis": ''
-        }
-    elif isinstance(tool, ExecuteCommandTool):
-        context = {"command": tool.command, "requires_approval": tool.requires_approval}
-    elif isinstance(tool, ListFilesTool):
-        rec_text_en = '(Recursively)' if tool.recursive else '(Top Level)'
-        rec_text_zh = '（递归）' if tool.recursive else '（顶层）'
-        context = {
-            "path": tool.path,
-            "recursive_text": rec_text_zh if lang == 'zh' else rec_text_en
-        }
-    elif isinstance(tool, SearchFilesTool):
-        context = {
-            "path": tool.path,
-            "file_pattern": tool.file_pattern or '*',
-            "regex": tool.regex
-        }
-    elif isinstance(tool, ListCodeDefinitionNamesTool):
-        context = {"path": tool.path}
-    elif isinstance(tool, AskFollowupQuestionTool):
-        options_text_en = ""
-        options_text_zh = ""
-        if tool.options:
-            options_list_en = "\n".join([f"- {opt}" for opt in tool.options])
-            options_list_zh = "\n".join([f"- {opt}" for opt in tool.options]) # Assuming options are simple enough not to need translation
-            options_text_en = f"[dim]Options:[/dim]\n{options_list_en}"
-            options_text_zh = f"[dim]选项：[/dim]\n{options_list_zh}"
-        context = {
-            "question": tool.question,
-            "options_text": options_text_zh if lang == 'zh' else options_text_en
-        }
-    elif isinstance(tool, UseMcpTool):
-        args_str = tool.query
-        snippet = args_str[:100]
-        context = {
-            "server_name": tool.server_name,
-            "tool_name": tool.tool_name,
-            "arguments_snippet": snippet,
-            "ellipsis": '...' if len(args_str) > 100 else ''
-        }    
-    else:
-        # Generic context for tools not specifically handled above
-        context = tool.model_dump()
-
-    try:
-        return format_str_jinja2(template, **context)
-    except Exception as e:
-        # Fallback in case of formatting errors
-        return f"Error formatting display for {tool_type.__name__}: {e}\nTemplate: {template}\nContext: {context}"

autocoder/plugins/dynamic_completion_example.py

@@ -1,148 +0,0 @@
-"""
-Dynamic Completion Example Plugin for Chat Auto Coder.
-"""
-
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
-from autocoder.plugins import Plugin, PluginManager
-
-
-class DynamicCompletionExamplePlugin(Plugin):
-    """A sample plugin demonstrating dynamic completion functionality."""
-
-    name = "dynamic_completion_example"
-    description = "Demonstrates the dynamic completion feature"
-    version = "0.1.0"
-
-    def __init__(self, manager: PluginManager, config: Optional[Dict[str, Any]] = None, config_path: Optional[str] = None):
-        """Initialize the plugin.
-
-        Args:
-            manager: The plugin manager instance
-            config: Optional configuration dictionary for the plugin
-            config_path: Optional path to the configuration file
-        """
-        super().__init__(manager, config, config_path)
-        self.items = ["item1", "item2", "item3", "custom_item"]
-
-    def initialize(self) -> bool:
-        """Initialize the plugin.
-
-        Returns:
-            True if initialization was successful, False otherwise
-        """
-        # Register for function interception if needed
-        # self.manager.register_function_interception(self.name, "ask")
-
-        # Register as a dynamic completion provider
-        self.manager.register_dynamic_completion_provider(self.name, ["/example"])
-
-        return True
-
-    def get_commands(self) -> Dict[str, Tuple[Callable, str]]:
-        """Get commands provided by this plugin.
-
-        Returns:
-            A dictionary of command name to handler and description
-        """
-        return {
-            "example": (
-                self.example_command,
-                "Example command with dynamic completion",
-            ),
-            "example/add": (self.add_item, "Add a new item to the example list"),
-            "example/list": (self.list_items, "List all available items"),
-        }
-
-    def get_completions(self) -> Dict[str, List[str]]:
-        """Get completions provided by this plugin.
-
-        Returns:
-            A dictionary mapping command prefixes to completion options
-        """
-        # 基本的静态补全选项
-        return {
-            "/example": ["add", "list", "select"],
-        }
-
-    def get_dynamic_completions(
-        self, command: str, current_input: str
-    ) -> List[Tuple[str, str]]:
-        """Get dynamic completions based on the current command context.
-
-        Args:
-            command: The base command (e.g., "/example select")
-            current_input: The full current input including the command
-
-        Returns:
-            A list of tuples containing (completion_text, display_text)
-        """
-        # 如果是 /example select 命令，提供动态项目列表
-        if current_input.startswith("/example select"):
-            # 提取已输入的部分项目名
-            parts = current_input.split(maxsplit=2)
-            item_prefix = ""
-            if len(parts) > 2:
-                item_prefix = parts[2]
-
-            # 返回匹配的项目
-            return [
-                (item, f"{item} (example item)")
-                for item in self.items
-                if item.startswith(item_prefix)
-            ]
-
-        return []
-
-    def example_command(self, args: str) -> None:
-        """Handle the example command.
-
-        Args:
-            args: Command arguments
-        """
-        if not args:
-            print("Usage: /example [add|list|select]")
-            return
-
-        parts = args.split(maxsplit=1)
-        subcommand = parts[0]
-
-        if subcommand == "select" and len(parts) > 1:
-            item = parts[1]
-            if item in self.items:
-                print(f"Selected item: {item}")
-            else:
-                print(
-                    f"Item '{item}' not found. Use /example list to see available items."
-                )
-        else:
-            print(f"Unknown subcommand: {subcommand}. Use add, list, or select.")
-
-    def add_item(self, args: str) -> None:
-        """Add a new item to the list.
-
-        Args:
-            args: The item name to add
-        """
-        if not args:
-            print("Please specify an item name to add.")
-            return
-
-        if args in self.items:
-            print(f"Item '{args}' already exists.")
-        else:
-            self.items.append(args)
-            print(f"Added item: {args}")
-
-    def list_items(self, args: str) -> None:
-        """List all available items.
-
-        Args:
-            args: Ignored
-        """
-        print("Available items:")
-        for item in self.items:
-            print(f"  - {item}")
-
-    def shutdown(self) -> None:
-        """Shutdown the plugin."""
-        pass