auto-coder-web 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

auto_coder_web/auto_coder_runner_wrapper.py

@@ -45,7 +45,11 @@ class AutoCoderRunnerWrapper:
         return auto_command(command,params)
     
     def configure_wrapper(self,conf: str, skip_print=False ):
-        return configure(conf, skip_print)
+        return configure(conf, skip_print)    
+
+    def get_conf_wrapper(self):
+        memory = get_memory()
+        return memory["conf"]
 
 
     def coding_wapper(self,query):

auto_coder_web/common_router/auto_coder_conf_router.py

@@ -1,42 +1,39 @@
 from fastapi import APIRouter, Request, HTTPException, Depends
+from autocoder.auto_coder_runner import get_memory, configure
 
 router = APIRouter()
 
-async def get_auto_coder_runner(request: Request):
-    """获取AutoCoderRunner实例作为依赖"""
-    return request.app.state.auto_coder_runner
 
 @router.get("/api/conf")
-async def get_conf(
-    auto_coder_runner = Depends(get_auto_coder_runner)
-):
+async def get_conf():
     """获取配置信息"""
-    return {"conf": auto_coder_runner.get_config()}
+    memory = get_memory()
+    return {"conf": memory["conf"]}
+
 
 @router.post("/api/conf")
 async def config(
     request: Request,
-    auto_coder_runner = Depends(get_auto_coder_runner)
 ):
     """更新配置信息"""
     data = await request.json()
     try:
         for key, value in data.items():
-            auto_coder_runner.configure(key, str(value))
+            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,
-    auto_coder_runner = Depends(get_auto_coder_runner)
+    key: str
 ):
     """删除配置项"""
     try:
-        result = auto_coder_runner.drop_config(key)
-        return result
+        configure(f"/drop {key}")
+        return {"status": "success"}
     except ValueError as e:
         raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e)) 
+        raise HTTPException(status_code=400, detail=str(e))

auto_coder_web/common_router/chat_list_router.py

@@ -1,31 +1,39 @@
 import os
 import json
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Request, Depends
 import aiofiles
 from auto_coder_web.types import ChatList
 
+
+async def get_project_path(request: Request) -> str:
+    """
+    从FastAPI请求上下文中获取项目路径
+    """
+    return request.app.state.project_path
+
 router = APIRouter()
 
+
 @router.post("/api/chat-lists/save")
-async def save_chat_list(chat_list: ChatList):
+async def save_chat_list(chat_list: ChatList, project_path: str = Depends(get_project_path)):
     try:
-        chat_lists_dir = os.path.join(
-            ".auto-coder", "auto-coder.web", "chat-lists")
+        chat_lists_dir = os.path.join(project_path,
+                                      ".auto-coder", "auto-coder.web", "chat-lists")
         os.makedirs(chat_lists_dir, exist_ok=True)
 
-        file_path = os.path.join(
-            chat_lists_dir, f"{chat_list.name}.json")
+        file_path = os.path.join(chat_lists_dir, f"{chat_list.name}.json")
         async with aiofiles.open(file_path, 'w') as f:
-            await f.write(json.dumps({"messages": chat_list.messages}, indent=2))
+            await f.write(json.dumps({"messages": chat_list.messages}, indent=2, ensure_ascii=False))
         return {"status": "success", "message": f"Chat list {chat_list.name} saved successfully"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @router.get("/api/chat-lists")
-async def get_chat_lists():
+async def get_chat_lists(project_path: str = Depends(get_project_path)):
     try:
         chat_lists_dir = os.path.join(
-            ".auto-coder", "auto-coder.web", "chat-lists")
+            project_path, ".auto-coder", "auto-coder.web", "chat-lists")
         os.makedirs(chat_lists_dir, exist_ok=True)
 
         # Get files with their modification times
@@ -45,11 +53,12 @@ async def get_chat_lists():
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @router.get("/api/chat-lists/{name}")
-async def get_chat_list(name: str):
+async def get_chat_list(name: str, project_path: str = Depends(get_project_path)):
     try:
         file_path = os.path.join(
-            ".auto-coder", "auto-coder.web", "chat-lists", f"{name}.json")
+            project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{name}.json")
         if not os.path.exists(file_path):
             raise HTTPException(
                 status_code=404, detail=f"Chat list {name} not found")
@@ -60,11 +69,12 @@ async def get_chat_list(name: str):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @router.delete("/api/chat-lists/{name}")
-async def delete_chat_list(name: str):
+async def delete_chat_list(name: str, project_path: str = Depends(get_project_path)):
     try:
         file_path = os.path.join(
-            ".auto-coder", "auto-coder.web", "chat-lists", f"{name}.json")
+            project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{name}.json")
         if not os.path.exists(file_path):
             raise HTTPException(
                 status_code=404, detail=f"Chat list {name} not found")
@@ -72,4 +82,4 @@ async def delete_chat_list(name: str):
         os.remove(file_path)
         return {"status": "success", "message": f"Chat list {name} deleted successfully"}
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e)) 
+        raise HTTPException(status_code=500, detail=str(e))

auto_coder_web/common_router/completions_router.py

@@ -1,22 +1,135 @@
 import os
+import glob
+import json
+from typing import List
+from pydantic import BaseModel
 from fastapi import APIRouter, Query, Request, Depends
 from auto_coder_web.types import CompletionItem, CompletionResponse
+from autocoder.index.symbols_utils import (
+    extract_symbols,
+    symbols_info_to_str,
+    SymbolsInfo,
+    SymbolType,
+)
+
+from autocoder.auto_coder_runner import get_memory
+import json
+import asyncio
+
 
 router = APIRouter()
 
+class SymbolItem(BaseModel):
+    symbol_name: str
+    symbol_type: SymbolType
+    file_name: str
+
 async def get_auto_coder_runner(request: Request):
     """获取AutoCoderRunner实例作为依赖"""
     return request.app.state.auto_coder_runner
 
+
+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]:
+    memory = get_memory()
+    default_exclude_dirs = [".git", "node_modules", "dist", "build", "__pycache__",".venv"]
+    active_file_list = memory["current_files"]["files"]
+
+    project_root = project_path
+    matched_files = []
+
+    if len(patterns) == 1 and patterns[0] == "":
+        return active_file_list
+
+    for pattern in patterns:
+        for file_path in active_file_list:
+            if pattern in os.path.basename(file_path):
+                matched_files.append(file_path)
+
+    final_exclude_dirs = default_exclude_dirs + \
+        memory.get("exclude_dirs", [])
+
+    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):
+                    abs_path = os.path.abspath(file_path)
+                    if not any(
+                        exclude_dir in abs_path.split(os.sep)
+                        for exclude_dir in final_exclude_dirs
+                    ):
+                        matched_files.append(abs_path)
+        else:
+            is_added = False
+            for root, dirs, files in os.walk(project_root, followlinks=True):
+                dirs[:] = [d for d in dirs if d not in final_exclude_dirs]
+                if pattern in files:
+                    matched_files.append(os.path.join(root, pattern))
+                    is_added = True
+                else:
+                    for file in files:
+                        if pattern in os.path.join(root, file):
+                            matched_files.append(os.path.join(root, file))
+                            is_added = True
+            if not is_added:
+                matched_files.append(pattern)
+
+    return list(set(matched_files))
+
+def get_symbol_list(project_path: str) -> List[SymbolItem]:
+    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)
+    else:
+        index_data = {}
+
+    for item in index_data.values():
+        symbols_str = item["symbols"]
+        module_name = item["module_name"]
+        info1 = extract_symbols(symbols_str)
+        for name in info1.classes:
+            list_of_symbols.append(
+                SymbolItem(
+                    symbol_name=name,
+                    symbol_type=SymbolType.CLASSES,
+                    file_name=module_name,
+                )
+            )
+        for name in info1.functions:
+            list_of_symbols.append(
+                SymbolItem(
+                    symbol_name=name,
+                    symbol_type=SymbolType.FUNCTIONS,
+                    file_name=module_name,
+                )
+            )
+        for name in info1.variables:
+            list_of_symbols.append(
+                SymbolItem(
+                    symbol_name=name,
+                    symbol_type=SymbolType.VARIABLES,
+                    file_name=module_name,
+                )
+            )
+    return list_of_symbols
+
 @router.get("/api/completions/files")
 async def get_file_completions(
     name: str = Query(...),
-    auto_coder_runner = Depends(get_auto_coder_runner)
+    project_path: str = Depends(get_project_path)
 ):
     """获取文件名补全"""
-    matches = auto_coder_runner.find_files_in_project([name])
+    patterns = [name]
+    matches = await asyncio.to_thread(find_files_in_project, patterns,project_path)
     completions = []
-    project_root = auto_coder_runner.project_path
+    project_root = project_path
     for file_name in matches:
         path_parts = file_name.split(os.sep)
         # 只显示最后三层路径，让显示更简洁
@@ -35,19 +148,19 @@ async def get_file_completions(
 @router.get("/api/completions/symbols")
 async def get_symbol_completions(
     name: str = Query(...),
-    auto_coder_runner = Depends(get_auto_coder_runner)
+    project_path: str = Depends(get_project_path)
 ):
     """获取符号补全"""
-    symbols = auto_coder_runner.get_symbol_list()
+    symbols = await asyncio.to_thread(get_symbol_list, project_path)
     matches = []
 
     for symbol in symbols:
         if name.lower() in symbol.symbol_name.lower():
             relative_path = os.path.relpath(
-                symbol.file_name, auto_coder_runner.project_path)
+                symbol.file_name, project_path)
             matches.append(CompletionItem(
                 name=symbol.symbol_name,
-                path=f"{symbol.symbol_name} ({relative_path}/{symbol.symbol_type.value})",
+                path=relative_path,
                 display=f"{symbol.symbol_name}(location: {relative_path})"
             ))
     return CompletionResponse(completions=matches) 

auto_coder_web/common_router/file_group_router.py

@@ -1,40 +1,116 @@
+from typing import List
+import asyncio
 from fastapi import APIRouter, Request, HTTPException, Depends
 from autocoder.agent.auto_filegroup import AutoFileGroup
 from autocoder.utils import operate_config_api
+from autocoder.auto_coder_runner import get_memory,save_memory, load_memory
+import json
+import os
 
 router = APIRouter()
 
-async def get_file_group_manager(request: Request):
-    """获取FileGroupManager实例作为依赖"""
-    return request.app.state.file_group_manager
 
 async def get_project_path(request: Request):
     """获取项目路径作为依赖"""
     return request.app.state.project_path
 
-async def get_auto_coder_runner(request: Request):
-    """获取AutoCoderRunner实例作为依赖"""
-    return request.app.state.auto_coder_runner
+
+def _create_file_group(group_name: str, description: str):
+    memory = get_memory()
+    if group_name in memory["current_files"]["groups"]:
+        return None
+
+    memory["current_files"]["groups"][group_name] = []
+
+    if "groups_info" not in memory["current_files"]:
+        memory["current_files"]["groups_info"] = {}
+
+    memory["current_files"]["groups_info"][group_name] = {
+        "query_prefix": description
+    }
+    save_memory()
+
+
+def _add_files_to_group(project_path: str, name: str, files: List[str]):
+    memory = get_memory()
+    for file in files:
+        memory["current_files"]["groups"][name].append(
+            os.path.join(project_path, file))
+    save_memory()
+
+
+def _remove_file_from_group(project_path: str, name: str, files: List[str]):
+    memory = get_memory()
+    for file in files:
+        memory["current_files"]["groups"][name].remove(
+            os.path.join(project_path, file))
+    save_memory()
+
+
+def _update_group_description(name: str, description: str):
+    memory = get_memory()
+    memory["current_files"]["groups_info"][name]["query_prefix"] = description
+    save_memory()
+
+
+def _get_groups(project_path: str):
+    memory = get_memory()     
+    v = [
+        {
+            "name": group_name,
+            "files": memory["current_files"]["groups"][group_name],
+            "description": memory["current_files"]["groups_info"][group_name]["query_prefix"]
+        } for group_name in memory["current_files"]["groups"]
+    ]
+    return v
+
+def _switch_groups(group_names: List[str], file_paths: List[str] = None):
+    memory = get_memory()
+    new_files = []
+    for group_name in group_names:
+        files = memory["current_files"]["groups"][group_name]
+        new_files.extend(files)
+    
+    # Add individual file paths if provided
+    if file_paths:
+        for file_path in file_paths:
+            # Only add unique paths
+            if file_path not in new_files:
+                new_files.append(file_path)
+    
+    memory["current_files"]["files"] = new_files
+    memory["current_files"]["current_groups"] = group_names
+    save_memory()
+
+
+def _delete_file_group(project_path: str, group_name: str):
+    memory = get_memory()
+    if group_name not in memory["current_files"]["groups"]:
+        return None
+    del memory["current_files"]["groups"][group_name]
+    if group_name in memory["current_files"]["groups_info"]:
+        del memory["current_files"]["groups_info"][group_name]
+    save_memory()
+
 
 @router.post("/api/file-groups")
 async def create_file_group(
-    request: Request,
-    file_group_manager = Depends(get_file_group_manager)
+    request: Request
 ):
     data = await request.json()
-    name = data.get("name")
+    group_name = data.get("name")
     description = data.get("description", "")
-    group = await file_group_manager.create_group(name, description)
-    return group
+    await asyncio.to_thread(_create_file_group, group_name, description)
+    return {"status": "success", "message": f"Created group: {group_name}"}
+
 
 @router.post("/api/file-groups/auto")
 async def auto_create_groups(
     request: Request,
-    file_group_manager = Depends(get_file_group_manager),
-    project_path: str = Depends(get_project_path),
-    auto_coder_runner = Depends(get_auto_coder_runner)
-):            
+    project_path: str = Depends(get_project_path)
+):
     try:
+        memory = get_memory()
         data = await request.json()
         file_size_limit = data.get("file_size_limit", 100)
         skip_diff = data.get("skip_diff", False)
@@ -42,7 +118,7 @@ async def auto_create_groups(
 
         # Create AutoFileGroup instance
         auto_grouper = AutoFileGroup(
-            operate_config_api.get_llm(auto_coder_runner.memory),
+            operate_config_api.get_llm(memory),
             project_path,
             skip_diff=skip_diff,
             file_size_limit=file_size_limit,
@@ -54,67 +130,80 @@ async def auto_create_groups(
 
         # Create groups using file_group_manager
         for group in groups:
-            await file_group_manager.create_group(
-                name=group.name,
-                description=group.description
-            )
+            await asyncio.to_thread(_create_file_group,
+                                    name=group.name,
+                                    description=group.description
+                                    )
             # Add files to the group
-            await file_group_manager.add_files_to_group(
-                group.name,
-                group.urls
-            )
+            await asyncio.to_thread(_add_files_to_group,
+                                    group.name,
+                                    group.urls
+                                    )
 
         return {"status": "success", "message": f"Created {len(groups)} groups"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
 @router.post("/api/file-groups/switch")
 async def switch_file_groups(
     request: Request,
-    file_group_manager = Depends(get_file_group_manager)
+    project_path: str = Depends(get_project_path)
 ):
     data = await request.json()
     group_names = data.get("group_names", [])
-    result = await file_group_manager.switch_groups(group_names)
-    return result
+    file_paths = data.get("file_paths", [])
+    
+    # Convert relative file paths to absolute paths
+    absolute_file_paths = []
+    for file_path in file_paths:
+        absolute_path = os.path.join(project_path, file_path)
+        absolute_file_paths.append(absolute_path)
+    
+    await asyncio.to_thread(_switch_groups, group_names, absolute_file_paths)
+    return {"status": "success", "message": f"Switched to groups: {group_names} and additional files"}
+
 
 @router.delete("/api/file-groups/{name}")
 async def delete_file_group(
     name: str,
-    file_group_manager = Depends(get_file_group_manager)
+    project_path: str = Depends(get_project_path)
 ):
-    await file_group_manager.delete_group(name)
-    return {"status": "success"}
+    await asyncio.to_thread(_delete_file_group, project_path, name)
+    return {"status": "success", "message": f"Deleted group: {name}"}
+
 
 @router.post("/api/file-groups/{name}/files")
 async def add_files_to_group(
-    name: str, 
+    name: str,
     request: Request,
-    file_group_manager = Depends(get_file_group_manager)
+    project_path: str = Depends(get_project_path)
 ):
     data = await request.json()
     files = data.get("files", [])
     description = data.get("description")
     if description is not None:
-        group = await file_group_manager.update_group_description(name, description)
+        await asyncio.to_thread(_update_group_description, name, description)
     else:
-        group = await file_group_manager.add_files_to_group(name, files)
-    return group
+        await asyncio.to_thread(_add_files_to_group, project_path, name, files)
+    return {"status": "success", "message": f"Added files to group: {name}"}
+
 
 @router.delete("/api/file-groups/{name}/files")
 async def remove_files_from_group(
-    name: str, 
+    name: str,
     request: Request,
-    file_group_manager = Depends(get_file_group_manager)
+    project_path: str = Depends(get_project_path)
 ):
     data = await request.json()
     files = data.get("files", [])
-    group = await file_group_manager.remove_files_from_group(name, files)
-    return group
+    await asyncio.to_thread(_remove_file_from_group, project_path, name, files)
+    return {"status": "success", "message": f"Removed files from group: {name}"}
+
 
 @router.get("/api/file-groups")
 async def get_file_groups(
-    file_group_manager = Depends(get_file_group_manager)
+    project_path: str = Depends(get_project_path)
 ):
-    groups = await file_group_manager.get_groups()
-    return {"groups": groups} 
+    groups = await asyncio.to_thread(_get_groups, project_path)
+    return {"groups": groups}

auto_coder_web/common_router/file_router.py

@@ -37,6 +37,7 @@ async def get_files(
     project_path: str = Depends(get_project_path)
 ):
     tree = get_directory_tree(project_path)
+    # print(tree)
     return {"tree": tree}
 
 @router.put("/api/file/{path:path}")

auto_coder_web/lang.py

@@ -0,0 +1,35 @@
+import locale
+from byzerllm.utils import format_str_jinja2
+
+MESSAGES = {
+    "project_not_initialized": {
+        "en":"Warning: Project not initialized.",
+        "zh":"警告：项目未初始化。"
+    },
+    "run_auto_coder_chat": {
+        "en":"Please run 'auto-coder.chat' to initialize the project first.",
+        "zh":"请先运行 'auto-coder.chat' 来初始化项目。"
+    },
+    "human_as_model_warning": {
+        "en":"Warning: Project is configured to use human as model, auto-coder.web will not work, we will set human_as_model to false",
+        "zh":"警告：项目配置为使用人类作为模型，auto-coder.web 将无法工作，我们将设置 human_as_model 为 false"
+    }    
+}
+
+
+def get_system_language():
+    try:
+        return locale.getdefaultlocale()[0][:2]
+    except:
+        return 'en'
+
+
+def get_message(key):
+    lang = get_system_language()
+    if key in MESSAGES:
+        return MESSAGES[key].get(lang, MESSAGES[key].get("en", ""))
+    return ""
+
+
+def get_message_with_format(msg_key: str, **kwargs):
+    return format_str_jinja2(get_message(msg_key), **kwargs)