auto-coder-web 0.1.26__tar.gz → 0.1.27__tar.gz

{auto_coder_web-0.1.26 → auto_coder_web-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto_coder_web
-Version: 0.1.26
+Version: 0.1.27
 Summary: auto-coder.web: A Python Project
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.9

{auto_coder_web-0.1.26 → auto_coder_web-0.1.27}/src/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-0.1.26 → auto_coder_web-0.1.27}/src/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-0.1.27/src/auto_coder_web/common_router/completions_router.py

@@ -0,0 +1,166 @@
+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(...),
+    project_path: str = Depends(get_project_path)
+):
+    """获取文件名补全"""
+    patterns = [name]
+    matches = await asyncio.to_thread(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.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(...),
+    project_path: str = Depends(get_project_path)
+):
+    """获取符号补全"""
+    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, project_path)
+            matches.append(CompletionItem(
+                name=symbol.symbol_name,
+                path=relative_path,
+                display=f"{symbol.symbol_name}(location: {relative_path})"
+            ))
+    return CompletionResponse(completions=matches) 

{auto_coder_web-0.1.26 → auto_coder_web-0.1.27}/src/auto_coder_web/common_router/file_group_router.py

@@ -64,12 +64,20 @@ def _get_groups(project_path: str):
     ]
     return v
 
-def _switch_groups(group_names: List[str]):
+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()
@@ -139,12 +147,21 @@ async def auto_create_groups(
 
 @router.post("/api/file-groups/switch")
 async def switch_file_groups(
-    request: Request
+    request: Request,
+    project_path: str = Depends(get_project_path)
 ):
     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}"}
+    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}")

auto_coder_web-0.1.27/src/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)

auto_coder_web-0.1.27/src/auto_coder_web/proxy.py

@@ -0,0 +1,304 @@
+from autocoder.run_context import get_run_context,RunMode
+
+# Set run mode to web
+get_run_context().set_mode(RunMode.WEB)
+
+from fastapi import FastAPI, Request, HTTPException, Response, Query
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi import WebSocket
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+import httpx
+import uuid
+import os
+import argparse
+import aiofiles
+import pkg_resources
+import sys
+from auto_coder_web.auto_coder_runner import AutoCoderRunner
+from .types import (        
+    FileContentResponse,    
+)
+from .terminal import terminal_manager
+from autocoder.common import AutoCoderArgs
+from auto_coder_web.auto_coder_runner_wrapper import AutoCoderRunnerWrapper
+from .routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router
+from expert_routers import history_router
+from .common_router import completions_router, file_router, auto_coder_conf_router, chat_list_router, file_group_router
+from rich.console import Console
+from loguru import logger
+from auto_coder_web.lang import get_message
+
+class ProxyServer:
+    def __init__(self, project_path: str, quick: bool = False, product_mode: str = "pro"):
+        self.app = FastAPI()                        
+        self.setup_middleware()
+
+        self.setup_static_files()
+        self.project_path = project_path
+        
+        # Check if project is initialized
+        self.is_initialized = self.check_project_initialization()
+        if not self.is_initialized:
+            logger.warning(get_message("project_not_initialized"))
+            logger.warning(get_message("run_auto_coder_chat"))
+            sys.exit(1)            
+
+        self.auto_coder_runner = AutoCoderRunnerWrapper(project_path, product_mode=product_mode)        
+         
+
+        self.setup_routes()        
+        self.client = httpx.AsyncClient()
+
+    def setup_middleware(self):
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+    def setup_static_files(self):
+        self.index_html_path = pkg_resources.resource_filename(
+            "auto_coder_web", "web/index.html")
+        self.resource_dir = os.path.dirname(self.index_html_path)
+        self.static_dir = os.path.join(self.resource_dir, "static")
+        
+        self.app.mount(
+            "/static", StaticFiles(directory=self.static_dir), name="static")
+        
+        self.app.mount(
+            "/monaco-editor", StaticFiles(directory=os.path.join(self.resource_dir, "monaco-editor")), name="monaco-editor")
+
+    def setup_routes(self):
+        
+        # Store project_path in app state for dependency injection
+        self.app.state.project_path = self.project_path
+        # Store auto_coder_runner in app state for dependency injection
+        self.app.state.auto_coder_runner = self.auto_coder_runner
+        # Store initialization status
+        self.app.state.is_initialized = self.is_initialized
+
+        self.app.include_router(todo_router.router)
+        self.app.include_router(settings_router.router)
+        self.app.include_router(auto_router.router)
+        self.app.include_router(commit_router.router)
+        self.app.include_router(chat_router.router)
+        self.app.include_router(coding_router.router)
+        self.app.include_router(history_router)
+        self.app.include_router(completions_router.router)
+        self.app.include_router(file_router.router)
+        self.app.include_router(auto_coder_conf_router.router)
+        self.app.include_router(chat_list_router.router)
+        self.app.include_router(file_group_router.router)                        
+
+        @self.app.on_event("shutdown")
+        async def shutdown_event():
+            await self.client.aclose()
+
+        @self.app.websocket("/ws/terminal")
+        async def terminal_websocket(websocket: WebSocket):
+            session_id = str(uuid.uuid4())
+            await terminal_manager.handle_websocket(websocket, session_id)
+
+        @self.app.get("/", response_class=HTMLResponse)
+        async def read_root():
+            if os.path.exists(self.index_html_path):
+                async with aiofiles.open(self.index_html_path, "r") as f:
+                    content = await f.read()
+                    
+                    # If project is not initialized, inject a warning banner
+                    if not self.is_initialized:
+                        init_warning = f"""
+                        <div style="background-color: #fff3cd; color: #856404; padding: 15px; margin: 15px; border-radius: 5px; text-align: center; font-weight: bold;">
+                            <p>⚠️ {get_message("project_not_initialized")}</p>
+                            <p>{get_message("run_auto_coder_chat")}</p>
+                        </div>
+                        """
+                        # Insert the warning after the body tag
+                        content = content.replace("<body>", "<body>" + init_warning)
+                        
+                return HTMLResponse(content=content)
+            return HTMLResponse(content="<h1>Welcome to Proxy Server</h1>")
+        
+
+        @self.app.get("/api/project-path")
+        async def get_project_path():
+            return {"project_path": self.project_path}
+
+        def get_project_runner(project_path: str) -> AutoCoderRunner:
+            return self.projects[project_path]
+
+        @self.app.get("/api/os")
+        async def get_os():
+            return {"os": os.name}
+
+        @self.app.get("/api/conf/keys")
+        async def get_conf_keys():
+            """Get all available configuration keys from AutoCoderArgs"""
+            field_info = AutoCoderArgs.model_fields
+            keys = []
+            for field_name, field in field_info.items():
+                field_type = field.annotation
+                type_str = str(field_type)
+                if "Optional" in type_str:
+                    # Extract the inner type for Optional fields
+                    inner_type = type_str.split("[")[1].split("]")[0]
+                    if "Union" in inner_type:
+                        # Handle Union types
+                        types = [t.strip() for t in inner_type.split(",")[
+                            :-1]]  # Remove Union
+                        type_str = " | ".join(types)
+                    else:
+                        type_str = inner_type
+
+                keys.append({
+                    "key": field_name,
+                    "type": type_str,
+                    "description": field.description or "",
+                    "default": field.default
+                })
+            return {"keys": keys}
+
+        @self.app.post("/api/revert")
+        async def revert():
+            try:
+                result = self.auto_coder_runner.revert()
+                return result
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.get("/api/active-files")
+        async def get_active_files():
+            """获取当前活动文件列表"""
+            active_files = self.auto_coder_runner.get_active_files()
+            return active_files
+
+        @self.app.post("/api/commit")
+        async def commit():
+            try:
+                result = self.auto_coder_runner.commit()
+                return result
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=str(e))        
+
+        @self.app.get("/api/last-yaml")
+        async def get_last_yaml():
+            """Get information about the last YAML file"""
+            return JSONResponse(content=self.auto_coder_runner.get_last_yaml_info())
+
+        @self.app.get("/api/history/file-content/{file_number}", response_model=FileContentResponse)
+        async def get_file_content(file_number: int):
+            """获取指定编号文件的完整内容"""
+            auto_coder_dir = "actions"
+            file_name = f"{file_number}_chat_action.yml"
+            file_path = ""
+            
+            # 搜索文件
+            for root, _, files in os.walk(auto_coder_dir):
+                if file_name in files:
+                    file_path = os.path.join(root, file_name)
+                    break
+                    
+            if not file_path:
+                return FileContentResponse(
+                    success=False,
+                    message=f"找不到文件: {file_name}"
+                )
+                
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                return FileContentResponse(
+                    success=True,
+                    content=content
+                )
+            except Exception as e:
+                return FileContentResponse(
+                    success=False, 
+                    message=f"读取文件出错: {str(e)}"
+                )
+
+        @self.app.get("/api/initialization-status")
+        async def get_initialization_status():
+            """Get the project initialization status"""
+            return {
+                "initialized": self.is_initialized,
+                "message": None if self.is_initialized else get_message("run_auto_coder_chat")
+            }
+    
+    def check_project_initialization(self) -> bool:
+        """Check if the project has been initialized with auto-coder.chat"""
+        auto_coder_dir = os.path.join(self.project_path, ".auto-coder")
+        actions_dir = os.path.join(self.project_path, "actions")
+        return os.path.exists(auto_coder_dir) and os.path.exists(actions_dir)
+    
+    def check_project_conf(self):
+        conf = self.auto_coder_runner.get_conf_wrapper()
+        if conf.get("human_as_model","false") in ["true","True","TRUE"]:
+            logger.warning(get_message("human_as_model_warning"))            
+            self.auto_coder_runner.configure_wrapper("human_as_model=false")            
+
+
+def main():
+    from autocoder.rag.variable_holder import VariableHolder
+    from tokenizers import Tokenizer
+    try:
+        tokenizer_path = pkg_resources.resource_filename(
+            "autocoder", "data/tokenizer.json"
+        )
+        VariableHolder.TOKENIZER_PATH = tokenizer_path
+        VariableHolder.TOKENIZER_MODEL = Tokenizer.from_file(tokenizer_path)
+    except FileNotFoundError:
+        tokenizer_path = None
+
+    parser = argparse.ArgumentParser(description="Proxy Server")
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8007,
+        help="Port to run the proxy server on (default: 8007)",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to run the proxy server on (default: 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--quick",
+        action="store_true",
+        help="Skip environment check",
+    )
+    parser.add_argument(
+        "--product_mode",
+        type=str,
+        default="lite",
+        help="The mode of the auto-coder.chat, lite/pro default is lite",
+    )
+    parser.add_argument(
+        "--lite",
+        action="store_true",
+        help="Run in lite mode (equivalent to --product_mode lite)",
+    )
+    parser.add_argument(
+        "--pro",
+        action="store_true",
+        help="Run in pro mode (equivalent to --product_mode pro)",
+    )
+    args = parser.parse_args()
+
+    # Handle lite/pro flags
+    if args.lite:
+        args.product_mode = "lite"
+    elif args.pro:
+        args.product_mode = "pro"
+
+    proxy_server = ProxyServer(quick=args.quick, project_path=os.getcwd(), product_mode=args.product_mode)
+    uvicorn.run(proxy_server.app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

auto_coder_web-0.1.27/src/auto_coder_web/version.py

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

auto_coder_web-0.1.27/src/auto_coder_web/web/asset-manifest.json

@@ -0,0 +1,15 @@
+{
+  "files": {
+    "main.css": "/static/css/main.8a602674.css",
+    "main.js": "/static/js/main.c14e8b91.js",
+    "static/js/453.d855a71b.chunk.js": "/static/js/453.d855a71b.chunk.js",
+    "index.html": "/index.html",
+    "main.8a602674.css.map": "/static/css/main.8a602674.css.map",
+    "main.c14e8b91.js.map": "/static/js/main.c14e8b91.js.map",
+    "453.d855a71b.chunk.js.map": "/static/js/453.d855a71b.chunk.js.map"
+  },
+  "entrypoints": [
+    "static/css/main.8a602674.css",
+    "static/js/main.c14e8b91.js"
+  ]
+}