auto-coder-web 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

auto_coder_web/auto_coder_runner.py

@@ -10,6 +10,7 @@ import sys
 import io
 import subprocess
 import byzerllm
+import hashlib
 from contextlib import contextmanager
 from byzerllm.utils.langutil import asyncfy_with_semaphore
 from autocoder.common import AutoCoderArgs
@@ -29,6 +30,7 @@ from autocoder.utils.queue_communicate import (
     CommunicateEventType,
 )
 from autocoder.utils.log_capture import LogCapture
+from autocoder.common import git_utils
 from threading import Thread
 from byzerllm.utils import format_str_jinja2
 from autocoder.index.symbols_utils import (
@@ -37,6 +39,7 @@ from autocoder.index.symbols_utils import (
     SymbolsInfo,
     SymbolType,
 )
+from autocoder.utils.llms import get_single_llm
 
 
 class SymbolItem(BaseModel):
@@ -46,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")
@@ -59,6 +62,8 @@ class AutoCoderRunner:
             "exclude_dirs": [],
         }
         self.load_memory()
+        # Configure product mode
+        self.configure("product_mode", product_mode)
 
     @contextmanager
     def redirect_stdout(self):
@@ -315,6 +320,82 @@ class AutoCoderRunner:
             self.save_memory()
             return {"message": f"Deleted configuration: {key}"}
 
+    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
+        args = AutoCoderArgs()
+        with open(yaml_file, "r") as f:
+            config = yaml.safe_load(f)
+            config = load_include_files(config, yaml_file)
+            for key, value in config.items():
+                if key != "file":  # 排除 --file 参数本身
+                    # key: ENV {{VARIABLE_NAME}}
+                    if isinstance(value, str) and value.startswith("ENV"):
+                        template = Template(value.removeprefix("ENV").strip())
+                        value = template.render(os.environ)
+                    setattr(args, key, value)
+        return args
+
+    def commit(self):
+        """Commit changes using git"""
+        try:
+            def prepare_commit_yaml():
+                auto_coder_main(["next", "chat_action"])
+
+            prepare_commit_yaml()
+
+            latest_yaml_file = get_last_yaml_file("actions")
+            
+            if latest_yaml_file:        
+                try:
+                    execute_file = os.path.join("actions", latest_yaml_file)
+                    yaml_config = {
+                        "include_file": ["./base/base.yml"],
+                        "auto_merge": self.memory.get("conf", {}).get("auto_merge", "editblock"),
+                        "human_as_model": self.memory.get("conf", {}).get("human_as_model", "false") == "true",
+                        "skip_build_index": self.memory.get("conf", {}).get("skip_build_index", "true") == "true",
+                        "skip_confirm": self.memory.get("conf", {}).get("skip_confirm", "true") == "true",
+                        "silence": self.memory.get("conf", {}).get("silence", "true") == "true",
+                        "include_project_structure": self.memory.get("conf", {}).get("include_project_structure", "true") == "true",
+                    }
+
+                    conf = self.memory.get("conf", {})
+                    for key, value in conf.items():
+                        converted_value = self.convert_config_value(key, value)
+                        if converted_value is not None:
+                            yaml_config[key] = converted_value
+
+                    yaml_config["urls"] = self.memory["current_files"]["files"] + self.get_llm_friendly_package_docs(
+                        return_paths=True
+                    )
+                    args = self.convert_yaml_to_config(execute_file)
+                    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)
+                    
+                    yaml_config["query"] = commit_message
+                    yaml_content = self.convert_yaml_config_to_str(yaml_config=yaml_config)            
+                    with open(execute_file, "w") as f:
+                        f.write(yaml_content) 
+                                
+                    file_content = open(execute_file).read()
+                    md5 = hashlib.md5(file_content.encode('utf-8')).hexdigest()            
+                    file_name = os.path.basename(execute_file)             
+                    commit_result = git_utils.commit_changes(".", f"auto_coder_{file_name}_{md5}")            
+                    
+                    return {"status": True, "message": "Changes committed successfully", "commit_info": commit_result}
+                except Exception as e:
+                    if execute_file:
+                        os.remove(execute_file)
+                    return {"status": False, "message": f"Failed to commit: {str(e)}"}
+            else:
+                return {"status": False, "message": "No changes to commit"}
+        except Exception as e:
+            return {"status": False, "message": f"Failed to commit: {str(e)}"}
+
     def get_config(self) -> Dict[str, str]:
         """Get current configuration
 

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}
@@ -585,6 +668,14 @@ class ProxyServer:
                 request_id, request.event, request.response)
             return {"message": "success"}
 
+        @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/output/{request_id}")
         async def get_terminal_logs(request_id: str):
             return self.auto_coder_runner.get_logs(request_id)
@@ -835,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",
@@ -853,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}