auto-coder 0.1.221__tar.gz → 0.1.224__tar.gz

{auto_coder-0.1.221 → auto_coder-0.1.224}/PKG-INFO

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

{auto_coder-0.1.221 → auto_coder-0.1.224}/src/auto_coder.egg-info/PKG-INFO

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

{auto_coder-0.1.221 → auto_coder-0.1.224}/src/auto_coder.egg-info/SOURCES.txt

@@ -11,6 +11,8 @@ src/autocoder/__init__.py
 src/autocoder/auto_coder.py
 src/autocoder/auto_coder_lang.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_server.py
 src/autocoder/benchmark.py
 src/autocoder/chat_auto_coder.py
@@ -58,6 +60,7 @@ src/autocoder/common/llm_rerank.py
 src/autocoder/common/mcp_hub.py
 src/autocoder/common/mcp_server.py
 src/autocoder/common/mcp_tools.py
+src/autocoder/common/memory_manager.py
 src/autocoder/common/recall_validation.py
 src/autocoder/common/screenshots.py
 src/autocoder/common/search.py

{auto_coder-0.1.221 → auto_coder-0.1.224}/src/autocoder/auto_coder.py

@@ -40,6 +40,7 @@ from rich.panel import Panel
 from rich.markdown import Markdown
 from rich.live import Live
 from autocoder.auto_coder_lang import get_message
+from autocoder.common.memory_manager import save_to_memory_file
 
 console = Console()
 
@@ -577,6 +578,9 @@ def main(input_args: Optional[List[str]] = None):
             with Live(
                 Panel("", title="Response", border_style="green", expand=False),
                 refresh_per_second=4,
+                auto_refresh=True,
+                vertical_overflow="visible",
+                console=Console(force_terminal=True, color_system="auto", height=None)
             ) as live:
                 live.update(
                     Panel(
@@ -689,6 +693,9 @@ def main(input_args: Optional[List[str]] = None):
             with Live(
                 Panel("", title="Response", border_style="green", expand=False),
                 refresh_per_second=4,
+                auto_refresh=True,
+                vertical_overflow="visible",
+                console=Console(force_terminal=True, color_system="auto", height=None)
             ) as live:
                 live.update(
                     Panel(
@@ -698,8 +705,8 @@ def main(input_args: Optional[List[str]] = None):
                         expand=False,
                     )
                 )
-            return
 
+            return
         elif raw_args.agent_command == "designer":
             from autocoder.agent.designer import SVGDesigner, SDDesigner, LogoDesigner
 
@@ -786,7 +793,7 @@ def main(input_args: Optional[List[str]] = None):
                     pre_conversations.append(
                         {
                             "role": "user",
-                            "content": f"下面是一些文档和源码，如果用户的问题和他们相关，请参考他们：\n <files>\n{file_content}</files>",
+                            "content": f"请阅读下面的代码和文档：\n\n <files>\n{file_content}\n</files>",
                         },
                     )
                     pre_conversations.append(
@@ -813,7 +820,7 @@ def main(input_args: Optional[List[str]] = None):
                 pre_conversations.append(
                     {
                         "role": "user",
-                        "content": f"下面是一些文档和源码，如果用户的问题和他们相关，请参考他们：\n <files>{s}</files>",
+                        "content": f"请阅读下面的代码和文档：\n\n <files>\n{s}\n</files>",
                     }
                 )
                 pre_conversations.append(
@@ -821,7 +828,7 @@ def main(input_args: Optional[List[str]] = None):
                 source_count += 1
 
             loaded_conversations = pre_conversations + \
-                chat_history["ask_conversation"]
+                chat_history["ask_conversation"]              
 
             if args.human_as_model:
                 console = Console()
@@ -830,12 +837,10 @@ def main(input_args: Optional[List[str]] = None):
                 def chat_with_human_as_model(
                     source_codes, pre_conversations, last_conversation
                 ):
-                    """
-                    <files>
-                    {% if source_codes %}
+                    """                    
+                    {% if source_codes %}                    
                     {{ source_codes }}
-                    {% endif %}
-                    </files>
+                    {% endif %}                    
 
                     {% if pre_conversations %}
                     下面是我们之间的历史对话，假设我是A，你是B。
@@ -847,7 +852,7 @@ def main(input_args: Optional[List[str]] = None):
                     {% endif %}
 
 
-                    参考上面的文件以及对话，回答用户的问题。
+                    参考上面的文件以及历史对话，回答用户的问题。
                     用户的问题: {{ last_conversation.content }}
                     """
 
@@ -936,13 +941,31 @@ def main(input_args: Optional[List[str]] = None):
                     ),
                 )
 
+                if "save" in args.action:
+                    save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+                                        query=args.query,
+                                        response=result)
+                    print("Saved to your memory")
                 return {}
 
-            if args.enable_rag_search or args.enable_rag_context:
+            if "rag" in args.action:
+                args.enable_rag_search = True
+                args.enable_rag_context = False
                 rag = RAGFactory.get_rag(llm=chat_llm, args=args, path="")
                 response = rag.stream_chat_oai(
-                    conversations=loaded_conversations)[0]
+                    conversations=[{"role": "user", "content": args.query}])[0]                                                
                 v = ([item, None] for item in response)
+                
+            elif "mcp" in args.action: 
+                from autocoder.common.mcp_server import get_mcp_server, McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, McpListRunningRequest, McpRefreshRequest                               
+                mcp_server = get_mcp_server()
+                response = mcp_server.send_request(
+                    McpRequest(
+                        query=args.query,
+                        model=args.inference_model or args.model
+                    )
+                )
+                v = [[response.result,None]]
             else:
                 v = chat_llm.stream_chat_oai(
                     conversations=loaded_conversations, delta_mode=True
@@ -953,10 +976,11 @@ def main(input_args: Optional[List[str]] = None):
 
             try:
                 with Live(
-                    Panel("", title="Response"),
+                    Panel("", title="Response", border_style="green", expand=False),
                     refresh_per_second=4,
                     auto_refresh=True,
-                    vertical_overflow="visible"
+                    vertical_overflow="visible",
+                    console=Console(force_terminal=True, color_system="auto", height=None)
                 ) as live:
                     for res in v:
                         markdown_content += res[0]
@@ -977,7 +1001,7 @@ def main(input_args: Optional[List[str]] = None):
                                 expand=False,
                             )
                         )
-                live.update(
+                    live.update(
                             Panel(
                                 Markdown(markdown_content),
                                 title="Response",
@@ -999,7 +1023,7 @@ def main(input_args: Optional[List[str]] = None):
                         value=StreamValue(value=[""]), status=RequestOption.COMPLETED
                     ),
                 )
-
+            
             chat_history["ask_conversation"].append(
                 {"role": "assistant", "content": assistant_response}
             )
@@ -1007,6 +1031,19 @@ def main(input_args: Optional[List[str]] = None):
             with open(memory_file, "w") as f:
                 json.dump(chat_history, f, ensure_ascii=False)
 
+            if "copy" in args.action:
+                #copy assistant_response to clipboard
+                import pyperclip
+                try:
+                    pyperclip.copy(assistant_response)    
+                except:
+                    print("pyperclip not installed or clipboard is not supported, instruction will not be copied to clipboard.")
+
+            if "save" in args.action:
+                save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+                                    query=args.query,
+                                    response=assistant_response)  
+                print("Saved to your memory")                      
             return
 
         else:

auto_coder-0.1.224/src/autocoder/auto_coder_rag_client_mcp.py

@@ -0,0 +1,170 @@
+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="deepseek_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.224/src/autocoder/auto_coder_rag_mcp.py

@@ -0,0 +1,193 @@
+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())