auto-coder 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

autocoder/terminal/tasks/background.py

@@ -0,0 +1,77 @@
+"""后台任务：监控全局状态或执行其他后台逻辑"""
+
+import asyncio
+from pathlib import Path
+
+
+async def background_task(stop_event: asyncio.Event, session=None, debug=False):
+    """后台任务：可以用于监控系统状态、清理任务等"""
+    counter = 0
+    toolbar_refresh_counter = 0
+    last_async_task_count = 0
+
+    # 配置刷新频率（秒）
+    TOOLBAR_REFRESH_INTERVAL = 5  # 默认5秒刷新一次
+    FAST_REFRESH_INTERVAL = 1  # 有异步任务时1秒刷新一次
+
+    while not stop_event.is_set():
+        try:
+            # 检查是否有需要处理的后台任务
+            # 这里可以添加系统监控逻辑
+            counter += 1
+            toolbar_refresh_counter += 1
+
+            # 检查当前异步任务状态，决定刷新频率
+            current_async_task_count = 0
+            try:
+                from autocoder.sdk.async_runner.task_metadata import (
+                    TaskMetadataManager,
+                )
+
+                async_agent_dir = Path.home() / ".auto-coder" / "async_agent"
+                meta_dir = async_agent_dir / "meta"
+
+                if meta_dir.exists():
+                    metadata_manager = TaskMetadataManager(str(meta_dir))
+                    summary = metadata_manager.get_task_summary()
+                    current_async_task_count = summary.get("running", 0)
+            except Exception:
+                # 静默处理异常
+                pass
+
+            # 智能刷新：有异步任务时更频繁刷新，无任务时降低刷新频率
+            should_refresh = False
+            if current_async_task_count > 0:
+                # 有异步任务时，每秒刷新
+                should_refresh = toolbar_refresh_counter >= FAST_REFRESH_INTERVAL
+            else:
+                # 无异步任务时，每5秒刷新
+                should_refresh = toolbar_refresh_counter >= TOOLBAR_REFRESH_INTERVAL
+
+            # 任务数量变化时立即刷新
+            if current_async_task_count != last_async_task_count:
+                should_refresh = True
+                last_async_task_count = current_async_task_count
+
+            # 执行工具栏刷新
+            if should_refresh and session and hasattr(session, "app"):
+                try:
+                    session.app.invalidate()
+                    toolbar_refresh_counter = 0
+                except Exception:
+                    # 静默处理刷新异常，不影响后台任务运行
+                    pass
+
+            # 每60秒执行一次清理
+            if counter % 60 == 0:
+                # 执行一些后台清理任务
+                pass
+
+            await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            break
+        except Exception as e:
+            # 后台任务出错时，不要让整个应用崩溃
+            if debug:
+                print(f"Background task error: {e}")
+            await asyncio.sleep(5)  # 出错后等待5秒再继续

autocoder/terminal/tasks/task_event.py

@@ -0,0 +1,70 @@
+"""任务事件和取消注册表"""
+
+import asyncio
+from typing import Dict
+
+
+class TaskEvent:
+    """任务事件状态管理器"""
+
+    def __init__(self):
+        self.state = "idle"  # idle, pending, started, running, completed
+        self._event = asyncio.Event()
+        self._event.set()  # 初始状态为可用
+
+    def set_state(self, state: str):
+        """设置任务状态"""
+        self.state = state
+        if state == "completed":
+            self._event.set()
+        else:
+            self._event.clear()
+
+    def get_state(self) -> str:
+        """获取当前状态"""
+        return self.state
+
+    def is_completed(self) -> bool:
+        """检查是否完成"""
+        return self.state == "completed"
+
+    def is_running(self) -> bool:
+        """检查是否正在运行"""
+        return self.state in ["started", "running"]
+
+    async def wait(self):
+        """等待任务完成"""
+        await self._event.wait()
+
+    def clear(self):
+        """清除完成状态，重置为pending"""
+        self.set_state("idle")
+
+
+class CancellationRegistry:
+    """任务取消注册表，用于集中管理和取消活跃的异步任务"""
+
+    def __init__(self) -> None:
+        self._tasks: Dict[str, asyncio.Task] = {}
+
+    def register(self, token: str, task: asyncio.Task) -> None:
+        """注册一个任务"""
+        self._tasks[token] = task
+
+    def unregister(self, token: str) -> None:
+        """注销一个任务"""
+        self._tasks.pop(token, None)
+
+    async def cancel_all(self) -> None:
+        """取消所有活跃任务"""
+        for t in list(self._tasks.values()):
+            if not t.done():
+                t.cancel()
+        # 等待所有任务完成（吞掉 CancelledError）
+        for token, t in list(self._tasks.items()):
+            try:
+                await t
+            except asyncio.CancelledError:
+                pass
+            finally:
+                self._tasks.pop(token, None)

autocoder/terminal/ui/__init__.py

@@ -0,0 +1,13 @@
+"""UI 组件模块"""
+
+from .completer import EnhancedCompleter
+from .keybindings import setup_keybindings
+from .toolbar import get_bottom_toolbar_func
+from .session import create_session
+
+__all__ = [
+    "EnhancedCompleter",
+    "setup_keybindings",
+    "get_bottom_toolbar_func",
+    "create_session",
+]

autocoder/terminal/ui/completer.py

@@ -0,0 +1,268 @@
+"""增强的命令补全器"""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from prompt_toolkit.completion import Completer, Completion
+from typing import List, Set
+import os
+
+
+class EnhancedCompleter(Completer):
+    """结合内置补全器和插件补全功能的增强补全器"""
+
+    def __init__(self, base_completer: Completer, plugin_manager):
+        self.base_completer: Completer = base_completer
+        self.plugin_manager = plugin_manager
+        self._custom_commands_cache: Set[str] = set()
+        self._cache_valid = False
+
+    def _get_custom_commands(self) -> List[str]:
+        """获取自定义命令列表（从 .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'):
+                        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 as e:
+            # 静默处理异常，返回空列表
+            pass
+        
+        return []
+
+    def get_completions(self, document, complete_event):
+        # 获取当前输入的文本
+        text_before_cursor = document.text_before_cursor.lstrip()
+
+        # 只有当我们需要处理命令补全时才进行处理
+        if text_before_cursor.startswith("/"):
+
+            # 获取当前输入的命令前缀
+            current_input = text_before_cursor
+            # 检查是否需要动态补全
+            if " " in current_input:
+                # 将连续的空格替换为单个空格
+                _input_one_space = " ".join(current_input.split())
+                # 先尝试动态补全特定命令
+                dynamic_cmds = self.plugin_manager.get_dynamic_cmds()
+                for dynamic_cmd in dynamic_cmds:
+                    if _input_one_space.startswith(dynamic_cmd):
+                        # 使用 PluginManager 处理动态补全，通常是用于命令或子命令动态的参数值列表的补全
+                        completions = self.plugin_manager.process_dynamic_completions(
+                            dynamic_cmd, current_input
+                        )
+                        for completion_text, display_text in completions:
+                            yield Completion(
+                                completion_text,
+                                start_position=0,
+                                display=display_text,
+                            )
+                        return
+
+                # 如果不是特定命令，检查一般命令 + 空格的情况, 通常是用于固定的下级子命令列表的补全
+                cmd_parts = current_input.split(maxsplit=1)
+                base_cmd = cmd_parts[0]
+
+                # 获取插件命令补全
+                plugin_completions_dict = self.plugin_manager.get_plugin_completions()
+
+                # 如果命令存在于补全字典中，进行处理
+                if base_cmd in plugin_completions_dict:
+                    yield from self._process_command_completions(
+                        base_cmd, current_input, plugin_completions_dict[base_cmd]
+                    )
+                    return
+            # 处理直接命令补全 - 如果输入不包含空格，匹配整个命令
+            # 1. 插件和内置命令
+            for command in self.plugin_manager.get_all_commands_with_prefix(
+                current_input
+            ):
+                yield Completion(
+                    command[len(current_input) :],
+                    start_position=0,
+                    display=command,
+                )
+            
+            # 2. 自定义命令（从 .autocodercommands 目录）
+            custom_commands = self._get_custom_commands()
+            for command in custom_commands:
+                if command.startswith(current_input):
+                    yield Completion(
+                        command[len(current_input) :],
+                        start_position=0,
+                        display=command,
+                    )
+
+        # 获取并返回基础补全器的补全
+        if self.base_completer:
+            for completion in self.base_completer.get_completions(
+                document, complete_event
+            ):
+                yield completion
+
+    def _process_command_completions(self, command, current_input, completions):
+        """处理通用命令补全"""
+        # 提取子命令前缀
+        parts = current_input.split(maxsplit=1)
+        cmd_prefix = ""
+        if len(parts) > 1:
+            cmd_prefix = parts[1].strip()
+
+        # 对于任何命令，当子命令前缀为空或与补全选项匹配时，都显示补全
+        for completion in completions:
+            if cmd_prefix == "" or completion.startswith(cmd_prefix):
+                # 只提供未输入部分作为补全
+                remaining_text = completion[len(cmd_prefix) :]
+                # 修复：设置 start_position 为 0，这样不会覆盖用户已输入的部分
+                start_position = 0
+                yield Completion(
+                    remaining_text,
+                    start_position=start_position,
+                    display=completion,
+                )
+
+    async def get_completions_async(self, document, complete_event):
+        """异步获取补全内容。
+
+        使用 asyncio.run_in_executor 来异步执行耗时的补全操作，
+        避免阻塞主线程导致输入卡顿。
+        """
+        # 获取当前输入的文本
+        text_before_cursor = document.text_before_cursor.lstrip()
+
+        # 只有当我们需要处理命令补全时才进行处理
+        if text_before_cursor.startswith("/"):
+            # 获取当前输入的命令前缀
+            current_input = text_before_cursor
+
+            # 使用线程池执行器来异步执行耗时操作
+            loop = asyncio.get_event_loop()
+            executor = ThreadPoolExecutor(max_workers=1)
+
+            try:
+                # 检查是否需要动态补全
+                if " " in current_input:
+                    # 将连续的空格替换为单个空格
+                    _input_one_space = " ".join(current_input.split())
+
+                    # 异步获取动态命令列表
+                    dynamic_cmds = await loop.run_in_executor(
+                        executor, self.plugin_manager.get_dynamic_cmds
+                    )
+
+                    for dynamic_cmd in dynamic_cmds:
+                        if _input_one_space.startswith(dynamic_cmd):
+                            # 异步处理动态补全
+                            completions = await loop.run_in_executor(
+                                executor,
+                                self.plugin_manager.process_dynamic_completions,
+                                dynamic_cmd,
+                                current_input,
+                            )
+                            for completion_text, display_text in completions:
+                                yield Completion(
+                                    completion_text,
+                                    start_position=0,
+                                    display=display_text,
+                                )
+                            return
+
+                    # 如果不是特定命令，检查一般命令 + 空格的情况
+                    cmd_parts = current_input.split(maxsplit=1)
+                    base_cmd = cmd_parts[0]
+
+                    # 异步获取插件命令补全
+                    plugin_completions_dict = await loop.run_in_executor(
+                        executor, self.plugin_manager.get_plugin_completions
+                    )
+
+                    # 如果命令存在于补全字典中，进行处理
+                    if base_cmd in plugin_completions_dict:
+                        # 异步处理命令补全
+                        completions_list = await loop.run_in_executor(
+                            executor,
+                            self._get_command_completions_list,
+                            base_cmd,
+                            current_input,
+                            plugin_completions_dict[base_cmd],
+                        )
+                        for completion in completions_list:
+                            yield completion
+                        return
+                else:
+                    # 处理直接命令补全 - 异步获取所有匹配的命令
+                    # 1. 插件和内置命令
+                    commands = await loop.run_in_executor(
+                        executor,
+                        self.plugin_manager.get_all_commands_with_prefix,
+                        current_input,
+                    )
+                    for command in commands:
+                        yield Completion(
+                            command[len(current_input) :],
+                            start_position=0,
+                            display=command,
+                        )
+                    
+                    # 2. 自定义命令（从 .autocodercommands 目录）
+                    custom_commands = await loop.run_in_executor(
+                        executor,
+                        self._get_custom_commands,
+                    )
+                    for command in custom_commands:
+                        if command.startswith(current_input):
+                            yield Completion(
+                                command[len(current_input) :],
+                                start_position=0,
+                                display=command,
+                            )
+            finally:
+                executor.shutdown(wait=False)
+
+        # 异步获取基础补全器的补全
+        if self.base_completer:
+            # 如果基础补全器支持异步方法，优先使用
+            if hasattr(self.base_completer, "get_completions_async"):
+                async for completion in self.base_completer.get_completions_async(
+                    document, complete_event
+                ):
+                    yield completion
+            else:
+                # 否则在线程池中运行同步方法
+                loop = asyncio.get_event_loop()
+                executor = ThreadPoolExecutor(max_workers=1)
+                try:
+                    completions = await loop.run_in_executor(
+                        executor,
+                        list,
+                        self.base_completer.get_completions(document, complete_event),
+                    )
+                    for completion in completions:
+                        yield completion
+                finally:
+                    executor.shutdown(wait=False)
+
+    def _get_command_completions_list(self, command, current_input, completions):
+        """获取命令补全列表（用于异步执行）"""
+        return list(
+            self._process_command_completions(command, current_input, completions)
+        )

autocoder/terminal/ui/keybindings.py

@@ -0,0 +1,75 @@
+"""键盘绑定设置"""
+
+from prompt_toolkit.key_binding import KeyBindings
+from autocoder.common.terminal_paste import register_paste_handler
+
+
+def setup_keybindings(
+    plugin_manager,
+    voice_input_func,
+    cycle_mode_func,
+    toggle_human_as_model_func,
+    toggle_agentic_mode_func,
+    configure_func,
+):
+    """设置所有键盘绑定
+
+    Args:
+        plugin_manager: 插件管理器
+        voice_input_func: 语音输入函数
+        cycle_mode_func: 模式切换函数
+        toggle_human_as_model_func: 切换 human_as_model 函数
+        toggle_agentic_mode_func: 切换 agentic_mode 函数
+        configure_func: 配置函数
+
+    Returns:
+        KeyBindings: 配置好的键盘绑定对象
+    """
+    kb = KeyBindings()
+
+    # 捕获 Ctrl+C 和 Ctrl+D
+    @kb.add("c-c")
+    def _(event):
+        # 如果正在搜索，只重置搜索状态
+        if event.app.layout.is_searching:
+            event.app.current_buffer.history_search_text = None
+            event.app.current_buffer.reset()
+        
+
+    @kb.add("c-d")
+    def _(event):
+        event.app.exit(exception=EOFError)
+
+    @kb.add("tab")
+    def _(event):
+        b = event.current_buffer
+        if b.complete_state:
+            b.complete_next()
+        else:
+            b.start_completion(select_first=False)
+
+    @kb.add("c-g")
+    def _(event):
+        transcription = voice_input_func()
+        if transcription:
+            event.app.current_buffer.insert_text(transcription)
+
+    @kb.add("c-k")
+    def _(event):
+        cycle_mode_func()
+        event.app.invalidate()
+
+    @kb.add("c-n")
+    def _(event):
+        new_status_bool = toggle_human_as_model_func()
+        new_status = "true" if new_status_bool else "false"
+        configure_func(f"human_as_model:{new_status}", skip_print=True)
+        event.app.invalidate()
+    
+    # 注册粘贴处理器
+    register_paste_handler(kb)
+
+    # 应用插件的键盘绑定
+    plugin_manager.apply_keybindings(kb)
+
+    return kb

autocoder/terminal/ui/session.py

@@ -0,0 +1,41 @@
+"""会话管理"""
+
+from pathlib import Path
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+
+
+def create_session(completer, key_bindings, bottom_toolbar_func):
+    """创建 PromptSession
+
+    Args:
+        completer: 补全器
+        key_bindings: 键盘绑定
+        bottom_toolbar_func: 底部工具栏函数
+
+    Returns:
+        PromptSession: 配置好的会话对象
+    """
+    # 定义历史文件路径，使用 pathlib
+    history_file_path = (
+        Path.cwd()
+        / ".auto-coder"
+        / "auto-coder.chat"
+        / "history"
+        / "command_history.txt"
+    )
+    history_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 创建会话
+    session = PromptSession(
+        history=FileHistory(str(history_file_path)),
+        auto_suggest=AutoSuggestFromHistory(),
+        enable_history_search=False,
+        completer=completer,
+        complete_while_typing=False,
+        key_bindings=key_bindings,
+        bottom_toolbar=bottom_toolbar_func,
+    )
+
+    return session

autocoder/terminal/ui/toolbar.py

@@ -0,0 +1,64 @@
+"""底部工具栏"""
+
+import os
+from pathlib import Path
+
+
+def get_bottom_toolbar_func(
+    get_mode_func, get_human_as_model_string_func, get_agentic_mode_string_func, plugin_manager
+):
+    """创建底部工具栏函数
+
+    Args:
+        get_mode_func: 获取当前模式的函数
+        get_human_as_model_string_func: 获取 human_as_model 字符串的函数
+        get_agentic_mode_string_func: 获取 agentic_mode 字符串的函数
+        plugin_manager: 插件管理器
+
+    Returns:
+        callable: 返回工具栏内容的函数
+    """
+
+    def get_bottom_toolbar():
+        mode = get_mode_func()
+        human_as_model = get_human_as_model_string_func()
+        agentic_mode = get_agentic_mode_string_func()
+        MODES = {
+            "normal": "normal",
+            "auto_detect": "nature language auto detect",
+            "voice_input": "voice input",
+            "shell": "shell",
+        }
+        if mode not in MODES:
+            mode = "auto_detect"
+        pwd = os.getcwd()
+        pwd_parts = pwd.split(os.sep)
+        if len(pwd_parts) > 3:
+            pwd = os.sep.join(pwd_parts[-3:])
+
+        plugin_info = (
+            f"Plugins: {len(plugin_manager.plugins)}" if plugin_manager.plugins else ""
+        )
+
+        # 获取正在运行的 async 任务数量
+        async_tasks_info = ""
+        try:
+            from autocoder.sdk.async_runner.task_metadata import TaskMetadataManager
+
+            async_agent_dir = Path.home() / ".auto-coder" / "async_agent"
+            meta_dir = async_agent_dir / "meta"
+
+            if meta_dir.exists():
+                metadata_manager = TaskMetadataManager(str(meta_dir))
+                summary = metadata_manager.get_task_summary()
+                running_count = summary.get("running", 0)
+
+                if running_count > 0:
+                    async_tasks_info = f" | Async Tasks: 🔄 {running_count}"
+        except Exception:
+            # 静默处理异常，不影响底部工具栏的显示
+            pass
+
+        return f"PWD: {pwd} \nInput: {MODES[mode]} | Human as Model: {human_as_model} | Agentic Mode: {agentic_mode} | {plugin_info}{async_tasks_info}"
+
+    return get_bottom_toolbar

autocoder/terminal/utils/__init__.py

@@ -0,0 +1,13 @@
+"""工具函数模块"""
+
+from .paths import get_history_path, get_async_agent_meta_dir
+from .shell import get_shell, run_shell_command_async
+from .errors import print_error
+
+__all__ = [
+    "get_history_path",
+    "get_async_agent_meta_dir",
+    "get_shell",
+    "run_shell_command_async",
+    "print_error",
+]

autocoder/terminal/utils/errors.py

@@ -0,0 +1,18 @@
+"""错误处理工具函数"""
+
+import traceback
+
+
+def print_error(tag: str, exc: Exception, debug: bool = False):
+    """统一的错误打印函数
+
+    Args:
+        tag: 错误标签（如 "1", "2", "3"）
+        exc: 异常对象
+        debug: 是否打印详细堆栈
+    """
+    print(
+        f"\033[91m {tag}. An error occurred:\033[0m \033[93m{type(exc).__name__}\033[0m - {str(exc)}"
+    )
+    if debug:
+        traceback.print_exc()

autocoder/terminal/utils/paths.py

@@ -0,0 +1,19 @@
+"""路径相关工具函数，使用 pathlib 确保跨平台兼容"""
+
+from pathlib import Path
+
+
+def get_history_path(cwd: Path = None) -> Path:
+    """获取命令历史文件路径"""
+    if cwd is None:
+        cwd = Path.cwd()
+    history_path = (
+        cwd / ".auto-coder" / "auto-coder.chat" / "history" / "command_history.txt"
+    )
+    history_path.parent.mkdir(parents=True, exist_ok=True)
+    return history_path
+
+
+def get_async_agent_meta_dir() -> Path:
+    """获取异步代理元数据目录"""
+    return Path.home() / ".auto-coder" / "async_agent" / "meta"