auto-coder-web 0.1.24__py3-none-any.whl → 0.1.26__py3-none-any.whl

auto_coder_web/auto_coder_runner_wrapper.py

@@ -46,6 +46,13 @@ class AutoCoderRunnerWrapper:
     
     def configure_wrapper(self,conf: str, skip_print=False ):
         return configure(conf, skip_print)
+
+
+    def coding_wapper(self,query):
+        return coding(query) 
+
+    def chat_wrapper(self,query):
+        return chat(query)          
         
     
     

auto_coder_web/common_router/auto_coder_conf_router.py

@@ -0,0 +1,39 @@
+from fastapi import APIRouter, Request, HTTPException, Depends
+from autocoder.auto_coder_runner import get_memory, configure
+
+router = APIRouter()
+
+
+@router.get("/api/conf")
+async def get_conf():
+    """获取配置信息"""
+    memory = get_memory()
+    return {"conf": memory["conf"]}
+
+
+@router.post("/api/conf")
+async def config(
+    request: Request,
+):
+    """更新配置信息"""
+    data = await request.json()
+    try:
+        for key, value in data.items():
+            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}")
+        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))

auto_coder_web/common_router/chat_list_router.py

@@ -0,0 +1,75 @@
+import os
+import json
+from fastapi import APIRouter, HTTPException
+import aiofiles
+from auto_coder_web.types import ChatList
+
+router = APIRouter()
+
+@router.post("/api/chat-lists/save")
+async def save_chat_list(chat_list: ChatList):
+    try:
+        chat_lists_dir = os.path.join(
+            ".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")
+        async with aiofiles.open(file_path, 'w') as f:
+            await f.write(json.dumps({"messages": chat_list.messages}, indent=2))
+        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():
+    try:
+        chat_lists_dir = os.path.join(
+            ".auto-coder", "auto-coder.web", "chat-lists")
+        os.makedirs(chat_lists_dir, exist_ok=True)
+
+        # Get files with their modification times
+        chat_lists = []
+        for file in os.listdir(chat_lists_dir):
+            if file.endswith('.json'):
+                file_path = os.path.join(chat_lists_dir, file)
+                mod_time = os.path.getmtime(file_path)
+                # Store tuple of (name, mod_time)
+                chat_lists.append((file[:-5], mod_time))
+
+        # Sort by modification time (newest first)
+        chat_lists.sort(key=lambda x: x[1], reverse=True)
+
+        # Return only the chat list names
+        return {"chat_lists": [name for name, _ in 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):
+    try:
+        file_path = os.path.join(
+            ".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")
+
+        async with aiofiles.open(file_path, 'r') as f:
+            content = await f.read()
+            return json.loads(content)
+    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):
+    try:
+        file_path = os.path.join(
+            ".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")
+
+        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)) 

auto_coder_web/common_router/completions_router.py

@@ -0,0 +1,53 @@
+import os
+from fastapi import APIRouter, Query, Request, Depends
+from auto_coder_web.types import CompletionItem, CompletionResponse
+
+router = APIRouter()
+
+async def get_auto_coder_runner(request: Request):
+    """获取AutoCoderRunner实例作为依赖"""
+    return request.app.state.auto_coder_runner
+
+@router.get("/api/completions/files")
+async def get_file_completions(
+    name: str = Query(...),
+    auto_coder_runner = Depends(get_auto_coder_runner)
+):
+    """获取文件名补全"""
+    matches = auto_coder_runner.find_files_in_project([name])
+    completions = []
+    project_root = auto_coder_runner.project_path
+    for file_name in matches:
+        path_parts = file_name.split(os.sep)
+        # 只显示最后三层路径，让显示更简洁
+        display_name = os.sep.join(
+            path_parts[-3:]) if len(path_parts) > 3 else file_name
+        relative_path = os.path.relpath(file_name, project_root)
+
+        completions.append(CompletionItem(
+            name=relative_path,  # 给补全项一个唯一标识
+            path=relative_path,  # 实际用于替换的路径
+            display=display_name,  # 显示的简短路径
+            location=relative_path  # 完整的相对路径信息
+        ))
+    return CompletionResponse(completions=completions)
+
+@router.get("/api/completions/symbols")
+async def get_symbol_completions(
+    name: str = Query(...),
+    auto_coder_runner = Depends(get_auto_coder_runner)
+):
+    """获取符号补全"""
+    symbols = auto_coder_runner.get_symbol_list()
+    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)
+            matches.append(CompletionItem(
+                name=symbol.symbol_name,
+                path=f"{symbol.symbol_name} ({relative_path}/{symbol.symbol_type.value})",
+                display=f"{symbol.symbol_name}(location: {relative_path})"
+            ))
+    return CompletionResponse(completions=matches) 

auto_coder_web/common_router/file_group_router.py

@@ -0,0 +1,192 @@
+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_project_path(request: Request):
+    """获取项目路径作为依赖"""
+    return request.app.state.project_path
+
+
+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]):
+    memory = get_memory()
+    new_files = []
+    for group_name in group_names:
+        files = memory["current_files"]["groups"][group_name]
+        new_files.extend(files)
+    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
+):
+    data = await request.json()
+    group_name = data.get("name")
+    description = data.get("description", "")
+    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,
+    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)
+        group_num_limit = data.get("group_num_limit", 10)
+
+        # Create AutoFileGroup instance
+        auto_grouper = AutoFileGroup(
+            operate_config_api.get_llm(memory),
+            project_path,
+            skip_diff=skip_diff,
+            file_size_limit=file_size_limit,
+            group_num_limit=group_num_limit
+        )
+
+        # Get groups
+        groups = auto_grouper.group_files()
+
+        # Create groups using file_group_manager
+        for group in groups:
+            await asyncio.to_thread(_create_file_group,
+                                    name=group.name,
+                                    description=group.description
+                                    )
+            # Add files to the group
+            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
+):
+    data = await request.json()
+    group_names = data.get("group_names", [])
+    await asyncio.to_thread(_switch_groups, group_names)
+    return {"status": "success", "message": f"Switched to groups: {group_names}"}
+
+
+@router.delete("/api/file-groups/{name}")
+async def delete_file_group(
+    name: str,
+    project_path: str = Depends(get_project_path)
+):
+    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,
+    request: Request,
+    project_path: str = Depends(get_project_path)
+):
+    data = await request.json()
+    files = data.get("files", [])
+    description = data.get("description")
+    if description is not None:
+        await asyncio.to_thread(_update_group_description, name, description)
+    else:
+        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,
+    request: Request,
+    project_path: str = Depends(get_project_path)
+):
+    data = await request.json()
+    files = data.get("files", [])
+    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(
+    project_path: str = Depends(get_project_path)
+):
+    groups = await asyncio.to_thread(_get_groups, project_path)
+    return {"groups": groups}

auto_coder_web/common_router/file_router.py

@@ -0,0 +1,79 @@
+import os
+import shutil
+from fastapi import APIRouter, Request, HTTPException, Depends
+from auto_coder_web.file_manager import get_directory_tree, read_file_content
+
+router = APIRouter()
+
+async def get_project_path(request: Request) -> str:
+    """获取项目路径作为依赖"""
+    return request.app.state.project_path
+
+async def get_auto_coder_runner(request: Request):
+    """获取AutoCoderRunner实例作为依赖"""
+    return request.app.state.auto_coder_runner
+
+@router.delete("/api/files/{path:path}")
+async def delete_file(
+    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):
+                shutil.rmtree(full_path)
+            else:
+                os.remove(full_path)
+            return {"message": f"Successfully deleted {path}"}
+        else:
+            raise HTTPException(
+                status_code=404, detail="File not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/api/files")
+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}")
+async def update_file(
+    path: str, 
+    request: Request,
+    project_path: str = Depends(get_project_path)
+):
+    try:
+        data = await request.json()
+        content = data.get("content")
+        if content is None:
+            raise HTTPException(
+                status_code=400, detail="Content is required")
+
+        full_path = os.path.join(project_path, path)
+
+        # 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)
+
+        return {"message": f"Successfully updated {path}"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/api/file/{path:path}")
+async def get_file_content(
+    path: str,
+    project_path: str = Depends(get_project_path)
+):
+    content = read_file_content(project_path, path)
+    if content is None:
+        raise HTTPException(
+            status_code=404, detail="File not found or cannot be read")
+
+    return {"content": content}