auto-coder-web 0.1.89__tar.gz → 0.1.91__tar.gz

{auto_coder_web-0.1.89 → auto_coder_web-0.1.91}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: auto_coder_web
-Version: 0.1.89
+Version: 0.1.91
 Summary: auto-coder.web: A Python Project
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
-Requires-Dist: auto-coder>=0.1.359
+Requires-Dist: auto-coder>=0.1.360
 Requires-Dist: aiofiles
 Requires-Dist: psutil
 Requires-Dist: watchdog

{auto_coder_web-0.1.89 → auto_coder_web-0.1.91}/src/auto_coder_web/common_router/completions_router.py

@@ -1,6 +1,7 @@
 import os
 import glob
 import json
+import fnmatch
 from typing import List
 from pydantic import BaseModel
 from fastapi import APIRouter, Query, Request, Depends
@@ -13,12 +14,15 @@ from autocoder.index.symbols_utils import (
 )
 
 from autocoder.auto_coder_runner import get_memory
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
+from autocoder.common.directory_cache.cache import DirectoryCache, initialize_cache
 import json
 import asyncio
 import aiofiles
 import aiofiles.os
+import logging
 
-
+logger = logging.getLogger(__name__)
 router = APIRouter()
 
 class SymbolItem(BaseModel):
@@ -35,67 +39,57 @@ async def get_project_path(request: Request):
     """获取项目路径作为依赖"""
     return request.app.state.project_path    
 
-def find_files_in_project(patterns: List[str], project_path: str) -> List[str]:
+async def find_files_in_project(patterns: List[str], project_path: str) -> List[str]:
     memory = get_memory()
-    default_exclude_dirs = [".git", "node_modules", "dist", "build", "__pycache__", ".venv", ".auto-coder"]
     active_file_list = memory["current_files"]["files"]
-    final_exclude_dirs = default_exclude_dirs + memory.get("exclude_dirs", [])
     project_root = project_path
     
-    def should_exclude_path(path: str) -> bool:
-        """检查路径是否应该被排除（路径中包含排除目录或以.开头的目录/文件）"""
-        # 处理相对/绝对路径
-        rel_path = path
-        if os.path.isabs(path):
-            try:
-                rel_path = os.path.relpath(path, project_root)
-            except ValueError:
-                rel_path = path
-                
-        # 检查文件或目录本身是否以.开头
-        if os.path.basename(rel_path).startswith('.'):
-            return True
-            
-        # 检查路径中是否包含排除目录
-        path_parts = rel_path.split(os.sep)
-        return any(part in final_exclude_dirs or part.startswith('.') for part in path_parts)
-
+    # 确保目录缓存已初始化
+    try:
+        cache = DirectoryCache.get_instance(project_root)
+    except ValueError:
+        # 如果缓存未初始化，则初始化它
+        initialize_cache(project_root)
+        cache = DirectoryCache.get_instance()
+    
     # 如果没有提供有效模式，返回过滤后的活动文件列表
     if not patterns or (len(patterns) == 1 and patterns[0] == ""):
-        return [f for f in active_file_list if not should_exclude_path(f)]
+        # 使用缓存中的所有文件
+        all_files = await cache.query([])
+        # 合并活动文件列表和缓存文件
+        combined_files = set(all_files)
+        combined_files.update([f for f in active_file_list if not should_ignore(f)])
+        return list(combined_files)
 
     matched_files = set()  # 使用集合避免重复
-
+    
+    # 1. 首先从活动文件列表中匹配，这通常是最近编辑的文件
     for pattern in patterns:
-        # 1. 从活动文件列表中匹配
         for file_path in active_file_list:
-            if not should_exclude_path(file_path) and pattern in os.path.basename(file_path):
+            if not should_ignore(file_path) and pattern.lower() in os.path.basename(file_path).lower():
                 matched_files.add(file_path)
-        
-        # 2. 如果是通配符模式，使用glob
+    
+    # 2. 使用DirectoryCache进行高效查询
+    cache_patterns = []
+    for pattern in patterns:
+        # 处理通配符模式
         if "*" in pattern or "?" in pattern:
-            for file_path in glob.glob(pattern, recursive=True):
-                if os.path.isfile(file_path) and not should_exclude_path(file_path):
-                    matched_files.add(os.path.abspath(file_path))
-            continue
-        
-        # 3. 使用os.walk在文件系统中查找
-        for root, dirs, files in os.walk(project_root, followlinks=True):
-            # 过滤不需要遍历的目录
-            dirs[:] = [d for d in dirs if d not in final_exclude_dirs and not d.startswith('.')]
-            
-            if should_exclude_path(root):
-                continue
-            
-            # 查找匹配文件
-            for file in files:
-                if pattern in file:
-                    file_path = os.path.join(root, file)
-                    if not should_exclude_path(file_path):
-                        matched_files.add(file_path)
-        
-        # 4. 如果pattern本身是文件路径
-        if os.path.exists(pattern) and os.path.isfile(pattern) and not should_exclude_path(pattern):
+            cache_patterns.append(pattern)
+        else:
+            # 对于非通配符模式，我们添加一个通配符以进行部分匹配
+            cache_patterns.append(f"*{pattern}*")
+    
+    # 执行缓存查询
+    if cache_patterns:
+        try:
+            cache_results = await cache.query(cache_patterns)
+            matched_files.update(cache_results)
+        except Exception as e:
+            logger.error(f"Error querying directory cache: {e}", exc_info=True)
+    
+    # 3. 如果pattern本身是文件路径，直接添加
+    for pattern in patterns:
+        if os.path.exists(pattern) and os.path.isfile(pattern) and not should_ignore(pattern):
             matched_files.add(os.path.abspath(pattern))
 
     return list(matched_files)
@@ -153,11 +147,11 @@ async def get_file_completions(
 ):
     """获取文件名补全"""
     patterns = [name]
-    matches = await asyncio.to_thread(find_files_in_project, patterns,project_path)
+    # 直接调用异步函数，不需要使用asyncio.to_thread
+    matches = await find_files_in_project(patterns, project_path)
     completions = []
     project_root = project_path
     for file_name in matches:
-        # path_parts = file_name.split(os.sep)
         # 只显示最后三层路径，让显示更简洁
         display_name = os.path.basename(file_name)
         relative_path = os.path.relpath(file_name, project_root)

{auto_coder_web-0.1.89 → auto_coder_web-0.1.91}/src/auto_coder_web/common_router/file_router.py

@@ -14,6 +14,9 @@ import pathspec
 
 router = APIRouter()
 
+class CreateFileRequest(BaseModel):
+    content: str = ""
+
 DEFAULT_IGNORED_DIRS = ['.git', '.auto-coder', 'node_modules', '.mvn', '.idea', '__pycache__', '.venv', 'venv', 'dist', 'build', '.gradle']
 
 def load_ignore_spec(source_dir: str) -> Optional[pathspec.PathSpec]:
@@ -196,6 +199,69 @@ async def list_files_in_directory(
     return result
 
 
+@router.post("/api/file/{path:path}")
+async def create_file(
+    path: str,
+    request: Request,
+    project_path: str = Depends(get_project_path)
+):
+    """
+    Create a new file at the specified path with optional initial content.
+    """
+    try:
+        data = await request.json()
+        content = data.get("content", "")
+
+        full_path = os.path.join(project_path, path)
+        dir_path = os.path.dirname(full_path)
+
+        # Check if file already exists
+        if await aiofiles.os.path.exists(full_path):
+            raise HTTPException(status_code=409, detail=f"File already exists at {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.")
+
+        # 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 created {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))
+
+@router.post("/api/directory/{path:path}")
+async def create_directory(
+    path: str,
+    project_path: str = Depends(get_project_path)
+):
+    """
+    Create a new directory at the specified path.
+    """
+    try:
+        full_path = os.path.join(project_path, path)
+        
+        # Check if directory already exists
+        if await aiofiles.os.path.exists(full_path):
+            if await aiofiles.os.path.isdir(full_path):
+                return {"message": f"Directory already exists at {path}"}
+            else:
+                raise HTTPException(status_code=409, detail=f"A file already exists at {path}")
+        
+        # Create the directory and any necessary parent directories
+        await aiofiles.os.makedirs(full_path, exist_ok=True)
+        
+        return {"message": f"Successfully created directory {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))
+
 @router.get("/api/search-in-files")
 async def search_in_files(
     query: str = Query(..., description="Search text"),

{auto_coder_web-0.1.89 → auto_coder_web-0.1.91}/src/auto_coder_web/proxy.py

@@ -75,6 +75,9 @@ class ProxyServer:
         self.app.mount(
             "/monaco-editor", StaticFiles(directory=os.path.join(self.resource_dir, "monaco-editor")), name="monaco-editor")
 
+        self.app.mount(
+            "/sounds", StaticFiles(directory=os.path.join(self.resource_dir, "sounds")), name="sounds")    
+
     def setup_routes(self):
         
         # Store project_path in app state for dependency injection

auto_coder_web-0.1.91/src/auto_coder_web/version.py

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