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

autocoder/auto_coder_terminal.py

@@ -0,0 +1,26 @@
+"""
+Auto Coder Terminal - 新的终端入口
+
+这是重构后的终端交互入口，代码结构更清晰，职责更分明。
+原有的 chat_auto_coder.py 保持不变以保证向后兼容。
+"""
+
+from loguru import logger
+
+logger.remove()  # 把默认 sink 去掉，彻底静音
+
+from autocoder.run_context import get_run_context, RunMode
+
+# 设置运行模式为终端模式
+get_run_context().set_mode(RunMode.TERMINAL)
+
+from autocoder.terminal.bootstrap import run_cli
+
+
+def main():
+    """主入口函数"""
+    run_cli()
+
+
+if __name__ == "__main__":
+    main()

autocoder/auto_coder_terminal_v3.py

@@ -0,0 +1,190 @@
+"""
+Auto Coder Chat V3 - 入口文件
+
+这是重构后的终端交互入口，使用模块化的设计。
+"""
+
+from loguru import logger
+
+logger.remove()  # 把默认 sink 去掉，彻底静音
+
+from autocoder.run_context import get_run_context, RunMode
+
+# 设置运行模式为终端模式
+get_run_context().set_mode(RunMode.TERMINAL)
+
+import asyncio
+import argparse
+from pathlib import Path
+from autocoder.auto_coder_runner import (
+    load_tokenizer,
+    initialize_system,
+    InitializeSystemRequest,
+    configure,
+    start as start_engine,
+    completer,
+    ask,
+    coding,
+    chat,
+    design,
+    voice_input,
+    auto_command,
+    run_agentic,
+    execute_shell_command,
+    active_context,
+    get_mcp_server,
+    stop as stop_engine,
+)
+from autocoder.chat_auto_coder_lang import (
+    get_message,
+    get_message_with_format as get_message_with_format_local,
+)
+from autocoder.plugins import PluginManager
+from autocoder.terminal_v3 import AutoCoderChatApp
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description="Auto-Coder V3 - Claude-style Chat Interface"
+    )
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    parser.add_argument(
+        "--quick",
+        action="store_true",
+        help="Enter the auto-coder.chat without initializing the system",
+    )
+    parser.add_argument(
+        "--skip_provider_selection",
+        action="store_true",
+        help="Skip the provider selection",
+    )
+    parser.add_argument(
+        "--product_mode",
+        type=str,
+        default="lite",
+        help="The mode of the auto-coder.chat, lite/pro default is lite",
+    )
+    parser.add_argument("--lite", action="store_true", help="Lite mode")
+    parser.add_argument("--pro", action="store_true", help="Pro mode")
+    return parser.parse_args()
+
+def load_builtin_plugins(plugin_manager):
+    """加载内置插件"""
+    try:
+        # 发现所有可用的插件
+        discovered_plugins = plugin_manager.discover_plugins()
+
+        # 排除的示例插件列表
+        excluded_plugins = {
+            "autocoder.plugins.dynamic_completion_example",
+            "autocoder.plugins.sample_plugin",
+        }
+
+        # 自动加载内置插件（在autocoder.plugins模块中的插件）
+        builtin_loaded = 0
+        for plugin_class in discovered_plugins:
+            module_name = plugin_class.__module__
+            if (
+                module_name.startswith("autocoder.plugins.")
+                and not module_name.endswith(".__init__")
+                and module_name not in excluded_plugins
+            ):
+                try:
+                    if plugin_manager.load_plugin(plugin_class):
+                        builtin_loaded += 1
+                        print(f"✓ Loaded builtin plugin: {plugin_class.plugin_name()}")
+                except Exception as e:
+                    print(
+                        f"✗ Failed to load builtin plugin {plugin_class.plugin_name()}: {e}"
+                    )
+
+        if builtin_loaded > 0:
+            print(
+                get_message_with_format_local(
+                    "loaded_plugins_builtin", count=builtin_loaded
+                )
+            )
+        else:
+            print(get_message("no_builtin_plugins_loaded"))
+
+    except Exception as e:
+        print(f"Error loading builtin plugins: {e}")
+
+
+async def async_main():
+    """异步主函数"""
+    load_tokenizer()
+    args = parse_arguments()
+    
+    if args.lite:
+        args.product_mode = "lite"
+    
+    if args.pro:
+        args.product_mode = "pro"
+    
+    if not args.quick:
+        initialize_system(
+            InitializeSystemRequest(
+                product_mode=args.product_mode,
+                skip_provider_selection=args.skip_provider_selection,
+                debug=args.debug,
+                quick=args.quick,
+                lite=args.lite,
+                pro=args.pro,
+            )
+        )
+
+
+
+    # 启动引擎
+    start_engine()
+
+    # 初始化插件系统
+    plugin_manager = PluginManager()
+    plugin_manager.load_global_plugin_dirs()
+
+    # 添加内置插件目录
+    plugins_dir = Path(__file__).parent.parent / "plugins"
+    plugin_manager.add_global_plugin_directory(str(plugins_dir))
+
+    # 加载保存的运行时配置
+    plugin_manager.load_runtime_cfg()
+
+    # 自动加载内置插件
+    load_builtin_plugins(plugin_manager)
+
+    # 配置 product_mode
+    configure(f"product_mode:{args.product_mode}")
+
+    # 创建原始函数字典
+    original_functions = {
+        "ask": ask,
+        "coding": coding,
+        "chat": chat,
+        "design": design,
+        "voice_input": voice_input,
+        "auto_command": auto_command,
+        "run_agentic": run_agentic,
+        "execute_shell_command": execute_shell_command,
+        "active_context": active_context,
+    }
+
+    # 创建 wrapped functions
+    wrapped_functions = {}
+    for func_name, original_func in original_functions.items():
+        wrapped_functions[func_name] = plugin_manager.wrap_function(
+            original_func, func_name
+        )
+    
+    # 创建并运行聊天式 TUI 应用
+    chat_app = AutoCoderChatApp(plugin_manager=plugin_manager)
+    await chat_app.run()
+
+
+def main():
+    """同步入口函数，供 console_scripts 使用"""
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    main()

autocoder/chat/conf_command.py

@@ -9,14 +9,18 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
-from autocoder.auto_coder_runner import save_memory  # Import save_memory
 from autocoder.common.conf_validator import ConfigValidator
-from autocoder.common.auto_coder_lang import get_message, get_message_with_format
+from autocoder.common.international import get_message, get_message_with_format
+from autocoder.common.ac_style_command_parser import create_config, parse_typed_query
+
+# Import core_config functions for direct configuration management
+from autocoder.common.core_config import get_memory_manager
 
 # Helper function to print the configuration table (internal implementation)
 def _print_conf_table(content: Dict[str, Any], title: str = "Configuration Settings"):
     """Display configuration dictionary in a Rich table format."""
-    console = Console(file=io.StringIO(), force_terminal=True, color_system="truecolor") # Capture output
+    output_buffer = io.StringIO()
+    console = Console(file=output_buffer, force_terminal=True, color_system="truecolor") # Capture output
 
     # Create a styled table with rounded borders
     table = Table(
@@ -54,39 +58,40 @@ def _print_conf_table(content: Dict[str, Any], title: str = "Configuration Setti
         subtitle=f"[italic]{get_message('conf_subtitle')}[/italic]",
         border_style="blue"
     ))
-    return console.file.getvalue() # Return captured string
+    return output_buffer.getvalue() # Return captured string
 
 # --- Command Handlers ---
 
-def _handle_list_conf(memory: Dict[str, Any], args: List[str]) -> str:
+def _handle_list_conf(args: List[str]) -> str:
     """Handles listing configuration settings, supports wildcard filtering."""
-    conf = memory.get("conf", {})
+    memory_manager = get_memory_manager()
+    conf = memory_manager.get_all_config()
     pattern = args[0] if args else "*" # Default to all if no pattern
 
     if pattern == "*":
         title = get_message("conf_title")
         filtered_conf = conf
     else:
-        title = f"Filtered Configuration (Pattern: {pattern})"
+        title = get_message_with_format("conf_filtered_title", pattern=pattern)
         filtered_conf = {k: v for k, v in conf.items() if fnmatch.fnmatch(k, pattern)}
         if not filtered_conf:
-            return f"No configuration keys found matching pattern: {pattern}"
+            return get_message_with_format("conf_no_pattern_matches", pattern=pattern)
 
     if not filtered_conf and pattern == "*":
-        return "No configurations set."
+        return get_message("conf_no_configs_found")
 
     return _print_conf_table(filtered_conf, title)
 
 
-def _handle_get_conf(memory: Dict[str, Any], args: List[str]) -> str:
+def _handle_get_conf(args: List[str]) -> str:
     """Handles getting a specific configuration setting."""
     if len(args) != 1:
-        return "Error: 'get' command requires exactly one argument (the key). Usage: /conf get <key>"
+        return get_message("conf_get_error_args")
     key = args[0]
-    conf = memory.get("conf", {})
-    value = conf.get(key)
+    memory_manager = get_memory_manager()
+    value = memory_manager.get_config(key)
     if value is None:
-        return f"Error: Configuration key '{key}' not found."
+        return get_message_with_format("conf_get_error_not_found", key=key)
     else:
         # Format value for better readability
         if isinstance(value, (list, dict)):
@@ -122,150 +127,245 @@ def _parse_value(value_str: str) -> Any:
     # If none of the above, return as string
     return value_str
 
-def _handle_set_conf(memory: Dict[str, Any], args: List[str]) -> str:
+def _handle_set_conf(args: List[str]) -> str:
     """Handles setting or updating a configuration setting."""
     if len(args) < 2:
-        return "Error: 'set' command requires at least two arguments (key and value). Usage: /conf set <key> <value>"
+        return get_message("conf_set_error_args")
     key = args[0]
     # Join the rest of the arguments to form the value string
     value_str = " ".join(args[1:])
     try:
         parsed_value = _parse_value(value_str)
 
-        # Validate before setting
-        product_mode = memory.get("conf", {}).get("product_mode", "lite")
+        # Get memory manager and validate before setting
+        memory_manager = get_memory_manager()
+        product_mode = memory_manager.get_config("product_mode", "lite")
         ConfigValidator.validate(key, str(parsed_value), product_mode) # Validate the parsed value as string initially if needed, or adjust validation
 
-        if "conf" not in memory:
-            memory["conf"] = {}
-        memory["conf"][key] = parsed_value
-        save_memory() # Save after modification
+        # Set configuration using MemoryManager
+        memory_manager.set_config(key, parsed_value)
+        
         # Use repr for confirmation message for clarity
-        return f"Configuration updated: {key} = {repr(parsed_value)}"
+        return get_message_with_format("conf_set_success", key=key, value=repr(parsed_value))
     except Exception as e:
-        return f"Error setting configuration for key '{key}': {e}"
+        return get_message_with_format("conf_set_error", key=key, error=str(e))
 
-def _handle_delete_conf(memory: Dict[str, Any], args: List[str]) -> str:
-    """Handles deleting a configuration setting."""
+def _handle_delete_conf(args: List[str]) -> str:
+    """Handles deleting configuration settings. Supports multiple keys separated by commas."""
     if len(args) != 1:
-        return "Error: 'delete' command requires exactly one argument (the key). Usage: /conf delete <key>"
-    key = args[0]
-    conf = memory.get("conf", {})
-    if key in conf:
-        try:
-            del memory["conf"][key]
-            save_memory() # Save after modification
-            return f"Configuration deleted: {key}"
-        except Exception as e:
-            return f"Error deleting key '{key}': {e}"
-    else:
-        return f"Error: Configuration key '{key}' not found."
+        return get_message("conf_delete_error_args")
+    
+    # 支持逗号分隔的多个key
+    keys_str = args[0]
+    keys = [key.strip() for key in keys_str.split(',') if key.strip()]
+    
+    if not keys:
+        return "Error: No valid keys provided for deletion."
+    
+    memory_manager = get_memory_manager()
+    results = []
+    deleted_keys = []
+    not_found_keys = []
+    error_keys = []
+    
+    for key in keys:
+        if memory_manager.has_config(key):
+            try:
+                memory_manager.delete_config(key)
+                deleted_keys.append(key)
+            except Exception as e:
+                error_keys.append(f"{key} ({str(e)})")
+        else:
+            not_found_keys.append(key)
+    
+    # 构建返回消息
+    messages = []
+    if deleted_keys:
+        if len(deleted_keys) == 1:
+            messages.append(get_message_with_format("conf_delete_success", key=deleted_keys[0]))
+        else:
+            messages.append(f"Successfully deleted configurations: {', '.join(deleted_keys)}")
+    
+    if not_found_keys:
+        if len(not_found_keys) == 1:
+            messages.append(get_message_with_format("conf_delete_not_found", key=not_found_keys[0]))
+        else:
+            messages.append(f"Configurations not found: {', '.join(not_found_keys)}")
+    
+    if error_keys:
+        messages.append(f"Failed to delete: {', '.join(error_keys)}")
+    
+    return '\n'.join(messages)
 
 
-def _handle_help(memory: Dict[str, Any], args: List[str]) -> str:
+def _handle_help(args: List[str]) -> str:
     """Provides help text for the /conf command."""
     if args:
-        return f"Error: 'help' command takes no arguments. Usage: /conf help"
+        return get_message("conf_help_args_error")
 
-    help_text = """
-/conf command usage:
-  /conf [pattern]    - Show configurations. Optional wildcard pattern (e.g., *_model, api*).  
-  /conf get <key>    - Get the value of a specific configuration key.
-  /conf set <key>:<value> - Set or update a configuration key.
-                       Value parsed (bool, int, float, None) or treated as string.
-                       Use quotes ("value with spaces") for explicit strings.
-  /conf /drop <key> - Delete a configuration key.
-  /conf /export <path> - Export current configuration to a file.
-  /conf /import <path> - Import configuration from a file.
-  /conf help         - Show this help message.
-    """
-    return help_text.strip()
+    help_text = get_message("conf_help_text")    
+    return help_text
 
 # Command dispatch table
-COMMAND_HANDLERS: Dict[str, Callable[[Dict[str, Any], List[str]], str]] = {
-    "/list": _handle_list_conf,
-    "/show": _handle_list_conf, # Alias
-    "/get": _handle_get_conf,
-    "/set": _handle_set_conf,
-    "/delete": _handle_delete_conf,
-    "/del": _handle_delete_conf,    # Alias
-    "/rm": _handle_delete_conf,     # Alias
-    "/drop": _handle_delete_conf,  # Add this line for /drop command
-    "/help": _handle_help,
+COMMAND_HANDLERS: Dict[str, Callable[[List[str]], str]] = {
+    "list": _handle_list_conf,
+    "show": _handle_list_conf, # Alias
+    "get": _handle_get_conf,
+    "set": _handle_set_conf,
+    "delete": _handle_delete_conf,
+    "del": _handle_delete_conf,    # Alias
+    "rm": _handle_delete_conf,     # Alias
+    "drop": _handle_delete_conf,  # Add this line for /drop command
+    "help": _handle_help,
 }
 
-def handle_conf_command(command_args: str, memory: Dict[str, Any]) -> str:
+def handle_conf_command(command_args: str) -> str:
     """
-    Handles the /conf command, its subcommands, and wildcard listing.
+    处理配置命令，支持两种格式：
+    1. 双斜杠格式（/conf /command）
+    2. 键值对格式（/conf key:value）
+    
+    支持的命令格式：
+    - /conf /list [pattern]     - 列出配置（可带过滤模式）
+    - /conf /show [pattern]     - 列出配置（list的别名）
+    - /conf /get <key>          - 获取单个配置
+    - /conf /set <key> <value>  - 设置配置
+    - /conf /delete <key>       - 删除配置
+    - /conf /del <key>          - 删除配置（别名）
+    - /conf /rm <key>           - 删除配置（别名）
+    - /conf /drop <key>         - 删除配置（别名）
+    - /conf /help               - 显示帮助
+    - /conf /export <path>      - 导出配置
+    - /conf /import <path>      - 导入配置
+    - /conf key:value           - 设置配置（简化格式）
 
     Args:
-        command_args: The arguments string following the /conf command.
-                      Example: "key:value", "get key", "set key value", "*_model", "/export path"
-        memory: The current session memory dictionary.
+        command_args: 命令参数字符串
 
     Returns:
-        A string response to be displayed to the user.
+        str: 返回给用户的响应字符串
     """
-    conf_str = command_args.strip()        
-
-    # Handle special subcommands first
-    if conf_str.startswith("/export"):
-        from autocoder.common.conf_import_export import export_conf
-        export_path = conf_str[len("/export"):].strip()
-        if not export_path:
+    conf_str = command_args.strip()
+    
+    # 检查是否为 key:value 格式
+    if ':' in conf_str and not conf_str.startswith('/'):
+        # 解析 key:value 格式
+        parts = conf_str.split(':', 1)  # 只分割第一个冒号
+        if len(parts) == 2:
+            key = parts[0].strip()
+            value = parts[1].strip()
+            return _handle_set_conf([key, value])
+        else:
+            return f"Error: Invalid key:value format. Usage: /conf key:value"
+    
+    # 创建配置解析器
+    config = (create_config()
+        .collect_remainder("query")  # 收集剩余参数
+        .command("list")
+        .positional("pattern")  # 可选的过滤模式
+        .max_args(1)  # 列出配置
+        .command("show")  # list的别名
+        .positional("pattern")
+        .max_args(1)
+        .command("get")
+        .positional("key", required=True)
+        .max_args(1)  # 获取单个配置
+        .command("set")
+        .positional("key", required=True)
+        .positional("value", required=True)
+        .max_args(2)  # 设置配置
+        .command("delete")
+        .collect_remainder("keys")  # 收集所有剩余参数以支持逗号分隔的多个key
+        .command("del")  # delete的别名
+        .collect_remainder("keys")
+        .command("rm")  # delete的别名
+        .collect_remainder("keys")
+        .command("drop")  # delete的别名
+        .collect_remainder("keys")
+        .command("help")
+        .max_args(0)  # 显示帮助
+        .command("export")
+        .positional("path", required=True)
+        .max_args(1)  # 导出配置
+        .command("import")
+        .positional("path", required=True)
+        .max_args(1)  # 导入配置
+        .build()
+    )
+    
+    if not conf_str:
+        # 默认显示所有配置
+        return _handle_list_conf([])
+    
+    # 解析命令
+    result = parse_typed_query(conf_str, config)
+    
+    # 检查各种子命令
+    if result.has_command("list"):
+        list_cmd = result.get_command("list")
+        pattern = list_cmd.args[0] if list_cmd.args else "*"
+        return _handle_list_conf([pattern] if pattern != "*" else [])
+    
+    if result.has_command("show"):
+        show_cmd = result.get_command("show")
+        pattern = show_cmd.args[0] if show_cmd.args else "*"
+        return _handle_list_conf([pattern] if pattern != "*" else [])
+    
+    if result.has_command("get"):
+        get_cmd = result.get_command("get")
+        if not get_cmd.args:
+            return "Error: 'get' command requires exactly one argument (the key). Usage: /conf /get <key>"
+        return _handle_get_conf([get_cmd.args[0]])
+    
+    if result.has_command("set"):
+        set_cmd = result.get_command("set")
+        if len(set_cmd.args) < 2:
+            return "Error: 'set' command requires exactly two arguments (key and value). Usage: /conf /set <key> <value>"
+        return _handle_set_conf([set_cmd.args[0], set_cmd.args[1]])
+    
+    if result.has_command("delete") or result.has_command("del") or result.has_command("rm") or result.has_command("drop"):
+        # 查找删除命令
+        delete_cmd = None
+        for cmd_name in ["delete", "del", "rm", "drop"]:
+            if result.has_command(cmd_name):
+                delete_cmd = result.get_command(cmd_name)
+                break
+        
+        if not delete_cmd or not delete_cmd.remainder:
+            return "Error: 'delete' command requires at least one key. Usage: /conf /delete <key> or /conf /delete <key1,key2,key3>"
+        
+        # remainder 已经是一个字符串，直接传递给处理函数
+        keys_str = delete_cmd.remainder
+        return _handle_delete_conf([keys_str])
+    
+    if result.has_command("help"):
+        return _handle_help([])
+    
+    if result.has_command("export"):
+        export_cmd = result.get_command("export")
+        if not export_cmd.args:
             return "Error: Please specify a path for export. Usage: /conf /export <path>"
+        
+        export_path = export_cmd.args[0]
         try:
+            from autocoder.common.conf_import_export import export_conf
             export_conf(os.getcwd(), export_path)
-            return f"Configuration exported successfully to {export_path}"
+            return get_message_with_format("conf_export_success", path=export_path)
         except Exception as e:
-            return f"Error exporting configuration: {e}"
-    elif conf_str.startswith("/import"):
-        from autocoder.common.conf_import_export import import_conf
-        import_path = conf_str[len("/import"):].strip()
-        if not import_path:
+            return get_message_with_format("conf_export_error", error=str(e))
+    
+    if result.has_command("import"):
+        import_cmd = result.get_command("import")
+        if not import_cmd.args:
             return "Error: Please specify a path for import. Usage: /conf /import <path>"
+        
+        import_path = import_cmd.args[0]
         try:
+            from autocoder.common.conf_import_export import import_conf
             import_conf(os.getcwd(), import_path)
-            # Reload memory after import might be needed depending on import_conf implementation
-            # load_memory() # Consider if import_conf modifies the passed memory or global state
-            return f"Configuration imported successfully from {import_path}. Use '/conf' to see changes."
+            return get_message_with_format("conf_import_success", path=import_path)
         except Exception as e:
-            return f"Error importing configuration: {e}"
-
-    # Handle regular commands and listing/filtering
-    args = conf_str.split()
-
-    if not args:
-        # Default action: list all configurations
-        return _handle_list_conf(memory, [])
-    else:
-        command = args[0].lower()
-        command_args_list = args[1:]        
-
-        # Check if the first argument is a known command or potentially a pattern
-        handler = COMMAND_HANDLERS.get(command)
-
-        if handler:
-            # It's a known command (list, get, set, delete, help)
-            try:
-                return handler(memory, command_args_list)
-            except Exception as e:
-                return f"An unexpected error occurred while executing '/conf {command}': {e}"
-        elif "*" in command or "?" in command:
-             # Treat as a list/filter pattern if it contains wildcards and is not a known command
-             return _handle_list_conf(memory, [command]) # Pass the pattern as the argument to list
-        else:
-            # Handle legacy key:value format for setting (optional, can be removed if only set command is preferred)
-            if ":" in conf_str and len(args) == 1: # Check if it looks like key:value and is a single "word"
-                 parts = conf_str.split(":", 1)
-                 if len(parts) == 2:
-                     key, value_str = parts[0].strip(), parts[1].strip()
-                     if key and value_str:
-                         return _handle_set_conf(memory, [key, value_str])
-                     else:
-                         return f"Error: Invalid key:value format in '{conf_str}'. Use '/conf set {key} {value_str}' or '/conf help'."
-                 else:
-                      return f"Error: Unknown command or invalid format '{conf_str}'. Type '/conf help' for available commands."
-            else:
-                # If it's not a known command, not a wildcard, and not key:value format
-                return f"Error: Unknown command '/conf {command}'. Type '/conf help' for available commands."
+            return get_message_with_format("conf_import_error", error=str(e))
+    
+    # 未知命令
+    return f"Error: Unknown command '/conf {conf_str}'. Type '/conf /help' for available commands."