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

autocoder/agent/entry_command_agent/chat.py

@@ -1,39 +1,29 @@
-
-import os
 import time
 import json
-from typing import Dict, Any, List
 from rich.console import Console
 from rich.panel import Panel
-from rich.markdown import Markdown
-from rich.live import Live
 from prompt_toolkit import prompt
 from prompt_toolkit.formatted_text import FormattedText
 from loguru import logger
 import byzerllm
-
+from typing import Optional
 from autocoder.common.auto_coder_lang import get_message
 from autocoder.common.memory_manager import save_to_memory_file
 from autocoder.common.utils_code_auto_generate import stream_chat_with_continue
 from autocoder.utils.auto_coder_utils.chat_stream_out import stream_out
 from autocoder.common.printer import Printer
-from autocoder.rag.token_counter import count_tokens
+from autocoder.common.tokens import count_string_tokens as count_tokens
 from autocoder.privacy.model_filter import ModelPathFilter
 from autocoder.common.result_manager import ResultManager
 from autocoder.events.event_manager_singleton import get_event_manager
 from autocoder.events import event_content as EventContentCreator
 from autocoder.events.event_types import EventMetadata
-from autocoder.common.mcp_server import get_mcp_server
-from autocoder.common.mcp_server_types import McpRequest
+from autocoder.common.mcp_tools.server import get_mcp_server
+from autocoder.common.mcp_tools.types import McpRequest
 from autocoder.utils.llms import get_llm_names
-from autocoder.utils.request_queue import (
-    request_queue,
-    RequestValue,
-    DefaultValue,
-    RequestOption,
-)
 from autocoder.run_context import get_run_context, RunMode
 from autocoder.common.action_yml_file_manager import ActionYmlFileManager
+from autocoder.common.conversations.get_conversation_manager import get_conversation_manager
 
 
 class ChatAgent:
@@ -43,6 +33,18 @@ class ChatAgent:
         self.raw_args = raw_args
         self.console = Console()
         self.result_manager = ResultManager()
+        self.conversation_manager = get_conversation_manager()
+        # 生成命名空间用于会话隔离
+        self.namespace = self._generate_namespace()
+
+    def _generate_namespace(self) -> Optional[str]:
+        """
+        生成命名空间，用于会话隔离
+        
+        Returns:
+            str: 基于项目路径的命名空间
+        """
+        return None
 
     def run(self):
         """执行 chat 命令的主要逻辑"""
@@ -55,20 +57,26 @@ class ChatAgent:
             for command in self.args.action:
                 commands_info[command] = {}
 
-        memory_dir = os.path.join(self.args.source_dir, ".auto-coder", "memory")
-        os.makedirs(memory_dir, exist_ok=True)
-        memory_file = os.path.join(memory_dir, "chat_history.json")
-
         # 处理新会话
         if self.args.new_session:
-            self._handle_new_session(memory_file)
+            self._handle_new_session()
             if not self.args.query or (self.args.query_prefix and self.args.query == self.args.query_prefix) or (self.args.query_suffix and self.args.query == self.args.query_suffix):
                 return
 
-        # 加载聊天历史
-        chat_history = self._load_chat_history(memory_file)
-        chat_history["ask_conversation"].append(
-            {"role": "user", "content": self.args.query}
+        # 确保有当前会话，如果没有则创建
+        current_conversation_id = self.conversation_manager.get_current_conversation_id(self.namespace)
+        if not current_conversation_id:
+            current_conversation_id = self.conversation_manager.create_conversation(
+                name="Chat Session",
+                description="Auto-coder chat session"
+            )
+            self.conversation_manager.set_current_conversation(current_conversation_id, self.namespace)
+
+        # 添加用户消息到当前会话
+        self.conversation_manager.append_message_to_current(
+            role="user",
+            content=self.args.query,
+            namespace=self.namespace
         )
 
         # 获取聊天模型
@@ -78,11 +86,11 @@ class ChatAgent:
             chat_llm = self.llm
 
         # 构建对话上下文
-        loaded_conversations = self._build_conversations(commands_info, chat_history)
+        loaded_conversations = self._build_conversations(commands_info)
 
         # 处理人工模型模式
         if get_run_context().mode != RunMode.WEB and self.args.human_as_model:
-            return self._handle_human_as_model(loaded_conversations, chat_history, memory_file, commands_info)
+            return self._handle_human_as_model(loaded_conversations, commands_info)
 
         # 计算耗时
         start_time = time.time()
@@ -118,33 +126,26 @@ class ChatAgent:
         if last_meta:
             self._print_stats(last_meta, start_time, model_name)
 
-        # 更新聊天历史
-        chat_history["ask_conversation"].append(
-            {"role": "assistant", "content": assistant_response}
+        # 更新聊天历史 - 添加助手回复到当前会话
+        self.conversation_manager.append_message_to_current(
+            role="assistant",
+            content=assistant_response,
+            namespace=self.namespace
         )
 
-        with open(memory_file, "w", encoding="utf-8") as f:
-            json.dump(chat_history, f, ensure_ascii=False)
-
         # 处理后续命令
-        self._handle_post_commands(commands_info, assistant_response, chat_history)
+        self._handle_post_commands(commands_info, assistant_response)
 
-    def _handle_new_session(self, memory_file):
+    def _handle_new_session(self):
         """处理新会话逻辑"""
-        if os.path.exists(memory_file):
-            with open(memory_file, "r", encoding="utf-8") as f:
-                old_chat_history = json.load(f)
-            if "conversation_history" not in old_chat_history:
-                old_chat_history["conversation_history"] = []
-            old_chat_history["conversation_history"].append(
-                old_chat_history.get("ask_conversation", []))
-            chat_history = {"ask_conversation": [],
-                            "conversation_history": old_chat_history["conversation_history"]}
-        else:
-            chat_history = {"ask_conversation": [],
-                            "conversation_history": []}
-        with open(memory_file, "w", encoding="utf-8") as f:
-            json.dump(chat_history, f, ensure_ascii=False)
+        # 创建新的对话会话
+        conversation_id = self.conversation_manager.create_conversation(
+            name="New Chat Session",
+            description=f"Chat session started at {time.strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+        
+        # 设置为当前会话
+        self.conversation_manager.set_current_conversation(conversation_id, self.namespace)
 
         self.result_manager.add_result(content=get_message("new_session_started"), meta={
             "action": "chat",
@@ -161,19 +162,15 @@ class ChatAgent:
             )
         )
 
-    def _load_chat_history(self, memory_file):
-        """加载聊天历史"""
-        if os.path.exists(memory_file):
-            with open(memory_file, "r", encoding="utf-8") as f:
-                chat_history = json.load(f)
-            if "conversation_history" not in chat_history:
-                chat_history["conversation_history"] = []
-        else:
-            chat_history = {"ask_conversation": [],
-                            "conversation_history": []}
-        return chat_history
+    def _get_current_conversation_messages(self):
+        """获取当前会话的消息列表"""
+        current_conversation_id = self.conversation_manager.get_current_conversation_id(self.namespace)
+        if current_conversation_id:
+            messages = self.conversation_manager.get_messages(current_conversation_id)
+            return [{"role": msg["role"], "content": msg["content"]} for msg in messages]
+        return []
 
-    def _build_conversations(self, commands_info, chat_history):
+    def _build_conversations(self, commands_info):
         """构建对话上下文"""
         source_count = 0
         pre_conversations = []
@@ -198,17 +195,19 @@ class ChatAgent:
             source_count += 1
 
         # 构建索引和过滤文件
-        if "no_context" not in commands_info:
-            from autocoder.index.index import IndexManager
+        if "no_context" not in commands_info:            
             from autocoder.index.entry import build_index_and_filter_files
             from autocoder.pyproject import PyProject
             from autocoder.tsproject import TSProject
             from autocoder.suffixproject import SuffixProject
+            from autocoder.default_project import DefaultProject
 
             if self.args.project_type == "ts":
                 pp = TSProject(args=self.args, llm=self.llm)
             elif self.args.project_type == "py":
                 pp = PyProject(args=self.args, llm=self.llm)
+            elif not self.args.project_type or self.args.project_type == "*":
+                pp = DefaultProject(args=self.args, llm=self.llm)
             else:
                 pp = SuffixProject(args=self.args, llm=self.llm, file_filter=None)
             pp.run()
@@ -242,10 +241,12 @@ class ChatAgent:
                     {"role": "assistant", "content": "read"})
                 source_count += 1
 
-        loaded_conversations = pre_conversations + chat_history["ask_conversation"]
+        # 获取当前会话的历史消息
+        current_messages = self._get_current_conversation_messages()
+        loaded_conversations = pre_conversations + current_messages
         return loaded_conversations
 
-    def _handle_human_as_model(self, loaded_conversations, chat_history, memory_file, commands_info):
+    def _handle_human_as_model(self, loaded_conversations, commands_info):
         """处理人工模型模式"""
         @byzerllm.prompt()
         def chat_with_human_as_model(
@@ -334,16 +335,17 @@ class ChatAgent:
                                        "query": self.args.query
                                    }})
 
-        # Update chat history with user's response
-        chat_history["ask_conversation"].append(
-            {"role": "assistant", "content": result}
+        # 更新当前会话的历史记录
+        self.conversation_manager.append_message_to_current(
+            role="assistant",
+            content=result,
+            namespace=self.namespace
         )
 
-        with open(memory_file, "w", encoding="utf-8") as f:
-            json.dump(chat_history, f, ensure_ascii=False)
-
         if "save" in commands_info:
-            save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+            # 获取当前会话消息用于保存
+            current_messages = self._get_current_conversation_messages()
+            save_to_memory_file(ask_conversation=current_messages,
                                 query=self.args.query,
                                 response=result)
             printer = Printer()
@@ -452,7 +454,7 @@ class ChatAgent:
                 action_file=self.args.file
             ).to_dict())
 
-    def _handle_post_commands(self, commands_info, assistant_response, chat_history):
+    def _handle_post_commands(self, commands_info, assistant_response):
         """处理后续命令"""
         if "copy" in commands_info:
             # copy assistant_response to clipboard
@@ -463,7 +465,9 @@ class ChatAgent:
                 print("pyperclip not installed or clipboard is not supported, instruction will not be copied to clipboard.")
 
         if "save" in commands_info:
-            tmp_dir = save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+            # 获取当前会话消息用于保存
+            current_messages = self._get_current_conversation_messages()
+            tmp_dir = save_to_memory_file(ask_conversation=current_messages,
                                           query=self.args.query,
                                           response=assistant_response)
             printer = Printer()

autocoder/auto_coder.py

@@ -1,4 +1,3 @@
-from autocoder.events.event_types import EventMetadata
 import byzerllm
 import yaml
 import os
@@ -10,8 +9,7 @@ from autocoder.common import git_utils, code_auto_execute
 from autocoder.utils.llm_client_interceptors import token_counter_interceptor
 from autocoder.db.store import Store
 from autocoder.common.action_yml_file_manager import ActionYmlFileManager
-
-from autocoder.utils.llms import get_llm_names
+from autocoder.common.llms import LLMManager
 
 from byzerllm.utils.client import EventCallbackResult, EventName
 from prompt_toolkit import prompt
@@ -31,31 +29,24 @@ from autocoder.utils.request_queue import (
     RequestOption,
 )
 from loguru import logger
-import json
 from rich.console import Console
 from rich.panel import Panel
-from rich.markdown import Markdown
-from rich.live import Live
 from autocoder.common.auto_coder_lang import get_message
-from autocoder.common.memory_manager import save_to_memory_file
-from autocoder import models as models_module
-from autocoder.common.utils_code_auto_generate import stream_chat_with_continue
-from autocoder.utils.auto_coder_utils.chat_stream_out import stream_out
-from autocoder.common.printer import Printer
-from autocoder.rag.token_counter import count_tokens
-from autocoder.privacy.model_filter import ModelPathFilter
-from autocoder.common.result_manager import ResultManager
-from autocoder.events.event_manager_singleton import get_event_manager
-from autocoder.events import event_content as EventContentCreator
-from autocoder.common.mcp_server import get_mcp_server
-from autocoder.common.mcp_server_types import (
-    McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, 
-    McpListRunningRequest, McpRefreshRequest
-)
 from autocoder.run_context import get_run_context,RunMode
 console = Console()
 
 
+def get_model_info_with_check(model_name: str, product_mode: str):
+    """获取模型信息并检查是否为None，如果为None则抛出友好的异常"""
+    model_info = LLMManager().get_model_info(model_name, product_mode)
+    if model_info is None:
+        from autocoder.common.international import get_message_with_format
+        error_message = get_message_with_format("model_info_not_found", 
+                                               model_name=model_name, 
+                                               product_mode=product_mode)
+        raise ValueError(error_message)
+    return model_info
+
 def resolve_include_path(base_path, include_path):
     if include_path.startswith(".") or include_path.startswith(".."):
         full_base_path = os.path.abspath(base_path)
@@ -257,7 +248,7 @@ def main(input_args: Optional[List[str]] = None):
         
         if args.product_mode == "lite":
             default_model = args.model        
-            model_info = models_module.get_model_by_name(default_model)                
+            model_info = get_model_info_with_check(default_model, args.product_mode)
             llm = byzerllm.SimpleByzerLLM(default_model_name=default_model)
             llm.deploy(
                 model_path="",
@@ -281,7 +272,7 @@ def main(input_args: Optional[List[str]] = None):
                     models = []
                     for _, model_name in enumerate(model_names):
                         model_name = model_name.strip()
-                        model_info = models_module.get_model_by_name(model_name)
+                        model_info = get_model_info_with_check(model_name, args.product_mode)
                         code_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                         code_model.deploy(
                             model_path="",
@@ -299,7 +290,7 @@ def main(input_args: Optional[List[str]] = None):
                     llm.setup_sub_client("code_model", models)
                 else:
                     # Single code model
-                    model_info = models_module.get_model_by_name(args.code_model)
+                    model_info = get_model_info_with_check(args.code_model, args.product_mode)
                     model_name = args.code_model
                     code_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                     code_model.deploy(
@@ -322,7 +313,7 @@ def main(input_args: Optional[List[str]] = None):
                     model_names = args.generate_rerank_model.split(",")
                     models = []
                     for _, model_name in enumerate(model_names):
-                        model_info = models_module.get_model_by_name(model_name)                        
+                        model_info = get_model_info_with_check(model_name, args.product_mode)                        
                         rerank_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                         rerank_model.deploy(
                             model_path="",
@@ -340,7 +331,7 @@ def main(input_args: Optional[List[str]] = None):
                     llm.setup_sub_client("generate_rerank_model", models)
                 else:
                     # Single rerank model
-                    model_info = models_module.get_model_by_name(args.generate_rerank_model)
+                    model_info = get_model_info_with_check(args.generate_rerank_model, args.product_mode)
                     model_name = args.generate_rerank_model
                     rerank_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                     rerank_model.deploy(
@@ -358,7 +349,7 @@ def main(input_args: Optional[List[str]] = None):
                     llm.setup_sub_client("generate_rerank_model", rerank_model)
             
             if args.inference_model:
-                model_info = models_module.get_model_by_name(args.inference_model)
+                model_info = get_model_info_with_check(args.inference_model, args.product_mode)
                 model_name = args.inference_model
                 inference_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 inference_model.deploy(
@@ -377,7 +368,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.index_filter_model:
                 model_name = args.index_filter_model.strip()
-                model_info = models_module.get_model_by_name(model_name)                
+                model_info = get_model_info_with_check(model_name, args.product_mode)                
                 index_filter_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 index_filter_model.deploy(
                     model_path="",
@@ -395,7 +386,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.context_prune_model:
                 model_name = args.context_prune_model.strip()
-                model_info = models_module.get_model_by_name(model_name)                
+                model_info = get_model_info_with_check(model_name, args.product_mode)                
                 context_prune_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 context_prune_model.deploy(
                     model_path="",
@@ -413,7 +404,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.conversation_prune_model:
                 model_name = args.conversation_prune_model.strip()
-                model_info = models_module.get_model_by_name(model_name)                
+                model_info = get_model_info_with_check(model_name, args.product_mode)                
                 conversation_prune_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 conversation_prune_model.deploy(
                     model_path="",
@@ -588,7 +579,7 @@ def main(input_args: Optional[List[str]] = None):
         if args.product_mode == "lite":             
             if args.chat_model:
                 model_name = args.chat_model.strip()
-                model_info = models_module.get_model_by_name(model_name)                
+                model_info = get_model_info_with_check(model_name, args.product_mode)                
                 chat_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 chat_model.deploy(
                     model_path="",
@@ -606,7 +597,7 @@ def main(input_args: Optional[List[str]] = None):
             
             if args.vl_model:   
                 model_name = args.vl_model.strip()
-                model_info = models_module.get_model_by_name(model_name)                
+                model_info = get_model_info_with_check(model_name, args.product_mode)                
                 vl_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 vl_model.deploy(
                     model_path="",
@@ -624,7 +615,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.index_model:   
                 model_name = args.index_model.strip()
-                model_info = models_module.get_model_by_name(model_name)                
+                model_info = get_model_info_with_check(model_name, args.product_mode)                
                 index_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 index_model.deploy(
                     model_path="",
@@ -642,7 +633,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.sd_model:
                 model_name = args.sd_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 sd_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 sd_model.deploy(
                     model_path="",
@@ -660,7 +651,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.text2voice_model:
                 model_name = args.text2voice_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 text2voice_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 text2voice_model.deploy(
                     model_path="",
@@ -678,7 +669,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.voice2text_model:
                 model_name = args.voice2text_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 voice2text_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 voice2text_model.deploy(
                     model_path="",
@@ -696,7 +687,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.planner_model:
                 model_name = args.planner_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 planner_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 planner_model.deploy(
                     model_path="",
@@ -714,7 +705,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.commit_model:
                 model_name = args.commit_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 commit_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 commit_model.deploy(
                     model_path="",
@@ -732,7 +723,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.designer_model:
                 model_name = args.designer_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 designer_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 designer_model.deploy(
                     model_path="",
@@ -750,7 +741,7 @@ def main(input_args: Optional[List[str]] = None):
 
             if args.emb_model:
                 model_name = args.emb_model.strip()
-                model_info = models_module.get_model_by_name(model_name)
+                model_info = get_model_info_with_check(model_name, args.product_mode)
                 emb_model = byzerllm.SimpleByzerLLM(default_model_name=model_name)
                 emb_model.deploy(
                     model_path="",