auto-coder 0.1.295__tar.gz → 0.1.296__tar.gz

{auto_coder-0.1.295 → auto_coder-0.1.296}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.295
+Version: 0.1.296
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/auto_coder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 0.1.295
+Version: 0.1.296
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/auto_coder.egg-info/SOURCES.txt

@@ -10,8 +10,6 @@ src/auto_coder.egg-info/top_level.txt
 src/autocoder/__init__.py
 src/autocoder/auto_coder.py
 src/autocoder/auto_coder_rag.py
-src/autocoder/auto_coder_rag_client_mcp.py
-src/autocoder/auto_coder_rag_mcp.py
 src/autocoder/auto_coder_runner.py
 src/autocoder/auto_coder_server.py
 src/autocoder/benchmark.py

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/autocoder/commands/auto_command.py

@@ -241,6 +241,7 @@ class CommandAutoTuner:
         而对于分析一个超大文件推荐组合 read_files 带上 line_ranges 参数来读取，或者组合 read_file_withread_file_with_keyword_ranges 等来读取，
         每个函数你还可以使用多次来获取更多信息。
         9. 根据操作系统，终端类型，脚本类型等各种信息，在涉及到路径或者脚本的时候，需要考虑平台差异性。
+        10. 使用 read_files 时，一次性读取文件数量不要超过1个,每次只读取200行。如果发现读取的内容不够，则继续读取下面200行。
         </function_combination_readme>
 
 
@@ -1057,7 +1058,8 @@ class CommandAutoTuner:
 
         你可以使用 get_project_structure 函数获取项目结构后，然后再通过 get_project_map 函数获取某个文件的用途，符号列表，以及
         文件大小（tokens数）,最后再通过 read_files 函数来读取文件内容，从而帮你做更好的决策。如果需要读取的文件过大，
-        你可以通过指定行范围来读取文件内容，从而避免读取过多的内容，你可以多次用行范围来调用 read_files,直到你看到满意的内容为止。
+        
+        特别注意：使用 read_files 时，一次性读取文件数量不要超过1个,每次只读取200行。如果发现读取的内容不够，则继续读取下面200行。
         
         </usage>
         </command>

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/autocoder/commands/tools.py

@@ -450,6 +450,8 @@ class AutoCommandTools:
                     content = "".join(lines[start:end])
                     filtered_lines.extend(f"##File: {absolute_path}\n##Line: {start}-{end}\n\n{content}")
                 source_code = "".join(filtered_lines)
+                # Add source_code to source_code_str
+                source_code_str += source_code
             else:
                 # Read entire file if no range specified
                 content = files_utils.read_file(absolute_path)

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/autocoder/common/mcp_hub.py

@@ -10,15 +10,21 @@ from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Any, Set, Optional, Tuple
 from pathlib import Path
 from pydantic import BaseModel, Field
-
-from mcp import ClientSession
-from mcp.client.stdio import stdio_client, StdioServerParameters
-from mcp.client.sse import sse_client
-import mcp.types as mcp_types
 from loguru import logger
 from contextlib import AsyncExitStack
 from datetime import timedelta
 
+try:
+    from mcp import ClientSession
+    from mcp.client.stdio import stdio_client, StdioServerParameters
+    from mcp.client.sse import sse_client
+    import mcp.types as mcp_types
+except ImportError:
+    mcp_types = None
+    stdio_client = None
+    sse_client = None   
+    ClientSession = None
+    logger.error("mcp is not installed(which requires python>=3.11), please install it by `pip install mcp`")
 
 class McpTool(BaseModel):
     """Represents an MCP tool configuration"""
@@ -101,9 +107,7 @@ def _generate_server_configs() -> Tuple[Dict[str, Any], Dict[str, str]]:
                 
                 # Store in dictionaries
                 servers[friendly_name] = config
-                templates[friendly_name] = json.dumps({friendly_name: config}, indent=4)
-                
-                logger.info(f"Detected MCP server: {friendly_name}")
+                templates[friendly_name] = json.dumps({friendly_name: config}, indent=4)                                
     
     except Exception as e:
         logger.error(f"Error generating server configs: {e}")

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/autocoder/common/mcp_servers/mcp_server_gpt4o_mini_search.py

@@ -1,13 +1,15 @@
 from os import getenv
 from textwrap import dedent
 import sys
-
+import json
+from openai import OpenAI
+from loguru import logger
 import mcp.server.stdio
 import mcp.types as types
 from mcp.server import NotificationOptions, Server
 from mcp.server.models import InitializationOptions
-import json
-from openai import OpenAI
+
+
 
 OPENAI_API_KEY = getenv("OPENAI_API_KEY")
 # Check if API key is empty or None

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/autocoder/common/mcp_servers/mcp_server_perplexity.py

@@ -2,11 +2,13 @@ from os import getenv
 from textwrap import dedent
 
 import httpx
+import json
+from loguru import logger
+
 import mcp.server.stdio
 import mcp.types as types
 from mcp.server import NotificationOptions, Server
 from mcp.server.models import InitializationOptions
-import json
 
 PERPLEXITY_API_KEY = getenv("PERPLEXITY_API_KEY")
 PERPLEXITY_API_BASE_URL = "https://api.perplexity.ai"

{auto_coder-0.1.295 → auto_coder-0.1.296}/src/autocoder/common/mcp_tools.py

@@ -1,14 +1,19 @@
 from typing import Dict, Any, List, Optional, Union
 from byzerllm import prompt
-from ..common.mcp_hub import McpHub
 import json
 import byzerllm
 import re
 from pydantic import BaseModel, Field
 from loguru import logger
-import mcp.types as mcp_types
 import os
 import time
+try:    
+    import mcp.types as mcp_types    
+except ImportError:
+    mcp_types = None
+    logger.error("mcp is not installed(which requires python>=3.11), please install it by `pip install mcp`")
+from autocoder.common.mcp_hub import McpHub    
+
 
 class McpToolCall(BaseModel):
     server_name: str = Field(..., description="The name of the MCP server")

auto_coder-0.1.296/src/autocoder/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.296"

auto_coder-0.1.295/src/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())

auto_coder-0.1.295/src/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())

auto_coder-0.1.295/src/autocoder/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.295"