auto-coder-web 0.1.61__py3-none-any.whl → 0.1.62__py3-none-any.whl

auto_coder_web/common_router/auto_coder_conf_router.py

@@ -1,5 +1,6 @@
 from fastapi import APIRouter, Request, HTTPException, Depends
 from autocoder.auto_coder_runner import get_memory, configure
+import asyncio
 
 router = APIRouter()
 
@@ -19,19 +20,18 @@ async def config(
     data = await request.json()
     try:
         for key, value in data.items():
-            configure(f"{key}:{str(value)}")
+            await asyncio.to_thread(configure, f"{key}:{str(value)}")
         return {"status": "success"}
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
 
-
 @router.delete("/api/conf/{key}")
 async def delete_config(
     key: str
 ):
     """删除配置项"""
     try:
-        configure(f"/drop {key}")
+        await asyncio.to_thread(configure, f"/drop {key}")
         return {"status": "success"}
     except ValueError as e:
         raise HTTPException(status_code=404, detail=str(e))

auto_coder_web/common_router/completions_router.py

@@ -15,6 +15,8 @@ from autocoder.index.symbols_utils import (
 from autocoder.auto_coder_runner import get_memory
 import json
 import asyncio
+import aiofiles
+import aiofiles.os
 
 
 router = APIRouter()
@@ -98,14 +100,19 @@ def find_files_in_project(patterns: List[str], project_path: str) -> List[str]:
 
     return list(matched_files)
 
-def get_symbol_list(project_path: str) -> List[SymbolItem]:
+async def get_symbol_list_async(project_path: str) -> List[SymbolItem]:
+    """Asynchronously reads the index file and extracts symbols."""
     list_of_symbols = []
-    index_file = os.path.join(
-        project_path, ".auto-coder", "index.json")
-
-    if os.path.exists(index_file):
-        with open(index_file, "r") as file:
-            index_data = json.load(file)
+    index_file = os.path.join(project_path, ".auto-coder", "index.json")
+
+    if await aiofiles.os.path.exists(index_file):
+        try:
+            async with aiofiles.open(index_file, "r", encoding='utf-8') as file:
+                content = await file.read()
+                index_data = json.loads(content)
+        except (IOError, json.JSONDecodeError):
+             # Handle file reading or JSON parsing errors
+             index_data = {}
     else:
         index_data = {}
 
@@ -169,7 +176,7 @@ async def get_symbol_completions(
     project_path: str = Depends(get_project_path)
 ):
     """获取符号补全"""
-    symbols = await asyncio.to_thread(get_symbol_list, project_path)
+    symbols = await get_symbol_list_async(project_path)
     matches = []
 
     for symbol in symbols:

auto_coder_web/common_router/file_router.py

@@ -1,7 +1,12 @@
 import os
 import shutil
+import aiofiles
+import aiofiles.os
 from fastapi import APIRouter, Request, HTTPException, Depends
-from auto_coder_web.file_manager import get_directory_tree, read_file_content
+from auto_coder_web.file_manager import (
+    get_directory_tree_async,
+    read_file_content_async,
+)
 
 router = APIRouter()
 
@@ -15,16 +20,18 @@ async def get_auto_coder_runner(request: Request):
 
 @router.delete("/api/files/{path:path}")
 async def delete_file(
-    path: str,
+    path: str,    
     project_path: str = Depends(get_project_path)
 ):
     try:
         full_path = os.path.join(project_path, path)
-        if os.path.exists(full_path):
-            if os.path.isdir(full_path):
+        if await aiofiles.os.path.exists(full_path):
+            if await aiofiles.os.path.isdir(full_path):
+                # Use shutil.rmtree for directories as aiofiles doesn't have a recursive delete
+                # Consider adding a custom async recursive delete if performance is critical
                 shutil.rmtree(full_path)
             else:
-                os.remove(full_path)
+                await aiofiles.os.remove(full_path)
             return {"message": f"Successfully deleted {path}"}
         else:
             raise HTTPException(
@@ -34,11 +41,22 @@ async def delete_file(
 
 @router.get("/api/files")
 async def get_files(
+    request: Request, # Need request to access project_path if not using Depends
+    path: str = None, # Optional path parameter for lazy loading
+    lazy: bool = False, # Optional lazy parameter
     project_path: str = Depends(get_project_path)
 ):
-    tree = get_directory_tree(project_path)
-    # print(tree)
-    return {"tree": tree}
+    try:
+        # Pass path and lazy parameters if provided in the query
+        query_params = request.query_params
+        path_param = query_params.get("path")
+        lazy_param = query_params.get("lazy", "false").lower() == "true"
+
+        tree = await get_directory_tree_async(project_path, path=path_param, lazy=lazy_param)
+        return {"tree": tree}
+    except Exception as e:
+        # Log the error e
+        raise HTTPException(status_code=500, detail=f"Failed to get directory tree: {str(e)}")
 
 @router.put("/api/file/{path:path}")
 async def update_file(
@@ -54,15 +72,22 @@ async def update_file(
                 status_code=400, detail="Content is required")
 
         full_path = os.path.join(project_path, path)
+        dir_path = os.path.dirname(full_path)
+
+        # Ensure the directory exists asynchronously
+        if not await aiofiles.os.path.exists(dir_path):
+            await aiofiles.os.makedirs(dir_path, exist_ok=True)
+        elif not await aiofiles.os.path.isdir(dir_path):
+             raise HTTPException(status_code=400, detail=f"Path conflict: {dir_path} exists but is not a directory.")
 
-        # Ensure the directory exists
-        os.makedirs(os.path.dirname(full_path), exist_ok=True)
 
-        # Write the file content
-        with open(full_path, 'w', encoding='utf-8') as f:
-            f.write(content)
+        # Write the file content asynchronously
+        async with aiofiles.open(full_path, 'w', encoding='utf-8') as f:
+            await f.write(content)
 
         return {"message": f"Successfully updated {path}"}
+    except HTTPException as http_exc: # Re-raise HTTP exceptions
+        raise http_exc
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -71,7 +96,7 @@ async def get_file_content(
     path: str,
     project_path: str = Depends(get_project_path)
 ):
-    content = read_file_content(project_path, path)
+    content = await read_file_content_async(project_path, path)
     if content is None:
         raise HTTPException(
             status_code=404, detail="File not found or cannot be read")

auto_coder_web/expert_routers/history_router.py

@@ -87,7 +87,7 @@ async def validate_and_load_history(
         历史记录查询列表
     """
     # 定义在线程中执行的函数
-    def load_history_task(project_path, max_history_count=50):
+    def load_history_task(project_path, max_history_count=10):
         try:
             # 过滤出聊天动作事件
             action_manager = ActionYmlFileManager(project_path)

auto_coder_web/file_manager.py

@@ -1,5 +1,8 @@
 import os
 import json
+import asyncio
+import aiofiles
+import aiofiles.os
 from typing import List, Dict, Any, Optional
 
 
@@ -100,15 +103,187 @@ def get_directory_tree(root_path: str, path: str = None, lazy: bool = False) ->
             return build_tree(target_path)
         return []
     
-    # If no path provided, build tree from root with lazy loading
+    # If no path provided, build tree from root 
+    # If lazy is True, only immediate children are returned.
+    # If lazy is False, the full tree is built recursively.
+    # If no path provided, build tree from root 
+    # If lazy is True, only immediate children are returned.
+    # If lazy is False, the full tree is built recursively.
     return build_tree(root_path)
 
 
+async def get_directory_tree_async(root_path: str, path: str = None, lazy: bool = False) -> List[Dict[str, Any]]:
+    """
+    Asynchronously generate a directory tree structure using aiofiles while ignoring common directories and files
+    that should not be included in version control or IDE specific files.
+
+    Args:
+        root_path: The root directory path to start traversing from
+        path: Optional path relative to root_path to get children for
+        lazy: If True, only return immediate children for directories
+
+    Returns:
+        A list of dictionaries representing the directory tree structure
+    """
+    # Common directories and files to ignore (same as synchronous version)
+    IGNORE_PATTERNS = {
+        # Version control
+        '.git', '.svn', '.hg',
+        # Dependencies
+        'node_modules', 'venv', '.venv', 'env', '.env',
+        '__pycache__', '.pytest_cache',
+        # Build outputs
+        'dist', 'build', 'target',
+        # IDE specific
+        '.idea', '.vscode', '.vs',
+        # OS specific
+        '.DS_Store', 'Thumbs.db',
+        # Other common patterns
+        'coverage', '.coverage', 'htmlcov',
+        # Hidden directories (start with .) - Note: This logic is slightly different now
+        # '.hidden_file', '.hidden_dir' # Example explicit hidden items if needed
+    }
+
+    def should_ignore(name: str) -> bool:
+        """Check if a file or directory should be ignored"""
+        # Ignore hidden files/directories (starting with '.')
+        if name.startswith('.'):
+            return True
+        # Ignore exact matches
+        return name in IGNORE_PATTERNS
+
+    async def build_tree(current_path: str) -> List[Dict[str, Any]]:
+        """Recursively build the directory tree asynchronously using aiofiles"""
+        items = []
+        try:
+            # Use aiofiles.os.listdir
+            child_names = await aiofiles.os.listdir(current_path)
+            tasks = []
+            for name in sorted(child_names):
+                if should_ignore(name):
+                    continue
+                tasks.append(process_item(current_path, name))
+            
+            results = await asyncio.gather(*tasks)
+            items = [item for item in results if item is not None] # Filter out None results from ignored items or errors
+
+        except PermissionError:
+            # Skip directories we don't have permission to read
+            pass
+        except FileNotFoundError:
+            # Handle case where directory doesn't exist during processing
+            pass
+
+        return items
+
+    async def process_item(current_path: str, name: str) -> Optional[Dict[str, Any]]:
+        """Process a single directory item asynchronously"""
+        try:
+            full_path = os.path.join(current_path, name)
+            relative_path = os.path.relpath(full_path, root_path)
+
+            # Use aiofiles.os.path.isdir
+            is_dir = await aiofiles.os.path.isdir(full_path)
+
+            if is_dir:
+                if lazy:
+                    # For lazy loading, check if directory has any visible children asynchronously
+                    has_children = False
+                    try:
+                        # Use aiofiles.os.listdir
+                        for child_name in await aiofiles.os.listdir(full_path):
+                            if not should_ignore(child_name):
+                                has_children = True
+                                break
+                    except (PermissionError, FileNotFoundError):
+                        pass # Ignore errors checking for children, assume no visible children
+
+                    return {
+                        'title': name,
+                        'key': relative_path,
+                        'children': [],  # Empty children array for lazy loading
+                        'isLeaf': False,
+                        'hasChildren': has_children
+                    }
+                else:
+                    children = await build_tree(full_path)
+                    if children:  # Only add non-empty directories
+                        return {
+                            'title': name,
+                            'key': relative_path,
+                            'children': children,
+                            'isLeaf': False,
+                            'hasChildren': True
+                        }
+                    else: # Represent empty directories as leaves if not lazy loading
+                         return {
+                            'title': name,
+                            'key': relative_path,                            
+                            'isLeaf': True,
+                            'hasChildren': False
+                        }
+            else:
+                return {
+                    'title': name,
+                    'key': relative_path,
+                    'isLeaf': True,
+                    'hasChildren': False
+                }
+        except (PermissionError, FileNotFoundError):
+             # Skip items we can't process
+            return None
+
+
+    target_path = root_path
+    if path:
+        # If path is provided, get children of that specific directory
+        potential_target_path = os.path.join(root_path, path)
+        # Use aiofiles.os.path.isdir for the check
+        if await aiofiles.os.path.isdir(potential_target_path):
+             target_path = potential_target_path
+        else:
+            return [] # Path does not point to a valid directory
+
+    return await build_tree(target_path)
+
+
 def read_file_content(project_path: str, file_path: str) -> str:
     """Read the content of a file"""
     try:
         full_path = os.path.join(project_path, file_path)
-        with open(full_path, 'r', encoding='utf-8') as f:
+        # Check if the path exists and is a file before attempting to open
+        if not os.path.exists(full_path) or not os.path.isfile(full_path):
+            return None # Or raise a specific error like FileNotFoundError
+        with open(full_path, 'r', encoding='utf-8', errors='ignore') as f: # Added errors='ignore' for robustness
             return f.read()
-    except (IOError, UnicodeDecodeError):
+    except IOError: # Catching only IOError, as UnicodeDecodeError is handled by errors='ignore'
+        # Log the error here if needed
+        return None
+    except Exception as e:
+        # Catch any other unexpected error
+        # Log e
+        return None
+
+
+async def read_file_content_async(project_path: str, file_path: str) -> Optional[str]:
+    """Asynchronously read the content of a file using aiofiles"""
+    full_path = os.path.join(project_path, file_path)
+    try:
+        # Check if the path exists and is a file before attempting to open using aiofiles.os
+        path_exists = await aiofiles.os.path.exists(full_path)
+        is_file = await aiofiles.os.path.isfile(full_path)
+
+        if not path_exists or not is_file:
+             return None # Or raise a specific error like FileNotFoundError
+
+        # Use aiofiles for asynchronous file reading
+        async with aiofiles.open(full_path, mode='r', encoding='utf-8', errors='ignore') as f:
+            content = await f.read()
+        return content
+    except (IOError, FileNotFoundError): # Catch file-related errors
+        # Log the error here if needed
+        return None
+    except Exception as e:
+        # Catch any other unexpected error during path checks or reading
+        # Log e
         return None

auto_coder_web/proxy.py

@@ -19,7 +19,7 @@ import sys
 from auto_coder_web.terminal import terminal_manager
 from autocoder.common import AutoCoderArgs
 from auto_coder_web.auto_coder_runner_wrapper import AutoCoderRunnerWrapper
-from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router
+from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router,mcp_router
 from auto_coder_web.expert_routers import history_router
 from auto_coder_web.common_router import completions_router, file_router, auto_coder_conf_router, chat_list_router, file_group_router, model_router, compiler_router
 from rich.console import Console
@@ -101,6 +101,7 @@ class ProxyServer:
         self.app.include_router(upload_router.router)
         self.app.include_router(rag_router.router)
         self.app.include_router(editable_preview_router.router)
+        self.app.include_router(mcp_router.router)
         # self.app.include_router(rag_router.router)
 
         @self.app.on_event("shutdown")

auto_coder_web/routers/auto_router.py

@@ -87,7 +87,7 @@ async def auto_command(request: AutoCommandRequest, project_path: str = Depends(
         except Exception as e:
             logger.error(f"Error executing auto command {file_id}: {str(e)}")
             get_event_manager(event_file).write_error(
-                EventContentCreator.create_error("500", "error", str(e)).to_dict()
+                EventContentCreator.create_error(error_code="500", error_message=str(e), details={}).to_dict()
             )
     
     # 创建并启动线程

auto_coder_web/routers/chat_router.py

@@ -80,7 +80,7 @@ async def chat_command(request: ChatCommandRequest, project_path: str = Depends(
         except Exception as e:
             logger.error(f"Error executing chat command {file_id}: {str(e)}")
             get_event_manager(event_file).write_error(
-                EventContentCreator.create_error("500", "error", str(e)).to_dict()
+                EventContentCreator.create_error(error_code="500", error_message=str(e), details={}).to_dict()
             )
     
     # 创建并启动线程
@@ -313,7 +313,7 @@ async def cancel_task(request: CancelTaskRequest, project_path: str = Depends(ge
                 # 写入取消事件
                 event_manager.write_error(
                     EventContentCreator.create_error(
-                        "499", "cancelled", "Task cancelled by user").to_dict()
+                        error_code="499", error_message="cancelled", details={}).to_dict()
                 )
                 
                 logger.info(f"Task {request.event_file_id} cancelled successfully")

auto_coder_web/routers/coding_router.py

@@ -146,7 +146,7 @@ async def coding_command(request: CodingCommandRequest, project_path: str = Depe
         except Exception as e:
             logger.error(f"Error executing coding command {file_id}: {str(e)}")
             get_event_manager(event_file).write_error(
-                EventContentCreator.create_error("500", "error", str(e)).to_dict()
+                EventContentCreator.create_error(error_code="500", error_message=str(e), details={}).to_dict()
             )
     
     # 创建并启动线程
@@ -371,7 +371,7 @@ async def cancel_task(request: CancelTaskRequest, project_path: str = Depends(ge
         def cancel_in_thread():
             try:
                 # 设置全局取消标志
-                global_cancel.set_cancel(request.event_file_id)
+                global_cancel.set()
                 
                 # 获取事件管理器
                 event_manager = get_event_manager(event_file)
@@ -379,7 +379,7 @@ async def cancel_task(request: CancelTaskRequest, project_path: str = Depends(ge
                 # 写入取消事件
                 event_manager.write_error(
                     EventContentCreator.create_error(
-                        "499", "cancelled", "Task cancelled by user").to_dict()
+                        error_code="499", error_message="cancelled", details={}).to_dict()
                 )
                 
                 logger.info(f"Task {request.event_file_id} cancelled successfully")

auto_coder_web/routers/commit_router.py

@@ -50,7 +50,7 @@ def get_repo(project_path: str) -> Repo:
 
 @router.get("/api/commits")
 async def get_commits(
-    limit: int = 50, 
+    limit: int = 10, 
     skip: int = 0, 
     project_path: str = Depends(get_project_path)
 ):

auto_coder_web/routers/config_router.py

@@ -1,5 +1,6 @@
 import os
 import json
+import aiofiles
 from fastapi import APIRouter, HTTPException, Request, Depends
 from pydantic import BaseModel
 from pathlib import Path
@@ -27,16 +28,20 @@ async def load_config(config_path: Path) -> UIConfig:
         return UIConfig()
     
     try:
-        with open(config_path, 'r') as f:
-            config_data = json.load(f)
+        async with aiofiles.open(config_path, mode='r', encoding='utf-8') as f:
+            content = await f.read()
+            config_data = json.loads(content)
             return UIConfig(**config_data)
+    except FileNotFoundError:
+        return UIConfig()
     except json.JSONDecodeError:
+        # Handle cases where the file is corrupted or empty
         return UIConfig()
 
 async def save_config(config: UIConfig, config_path: Path):
     """保存配置"""
-    with open(config_path, 'w') as f:
-        json.dump(config.dict(), f)
+    async with aiofiles.open(config_path, mode='w', encoding='utf-8') as f:
+        await f.write(json.dumps(config.dict()))
 
 @router.get("/api/config/ui/mode")
 async def get_ui_mode(request: Request):