auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/auto_coder_runner.py

@@ -1,8 +1,7 @@
-from itertools import product
+from autocoder.common.project_scanner.compat import create_scanner_functions
 from rich.console import Console
 from rich.panel import Panel
 from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.shortcuts import radiolist_dialog
 from prompt_toolkit import prompt
 import os
 import yaml
@@ -10,73 +9,106 @@ import json
 import sys
 import io
 import uuid
-import glob
 import time
-import datetime
-import hashlib
+import byzerllm
+import subprocess
 from contextlib import contextmanager
 from typing import List, Dict, Any, Optional
 from autocoder.common import AutoCoderArgs
+from autocoder.common.autocoderargs_parser import AutoCoderArgsParser
 from pydantic import BaseModel
-from autocoder.common.action_yml_file_manager import ActionYmlFileManager
 from autocoder.common.result_manager import ResultManager
 from autocoder.version import __version__
 from autocoder.auto_coder import main as auto_coder_main
 from autocoder.utils import get_last_yaml_file
-from autocoder.commands.auto_command import CommandAutoTuner, AutoCommandRequest, CommandConfig, MemoryConfig
-from autocoder.common.v2.agent.agentic_edit import AgenticEdit,AgenticEditRequest
-from autocoder.common.v2.agent.agentic_edit_types import AgenticEditConversationConfig
+from autocoder.commands.auto_command import (
+    CommandAutoTuner,
+    AutoCommandRequest,
+    CommandConfig,
+    MemoryConfig,
+)
+from autocoder.common.v2.agent.agentic_edit import AgenticEditRequest
+from autocoder.common.v2.agent.agentic_edit_types import (
+    AgenticEditConversationConfig,
+    ConversationAction,
+)
+from autocoder.common.conversations.get_conversation_manager import (
+    get_conversation_manager,
+)
 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
-# Removed Text import as it's only used in the deleted print_conf
-from rich.live import Live
+from copy import deepcopy
+
 from rich.markdown import Markdown
 from byzerllm.utils.nontext import Image
-import git
+from autocoder.inner.agentic import RunAgentic
+
+# 延迟导入git模块以避免启动异常
+try:
+    import git
+
+    GIT_AVAILABLE = True
+except ImportError:
+    from loguru import logger
+
+    logger.warning("Git module not available. Some git features will be disabled.")
+    GIT_AVAILABLE = False
+    git = None
 from autocoder.common import git_utils
-from autocoder.chat_auto_coder_lang import get_message,get_message_with_format
+from autocoder.chat_auto_coder_lang import get_message, get_message_with_format
 from autocoder.agent.auto_guess_query import AutoGuessQuery
-from autocoder.common.mcp_server import get_mcp_server
-from autocoder.common.mcp_server_types import (
-    McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, 
-    McpListRunningRequest, McpRefreshRequest, McpServerInfoRequest
-)
-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
+
+# Do not remove these imports, they are exported to other modules e.g. chat_auto_coder.py
+from autocoder.common.mcp_tools.server import get_mcp_server
+from autocoder.common.memory_manager import get_global_memory_file_paths
+
+from rich.panel import Panel
+from rich.table import Table
+from autocoder.common.international import get_message, get_message_with_format
+from rich.prompt import Confirm
+from autocoder.common.printer import Printer
 from autocoder.utils.llms import get_single_llm
-import fnmatch
-import pkg_resources
+import importlib.resources as resources
 from autocoder.common.printer import Printer
-from autocoder.utils.thread_utils import run_in_raw_thread
-from autocoder.memory.active_context_manager import ActiveContextManager
-from autocoder.common.command_completer import CommandCompleter,FileSystemModel as CCFileSystemModel,MemoryConfig as CCMemoryModel
+from autocoder.common.command_completer import MemoryConfig as CCMemoryModel
 from autocoder.common.conf_validator import ConfigValidator
 from autocoder.common.ac_style_command_parser import parse_query
 from loguru import logger as global_logger
 from autocoder.utils.project_structure import EnhancedFileAnalyzer
-from autocoder.common import SourceCodeList,SourceCode
+from autocoder.common import SourceCode
 from autocoder.common.file_monitor import FileMonitor
-from filelock import FileLock
 from autocoder.common.command_file_manager import CommandManager
+from autocoder.common.v2.agent.runner import (
+    SdkRunner,
+    TerminalRunner,
+    FileBasedEventRunner,
+)
+from autocoder.completer import CommandCompleterV2
+from autocoder.common.core_config import get_memory_manager, load_memory as _load_memory
+from autocoder.common.global_cancel import global_cancel
+from autocoder.inner.async_command_handler import AsyncCommandHandler
+from autocoder.inner.queue_command_handler import QueueCommandHandler
+from autocoder.inner.conversation_command_handlers import (
+    ConversationNewCommandHandler,
+    ConversationResumeCommandHandler,
+    ConversationListCommandHandler,
+    ConversationRenameCommandHandler,
+    ConversationCommandCommandHandler,
+)
+
+# 对外API，用于第三方集成 auto-coder 使用。
 
 
-## 对外API，用于第三方集成 auto-coder 使用。
 class SymbolItem(BaseModel):
     symbol_name: str
     symbol_type: SymbolType
     file_name: str
 
+
 class InitializeSystemRequest(BaseModel):
     product_mode: str
     skip_provider_selection: bool
@@ -92,20 +124,45 @@ if platform.system() == "Windows":
     init()
 
 
-memory = {
-    "conversation": [],
-    "current_files": {"files": [], "groups": {}},
-    "conf": {},
-    "exclude_dirs": [],
-    "mode": "auto_detect",  # 新增mode字段,默认为 auto_detect 模式
-}
-
+# Initialize memory and project root
 project_root = os.getcwd()
 
+# Initialize memory manager with project root
+_memory_manager = get_memory_manager(project_root)
+
+# Wrapper functions to sync global memory variable
+
+
+def save_memory():
+    """Save memory - compatibility function (no-op since MemoryManager handles persistence)"""
+    # This function is kept for backward compatibility but does nothing
+    # since MemoryManager automatically handles persistence
+    raise NotImplementedError(
+        "save_memory is not supported anymore, please use autocoder.common.core_config.memory_manager instead."
+    )
+
+
+def load_memory():
+    """Load memory using MemoryManager"""
+    return _load_memory()
+
+
+def get_memory():
+    """Get current memory"""
+    return load_memory()
 
-base_persist_dir = os.path.join(project_root,".auto-coder", "plugins", "chat-auto-coder")
 
-defaut_exclude_dirs = [".git", "node_modules", "dist", "build", "__pycache__",".auto-coder"]
+# Compatibility: base_persist_dir is now managed by memory manager
+base_persist_dir = _memory_manager.base_persist_dir
+
+defaut_exclude_dirs = [
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "__pycache__",
+    ".auto-coder",
+]
 
 commands = [
     "/add_files",
@@ -122,7 +179,7 @@ commands = [
     "/index/build",
     "/index/export",
     "/index/import",
-    "/exclude_files",        
+    "/exclude_files",
     "/help",
     "/shell",
     "/voice_input",
@@ -137,21 +194,65 @@ commands = [
     "/conf/export",
     "/conf/import",
     "/exclude_dirs",
+    "/queue",
 ]
 
+
 def load_tokenizer():
     from autocoder.rag.variable_holder import VariableHolder
-    from tokenizers import Tokenizer    
+    from tokenizers import Tokenizer
+
     try:
-        tokenizer_path = pkg_resources.resource_filename(
-            "autocoder", "data/tokenizer.json"
-        )
+        tokenizer_path = str(resources.files("autocoder") / "data" / "tokenizer.json")
         VariableHolder.TOKENIZER_PATH = tokenizer_path
         VariableHolder.TOKENIZER_MODEL = Tokenizer.from_file(tokenizer_path)
     except FileNotFoundError:
         tokenizer_path = None
 
 
+def configure_logger():
+    # 设置日志目录和文件
+    log_dir = os.path.join(project_root, ".auto-coder", "logs")
+    os.makedirs(log_dir, exist_ok=True)
+    log_file = os.path.join(log_dir, "auto-coder.log")
+
+    # 配置全局日志
+    # 默认情况下，所有日志都写入文件
+    # 控制台上默认不输出任何日志，除非显式配置
+    global_logger.configure(
+        handlers=[
+            {
+                "sink": log_file,
+                "level": "INFO",
+                "rotation": "10 MB",
+                "retention": "1 week",
+                "format": "{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
+            },
+            {
+                "sink": sys.stdout,
+                "level": "INFO",
+                "format": "{time:YYYY-MM-DD HH:mm:ss} | {name} | {message}",
+                # 默认不打印任何日志到控制台
+                "filter": lambda record: False,
+            },
+        ]
+    )
+
+
+def init_singleton_instances():
+    # 初始化文件监控系统
+    try:
+        FileMonitor(project_root).start()
+    except Exception as e:
+        global_logger.error(f"Failed to start file monitor: {e}")
+        global_logger.exception(e)
+
+    # 初始化忽略文件管理器
+    from autocoder.common.ignorefiles.ignore_file_utils import IgnoreFileManager
+
+    _ = IgnoreFileManager(project_root=project_root)
+
+
 def configure_project_type():
     from prompt_toolkit.lexers import PygmentsLexer
     from pygments.lexers.markup import MarkdownLexer
@@ -173,12 +274,10 @@ def configure_project_type():
         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)
+        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_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"))
@@ -188,7 +287,7 @@ def configure_project_type():
     print_info(get_message("examples"))
 
     print_warning(f"{get_message('default_type')}\n")
-    
+
     extensions = get_all_extensions(project_root) or "py"
     project_type = prompt(
         get_message("enter_project_type"), default=extensions, style=style
@@ -215,72 +314,27 @@ def get_all_extensions(directory: str = ".") -> str:
         target_file="",
         git_url="",
         project_type="",
-        conversation_prune_safe_zone_tokens=0
+        conversation_prune_safe_zone_tokens=0,
     )
-    
+
     analyzer = EnhancedFileAnalyzer(
         args=args,
         llm=None,  # 如果只是获取后缀名，可以不需要LLM
-        config=None  # 使用默认配置
+        config=None,  # 使用默认配置
     )
-    
+
     # 获取分析结果
     analysis_result = analyzer.analyze_extensions()
-    
+
     # 合并 code 和 config 的后缀名
     all_extensions = set(analysis_result["code"] + analysis_result["config"])
-    
+
     # 转换为逗号分隔的字符串
     return ",".join(sorted(all_extensions))
 
-def configure_logger():
-    # 设置日志目录和文件    
-    log_dir = os.path.join(project_root, ".auto-coder", "logs")
-    os.makedirs(log_dir, exist_ok=True)
-    log_file = os.path.join(log_dir, "auto-coder.log")
-
-    # 配置全局日志
-    # 默认情况下，所有日志都写入文件
-    # 控制台上默认不输出任何日志，除非显式配置
-    global_logger.configure(
-        handlers=[
-            {
-                "sink": log_file,
-                "level": "INFO",
-                "rotation": "10 MB",
-                "retention": "1 week",
-                "format": "{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
-            },
-            {
-                "sink": sys.stdout,
-                "level": "INFO",
-                "format": "{time:YYYY-MM-DD HH:mm:ss} | {name} | {message}",
-                # 默认不打印任何日志到控制台
-                "filter": lambda record: False
-            }
-        ]
-    )
-
-
-def init_singleton_instances():
-    # 初始化文件监控系统
-    try:
-        FileMonitor(project_root).start()
-    except Exception as e:
-        global_logger.error(f"Failed to start file monitor: {e}")
-        global_logger.exception(e)
-    
-    # 初始化规则文件管理器
-    from autocoder.common.rulefiles.autocoderrules_utils import get_rules
-    get_rules(project_root=project_root)
-
-    # 初始化忽略文件管理器
-    from autocoder.common.ignorefiles.ignore_file_utils import IgnoreFileManager
-    _ = IgnoreFileManager(project_root=project_root)
-
 
-def start():    
-    if os.environ.get('autocoder_auto_init',"true") in ["true","True","True",True]:
+def start():
+    if os.environ.get("autocoder_auto_init", "true") in ["true", "True", "True", True]:
         configure_logger()
         init_singleton_instances()
 
@@ -292,7 +346,7 @@ def start():
     #     name = f"{time_str}-{str(uuid.uuid4())}"
     #     conversation_id = conversation_manager.create_new_conversation(name=name,description="")
     #     conversation_manager.set_current_conversation(conversation_id)
-            
+
 
 def stop():
     try:
@@ -301,9 +355,11 @@ def stop():
         global_logger.error(f"Failed to stop file monitor: {e}")
         global_logger.exception(e)
 
-def initialize_system(args:InitializeSystemRequest):
+
+def initialize_system(args: InitializeSystemRequest):
     from autocoder.utils.model_provider_selector import ModelProviderSelector
-    from autocoder import models as models_module
+    from autocoder.common.llms import LLMManager
+
     print(f"\n\033[1;34m{get_message('initializing')}\033[0m")
 
     first_time = [False]
@@ -319,54 +375,42 @@ def initialize_system(args:InitializeSystemRequest):
         else:
             print(f"  {message}")
 
-    def init_project():           
-        if not os.path.exists(".auto-coder") or not os.path.exists("actions"):
-            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_with_format("created_dir",path=base_persist_dir), "success")
+            print_status(
+                get_message_with_format("created_dir", path=base_persist_dir), "success"
+            )
 
         if first_time[0]:
-            configure_project_type()
+            configure("project_type:*", skip_print=True)
             configure_success[0] = True
 
         print_status(get_message("init_complete"), "success")
 
-    init_project()
+    init_project_if_required(target_dir=project_root, project_type="*")
 
     if not args.skip_provider_selection and first_time[0]:
-        if args.product_mode == "lite":                    
-            ## 如果已经是配置过的项目，就无需再选择
+        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"):
+                llm_manager = LLMManager()
+                if not llm_manager.check_model_exists(
+                    "v3_chat"
+                ) or not llm_manager.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)              
+                        models_json_list = model_provider_selector.to_models_json(
+                            model_provider_info
+                        )
+                        llm_manager.add_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)
+                ["ray", "status"], capture_output=True, text=True
+            )
             if ray_status.returncode != 0:
                 print_status(get_message("ray_not_running"), "warning")
                 try:
@@ -389,7 +433,6 @@ def initialize_system(args:InitializeSystemRequest):
                 )
                 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:
@@ -428,7 +471,6 @@ def initialize_system(args:InitializeSystemRequest):
                 print_status(get_message("deploy_fail"), "error")
                 return
 
-
             deploy_cmd = [
                 "byzerllm",
                 "deploy",
@@ -471,14 +513,18 @@ def initialize_system(args:InitializeSystemRequest):
                 print_status(get_message("manual_start"), "warning")
                 print_status("easy-byzerllm chat v3_chat 你好", "")
 
-            print_status(get_message("init_complete_final"), "success")  
+            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"model:v3_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)        
+    if (
+        first_time[0]
+        and args.product_mode == "lite"
+        and LLMManager().check_model_exists("v3_chat")
+    ):
+        configure(f"model:v3_chat", skip_print=True)
 
 
 def convert_yaml_config_to_str(yaml_config):
@@ -491,92 +537,44 @@ def convert_yaml_config_to_str(yaml_config):
     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):
+    # 定义需要使用 token 解析的字段
+    token_fields = {
+        "conversation_prune_safe_zone_tokens",
+        "context_prune_safe_zone_tokens",
+        "context_prune_sliding_window_size",
+        "context_prune_sliding_window_overlap",
+        "rag_params_max_tokens",
+        "rag_context_window_limit",
+        "rag_duckdb_vector_dim",
+        "rag_duckdb_query_top_k",
+        "rag_emb_dim",
+        "rag_emb_text_size",
+        "hybrid_index_max_output_tokens",
+        "data_cells_max_num",
+    }
+
     field_info = AutoCoderArgs.model_fields.get(key)
     if field_info:
+        # 对于需要 token 解析的字段，使用 AutoCoderArgsParser
+        if key in token_fields:
+            try:
+                parser = AutoCoderArgsParser()
+                return parser.parse_token_field(key, value)
+            except Exception as e:
+                print(
+                    f"Warning: Failed to parse token field '{key}' with value '{value}': {e}"
+                )
+                # 如果解析失败，fallback 到原有逻辑
+                pass
+
+        # 原有的类型转换逻辑
         if isinstance(value, str) and 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)
+        elif "int" in str(field_info.annotation):
+            return int(value)
         else:
             return value
     else:
@@ -594,14 +592,14 @@ def redirect_stdout():
         sys.stdout = original_stdout
 
 
-def configure(conf: str, skip_print=False):
+def configure(conf: str, skip_print=True):
     printer = Printer()
+    memory_manager = get_memory_manager()
     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()
+        if memory_manager.has_config(key):
+            memory_manager.delete_config(key)
             printer.print_in_terminal("config_delete_success", style="green", key=key)
         else:
             printer.print_in_terminal("config_not_found", style="yellow", key=key)
@@ -616,109 +614,75 @@ def configure(conf: str, skip_print=False):
         if not value:
             printer.print_in_terminal("config_value_empty", style="red")
             return
-        product_mode = memory["conf"].get("product_mode",None)  
+        product_mode = memory_manager.get_config("product_mode", None)
         if product_mode:
-            ConfigValidator.validate(key, value, product_mode)    
-        memory["conf"][key] = value
-        save_memory()
+            ConfigValidator.validate(key, value, product_mode)
+        memory_manager.set_config(key, value)
         if not skip_print:
-            printer.print_in_terminal("config_set_success", style="green", key=key, value=value)
+            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")
+# Memory management functions are now imported from core_config module
+# Helper functions to access memory without global variables
+def get_current_memory():
+    """Get current memory as dictionary for backward compatibility"""
+    return get_memory()
 
-    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 get_current_files():
+    """Get current files list"""
+    memory_manager = get_memory_manager()
+    return memory_manager.get_current_files()
+
+
+def set_current_files(files):
+    """Set current files list"""
+    memory_manager = get_memory_manager()
+    memory_manager.set_current_files(files)
+
+
+def get_file_groups():
+    """Get file groups"""
+    memory_manager = get_memory_manager()
+    return memory_manager.get_file_groups()
+
+
+def get_exclude_dirs():
+    """Get exclude directories"""
+    memory_manager = get_memory_manager()
+    return memory_manager.get_exclude_dirs()
+
+
+# 使用 project_scanner 模块创建兼容函数（供其他地方使用）
+scanner_funcs = create_scanner_functions(
+    project_root=project_root,
+    default_exclude_dirs=defaut_exclude_dirs,
+    get_extra_exclude_dirs_func=get_exclude_dirs,
+)
+
+# 导出兼容函数
+get_all_file_names_in_project = scanner_funcs["get_all_file_names_in_project"]
+get_all_file_in_project = scanner_funcs["get_all_file_in_project"]
+get_all_file_in_project_with_dot = scanner_funcs["get_all_file_in_project_with_dot"]
+get_all_dir_names_in_project = scanner_funcs["get_all_dir_names_in_project"]
+find_files_in_project = scanner_funcs["find_files_in_project"]
+get_symbol_list = scanner_funcs["get_symbol_list"]
+
+# 直接创建 CommandCompleterV2，它内部会使用 project_scanner
+completer = CommandCompleterV2(
+    commands,
+    memory_model=CCMemoryModel(
+        get_memory_func=get_memory, save_memory_func=save_memory
+    ),
+    project_root=project_root,
+)
 
 
-def save_memory():
-    memory_path = os.path.join(base_persist_dir, "memory.json")
-    lock_path = memory_path + ".lock"
-    
-    with FileLock(lock_path, timeout=30):
-        with open(memory_path, "w", encoding="utf-8") as f:
-            json.dump(memory, f, indent=2, ensure_ascii=False)
-    
-    load_memory()
-
-
-def save_memory_with_new_memory(new_memory):
-    memory_path = os.path.join(base_persist_dir, "memory.json")
-    lock_path = memory_path + ".lock"
-    
-    with FileLock(lock_path, timeout=30):
-        with open(memory_path, "w", encoding="utf-8") as f:
-            json.dump(new_memory, f, indent=2, ensure_ascii=False)
-    load_memory()        
-
-
-def load_memory():    
-    global memory
-    memory_path = os.path.join(base_persist_dir, "memory.json")
-    lock_path = memory_path + ".lock"
-    
-    if os.path.exists(memory_path):
-        with FileLock(lock_path, timeout=30):
-            with open(memory_path, "r", encoding="utf-8") as f:
-                _memory = json.load(f)
-            # clear memory
-            memory.clear()
-            memory.update(_memory)    
-    return memory
-
-def get_memory():    
-    return load_memory()    
-
-
-from autocoder.common.command_completer_v2 import CommandCompleterV2
-completer = CommandCompleterV2(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(get_memory_func=get_memory,
-                                                         save_memory_func=save_memory))
 def revert():
     result_manager = ResultManager()
     last_yaml_file = get_last_yaml_file("actions")
@@ -728,57 +692,36 @@ def revert():
         with redirect_stdout() as output:
             auto_coder_main(["revert", "--file", file_path])
         s = output.getvalue()
-        
+
         console = Console()
         panel = Panel(
             Markdown(s),
             title="Revert Result",
             border_style="green" if "Successfully reverted changes" in s else "red",
             padding=(1, 2),
-            expand=False
+            expand=False,
         )
         console.print(panel)
-        
+
         if "Successfully reverted changes" in s:
-            result_manager.append(content=s, meta={"action": "revert","success":False, "input":{                
-            }})                                    
+            result_manager.append(
+                content=s, meta={"action": "revert", "success": False, "input": {}}
+            )
         else:
-            result_manager.append(content=s, meta={"action": "revert","success":False, "input":{                
-            }})
+            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":{                
-            }})        
-
-
-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()
+        result_manager.append(
+            content="No previous chat action found to revert.",
+            meta={"action": "revert", "success": False, "input": {}},
+        )
 
 
 def _handle_post_commit_and_pr(post_commit: bool, pr: bool, query: str, args, llm):
     """
     处理 post_commit 和 PR 功能
-    
+
     Args:
         post_commit: 是否执行 post_commit
         pr: 是否创建 PR
@@ -787,13 +730,11 @@ def _handle_post_commit_and_pr(post_commit: bool, pr: bool, query: str, args, ll
         llm: LLM 实例
     """
     printer = Printer()
-    console = Console()
-    
     try:
         if post_commit:
             # 执行 post_commit 操作
             printer.print_in_terminal("post_commit_executing", style="blue")
-            
+
             # 检查是否有未提交的更改
             uncommitted_changes = git_utils.get_uncommitted_changes(".")
             if uncommitted_changes:
@@ -801,46 +742,144 @@ def _handle_post_commit_and_pr(post_commit: bool, pr: bool, query: str, args, ll
                 commit_message = git_utils.generate_commit_message.with_llm(llm).run(
                     uncommitted_changes
                 )
-                
+
                 # 执行提交
                 commit_result = git_utils.commit_changes(".", commit_message)
                 git_utils.print_commit_info(commit_result=commit_result)
-                printer.print_in_terminal("post_commit_success", style="green", message=commit_message)
-                
+                printer.print_in_terminal(
+                    "post_commit_success", style="green", message=commit_message
+                )
+
                 # 如果需要创建 PR，则继续处理
                 if pr:
                     _create_pull_request(commit_result, query, llm)
             else:
                 printer.print_in_terminal("post_commit_no_changes", style="yellow")
-                
+
         elif pr:
             # 只创建 PR，不执行 post_commit
             # 获取最后一个 commit
             try:
                 repo = git.Repo(".")
                 last_commit = repo.head.commit
-                
+
                 # 创建一个模拟的 commit_result 对象
                 class MockCommitResult:
                     def __init__(self, commit):
                         self.commit_hash = commit.hexsha
                         self.commit_message = commit.message.strip()
                         self.changed_files = []
-                        
+
                 mock_commit_result = MockCommitResult(last_commit)
                 _create_pull_request(mock_commit_result, query, llm)
-                
+
             except Exception as e:
-                printer.print_in_terminal("pr_get_last_commit_failed", style="red", error=str(e))
-                
+                printer.print_in_terminal(
+                    "pr_get_last_commit_failed", style="red", error=str(e)
+                )
+
     except Exception as e:
         printer.print_in_terminal("post_commit_pr_failed", style="red", error=str(e))
 
 
+def init_project_if_required(target_dir: str, project_type: str):
+    """
+    如果项目没有初始化，则自动初始化项目
+
+    Args:
+        target_dir: 目标目录路径
+    """
+
+    # 确保目标目录是绝对路径
+    if not os.path.isabs(target_dir):
+        target_dir = os.path.abspath(target_dir)
+
+    actions_dir = os.path.join(target_dir, "actions")
+    auto_coder_dir = os.path.join(target_dir, ".auto-coder")
+
+    # 检查是否已经初始化
+    if os.path.exists(actions_dir) and os.path.exists(auto_coder_dir):
+        return  # 已经初始化，无需再次初始化
+
+    printer = Printer()
+
+    try:
+        # 创建必要的目录
+        os.makedirs(actions_dir, exist_ok=True)
+        os.makedirs(auto_coder_dir, exist_ok=True)
+
+        # 导入并使用 create_actions 创建默认的 action 文件
+        from autocoder.common.command_templates import create_actions
+
+        create_actions(
+            source_dir=target_dir,
+            params={"project_type": project_type, "source_dir": target_dir},
+        )
+
+        # 初始化 git 仓库
+        try:
+            git_utils.init(target_dir)
+        except Exception as e:
+            global_logger.warning(f"Failed to initialize git repository: {e}")
+
+        # 创建或更新 .gitignore 文件
+        gitignore_path = os.path.join(target_dir, ".gitignore")
+        gitignore_entries = [
+            ".auto-coder/",
+            "/actions/",
+            "/output.txt",
+            ".autocoderrules",
+            ".autocodertools",
+            ".autocodercommands",
+            ".autocoderagents",
+            ".autocoderlinters",
+        ]
+
+        try:
+            # 读取现有的 .gitignore 内容
+            existing_entries = set()
+            if os.path.exists(gitignore_path):
+                with open(gitignore_path, "r", encoding="utf-8") as f:
+                    # 将现有内容按行分割并去除空白字符，转换为集合以便快速查找
+                    existing_entries = {line.strip() for line in f if line.strip()}
+
+            # 筛选出需要添加的新条目
+            new_entries = [
+                entry for entry in gitignore_entries if entry not in existing_entries
+            ]
+
+            # 如果有新条目需要添加，则写入文件
+            if new_entries:
+                with open(gitignore_path, "a", encoding="utf-8") as f:
+                    for entry in new_entries:
+                        f.write(f"\n{entry}")
+        except Exception as e:
+            global_logger.warning(f"Failed to update .gitignore: {e}")
+
+        # 创建 .autocoderignore 文件
+        try:
+            autocoderignore_path = os.path.join(target_dir, ".autocoderignore")
+            if not os.path.exists(autocoderignore_path):
+                autocoderignore_content = "target\n"
+                with open(autocoderignore_path, "w", encoding="utf-8") as f:
+                    f.write(autocoderignore_content)
+        except Exception as e:
+            global_logger.warning(f"Failed to create .autocoderignore: {e}")
+
+        configure(f"project_type:{project_type}", skip_print=True)
+        global_logger.info(
+            f"Successfully initialized auto-coder project in {target_dir}"
+        )
+
+    except Exception as e:
+        global_logger.error(f"Failed to initialize project in {target_dir}: {e}")
+        printer.print_in_terminal("init_project_error", style="red", error=str(e))
+
+
 def _create_pull_request(commit_result, original_query: str, llm):
     """
     创建 Pull Request
-    
+
     Args:
         commit_result: 提交结果对象
         original_query: 原始查询
@@ -848,76 +887,92 @@ def _create_pull_request(commit_result, original_query: str, llm):
     """
     printer = Printer()
     console = Console()
-    
+
     try:
         # 检查是否安装了 gh CLI
         gh_check = subprocess.run(["gh", "--version"], capture_output=True, text=True)
         if gh_check.returncode != 0:
             printer.print_in_terminal("pr_gh_not_installed", style="red")
             return
-            
+
         # 检查是否已经登录 GitHub
-        auth_check = subprocess.run(["gh", "auth", "status"], capture_output=True, text=True)
+        auth_check = subprocess.run(
+            ["gh", "auth", "status"], capture_output=True, text=True
+        )
         if auth_check.returncode != 0:
             printer.print_in_terminal("pr_gh_not_authenticated", style="red")
             return
-            
+
         # 获取当前分支名
         repo = git.Repo(".")
         current_branch = repo.active_branch.name
-        
+
         # 如果在 main/master 分支，创建新分支
         if current_branch in ["main", "master"]:
             # 生成新分支名
             import re
-            branch_name = re.sub(r'[^a-zA-Z0-9\-_]', '-', original_query.lower())
+
+            branch_name = re.sub(r"[^a-zA-Z0-9\-_]", "-", original_query.lower())
             branch_name = f"auto-coder-{branch_name[:30]}-{int(time.time())}"
-            
+
             # 创建并切换到新分支
             new_branch = repo.create_head(branch_name)
             new_branch.checkout()
             current_branch = branch_name
-            
-            printer.print_in_terminal("pr_created_branch", style="blue", branch=branch_name)
-            
+
+            printer.print_in_terminal(
+                "pr_created_branch", style="blue", branch=branch_name
+            )
+
         # 推送当前分支到远程
         try:
             origin = repo.remotes.origin
             origin.push(current_branch)
-            printer.print_in_terminal("pr_pushed_branch", style="blue", branch=current_branch)
+            printer.print_in_terminal(
+                "pr_pushed_branch", style="blue", branch=current_branch
+            )
         except Exception as e:
             printer.print_in_terminal("pr_push_failed", style="red", error=str(e))
             return
-            
+
         # 生成 PR 标题和描述
         pr_title, pr_body = _generate_pr_content(commit_result, original_query, llm)
-        
+
         # 创建 PR
         pr_cmd = [
-            "gh", "pr", "create",
-            "--title", pr_title,
-            "--body", pr_body,
-            "--head", current_branch
+            "gh",
+            "pr",
+            "create",
+            "--title",
+            pr_title,
+            "--body",
+            pr_body,
+            "--head",
+            current_branch,
         ]
-        
+
         pr_result = subprocess.run(pr_cmd, capture_output=True, text=True)
-        
+
         if pr_result.returncode == 0:
             pr_url = pr_result.stdout.strip()
             printer.print_in_terminal("pr_created_success", style="green", url=pr_url)
-            
+
             # 显示 PR 信息
-            console.print(Panel(
-                f"[bold green]Pull Request Created Successfully![/bold green]\n\n"
-                f"[bold]Title:[/bold] {pr_title}\n"
-                f"[bold]URL:[/bold] {pr_url}\n"
-                f"[bold]Branch:[/bold] {current_branch}",
-                title="🎉 Pull Request",
-                border_style="green"
-            ))
+            console.print(
+                Panel(
+                    f"[bold green]Pull Request Created Successfully![/bold green]\n\n"
+                    f"[bold]Title:[/bold] {pr_title}\n"
+                    f"[bold]URL:[/bold] {pr_url}\n"
+                    f"[bold]Branch:[/bold] {current_branch}",
+                    title="🎉 Pull Request",
+                    border_style="green",
+                )
+            )
         else:
-            printer.print_in_terminal("pr_creation_failed", style="red", error=pr_result.stderr)
-            
+            printer.print_in_terminal(
+                "pr_creation_failed", style="red", error=pr_result.stderr
+            )
+
     except Exception as e:
         printer.print_in_terminal("pr_creation_error", style="red", error=str(e))
 
@@ -926,22 +981,22 @@ def _create_pull_request(commit_result, original_query: str, llm):
 def _generate_pr_content(commit_result, original_query: str, llm) -> tuple:
     """
     生成 PR 标题和描述
-    
+
     根据提交信息和原始查询生成合适的 PR 标题和描述。
-    
+
     Args:
         commit_result: 提交结果，包含 commit_message 和 changed_files
         original_query: 用户的原始查询请求
-        
+
     Returns:
         tuple: (pr_title, pr_body) PR标题和描述内容
-        
+
     请生成简洁明了的 PR 标题（不超过72字符）和详细的描述内容。
     标题应该概括主要变更，描述应该包含：
     1. 变更的背景和目的
     2. 主要修改内容
     3. 影响的文件（如果有的话）
-    
+
     提交信息：{{ commit_result.commit_message }}
     原始需求：{{ original_query }}
     {% if commit_result.changed_files %}
@@ -951,7 +1006,7 @@ def _generate_pr_content(commit_result, original_query: str, llm) -> tuple:
     {% endfor %}
     {% endif %}
     """
-    
+
     # 这个函数会被 byzerllm 装饰器处理，返回 LLM 生成的内容
     # 实际实现会在运行时由装饰器处理
     pass
@@ -979,14 +1034,14 @@ def _generate_pr_content(commit_result, original_query: str, llm):
 TITLE: [标题内容]
 BODY: [描述内容]
 """
-        
+
         response = llm.chat([{"role": "user", "content": prompt}])
-        
+
         # 解析响应
-        lines = response.split('\n')
+        lines = response.split("\n")
         title = ""
         body = ""
-        
+
         for line in lines:
             if line.startswith("TITLE:"):
                 title = line.replace("TITLE:", "").strip()
@@ -994,15 +1049,15 @@ BODY: [描述内容]
                 body = line.replace("BODY:", "").strip()
             elif body:  # 如果已经开始收集 body，继续添加后续行
                 body += "\n" + line
-                
+
         # 如果解析失败，使用默认值
         if not title:
             title = f"Auto-coder: {original_query[:50]}..."
         if not body:
             body = f"This PR was automatically generated by Auto-coder.\n\nOriginal request: {original_query}"
-            
+
         return title, body
-        
+
     except Exception as e:
         # 如果 LLM 生成失败，使用默认值
         title = f"Auto-coder: {original_query[:50]}..."
@@ -1011,351 +1066,34 @@ BODY: [描述内容]
 
 
 def add_files(args: List[str]):
+    """
+    处理文件添加命令，使用 AddFilesHandler 进行统一处理
 
-    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}})
+    Args:
+        args: 命令参数列表
+    """
+    from autocoder.common.file_handler import AddFilesHandler
 
-    save_memory()
+    handler = AddFilesHandler()
+    handler.handle_add_files_command(args)
 
 
 def remove_files(file_names: List[str]):
-    project_root = os.getcwd()
-    printer = Printer()
-    result_manager = ResultManager()
+    """
+    处理文件删除命令，使用 RemoveFilesHandler 进行统一处理
 
-    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:
-        files_to_remove = set()
-        current_files_abs = memory["current_files"]["files"]
-
-        for pattern in file_names:
-            pattern = pattern.strip() # Remove leading/trailing whitespace
-            if not pattern:
-                continue
-
-            is_wildcard = "*" in pattern or "?" in pattern
-
-            for file_path_abs in current_files_abs:
-                relative_path = os.path.relpath(file_path_abs, project_root)
-                basename = os.path.basename(file_path_abs)
-
-                matched = False
-                if is_wildcard:
-                    # Match pattern against relative path or basename
-                    if fnmatch.fnmatch(relative_path, pattern) or fnmatch.fnmatch(basename, pattern):
-                        matched = True
-                else:
-                    # Exact match against relative path, absolute path, or basename
-                    if relative_path == pattern or file_path_abs == pattern or basename == pattern:
-                        matched = True
-
-                if matched:
-                    files_to_remove.add(file_path_abs)
-
-        removed_files_list = list(files_to_remove)
-        if removed_files_list:
-            # Update memory by filtering out the files to remove
-            memory["current_files"]["files"] = [
-                f for f in current_files_abs if f not in files_to_remove
-            ]
+    Args:
+        file_names: 文件名列表或模式列表
+    """
+    from autocoder.common.file_handler import RemoveFilesHandler
 
-            table = Table(
-                show_header=True,
-                header_style="bold magenta"
-            )
-            table.add_column(printer.get_message_from_key("file_column_title"), style="green")
-            for f in removed_files_list:
-                table.add_row(os.path.relpath(f, project_root))
+    handler = RemoveFilesHandler()
+    handler.handle_remove_files_command(file_names)
 
-            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_list)}",
-                              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}})    
-    save_memory()
 
-@run_in_raw_thread()
 def ask(query: str):
-    conf = memory.get("conf", {})
+    memory_manager = get_memory_manager()
+    conf = memory_manager.get_all_config()
     yaml_config = {
         "include_file": ["./base/base.yml"],
     }
@@ -1383,7 +1121,7 @@ def ask(query: str):
 
     execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
 
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
+    with open(os.path.join(execute_file), "w", encoding="utf-8") as f:
         f.write(yaml_content)
 
     def execute_ask():
@@ -1398,50 +1136,27 @@ def ask(query: str):
 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
+    """
+    Get LLM friendly package documentation using the new AC module system
+
+    Args:
+        package_name: Specific package name to get docs for, None for all packages
+        return_paths: If True, return file paths; if False, return file contents
+
+    Returns:
+        List of documentation content or file paths
+    """
+    from autocoder.common.llm_friendly_package import get_package_manager
+
+    package_manager = get_package_manager()
+    return package_manager.get_docs(package_name, return_paths)
 
 
 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:
+    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():
@@ -1453,150 +1168,22 @@ def convert_yaml_to_config(yaml_file: str):
                 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",
-        "exclude_files": memory.get("exclude_files", []),
-    }
-    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()   
-
-
-    if query.startswith("/info"):
-        response = mcp_server.send_request(McpServerInfoRequest(
-            model=args.inference_model or args.model,
-            product_mode=args.product_mode
-        ))
-        if response.error:
-            printer.print_in_terminal("mcp_server_info_error", style="red", error=response.error)
-        else:
-            printer.print_in_terminal("mcp_server_info_title")
-            printer.print_str_in_terminal(response.result)
-        return
-
-    response = mcp_server.send_request(
-        McpRequest(
-            query=query,
-            model=args.inference_model or args.model,
-            product_mode=args.product_mode
-        )
-    )
+def mcp(query: str):
+    """
+    处理MCP命令，使用 McpHandler 进行统一处理
 
-    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")
+    Args:
+        query: 查询字符串
+    """
+    from autocoder.common.file_handler import McpHandler
 
-        # Format response as markdown
-        markdown_content = response.result
+    handler = McpHandler()
+    handler.handle_mcp_command(query)
 
-        # 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):
+    memory = get_current_memory()
     conf = memory.get("conf", {})
     yaml_config = {
         "include_file": ["./base/base.yml"],
@@ -1605,7 +1192,7 @@ def code_next(query: str):
         "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")
+        "include_project_structure": conf.get("include_project_structure", "false")
         == "true",
         "exclude_files": memory.get("exclude_files", []),
     }
@@ -1616,7 +1203,7 @@ def code_next(query: str):
 
     temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
     try:
-        with open(temp_yaml, "w",encoding="utf-8") as f:
+        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:
@@ -1626,8 +1213,7 @@ def code_next(query: str):
     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)
+    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
@@ -1641,25 +1227,20 @@ def code_next(query: str):
     console = Console()
 
     # Create main panel for all predicted tasks
-    table = Table(show_header=True,
-                  header_style="bold magenta", show_lines=True)
+    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("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")
+    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])
+        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"
+            "\n".join(task.dependency_queries) if task.dependency_queries else "None"
         )
 
         table.add_row(
@@ -1676,260 +1257,42 @@ def code_next(query: str):
     )
 
 
-@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", "false") 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)
-
-            args.file = execute_file             
-            
-            file_name = os.path.basename(execute_file)
-            commit_result = git_utils.commit_changes(
-                ".", f"{commit_message}\nauto_coder_{file_name}"
-            )
-
-            printer = Printer()
-
-            action_yml_file_manager = ActionYmlFileManager(args.source_dir)
-            action_file_name = os.path.basename(args.file)
-            add_updated_urls = []            
-            for file in commit_result.changed_files:
-                add_updated_urls.append(os.path.join(args.source_dir, file))
-
-            args.add_updated_urls = add_updated_urls
-            update_yaml_success = action_yml_file_manager.update_yaml_field(action_file_name, "add_updated_urls", add_updated_urls)
-            if not update_yaml_success:                        
-                printer.print_in_terminal("yaml_save_error", style="red", yaml_file=action_file_name)  
-                        
-            if args.enable_active_context:                
-                active_context_manager = ActiveContextManager(llm, args.source_dir)
-                task_id = active_context_manager.process_changes(args)
-                printer.print_in_terminal("active_context_background_task", 
-                                             style="blue",
-                                             task_id=task_id)
-            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
+def commit(query: Optional[str] = None):
+    """
+    处理提交命令，使用 CommitHandler 进行统一处理
 
-        yaml_config["urls"] = current_files + get_llm_friendly_package_docs(
-            return_paths=True
-        )
+    Args:
+        query: 可选的提交消息或命令
+    """
+    from autocoder.common.file_handler import CommitHandler
 
-        if conf.get("enable_global_memory", "false") in ["true", "True",True]:
-            yaml_config["urls"] += get_global_memory_file_paths()
+    handler = CommitHandler()
+    handler.handle_commit_command(query)
 
-        # 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",
-                    )
-                )
+def coding(query: str, cancel_token=None):
+    """
+    处理代码生成命令，使用 CodingHandler 进行统一处理
 
-            conversations = []
-            if os.path.exists(memory_file):            
-                with open(memory_file, "r",encoding="utf-8") as f:
-                    chat_history = json.load(f)
-
-                if not chat_history["ask_conversation"]:
-                    error_message()                    
-                else: 
-                    conversations = chat_history["ask_conversation"]
-            
-            if conversations:
-                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)        
+    Args:
+        query: 代码生成查询字符串
+        cancel_token: 可选的取消令牌
+    """
+    from autocoder.common.file_handler import CodingHandler
 
-        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)
+    handler = CodingHandler()
+    handler.handle_coding_command(query, cancel_token)
 
-        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}","action": "coding", "input":{
-                "query": query
-            }})
 
-        execute_chat()
-    else:
-        print("Failed to create new YAML file.")
+def rules(query: str):
+    from autocoder.chat.rules_command import handle_rules_command
 
-    save_memory()
+    result = handle_rules_command(query, coding_func=coding)
+    # 只有当结果不为空时才打印，避免重复输出
+    if result and result.strip():
+        print(result)
     completer.refresh_files()
 
-@run_in_raw_thread()
-def rules(query: str):
-    from autocoder.chat.rules_command import handle_rules_command
-    memory = get_memory()
-    handle_rules_command(query, memory,coding_func=coding) 
-    completer.refresh_files()   
 
 @byzerllm.prompt()
 def code_review(query: str) -> str:
@@ -1947,95 +1310,32 @@ def code_review(query: str) -> str:
     如果用户的需求包含了@一个文件名 或者 @@符号， 那么重点关注这些文件或者符号（函数，类）进行上述的review。
     review 过程中严格遵循上述的检查点，不要遗漏，没有发现异常的点直接跳过，只对发现的异常点，给出具体的修改后的代码。
     """
+    return {}  # type: ignore
 
 
-@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", "false") 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"]
-
-    # 解析命令        
-    commands_infos = parse_query(query)    
-    if len(commands_infos) > 0:
-        if "query" in commands_infos:
-            query = " ".join(commands_infos["query"]["args"])
-        else:            
-            temp_query = ""
-            for (command,command_info) in commands_infos.items():
-                if command_info["args"]:
-                    temp_query = " ".join(command_info["args"])                    
-            query = temp_query
-
-    is_new = "new" in commands_infos
-
-    if "learn" in commands_infos:
-        commands_infos["no_context"] = {}
-
-    if "review" in commands_infos:
-        commands_infos["no_context"] = {}
-
-    yaml_config["action"] = commands_infos            
-    
-    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)
+    """
+    处理聊天命令，使用 ChatHandler 进行统一处理
 
-    def execute_ask():
-        cmd = ["agent", "chat", "--file", execute_file]
-        if is_new:
-            cmd.append("--new_session")
-        auto_coder_main(cmd)
+    Args:
+        query: 聊天查询字符串
+    """
+    from autocoder.common.file_handler import ChatHandler
 
-    try:
-        execute_ask()
-    finally:
-        os.remove(execute_file)
+    handler = ChatHandler()
+    handler.handle_chat_command(query)
 
 
-@run_in_raw_thread()
 def summon(query: str):
+    memory = get_current_memory()
     conf = memory.get("conf", {})
-    current_files = memory["current_files"]["files"]
+    current_files = get_current_files()
 
     file_contents = []
     for file in current_files:
         if os.path.exists(file):
             try:
-                with open(file, "r",encoding="utf-8") as f:
+                with open(file, "r", encoding="utf-8") as f:
                     content = f.read()
                     s = f"##File: {file}\n{content}\n\n"
                     file_contents.append(s)
@@ -2071,7 +1371,7 @@ def summon(query: str):
 
     execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
 
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
+    with open(os.path.join(execute_file), "w", encoding="utf-8") as f:
         f.write(yaml_content)
 
     def execute_summon():
@@ -2083,9 +1383,8 @@ def summon(query: str):
         os.remove(execute_file)
 
 
-@run_in_raw_thread()
 def design(query: str):
-
+    memory = get_current_memory()
     conf = memory.get("conf", {})
     yaml_config = {
         "include_file": ["./base/base.yml"],
@@ -2118,7 +1417,7 @@ def design(query: str):
 
     execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
 
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
+    with open(os.path.join(execute_file), "w", encoding="utf-8") as f:
         f.write(yaml_content)
 
     def execute_design():
@@ -2130,117 +1429,21 @@ def design(query: str):
         os.remove(execute_file)
 
 
-@run_in_raw_thread()
 def active_context(query: str):
     """
-    管理活动上下文任务，支持列表、查询等操作
-    
+    处理活动上下文命令，使用 ActiveContextHandler 进行统一处理
+
     Args:
         query: 命令参数，例如 "list" 列出所有任务
-    """    
-    # 解析命令
-    commands_infos = parse_query(query)
-    command = "list"  # 默认命令是列出所有任务
-    
-    if len(commands_infos) > 0:
-        if "list" in commands_infos:
-            command = "list"
-        if "run" in commands_infos:
-            command = "run"
-    
-    args = get_final_config()
-    printer = Printer()
-    # 获取LLM实例    
-    llm = get_single_llm(args.model,product_mode=args.product_mode)
-    action_file_manager = ActionYmlFileManager(args.source_dir)
-    
-    # 获取配置和参数
-    
-    
-    active_context_manager = ActiveContextManager(llm, args.source_dir)
-    if command == "run":
-        file_name = commands_infos["run"]["args"][-1]
-        args.file = action_file_manager.get_full_path_by_file_name(file_name)        
-        ## 因为更新了args.file
-        active_context_manager = ActiveContextManager(llm, args.source_dir)
-        task_id = active_context_manager.process_changes(args)
-        printer.print_in_terminal("active_context_background_task", 
-                                        style="blue",
-                                        task_id=task_id)
-
-    # 处理不同的命令
-    if command == "list":
-        # 获取所有任务
-        all_tasks = active_context_manager.get_all_tasks()
-        
-        if not all_tasks:
-            console = Console()
-            console.print("[yellow]没有找到任何活动上下文任务[/yellow]")
-            return
-        
-        # 创建表格
-        table = Table(title="活动上下文任务列表", show_lines=True, expand=True)
-        table.add_column("任务ID", style="cyan", no_wrap=False)
-        table.add_column("状态", style="green", no_wrap=False)
-        table.add_column("开始时间", style="yellow", no_wrap=False)
-        table.add_column("完成时间", style="yellow", no_wrap=False)
-        table.add_column("文件", style="blue", no_wrap=False)
-        table.add_column("Token统计", style="magenta", no_wrap=False)
-        table.add_column("费用", style="red", no_wrap=False)
-        
-        # 添加任务数据
-        for task in all_tasks:
-            status = task.get("status", "未知")
-            status_display = status
-            
-            # 根据状态设置不同的显示样式
-            if status == "completed":
-                status_display = "[green]已完成[/green]"
-            elif status == "running":
-                status_display = "[blue]运行中[/blue]"
-            elif status == "queued":
-                position = task.get("queue_position", 0)
-                status_display = f"[yellow]排队中 (位置: {position})[/yellow]"
-            elif status == "failed":
-                status_display = "[red]失败[/red]"
-            
-            # 格式化时间
-            start_time = task.get("start_time", "") 
-            start_time_str = start_time.strftime("%Y-%m-%d %H:%M:%S") if start_time else "未知"
-            
-            completion_time = task.get("completion_time", "")
-            completion_time_str = completion_time.strftime("%Y-%m-%d %H:%M:%S") if completion_time else "-"
-            
-            # 获取文件名
-            file_name = task.get("file_name", "未知")
-            
-            # 获取token信息
-            total_tokens = task.get("total_tokens", 0)
-            input_tokens = task.get("input_tokens", 0)
-            output_tokens = task.get("output_tokens", 0)
-            token_info = f"总计: {total_tokens:,}\n输入: {input_tokens:,}\n输出: {output_tokens:,}"
-            
-            # 获取费用信息
-            cost = task.get("cost", 0.0)
-            cost_info = f"${cost:.6f}"
-            
-            # 添加到表格
-            table.add_row(
-                task.get("task_id", "未知"),
-                status_display,
-                start_time_str,
-                completion_time_str,
-                file_name,
-                token_info,
-                cost_info
-            )
-        
-        # 显示表格
-        console = Console(width=120)  # 设置更宽的显示宽度
-        console.print(table)
+    """
+    from autocoder.common.file_handler import ActiveContextHandler
+
+    handler = ActiveContextHandler()
+    handler.handle_active_context_command(query)
 
 
 def voice_input():
+    memory = get_current_memory()
     conf = memory.get("conf", {})
     yaml_config = {
         "include_file": ["./base/base.yml"],
@@ -2257,7 +1460,7 @@ def voice_input():
 
     execute_file = os.path.join("actions", f"{uuid.uuid4()}.yml")
 
-    with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
+    with open(os.path.join(execute_file), "w", encoding="utf-8") as f:
         f.write(yaml_content)
 
     def execute_voice2text_command():
@@ -2265,14 +1468,16 @@ def voice_input():
 
     try:
         execute_voice2text_command()
-        with open(os.path.join(".auto-coder", "exchange.txt"), "r",encoding="utf-8") as f:
+        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):
+    memory = get_current_memory()
     conf = memory.get("conf", {})
     yaml_config = {
         "include_file": ["./base/base.yml"],
@@ -2283,432 +1488,62 @@ def generate_shell_command(input_text):
 
     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
-    """
-    console = Console()
-    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()
+    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)
 
-    if not subcmd:
-        printer.print_in_terminal("models_usage")        
+    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)
 
-    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_tester 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:            
-            models_list = "\n".join([m["name"] for m in models_module.default_models_list])                     
-            printer.print_in_terminal("models_add_usage", style="red", models=models_list)
-            result_manager.add_result(content=printer.get_message_from_key_with_format("models_add_usage",models=models_list),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
+def manage_models(query: str):
+    """
+    处理模型管理命令，使用 ModelsHandler 进行统一处理
 
-        # 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_with_format("models_add_model_exists",name=data_dict["name"]),meta={
-                "action": "models",
-                "input": {
-                    "query": query
-                }
-            })
-            return
+    Args:
+        query: 查询字符串，支持多种模型管理子命令
+    """
+    from autocoder.common.file_handler import ModelsHandler
 
-        # 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"]
-        }
+    handler = ModelsHandler()
+    handler.handle_models_command(query)
 
-        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_with_format("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_with_format("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_with_format("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])            
+    memory_manager = get_memory_manager()
+    new_dirs = memory_manager.add_exclude_dirs(dir_names)
+
+    if new_dirs:
+        print(f"Added exclude dirs: {new_dirs}")
+        exclude_files(",".join([f"regex://.*/{d}/*." for d in new_dirs]))
     else:
         print("All specified dirs are already in the exclude list.")
-    save_memory()
     completer.refresh_files()
 
+
 def exclude_files(query: str):
+    memory_manager = get_memory_manager()
     result_manager = ResultManager()
     printer = Printer()
+
     if "/list" in query:
         query = query.replace("/list", "", 1).strip()
-        existing_file_patterns = memory.get("exclude_files", []) 
+        existing_file_patterns = memory_manager.get_exclude_files()
         console = Console()
         # 打印表格
         table = Table(title="Exclude Files")
@@ -2716,70 +1551,58 @@ def exclude_files(query: str):
         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
-            }
-        })
+        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()
+        removed_patterns = memory_manager.remove_exclude_files([query.strip()])
         completer.refresh_files()
-        result_manager.add_result(content=f"Dropped exclude files: {query}",meta={
-            "action": "exclude_files",
-            "input": {
-                "query": query
-            }
-        })
+        result_manager.add_result(
+            content=f"Dropped exclude files: {removed_patterns}",
+            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}")
+
+    # Validate patterns
+    for file_pattern in new_file_patterns:
+        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
+                )
+            )
+
+    # Add new patterns
+    new_patterns_added = memory_manager.add_exclude_files(new_file_patterns)
+
+    if new_patterns_added:
+        result_manager.add_result(
+            content=f"Added exclude files: {new_patterns_added}",
+            meta={"action": "exclude_files", "input": {"query": new_patterns_added}},
+        )
+        print(f"Added exclude files: {new_patterns_added}")
     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
-            }
-        })
+        result_manager.add_result(
+            content=f"All specified files are already in the exclude list.",
+            meta={"action": "exclude_files", "input": {"query": new_file_patterns}},
+        )
         print("All specified files are already in the exclude list.")
-    
-    
 
-@run_in_raw_thread()
+
 def index_build():
+    memory = get_memory()
     conf = memory.get("conf", {})
     yaml_config = {
         "include_file": ["./base/base.yml"],
@@ -2794,17 +1617,18 @@ def index_build():
     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:
+    with open(yaml_file, "w", encoding="utf-8") as f:
         f.write(yaml_content)
-    try:        
-        auto_coder_main(["index", "--file", yaml_file])        
+    try:
+        auto_coder_main(["index", "--file", yaml_file])
         completer.refresh_files()
     finally:
         os.remove(yaml_file)
 
 
-def get_final_config()->AutoCoderArgs:
-    conf = memory.get("conf", {})
+def get_final_config() -> AutoCoderArgs:
+    memory_manager = get_memory_manager()
+    conf = memory_manager.get_all_config()
     yaml_config = {
         "include_file": ["./base/base.yml"],
         "auto_merge": conf.get("auto_merge", "editblock"),
@@ -2812,9 +1636,9 @@ def get_final_config()->AutoCoderArgs:
         "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")
+        "include_project_structure": conf.get("include_project_structure", "false")
         == "true",
-        "exclude_files": memory.get("exclude_files", []),
+        "exclude_files": memory_manager.get_exclude_files(),
     }
     for key, value in conf.items():
         converted_value = convert_config_value(key, value)
@@ -2823,7 +1647,7 @@ def get_final_config()->AutoCoderArgs:
 
     temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
     try:
-        with open(temp_yaml, "w",encoding="utf-8") as f:
+        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:
@@ -2831,18 +1655,31 @@ def get_final_config()->AutoCoderArgs:
             os.remove(temp_yaml)
     return args
 
+
 def help(query: str):
-    from autocoder.common.auto_configure import ConfigAutoTuner,MemoryConfig,AutoConfigRequest        
+    from autocoder.common.auto_configure import (
+        ConfigAutoTuner,
+        MemoryConfig,
+        AutoConfigRequest,
+    )
+
+    memory_manager = get_memory_manager()
+    memory = get_memory()
     args = get_final_config()
-    product_mode = memory.get("product_mode", "lite")
+    product_mode = memory_manager.get_config("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))    
+    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):
@@ -2850,10 +1687,11 @@ def index_export(path: str):
     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):
@@ -2861,7 +1699,7 @@ def index_import(path: str):
     else:
         printer.print_in_terminal("index_import_fail", path=path)
 
-@run_in_raw_thread()
+
 def index_query(query: str):
     from autocoder.index.entry import build_index_and_filter_files
     from autocoder.pyproject import PyProject
@@ -2871,7 +1709,9 @@ def index_query(query: str):
     config = get_final_config()
     config.query = query
     config.skip_filter_index = False
-    llm = get_single_llm(config.chat_model or config.model, product_mode=config.product_mode)
+    llm = get_single_llm(
+        config.chat_model or config.model, product_mode=config.product_mode
+    )
 
     if config.project_type == "ts":
         pp = TSProject(args=config, llm=llm)
@@ -2880,264 +1720,79 @@ def index_query(query: str):
     else:
         pp = SuffixProject(args=config, llm=llm, file_filter=None)
     pp.run()
-    sources = pp.sources    
-    source_code_list = build_index_and_filter_files(llm=llm, args=config, sources=sources)
-    return source_code_list    
+    sources = pp.sources
+    source_code_list = build_index_and_filter_files(
+        llm=llm, args=config, sources=sources
+    )
+    return source_code_list
+
 
 def list_files():
-    console = Console()
-    project_root = os.getcwd()
-    current_files = memory["current_files"]["files"]
+    """
+    处理文件列表命令，使用 ListFilesHandler 进行统一处理
+    """
+    from autocoder.common.file_handler import ListFilesHandler
 
-    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",
-            )
-        )
+    handler = ListFilesHandler()
+    handler.handle_list_files_command()
 
 
 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)    
+    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
+        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"
+                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, /list_all, /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 == "/list_all":
-        if not os.path.exists(llm_friendly_packages_dir):
-            console.print("llm_friendly_packages repository does not exist. Please run /lib /add <library_name> command first to clone it.")
-            return
-            
-        available_libs = []
-        
-        # 遍历所有domain目录
-        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):
-                # 遍历所有username目录
-                for username in os.listdir(domain_path):
-                    username_path = os.path.join(domain_path, username)
-                    if os.path.isdir(username_path):
-                        # 遍历所有lib_name目录
-                        for lib_name in os.listdir(username_path):
-                            lib_path = os.path.join(username_path, lib_name)
-                            if os.path.isdir(lib_path):
-                                # 检查是否有Markdown文件
-                                has_md_files = False
-                                for root, _, files in os.walk(lib_path):
-                                    if any(file.endswith('.md') for file in files):
-                                        has_md_files = True
-                                        break
-                                
-                                if has_md_files:
-                                    available_libs.append({
-                                        "domain": domain,
-                                        "username": username,
-                                        "lib_name": lib_name,
-                                        "full_path": f"{username}/{lib_name}",
-                                        "is_added": lib_name in memory["libs"]
-                                    })
-        
-        if available_libs:
-            table = Table(title="Available Libraries")
-            table.add_column("Domain", style="blue")
-            table.add_column("Username", style="green")
-            table.add_column("Library Name", style="cyan")
-            table.add_column("Full Path", style="magenta")
-            table.add_column("Status", style="yellow")
-            
-            # 按domain和username分组排序
-            available_libs.sort(key=lambda x: (x["domain"], x["username"], x["lib_name"]))
-            
-            for lib in available_libs:
-                status = "[green]Added[/green]" if lib["is_added"] else "[white]Not Added[/white]"
-                table.add_row(
-                    lib["domain"],
-                    lib["username"],
-                    lib["lib_name"],
-                    lib["full_path"],
-                    status
-                )
-            
-            console.print(table)
-        else:
-            console.print("No available libraries found in the repository.")
-
-    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."
-            )
+    """
+    处理库管理命令，使用 LibHandler 进行统一处理
 
-    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}")
+    Args:
+        args: 命令参数列表
+    """
+    from autocoder.common.file_handler import LibHandler
 
-    else:
-        console.print(f"Unknown subcommand: {subcommand}")
+    handler = LibHandler()
+    handler.handle_lib_command(args)
 
 
 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)
 
+
 def generate_new_yaml(query: str):
     memory = get_memory()
-    conf = memory.get("conf",{})
-    current_files = memory.get("current_files",{}).get("files",[])
-    auto_coder_main(["next", "chat_action"])        
+    conf = memory.get("conf", {})
+    current_files = memory.get("current_files", {}).get("files", [])
+    auto_coder_main(["next", "chat_action"])
     latest_yaml_file = get_last_yaml_file("actions")
     if latest_yaml_file:
         yaml_config = {
@@ -3147,11 +1802,11 @@ def generate_new_yaml(query: str):
             "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")
+            "include_project_structure": conf.get("include_project_structure", "false")
             == "true",
             "exclude_files": memory.get("exclude_files", []),
         }
-        yaml_config["context"] = ""                    
+        yaml_config["context"] = ""
         for key, value in conf.items():
             converted_value = convert_config_value(key, value)
             if converted_value is not None:
@@ -3162,294 +1817,356 @@ def generate_new_yaml(query: str):
         )
         # handle image
         v = Image.convert_image_paths_from(query)
-        yaml_config["query"] = v                    
+        yaml_config["query"] = v
 
-        yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)        
+        yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
 
         execute_file = os.path.join("actions", latest_yaml_file)
-        with open(os.path.join(execute_file), "w",encoding="utf-8") as f:
+        with open(os.path.join(execute_file), "w", encoding="utf-8") as f:
             f.write(yaml_content)
-        return execute_file,convert_yaml_to_config(execute_file)
-
-@run_in_raw_thread()
-def auto_command(query: str,extra_args: Dict[str,Any]={}):    
-    """处理/auto指令"""        
-    args = get_final_config() 
-    memory = get_memory()         
-    if args.enable_agentic_edit:        
-        from autocoder.run_context import get_run_context,RunMode
-        execute_file,args = generate_new_yaml(query)
-        args.file = execute_file                      
-        current_files = memory.get("current_files",{}).get("files",[])
-        sources = []
-        for file in current_files:
-            try:
-                with open(file,"r",encoding="utf-8") as f:
-                    sources.append(SourceCode(module_name=file,source_code=f.read()))  
-            except Exception as e:
-                global_logger.error(f"Failed to read file {file}: {e}")
-                    
-        llm = get_single_llm(args.code_model or args.model,product_mode=args.product_mode) 
-        conversation_history = extra_args.get("conversations",[])   
+        return execute_file, convert_yaml_to_config(execute_file)
 
-        command_infos = parse_query(query) 
 
-        # terminal 的总是接着上次对话, 所以这里总是设置为 resume
-        conversation_config = AgenticEditConversationConfig(
-            action="resume"
-        )
-        
-        ## web 模式会自己管理对话,所以这里总是设置为新对话
-        if get_run_context().mode == RunMode.WEB:
-            command_infos = {
-                "new":{
-                    "args":[query]
-                }
-            }
-        
-        task_query = query
-        
-        if "new" in command_infos:  
-            conversation_config.action = "new"
-            task_query = " ".join(command_infos["new"]["args"])
-            
-        if "resume" in command_infos:
-            conversation_config.action = "resume"
-            conversation_config.conversation_id = command_infos["resume"]["args"][0]            
-            task_query = " ".join(command_infos["resume"]["args"][1:])  
+def handle_conversation_actions(conversation_config) -> bool:
+    """
+    处理对话列表和创建新对话的操作
 
-        if "list" in command_infos:
-            conversation_config.action = "list"   
+    Args:
+        conversation_config: 对话配置对象
 
-        if "command" in command_infos:
-            conversation_config.action = "command"
-            task_query = render_command_file_with_variables(command_infos)             
-             
+    Returns:
+        bool: 如果处理了特殊操作（LIST或NEW without input）返回True，否则返回False
+    """
+    if not conversation_config:
+        return False
 
-        conversation_config.query = task_query
+    console = Console()
 
-        agent = AgenticEdit(llm=llm,args=args,files=SourceCodeList(sources=sources), 
-                            conversation_history=conversation_history,
-                            memory_config=MemoryConfig(memory=memory, 
-                            save_memory_func=save_memory), command_config=CommandConfig,
-                            conversation_name="current",
-                            conversation_config=conversation_config
-                            )           
-        if get_run_context().mode == RunMode.WEB:
-            agent.run_with_events(AgenticEditRequest(user_input=task_query))
-        
-        if get_run_context().mode == RunMode.TERMINAL:
-            agent.run_in_terminal(AgenticEditRequest(user_input=task_query))
-            
-        completer.refresh_files()
-        return
-        
-    args = get_final_config()  
-    # 准备请求参数
-    request = AutoCommandRequest(
-        user_input=query        
-    )
+    # 处理LIST操作
+    if conversation_config.action == ConversationAction.LIST:
+        conversation_manager = get_conversation_manager()
+        conversations = conversation_manager.list_conversations()
+        # 只保留 conversation_id 和 name 字段
+        filtered_conversations = []
+        for conv in conversations:
+            filtered_conv = {
+                "conversation_id": conv.get("conversation_id"),
+                "name": conv.get("name"),
+            }
+            filtered_conversations.append(filtered_conv)
 
-    # 初始化调优器
-    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                                                                                       
-                             ))
+        # 格式化 JSON 输出，使用 JSON 格式渲染而不是 Markdown
+        json_str = json.dumps(filtered_conversations, ensure_ascii=False, indent=4)
+        console.print(
+            Panel(
+                json_str,
+                title="🏁 Task Completion",
+                border_style="green",
+                title_align="left",
+            )
+        )
+        return True
 
-    # 生成建议
-    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)
-    ))
-    completer.refresh_files()
+    # 处理NEW操作且没有用户输入
+    if (
+        conversation_config.action == ConversationAction.NEW
+        and not conversation_config.query.strip()
+    ):
+        conversation_manager = get_conversation_manager()
+        conversation_id = conversation_manager.create_conversation(
+            name=conversation_config.query or "New Conversation",
+            description=conversation_config.query or "New Conversation",
+        )
+        conversation_manager.set_current_conversation(conversation_id)
+        conversation_message = f"New conversation created: {conversation_manager.get_current_conversation_id()}"
+
+        # 使用safe console print的简单版本
+        try:
+            console.print(
+                Panel(
+                    Markdown(conversation_message),
+                    title="🏁 Task Completion",
+                    border_style="green",
+                    title_align="left",
+                )
+            )
+        except Exception:
+            # fallback to plain text
+            safe_content = conversation_message.replace("[", "\\[").replace("]", "\\]")
+            console.print(
+                Panel(
+                    safe_content,
+                    title="🏁 Task Completion",
+                    border_style="green",
+                    title_align="left",
+                )
+            )
+        return True
+
+    return False
+
+
+# used in /auto command in terminal
+def run_agentic(
+    query: str,
+    cancel_token: Optional[str] = None,
+    conversation_history: Optional[List[Dict[str, Any]]] = None,
+):
+    """处理/auto指令"""
+    agentic = RunAgentic()
+    return agentic.run(query, cancel_token, conversation_history)
+
+
+def run_agentic_filter(query: str, cancel_token: Optional[str] = None):
+    """处理/auto指令"""
+    agentic = RunAgentic()
+    return agentic.filter(query, cancel_token)
+
+
+# used in autocoder/sdk/core/bridge.py
+def run_auto_command(
+    query: str,
+    pre_commit: bool = False,
+    post_commit: bool = False,
+    pr: bool = False,
+    extra_args: Dict[str, Any] = {},
+    cancel_token: Optional[str] = None,
+    conversation_history: Optional[List[Dict[str, Any]]] = None,
+    system_prompt: Optional[str] = None,
+    conversation_action: ConversationAction = ConversationAction.NEW,
+    conversation_id: Optional[str] = None,
+    is_sub_agent: bool = False,
+):
+    """处理/auto指令"""
+    agentic = RunAgentic()
+    for event in agentic.run_with_events(
+        query,
+        pre_commit=pre_commit,
+        post_commit=post_commit,
+        pr=pr,
+        extra_args=extra_args,
+        cancel_token=cancel_token,
+        conversation_history=conversation_history,
+        system_prompt=system_prompt,
+        conversation_action=conversation_action,
+        conversation_id=conversation_id,
+        is_sub_agent=is_sub_agent,
+    ):
+        yield event
 
 
+# used in auto-coder.web
+def auto_command(query: str, extra_args: Dict[str, Any] = {}):
+    """处理/auto指令"""
+    args = get_final_config()
+    memory = get_memory()
+    if args.enable_agentic_edit:
+        from autocoder.run_context import get_run_context, RunMode
 
-def run_auto_command(query: str,
-                     pre_commit:bool=False,
-                     post_commit:bool=False,
-                     pr:bool=False,
-                     extra_args: Dict[str,Any]={}
-                     ):    
-    """处理/auto指令"""        
-    args = get_final_config() 
-    memory = get_memory()         
-    if args.enable_agentic_edit:        
-        from autocoder.run_context import get_run_context,RunMode
-        execute_file,args = generate_new_yaml(query)
-        args.file = execute_file                      
-        current_files = memory.get("current_files",{}).get("files",[])
+        execute_file, _ = generate_new_yaml(query)
+        args.file = execute_file
+        current_files = memory.get("current_files", {}).get("files", [])
         sources = []
         for file in current_files:
             try:
-                with open(file,"r",encoding="utf-8") as f:
-                    sources.append(SourceCode(module_name=file,source_code=f.read()))  
+                with open(file, "r", encoding="utf-8") as f:
+                    sources.append(SourceCode(module_name=file, source_code=f.read()))
             except Exception as e:
                 global_logger.error(f"Failed to read file {file}: {e}")
-                    
-        llm = get_single_llm(args.code_model or args.model,product_mode=args.product_mode) 
-        conversation_history = extra_args.get("conversations",[])   
 
-        command_infos = parse_query(query) 
+        try:
+            llm = get_single_llm(
+                args.code_model or args.model, product_mode=args.product_mode
+            )
+        except ValueError as e:
+            console = Console()
+            console.print(
+                Panel(
+                    f"[red]LLM Configuration Error:[/red]\n\n{str(e)}",
+                    title="[red]Error[/red]",
+                    border_style="red",
+                    padding=(1, 2),
+                )
+            )
+            return
+        conversation_history = extra_args.get("conversations", [])
+
+        command_infos = parse_query(query)
 
         # terminal 的总是接着上次对话, 所以这里总是设置为 resume
         conversation_config = AgenticEditConversationConfig(
-            action="resume"
+            action=ConversationAction.RESUME
         )
-        
-        ## web 模式会自己管理对话,所以这里总是设置为新对话
-        if get_run_context().mode == RunMode.WEB:
-            command_infos = {
-                "new":{
-                    "args":[query]
-                }
-            }
-        
-        task_query = query        
-        
-        if "new" in command_infos:  
-            conversation_config.action = "new"
+
+        task_query = query
+
+        if "new" in command_infos:
+            conversation_config.action = ConversationAction.NEW
             task_query = " ".join(command_infos["new"]["args"])
-            
+
         if "resume" in command_infos:
-            conversation_config.action = "resume"
-            conversation_config.conversation_id = command_infos["resume"]["args"][0]            
-            task_query = " ".join(command_infos["resume"]["args"][1:])  
+            conversation_config.action = ConversationAction.RESUME
+            conversation_config.conversation_id = command_infos["resume"]["args"][0]
+            task_query = " ".join(command_infos["resume"]["args"][1:])
 
         if "list" in command_infos:
-            conversation_config.action = "list"
+            conversation_config.action = ConversationAction.LIST
 
-        
         if "command" in command_infos:
-            conversation_config.action = "command"
+            conversation_config.action = ConversationAction.COMMAND
             task_query = render_command_file_with_variables(command_infos)
-             
-        conversation_config.query = task_query   
-        conversation_config.pull_request = pr     
-
-        agent = AgenticEdit(llm=llm,args=args,files=SourceCodeList(sources=sources), 
-                            conversation_history=conversation_history,
-                            memory_config=MemoryConfig(memory=memory, 
-                            save_memory_func=save_memory), command_config=CommandConfig,
-                            conversation_name="current",
-                            conversation_config=conversation_config
-                            )           
-        if pre_commit:
-            agent.apply_pre_changes()
-        
-        events = agent.run(AgenticEditRequest(user_input=task_query))        
-        
-        for event in events:
-            yield event
-            
-        # 处理 post_commit 和 PR 功能
-        if post_commit or pr:
-            _handle_post_commit_and_pr(post_commit, pr, query, args, llm)
-            
+
+        conversation_config.query = task_query
+
+        # 处理特殊的conversation操作（LIST和NEW without input）
+        if handle_conversation_actions(conversation_config):
+            return conversation_config.conversation_id
+
+        conversation_manager = get_conversation_manager()
+        if conversation_config.action == ConversationAction.NEW:
+            conversation_id = conversation_manager.create_conversation(
+                name=conversation_config.query or "New Conversation",
+                description=conversation_config.query or "New Conversation",
+            )
+            conversation_manager.set_current_conversation(conversation_id)
+            conversation_config.conversation_id = conversation_id
+
+        if (
+            conversation_config.action == ConversationAction.RESUME
+            and conversation_config.conversation_id
+        ):
+            conversation_manager.set_current_conversation(
+                conversation_config.conversation_id
+            )
+
+        if (
+            conversation_config.action == ConversationAction.RESUME
+            and not conversation_config.conversation_id
+            and conversation_manager.get_current_conversation_id()
+        ):
+            conversation_config.conversation_id = (
+                conversation_manager.get_current_conversation_id()
+            )
+            conversation_manager.set_current_conversation(
+                conversation_config.conversation_id
+            )
+
+        if not conversation_config.conversation_id:
+            conversation_id = conversation_manager.create_conversation(
+                name=conversation_config.query or "New Conversation",
+                description=conversation_config.query or "New Conversation",
+            )
+            conversation_manager.set_current_conversation(conversation_id)
+            conversation_config.conversation_id = conversation_id
+
+        cancel_token = extra_args.get("event_file_id", None)
+        global_logger.info(f"cancel_token: {cancel_token}")
+        if cancel_token:
+            global_cancel.register_token(cancel_token)
+
+        if get_run_context().mode == RunMode.WEB:
+            runner = FileBasedEventRunner(
+                llm=llm,
+                args=args,
+                conversation_config=conversation_config,
+                cancel_token=cancel_token,
+            )
+            runner.run(AgenticEditRequest(user_input=task_query))
+
+        if get_run_context().mode == RunMode.TERMINAL:
+            runner = TerminalRunner(
+                llm=llm,
+                args=args,
+                conversation_config=conversation_config,
+                cancel_token=cancel_token,
+            )
+            runner.run(AgenticEditRequest(user_input=task_query))
+
         completer.refresh_files()
-        return
-        
-    args = get_final_config()  
+        return conversation_config.conversation_id
+
+    args = get_final_config()
     # 准备请求参数
-    request = AutoCommandRequest(
-        user_input=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                                                                                       
-                             ))
+    try:
+        llm = get_single_llm(
+            args.chat_model or args.model, product_mode=args.product_mode
+        )
+    except ValueError as e:
+        console = Console()
+        console.print(
+            Panel(
+                f"[red]LLM Configuration Error:[/red]\n\n{str(e)}",
+                title="[red]Error[/red]",
+                border_style="red",
+                padding=(1, 2),
+            )
+        )
+        return
+    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)
-    ))
-    
-    # 处理 post_commit 和 PR 功能
-    if post_commit or pr:
-        _handle_post_commit_and_pr(post_commit, pr, query, args, llm)
-    
+    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),
+        )
+    )
     completer.refresh_files()
+    return None
 
 
 def render_command_file_with_variables(command_infos: Dict[str, Any]) -> str:
     """
     使用 CommandManager 加载并渲染命令文件
-    
+
     Args:
         command_infos: parse_query(query) 的返回结果，包含命令和参数信息
-        
+
     Returns:
         str: 渲染后的文件内容
-        
+
     Raises:
         ValueError: 当参数不足或文件不存在时
         Exception: 当渲染过程出现错误时
@@ -3458,31 +2175,33 @@ def render_command_file_with_variables(command_infos: Dict[str, Any]) -> str:
         # 获取第一个命令的信息
         if not command_infos:
             raise ValueError("command_infos 为空，无法获取命令信息")
-        
+
         # command 的位置参数作为路径
         first_command = command_infos["command"]
-        
+
         # 获取位置参数（文件路径）
         args = first_command.get("args", [])
         if not args:
             raise ValueError("未提供文件路径参数")
-        
+
         file_path = args[0]  # 第一个位置参数作为文件路径
-        
+
         # 获取关键字参数作为渲染参数
         kwargs = first_command.get("kwargs", {})
-        
+
         # 初始化 CommandManager
         command_manager = CommandManager()
-        
+
         # 使用 read_command_file_with_render 直接读取并渲染命令文件
-        rendered_content = command_manager.read_command_file_with_render(file_path, kwargs)
+        rendered_content = command_manager.read_command_file_with_render(
+            file_path, kwargs
+        )
         if rendered_content is None:
             raise ValueError(f"无法读取或渲染命令文件: {file_path}")
-        
+
         global_logger.info(f"成功渲染命令文件: {file_path}, 使用参数: {kwargs}")
         return rendered_content
-            
+
     except Exception as e:
         global_logger.error(f"render_command_file_with_variables 执行失败: {str(e)}")
-        raise
+        raise