auto-coder 3.0.5__tar.gz → 3.0.7__tar.gz

{auto_coder-3.0.5/src/auto_coder.egg-info → auto_coder-3.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 3.0.5
+Version: 3.0.7
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.5 → auto_coder-3.0.7}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.5"
+version = "3.0.7"
 description = "AutoCoder: AutoCoder"
 authors = [
     {name = "allwefantasy", email = "allwefantasy@gmail.com"}

{auto_coder-3.0.5 → auto_coder-3.0.7/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 3.0.5
+Version: 3.0.7
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.5 → auto_coder-3.0.7}/src/auto_coder.egg-info/SOURCES.txt

@@ -672,6 +672,7 @@ src/autocoder/rag/token_limiter_utils.py
 src/autocoder/rag/types.py
 src/autocoder/rag/utils.py
 src/autocoder/rag/variable_holder.py
+src/autocoder/rag/wildcard_sync.py
 src/autocoder/rag/cache/__init__.py
 src/autocoder/rag/cache/base_cache.py
 src/autocoder/rag/cache/byzer_storage_cache.py

{auto_coder-3.0.5 → auto_coder-3.0.7}/src/autocoder/auto_coder_runner.py

@@ -2099,26 +2099,25 @@ def auto_command(query: str, extra_args: Dict[str, Any] = {}):
 
         cancel_token = extra_args.get("event_file_id", None)
         global_logger.info(f"cancel_token: {cancel_token}")
-        if cancel_token:
-            global_cancel.register_token(cancel_token)
-
-        if get_run_context().mode == RunMode.WEB:
-            runner = FileBasedEventRunner(
-                llm=llm,
-                args=args,
-                conversation_config=conversation_config,
-                cancel_token=cancel_token,
-            )
-            runner.run(AgenticEditRequest(user_input=task_query))
-
-        if get_run_context().mode == RunMode.TERMINAL:
-            runner = TerminalRunner(
-                llm=llm,
-                args=args,
-                conversation_config=conversation_config,
-                cancel_token=cancel_token,
-            )
-            runner.run(AgenticEditRequest(user_input=task_query))
+
+        with global_cancel.scope(cancel_token):
+            if get_run_context().mode == RunMode.WEB:
+                runner = FileBasedEventRunner(
+                    llm=llm,
+                    args=args,
+                    conversation_config=conversation_config,
+                    cancel_token=cancel_token,
+                )
+                runner.run(AgenticEditRequest(user_input=task_query))
+
+            if get_run_context().mode == RunMode.TERMINAL:
+                runner = TerminalRunner(
+                    llm=llm,
+                    args=args,
+                    conversation_config=conversation_config,
+                    cancel_token=cancel_token,
+                )
+                runner.run(AgenticEditRequest(user_input=task_query))
 
         completer.refresh_files()
         return conversation_config.conversation_id
@@ -2227,8 +2226,8 @@ def render_command_file_with_variables(command_infos: Dict[str, Any]) -> str:
         # 获取关键字参数作为渲染参数
         kwargs = first_command.get("kwargs", {})
         render_variables = {
-            "kwargs":kwargs,
-            "args":args[1:],
+            "kwargs": kwargs,
+            "args": args[1:],
             **kwargs,
         }
 
@@ -2242,7 +2241,9 @@ def render_command_file_with_variables(command_infos: Dict[str, Any]) -> str:
         if rendered_content is None:
             raise ValueError(f"无法读取或渲染命令文件: {file_path}")
 
-        global_logger.info(f"成功渲染命令文件: {file_path}, 使用参数: {render_variables}")
+        global_logger.info(
+            f"成功渲染命令文件: {file_path}, 使用参数: {render_variables}"
+        )
         return rendered_content
 
     except Exception as e:

{auto_coder-3.0.5 → auto_coder-3.0.7}/src/autocoder/chat_auto_coder.py

@@ -275,33 +275,33 @@ class EnhancedCompleter(Completer):
         """获取自定义命令列表（从 .autocodercommands 目录）"""
         if self._cache_valid and self._custom_commands_cache:
             return sorted(list(self._custom_commands_cache))
-        
+
         try:
             from autocoder.common.command_file_manager.manager import CommandManager
-            
+
             # 创建命令管理器
             command_manager = CommandManager()
-            
+
             # 列出所有命令文件
             result = command_manager.list_command_files(recursive=True)
-            
+
             if result.success:
                 commands = set()
                 for file_name in result.command_files:
                     # 去掉 .md 后缀和路径前缀，只保留命令名
                     command_name = os.path.basename(file_name)
-                    if command_name.endswith('.md'):
+                    if command_name.endswith(".md"):
                         command_name = command_name[:-3]
                     # 添加 / 前缀形成完整命令
                     commands.add(f"/{command_name}")
-                
+
                 self._custom_commands_cache = commands
                 self._cache_valid = True
                 return sorted(list(commands))
         except Exception:
             # 静默处理异常，返回空列表
             pass
-        
+
         return []
 
     def get_completions(self, document, complete_event):
@@ -356,7 +356,7 @@ class EnhancedCompleter(Completer):
                     start_position=0,
                     display=command,
                 )
-            
+
             # 2. 自定义命令（从 .autocodercommands 目录）
             custom_commands = self._get_custom_commands()
             for command in custom_commands:
@@ -480,7 +480,7 @@ class EnhancedCompleter(Completer):
                             start_position=0,
                             display=command,
                         )
-                    
+
                     # 2. 自定义命令（从 .autocodercommands 目录）
                     custom_commands = await loop.run_in_executor(
                         executor,
@@ -744,8 +744,8 @@ async def process_user_input(user_input: str, new_prompt_callback, session=None)
         ):
             event_file, file_id = gengerate_event_file_path()
             configure(f"event_file:{event_file}")
-            global_cancel.register_token(event_file)
-            run_agentic(user_input, cancel_token=event_file)
+            with global_cancel.scope(event_file):
+                run_agentic(user_input, cancel_token=event_file)
 
         elif memory_manager.is_voice_input_mode() and not user_input.startswith("/"):
             text = voice_input()
@@ -773,8 +773,8 @@ async def process_user_input(user_input: str, new_prompt_callback, session=None)
         elif user_input.startswith("/index/build"):
             event_file, file_id = gengerate_event_file_path()
             configure(f"event_file:{event_file}")
-            global_cancel.register_token(event_file)
-            index_build()
+            with global_cancel.scope(event_file):
+                index_build()
 
         elif user_input.startswith("/index/export"):
             export_path = user_input[len("/index/export") :].strip()
@@ -845,21 +845,21 @@ async def process_user_input(user_input: str, new_prompt_callback, session=None)
         elif user_input.startswith("/coding"):
             event_file, file_id = gengerate_event_file_path()
             configure(f"event_file:{event_file}")
-            global_cancel.register_token(event_file)
             query = user_input[len("/coding") :].strip()
             if not query:
                 print(f"\033[91m{get_message('please_enter_request')}\033[0m")
                 return
-            coding(query, cancel_token=event_file)
+            with global_cancel.scope(event_file):
+                coding(query, cancel_token=event_file)
         elif user_input.startswith("/chat"):
             event_file, file_id = gengerate_event_file_path()
             configure(f"event_file:{event_file}")
-            global_cancel.register_token(event_file)
             query = user_input[len("/chat") :].strip()
             if not query:
                 print(f"\033[91m{get_message('please_enter_request')}\033[0m")
             else:
-                chat(query)
+                with global_cancel.scope(event_file):
+                    chat(query)
 
         elif user_input.startswith("/design"):
             query = user_input[len("/design") :].strip()
@@ -897,9 +897,9 @@ async def process_user_input(user_input: str, new_prompt_callback, session=None)
         elif user_input.startswith("/auto"):
             query = user_input[len("/auto") :].strip()
             event_file, _ = gengerate_event_file_path()
-            global_cancel.register_token(event_file)
             configure(f"event_file:{event_file}")
-            run_agentic(query, cancel_token=event_file)
+            with global_cancel.scope(event_file):
+                run_agentic(query, cancel_token=event_file)
         elif user_input.startswith("/debug"):
             code = user_input[len("/debug") :].strip()
             try:
@@ -917,25 +917,25 @@ async def process_user_input(user_input: str, new_prompt_callback, session=None)
             else:
                 if command.startswith("/chat"):
                     event_file, file_id = gengerate_event_file_path()
-                    global_cancel.register_token(event_file)
                     configure(f"event_file:{event_file}")
                     command = command[len("/chat") :].strip()
-                    gen_and_exec_shell_command(command)
+                    with global_cancel.scope(event_file):
+                        gen_and_exec_shell_command(command)
                 else:
                     execute_shell_command(command)
         else:
             # 对于未识别的命令，显示提示信息而不是执行auto_command
             if user_input and user_input.strip():
-                if user_input.startswith("/"):                    
+                if user_input.startswith("/"):
                     command = user_input.split(" ")[0][1:]
-                    query = user_input[len(command) + 1:].strip()
-                    user_input = f"/command {command}.md {query}"                    
-                
+                    query = user_input[len(command) + 1 :].strip()
+                    user_input = f"/command {command}.md {query}"
+
                 # 只有非命令输入才执行auto_command
                 event_file, _ = gengerate_event_file_path()
-                global_cancel.register_token(event_file)
                 configure(f"event_file:{event_file}")
-                run_agentic(user_input, cancel_token=event_file)
+                with global_cancel.scope(event_file):
+                    run_agentic(user_input, cancel_token=event_file)
 
     except EOFError:
         # 重新抛出这些异常，让主循环处理

{auto_coder-3.0.5 → auto_coder-3.0.7}/src/autocoder/common/__init__.py

@@ -342,6 +342,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     verify_file_relevance_score: int = 6
     enable_rag_search: Union[bool, str] = False
     enable_rag_context: Union[bool, str] = False
+    custom_knowledge_bases: List[Dict[str, Any]] = pydantic.Field(default_factory=list)
+    custom_rules: List[Dict[str, Any]] = pydantic.Field(default_factory=list)
     codebase_rag_suffixs: Optional[str] = None
     collection: Optional[str] = None
     collections: Optional[str] = None

auto_coder-3.0.7/src/autocoder/common/global_cancel.py

@@ -0,0 +1,346 @@
+"""
+Cancellation framework based on CancellationToken + Scope pattern.
+
+Key design choices:
+- **Sticky cancellation**: once a token is cancelled, it stays cancelled until
+  the owning scope exits (or an explicit reset). Multiple observers can all
+  see the cancelled state.
+- **CancellationScope**: context-manager that auto-registers / unregisters a
+  token and propagates it via ``contextvars`` so deep call-chains don't need
+  to pass the token explicitly.
+- **Thread-safe**: all mutable state is guarded by a single ``threading.Lock``
+  and iterations always operate on snapshots.
+- **Backward-compatible**: the existing ``global_cancel`` singleton and every
+  public method name is preserved.  New capabilities are additive.
+"""
+
+import contextvars
+import threading
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Generator, List, Optional, Set
+
+# ---------------------------------------------------------------------------
+# ContextVar – carries the "current cancel token" across sync call-chains
+# and is automatically copied into child threads started via
+# ``threading.Thread`` (Python 3.12+) or ``concurrent.futures``.
+# ---------------------------------------------------------------------------
+_current_cancel_token: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "current_cancel_token", default=None
+)
+
+
+# ---------------------------------------------------------------------------
+# Exception
+# ---------------------------------------------------------------------------
+class CancelRequestedException(Exception):
+    """当取消请求被触发时抛出的异常"""
+
+    def __init__(
+        self, token: Optional[str] = None, message: str = "Operation was cancelled"
+    ):
+        self.token = token
+        self.message = message
+        super().__init__(self.message)
+
+
+# ---------------------------------------------------------------------------
+# Internal per-token state
+# ---------------------------------------------------------------------------
+@dataclass
+class _TokenState:
+    """Internal mutable state for a single cancellation token."""
+
+    cancelled: bool = False
+    active_count: int = 0  # supports nested scopes for the same token
+    context: Dict[str, Any] = field(default_factory=dict)
+    created_at: float = field(default_factory=time.time)
+    callbacks: List[Callable[[], None]] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# GlobalCancel – the singleton registry
+# ---------------------------------------------------------------------------
+class GlobalCancel:
+    """Thread-safe cancellation registry with scope support.
+
+    All pre-existing public methods are preserved for backward compatibility.
+    New capabilities:
+
+    * ``scope(token)`` – context-manager for auto register/unregister.
+    * ``raise_if_cancelled(token)`` – sticky check (does **not** consume the
+      cancellation state).
+    * ``cancel(token, context)`` – alias for ``set(token, context)``; also
+      fires registered callbacks.
+    * ``cancel_active(context)`` – thread-safe batch cancel of all active
+      tokens (snapshot-based, no iteration-mutation risk).
+    * ``on_cancel(token, callback)`` – register a callback invoked when the
+      token is cancelled.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._global_flag: bool = False
+        self._global_context: Dict[str, Any] = {}
+        self._tokens: Dict[str, _TokenState] = {}
+        self._active_tokens: Set[str] = set()
+        # kept for legacy callers that read it directly
+        self._current_task_token: Optional[str] = None
+
+    # ------------------------------------------------------------------
+    # helpers
+    # ------------------------------------------------------------------
+    def _get_or_create_state(self, token: str) -> _TokenState:
+        """Return existing state or lazily create one (caller holds lock)."""
+        if token not in self._tokens:
+            self._tokens[token] = _TokenState()
+        return self._tokens[token]
+
+    def _effective_token(self, token: Optional[str]) -> Optional[str]:
+        """Resolve *token*: if ``None`` fall back to the contextvar."""
+        if token is not None:
+            return token
+        return _current_cancel_token.get(None)
+
+    # ------------------------------------------------------------------
+    # Scope (new API)
+    # ------------------------------------------------------------------
+    @contextmanager
+    def scope(
+        self, token: Optional[str] = None
+    ) -> Generator[Optional[str], None, None]:
+        """Context-manager that registers *token* on entry and unregisters on
+        exit.  While the scope is active the contextvar
+        ``_current_cancel_token`` is set so that ``check_and_raise()`` /
+        ``raise_if_cancelled()`` can discover it automatically.
+
+        Usage::
+
+            with global_cancel.scope(cancel_token):
+                do_work()          # check_and_raise() will use cancel_token
+                call_deep_fn()     # same, no need to pass token explicitly
+        """
+        if token is not None:
+            self.register_token(token)
+        reset_cv = _current_cancel_token.set(token)
+        try:
+            yield token
+        finally:
+            _current_cancel_token.reset(reset_cv)
+            if token is not None:
+                self._unregister_token(token)
+
+    # ------------------------------------------------------------------
+    # Registration
+    # ------------------------------------------------------------------
+    def register_token(self, token: str) -> None:
+        """注册一个 token，表示一个操作开始，但尚未请求取消
+
+        If the token was already cancelled before registration (e.g. a race
+        where ``set()`` arrived first) the cancelled state is **preserved**,
+        not overwritten.
+        """
+        with self._lock:
+            state = self._get_or_create_state(token)
+            state.active_count += 1
+            self._active_tokens.add(token)
+            self._current_task_token = token
+
+    def _unregister_token(self, token: str) -> None:
+        """Decrement active count; remove state when no scopes remain."""
+        with self._lock:
+            state = self._tokens.get(token)
+            if state is None:
+                return
+            state.active_count = max(0, state.active_count - 1)
+            if state.active_count <= 0:
+                self._active_tokens.discard(token)
+                del self._tokens[token]
+                if self._current_task_token == token:
+                    self._current_task_token = None
+
+    # ------------------------------------------------------------------
+    # Query
+    # ------------------------------------------------------------------
+    def get_current_task_token(self) -> Optional[str]:
+        """获取当前任务token"""
+        with self._lock:
+            return self._current_task_token
+
+    def get_active_tokens(self) -> Set[str]:
+        """获取当前正在运行的token"""
+        with self._lock:
+            return self._active_tokens.copy()
+
+    def is_requested(self, token: Optional[str] = None) -> bool:
+        """检查是否请求了特定token或全局的取消"""
+        with self._lock:
+            if self._global_flag:
+                return True
+            resolved = self._effective_token(token)
+            if resolved is not None:
+                state = self._tokens.get(resolved)
+                if state is not None:
+                    return state.cancelled
+            return False
+
+    # ------------------------------------------------------------------
+    # Cancel (set)
+    # ------------------------------------------------------------------
+    def set(
+        self,
+        token: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """设置特定token或全局的取消标志"""
+        callbacks_to_fire: List[Callable[[], None]] = []
+        with self._lock:
+            if token is None:
+                self._global_flag = True
+                if context:
+                    self._global_context.update(context)
+            else:
+                state = self._get_or_create_state(token)
+                if not state.cancelled:
+                    state.cancelled = True
+                    callbacks_to_fire = list(state.callbacks)
+                if context:
+                    state.context.update(context)
+
+        # Fire callbacks outside the lock to avoid deadlocks
+        for cb in callbacks_to_fire:
+            try:
+                cb()
+            except Exception:
+                pass
+
+    # Alias – more expressive name
+    cancel = set
+
+    def set_active_tokens(self) -> None:
+        """启用所有活跃的token (thread-safe snapshot iteration)."""
+        with self._lock:
+            snapshot = list(self._active_tokens)
+        for t in snapshot:
+            self.set(t)
+
+    # Alias
+    cancel_active = set_active_tokens
+
+    # ------------------------------------------------------------------
+    # Reset
+    # ------------------------------------------------------------------
+    def reset_global(self) -> None:
+        """重置全局取消标志"""
+        with self._lock:
+            self._global_flag = False
+            self._global_context.clear()
+
+    def reset_token(self, token: str) -> None:
+        """重置特定token的取消标志并从活跃集合移除。"""
+        with self._lock:
+            if token in self._tokens:
+                del self._tokens[token]
+            self._active_tokens.discard(token)
+            if self._current_task_token == token:
+                self._current_task_token = None
+
+    def reset(self, token: Optional[str] = None) -> None:
+        """重置特定token或全局的取消标志"""
+        with self._lock:
+            if token is None:
+                self._global_flag = False
+                self._global_context.clear()
+                self._tokens.clear()
+                self._active_tokens.clear()
+                self._current_task_token = None
+            else:
+                if token in self._tokens:
+                    del self._tokens[token]
+                self._active_tokens.discard(token)
+                if self._current_task_token == token:
+                    self._current_task_token = None
+
+    def reset_active_tokens(self) -> None:
+        """重置所有活跃的token"""
+        with self._lock:
+            tokens_snapshot = list(self._active_tokens)
+        for t in tokens_snapshot:
+            self.reset_token(t)
+
+    # ------------------------------------------------------------------
+    # Context
+    # ------------------------------------------------------------------
+    def get_context(self, token: Optional[str] = None) -> Dict[str, Any]:
+        """获取与取消相关的上下文信息"""
+        with self._lock:
+            if token is None:
+                return self._global_context.copy()
+            state = self._tokens.get(token)
+            if state is not None:
+                return state.context.copy()
+            return {}
+
+    # ------------------------------------------------------------------
+    # Check & raise helpers
+    # ------------------------------------------------------------------
+    def raise_if_cancelled(self, token: Optional[str] = None) -> None:
+        """Sticky check: raises ``CancelRequestedException`` if the token
+        (or the global flag) is cancelled.  Does **not** reset/consume the
+        cancellation state – that is left to the owning ``scope``.
+
+        If *token* is ``None`` the current contextvar token is used.
+        """
+        resolved = self._effective_token(token)
+        if self.is_requested(resolved):
+            ctx = self.get_context(resolved)
+            raise CancelRequestedException(
+                resolved, ctx.get("message", "Operation was cancelled")
+            )
+
+    def check_and_raise(self, token: Optional[str] = None) -> None:
+        """检查是否请求了取消，如果是则抛出异常
+
+        **Backward-compatible**: this method now delegates to
+        ``raise_if_cancelled`` (sticky semantics).  The cancellation state is
+        **not** consumed – cleanup happens when the scope exits or when
+        ``reset_token`` / ``reset`` is called explicitly.
+        """
+        self.raise_if_cancelled(token)
+
+    # ------------------------------------------------------------------
+    # Callback registration (new API)
+    # ------------------------------------------------------------------
+    def on_cancel(self, token: str, callback: Callable[[], None]) -> None:
+        """Register a callback to be invoked when *token* is cancelled.
+
+        If *token* is **already** cancelled at the time of registration the
+        callback is fired immediately (outside the lock).
+        """
+        fire_now = False
+        with self._lock:
+            state = self._get_or_create_state(token)
+            if state.cancelled:
+                fire_now = True
+            else:
+                state.callbacks.append(callback)
+        if fire_now:
+            try:
+                callback()
+            except Exception:
+                pass
+
+    # ------------------------------------------------------------------
+    # Legacy property kept for code that accesses _token_flags directly
+    # ------------------------------------------------------------------
+    @property
+    def _token_flags(self) -> Dict[str, bool]:
+        """Backward-compat shim: returns a snapshot dict mirroring old
+        ``_token_flags`` layout.  **Read-only** – mutations are ignored.
+        """
+        with self._lock:
+            return {t: s.cancelled for t, s in self._tokens.items()}
+
+
+global_cancel = GlobalCancel()