auto-coder 0.1.288__tar.gz → 0.1.289__tar.gz

{auto_coder-0.1.288 → auto_coder-0.1.289}/PKG-INFO

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

{auto_coder-0.1.288 → auto_coder-0.1.289}/src/auto_coder.egg-info/PKG-INFO

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

{auto_coder-0.1.288 → auto_coder-0.1.289}/src/auto_coder.egg-info/SOURCES.txt

@@ -134,6 +134,7 @@ src/autocoder/rag/rag_config.py
 src/autocoder/rag/rag_entry.py
 src/autocoder/rag/raw_rag.py
 src/autocoder/rag/relevant_utils.py
+src/autocoder/rag/searchable.py
 src/autocoder/rag/simple_directory_reader.py
 src/autocoder/rag/simple_rag.py
 src/autocoder/rag/token_checker.py

{auto_coder-0.1.288 → auto_coder-0.1.289}/src/autocoder/chat_auto_coder_lang.py

@@ -4,16 +4,16 @@ from byzerllm.utils import format_str_jinja2
 MESSAGES = {
     "en": {
         "auto_command_analyzing": "Analyzing Command Request",
-        "mcp_remove_error": "Error removing MCP server: {error}",
-        "mcp_remove_success": "Successfully removed MCP server: {result}",
-        "mcp_list_running_error": "Error listing running MCP servers: {error}",
+        "mcp_remove_error": "Error removing MCP server: {{error}}",
+        "mcp_remove_success": "Successfully removed MCP server: {{result}}",
+        "mcp_list_running_error": "Error listing running MCP servers: {{error}}",
         "mcp_list_running_title": "Running MCP servers:",
-        "mcp_list_builtin_error": "Error listing builtin MCP servers: {error}",
+        "mcp_list_builtin_error": "Error listing builtin MCP servers: {{error}}",
         "mcp_list_builtin_title": "Available builtin MCP servers:",
-        "mcp_refresh_error": "Error refreshing MCP servers: {error}",
+        "mcp_refresh_error": "Error refreshing MCP servers: {{error}}",
         "mcp_refresh_success": "Successfully refreshed MCP servers",
-        "mcp_install_error": "Error installing MCP server: {error}",
-        "mcp_install_success": "Successfully installed MCP server: {result}",
+        "mcp_install_error": "Error installing MCP server: {{error}}",
+        "mcp_install_success": "Successfully installed MCP server: {{result}}",
         "mcp_query_empty": "Please enter your query.",
         "mcp_error_title": "Error",
         "mcp_response_title": "MCP Response",
@@ -24,7 +24,7 @@ MESSAGES = {
         "init_fail": "Failed to initialize the project.",
         "init_manual": "Please try manually: auto-coder init --source_dir .",
         "exit_no_init": "Exiting without initialization.",
-        "created_dir": "Created directory: {}",
+        "created_dir": "Created directory: {{path}}",
         "init_complete": "Project initialization completed.",
         "checking_ray": "Checking Ray status...",
         "ray_not_running": "Ray is not running. Starting Ray...",
@@ -145,16 +145,16 @@ MESSAGES = {
         "auto_command_reasoning_title": "回复",
         "commit_message": "{{ model_name }} 生成的提交信息: {{ message }}",
         "commit_failed": "{{ model_name }} 生成提交信息失败: {{ error }}",
-        "mcp_remove_error": "移除 MCP 服务器时出错:{error}",
-        "mcp_remove_success": "成功移除 MCP 服务器：{result}",
-        "mcp_list_running_error": "列出运行中的 MCP 服务器时出错：{error}",
+        "mcp_remove_error": "移除 MCP 服务器时出错:{{error}}",
+        "mcp_remove_success": "成功移除 MCP 服务器：{{result}}",
+        "mcp_list_running_error": "列出运行中的 MCP 服务器时出错：{{error}}",
         "mcp_list_running_title": "正在运行的 MCP 服务器：",
-        "mcp_list_builtin_error": "列出内置 MCP 服务器时出错：{error}",
+        "mcp_list_builtin_error": "列出内置 MCP 服务器时出错：{{error}}",
         "mcp_list_builtin_title": "可用的内置 MCP 服务器：",
-        "mcp_refresh_error": "刷新 MCP 服务器时出错：{error}",
+        "mcp_refresh_error": "刷新 MCP 服务器时出错：{{error}}",
         "mcp_refresh_success": "成功刷新 MCP 服务器",
-        "mcp_install_error": "安装 MCP 服务器时出错：{error}",
-        "mcp_install_success": "成功安装 MCP 服务器：{result}",
+        "mcp_install_error": "安装 MCP 服务器时出错：{{error}}",
+        "mcp_install_success": "成功安装 MCP 服务器：{{result}}",
         "mcp_query_empty": "请输入您的查询。",
         "mcp_error_title": "错误",
         "mcp_response_title": "MCP 响应",
@@ -165,7 +165,7 @@ MESSAGES = {
         "init_fail": "项目初始化失败。",
         "init_manual": "请尝试手动初始化：auto-coder init --source_dir .",
         "exit_no_init": "退出而不初始化。",
-        "created_dir": "创建目录：{}",
+        "created_dir": "创建目录：{{path}}",
         "init_complete": "项目初始化完成。",
         "checking_ray": "正在检查Ray状态...",
         "ray_not_running": "Ray未运行。正在启动Ray...",

{auto_coder-0.1.288 → auto_coder-0.1.289}/src/autocoder/common/auto_coder_lang.py

@@ -184,9 +184,14 @@ MESSAGES = {
         "action_verification_failed": "Action verification failed: {{action}} - {{reason}}",
         "action_succeeded": "Action succeeded: {{action}}",
         "replanned_actions": "Replanned {{count}} actions",
-        "web_automation_ask_user": "Your answer: "  # 新增消息
-        
-        
+        "web_automation_ask_user": "Your answer: ",
+        "filter_mode_normal": "Using normal filter mode for index processing...",
+        "filter_mode_big": "Index file is large ({{ tokens_len }} tokens), using big_filter mode for processing...",
+        "filter_mode_super_big": "Index file is very large ({{ tokens_len }} tokens), using super_big_filter mode for processing...",
+        "super_big_filter_failed": "❌ Super big filter failed: {{ error }}.",
+        "super_big_filter_stats": "{{ model_names }} Super big filter completed in {{ elapsed_time }} seconds, input tokens: {{ input_tokens }}, output tokens: {{ output_tokens }}, input cost: {{ input_cost }}, output cost: {{ output_cost }}, speed: {{ speed }} tokens/s, chunk_index: {{ chunk_index }}",
+        "super_big_filter_splitting": "⚠️ Index file is extremely large ({{ tokens_len }}/{{ max_tokens }}). The query will be split into {{ split_size }} chunks for processing.",
+        "super_big_filter_title": "{{ model_name }} is analyzing how to filter extremely large context..."
     },
     "zh": {
         "file_sliding_window_processing": "文件 {{ file_path }} 过大 ({{ tokens }} tokens)，正在使用滑动窗口处理...",
@@ -368,7 +373,14 @@ MESSAGES = {
         "action_verification_failed": "操作验证失败: {{action}} - {{reason}}",
         "action_succeeded": "操作成功: {{action}}",
         "replanned_actions": "已重新规划 {{count}} 个操作",
-        "web_automation_ask_user": "您的回答: "  # 新增消息
+        "web_automation_ask_user": "您的回答: ",
+        "filter_mode_normal": "正在使用普通过滤模式处理索引...",
+        "filter_mode_big": "索引文件较大 ({{ tokens_len }} tokens)，正在使用 big_filter 模式处理...",
+        "filter_mode_super_big": "索引文件非常大 ({{ tokens_len }} tokens)，正在使用 super_big_filter 模式处理...",
+        "super_big_filter_failed": "❌ 超大过滤器失败: {{ error }}.",
+        "super_big_filter_stats": "{{ model_names }} 超大过滤器完成耗时 {{ elapsed_time }} 秒，输入token数: {{ input_tokens }}, 输出token数: {{ output_tokens }}, 输入成本: {{ input_cost }}, 输出成本: {{ output_cost }}, 速度: {{ speed }} tokens/秒, 块索引: {{ chunk_index }}",
+        "super_big_filter_splitting": "⚠️ 索引文件极其庞大 ({{ tokens_len }}/{{ max_tokens }})。查询将被分成 {{ split_size }} 个部分进行处理。",
+        "super_big_filter_title": "{{ model_name }} 正在分析如何过滤极大规模上下文..."
     }}
 
 

{auto_coder-0.1.288 → auto_coder-0.1.289}/src/autocoder/common/mcp_hub.py

@@ -2,16 +2,18 @@ import os
 import json
 import asyncio
 import aiohttp
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Any, Set, Optional
 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
-import time
+from contextlib import AsyncExitStack
+from datetime import timedelta
 
 
 class McpTool(BaseModel):
@@ -55,12 +57,9 @@ class McpServer(BaseModel):
 class McpConnection:
     """Represents an active MCP server connection"""
 
-    def __init__(self, server: McpServer, session: ClientSession, transport_manager):
+    def __init__(self, server: McpServer, session: ClientSession):
         self.server = server
-        self.session = session
-        self.transport_manager = (
-            transport_manager  # Will hold transport context manager
-        )
+        self.session = session        
 
 
 MCP_PERPLEXITY_SERVER = '''
@@ -81,6 +80,7 @@ MCP_BUILD_IN_SERVERS = {
     "perplexity": json.loads(MCP_PERPLEXITY_SERVER)["perplexity"]
 }
 
+
 class McpHub:
     """
     Manages MCP server connections and interactions.
@@ -105,6 +105,7 @@ class McpHub:
             self.settings_path = Path(settings_path)
         self.connections: Dict[str, McpConnection] = {}
         self.is_connecting = False
+        self.exit_stacks: Dict[str, AsyncExitStack] = {}
 
         # Ensure settings directory exists
         self.settings_path.parent.mkdir(parents=True, exist_ok=True)
@@ -116,26 +117,31 @@ class McpHub:
     def _write_default_settings(self):
         """Write default MCP settings file"""
         default_settings = {"mcpServers": {}}
-        with open(self.settings_path, "w",encoding="utf-8") as f:
+        with open(self.settings_path, "w", encoding="utf-8") as f:
             json.dump(default_settings, f, indent=2)
 
-    async def add_server_config(self, name: str, config:Dict[str,Any]) -> None:
+    async def add_server_config(self, name: str, config: Dict[str, Any]) -> None:
         """
         Add or update MCP server configuration in settings file.
 
         Args:
             server_name_or_config: Name of the server or server configuration dictionary
         """
-        try:
-            settings = self._read_settings()            
-            settings["mcpServers"][name] = config
-            with open(self.settings_path, "w",encoding="utf-8") as f:
-                json.dump(settings, f, indent=2, ensure_ascii=False)
-            await self.initialize()
-            logger.info(f"Added/updated MCP server config: {name}")
-        except Exception as e:
-            logger.error(f"Failed to add MCP server config: {e}")
-            raise
+        settings = self._read_settings()
+        settings["mcpServers"][name] = config
+        with open(self.settings_path, "w", encoding="utf-8") as f:
+            json.dump(settings, f, indent=2, ensure_ascii=False)
+        await self.initialize()
+        if name in self.connections:
+            if self.connections[name].server.status == "connected":
+                logger.info(f"Added/updated MCP server config: {name}")
+                return True
+            else:
+                logger.error(f"Failed to add MCP server config: {name}")
+                return False
+        else:
+            logger.error(f"Failed to add MCP server config: {name}")
+            return False
 
     async def remove_server_config(self, name: str) -> None:
         """
@@ -148,7 +154,7 @@ class McpHub:
             settings = self._read_settings()
             if name in settings["mcpServers"]:
                 del settings["mcpServers"][name]
-                with open(self.settings_path, "w",encoding="utf-8") as f:
+                with open(self.settings_path, "w", encoding="utf-8") as f:
                     json.dump(settings, f, indent=2, ensure_ascii=False)
                 logger.info(f"Removed MCP server config: {name}")
                 await self.initialize()
@@ -160,18 +166,14 @@ class McpHub:
 
     async def initialize(self):
         """Initialize MCP server connections from settings"""
-        try:
-            config = self._read_settings()
-            await self.update_server_connections(config.get("mcpServers", {}))
-        except Exception as e:
-            logger.error(f"Failed to initialize MCP servers: {e}")
-            raise
+        config = self._read_settings()
+        await self.update_server_connections(config.get("mcpServers", {}))
 
     def get_servers(self) -> List[McpServer]:
         """Get list of all configured servers"""
         return [conn.server for conn in self.connections.values()]
 
-    async def connect_to_server(self, name: str, config: dict) -> None:
+    async def connect_to_server(self, name: str, config: dict) -> McpServer:
         """
         Establish connection to an MCP server with proper resource management
         """
@@ -179,79 +181,90 @@ class McpHub:
         if name in self.connections:
             await self.delete_connection(name)
 
-        try:
-            server = McpServer(
-                name=name, config=json.dumps(config), status="connecting"
-            )
+        self.exit_stacks[name] = AsyncExitStack()
+        exit_stack = self.exit_stacks[name]
+
+        server = McpServer(
+            name=name, config=json.dumps(config), status="connecting"
+        )
+        transport_config = config.get("transport", {
+            "type": "stdio",
+            "endpoint":""
+        })
 
+        if transport_config["type"] not in ["stdio", "sse"]:
+            raise ValueError(f"Invalid transport type: {transport_config['type']}")
+        
+        if transport_config["type"] == "stdio":            
             # Setup transport parameters
             server_params = StdioServerParameters(
                 command=config["command"],
                 args=config.get("args", []),
                 env={**config.get("env", {}),
-                     "PATH": os.environ.get("PATH", "")},
+                    "PATH": os.environ.get("PATH", "")},
             )
 
-            # Create transport using context manager            
-            transport_manager = stdio_client(server_params)
-            transport = await transport_manager.__aenter__()
-            try:
-                session = await ClientSession(transport[0], transport[1]).__aenter__()
-                await session.initialize()
-
-                # Store connection with transport manager
-                connection = McpConnection(server, session, transport_manager)
-                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.resource_templates = await self._fetch_resource_templates(name)
-
-            except Exception as e:
-                # Clean up transport if session initialization fails
-
-                await transport_manager.__aexit__(None, None, None)
-                raise
-
+            # Create transport using context manager
+            transport = await exit_stack.enter_async_context(stdio_client(server_params))
+        
+        if transport_config["type"] == "sse":
+            url = transport_config["endpoint"]
+            transport = await exit_stack.enter_async_context(sse_client(url))
+        
+        
+        try:
+            stdio, write = transport
+            session = await exit_stack.enter_async_context(
+                ClientSession(stdio, write, read_timeout_seconds=timedelta(seconds=60)))
+            await session.initialize()
+            connection = McpConnection(server, session)
+            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.resource_templates = await self._fetch_resource_templates(name)
+            return server
+        
         except Exception as e:
             error_msg = str(e)
             logger.error(f"Failed to connect to server {name}: {error_msg}")
             if name in self.connections:
                 self.connections[name].server.status = "disconnected"
                 self.connections[name].server.error = error_msg
-            raise
+            return server
+
+        
+
+
+
 
     async def delete_connection(self, name: str) -> None:
         """
         Close and remove a server connection with proper cleanup
         """
         if name in self.connections:
-            try:
-                connection = self.connections[name]
-                # Clean up in reverse order of creation
-                await connection.session.__aexit__(None, None, None)
-                await connection.transport_manager.__aexit__(None, None, None)
+            
+            try:                
                 del self.connections[name]
             except Exception as e:
                 logger.error(f"Error closing connection to {name}: {e}")
-                # Continue with deletion even if cleanup fails
-                if name in self.connections:
-                    del self.connections[name]
+
+            try:
+                exit_stack = self.exit_stacks[name]
+                await exit_stack.aclose()
+                del self.exit_stacks[name]
+            except Exception as e:
+                logger.error(f"Error cleaning up to {name}: {e}")
+                        
 
     async def refresh_server_connection(self, name: str) -> None:
         """
         Refresh a server connection
         """
-        try:
-            config = self._read_settings()
-            await self.delete_connection(name)
-            await self.connect_to_server(name, config.get("mcpServers", {}).get(name, {}))
-        except Exception as e:
-            logger.error(f"Failed to refresh MCP server {name}: {e}")
-            raise
-        
+        config = self._read_settings()
+        await self.delete_connection(name)
+        await self.connect_to_server(name, config.get("mcpServers", {}).get(name, {}))
 
     async def update_server_connections(self, new_servers: Dict[str, Any]) -> None:
         """
@@ -273,13 +286,22 @@ class McpHub:
 
                 if not current_conn:
                     # New server
-                    await self.connect_to_server(name, config)
-                    logger.info(f"Connected to new MCP server: {name}")
+                    server = await self.connect_to_server(name, config)
+                    if server.status == "connected":
+                        logger.info(f"Connected to new MCP server: {name}")
+                    else:
+                        logger.error(
+                            f"Failed to connect to new MCP server: {name}")
+
                 elif current_conn.server.config != json.dumps(config):
                     # Updated configuration
-                    await self.connect_to_server(name, config)
-                    logger.info(
-                        f"Reconnected MCP server with updated config: {name}")
+                    server = await self.connect_to_server(name, config)
+                    if server.status == "connected":
+                        logger.info(
+                            f"Reconnected MCP server with updated config: {name}")
+                    else:
+                        logger.error(
+                            f"Failed to reconnected MCP server with updated config: {name}")
 
         finally:
             self.is_connecting = False