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

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

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

{auto_coder-0.1.222 → 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.222
+Version: 0.1.224
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{auto_coder-0.1.222 → 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.222 → 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()
 
@@ -792,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(
@@ -819,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(
@@ -827,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()
@@ -836,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。
@@ -853,7 +852,7 @@ def main(input_args: Optional[List[str]] = None):
                     {% endif %}
 
 
-                    参考上面的文件以及对话，回答用户的问题。
+                    参考上面的文件以及历史对话，回答用户的问题。
                     用户的问题: {{ last_conversation.content }}
                     """
 
@@ -942,9 +941,14 @@ 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.action == "rag":
+            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="")
@@ -952,7 +956,7 @@ def main(input_args: Optional[List[str]] = None):
                     conversations=[{"role": "user", "content": args.query}])[0]                                                
                 v = ([item, None] for item in response)
                 
-            elif args.action == "mcp": 
+            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(
@@ -1027,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())

{auto_coder-0.1.222 → auto_coder-0.1.224}/src/autocoder/chat_auto_coder.py

@@ -48,6 +48,7 @@ from autocoder.agent.auto_guess_query import AutoGuessQuery
 from autocoder.common.mcp_server import get_mcp_server, McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, McpListRunningRequest, McpRefreshRequest
 import byzerllm
 from byzerllm.utils import format_str_jinja2
+from autocoder.common.memory_manager import get_global_memory_file_paths 
 
 
 class SymbolItem(BaseModel):
@@ -1657,6 +1658,9 @@ def commit(query: str):
                 return_paths=True
             )
 
+            if conf.get("enable_global_memory", "true") in ["true", "True",True]:
+                yaml_config["urls"] += get_global_memory_file_paths()
+
             # 临时保存yaml文件，然后读取yaml文件，转换为args
             temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
             try:
@@ -1740,11 +1744,14 @@ def coding(query: str):
             converted_value = convert_config_value(key, value)
             if converted_value is not None:
                 yaml_config[key] = converted_value
-
+        
         yaml_config["urls"] = current_files + get_llm_friendly_package_docs(
             return_paths=True
         )
 
+        if conf.get("enable_global_memory", "true") in ["true", "True",True]:
+            yaml_config["urls"] += get_global_memory_file_paths()
+        
         # handle image
         v = Image.convert_image_paths_from(query)
         yaml_config["query"] = v
@@ -1794,7 +1801,7 @@ def coding(query: str):
 
             yaml_config[
                 "context"
-            ] += f"下面是我们的历史对话，参考我们的历史对话从而更好的理解需求和修改代码。\n\n<history>\n"
+            ] += f"下面是我们的历史对话，参考我们的历史对话从而更好的理解需求和修改代码: \n\n<history>\n"
             for conv in conversations:
                 if conv["role"] == "user":
                     yaml_config["context"] += f"用户: {conv['content']}\n"
@@ -1855,6 +1862,9 @@ def chat(query: str):
         return_paths=True
     )
 
+    if conf.get("enable_global_memory", "true") in ["true", "True",True]:
+        current_files += get_global_memory_file_paths()
+
     yaml_config["urls"] = current_files
 
     if "emb_model" in conf:
@@ -1864,14 +1874,24 @@ def chat(query: str):
     if is_new:
         query = query.replace("/new", "", 1).strip()
 
+    yaml_config["action"] = []    
+
     if "/mcp " in query:
-        yaml_config["action"] = "mcp"
+        yaml_config["action"].append("mcp")
         query = query.replace("/mcp ", "", 1).strip()
 
     if "/rag " in query:
-        yaml_config["action"] = "rag"
+        yaml_config["action"].append("rag")
         query = query.replace("/rag ", "", 1).strip()
 
+    if "/copy" in query:
+        yaml_config["action"].append("copy")
+        query = query.replace("/copy", "", 1).strip()   
+
+    if "/save" in query:
+        yaml_config["action"].append("save")
+        query = query.replace("/save", "", 1).strip()        
+
     is_review = query.strip().startswith("/review")
     if is_review:
         query = query.replace("/review", "", 1).strip()

{auto_coder-0.1.222 → auto_coder-0.1.224}/src/autocoder/common/__init__.py

@@ -348,7 +348,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     data_cells_max_num: Optional[int] = 2000
     generate_times_same_model: Optional[int] = 1
 
-    action: Optional[str] = None
+    action: List[str] = []
+    enable_global_memory: Optional[bool] = True
 
     class Config:
         protected_namespaces = ()

{auto_coder-0.1.222 → auto_coder-0.1.224}/src/autocoder/common/command_completer.py

@@ -13,7 +13,7 @@ COMMANDS = {
         "/sd": {},
     },
     "/coding": {"/apply": {}, "/next": {}},
-    "/chat": {"/new": {}, "/mcp": {}, "/rag": {}, "/review": {}, "/no_context": {}},
+    "/chat": {"/new": {}, "/save": {}, "/copy":{}, "/mcp": {}, "/rag": {}, "/review": {}, "/no_context": {}},
     "/mcp": {
         "/add": "",         
         "/remove": "",

{auto_coder-0.1.222 → auto_coder-0.1.224}/src/autocoder/common/mcp_hub.py

@@ -192,7 +192,7 @@ class McpHub:
                      "PATH": os.environ.get("PATH", "")},
             )
 
-            # Create transport using context manager
+            # Create transport using context manager            
             transport_manager = stdio_client(server_params)
             transport = await transport_manager.__aenter__()
             try:
@@ -204,9 +204,9 @@ class McpHub:
                 self.connections[name] = connection
 
                 # Update server status and fetch capabilities
-                server.status = "connected"
-                server.tools = await self._fetch_tools(name)
-                server.resources = await self._fetch_resources(name)
+                server.status = "connected"                
+                server.tools = await self._fetch_tools(name)                
+                server.resources = await self._fetch_resources(name)                
                 server.resource_templates = await self._fetch_resource_templates(name)
 
             except Exception as e: