auto-coder 0.1.374__py3-none-any.whl → 0.1.376__py3-none-any.whl

autocoder/agent/agentic_edit_tools/write_to_file_tool_resolver.py

@@ -1,98 +0,0 @@
-import os
-import re
-from typing import Dict, Any, Optional, List, Tuple
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import WriteToFileTool, ToolResult  # Import ToolResult from types
-from loguru import logger
-
-
-class WriteToFileToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: WriteToFileTool, args: Dict[str, Any]):
-        super().__init__(agent, tool, args)
-        self.tool: WriteToFileTool = tool  # For type hinting
-
-    def parse_diff(self, diff_content: str) -> List[Tuple[str, str]]:
-        """
-        Parses the diff content into a list of (search_block, replace_block) tuples.
-        """
-        blocks = []
-        # Regex to find SEARCH/REPLACE blocks, handling potential variations in line endings
-        pattern = re.compile(r"<<<<<<< SEARCH\r?\n(.*?)\r?\n=======\r?\n(.*?)\r?\n>>>>>>> REPLACE", re.DOTALL)
-        matches = pattern.findall(diff_content)
-        for search_block, replace_block in matches:
-            blocks.append((search_block, replace_block))
-        if not matches and diff_content.strip():
-            logger.warning(f"Could not parse any SEARCH/REPLACE blocks from diff: {diff_content}")
-        return blocks
-
-    def resolve(self) -> ToolResult:
-        file_path = self.tool.path
-        content = self.tool.content
-        source_dir = self.args.source_dir or "."
-        absolute_path = os.path.abspath(os.path.join(source_dir, file_path))
-
-        # Security check: ensure the path is within the source directory
-        if not absolute_path.startswith(os.path.abspath(source_dir)):
-            return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
-
-        try:
-            # Create directories if they don't exist
-            os.makedirs(os.path.dirname(absolute_path), exist_ok=True)
-
-            # Check if the content contains SEARCH/REPLACE blocks
-            parsed_blocks = self.parse_diff(content)
-            if parsed_blocks:
-                # If file exists, read its current content
-                if os.path.exists(absolute_path):
-                    try:
-                        with open(absolute_path, 'r', encoding='utf-8', errors='replace') as f:
-                            original_content = f.read()
-                    except Exception as e:
-                        logger.error(f"Error reading existing file '{file_path}' for diff apply: {str(e)}")
-                        return ToolResult(success=False, message=f"An error occurred while reading the existing file: {str(e)}")
-                else:
-                    # If file does not exist, start with empty content
-                    original_content = ""
-
-                current_content = original_content
-                applied_count = 0
-                errors = []
-
-                for i, (search_block, replace_block) in enumerate(parsed_blocks):
-                    start_index = current_content.find(search_block)
-                    if start_index != -1:
-                        current_content = (
-                            current_content[:start_index]
-                            + replace_block
-                            + current_content[start_index + len(search_block):]
-                        )
-                        applied_count += 1
-                        logger.info(f"Applied SEARCH/REPLACE block {i+1} in file {file_path}")
-                    else:
-                        error_message = f"SEARCH block {i+1} not found in current content. Search block:\n---\n{search_block}\n---"
-                        logger.warning(error_message)
-                        errors.append(error_message)
-                        # Continue with next block
-
-                try:
-                    with open(absolute_path, 'w', encoding='utf-8') as f:
-                        f.write(current_content)
-                    message = f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to file: {file_path}."
-                    if errors:
-                        message += "\nWarnings:\n" + "\n".join(errors)
-                    logger.info(message)
-                    return ToolResult(success=True, message=message, content=current_content)
-                except Exception as e:
-                    logger.error(f"Error writing replaced content to file '{file_path}': {str(e)}")
-                    return ToolResult(success=False, message=f"An error occurred while writing the modified file: {str(e)}")
-            else:
-                # No diff blocks detected, treat as full content overwrite
-                with open(absolute_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-
-                logger.info(f"Successfully wrote to file: {file_path}")
-                return ToolResult(success=True, message=f"Successfully wrote to file: {file_path}", content=content)
-
-        except Exception as e:
-            logger.error(f"Error writing to file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")

autocoder/agent/agentic_edit_types.py

@@ -1,124 +0,0 @@
-from pydantic import BaseModel
-from typing import List, Dict, Any, Callable, Optional, Type
-from pydantic import SkipValidation
-
-
-# Result class used by Tool Resolvers
-class ToolResult(BaseModel):
-    success: bool
-    message: str
-    content: Any = None # Can store file content, command output, etc.
-
-# Pydantic Models for Tools
-class BaseTool(BaseModel):
-    pass
-
-class ExecuteCommandTool(BaseTool):
-    command: str
-    requires_approval: bool
-
-class ReadFileTool(BaseTool):
-    path: str
-
-class WriteToFileTool(BaseTool):
-    path: str
-    content: str
-
-class ReplaceInFileTool(BaseTool):
-    path: str
-    diff: str
-
-class SearchFilesTool(BaseTool):
-    path: str
-    regex: str
-    file_pattern: Optional[str] = None
-
-class ListFilesTool(BaseTool):
-    path: str
-    recursive: Optional[bool] = False
-
-class ListCodeDefinitionNamesTool(BaseTool):
-    path: str
-
-class AskFollowupQuestionTool(BaseTool):
-    question: str
-    options: Optional[List[str]] = None
-
-class AttemptCompletionTool(BaseTool):
-    result: str
-    command: Optional[str] = None
-
-class PlanModeRespondTool(BaseTool):
-    response: str
-    options: Optional[List[str]] = None
-
-class UseMcpTool(BaseTool):
-    server_name: str
-    tool_name: str
-    arguments: Dict[str, Any]
-
-class PlainTextOutput(BaseModel):
-    text: str
-
-
-# Mapping from tool tag names to Pydantic models
-TOOL_MODEL_MAP: Dict[str, Type[BaseTool]] = {
-    "execute_command": ExecuteCommandTool,
-    "read_file": ReadFileTool,
-    "write_to_file": WriteToFileTool,
-    "replace_in_file": ReplaceInFileTool,
-    "search_files": SearchFilesTool,
-    "list_files": ListFilesTool,
-    "list_code_definition_names": ListCodeDefinitionNamesTool,
-    "ask_followup_question": AskFollowupQuestionTool,
-    "attempt_completion": AttemptCompletionTool,
-    "plan_mode_respond": PlanModeRespondTool,
-    "use_mcp_tool": UseMcpTool,
-}
-
-
-class AgenticEditRequest(BaseModel):
-    user_input: str
-
-
-class FileOperation(BaseModel):
-    path: str
-    operation: str  # e.g., "MODIFY", "REFERENCE", "ADD", "REMOVE"
-class MemoryConfig(BaseModel):
-    """
-    A model to encapsulate memory configuration and operations.
-    """
-
-    memory: Dict[str, Any]
-    save_memory_func: SkipValidation[Callable]
-
-    class Config:
-        arbitrary_types_allowed = True
-
-
-class CommandConfig(BaseModel):
-    coding: SkipValidation[Callable]
-    chat: SkipValidation[Callable]
-    add_files: SkipValidation[Callable]
-    remove_files: SkipValidation[Callable]
-    index_build: SkipValidation[Callable]
-    index_query: SkipValidation[Callable]
-    list_files: SkipValidation[Callable]
-    ask: SkipValidation[Callable]
-    revert: SkipValidation[Callable]
-    commit: SkipValidation[Callable]
-    help: SkipValidation[Callable]
-    exclude_dirs: SkipValidation[Callable]
-    summon: SkipValidation[Callable]
-    design: SkipValidation[Callable]
-    mcp: SkipValidation[Callable]
-    models: SkipValidation[Callable]
-    lib: SkipValidation[Callable]
-    execute_shell_command: SkipValidation[Callable]
-    generate_shell_command: SkipValidation[Callable]
-    conf_export: SkipValidation[Callable]
-    conf_import: SkipValidation[Callable]
-    index_export: SkipValidation[Callable]
-    index_import: SkipValidation[Callable]
-    exclude_files: SkipValidation[Callable]
-

autocoder/auto_coder_lang.py

@@ -1,60 +0,0 @@
-import locale
-
-MESSAGES = {
-    "en": {
-        "human_as_model_instructions": (
-            "You are now in Human as Model mode. The content has been copied to your clipboard.\n"
-            "The system is waiting for your input. When finished, enter 'EOF' on a new line to submit.\n"
-            "Use '/break' to exit this mode. If you have issues with copy-paste, use '/clear' to clean and paste again."
-        ),
-        "clipboard_not_supported": (
-            "pyperclip not installed or clipboard is not supported, instruction will not be copied to clipboard."
-        ),
-        "human_as_model_instructions_no_clipboard": (
-            "You are now in Human as Model mode. [bold red]The content could not be copied to your clipboard.[/bold red]\n"
-            "but you can copy prompt from output.txt file.\n"
-            "The system is waiting for your input. When finished, enter 'EOF' on a new line to submit.\n"
-            "Use '/break' to exit this mode. If you have issues with copy-paste, use '/clear' to clean and paste again."
-        ),
-        "chat_human_as_model_instructions": (
-            "Chat is now in Human as Model mode.\n"
-            "The question has been copied to your clipboard.\n"
-            "Please use Web version model to get the answer.\n"
-            "Or use /conf human_as_model:false to close this mode and get the answer in terminal directly."
-            "Paste the answer to the input box below, use '/break' to exit, '/clear' to clear the screen, '/eof' to submit."
-        )
-    },
-    "zh": {
-        "human_as_model_instructions": (
-            "您现在处于人类作为模型模式。内容已复制到您的剪贴板。\n"
-            "系统正在等待您的输入。完成后，在新行输入'EOF'提交。\n"
-            "使用'/break'退出此模式。如果复制粘贴有问题，使用'/clear'清理并重新粘贴。"
-        ),
-        "clipboard_not_supported": (
-            "未安装pyperclip或不支持剪贴板，指令将不会被复制到剪贴板。"
-        ),
-        "human_as_model_instructions_no_clipboard": (
-            "您现在处于人类作为模型模式。[bold red]内容无法复制到您的剪贴板。[/bold red]\n"
-            "但您可以从output.txt文件复制提示。\n"
-            "系统正在等待您的输入。完成后，在新行输入'EOF'提交。\n"
-            "使用'/break'退出此模式。如果复制粘贴有问题，使用'/clear'清理并重新粘贴。"
-        ),
-        "chat_human_as_model_instructions": (
-            "\n============= Chat 处于 Human as Model 模式 =============\n"
-            "问题已复制到剪贴板\n"
-            "请使用Web版本模型获取答案\n"
-            "或者使用 /conf human_as_model:false 关闭该模式直接在终端获得答案。" 
-            "将获得答案黏贴到下面的输入框，换行后，使用 '/break' 退出，'/clear' 清屏，'/eof' 提交。"           
-        ),
-    }
-}
-
-def get_system_language():
-    try:
-        return locale.getdefaultlocale()[0][:2]
-    except:
-        return 'en'
-
-def get_message(key):
-    lang = get_system_language()
-    return MESSAGES.get(lang, MESSAGES['en']).get(key, MESSAGES['en'][key])

autocoder/auto_coder_rag_client_mcp.py

@@ -1,170 +0,0 @@
-from typing import Any, List, Dict, Generator, Optional
-import asyncio
-import httpx
-import argparse
-from mcp.server.models import InitializationOptions
-import mcp.types as types
-from mcp.server import NotificationOptions, Server
-import mcp.server.stdio
-from autocoder.common import AutoCoderArgs
-from byzerllm import ByzerLLM
-from autocoder.lang import lang_desc
-import locale
-import pkg_resources
-from openai import OpenAI
-
-class AutoCoderRAGClientMCP:
-    def __init__(self, llm: ByzerLLM, args: AutoCoderArgs):
-        self.llm = llm
-        self.args = args
-        
-        if not args.rag_url:
-            raise ValueError("rag_url is required for RAG client mode")
-            
-        if not args.rag_url.startswith("http://"):
-            args.rag_url = f"http://{args.rag_url}"
-            
-        if not args.rag_url.endswith("/v1"):
-            args.rag_url = args.rag_url.rstrip("/") + "/v1"
-            
-        if not args.rag_token:
-            raise ValueError("rag_token is required for RAG client mode")
-            
-        self.client = OpenAI(api_key=args.rag_token, base_url=args.rag_url)
-        
-        self.server = Server("auto_coder_rag_client")
-
-    async def setup_server(self):
-        @self.server.list_tools()
-        async def handle_list_tools() -> List[types.Tool]:
-            return [
-                types.Tool(
-                    name="rag-search",
-                    description="Search documents using RAG",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "query": {
-                                "type": "string",
-                                "description": "Search query",
-                            },
-                        },
-                        "required": ["query"],
-                    },
-                ),
-                types.Tool(
-                    name="rag-chat",
-                    description="Chat with documents using RAG",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "query": {
-                                "type": "string",
-                                "description": "Chat query",
-                            },
-                        },
-                        "required": ["query"],
-                    },
-                ),
-            ]
-
-        @self.server.call_tool()
-        async def handle_call_tool(
-            name: str, arguments: Dict[str, Any] | None
-        ) -> List[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-            if not arguments:
-                raise ValueError("Missing arguments")
-
-            if name == "rag-search":
-                query = arguments.get("query")
-                if not query:
-                    raise ValueError("Missing query parameter")
-
-                response = self.client.chat.completions.create(
-                    messages=[{"role": "user", "content": json.dumps({
-                        "query": query,
-                        "only_contexts": True
-                    })}],
-                    model=self.args.model,
-                    max_tokens=self.args.rag_params_max_tokens,
-                )
-                result = response.choices[0].message.content
-                
-                return [
-                    types.TextContent(
-                        type="text",
-                        text=f"Search results for '{query}':\n\n{result}"
-                    )
-                ]
-
-            elif name == "rag-chat":
-                query = arguments.get("query")
-                if not query:
-                    raise ValueError("Missing query parameter")
-
-                response = self.client.chat.completions.create(
-                    messages=[{"role": "user", "content": query}],
-                    model=self.args.model,
-                    stream=True,
-                    max_tokens=self.args.rag_params_max_tokens
-                )
-                
-                full_response = ""
-                for chunk in response:
-                    if chunk.choices[0].delta.content is not None:
-                        full_response += chunk.choices[0].delta.content
-                
-                return [
-                    types.TextContent(
-                        type="text",
-                        text=f"Chat response for '{query}':\n\n{full_response}"
-                    )
-                ]
-
-            else:
-                raise ValueError(f"Unknown tool: {name}")
-
-    async def run(self):
-        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-            await self.server.run(
-                read_stream,
-                write_stream,
-                InitializationOptions(
-                    server_name="auto_coder_rag_client",
-                    server_version="0.1.0",
-                    capabilities=self.server.get_capabilities(
-                        notification_options=NotificationOptions(),
-                        experimental_capabilities={},
-                    ),
-                ),
-            )
-
-def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:    
-    system_lang, _ = locale.getdefaultlocale()
-    lang = "zh" if system_lang and system_lang.startswith("zh") else "en"
-    desc = lang_desc[lang]
-    
-    parser = argparse.ArgumentParser(description="Auto Coder RAG Client MCP Server")
-    parser.add_argument("--rag_url", required=True, help="RAG server URL")
-    parser.add_argument("--rag_token", required=True, help="RAG server token")
-    parser.add_argument("--model", default="v3_chat", help=desc["model"])
-    parser.add_argument("--rag_params_max_tokens", type=int, default=4096, help="Max tokens for RAG response")
-    
-    args = parser.parse_args(input_args)
-    return AutoCoderArgs(**vars(args))
-
-async def main():
-    # Parse command line arguments
-    args = parse_args()
-    
-    # Initialize LLM
-    llm = ByzerLLM()
-    llm.setup_default_model_name(args.model)
-    
-    # Initialize and run server
-    server = AutoCoderRAGClientMCP(llm=llm, args=args)
-    await server.setup_server()
-    await server.run()
-
-if __name__ == "__main__":
-    asyncio.run(main())

autocoder/auto_coder_rag_mcp.py

@@ -1,193 +0,0 @@
-from typing import Any, List, Dict, Generator, Optional
-import asyncio
-import httpx
-import argparse
-from mcp.server.models import InitializationOptions
-import mcp.types as types
-from mcp.server import NotificationOptions, Server
-import mcp.server.stdio
-from autocoder.rag.long_context_rag import LongContextRAG
-from autocoder.common import AutoCoderArgs
-from byzerllm import ByzerLLM
-from autocoder.lang import lang_desc
-import locale
-import pkg_resources
-
-class AutoCoderRAGMCP:
-    def __init__(self, llm: ByzerLLM, args: AutoCoderArgs):
-        self.llm = llm
-        self.args = args
-        self.rag = LongContextRAG(
-            llm=llm,
-            args=args,
-            path=args.source_dir,
-            tokenizer_path=args.tokenizer_path
-        )
-        self.server = Server("auto_coder_rag")
-
-    async def setup_server(self):
-        @self.server.list_tools()
-        async def handle_list_tools() -> List[types.Tool]:
-            return [
-                types.Tool(
-                    name="rag-search",
-                    description="Search documents using RAG",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "query": {
-                                "type": "string",
-                                "description": "Search query",
-                            },
-                        },
-                        "required": ["query"],
-                    },
-                ),
-                types.Tool(
-                    name="rag-chat",
-                    description="Chat with documents using RAG",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "query": {
-                                "type": "string",
-                                "description": "Chat query",
-                            },
-                        },
-                        "required": ["query"],
-                    },
-                ),
-            ]
-
-        @self.server.call_tool()
-        async def handle_call_tool(
-            name: str, arguments: Dict[str, Any] | None
-        ) -> List[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-            if not arguments:
-                raise ValueError("Missing arguments")
-
-            if name == "rag-search":
-                query = arguments.get("query")
-                if not query:
-                    raise ValueError("Missing query parameter")
-
-                results = self.rag.search(query)
-                return [
-                    types.TextContent(
-                        type="text",
-                        text=f"Search results for '{query}':\n\n" + 
-                        "\n".join([f"- {result.module_name}: {result.source_code[:200]}..." 
-                                 for result in results])
-                    )
-                ]
-
-            elif name == "rag-chat":
-                query = arguments.get("query")
-                if not query:
-                    raise ValueError("Missing query parameter")
-
-                response, _ = self.rag.stream_chat_oai(
-                    conversations=[{"role": "user", "content": query}]
-                )
-                full_response = "".join([chunk for chunk in response])
-                
-                return [
-                    types.TextContent(
-                        type="text",
-                        text=f"Chat response for '{query}':\n\n{full_response}"
-                    )
-                ]
-
-            else:
-                raise ValueError(f"Unknown tool: {name}")
-
-    async def run(self):
-        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-            await self.server.run(
-                read_stream,
-                write_stream,
-                InitializationOptions(
-                    server_name="auto_coder_rag",
-                    server_version="0.1.0",
-                    capabilities=self.server.get_capabilities(
-                        notification_options=NotificationOptions(),
-                        experimental_capabilities={},
-                    ),
-                ),
-            )
-
-def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
-    try:
-        tokenizer_path = pkg_resources.resource_filename(
-            "autocoder", "data/tokenizer.json"
-        )
-    except FileNotFoundError:
-        tokenizer_path = None
-
-    system_lang, _ = locale.getdefaultlocale()
-    lang = "zh" if system_lang and system_lang.startswith("zh") else "en"
-    desc = lang_desc[lang]
-    
-    parser = argparse.ArgumentParser(description="Auto Coder RAG MCP Server")
-    parser.add_argument("--source_dir", default=".", help="Source directory path")
-    parser.add_argument("--tokenizer_path", default=tokenizer_path, help="Path to tokenizer file")
-    parser.add_argument("--model", default="deepseek_chat", help=desc["model"])
-    parser.add_argument("--index_model", default="", help=desc["index_model"])
-    parser.add_argument("--emb_model", default="", help=desc["emb_model"])
-    parser.add_argument("--ray_address", default="auto", help=desc["ray_address"])
-    parser.add_argument("--required_exts", default="", help=desc["doc_build_parse_required_exts"])
-    parser.add_argument("--rag_doc_filter_relevance", type=int, default=5, help="Relevance score threshold for document filtering")
-    parser.add_argument("--rag_context_window_limit", type=int, default=56000, help="Context window limit for RAG")
-    parser.add_argument("--full_text_ratio", type=float, default=0.7, help="Ratio of full text area in context window")
-    parser.add_argument("--segment_ratio", type=float, default=0.2, help="Ratio of segment area in context window")
-    parser.add_argument("--index_filter_workers", type=int, default=5, help="Number of workers for document filtering")
-    parser.add_argument("--index_filter_file_num", type=int, default=3, help="Maximum number of files to filter")
-    parser.add_argument("--host", default="", help="Server host address")
-    parser.add_argument("--port", type=int, default=8000, help="Server port")
-    parser.add_argument("--monitor_mode", action="store_true", help="Enable document monitoring mode")
-    parser.add_argument("--enable_hybrid_index", action="store_true", help="Enable hybrid index")
-    parser.add_argument("--disable_auto_window", action="store_true", help="Disable automatic window adaptation")
-    parser.add_argument("--disable_segment_reorder", action="store_true", help="Disable segment reordering")
-    parser.add_argument("--disable_inference_enhance", action="store_true", help="Disable inference enhancement")
-    parser.add_argument("--inference_deep_thought", action="store_true", help="Enable deep thought in inference")
-    parser.add_argument("--inference_slow_without_deep_thought", action="store_true", help="Enable slow inference without deep thought")
-    parser.add_argument("--inference_compute_precision", type=int, default=64, help="Inference compute precision")
-    parser.add_argument("--data_cells_max_num", type=int, default=2000, help="Maximum number of data cells to process")
-    parser.add_argument("--recall_model", default="", help="Model used for document recall")
-    parser.add_argument("--chunk_model", default="", help="Model used for document chunking")
-    parser.add_argument("--qa_model", default="", help="Model used for question answering")    
-
-    args = parser.parse_args(input_args)
-    return AutoCoderArgs(**vars(args)),args
-
-async def main():
-    # Parse command line arguments
-    args,raw_rags = parse_args()
-    
-    # Initialize LLM
-    llm = ByzerLLM()
-    llm.setup_default_model_name(args.model)
-    
-    # Setup sub models if specified
-    if raw_rags.recall_model:
-        recall_model = ByzerLLM()
-        recall_model.setup_default_model_name(args.recall_model)
-        llm.setup_sub_client("recall_model", recall_model)
-
-    if raw_rags.chunk_model:
-        chunk_model = ByzerLLM()
-        chunk_model.setup_default_model_name(args.chunk_model)
-        llm.setup_sub_client("chunk_model", chunk_model)
-
-    if raw_rags.qa_model:
-        qa_model = ByzerLLM()
-        qa_model.setup_default_model_name(args.qa_model)
-        llm.setup_sub_client("qa_model", qa_model)
-
-    # Initialize and run server
-    server = AutoCoderRAGMCP(llm=llm, args=args)
-    await server.setup_server()
-    await server.run()
-
-if __name__ == "__main__":
-    asyncio.run(main())