auto-coder 0.1.268__py3-none-any.whl → 0.1.269__py3-none-any.whl

autocoder/chat_auto_coder.py

@@ -1,73 +1,53 @@
-from itertools import product
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.shortcuts import radiolist_dialog
-from prompt_toolkit import prompt
+
+
+import argparse
 import os
-import yaml
-import json
-import sys
-import io
-import uuid
-import glob
-import time
-import hashlib
-from contextlib import contextmanager
-from typing import List, Dict, Any, Optional
 from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.styles import Style
-from prompt_toolkit.formatted_text import FormattedText
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.completion import WordCompleter, Completer, Completion
-from prompt_toolkit.shortcuts import confirm
-from autocoder.common import AutoCoderArgs
-from pydantic import Field, BaseModel
-from autocoder.common.result_manager import ResultManager
 from autocoder.version import __version__
-from autocoder.auto_coder import main as auto_coder_main
-from autocoder.common.command_completer import CommandTextParser
-from autocoder.utils import get_last_yaml_file
-from autocoder.index.symbols_utils import (
-    extract_symbols,
-    SymbolType,
-)
-import platform
-import subprocess
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-from rich.live import Live
-from rich.text import Text
-from rich.live import Live
-from rich.markdown import Markdown
-from byzerllm.utils.nontext import Image
-import git
-from autocoder.common import git_utils
 from autocoder.chat_auto_coder_lang import get_message
-from autocoder.utils import operate_config_api
-from autocoder.agent.auto_guess_query import AutoGuessQuery
-from autocoder.common.mcp_server import get_mcp_server, McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, McpListRunningRequest, McpRefreshRequest
-import byzerllm
-from byzerllm.utils import format_str_jinja2
-from autocoder.common.memory_manager import get_global_memory_file_paths 
-from autocoder import models as models_module
-import shlex
-from autocoder.utils.llms import get_single_llm
-import pkg_resources
-from autocoder.common.printer import Printer
-from autocoder.utils.thread_utils import run_in_thread,run_in_raw_thread
-from autocoder.common.command_completer import CommandCompleter,FileSystemModel as CCFileSystemModel,MemoryConfig as CCMemoryModel
-from autocoder.common.conf_validator import ConfigValidator
-
-class SymbolItem(BaseModel):
-    symbol_name: str
-    symbol_type: SymbolType
-    file_name: str
-
+from prompt_toolkit.formatted_text import FormattedText
+from autocoder.auto_coder_runner import (
+    auto_command,
+    load_memory,
+    save_memory,
+    configure,    
+    manage_models,
+    print_conf,    
+    exclude_dirs,
+    exclude_files,
+    ask,
+    coding,
+    load_tokenizer,
+    initialize_system,
+    InitializeSystemRequest,
+    add_files,
+    remove_files,
+    index_query,
+    index_build,
+    index_export,
+    index_import,
+    list_files,
+    lib_command,
+    mcp,
+    revert,
+    commit,
+    design,    
+    voice_input,
+    chat,
+    gen_and_exec_shell_command,
+    execute_shell_command,
+    get_mcp_server,
+    completer,
+    summon,  
+    get_memory  
+)
 
 def parse_arguments():
-    import argparse
+    
 
     parser = argparse.ArgumentParser(description="Chat Auto Coder")
     parser.add_argument("--debug", action="store_true",
@@ -97,60 +77,6 @@ def parse_arguments():
     return parser.parse_args()
 
 
-ARGS = None
-
-if platform.system() == "Windows":
-    from colorama import init
-
-    init()
-
-
-memory = {
-    "conversation": [],
-    "current_files": {"files": [], "groups": {}},
-    "conf": {},
-    "exclude_dirs": [],
-    "mode": "auto_detect",  # 新增mode字段,默认为 auto_detect 模式
-}
-
-project_root = os.getcwd()
-
-base_persist_dir = os.path.join(".auto-coder", "plugins", "chat-auto-coder")
-
-defaut_exclude_dirs = [".git", "node_modules", "dist", "build", "__pycache__"]
-
-commands = [
-    "/add_files",
-    "/remove_files",
-    "/list_files",
-    "/conf",
-    "/coding",
-    "/chat",
-    "/ask",
-    "/commit",
-    "/revert",
-    "/index/query",
-    "/index/build",
-    "/index/export",
-    "/index/import",
-    "/exclude_files",        
-    "/help",
-    "/shell",
-    "/voice_input",
-    "/exit",
-    "/summon",
-    "/mode",
-    "/lib",
-    "/design",
-    "/mcp",
-    "/models",
-    "/auto",
-    "/conf/export",
-    "/conf/import",
-    "/exclude_dirs",
-]
-
-
 def show_help():
     print(f"\033[1m{get_message('official_doc')}\033[0m")
     print()
@@ -212,2521 +138,11 @@ def show_help():
         f"  \033[94m/exit\033[0m - \033[92m{get_message('exit_desc')}\033[0m")
     print()
 
-
-def configure_project_type():
-    from prompt_toolkit.lexers import PygmentsLexer
-    from pygments.lexers.markup import MarkdownLexer
-    from prompt_toolkit.formatted_text import HTML
-    from prompt_toolkit.shortcuts import print_formatted_text
-    from prompt_toolkit.styles import Style
-    from html import escape
-
-    style = Style.from_dict(
-        {
-            "info": "#ansicyan",
-            "warning": "#ansiyellow",
-            "input-area": "#ansigreen",
-            "header": "#ansibrightyellow bold",
-        }
-    )
-
-    def print_info(text):
-        print_formatted_text(HTML(f"<info>{escape(text)}</info>"), style=style)
-
-    def print_warning(text):
-        print_formatted_text(
-            HTML(f"<warning>{escape(text)}</warning>"), style=style)
-
-    def print_header(text):
-        print_formatted_text(
-            HTML(f"<header>{escape(text)}</header>"), style=style)
-
-    print_header(f"\n=== {get_message('project_type_config')} ===\n")
-    print_info(get_message("project_type_supports"))
-    print_info(get_message("language_suffixes"))
-    print_info(get_message("predefined_types"))
-    print_info(get_message("mixed_projects"))
-    print_info(get_message("examples"))
-
-    print_warning(f"{get_message('default_type')}\n")
-
-    project_type = prompt(
-        get_message("enter_project_type"), default="py", style=style
-    ).strip()
-
-    if project_type:
-        configure(f"project_type:{project_type}", skip_print=True)
-        configure("skip_build_index:false", skip_print=True)
-        print_info(f"\n{get_message('project_type_set')} {project_type}")
-    else:
-        print_info(f"\n{get_message('using_default_type')}")
-
-    print_warning(f"\n{get_message('change_setting_later')}:")
-    print_warning("/conf project_type:<new_type>\n")
-
-    return project_type
-
-
-def initialize_system(args):
-    from autocoder.utils.model_provider_selector import ModelProviderSelector
-    from autocoder import models as models_module
-    print(f"\n\033[1;34m{get_message('initializing')}\033[0m")
-
-    first_time = [False]
-    configure_success = [False]
-
-    def print_status(message, status):
-        if status == "success":
-            print(f"\033[32m✓ {message}\033[0m")
-        elif status == "warning":
-            print(f"\033[33m! {message}\033[0m")
-        elif status == "error":
-            print(f"\033[31m✗ {message}\033[0m")
-        else:
-            print(f"  {message}")
-
-    def init_project():        
-        if not os.path.exists(".auto-coder"):
-            first_time[0] = True
-            print_status(get_message("not_initialized"), "warning")
-            init_choice = input(
-                f"  {get_message('init_prompt')}").strip().lower()
-            if init_choice == "y":
-                try:
-                    subprocess.run(
-                        ["auto-coder", "init", "--source_dir", "."], check=True
-                    )
-                    print_status(get_message("init_success"), "success")
-                except subprocess.CalledProcessError:
-                    print_status(get_message("init_fail"), "error")
-                    print_status(get_message("init_manual"), "warning")
-                    exit(1)
-            else:
-                print_status(get_message("exit_no_init"), "warning")
-                exit(1)
-
-        if not os.path.exists(base_persist_dir):
-            os.makedirs(base_persist_dir, exist_ok=True)
-            print_status(get_message("created_dir").format(
-                base_persist_dir), "success")
-
-        if first_time[0]:
-            configure_project_type()
-            configure_success[0] = True
-
-        print_status(get_message("init_complete"), "success")
-
-    init_project()
-
-    if not args.skip_provider_selection and first_time[0]:
-        if args.product_mode == "lite":                    
-            ## 如果已经是配置过的项目，就无需再选择
-            if first_time[0]:
-                if not models_module.check_model_exists("v3_chat") or not models_module.check_model_exists("r1_chat"):
-                    model_provider_selector = ModelProviderSelector()
-                    model_provider_info = model_provider_selector.select_provider()
-                    if model_provider_info is not None:
-                        models_json_list = model_provider_selector.to_models_json(model_provider_info)
-                        models_module.add_and_activate_models(models_json_list)              
-
-        if args.product_mode == "pro":
-            # Check if Ray is running
-            print_status(get_message("checking_ray"), "")
-            ray_status = subprocess.run(
-                ["ray", "status"], capture_output=True, text=True)
-            if ray_status.returncode != 0:
-                print_status(get_message("ray_not_running"), "warning")
-                try:
-                    subprocess.run(["ray", "start", "--head"], check=True)
-                    print_status(get_message("ray_start_success"), "success")
-                except subprocess.CalledProcessError:
-                    print_status(get_message("ray_start_fail"), "error")
-                    return
-            else:
-                print_status(get_message("ray_running"), "success")
-
-            # Check if deepseek_chat model is available
-            print_status(get_message("checking_model"), "")
-            try:
-                result = subprocess.run(
-                    ["easy-byzerllm", "chat", "v3_chat", "你好"],
-                    capture_output=True,
-                    text=True,
-                    timeout=30,
-                )
-                if result.returncode == 0:
-                    print_status(get_message("model_available"), "success")
-                    init_project()
-                    print_status(get_message("init_complete_final"), "success")
-                    return
-            except subprocess.TimeoutExpired:
-                print_status(get_message("model_timeout"), "error")
-            except subprocess.CalledProcessError:
-                print_status(get_message("model_error"), "error")
-
-            # If deepseek_chat is not available
-            print_status(get_message("model_not_available"), "warning")
-            api_key = prompt(HTML(f"<b>{get_message('enter_api_key')} </b>"))
-
-            print_status(get_message("deploying_model").format("Deepseek官方"), "")
-            deploy_cmd = [
-                "byzerllm",
-                "deploy",
-                "--pretrained_model_type",
-                "saas/openai",
-                "--cpus_per_worker",
-                "0.001",
-                "--gpus_per_worker",
-                "0",
-                "--worker_concurrency",
-                "1000",
-                "--num_workers",
-                "1",
-                "--infer_params",
-                f"saas.base_url=https://api.deepseek.com/v1 saas.api_key={api_key} saas.model=deepseek-chat",
-                "--model",
-                "v3_chat",
-            ]
-
-            try:
-                subprocess.run(deploy_cmd, check=True)
-                print_status(get_message("deploy_complete"), "success")
-            except subprocess.CalledProcessError:
-                print_status(get_message("deploy_fail"), "error")
-                return
-
-
-            deploy_cmd = [
-                "byzerllm",
-                "deploy",
-                "--pretrained_model_type",
-                "saas/reasoning_openai",
-                "--cpus_per_worker",
-                "0.001",
-                "--gpus_per_worker",
-                "0",
-                "--worker_concurrency",
-                "1000",
-                "--num_workers",
-                "1",
-                "--infer_params",
-                f"saas.base_url=https://api.deepseek.com/v1 saas.api_key={api_key} saas.model=deepseek-reasoner",
-                "--model",
-                "r1_chat",
-            ]
-
-            try:
-                subprocess.run(deploy_cmd, check=True)
-                print_status(get_message("deploy_complete"), "success")
-            except subprocess.CalledProcessError:
-                print_status(get_message("deploy_fail"), "error")
-                return
-
-            # Validate the deployment
-            print_status(get_message("validating_deploy"), "")
-            try:
-                validation_result = subprocess.run(
-                    ["easy-byzerllm", "chat", "v3_chat", "你好"],
-                    capture_output=True,
-                    text=True,
-                    timeout=30,
-                    check=True,
-                )
-                print_status(get_message("validation_success"), "success")
-            except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
-                print_status(get_message("validation_fail"), "error")
-                print_status(get_message("manual_start"), "warning")
-                print_status("easy-byzerllm chat v3_chat 你好", "")
-
-            print_status(get_message("init_complete_final"), "success")  
-            configure_success[0] = True
-
-    if first_time[0] and args.product_mode == "pro" and configure_success[0]:
-        configure(f"model:v3_chat", skip_print=True)
-        configure(f"chat_model:r1_chat", skip_print=True)
-        configure(f"generate_rerank_model:r1_chat", skip_print=True)
-        configure(f"code_model:v3_chat", skip_print=True)
-        configure(f"index_filter_model:r1_chat", skip_print=True)  
-
-    if first_time[0] and args.product_mode == "lite" and models_module.check_model_exists("v3_chat"):
-        configure(f"model:v3_chat", skip_print=True)
-        configure(f"chat_model:r1_chat", skip_print=True)
-        configure(f"generate_rerank_model:r1_chat", skip_print=True)
-        configure(f"code_model:v3_chat", skip_print=True)
-        configure(f"index_filter_model:r1_chat", skip_print=True)
-
-
-def convert_yaml_config_to_str(yaml_config):
-    yaml_content = yaml.safe_dump(
-        yaml_config,
-        allow_unicode=True,
-        default_flow_style=False,
-        default_style=None,
-    )
-    return yaml_content
-
-
-def get_all_file_names_in_project() -> List[str]:
-
-    file_names = []
-    final_exclude_dirs = defaut_exclude_dirs + memory.get("exclude_dirs", [])
-    for root, dirs, files in os.walk(project_root, followlinks=True):
-        dirs[:] = [d for d in dirs if d not in final_exclude_dirs]
-        file_names.extend(files)
-    return file_names
-
-
-def get_all_file_in_project() -> List[str]:
-
-    file_names = []
-    final_exclude_dirs = defaut_exclude_dirs + memory.get("exclude_dirs", [])
-    for root, dirs, files in os.walk(project_root, followlinks=True):
-        dirs[:] = [d for d in dirs if d not in final_exclude_dirs]
-        for file in files:
-            file_names.append(os.path.join(root, file))
-    return file_names
-
-
-def get_all_file_in_project_with_dot() -> List[str]:
-    file_names = []
-    final_exclude_dirs = defaut_exclude_dirs + memory.get("exclude_dirs", [])
-    for root, dirs, files in os.walk(project_root, followlinks=True):
-        dirs[:] = [d for d in dirs if d not in final_exclude_dirs]
-        for file in files:
-            file_names.append(os.path.join(
-                root, file).replace(project_root, "."))
-    return file_names
-
-
-def get_all_dir_names_in_project() -> List[str]:
-    dir_names = []
-    final_exclude_dirs = defaut_exclude_dirs + memory.get("exclude_dirs", [])
-    for root, dirs, files in os.walk(project_root, followlinks=True):
-        dirs[:] = [d for d in dirs if d not in final_exclude_dirs]
-        for dir in dirs:
-            dir_names.append(dir)
-    return dir_names
-
-
-def find_files_in_project(patterns: List[str]) -> List[str]:
-    matched_files = []
-    final_exclude_dirs = defaut_exclude_dirs + memory.get("exclude_dirs", [])
-
-    for pattern in patterns:
-        if "*" in pattern or "?" in pattern:
-            for file_path in glob.glob(pattern, recursive=True):
-                if os.path.isfile(file_path):
-                    abs_path = os.path.abspath(file_path)
-                    if not any(
-                        exclude_dir in abs_path.split(os.sep)
-                        for exclude_dir in final_exclude_dirs
-                    ):
-                        matched_files.append(abs_path)
-        else:
-            is_added = False
-            # add files belongs to project
-            for root, dirs, files in os.walk(project_root, followlinks=True):
-                dirs[:] = [d for d in dirs if d not in final_exclude_dirs]
-                if pattern in files:
-                    matched_files.append(os.path.join(root, pattern))
-                    is_added = True
-                else:
-                    for file in files:
-                        _pattern = os.path.abspath(pattern)
-                        if _pattern in os.path.join(root, file):
-                            matched_files.append(os.path.join(root, file))
-                            is_added = True
-            # add files not belongs to project
-            if not is_added:
-                matched_files.append(pattern)
-
-    return list(set(matched_files))
-
-
-def convert_config_value(key, value):
-    field_info = AutoCoderArgs.model_fields.get(key)
-    if field_info:
-        if value.lower() in ["true", "false"]:
-            return value.lower() == "true"
-        elif "int" in str(field_info.annotation):
-            return int(value)
-        elif "float" in str(field_info.annotation):
-            return float(value)
-        else:
-            return value
-    else:
-        print(f"Invalid configuration key: {key}")
-        return None
-
-
-@contextmanager
-def redirect_stdout():
-    original_stdout = sys.stdout
-    sys.stdout = f = io.StringIO()
-    try:
-        yield f
-    finally:
-        sys.stdout = original_stdout
-
-
-def configure(conf: str, skip_print=False):
-    printer = Printer()
-    parts = conf.split(None, 1)
-    if len(parts) == 2 and parts[0] in ["/drop", "/unset", "/remove"]:
-        key = parts[1].strip()
-        if key in memory["conf"]:
-            del memory["conf"][key]
-            save_memory()
-            printer.print_in_terminal("config_delete_success", style="green", key=key)
-        else:
-            printer.print_in_terminal("config_not_found", style="yellow", key=key)
-    else:
-        parts = conf.split(":", 1)
-        if len(parts) != 2:
-            printer.print_in_terminal("config_invalid_format", style="red")
-            return
-        key, value = parts
-        key = key.strip()
-        value = value.strip()
-        if not value:
-            printer.print_in_terminal("config_value_empty", style="red")
-            return
-        product_mode = memory["conf"].get("product_mode",None)  
-        if product_mode:
-            ConfigValidator.validate(key, value, product_mode)    
-        memory["conf"][key] = value
-        save_memory()
-        if not skip_print:
-            printer.print_in_terminal("config_set_success", style="green", key=key, value=value)
-
-# word_completer = WordCompleter(commands)
-
-
-def get_symbol_list() -> List[SymbolItem]:
-    list_of_symbols = []
-    index_file = os.path.join(".auto-coder", "index.json")
-
-    if os.path.exists(index_file):
-        with open(index_file, "r",encoding="utf-8") as file:
-            index_data = json.load(file)
-    else:
-        index_data = {}
-
-    for item in index_data.values():
-        symbols_str = item["symbols"]
-        module_name = item["module_name"]
-        info1 = extract_symbols(symbols_str)
-        for name in info1.classes:
-            list_of_symbols.append(
-                SymbolItem(
-                    symbol_name=name,
-                    symbol_type=SymbolType.CLASSES,
-                    file_name=module_name,
-                )
-            )
-        for name in info1.functions:
-            list_of_symbols.append(
-                SymbolItem(
-                    symbol_name=name,
-                    symbol_type=SymbolType.FUNCTIONS,
-                    file_name=module_name,
-                )
-            )
-        for name in info1.variables:
-            list_of_symbols.append(
-                SymbolItem(
-                    symbol_name=name,
-                    symbol_type=SymbolType.VARIABLES,
-                    file_name=module_name,
-                )
-            )
-    return list_of_symbols
-
-
-def save_memory():
-    with open(os.path.join(base_persist_dir, "memory.json"), "w",encoding="utf-8") as f:
-        json.dump(memory, f, indent=2, ensure_ascii=False)
-    load_memory()
-
-
-def load_memory():
-    global memory
-    memory_path = os.path.join(base_persist_dir, "memory.json")
-    if os.path.exists(memory_path):
-        with open(memory_path, "r", encoding="utf-8") as f:
-            memory = json.load(f)
-    completer.update_current_files(memory["current_files"]["files"])
-
-
-completer = CommandCompleter(commands,
-                             file_system_model=CCFileSystemModel(project_root=project_root,
-                                                                defaut_exclude_dirs=defaut_exclude_dirs,
-                                                                get_all_file_names_in_project=get_all_file_names_in_project,
-                                                                get_all_file_in_project=get_all_file_in_project,
-                                                                get_all_dir_names_in_project=get_all_dir_names_in_project,
-                                                                get_all_file_in_project_with_dot=get_all_file_in_project_with_dot,
-                                                                get_symbol_list=get_symbol_list
-                                                                ),
-                             memory_model=CCMemoryModel(memory=memory,
-                                                        save_memory_func=save_memory))
-
-
-
-
-def print_conf(content:Dict[str,Any]):        
-        """Display configuration dictionary in a Rich table format with enhanced visual styling.
-
-        Args:
-            conf (Dict[str, Any]): Configuration dictionary to display
-        """
-        console = Console()
-
-        # Create a styled table with rounded borders
-        table = Table(
-            show_header=True,
-            header_style="bold magenta",
-            title=get_message("conf_title"),
-            title_style="bold blue",
-            border_style="blue",
-            show_lines=True            
-        )
-
-        # Add columns with explicit width and alignment
-        table.add_column(get_message("conf_key"), style="cyan", justify="right", width=30, no_wrap=False)
-        table.add_column(get_message("conf_value"), style="green", justify="left", width=50, no_wrap=False)
-
-        # Sort keys for consistent display
-        for key in sorted(content.keys()):
-            value = content[key]
-            # Format value based on type
-            if isinstance(value, (dict, list)):
-                formatted_value = Text(json.dumps(value, indent=2), style="yellow")
-            elif isinstance(value, bool):
-                formatted_value = Text(str(value), style="bright_green" if value else "red")
-            elif isinstance(value, (int, float)):
-                formatted_value = Text(str(value), style="bright_cyan")
-            else:
-                formatted_value = Text(str(value), style="green")
-
-            table.add_row(str(key), formatted_value)
-
-        # Add padding and print with a panel
-        console.print(Panel(
-            table,
-            padding=(1, 2),
-            subtitle=f"[italic]{get_message('conf_subtitle')}[/italic]",
-            border_style="blue"
-        ))
-
-def revert():
-    result_manager = ResultManager()
-    last_yaml_file = get_last_yaml_file("actions")
-    if last_yaml_file:
-        file_path = os.path.join("actions", last_yaml_file)
-
-        with redirect_stdout() as output:
-            auto_coder_main(["revert", "--file", file_path])
-        s = output.getvalue()
-        print(s, flush=True)
-        if "Successfully reverted changes" in s:
-            result_manager.append(content=s, meta={"action": "revert","success":False, "input":{                
-            }})
-            print(
-                "Reverted the last chat action successfully. Remove the yaml file {file_path}"
-            )
-            os.remove(file_path)
-        else:
-            result_manager.append(content=s, meta={"action": "revert","success":False, "input":{                
-            }})
-    else:
-        result_manager.append(content="No previous chat action found to revert.", meta={"action": "revert","success":False, "input":{                
-            }})
-        print("No previous chat action found to revert.")
-
-
-def add_files(args: List[str]):
-
-    result_manager = ResultManager()
-    if "groups" not in memory["current_files"]:
-        memory["current_files"]["groups"] = {}
-    if "groups_info" not in memory["current_files"]:
-        memory["current_files"]["groups_info"] = {}
-    if "current_groups" not in memory["current_files"]:
-        memory["current_files"]["current_groups"] = []
-    groups = memory["current_files"]["groups"]
-    groups_info = memory["current_files"]["groups_info"]
-
-    console = Console()
-    printer = Printer()
-
-    if not args:
-        printer.print_in_terminal("add_files_no_args", style="red")
-        result_manager.append(content=printer.get_message_from_key("add_files_no_args"), 
-                              meta={"action": "add_files","success":False, "input":{ "args": args}})
-        return
-
-    if args[0] == "/refresh":
-        completer.refresh_files()
-        load_memory()
-        console.print(
-            Panel("Refreshed file list.",
-                  title="Files Refreshed", border_style="green")
-        )
-        result_manager.append(content="Files refreshed.", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-        return
-
-    if args[0] == "/group":
-        if len(args) == 1 or (len(args) == 2 and args[1] == "list"):
-            if not groups:
-                console.print(
-                    Panel("No groups defined.", title="Groups",
-                          border_style="yellow")
-                )
-                result_manager.append(content="No groups defined.", 
-                              meta={"action": "add_files","success":False, "input":{ "args": args}})
-            else:
-                table = Table(
-                    title="Defined Groups",
-                    show_header=True,
-                    header_style="bold magenta",
-                    show_lines=True,
-                )
-                table.add_column("Group Name", style="cyan", no_wrap=True)
-                table.add_column("Files", style="green")
-                table.add_column("Query Prefix", style="yellow")
-                table.add_column("Active", style="magenta")
-
-                for i, (group_name, files) in enumerate(groups.items()):
-                    query_prefix = groups_info.get(group_name, {}).get(
-                        "query_prefix", ""
-                    )
-                    is_active = (
-                        "✓"
-                        if group_name in memory["current_files"]["current_groups"]
-                        else ""
-                    )
-                    table.add_row(
-                        group_name,
-                        "\n".join([os.path.relpath(f, project_root)
-                                  for f in files]),
-                        query_prefix,
-                        is_active,
-                        end_section=(i == len(groups) - 1),
-                    )
-                console.print(Panel(table, border_style="blue"))
-                result_manager.append(content="Defined groups.", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-        elif len(args) >= 2 and args[1] == "/reset":
-            memory["current_files"]["current_groups"] = []
-            console.print(
-                Panel(
-                    "Active group names have been reset. If you want to clear the active files, you should use the command /remove_files /all.",
-                    title="Groups Reset",
-                    border_style="green",
-                )
-            )
-            result_manager.append(content="Active group names have been reset. If you want to clear the active files, you should use the command /remove_files /all.", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-        elif len(args) >= 3 and args[1] == "/add":
-            group_name = args[2]
-            groups[group_name] = memory["current_files"]["files"].copy()
-            console.print(
-                Panel(
-                    f"Added group '{group_name}' with current files.",
-                    title="Group Added",
-                    border_style="green",
-                )
-            )
-            result_manager.append(content=f"Added group '{group_name}' with current files.", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-
-        elif len(args) >= 3 and args[1] == "/drop":
-            group_name = args[2]
-            if group_name in groups:
-                del memory["current_files"]["groups"][group_name]
-                if group_name in groups_info:
-                    del memory["current_files"]["groups_info"][group_name]
-                if group_name in memory["current_files"]["current_groups"]:
-                    memory["current_files"]["current_groups"].remove(
-                        group_name)
-                console.print(
-                    Panel(
-                        f"Dropped group '{group_name}'.",
-                        title="Group Dropped",
-                        border_style="green",
-                    )
-                )
-                result_manager.append(content=f"Dropped group '{group_name}'.", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-            else:
-                console.print(
-                    Panel(
-                        f"Group '{group_name}' not found.",
-                        title="Error",
-                        border_style="red",
-                    )
-                )
-                result_manager.append(content=f"Group '{group_name}' not found.", 
-                              meta={"action": "add_files","success":False, "input":{ "args": args}})
-        elif len(args) == 3 and args[1] == "/set":
-            group_name = args[2]
-
-            def multiline_edit():
-                from prompt_toolkit.lexers import PygmentsLexer
-                from pygments.lexers.markup import MarkdownLexer
-                from prompt_toolkit.formatted_text import HTML
-                from prompt_toolkit.shortcuts import print_formatted_text
-
-                style = Style.from_dict(
-                    {
-                        "dialog": "bg:#88ff88",
-                        "dialog frame.label": "bg:#ffffff #000000",
-                        "dialog.body": "bg:#000000 #00ff00",
-                        "dialog shadow": "bg:#00aa00",
-                    }
-                )
-
-                print_formatted_text(
-                    HTML(
-                        "<b>Type Atom Group Desc (Prese [Esc] + [Enter]  to finish.)</b><br/>"
-                    )
-                )
-                text = prompt(
-                    HTML("<ansicyan>║</ansicyan> "),
-                    multiline=True,
-                    lexer=PygmentsLexer(MarkdownLexer),
-                    style=style,
-                    wrap_lines=True,
-                    prompt_continuation=HTML("<ansicyan>║</ansicyan> "),
-                    rprompt=HTML("<ansicyan>║</ansicyan>"),
-                )
-                return text
-
-            query_prefix = multiline_edit()
-            if group_name in groups:
-                groups_info[group_name] = {"query_prefix": query_prefix}
-                console.print(
-                    Panel(
-                        f"Set Atom Group Desc for group '{group_name}'.",
-                        title="Group Info Updated",
-                        border_style="green",
-                    )
-                )
-            else:
-                console.print(
-                    Panel(
-                        f"Group '{group_name}' not found.",
-                        title="Error",
-                        border_style="red",
-                    )
-                )
-        elif len(args) >= 2:
-            # 支持多个组的合并，允许组名之间使用逗号或空格分隔
-            group_names = " ".join(args[1:]).replace(",", " ").split()
-            merged_files = set()
-            missing_groups = []
-            for group_name in group_names:
-                if group_name in groups:
-                    merged_files.update(groups[group_name])
-                else:
-                    missing_groups.append(group_name)
-
-            if missing_groups:
-                console.print(
-                    Panel(
-                        f"Group(s) not found: {', '.join(missing_groups)}",
-                        title="Error",
-                        border_style="red",
-                    )
-                )
-                result_manager.append(content=f"Group(s) not found: {', '.join(missing_groups)}", 
-                              meta={"action": "add_files","success":False, "input":{ "args": args}})
-
-            if merged_files:
-                memory["current_files"]["files"] = list(merged_files)
-                memory["current_files"]["current_groups"] = [
-                    name for name in group_names if name in groups
-                ]
-                console.print(
-                    Panel(
-                        f"Merged files from groups: {', '.join(group_names)}",
-                        title="Files Merged",
-                        border_style="green",
-                    )
-                )
-                table = Table(
-                    title="Current Files",
-                    show_header=True,
-                    header_style="bold magenta",
-                    show_lines=True,  # 这会在每行之间添加分割线
-                )
-                table.add_column("File", style="green")
-                for i, f in enumerate(memory["current_files"]["files"]):
-                    table.add_row(
-                        os.path.relpath(f, project_root),
-                        end_section=(
-                            i == len(memory["current_files"]["files"]) - 1
-                        ),  # 在最后一行之后不添加分割线
-                    )
-                console.print(Panel(table, border_style="blue"))
-                console.print(
-                    Panel(
-                        f"Active groups: {', '.join(memory['current_files']['current_groups'])}",
-                        title="Active Groups",
-                        border_style="green",
-                    )
-                )
-                result_manager.append(content=f"Active groups: {', '.join(memory['current_files']['current_groups'])}", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-            elif not missing_groups:
-                console.print(
-                    Panel(
-                        "No files in the specified groups.",
-                        title="No Files Added",
-                        border_style="yellow",
-                    )
-                    )
-                result_manager.append(content="No files in the specified groups.", 
-                              meta={"action": "add_files","success":False, "input":{ "args": args}})
-    else:
-        existing_files = memory["current_files"]["files"]
-        matched_files = find_files_in_project(args)
-
-        files_to_add = [f for f in matched_files if f not in existing_files]
-        if files_to_add:
-            memory["current_files"]["files"].extend(files_to_add)
-            table = Table(
-                title=get_message("add_files_added_files"),
-                show_header=True,
-                header_style="bold magenta",
-                show_lines=True,  # 这会在每行之间添加分割线
-            )
-            table.add_column("File", style="green")
-            for i, f in enumerate(files_to_add):
-                table.add_row(
-                    os.path.relpath(f, project_root),
-                    end_section=(
-                        i == len(files_to_add) - 1
-                    ),  # 在最后一行之后不添加分割线
-                )
-            console.print(Panel(table, border_style="green"))   
-            result_manager.append(content=f"Added files: {', '.join(files_to_add)}", 
-                              meta={"action": "add_files","success":True, "input":{ "args": args}})
-        else:
-            printer.print_in_terminal("add_files_matched", style="yellow")
-            result_manager.append(content=f"No files matched.", 
-                              meta={"action": "add_files","success":False, "input":{ "args": args}})
-
-    completer.update_current_files(memory["current_files"]["files"])
-    save_memory()
-
-
-def remove_files(file_names: List[str]):
-    project_root = os.getcwd()
-    printer = Printer()
-    result_manager = ResultManager()
-
-    if "/all" in file_names:
-        memory["current_files"]["files"] = []
-        memory["current_files"]["current_groups"] = []
-        printer.print_in_terminal("remove_files_all", style="green")
-        result_manager.append(content="All files removed.", 
-                              meta={"action": "remove_files","success":True, "input":{ "file_names": file_names}})
-    else:
-        removed_files = []
-        for file in memory["current_files"]["files"]:
-            if os.path.basename(file) in file_names:
-                removed_files.append(file)
-            elif file in file_names:
-                removed_files.append(file)
-        for file in removed_files:
-            memory["current_files"]["files"].remove(file)
-
-        if removed_files:
-            table = Table(                
-                show_header=True, 
-                header_style="bold magenta"
-            )
-            table.add_column("File", style="green")
-            for f in removed_files:
-                table.add_row(os.path.relpath(f, project_root))
-
-            console = Console()
-            console.print(
-                Panel(table, border_style="green",
-                      title=printer.get_message_from_key("files_removed"))) 
-            result_manager.append(content=f"Removed files: {', '.join(removed_files)}", 
-                              meta={"action": "remove_files","success":True, "input":{ "file_names": file_names}})
-        else:
-            printer.print_in_terminal("remove_files_none", style="yellow")
-            result_manager.append(content=printer.get_message_from_key("remove_files_none"), 
-                              meta={"action": "remove_files","success":False, "input":{ "file_names": file_names}})
-
-    completer.update_current_files(memory["current_files"]["files"])
-    save_memory()
-
-@run_in_raw_thread()
-def ask(query: str):
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-    yaml_config["query"] = query
-
-    if "project_type" in conf:
-        yaml_config["project_type"] = conf["project_type"]
-
-    if "model" in conf:
-        yaml_config["model"] = conf["model"]
-
-    if "index_model" in conf:
-        yaml_config["index_model"] = conf["index_model"]
-
-    if "vl_model" in conf:
-        yaml_config["vl_model"] = conf["vl_model"]
-
-    if "code_model" in conf:
-        yaml_config["code_model"] = conf["code_model"]
-
-    if "product_mode" in conf:
-        yaml_config["product_mode"] = conf["product_mode"]
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-    execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-
-    def execute_ask():
-        auto_coder_main(["agent", "project_reader", "--file", execute_file])
-
-    try:
-        execute_ask()
-    finally:
-        os.remove(execute_file)
-
-
-def get_llm_friendly_package_docs(
-    package_name: Optional[str] = None, return_paths: bool = False
-) -> List[str]:
-    lib_dir = os.path.join(".auto-coder", "libs")
-    llm_friendly_packages_dir = os.path.join(lib_dir, "llm_friendly_packages")
-    docs = []
-
-    if not os.path.exists(llm_friendly_packages_dir):
-        return docs
-
-    libs = list(memory.get("libs", {}).keys())
-
-    for domain in os.listdir(llm_friendly_packages_dir):
-        domain_path = os.path.join(llm_friendly_packages_dir, domain)
-        if os.path.isdir(domain_path):
-            for username in os.listdir(domain_path):
-                username_path = os.path.join(domain_path, username)
-                if os.path.isdir(username_path):
-                    for lib_name in os.listdir(username_path):
-                        lib_path = os.path.join(username_path, lib_name)
-                        if (
-                            os.path.isdir(lib_path)
-                            and (
-                                package_name is None
-                                or lib_name == package_name
-                                or package_name == os.path.join(username, lib_name)
-                            )
-                            and lib_name in libs
-                        ):
-                            for root, _, files in os.walk(lib_path):
-                                for file in files:
-                                    if file.endswith(".md"):
-                                        file_path = os.path.join(root, file)
-                                        if return_paths:
-                                            docs.append(file_path)
-                                        else:
-                                            with open(file_path, "r",encoding="utf-8") as f:
-                                                docs.append(f.read())
-
-    return docs
-
-
-def convert_yaml_to_config(yaml_file: str):
-    from autocoder.auto_coder import AutoCoderArgs, load_include_files, Template
-
-    args = AutoCoderArgs()
-    with open(yaml_file, "r",encoding="utf-8") as f:
-        config = yaml.safe_load(f)
-        config = load_include_files(config, yaml_file)
-        for key, value in config.items():
-            if key != "file":  # 排除 --file 参数本身
-                # key: ENV {{VARIABLE_NAME}}
-                if isinstance(value, str) and value.startswith("ENV"):
-                    template = Template(value.removeprefix("ENV").strip())
-                    value = template.render(os.environ)
-                setattr(args, key, value)
-    return args
-
-@run_in_raw_thread()
-def mcp(query: str):
-    query = query.strip()
-    mcp_server = get_mcp_server()
-    printer = Printer()
-
-    # Handle remove command
-    if query.startswith("/remove"):
-        server_name = query.replace("/remove", "", 1).strip()
-        response = mcp_server.send_request(
-            McpRemoveRequest(server_name=server_name))
-        if response.error:
-            printer.print_in_terminal("mcp_remove_error", style="red", error=response.error)
-        else:
-            printer.print_in_terminal("mcp_remove_success", style="green", result=response.result)
-        return
-
-    # Handle list command
-    if query.startswith("/list_running"):
-        response = mcp_server.send_request(McpListRunningRequest())
-        if response.error:
-            printer.print_in_terminal("mcp_list_running_error", style="red", error=response.error)
-        else:
-            printer.print_in_terminal("mcp_list_running_title")
-            printer.print_str_in_terminal(response.result)
-        return
-
-    # Handle list command
-    if query.startswith("/list"):
-        response = mcp_server.send_request(McpListRequest())
-        if response.error:
-            printer.print_in_terminal("mcp_list_builtin_error", style="red", error=response.error)
-        else:
-            printer.print_in_terminal("mcp_list_builtin_title")
-            printer.print_str_in_terminal(response.result)
-        return
-
-    # Handle refresh command
-    if query.startswith("/refresh"):
-        server_name = query.replace("/refresh", "", 1).strip()    
-        response = mcp_server.send_request(McpRefreshRequest(name=server_name or None))
-        if response.error:
-            printer.print_in_terminal("mcp_refresh_error", style="red", error=response.error)
-        else:
-            printer.print_in_terminal("mcp_refresh_success", style="green")
-        return
-
-    # Handle add command
-    if query.startswith("/add"):
-        query = query.replace("/add", "", 1).strip()
-        request = McpInstallRequest(server_name_or_config=query)
-        response = mcp_server.send_request(request)
-
-        if response.error:
-            printer.print_in_terminal("mcp_install_error", style="red", error=response.error)
-        else:
-            printer.print_in_terminal("mcp_install_success", style="green", result=response.result)
-        return
-
-    # Handle default query
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-        "auto_merge": conf.get("auto_merge", "editblock"),
-        "human_as_model": conf.get("human_as_model", "false") == "true",
-        "skip_build_index": conf.get("skip_build_index", "true") == "true",
-        "skip_confirm": conf.get("skip_confirm", "true") == "true",
-        "silence": conf.get("silence", "true") == "true",
-        "include_project_structure": conf.get("include_project_structure", "true")
-        == "true",
-    }
-    for key, value in conf.items():
-        converted_value = convert_config_value(key, value)
-        if converted_value is not None:
-            yaml_config[key] = converted_value
-
-    temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
-    try:
-        with open(temp_yaml, "w",encoding="utf-8") as f:
-            f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
-        args = convert_yaml_to_config(temp_yaml)
-    finally:
-        if os.path.exists(temp_yaml):
-            os.remove(temp_yaml)
-
-    mcp_server = get_mcp_server()    
-    response = mcp_server.send_request(
-        McpRequest(
-            query=query,
-            model=args.inference_model or args.model,
-            product_mode=args.product_mode
-        )
-    )
-
-    if response.error:
-        printer.print_panel(
-            f"Error from MCP server: {response.error}",
-            text_options={"justify": "left"},
-            panel_options={
-                "title": printer.get_message_from_key("mcp_error_title"),
-                "border_style": "red"
-            }
-        )
-    else:
-        # Save conversation
-        mcp_dir = os.path.join(".auto-coder", "mcp", "conversations")
-        os.makedirs(mcp_dir, exist_ok=True)
-        timestamp = str(int(time.time()))
-        file_path = os.path.join(mcp_dir, f"{timestamp}.md")
-
-        # Format response as markdown
-        markdown_content = response.result
-
-        # Save to file
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(markdown_content)
-
-        console = Console()
-        console.print(
-            Panel(
-                Markdown(markdown_content, justify="left"),
-                title=printer.get_message_from_key('mcp_response_title'),
-                border_style="green"
-            )
-        )
-
-
-@run_in_raw_thread()
-def code_next(query: str):
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-        "auto_merge": conf.get("auto_merge", "editblock"),
-        "human_as_model": conf.get("human_as_model", "false") == "true",
-        "skip_build_index": conf.get("skip_build_index", "true") == "true",
-        "skip_confirm": conf.get("skip_confirm", "true") == "true",
-        "silence": conf.get("silence", "true") == "true",
-        "include_project_structure": conf.get("include_project_structure", "true")
-        == "true",
-    }
-    for key, value in conf.items():
-        converted_value = convert_config_value(key, value)
-        if converted_value is not None:
-            yaml_config[key] = converted_value
-
-    temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
-    try:
-        with open(temp_yaml, "w",encoding="utf-8") as f:
-            f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
-        args = convert_yaml_to_config(temp_yaml)
-    finally:
-        if os.path.exists(temp_yaml):
-            os.remove(temp_yaml)
-
-    product_mode = conf.get("product_mode", "lite")
-    llm = get_single_llm(args.chat_model or args.model, product_mode=product_mode)
-
-    auto_guesser = AutoGuessQuery(
-        llm=llm, project_dir=os.getcwd(), skip_diff=True)
-
-    predicted_tasks = auto_guesser.predict_next_tasks(
-        5, is_human_as_model=args.human_as_model
-    )
-
-    if not predicted_tasks:
-        console = Console()
-        console.print(Panel("No task predictions available", style="yellow"))
-        return
-
-    console = Console()
-
-    # Create main panel for all predicted tasks
-    table = Table(show_header=True,
-                  header_style="bold magenta", show_lines=True)
-    table.add_column("Priority", style="cyan", width=8)
-    table.add_column("Task Description", style="green",
-                     width=40, overflow="fold")
-    table.add_column("Files", style="yellow", width=30, overflow="fold")
-    table.add_column("Reason", style="blue", width=30, overflow="fold")
-    table.add_column("Dependencies", style="magenta",
-                     width=30, overflow="fold")
-
-    for task in predicted_tasks:
-        # Format file paths to be more readable
-        file_list = "\n".join([os.path.relpath(f, os.getcwd())
-                              for f in task.urls])
-
-        # Format dependencies to be more readable
-        dependencies = (
-            "\n".join(
-                task.dependency_queries) if task.dependency_queries else "None"
-        )
-
-        table.add_row(
-            str(task.priority), task.query, file_list, task.reason, dependencies
-        )
-
-    console.print(
-        Panel(
-            table,
-            title="[bold]Predicted Next Tasks[/bold]",
-            border_style="blue",
-            padding=(1, 2),  # Add more horizontal padding
-        )
-    )
-
-
-@run_in_raw_thread()
-def commit(query: str):
-    conf = memory.get("conf", {})
-    product_mode = conf.get("product_mode", "lite")
-    def prepare_commit_yaml():
-        auto_coder_main(["next", "chat_action"])
-
-    prepare_commit_yaml()
-
-    # no_diff = query.strip().startswith("/no_diff")
-    # if no_diff:
-    #     query = query.replace("/no_diff", "", 1).strip()
-
-    latest_yaml_file = get_last_yaml_file("actions")
-
-    conf = memory.get("conf", {})
-    current_files = memory["current_files"]["files"]
-    execute_file = None
-
-    if latest_yaml_file:
-        try:
-            execute_file = os.path.join("actions", latest_yaml_file)
-            yaml_config = {
-                "include_file": ["./base/base.yml"],
-                "auto_merge": conf.get("auto_merge", "editblock"),
-                "human_as_model": conf.get("human_as_model", "false") == "true",
-                "skip_build_index": conf.get("skip_build_index", "true") == "true",
-                "skip_confirm": conf.get("skip_confirm", "true") == "true",
-                "silence": conf.get("silence", "true") == "true",
-                "include_project_structure": conf.get("include_project_structure", "true")
-                == "true",
-            }
-            for key, value in conf.items():
-                converted_value = convert_config_value(key, value)
-                if converted_value is not None:
-                    yaml_config[key] = converted_value
-
-            yaml_config["urls"] = current_files + get_llm_friendly_package_docs(
-                return_paths=True
-            )
-
-            if conf.get("enable_global_memory", "true") in ["true", "True",True]:
-                yaml_config["urls"] += get_global_memory_file_paths()
-
-            # 临时保存yaml文件，然后读取yaml文件，转换为args
-            temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
-            try:
-                with open(temp_yaml, "w",encoding="utf-8") as f:
-                    f.write(convert_yaml_config_to_str(
-                        yaml_config=yaml_config))
-                args = convert_yaml_to_config(temp_yaml)
-            finally:
-                if os.path.exists(temp_yaml):
-                    os.remove(temp_yaml)
-
-            target_model = args.commit_model or args.model
-            llm = get_single_llm(target_model, product_mode)
-            printer = Printer()
-            printer.print_in_terminal("commit_generating", style="yellow", model_name=target_model)
-            commit_message = ""
-
-            try:
-                uncommitted_changes = git_utils.get_uncommitted_changes(".")
-                commit_message = git_utils.generate_commit_message.with_llm(llm).run(
-                    uncommitted_changes
-                )                
-                memory["conversation"].append(
-                    {"role": "user", "content": commit_message})
-            except Exception as e:
-                printer.print_in_terminal("commit_failed", style="red", error=str(e), model_name=target_model)
-                return
-
-            yaml_config["query"] = commit_message
-            yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-            with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-                f.write(yaml_content)
-
-            file_content = open(execute_file).read()
-            md5 = hashlib.md5(file_content.encode("utf-8")).hexdigest()
-            file_name = os.path.basename(execute_file)
-            commit_result = git_utils.commit_changes(
-                ".", f"auto_coder_{file_name}_{md5}\n{commit_message}"
-            )
-            git_utils.print_commit_info(commit_result=commit_result)
-            if commit_message:
-                printer.print_in_terminal("commit_message", style="green", model_name=target_model, message=commit_message)                
-        except Exception as e:
-            import traceback
-            traceback.print_exc()            
-            print(f"Failed to commit: {e}")
-            if execute_file:
-                os.remove(execute_file)
-
-
-@run_in_raw_thread()
-def coding(query: str):
-    console = Console()
-    is_apply = query.strip().startswith("/apply")
-    if is_apply:
-        query = query.replace("/apply", "", 1).strip()
-
-    is_next = query.strip().startswith("/next")
-    if is_next:
-        query = query.replace("/next", "", 1).strip()
-
-    if is_next:
-        code_next(query)
-        return
-
-    memory["conversation"].append({"role": "user", "content": query})
-    conf = memory.get("conf", {})
-
-    current_files = memory["current_files"]["files"]
-    current_groups = memory["current_files"].get("current_groups", [])
-    groups = memory["current_files"].get("groups", {})
-    groups_info = memory["current_files"].get("groups_info", {})
-
-    def prepare_chat_yaml():
-        auto_coder_main(["next", "chat_action"])
-
-    prepare_chat_yaml()
-
-    latest_yaml_file = get_last_yaml_file("actions")
-
-    if latest_yaml_file:
-        yaml_config = {
-            "include_file": ["./base/base.yml"],
-            "auto_merge": conf.get("auto_merge", "editblock"),
-            "human_as_model": conf.get("human_as_model", "false") == "true",
-            "skip_build_index": conf.get("skip_build_index", "true") == "true",
-            "skip_confirm": conf.get("skip_confirm", "true") == "true",
-            "silence": conf.get("silence", "true") == "true",
-            "include_project_structure": conf.get("include_project_structure", "true")
-            == "true",
-            "exclude_files": memory.get("exclude_files", []),
-        }
-
-        yaml_config["context"] = ""        
-        yaml_config["in_code_apply"] = is_apply
-
-        for key, value in conf.items():
-            converted_value = convert_config_value(key, value)
-            if converted_value is not None:
-                yaml_config[key] = converted_value
-
-        yaml_config["urls"] = current_files + get_llm_friendly_package_docs(
-            return_paths=True
-        )
-
-        if conf.get("enable_global_memory", "true") in ["true", "True",True]:
-            yaml_config["urls"] += get_global_memory_file_paths()
-
-        # handle image
-        v = Image.convert_image_paths_from(query)
-        yaml_config["query"] = v
-
-        # Add context for active groups and their query prefixes
-        if current_groups:
-            active_groups_context = "下面是对上面文件按分组给到的一些描述，当用户的需求正好匹配描述的时候，参考描述来做修改：\n"
-            for group in current_groups:
-                group_files = groups.get(group, [])
-                query_prefix = groups_info.get(
-                    group, {}).get("query_prefix", "")
-                active_groups_context += f"组名: {group}\n"
-                active_groups_context += f"文件列表:\n"
-                for file in group_files:
-                    active_groups_context += f"- {file}\n"
-                active_groups_context += f"组描述: {query_prefix}\n\n"
-
-            yaml_config["context"] = active_groups_context + "\n"
-
-        if is_apply:
-            memory_dir = os.path.join(".auto-coder", "memory")
-            os.makedirs(memory_dir, exist_ok=True)
-            memory_file = os.path.join(memory_dir, "chat_history.json")
-
-            def error_message():
-                console.print(
-                    Panel(
-                        "No chat history found to apply.",
-                        title="Chat History",
-                        expand=False,
-                        border_style="yellow",
-                    )
-                )
-
-            if not os.path.exists(memory_file):
-                error_message()
-                return
-
-            with open(memory_file, "r",encoding="utf-8") as f:
-                chat_history = json.load(f)
-
-            if not chat_history["ask_conversation"]:
-                error_message()
-                return
-
-            conversations = chat_history["ask_conversation"]
-
-            yaml_config[
-                "context"
-            ] += f"下面是我们的历史对话，参考我们的历史对话从而更好的理解需求和修改代码: \n\n<history>\n"
-            for conv in conversations:
-                if conv["role"] == "user":
-                    yaml_config["context"] += f"用户: {conv['content']}\n"
-                elif conv["role"] == "assistant":
-                    yaml_config["context"] += f"你: {conv['content']}\n"
-            yaml_config["context"] += "</history>\n"
-
-        yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-        md5 = hashlib.md5(yaml_content.encode("utf-8")).hexdigest()
-
-        execute_file = os.path.join("actions", latest_yaml_file)
-        with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-            f.write(yaml_content)
-
-        def execute_chat():
-            cmd = ["--file", execute_file]
-            auto_coder_main(cmd)
-            result_manager = ResultManager()
-            result_manager.append(content="", meta={"commit_message": f"auto_coder_{latest_yaml_file}_{md5}","action": "coding", "input":{
-                "query": query
-            }})
-
-        execute_chat()
-    else:
-        print("Failed to create new YAML file.")
-
-    save_memory()
-    completer.refresh_files()
-
-
-@byzerllm.prompt()
-def code_review(query: str) -> str:
-    """
-    掐面提供了上下文，对代码进行review，参考如下检查点。
-    1. 有没有调用不符合方法，类的签名的调用，包括对第三方类，模块，方法的检查（如果上下文提供了这些信息）
-    2. 有没有未声明直接使用的变量，方法，类
-    3. 有没有明显的语法错误
-    4. 如果是python代码，检查有没有缩进方面的错误
-    5. 如果是python代码，检查是否 try 后面缺少 except 或者 finally
-    {% if query %}
-    6. 用户的额外的检查需求：{{ query }}
-    {% endif %}
-
-    如果用户的需求包含了@一个文件名 或者 @@符号， 那么重点关注这些文件或者符号（函数，类）进行上述的review。
-    review 过程中严格遵循上述的检查点，不要遗漏，没有发现异常的点直接跳过，只对发现的异常点，给出具体的修改后的代码。
-    """
-
-
-@run_in_raw_thread()
-def chat(query: str):
-    conf = memory.get("conf", {})
-
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-        "include_project_structure": conf.get("include_project_structure", "true")
-        in ["true", "True"],
-        "human_as_model": conf.get("human_as_model", "false") == "true",
-        "skip_build_index": conf.get("skip_build_index", "true") == "true",
-        "skip_confirm": conf.get("skip_confirm", "true") == "true",
-        "silence": conf.get("silence", "true") == "true",
-        "exclude_files": memory.get("exclude_files", []),
-    }
-
-    current_files = memory["current_files"]["files"] + get_llm_friendly_package_docs(
-        return_paths=True
-    )
-
-    if conf.get("enable_global_memory", "true") in ["true", "True",True]:
-        current_files += get_global_memory_file_paths()
-
-    yaml_config["urls"] = current_files
-
-    if "emb_model" in conf:
-        yaml_config["emb_model"] = conf["emb_model"]
-
-    is_new = "/new" in query
-    if is_new:
-        query = query.replace("/new", "", 1).strip()
-
-    yaml_config["action"] = []    
-
-    if "/mcp " in query:
-        yaml_config["action"].append("mcp")
-        query = query.replace("/mcp ", "", 1).strip()
-
-    if "/rag " in query:
-        yaml_config["action"].append("rag")
-        query = query.replace("/rag ", "", 1).strip()
-
-    if "/copy" in query:
-        yaml_config["action"].append("copy")
-        query = query.replace("/copy", "", 1).strip()   
-
-    if "/save" in query:
-        yaml_config["action"].append("save")
-        query = query.replace("/save", "", 1).strip()        
-
-    if "/review" in query and "/commit" in query:
-        yaml_config["action"].append("review_commit")
-        query = query.replace("/review", "", 1).replace("/commit", "", 1).strip()
-    else:    
-        is_review = query.strip().startswith("/review")
-        if is_review:
-            query = query.replace("/review", "", 1).strip()
-            if "prompt_review" in conf:
-                query = format_str_jinja2(conf["prompt_review"], query=query)
-            else:
-                query = code_review.prompt(query)
-
-    is_no_context = "/no_context" in query.strip()
-    if is_no_context:
-        query = query.replace("/no_context", "", 1).strip()
-        yaml_config["action"].append("no_context")
-
-    for key, value in conf.items():
-        converted_value = convert_config_value(key, value)
-        if converted_value is not None:
-            yaml_config[key] = converted_value
-
-    query = Image.convert_image_paths_from(query)
-
-    yaml_config["query"] = query
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-    execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-
-    def execute_ask():
-        cmd = ["agent", "chat", "--file", execute_file]
-        if is_new:
-            cmd.append("--new_session")
-        auto_coder_main(cmd)
-
-    try:
-        execute_ask()
-    finally:
-        os.remove(execute_file)
-
-
-@run_in_raw_thread()
-def summon(query: str):
-    conf = memory.get("conf", {})
-    current_files = memory["current_files"]["files"]
-
-    file_contents = []
-    for file in current_files:
-        if os.path.exists(file):
-            try:
-                with open(file, "r",encoding="utf-8") as f:
-                    content = f.read()
-                    s = f"##File: {file}\n{content}\n\n"
-                    file_contents.append(s)
-            except Exception as e:
-                print(f"Failed to read file: {file}. Error: {str(e)}")
-
-    all_file_content = "".join(file_contents)
-
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-    yaml_config["query"] = query
-    yaml_config["context"] = json.dumps(
-        {"file_content": all_file_content}, ensure_ascii=False
-    )
-
-    if "emb_model" in conf:
-        yaml_config["emb_model"] = conf["emb_model"]
-
-    if "vl_model" in conf:
-        yaml_config["vl_model"] = conf["vl_model"]
-
-    if "code_model" in conf:
-        yaml_config["code_model"] = conf["code_model"]
-
-    if "model" in conf:
-        yaml_config["model"] = conf["model"]
-
-    if "product_mode" in conf:
-        yaml_config["product_mode"] = conf["product_mode"]
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-    execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-
-    def execute_summon():
-        auto_coder_main(["agent", "auto_tool", "--file", execute_file])
-
-    try:
-        execute_summon()
-    finally:
-        os.remove(execute_file)
-
-
-@run_in_raw_thread()
-def design(query: str):
-
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-
-    if query.strip().startswith("/svg"):
-        query = query.replace("/svg", "", 1).strip()
-        yaml_config["agent_designer_mode"] = "svg"
-    elif query.strip().startswith("/sd"):
-        query = query.replace("/svg", "", 1).strip()
-        yaml_config["agent_designer_mode"] = "sd"
-    elif query.strip().startswith("/logo"):
-        query = query.replace("/logo", "", 1).strip()
-        yaml_config["agent_designer_mode"] = "logo"
-    else:
-        yaml_config["agent_designer_mode"] = "svg"
-
-    yaml_config["query"] = query
-
-    if "model" in conf:
-        yaml_config["model"] = conf["model"]
-
-    if "designer_model" in conf:
-        yaml_config["designer_model"] = conf["designer_model"]
-
-    if "sd_model" in conf:
-        yaml_config["sd_model"] = conf["sd_model"]
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-    execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-
-    def execute_design():
-        auto_coder_main(["agent", "designer", "--file", execute_file])
-
-    try:
-        execute_design()
-    finally:
-        os.remove(execute_file)
-
-
-def voice_input():
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-
-    if "voice2text_model" not in conf:
-        print(
-            "Please set voice2text_model in configuration. /conf voice2text_model:<model>"
-        )
-        return
-
-    yaml_config["voice2text_model"] = conf["voice2text_model"]
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-    execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-
-    def execute_voice2text_command():
-        auto_coder_main(["agent", "voice2text", "--file", execute_file])
-
-    try:
-        execute_voice2text_command()
-        with open(os.path.join(".auto-coder", "exchange.txt"), "r",encoding="utf-8") as f:
-            return f.read()
-    finally:
-        os.remove(execute_file)
-
-
-@run_in_raw_thread()
-def generate_shell_command(input_text):
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-
-    if "model" in conf:
-        yaml_config["model"] = conf["model"]
-
-    yaml_config["query"] = input_text
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-
-    execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-
-    try:
-        auto_coder_main(["agent", "generate_command", "--file", execute_file])
-        with open(os.path.join(".auto-coder", "exchange.txt"), "r",encoding="utf-8") as f:
-            shell_script = f.read()
-        result_manager = ResultManager()
-        result_manager.add_result(content=shell_script,meta={
-            "action": "generate_shell_command",
-            "input": {
-                "query": input_text
-            }
-        })
-        return shell_script
-    finally:
-        os.remove(execute_file)
-
-def manage_models(query: str):
-    """    
-    Handle /models subcommands:
-      /models /list - List all models (default + custom)
-      /models /add <name> <api_key> - Add model with simplified params
-      /models /add_model name=xxx base_url=xxx ... - Add model with custom params
-      /models /remove <name> - Remove model by name
-    """
-    printer = Printer()
-    console = Console()
-
-    product_mode = memory.get("product_mode", "lite")
-    if product_mode != "lite":
-        printer.print_in_terminal("models_lite_only", style="red")
-        return
-
-    models_data = models_module.load_models()
-    subcmd = ""
-    if "/list" in query:
-        subcmd = "/list"
-        query = query.replace("/list", "", 1).strip()
-
-    if "/add_model" in query:
-        subcmd = "/add_model"
-        query = query.replace("/add_model", "", 1).strip()
-
-    if "/add" in query:
-        subcmd = "/add"
-        query = query.replace("/add", "", 1).strip()
-
-    # alias to /add
-    if "/activate" in query:
-        subcmd = "/add"
-        query = query.replace("/activate", "", 1).strip()    
-
-    if "/remove" in query:
-        subcmd = "/remove"
-        query = query.replace("/remove", "", 1).strip()
-
-    if "/speed-test" in query:
-        subcmd = "/speed-test"
-        query = query.replace("/speed-test", "", 1).strip()
-
-    if "/speed_test" in query:
-        subcmd = "/speed-test"
-        query = query.replace("/speed_test", "", 1).strip() 
-
-    if "input_price" in query:
-        subcmd = "/input_price"
-        query = query.replace("/input_price", "", 1).strip()
-
-    if "output_price" in query:
-        subcmd = "/output_price"
-        query = query.replace("/output_price", "", 1).strip()        
-
-    if "/speed" in query:
-        subcmd = "/speed"
-        query = query.replace("/speed", "", 1).strip()
-
-
-
-    if not subcmd:
-        printer.print_in_terminal("models_usage")        
-
-    result_manager = ResultManager()
-    if subcmd == "/list":                    
-        if models_data:
-            # Sort models by speed (average_speed)
-            sorted_models = sorted(models_data, key=lambda x: float(x.get('average_speed', 0)))
-            sorted_models.reverse()
-
-            table = Table(
-                title=printer.get_message_from_key("models_title"),
-                expand=True,
-                show_lines=True
-            )
-            table.add_column("Name", style="cyan", width=30, overflow="fold", no_wrap=False)
-            table.add_column("Model Name", style="magenta", width=30, overflow="fold", no_wrap=False)
-            table.add_column("Base URL", style="white", width=40, overflow="fold", no_wrap=False)
-            table.add_column("Input Price (M)", style="magenta", width=15, overflow="fold", no_wrap=False)
-            table.add_column("Output Price (M)", style="magenta", width=15, overflow="fold", no_wrap=False)
-            table.add_column("Speed (s/req)", style="blue", width=15, overflow="fold", no_wrap=False)
-            for m in sorted_models:
-                # Check if api_key_path exists and file exists
-                is_api_key_set = "api_key" in m  
-                name = m.get("name", "")              
-                if is_api_key_set:
-                    api_key = m.get("api_key", "").strip()                    
-                    if not api_key:                                                
-                        printer.print_in_terminal("models_api_key_empty", style="yellow", name=name)                                           
-                    name = f"{name} *"
-
-                table.add_row(
-                    name,                    
-                    m.get("model_name", ""),                    
-                    m.get("base_url", ""),
-                    f"{m.get('input_price', 0.0):.2f}",
-                    f"{m.get('output_price', 0.0):.2f}",
-                    f"{m.get('average_speed', 0.0):.3f}"
-                )
-            console.print(table)
-            result_manager.add_result(content=json.dumps(sorted_models,ensure_ascii=False),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-
-        else:
-            printer.print_in_terminal("models_no_models", style="yellow")
-            result_manager.add_result(content="No models found",meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-
-    elif subcmd == "/input_price":
-        args = query.strip().split()
-        if len(args) >= 2:
-            name = args[0]
-            try:
-                price = float(args[1])
-                if models_module.update_model_input_price(name, price):
-                    printer.print_in_terminal("models_input_price_updated", style="green", name=name, price=price)
-                    result_manager.add_result(content=f"models_input_price_updated: {name} {price}",meta={
-                        "action": "models",
-                        "input": {
-                            "query": query
-                        }
-                    })
-                else:
-                    printer.print_in_terminal("models_not_found", style="red", name=name)
-                    result_manager.add_result(content=f"models_not_found: {name}",meta={
-                        "action": "models",
-                        "input": {
-                            "query": query
-                        }
-                    })
-            except ValueError as e:
-                result_manager.add_result(content=f"models_invalid_price: {str(e)}",meta={
-                    "action": "models",
-                    "input": {
-                        "query": query
-                    }
-                })
-                printer.print_in_terminal("models_invalid_price", style="red", error=str(e))
-        else:
-            result_manager.add_result(content=printer.get_message_from_key("models_input_price_usage"),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            printer.print_in_terminal("models_input_price_usage", style="red")
-
-    elif subcmd == "/output_price":
-        args = query.strip().split()
-        if len(args) >= 2:
-            name = args[0]
-            try:
-                price = float(args[1])
-                if models_module.update_model_output_price(name, price):
-                    printer.print_in_terminal("models_output_price_updated", style="green", name=name, price=price)
-                    result_manager.add_result(content=f"models_output_price_updated: {name} {price}",meta={
-                        "action": "models",
-                        "input": {
-                            "query": query
-                        }
-                    })
-                else:
-                    printer.print_in_terminal("models_not_found", style="red", name=name)
-                    result_manager.add_result(content=f"models_not_found: {name}",meta={
-                        "action": "models",
-                        "input": {
-                            "query": query
-                        }
-                    })
-            except ValueError as e:
-                printer.print_in_terminal("models_invalid_price", style="red", error=str(e))
-                result_manager.add_result(content=f"models_invalid_price: {str(e)}",meta={
-                    "action": "models",
-                    "input": {
-                        "query": query
-                    }
-                })
-        else:
-            result_manager.add_result(content=printer.get_message_from_key("models_output_price_usage"),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            printer.print_in_terminal("models_output_price_usage", style="red")
-
-    elif subcmd == "/speed":
-        args = query.strip().split()
-        if len(args) >= 2:
-            name = args[0]
-            try:
-                speed = float(args[1])
-                if models_module.update_model_speed(name, speed):
-                    printer.print_in_terminal("models_speed_updated", style="green", name=name, speed=speed)
-                    result_manager.add_result(content=f"models_speed_updated: {name} {speed}",meta={
-                        "action": "models",
-                        "input": {
-                            "query": query
-                        }
-                    })
-                else:
-                    printer.print_in_terminal("models_not_found", style="red", name=name)
-                    result_manager.add_result(content=f"models_not_found: {name}",meta={
-                        "action": "models",
-                        "input": {
-                            "query": query
-                        }
-                    })
-            except ValueError as e:
-                printer.print_in_terminal("models_invalid_speed", style="red", error=str(e))
-                result_manager.add_result(content=f"models_invalid_speed: {str(e)}",meta={
-                    "action": "models",
-                    "input": {
-                        "query": query
-                    }
-                })
-        else:
-            result_manager.add_result(content=printer.get_message_from_key("models_speed_usage"),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            printer.print_in_terminal("models_speed_usage", style="red")
-
-    elif subcmd == "/speed-test":
-        from autocoder.common.model_speed_test import render_speed_test_in_terminal
-        test_rounds = 1  # 默认测试轮数
-
-        enable_long_context = False
-        if "/long_context" in query:
-            enable_long_context = True
-            query = query.replace("/long_context", "", 1).strip()
-
-        if "/long-context" in query:
-            enable_long_context = True
-            query = query.replace("/long-context", "", 1).strip()
-
-        # 解析可选的测试轮数参数
-        args = query.strip().split()
-        if args and args[0].isdigit():
-            test_rounds = int(args[0])
-
-        render_speed_test_in_terminal(product_mode, test_rounds,enable_long_context=enable_long_context)
-        ## 等待优化，获取明细数据
-        result_manager.add_result(content="models test success",meta={
-            "action": "models",
-            "input": {
-                "query": query
-            }
-        })
-
-    elif subcmd == "/add":
-        # Support both simplified and legacy formats
-        args = query.strip().split(" ")        
-        if len(args) == 2:
-            # Simplified: /models /add <name> <api_key>
-            name, api_key = args[0], args[1]            
-            result = models_module.update_model_with_api_key(name, api_key)
-            if result:
-                result_manager.add_result(content=f"models_added: {name}",meta={
-                    "action": "models",
-                    "input": {
-                        "query": query
-                    }
-                })
-                printer.print_in_terminal("models_added", style="green", name=name)
-            else:
-                result_manager.add_result(content=f"models_add_failed: {name}",meta={
-                    "action": "models",
-                    "input": {
-                        "query": query
-                    }
-                })
-                printer.print_in_terminal("models_add_failed", style="red", name=name)
-        else:
-            printer.print_in_terminal("models_add_usage", style="red")
-            result_manager.add_result(content=printer.get_message_from_key("models_add_usage"),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-
-    elif subcmd == "/add_model":
-        # Parse key=value pairs: /models /add_model name=abc base_url=http://xx ...       
-        # Collect key=value pairs
-        kv_pairs = shlex.split(query)
-        data_dict = {}
-        for pair in kv_pairs:
-            if '=' not in pair:
-                printer.print_in_terminal("models_add_model_params", style="red")
-                continue
-            k, v = pair.split('=', 1)
-            data_dict[k.strip()] = v.strip()
-
-        # Name is required
-        if "name" not in data_dict:
-            printer.print_in_terminal("models_add_model_name_required", style="red")
-            return
-
-        # Check duplication
-        if any(m["name"] == data_dict["name"] for m in models_data):
-            printer.print_in_terminal("models_add_model_exists", style="yellow", name=data_dict["name"])
-            result_manager.add_result(content=printer.get_message_from_key("models_add_model_exists",name=data_dict["name"]),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            return
-
-        # Create model with defaults
-        final_model = {
-            "name": data_dict["name"],
-            "model_type": data_dict.get("model_type", "saas/openai"),
-            "model_name": data_dict.get("model_name", data_dict["name"]),
-            "base_url": data_dict.get("base_url", "https://api.openai.com/v1"),
-            "api_key_path": data_dict.get("api_key_path", "api.openai.com"),
-            "description": data_dict.get("description", ""),
-            "is_reasoning": data_dict.get("is_reasoning", "false") in ["true", "True", "TRUE", "1"]
-        }
-
-        models_data.append(final_model)
-        models_module.save_models(models_data)
-        printer.print_in_terminal("models_add_model_success", style="green", name=data_dict["name"])
-        result_manager.add_result(content=f"models_add_model_success: {data_dict['name']}",meta={
-            "action": "models",
-            "input": {
-                "query": query
-            }
-        })
-
-    elif subcmd == "/remove":
-        args = query.strip().split(" ")
-        if len(args) < 1:
-            printer.print_in_terminal("models_add_usage", style="red")
-            result_manager.add_result(content=printer.get_message_from_key("models_add_usage"),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            return
-        name = args[0]
-        filtered_models = [m for m in models_data if m["name"] != name]
-        if len(filtered_models) == len(models_data):
-            printer.print_in_terminal("models_add_model_remove", style="yellow", name=name)
-            result_manager.add_result(content=printer.get_message_from_key("models_add_model_remove",name=name),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            return
-        models_module.save_models(filtered_models)
-        printer.print_in_terminal("models_add_model_removed", style="green", name=name)
-        result_manager.add_result(content=printer.get_message_from_key("models_add_model_removed",name=name),meta={ 
-            "action": "models",
-            "input": {
-                "query": query
-            }
-        })
-    else:
-        printer.print_in_terminal("models_unknown_subcmd", style="yellow", subcmd=subcmd)
-        result_manager.add_result(content=printer.get_message_from_key("models_unknown_subcmd",subcmd=subcmd),meta={ 
-            "action": "models",
-            "input": {
-                "query": query
-            }
-        })
-
-def exclude_dirs(dir_names: List[str]):
-    new_dirs = dir_names
-    existing_dirs = memory.get("exclude_dirs", [])    
-    dirs_to_add = [d for d in new_dirs if d not in existing_dirs]
-    
-    if dirs_to_add:
-        existing_dirs.extend(dirs_to_add)
-        if "exclude_dirs" not in memory:
-            memory["exclude_dirs"] = existing_dirs
-        print(f"Added exclude dirs: {dirs_to_add}")
-        exclude_files([f"regex://.*/{d}/*." for d in dirs_to_add])            
-    else:
-        print("All specified dirs are already in the exclude list.")
-    save_memory()
-    completer.refresh_files()
-
-def exclude_files(query: str):
-    result_manager = ResultManager()
-    printer = Printer()
-    if "/list" in query:
-        query = query.replace("/list", "", 1).strip()
-        existing_file_patterns = memory.get("exclude_files", []) 
-        console = Console()
-        # 打印表格
-        table = Table(title="Exclude Files")
-        table.add_column("File Pattern")
-        for file_pattern in existing_file_patterns:
-            table.add_row(file_pattern)
-        console.print(table)
-        result_manager.add_result(content=f"Exclude files: {existing_file_patterns}",meta={
-            "action": "exclude_files",
-            "input": {
-                "query": query
-            }
-        })
-        return
-
-    if "/drop" in query:
-        query = query.replace("/drop", "", 1).strip()
-        existing_file_patterns = memory.get("exclude_files", [])    
-        existing_file_patterns.remove(query.strip())
-        memory["exclude_files"] = existing_file_patterns
-        save_memory()
-        completer.refresh_files()
-        result_manager.add_result(content=f"Dropped exclude files: {query}",meta={
-            "action": "exclude_files",
-            "input": {
-                "query": query
-            }
-        })
-        return
-    
-    new_file_patterns = query.strip().split(",")
-    
-    existing_file_patterns = memory.get("exclude_files", [])    
-    file_patterns_to_add = [f for f in new_file_patterns if f not in existing_file_patterns]
-
-    for file_pattern in file_patterns_to_add:
-        if not file_pattern.startswith("regex://"): 
-            result_manager.add_result(content=printer.get_message_from_key_with_format("invalid_file_pattern", file_pattern=file_pattern),meta={
-                "action": "exclude_files",
-                "input": {
-                    "query": file_pattern
-                }
-            })
-            raise ValueError(printer.get_message_from_key_with_format("invalid_file_pattern", file_pattern=file_pattern))
-
-    if file_patterns_to_add:
-        existing_file_patterns.extend(file_patterns_to_add)
-        if "exclude_files" not in memory:
-            memory["exclude_files"] = existing_file_patterns
-        
-        result_manager.add_result(content=f"Added exclude files: {file_patterns_to_add}",meta={
-            "action": "exclude_files",
-            "input": {
-                "query": file_patterns_to_add
-            }
-        })
-        save_memory()
-        print(f"Added exclude files: {file_patterns_to_add}")
-    else:
-        result_manager.add_result(content=f"All specified files are already in the exclude list.",meta={
-            "action": "exclude_files",
-            "input": {
-                "query": file_patterns_to_add
-            }
-        })
-        print("All specified files are already in the exclude list.")
-    
-    
-
-@run_in_raw_thread()
-def index_build():
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-
-    for key, value in conf.items():
-        converted_value = convert_config_value(key, value)
-        if converted_value is not None:
-            yaml_config[key] = converted_value
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-    yaml_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(yaml_file, "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-    try:
-        with redirect_stdout() as output:
-            auto_coder_main(["index", "--file", yaml_file])
-        print(output.getvalue(), flush=True)
-        completer.refresh_files()
-    finally:
-        os.remove(yaml_file)
-
-
-def get_final_config()->AutoCoderArgs:
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-        "auto_merge": conf.get("auto_merge", "editblock"),
-        "human_as_model": conf.get("human_as_model", "false") == "true",
-        "skip_build_index": conf.get("skip_build_index", "true") == "true",
-        "skip_confirm": conf.get("skip_confirm", "true") == "true",
-        "silence": conf.get("silence", "true") == "true",
-        "include_project_structure": conf.get("include_project_structure", "true")
-        == "true",
-    }
-    for key, value in conf.items():
-        converted_value = convert_config_value(key, value)
-        if converted_value is not None:
-            yaml_config[key] = converted_value
-
-    temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
-    try:
-        with open(temp_yaml, "w",encoding="utf-8") as f:
-            f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
-        args = convert_yaml_to_config(temp_yaml)
-    finally:
-        if os.path.exists(temp_yaml):
-            os.remove(temp_yaml)
-    return args
-
-def help(query: str):
-    from autocoder.common.auto_configure import ConfigAutoTuner,MemoryConfig,AutoConfigRequest        
-    args = get_final_config()
-    product_mode = memory.get("product_mode", "lite")
-    llm = get_single_llm(args.chat_model or args.model, product_mode=product_mode)
-    auto_config_tuner = ConfigAutoTuner(args=args, llm=llm, memory_config=MemoryConfig(memory=memory, save_memory_func=save_memory))
-    auto_config_tuner.tune(AutoConfigRequest(query=query))    
-
-@run_in_raw_thread()
-def index_export(path: str):
-    from autocoder.common.index_import_export import export_index
-    from autocoder.common.printer import Printer
-    printer = Printer()
-    project_root = os.getcwd()
-    if export_index(project_root, path):
-        printer.print_in_terminal("index_export_success", path=path)
-    else:
-        printer.print_in_terminal("index_export_fail", path=path)
-
-@run_in_raw_thread()
-def index_import(path: str):
-    from autocoder.common.index_import_export import import_index
-    from autocoder.common.printer import Printer
-    printer = Printer()
-    project_root = os.getcwd()
-    if import_index(project_root, path):
-        printer.print_in_terminal("index_import_success", path=path)
-    else:
-        printer.print_in_terminal("index_import_fail", path=path)
-
-@run_in_raw_thread()
-def index_query(query: str):
-    conf = memory.get("conf", {})
-    yaml_config = {
-        "include_file": ["./base/base.yml"],
-    }
-
-    for key, value in conf.items():
-        converted_value = convert_config_value(key, value)
-        if converted_value is not None:
-            yaml_config[key] = converted_value
-
-    yaml_config["query"] = query
-
-    yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
-    yaml_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
-
-    with open(yaml_file, "w",encoding="utf-8") as f:
-        f.write(yaml_content)
-    try:
-        with redirect_stdout() as output:
-            auto_coder_main(["index-query", "--file", yaml_file])
-        print(output.getvalue(), flush=True)
-    finally:
-        os.remove(yaml_file)
-
-
-def list_files():
-    console = Console()
-    project_root = os.getcwd()
-    current_files = memory["current_files"]["files"]
-
-    if current_files:
-        table = Table(
-            title="Current Files", show_header=True, header_style="bold magenta"
-        )
-        table.add_column("File", style="green")
-        for file in current_files:
-            table.add_row(os.path.relpath(file, project_root))
-        console.print(Panel(table, border_style="blue"))
-    else:
-        console.print(
-            Panel(
-                "No files in the current session.",
-                title="Current Files",
-                border_style="yellow",
-            )
-        )
-
-
-def gen_and_exec_shell_command(query: str):
-    from rich.prompt import Confirm    
-    from autocoder.common.printer import Printer 
-    from rich.console import Console
-    
-    printer = Printer()
-    console = Console()
-    # Generate the shell script
-    shell_script = generate_shell_command(query)    
-
-    # Ask for confirmation using rich
-    if Confirm.ask(
-        printer.get_message_from_key("confirm_execute_shell_script"),
-        default=False
-    ):
-        execute_shell_command(shell_script)
-    else:
-        console.print(
-            Panel(
-                printer.get_message_from_key("shell_script_not_executed"),
-                border_style="yellow"
-            )
-        )
-
-
-def lib_command(args: List[str]):
-    console = Console()
-    lib_dir = os.path.join(".auto-coder", "libs")
-    llm_friendly_packages_dir = os.path.join(lib_dir, "llm_friendly_packages")
-
-    if not os.path.exists(lib_dir):
-        os.makedirs(lib_dir)
-
-    if "libs" not in memory:
-        memory["libs"] = {}
-
-    if not args:
-        console.print(
-            "Please specify a subcommand: /add, /remove, /list, /set-proxy, /refresh, or /get"
-        )
-        return
-
-    subcommand = args[0]
-
-    if subcommand == "/add":
-        if len(args) < 2:
-            console.print("Please specify a library name to add")
-            return
-        lib_name = args[1].strip()
-
-        # Clone the repository if it doesn't exist
-        if not os.path.exists(llm_friendly_packages_dir):
-            console.print("Cloning llm_friendly_packages repository...")
-            try:
-                proxy_url = memory.get(
-                    "lib-proxy", "https://github.com/allwefantasy/llm_friendly_packages"
-                )
-                git.Repo.clone_from(
-                    proxy_url,
-                    llm_friendly_packages_dir,
-                )
-                console.print(
-                    "Successfully cloned llm_friendly_packages repository")
-            except git.exc.GitCommandError as e:
-                console.print(f"Error cloning repository: {e}")
-
-        if lib_name in memory["libs"]:
-            console.print(f"Library {lib_name} is already added")
-        else:
-            memory["libs"][lib_name] = {}
-            console.print(f"Added library: {lib_name}")
-
-            save_memory()
-
-    elif subcommand == "/remove":
-        if len(args) < 2:
-            console.print("Please specify a library name to remove")
-            return
-        lib_name = args[1].strip()
-        if lib_name in memory["libs"]:
-            del memory["libs"][lib_name]
-            console.print(f"Removed library: {lib_name}")
-            save_memory()
-        else:
-            console.print(f"Library {lib_name} is not in the list")
-
-    elif subcommand == "/list":
-        if memory["libs"]:
-            table = Table(title="Added Libraries")
-            table.add_column("Library Name", style="cyan")
-            for lib_name in memory["libs"]:
-                table.add_row(lib_name)
-            console.print(table)
-        else:
-            console.print("No libraries added yet")
-
-    elif subcommand == "/set-proxy":
-        if len(args) == 1:
-            current_proxy = memory.get("lib-proxy", "No proxy set")
-            console.print(f"Current proxy: {current_proxy}")
-        elif len(args) == 2:
-            proxy_url = args[1]
-            memory["lib-proxy"] = proxy_url
-            console.print(f"Set proxy to: {proxy_url}")
-            save_memory()
-        else:
-            console.print("Invalid number of arguments for /set-proxy")
-
-    elif subcommand == "/refresh":
-        if os.path.exists(llm_friendly_packages_dir):
-            try:
-                repo = git.Repo(llm_friendly_packages_dir)
-                origin = repo.remotes.origin
-                proxy_url = memory.get("lib-proxy")
-
-                current_url = origin.url
-
-                if proxy_url and proxy_url != current_url:
-                    new_url = proxy_url
-                    origin.set_url(new_url)
-                    console.print(f"Updated remote URL to: {new_url}")
-
-                origin.pull()
-                console.print(
-                    "Successfully updated llm_friendly_packages repository")
-
-            except git.exc.GitCommandError as e:
-                console.print(f"Error updating repository: {e}")
-        else:
-            console.print(
-                "llm_friendly_packages repository does not exist. Please run /lib /add <library_name> command first to clone it."
-            )
-
-    elif subcommand == "/get":
-        if len(args) < 2:
-            console.print("Please specify a package name to get")
-            return
-        package_name = args[1].strip()
-        docs = get_llm_friendly_package_docs(package_name, return_paths=True)
-        if docs:
-            table = Table(title=f"Markdown Files for {package_name}")
-            table.add_column("File Path", style="cyan")
-            for doc in docs:
-                table.add_row(doc)
-            console.print(table)
-        else:
-            console.print(
-                f"No markdown files found for package: {package_name}")
-
-    else:
-        console.print(f"Unknown subcommand: {subcommand}")
-
-
-def execute_shell_command(command: str):
-    from autocoder.common.shells import execute_shell_command as shell_exec
-    shell_exec(command)
-
-
-def conf_export(path: str):
-    from autocoder.common.conf_import_export import export_conf
-    export_conf(os.getcwd(), path)
-
-def conf_import(path: str):
-    from autocoder.common.conf_import_export import import_conf
-    import_conf(os.getcwd(), path)
-
-@run_in_raw_thread()
-def auto_command(params,query: str):
-    """处理/auto指令"""
-    from autocoder.commands.auto_command import CommandAutoTuner, AutoCommandRequest, CommandConfig, MemoryConfig
-    args = get_final_config()
-    # help(query)
-
-    # 准备请求参数
-    request = AutoCommandRequest(
-        user_input=query        
-    )
-
-    # 初始化调优器
-    llm = get_single_llm(args.chat_model or args.model,product_mode=args.product_mode)    
-    tuner = CommandAutoTuner(llm, 
-                             args=args,
-                             memory_config=MemoryConfig(memory=memory, save_memory_func=save_memory), 
-                             command_config=CommandConfig(
-                                 add_files=add_files,
-                                 remove_files=remove_files,
-                                 list_files=list_files,
-                                 conf=configure,
-                                 revert=revert,
-                                 commit=commit,
-                                 help=help,
-                                 exclude_dirs=exclude_dirs,
-                                 exclude_files=exclude_files,
-                                 ask=ask,
-                                 chat=chat,
-                                 coding=coding,
-                                 design=design,
-                                 summon=summon,
-                                 lib=lib_command,
-                                 mcp=mcp,
-                                 models=manage_models,
-                                 index_build=index_build,
-                                 index_query=index_query,  
-                                 execute_shell_command=execute_shell_command,  
-                                 generate_shell_command=generate_shell_command,
-                                 conf_export=conf_export,
-                                 conf_import=conf_import,
-                                 index_export=index_export,
-                                 index_import=index_import                                                                                       
-                             ))
-
-    # 生成建议
-    response = tuner.analyze(request)
-    printer = Printer()
-    # 显示建议
-    console = Console()        
-    console.print(Panel(
-        Markdown(response.reasoning or ""),
-        title=printer.get_message_from_key_with_format("auto_command_reasoning_title"),
-        border_style="blue",
-        padding=(1, 2)
-    ))    
+ARGS = None
 
 
 def main():
-    from autocoder.rag.variable_holder import VariableHolder
-    from tokenizers import Tokenizer    
-    try:
-        tokenizer_path = pkg_resources.resource_filename(
-            "autocoder", "data/tokenizer.json"
-        )
-        VariableHolder.TOKENIZER_PATH = tokenizer_path
-        VariableHolder.TOKENIZER_MODEL = Tokenizer.from_file(tokenizer_path)
-    except FileNotFoundError:
-        tokenizer_path = None
+    load_tokenizer()
 
     ARGS = parse_arguments()
 
@@ -2736,10 +152,18 @@ def main():
     if ARGS.pro:
         ARGS.product_mode = "pro" 
 
-    if not ARGS.quick:
-        initialize_system(ARGS)    
+    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
+        ))
 
     load_memory()
+    memory = get_memory()    
 
     configure(f"product_mode:{ARGS.product_mode}")
 
@@ -2805,7 +229,7 @@ def main():
         pwd_parts = pwd.split(os.sep)
         if len(pwd_parts) > 3:
             pwd = os.sep.join(pwd_parts[-3:])
-        return f"Current Dir: {pwd} \nMode: {MODES[mode]} | Human as Model: {human_as_model} "
+        return f"Current Dir: {pwd} \nMode: {MODES[mode]}(ctrl+k) | Human as Model: {human_as_model}(ctrl+n) "
 
     session = PromptSession(
         history=InMemoryHistory(),