auto-coder-web 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

auto_coder_web/auto_coder_runner.py

@@ -39,6 +39,7 @@ from autocoder.index.symbols_utils import (
     SymbolsInfo,
     SymbolType,
 )
+from autocoder.utils.llms import get_single_llm
 
 
 class SymbolItem(BaseModel):
@@ -48,7 +49,7 @@ class SymbolItem(BaseModel):
 
 
 class AutoCoderRunner:
-    def __init__(self, project_path: str):
+    def __init__(self, project_path: str, product_mode: str = "pro"):
         self.project_path = project_path
         self.base_persist_dir = os.path.join(
             project_path, ".auto-coder", "plugins", "chat-auto-coder")
@@ -61,6 +62,8 @@ class AutoCoderRunner:
             "exclude_dirs": [],
         }
         self.load_memory()
+        # Configure product mode
+        self.configure("product_mode", product_mode)
 
     @contextmanager
     def redirect_stdout(self):
@@ -319,7 +322,7 @@ class AutoCoderRunner:
 
     def convert_yaml_to_config(self, yaml_file: str):
         """Convert YAML file to AutoCoderArgs configuration"""
-        from autocoder.auto_coder import AutoCoderArgs, load_include_files, Template
+        from autocoder.commmon import AutoCoderArgs, load_include_files, Template
         args = AutoCoderArgs()
         with open(yaml_file, "r") as f:
             config = yaml.safe_load(f)
@@ -366,7 +369,9 @@ class AutoCoderRunner:
                         return_paths=True
                     )
                     args = self.convert_yaml_to_config(execute_file)
-                    llm = byzerllm.ByzerLLM.from_default_model(args.code_model or args.model)
+                    product_mode = conf.get("product_mode", "pro")
+                    target_model = args.code_model or args.model
+                    llm = get_single_llm(target_model, product_mode)
                     uncommitted_changes = git_utils.get_uncommitted_changes(".")            
                     commit_message = git_utils.generate_commit_message.with_llm(
                         llm).run(uncommitted_changes)
@@ -828,3 +833,49 @@ query: |
                 "status": False,
                 "message": "No previous chat action found."
             }
+
+    async def auto_command(self, query: str):
+        """处理/auto指令"""
+        from autocoder.commands.auto_command import CommandAutoTuner, AutoCommandRequest, CommandConfig
+        args = self.get_final_config()
+        
+        # 准备请求参数
+        request = AutoCommandRequest(
+            user_input=query        
+        )
+        
+        # 初始化调优器
+        llm = get_single_llm(args.chat_model or args.model, product_mode=args.product_mode)    
+        tuner = CommandAutoTuner(llm, 
+                                args=args,
+                                memory_config=MemoryConfig(memory=self.memory, save_memory_func=self.save_memory), 
+                                command_config=CommandConfig(
+                                    add_files=self.add_files,
+                                    remove_files=self.remove_files,
+                                    list_files=self.list_files,
+                                    conf=self.configure,
+                                    revert=self.revert,
+                                    commit=self.commit,
+                                    help=self.help,
+                                    exclude_dirs=self.exclude_dirs,
+                                    ask=self.ask,
+                                    chat=self.chat,
+                                    coding=self.coding,
+                                    design=self.design,
+                                    summon=self.summon,
+                                    lib=self.lib_command,
+                                    mcp=self.mcp,
+                                    models=self.manage_models,
+                                    index_build=self.index_build,
+                                    index_query=self.index_query,  
+                                    execute_shell_command=self.execute_shell,  
+                                    generate_shell_command=self.generate_shell_command                                                                                       
+                                ))
+        
+        # 生成建议
+        response = await tuner.analyze(request)
+        
+        return {
+            "suggestions": [s.dict() for s in response.suggestions],
+            "reasoning": response.reasoning
+        }

auto_coder_web/proxy.py

@@ -6,7 +6,6 @@ from fastapi.staticfiles import StaticFiles
 import uvicorn
 import httpx
 import uuid
-from typing import Optional, Dict, List, Any
 import os
 import argparse
 import aiofiles
@@ -18,6 +17,21 @@ import sys
 from .file_group import FileGroupManager
 from .file_manager import get_directory_tree
 from .auto_coder_runner import AutoCoderRunner
+from autocoder.agent.auto_filegroup import AutoFileGroup
+from .types import (
+    EventGetRequest,
+    EventResponseRequest,
+    CompletionItem,
+    CompletionResponse,
+    ChatList,
+    HistoryQuery,
+    ValidationResponse,
+    QueryWithFileNumber,
+    ValidationResponseWithFileNumbers,
+    FileContentResponse,
+    FileChange,
+    CommitDiffResponse,
+)
 
 from rich.console import Console
 from prompt_toolkit.shortcuts import radiolist_dialog
@@ -26,7 +40,6 @@ import subprocess
 from prompt_toolkit import prompt
 from pydantic import BaseModel
 from autocoder.utils.log_capture import LogCapture
-from typing import Optional, Dict, List, Any
 from .terminal import terminal_manager
 from autocoder.common import AutoCoderArgs
 import json
@@ -35,69 +48,11 @@ import yaml
 import git
 import hashlib
 from datetime import datetime
+from autocoder.utils import operate_config_api
+from .routers import todo_router
+from .routers import settings_router
 
 
-class EventGetRequest(BaseModel):
-    request_id: str
-
-
-class EventResponseRequest(BaseModel):
-    request_id: str
-    event: Dict[str, str]
-    response: str
-
-
-class CompletionItem(BaseModel):
-    name: str
-    path: str
-    display: str
-    location: Optional[str] = None
-
-
-class CompletionResponse(BaseModel):
-    completions: List[CompletionItem]
-
-
-class ChatList(BaseModel):
-    name: str
-    messages: List[Dict[str, Any]]
-
-class HistoryQuery(BaseModel):
-    query: str
-    timestamp: Optional[str] = None
-
-class ValidationResponse(BaseModel):
-    success: bool
-    message: str = ""
-    queries: List[HistoryQuery] = []
-
-class QueryWithFileNumber(BaseModel):
-    query: str
-    timestamp: Optional[str] = None
-    file_number: int  
-    response: Optional[str] = None  
-    urls: Optional[List[str]] = None 
-
-class ValidationResponseWithFileNumbers(BaseModel):
-    success: bool
-    message: str = ""
-    queries: List[QueryWithFileNumber] = []
-
-class FileContentResponse(BaseModel):
-    success: bool
-    message: str = ""
-    content: Optional[str] = None
-
-class FileChange(BaseModel):
-    path: str  
-    change_type: str   # "added" 或 "modified"
-
-class CommitDiffResponse(BaseModel):
-    success: bool
-    message: str = ""
-    diff: Optional[str] = None
-    file_changes: Optional[List[FileChange]] = None
-
 def check_environment():
     """Check and initialize the required environment"""
     console = Console()
@@ -114,10 +69,8 @@ def check_environment():
                 console.print(f"✗ {message}", style="red")
             else:
                 console.print(f"  {message}")
-
-        first_time = False
-        if not os.path.exists("actions") or not os.path.exists(".auto-coder"):
-            first_time = True
+        
+        if not os.path.exists("actions") or not os.path.exists(".auto-coder"):            
             print_status("Project not initialized", "warning")
             init_choice = input(
                 "  Do you want to initialize the project? (y/n): ").strip().lower()
@@ -271,23 +224,113 @@ def check_environment():
     return True
 
 
+def check_environment_lite():
+    """Check and initialize the required environment for lite mode"""
+    console = Console()
+    console.print("\n[blue]Initializing the environment (Lite Mode)...[/blue]")
+
+    def check_project():
+        """Check if the current directory is initialized as an auto-coder project"""
+        def print_status(message, status):
+            if status == "success":
+                console.print(f"✓ {message}", style="green")
+            elif status == "warning":
+                console.print(f"! {message}", style="yellow")
+            elif status == "error":
+                console.print(f"✗ {message}", style="red")
+            else:
+                console.print(f"  {message}")
+
+        first_time = False
+        if not os.path.exists("actions") or not os.path.exists(".auto-coder"):
+            first_time = True
+            print_status("Project not initialized", "warning")
+            init_choice = input(
+                "  Do you want to initialize the project? (y/n): ").strip().lower()
+            if init_choice == "y":
+                try:
+                    if not os.path.exists("actions"):
+                        os.makedirs("actions", exist_ok=True)
+                        print_status("Created actions directory", "success")
+
+                    if not os.path.exists(".auto-coder"):
+                        os.makedirs(".auto-coder", exist_ok=True)
+                        print_status(
+                            "Created .auto-coder directory", "success")
+
+                    subprocess.run(
+                        ["auto-coder", "init", "--source_dir", "."], check=True)
+                    print_status("Project initialized successfully", "success")
+                except subprocess.CalledProcessError:
+                    print_status("Failed to initialize project", "error")
+                    print_status(
+                        "Please try to initialize manually: auto-coder init --source_dir .", "warning")
+                    return False
+            else:
+                print_status("Exiting due to no initialization", "warning")
+                return False
+
+        print_status("Project initialization check complete", "success")
+        return True
+
+    if not check_project():
+        return False
+
+    def print_status(message, status):
+        if status == "success":
+            console.print(f"✓ {message}", style="green")
+        elif status == "warning":
+            console.print(f"! {message}", style="yellow")
+        elif status == "error":
+            console.print(f"✗ {message}", style="red")
+        else:
+            console.print(f"  {message}")
+
+    # Setup deepseek api key
+    api_key_dir = os.path.expanduser("~/.auto-coder/keys")
+    api_key_file = os.path.join(api_key_dir, "api.deepseek.com")
+    
+    if not os.path.exists(api_key_file):
+        print_status("API key not found", "warning")
+        api_key = prompt(HTML("<b>Please enter your API key: </b>"))
+        
+        # Create directory if it doesn't exist
+        os.makedirs(api_key_dir, exist_ok=True)
+        
+        # Save the API key
+        with open(api_key_file, "w") as f:
+            f.write(api_key)
+        
+        print_status(f"API key saved successfully: {api_key_file}", "success")
+
+    print_status("Environment initialization complete", "success")
+    return True
+
+
 class ProxyServer:
-    def __init__(self, project_path: str, quick: bool = False):
+    def __init__(self, project_path: str, quick: bool = False, product_mode: str = "pro"):
         self.app = FastAPI()
 
         if not quick:
-            # Check the environment if not in quick mode
-            if not check_environment():
-                print(
-                    "\033[31mEnvironment check failed. Some features may not work properly.\033[0m")
+            # Check the environment based on product mode
+            if product_mode == "lite":
+                if not check_environment_lite():
+                    print(
+                        "\033[31mEnvironment check failed. Some features may not work properly.\033[0m")
+            else:
+                if not check_environment():
+                    print(
+                        "\033[31mEnvironment check failed. Some features may not work properly.\033[0m")
+                        
         self.setup_middleware()
 
         self.setup_static_files()
 
         self.setup_routes()
+        
         self.client = httpx.AsyncClient()
         self.project_path = project_path
-        self.auto_coder_runner = AutoCoderRunner(project_path)
+        self.auto_coder_runner = AutoCoderRunner(project_path, product_mode=product_mode)
         self.file_group_manager = FileGroupManager(self.auto_coder_runner)
 
     def setup_middleware(self):
@@ -308,6 +351,10 @@ class ProxyServer:
             "/static", StaticFiles(directory=self.static_dir), name="static")
 
     def setup_routes(self):
+        
+        self.app.include_router(todo_router.router)
+        self.app.include_router(settings_router.router)
+
         @self.app.on_event("shutdown")
         async def shutdown_event():
             await self.client.aclose()
@@ -357,6 +404,42 @@ class ProxyServer:
             group = await self.file_group_manager.create_group(name, description)
             return group
 
+        @self.app.post("/api/file-groups/auto")
+        async def auto_create_groups(request: Request):            
+            try:
+                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(self.auto_coder_runner.memory),
+                    self.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 self.file_group_manager.create_group(
+                        name=group.name,
+                        description=group.description
+                    )
+                    # Add files to the group
+                    await self.file_group_manager.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))
+
         @self.app.get("/api/os")
         async def get_os():
             return {"os": os.name}
@@ -843,6 +926,17 @@ class ProxyServer:
 
 
 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",
@@ -861,9 +955,31 @@ def main():
         action="store_true",
         help="Skip environment check",
     )
+    parser.add_argument(
+        "--product_mode",
+        type=str,
+        default="pro",
+        help="The mode of the auto-coder.chat, lite/pro default is pro",
+    )
+    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()
 
-    proxy_server = ProxyServer(quick=args.quick, project_path=os.getcwd())
+    # 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)
 
 

auto_coder_web/routers/settings_router.py

@@ -0,0 +1,76 @@
+
+import os
+import json
+import logging
+import aiofiles
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+from pathlib import Path
+import asyncio
+
+router = APIRouter()
+
+# 配置存储路径
+SETTINGS_FILE = Path(".auto-coder/auto-coder.web/settings/settings.json")
+
+# 确保目录存在
+SETTINGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+logger = logging.getLogger(__name__)
+
+class SettingsModel(BaseModel):
+    language: str = "zh"
+    theme: str = "dark"
+    font_size: int = 14
+    auto_save: bool = True
+    show_line_numbers: bool = True
+
+async def load_settings() -> SettingsModel:
+    """异步加载设置"""
+    if not await asyncio.to_thread(lambda: SETTINGS_FILE.exists()):
+        # 如果文件不存在，返回默认设置
+        return SettingsModel()
+    
+    try:
+        async with aiofiles.open(SETTINGS_FILE, mode='r') as f:
+            content = await f.read()
+            return SettingsModel(**json.loads(content))
+    except (json.JSONDecodeError, FileNotFoundError):
+        logger.error("Failed to parse settings.json, returning default settings")
+        return SettingsModel()
+
+async def save_settings(settings: SettingsModel):
+    """异步保存设置"""
+    async with aiofiles.open(SETTINGS_FILE, mode='w') as f:
+        await f.write(settings.json(indent=2, ensure_ascii=False))
+
+@router.get("/api/settings")
+async def get_settings():
+    """获取当前设置"""
+    return await load_settings()
+
+@router.post("/api/settings")
+async def update_settings(settings: dict):
+    """更新设置"""
+    current_settings = await load_settings()
+    updated_settings = current_settings.copy(update=settings)
+    await save_settings(updated_settings)
+    return updated_settings
+
+@router.post("/api/settings/language")
+async def set_language(language: str):
+    """设置语言"""
+    if language not in ["zh", "en"]:
+        raise HTTPException(status_code=400, detail="Invalid language, must be 'zh' or 'en'")
+    
+    current_settings = await load_settings()
+    current_settings.language = language
+    await save_settings(current_settings)
+    return {"status": "success", "language": language}
+
+@router.get("/api/settings/language")
+async def get_language():
+    """获取当前语言设置"""
+    settings = await load_settings()
+    return {"language": settings.language}

auto_coder_web/routers/todo_router.py

@@ -0,0 +1,156 @@
+import os
+import json
+import uuid
+import logging
+import asyncio
+import aiofiles
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Optional
+from datetime import datetime
+from pathlib import Path
+
+router = APIRouter()
+
+# 配置存储路径
+TODO_FILE = Path(".auto-coder/auto-coder.web/todos/todos.json")
+
+# 确保目录存在
+TODO_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+logger = logging.getLogger(__name__)
+
+class TodoItem(BaseModel):
+    id: str
+    title: str
+    status: str  # pending/developing/testing/done
+    priority: str  # P0/P1/P2/P3
+    tags: List[str] = []
+    owner: Optional[str] = None
+    due_date: Optional[str] = None
+    created_at: str
+    updated_at: str
+
+class CreateTodoRequest(BaseModel):
+    title: str
+    priority: str
+    tags: List[str] = []
+
+class ReorderTodoRequest(BaseModel):
+    source_status: str
+    source_index: int
+    destination_status: str
+    destination_index: int
+    todo_id: str
+
+async def load_todos() -> List[TodoItem]:
+    """异步加载所有待办事项"""
+    if not await asyncio.to_thread(lambda: TODO_FILE.exists()):
+        return []
+    
+    try:
+        async with aiofiles.open(TODO_FILE, mode='r') as f:
+            content = await f.read()
+            return [TodoItem(**item) for item in json.loads(content)]
+    except (json.JSONDecodeError, FileNotFoundError):
+        logger.error("Failed to parse todos.json, returning empty list")
+        return []
+
+async def save_todos(todos: List[TodoItem]):
+    """异步保存待办事项"""
+    async with aiofiles.open(TODO_FILE, mode='w') as f:
+        await f.write(json.dumps([todo.dict() for todo in todos], indent=2,ensure_ascii=False))
+
+@router.get("/api/todos", response_model=List[TodoItem])
+async def get_all_todos():
+    """获取所有待办事项"""
+    return await load_todos()
+
+@router.post("/api/todos", response_model=TodoItem)
+async def create_todo(request: CreateTodoRequest):
+    """创建新待办事项"""
+    todos = await load_todos()
+    
+    new_todo = TodoItem(
+        id=str(uuid.uuid4()),
+        title=request.title,
+        status="pending",
+        priority=request.priority,
+        tags=request.tags,
+        created_at=datetime.now().isoformat(),
+        updated_at=datetime.now().isoformat()
+    )
+    
+    todos.append(new_todo)
+    await save_todos(todos)
+    return new_todo
+
+@router.put("/api/todos/{todo_id}", response_model=TodoItem)
+async def update_todo(todo_id: str, update_data: dict):
+    """更新待办事项"""
+    todos = await load_todos()
+    
+    for index, todo in enumerate(todos):
+        if todo.id == todo_id:
+            updated_data = todos[index].dict()
+            updated_data.update(update_data)
+            updated_data["updated_at"] = datetime.now().isoformat()
+            todos[index] = TodoItem(**updated_data)
+            await save_todos(todos)
+            return todos[index]
+    
+    raise HTTPException(status_code=404, detail="Todo not found")
+
+@router.delete("/api/todos/{todo_id}")
+async def delete_todo(todo_id: str):
+    """删除待办事项"""
+    todos = await load_todos()
+    new_todos = [todo for todo in todos if todo.id != todo_id]
+    
+    if len(new_todos) == len(todos):
+        raise HTTPException(status_code=404, detail="Todo not found")
+    
+    await save_todos(new_todos)
+    return {"status": "success"}
+
+@router.post("/api/todos/reorder")
+async def reorder_todos(request: ReorderTodoRequest):
+    """处理拖放排序"""
+    todos = await load_todos()
+    
+    # 找到移动的待办事项
+    moved_todo = next((t for t in todos if t.id == request.todo_id), None)
+    if not moved_todo:
+        raise HTTPException(status_code=404, detail="Todo not found")
+    
+    # 移除原位置
+    todos = [t for t in todos if t.id != request.todo_id]
+    
+    # 更新状态
+    moved_todo.status = request.destination_status
+    moved_todo.updated_at = datetime.now().isoformat()
+    
+    # 插入新位置
+    todos.insert(
+        await get_insert_index(todos, request.destination_status, request.destination_index),
+        moved_todo
+    )
+    
+    await save_todos(todos)
+    return {"status": "success"}
+
+async def get_insert_index(todos: List[TodoItem], status: str, destination_index: int) -> int:
+    """计算插入位置的绝对索引"""
+    status_todos = [i for i, t in enumerate(todos) if t.status == status]
+    if not status_todos:
+        return len(todos)
+    
+    # 确保目标索引在有效范围内
+    destination_index = min(max(destination_index, 0), len(status_todos))
+    
+    # 如果目标列没有项目，直接插入到最后
+    if not status_todos:
+        return len(todos)
+    
+    # 返回目标列中对应位置的索引
+    return status_todos[destination_index] if destination_index < len(status_todos) else status_todos[-1] + 1