auto-coder-web 0.1.64__tar.gz → 0.1.65__tar.gz

{auto_coder_web-0.1.64 → auto_coder_web-0.1.65}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: auto_coder_web
-Version: 0.1.64
+Version: 0.1.65
 Summary: auto-coder.web: A Python Project
 Author: allwefantasy
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Description-Content-Type: text/markdown
-Requires-Dist: auto-coder>=0.1.336
+Requires-Dist: auto-coder>=0.1.340
 Requires-Dist: aiofiles
 Requires-Dist: psutil
 Requires-Dist: sse-starlette

auto_coder_web-0.1.65/src/auto_coder_web/common_router/active_context_router.py

@@ -0,0 +1,152 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+from autocoder.memory.active_context_manager import ActiveContextManager
+from autocoder.auto_coder_runner import get_final_config
+from autocoder.common.action_yml_file_manager import ActionYmlFileManager
+import threading
+
+router = APIRouter()
+
+class TaskInfo(BaseModel):
+    task_id: str = Field(..., description="任务ID")
+    status: str = Field(..., description="任务状态")
+    start_time: Optional[str] = Field(None, description="任务开始时间")
+    completion_time: Optional[str] = Field(None, description="任务完成时间")
+    file_name: Optional[str] = Field(None, description="关联的文件名")
+    total_tokens: int = Field(0, description="总token数")
+    input_tokens: int = Field(0, description="输入token数")
+    output_tokens: int = Field(0, description="输出token数")
+    cost: float = Field(0.0, description="费用")
+    processed_dirs: Optional[List[str]] = Field(None, description="已处理的目录列表")
+    error: Optional[str] = Field(None, description="错误信息")
+
+class TaskListResponse(BaseModel):
+    tasks: List[TaskInfo] = Field(default_factory=list, description="任务列表")
+
+
+_active_context_manager_lock = threading.Lock()
+_active_context_manager_instance: Optional[ActiveContextManager] = None
+
+def get_active_context_manager() -> ActiveContextManager:
+    """
+    获取ActiveContextManager单例实例
+    """
+    global _active_context_manager_instance
+    with _active_context_manager_lock:
+        if _active_context_manager_instance is None:
+            args = get_final_config()
+            llm = None
+            try:
+                from autocoder.utils.llms import get_single_llm
+                llm = get_single_llm(args.model, product_mode=args.product_mode)
+            except Exception:
+                llm = None
+            _active_context_manager_instance = ActiveContextManager(llm, args.source_dir)
+        return _active_context_manager_instance
+
+@router.get("/api/active-context/tasks", response_model=TaskListResponse)
+async def list_active_context_tasks():
+    """
+    获取最新的50条活动上下文任务，按开始时间降序排列。
+    如果发现有超过10分钟还未结束（running/queued）的任务，自动标记为failed。
+    """
+    try:
+        import datetime
+
+        manager = get_active_context_manager()
+        all_tasks_raw = manager.get_all_tasks()
+
+        # 排序，降序，优先使用 start_time，没有则用 completion_time，没有则不排序
+        def get_sort_time(t):
+            st = t.get('start_time')
+            ct = t.get('completion_time')
+            if st:
+                if isinstance(st, str):
+                    try:
+                        return datetime.datetime.strptime(st, "%Y-%m-%d %H:%M:%S")
+                    except:
+                        return st
+                else:
+                    return st
+            elif ct:
+                if isinstance(ct, str):
+                    try:
+                        return datetime.datetime.strptime(ct, "%Y-%m-%d %H:%M:%S")
+                    except:
+                        return ct
+                else:
+                    return ct
+            else:
+                return 0
+
+        sorted_tasks = sorted(all_tasks_raw, key=get_sort_time, reverse=True)
+
+        latest_tasks = sorted_tasks[:50]
+
+        now = datetime.datetime.now()
+
+        # 检查是否有超过10分钟还未完成的任务，将其状态置为failed
+        for t in latest_tasks:
+            status = t.get("status", "")
+            if status in ("running", "queued"):
+                st = t.get("start_time")
+                start_time_dt = None
+                if isinstance(st, str):
+                    try:
+                        start_time_dt = datetime.datetime.strptime(st, "%Y-%m-%d %H:%M:%S")
+                    except:
+                        start_time_dt = None
+                elif isinstance(st, datetime.datetime):
+                    start_time_dt = st
+                else:
+                    start_time_dt = None
+
+                if start_time_dt:
+                    elapsed = now - start_time_dt
+                    if elapsed.total_seconds() > 600:  # 超过10分钟
+                        t["status"] = "failed"
+                        t["error"] = "Timeout: Task exceeded 10 minutes and was automatically marked as failed."
+
+        tasks = []
+        for t in latest_tasks:
+            # 处理时间格式
+            start_time = t.get('start_time')
+            if isinstance(start_time, str):
+                start_time_str = start_time
+            elif start_time:
+                try:
+                    start_time_str = start_time.strftime("%Y-%m-%d %H:%M:%S")
+                except:
+                    start_time_str = str(start_time)
+            else:
+                start_time_str = None
+
+            completion_time = t.get('completion_time')
+            if isinstance(completion_time, str):
+                completion_time_str = completion_time
+            elif completion_time:
+                try:
+                    completion_time_str = completion_time.strftime("%Y-%m-%d %H:%M:%S")
+                except:
+                    completion_time_str = str(completion_time)
+            else:
+                completion_time_str = None
+
+            task_info = TaskInfo(
+                task_id = t.get("task_id", ""),
+                status = t.get("status", ""),
+                start_time = start_time_str,
+                completion_time = completion_time_str,
+                file_name = t.get("file_name", ""),
+                total_tokens = t.get("total_tokens", 0),
+                input_tokens = t.get("input_tokens", 0),
+                output_tokens = t.get("output_tokens", 0),
+                cost = t.get("cost", 0.0),
+                processed_dirs = t.get("processed_dirs", []),
+                error = t.get("error", None)
+            )
+            tasks.append(task_info)
+        return TaskListResponse(tasks=tasks)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get active context tasks: {str(e)}")

{auto_coder_web-0.1.64 → auto_coder_web-0.1.65}/src/auto_coder_web/common_router/file_router.py

@@ -7,9 +7,15 @@ from auto_coder_web.file_manager import (
     get_directory_tree_async,
     read_file_content_async,
 )
+from pydantic import BaseModel
+from typing import List
 
 router = APIRouter()
 
+class FileInfo(BaseModel):
+    name: str
+    path: str
+
 async def get_project_path(request: Request) -> str:
     """获取项目路径作为依赖"""
     return request.app.state.project_path
@@ -101,4 +107,42 @@ async def get_file_content(
         raise HTTPException(
             status_code=404, detail="File not found or cannot be read")
 
-    return {"content": content} 
+    return {"content": content} 
+
+
+@router.get("/api/list-files", response_model=List[FileInfo])
+async def list_files_in_directory(
+    dir_path: str
+):
+    """
+    List all files (not directories) under the specified directory.
+    If dir_path is a file, return info of that file.
+    """
+    if not await aiofiles.os.path.exists(dir_path):
+        raise HTTPException(status_code=404, detail="Path not found")
+
+    # If path is a file, return info of the file
+    if await aiofiles.os.path.isfile(dir_path):
+        file_name = os.path.basename(dir_path)
+        return [FileInfo(name=file_name, path=dir_path)]
+
+    # If not a directory, error
+    if not await aiofiles.os.path.isdir(dir_path):
+        raise HTTPException(status_code=400, detail="Provided path is neither a directory nor a file")
+
+    # Else, list all files under directory
+    try:
+        entries = await aiofiles.os.listdir(dir_path)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    result = []
+    for entry in entries:
+        full_path = os.path.join(dir_path, entry)
+        try:
+            if await aiofiles.os.path.isfile(full_path):
+                result.append(FileInfo(name=entry, path=full_path))
+        except Exception:
+            continue  # ignore errors per file
+
+    return result

auto_coder_web-0.1.65/src/auto_coder_web/common_router/filecacher.py

@@ -0,0 +1,139 @@
+import os
+import json
+import threading
+import time
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+
+class FileCacheHandler(FileSystemEventHandler):
+    def __init__(self, cacher):
+        super().__init__()
+        self.cacher = cacher
+
+    def on_created(self, event):
+        if not event.is_directory:
+            self.cacher._update_file(event.src_path)
+
+    def on_modified(self, event):
+        if not event.is_directory:
+            self.cacher._update_file(event.src_path)
+
+    def on_deleted(self, event):
+        if not event.is_directory:
+            self.cacher._remove_file(event.src_path)
+
+    def on_moved(self, event):
+        if not event.is_directory:
+            self.cacher._remove_file(event.src_path)
+            self.cacher._update_file(event.dest_path)
+
+
+class FileCacher:
+    def __init__(self, project_path):
+        self.project_path = project_path
+        self.index_file = os.path.join(project_path, ".auto-coder", "cache", "file_cache.json")
+        self.file_info = {}  # key: absolute path, value: metadata dict
+        self.ready = False
+        self.lock = threading.RLock()
+        self.observer = None
+
+    def start(self):
+        """启动缓存构建和监控"""
+        # 启动索引构建线程
+        t = threading.Thread(target=self._build_cache_thread, daemon=True)
+        t.start()
+
+    def _build_cache_thread(self):
+        """后台构建索引并启动watchdog监控"""
+        try:
+            self._build_cache()
+        finally:
+            self.ready = True
+            self._save_cache()
+            self._start_watchdog()
+
+    def _build_cache(self):
+        """遍历项目目录，构建初始缓存"""
+        exclude_dirs = {".git", "node_modules", "dist", "build", "__pycache__", ".venv", ".auto-coder"}
+        for root, dirs, files in os.walk(self.project_path, followlinks=True):
+            # 过滤目录
+            dirs[:] = [d for d in dirs if d not in exclude_dirs and not d.startswith('.')]
+            for f in files:
+                abs_path = os.path.join(root, f)
+                self._update_file(abs_path)
+
+    def _update_file(self, abs_path):
+        """添加或更新单个文件的缓存信息"""
+        try:
+            if not os.path.isfile(abs_path):
+                return
+            stat = os.stat(abs_path)
+            rel_path = os.path.relpath(abs_path, self.project_path)
+            with self.lock:
+                self.file_info[rel_path] = {
+                    "mtime": stat.st_mtime,
+                    "size": stat.st_size,
+                    "abs_path": abs_path,
+                    "name": os.path.basename(abs_path),
+                }
+        except Exception:
+            pass  # ignore errors
+
+    def _remove_file(self, abs_path):
+        try:
+            rel_path = os.path.relpath(abs_path, self.project_path)
+            with self.lock:
+                if rel_path in self.file_info:
+                    del self.file_info[rel_path]
+        except Exception:
+            pass
+
+    def _start_watchdog(self):
+        """启动watchdog监控项目目录变更"""
+        event_handler = FileCacheHandler(self)
+        self.observer = Observer()
+        self.observer.schedule(event_handler, self.project_path, recursive=True)
+        self.observer.daemon = True
+        self.observer.start()
+
+    def stop(self):
+        """停止监控"""
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+
+    def _save_cache(self):
+        """将缓存写入磁盘"""
+        try:
+            cache_dir = os.path.dirname(self.index_file)
+            os.makedirs(cache_dir, exist_ok=True)
+            with open(self.index_file, 'w', encoding='utf-8') as f:
+                json.dump(self.file_info, f)
+        except Exception:
+            pass
+
+    def load_cache(self):
+        """尝试加载磁盘缓存"""
+        try:
+            if os.path.exists(self.index_file):
+                with open(self.index_file, 'r', encoding='utf-8') as f:
+                    self.file_info = json.load(f)
+                self.ready = True
+        except Exception:
+            pass
+
+    def search_files(self, patterns):
+        """
+        根据模式列表查找匹配文件
+        :param patterns: list[str]
+        :return: list[str] 相对路径
+        """
+        matched = set()
+        with self.lock:
+            for rel_path, info in self.file_info.items():
+                filename = info.get("name", "")
+                for pattern in patterns:
+                    if pattern == "" or pattern in filename:
+                        matched.add(rel_path)
+        return list(matched)

auto_coder_web-0.1.65/src/auto_coder_web/file_cacher/filecacher.py

@@ -0,0 +1,195 @@
+import os
+import json
+import threading
+import time
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from pydantic import BaseModel
+
+class FileCacheResult(BaseModel):
+    miss: bool
+    files: list[str]
+
+class FileCacheHandler(FileSystemEventHandler):
+    def __init__(self, cacher):
+        super().__init__()
+        self.cacher = cacher
+
+    def on_created(self, event):
+        if not event.is_directory:
+            self.cacher._update_file(event.src_path)
+
+    def on_modified(self, event):
+        if not event.is_directory:
+            self.cacher._update_file(event.src_path)
+
+    def on_deleted(self, event):
+        if not event.is_directory:
+            self.cacher._remove_file(event.src_path)
+
+    def on_moved(self, event):
+        if not event.is_directory:
+            self.cacher._remove_file(event.src_path)
+            self.cacher._update_file(event.dest_path)
+
+
+class FileCacher:
+    def __init__(self, project_path):
+        self.project_path = project_path
+        self.index_file = os.path.join(
+            project_path, ".auto-coder", "cache", "file_cache.json")
+        self.file_info = {}  # key: absolute path, value: metadata dict
+        self.ready = False
+        self.lock = threading.RLock()
+        self.observer = None
+
+    def start(self):
+        """启动缓存构建和监控"""
+        # 启动索引构建线程
+        t = threading.Thread(target=self._build_cache_thread, daemon=True)
+        t.start()
+
+    def _build_cache_thread(self):
+        """后台构建索引并启动watchdog监控"""
+        try:
+            self._build_cache()
+        finally:
+            self.ready = True
+            self._save_cache()
+            self._start_watchdog()
+
+    def _build_cache(self):
+        """遍历项目目录，构建初始缓存"""
+        exclude_dirs = {".git", "node_modules", "dist",
+                        "build", "__pycache__", ".venv", ".auto-coder"}
+        for root, dirs, files in os.walk(self.project_path, followlinks=True):
+            # 过滤目录
+            dirs[:] = [
+                d for d in dirs if d not in exclude_dirs and not d.startswith('.')]
+            for f in files:
+                abs_path = os.path.join(root, f)
+                self._update_file(abs_path)
+
+    def _update_file(self, abs_path):
+        """添加或更新单个文件的缓存信息"""
+        try:
+            if not os.path.isfile(abs_path):
+                return
+            stat = os.stat(abs_path)
+            rel_path = os.path.relpath(abs_path, self.project_path)
+            with self.lock:
+                self.file_info[rel_path] = {
+                    "mtime": stat.st_mtime,
+                    "size": stat.st_size,
+                    "abs_path": abs_path,
+                    "name": os.path.basename(abs_path),
+                }
+        except Exception:
+            pass  # ignore errors
+
+    def _remove_file(self, abs_path):
+        try:
+            rel_path = os.path.relpath(abs_path, self.project_path)
+            with self.lock:
+                if rel_path in self.file_info:
+                    del self.file_info[rel_path]
+        except Exception:
+            pass
+
+    def _start_watchdog(self):
+        """启动watchdog监控项目目录变更"""
+        event_handler = FileCacheHandler(self)
+        self.observer = Observer()
+        self.observer.schedule(
+            event_handler, self.project_path, recursive=True)
+        self.observer.daemon = True
+        self.observer.start()
+
+    def stop(self):
+        """停止监控"""
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+
+    def _save_cache(self):
+        """将缓存写入磁盘"""
+        try:
+            cache_dir = os.path.dirname(self.index_file)
+            os.makedirs(cache_dir, exist_ok=True)
+            with open(self.index_file, 'w', encoding='utf-8') as f:
+                json.dump(self.file_info, f)
+        except Exception:
+            pass
+
+    def load_cache(self):
+        """尝试加载磁盘缓存"""
+        try:
+            if os.path.exists(self.index_file):
+                with open(self.index_file, 'r', encoding='utf-8') as f:
+                    self.file_info = json.load(f)
+                self.ready = True
+        except Exception:
+            pass
+
+    def search_files(self, patterns):
+        """
+        根据模式列表查找匹配文件
+        :param patterns: list[str]
+        :return: FileCacheResult(miss=True/False, files=List[str])
+        """
+        if not self.ready:
+            # 索引未准备好，返回 miss = True，空文件列表
+            return self.FileCacheResult(miss=True, files=[])
+
+        matched = set()
+        default_exclude_dirs = [".git", "node_modules", "dist", "build", "__pycache__", ".venv", ".auto-coder"]
+        project_root = self.project_path
+
+        def should_exclude_path(path: str) -> bool:
+            """检查路径是否应该被排除（路径中包含排除目录或以.开头的目录/文件）"""
+            # 处理相对/绝对路径
+            rel_path = path
+            if os.path.isabs(path):
+                try:
+                    rel_path = os.path.relpath(path, project_root)
+                except ValueError:
+                    rel_path = path
+
+            # 检查文件或目录本身是否以.开头
+            if os.path.basename(rel_path).startswith('.'):
+                return True
+
+            # 检查路径中是否包含排除目录
+            path_parts = rel_path.split(os.sep)
+            return any(part in default_exclude_dirs or part.startswith('.') for part in path_parts)
+
+        with self.lock:
+            # 如果没有提供有效模式，返回过滤后的缓存列表
+            if not patterns or (len(patterns) == 1 and patterns[0] == ""):
+                for rel_path, info in self.file_info.items():
+                    abs_path = info.get("abs_path", "")
+                    if not should_exclude_path(rel_path):
+                        matched.add(rel_path)
+                return self.FileCacheResult(miss=False, files=list(matched))
+
+            for pattern in patterns:
+                # 1. 在缓存中匹配文件名
+                for rel_path, info in self.file_info.items():
+                    filename = info.get("name", "")
+                    abs_path = info.get("abs_path", "")
+                    if should_exclude_path(rel_path):
+                        continue
+                    if pattern in filename:
+                        matched.add(rel_path)
+
+                # 2. 如果pattern本身是存在的文件路径（绝对或相对）
+                abs_pattern_path = pattern
+                if not os.path.isabs(abs_pattern_path):
+                    abs_pattern_path = os.path.join(project_root, pattern)
+                if os.path.exists(abs_pattern_path) and os.path.isfile(abs_pattern_path) and not should_exclude_path(abs_pattern_path):
+                    try:
+                        rel_p = os.path.relpath(abs_pattern_path, project_root)
+                        matched.add(rel_p)
+                    except:
+                        matched.add(abs_pattern_path)
+        return self.FileCacheResult(miss=False, files=list(matched))

{auto_coder_web-0.1.64 → auto_coder_web-0.1.65}/src/auto_coder_web/proxy.py

@@ -22,9 +22,11 @@ from auto_coder_web.auto_coder_runner_wrapper import AutoCoderRunnerWrapper
 from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router,mcp_router
 from auto_coder_web.expert_routers import history_router
 from auto_coder_web.common_router import completions_router, file_router, auto_coder_conf_router, chat_list_router, file_group_router, model_router, compiler_router
+from auto_coder_web.common_router import active_context_router
 from rich.console import Console
 from loguru import logger
 from auto_coder_web.lang import get_message
+from auto_coder_web.file_cacher.filecacher import FileCacher
 
 class ProxyServer:
     def __init__(self, project_path: str, quick: bool = False, product_mode: str = "pro"):    
@@ -79,6 +81,7 @@ class ProxyServer:
         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
+        # self.app.state.file_cacher = FileCacher(self.project_path)
         # Store initialization status
         self.app.state.is_initialized = self.is_initialized
 
@@ -102,6 +105,7 @@ class ProxyServer:
         self.app.include_router(rag_router.router)
         self.app.include_router(editable_preview_router.router)
         self.app.include_router(mcp_router.router)
+        self.app.include_router(active_context_router.router)
         # self.app.include_router(rag_router.router)
 
         @self.app.on_event("shutdown")

{auto_coder_web-0.1.64 → auto_coder_web-0.1.65}/src/auto_coder_web/routers/auto_router.py

@@ -15,6 +15,7 @@ from autocoder.events.event_types import EventType
 from byzerllm.utils.langutil import asyncfy_with_semaphore
 from autocoder.common.global_cancel import global_cancel, CancelRequestedException 
 from loguru import logger
+import byzerllm
 router = APIRouter()
 
 # 创建线程池
@@ -22,6 +23,8 @@ cancel_thread_pool = ThreadPoolExecutor(max_workers=5)
 
 class AutoCommandRequest(BaseModel):
     command: str
+    include_conversation_history: bool = False
+    buildin_conversation_history: bool = False
 
 class EventPollRequest(BaseModel):
     event_file_id:str    
@@ -58,6 +61,26 @@ def ensure_task_dir(project_path: str) -> str:
     os.makedirs(task_dir, exist_ok=True)
     return task_dir
 
+@byzerllm.prompt()
+def coding_prompt(messages: List[Dict[str, Any]], query: str):
+    '''
+    下面是我们已经产生的一个消息列表,其中 USER_RESPONSE 表示用户的输入，RESULT 你的输出：
+    <messages>
+    {% for message in messages %}
+    <message>
+    <type>{{ message.type }}</type>
+    <content>{{ message.content }}</content>
+    </message>
+    {% endfor %}
+    </messages>
+    
+    下面是用户的最新需求：
+    <request>
+    {{ query }}    
+    </request>
+    '''
+
+
 
 @router.post("/api/auto-command")
 async def auto_command(request: AutoCommandRequest, project_path: str = Depends(get_project_path)):
@@ -75,8 +98,50 @@ async def auto_command(request: AutoCommandRequest, project_path: str = Depends(
             wrapper = AutoCoderRunnerWrapper(project_path)
             wrapper.configure_wrapper(f"event_file:{event_file}")
 
-            # 调用auto_command_wrapper方法
-            result = wrapper.auto_command_wrapper(request.command, {
+
+            if request.include_conversation_history:
+                # 获取当前会话名称
+                current_session_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "current-session.json")
+                current_session_name = ""
+                if os.path.exists(current_session_file):
+                    try:
+                        with open(current_session_file, 'r',encoding="utf-8") as f:
+                            session_data = json.load(f)
+                            current_session_name = session_data.get("session_name", "")
+                    except Exception as e:                        
+                        logger.error(f"Error reading current session: {str(e)}")
+                
+                # 获取历史消息
+                messages = []
+                if current_session_name:
+                    chat_list_file = os.path.join(project_path, ".auto-coder", "auto-coder.web", "chat-lists", f"{current_session_name}.json")
+                    if os.path.exists(chat_list_file):
+                        try:
+                            with open(chat_list_file, 'r', encoding="utf-8") as f:
+                                chat_data = json.load(f)
+                                # 从聊天历史中提取消息
+                                for msg in chat_data.get("messages", []):
+                                    # 只保留用户和中间结果信息
+                                    if msg.get("type","") not in ["USER_RESPONSE","RESULT"]:
+                                        continue     
+
+                                    if msg.get("contentType","") in ["token_stat"]:
+                                        continue                            
+                                    
+                                    messages.append(msg)
+                        except Exception as e:                            
+                            logger.error(f"Error reading chat history: {str(e)}")
+                
+                # 构建提示信息
+                prompt_text = ""
+                if messages:
+                    # 调用coding_prompt生成包含历史消息的提示
+                    prompt_text = prompt_text + coding_prompt.prompt(messages, request.command)                    
+                else:
+                    prompt_text = request.command
+
+            # 调用auto_command_wrapper方法            
+            result = wrapper.auto_command_wrapper(prompt_text, {
                 "event_file_id": file_id
             })            
             get_event_manager(event_file).write_completion(