fix:修复rewrite的功能

src/chat/express/exprssion_learner.py

@@ -414,11 +414,11 @@ class ExpressionLearner:
 init_prompt()
 
 
-if global_config.expression.enable_expression:
-    expression_learner = None
 
-    def get_expression_learner():
+expression_learner = None
-        global expression_learner
+
-        if expression_learner is None:
+def get_expression_learner():
-            expression_learner = ExpressionLearner()
+    global expression_learner
-        return expression_learner
+    if expression_learner is None:
+        expression_learner = ExpressionLearner()
+    return expression_learner

src/chat/replyer/default_generator.py

@@ -37,7 +37,7 @@ def init_prompt():
     Prompt("你正在qq群里聊天，下面是群里在聊的内容：", "chat_target_group1")
     Prompt("你正在和{sender_name}聊天，这是你们之前聊的内容：", "chat_target_private1")
     Prompt("在群里聊天", "chat_target_group2")
-    Prompt("和{sender_name}私聊", "chat_target_private2")
+    Prompt("和{sender_name}聊天", "chat_target_private2")
     Prompt("\n你有以下这些**知识**：\n{prompt_info}\n请你**记住上面的知识**，之后可能会用到。\n", "knowledge_prompt")
 
     Prompt(
@@ -69,70 +69,25 @@ def init_prompt():
     Prompt(
         """
 {expression_habits_block}
-{tool_info_block}
-{knowledge_prompt}
-{memory_block}
 {relation_info_block}
-{extra_info_block}
+
+{chat_target}
 {time_block}
-{chat_target}
 {chat_info}
-现在"{sender_name}"说:{target_message}。你想要回复对方的这条消息。
+{identity}
-{identity}，
-你需要使用合适的语法和句法，参考聊天内容，组织一条日常且口语化的回复。注意不要复读你说过的话。
 
-{config_expression_style}。回复不要浮夸，不要用夸张修辞，平淡一些。
+你正在{chat_target_2},{reply_target_block}
-{keywords_reaction_prompt}
+对这句话，你想表达，原句：{raw_reply},原因是：{reason}。你现在要思考怎么组织回复
-请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。
-不要浮夸，不要夸张修辞，请注意不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出一条回复就好。
-现在，你说：
-""",
-        "default_generator_private_prompt",
-    )
-
-    Prompt(
-        """
-你可以参考你的以下的语言习惯，如果情景合适就使用，不要盲目使用,不要生硬使用，而是结合到表达中：
-{style_habbits}
-
-你现在正在群里聊天，以下是群里正在进行的聊天内容：
-{chat_info}
-
-以上是聊天内容，你需要了解聊天记录中的内容
-
-{chat_target}
-你的名字是{bot_name}，{prompt_personality}，在这聊天中，"{sender_name}"说的"{target_message}"引起了你的注意，对这句话，你想表达：{raw_reply},原因是：{reason}。你现在要思考怎么回复
 你需要使用合适的语法和句法，参考聊天内容，组织一条日常且口语化的回复。请你修改你想表达的原句，符合你的表达风格和语言习惯
-请你根据情景使用以下句法：
-{grammar_habbits}
 {config_expression_style}，你可以完全重组回复，保留最基本的表达含义就好，但重组后保持语意通顺。
+{keywords_reaction_prompt}
+{moderation_prompt}
 不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )，只输出一条回复就好。
 现在，你说：
 """,
         "default_expressor_prompt",
     )
 
-    Prompt(
-        """
-你可以参考以下的语言习惯，如果情景合适就使用，不要盲目使用,不要生硬使用，而是结合到表达中：
-{style_habbits}
-
-你现在正在群里聊天，以下是群里正在进行的聊天内容：
-{chat_info}
-
-以上是聊天内容，你需要了解聊天记录中的内容
-
-{chat_target}
-你的名字是{bot_name}，{prompt_personality}，在这聊天中，"{sender_name}"说的"{target_message}"引起了你的注意，对这句话，你想表达：{raw_reply},原因是：{reason}。你现在要思考怎么回复
-你需要使用合适的语法和句法，参考聊天内容，组织一条日常且口语化的回复。
-请你根据情景使用以下句法：
-{grammar_habbits}
-{config_expression_style}，你可以完全重组回复，保留最基本的表达含义就好，但重组后保持语意通顺。
-不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )，只输出一条回复就好。
-现在，你说：
-""",
-        "default_expressor_private_prompt",  # New template for private FOCUSED chat
-    )
 
 
 class DefaultReplyer:
@@ -282,20 +237,29 @@ class DefaultReplyer:
             traceback.print_exc()
             return False, None
 
-    async def rewrite_reply_with_context(self, reply_data: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
+    async def rewrite_reply_with_context(
+        self,
+        reply_data: Dict[str, Any],
+        raw_reply: str = "",
+        reason: str = "",
+        reply_to: str = "",
+        relation_info: str = "",
+    ) -> Tuple[bool, Optional[str]]:
         """
         表达器 (Expressor): 核心逻辑，负责生成回复文本。
         """
         try:
-            reply_to = reply_data.get("reply_to", "")
+            if not reply_data:
-            raw_reply = reply_data.get("raw_reply", "")
+                reply_data = {
-            reason = reply_data.get("reason", "")
+                    "reply_to": reply_to,
+                    "relation_info": relation_info,
+                }
 
             with Timer("构建Prompt", {}):  # 内部计时器，可选保留
                 prompt = await self.build_prompt_rewrite_context(
                     raw_reply=raw_reply,
                     reason=reason,
-                    reply_to=reply_to,
+                    reply_data=reply_data,
                 )
 
             content = None
@@ -320,8 +284,7 @@ class DefaultReplyer:
 
                     content, (reasoning_content, model_name) = await express_model.generate_response_async(prompt)
 
-                    logger.info(f"想要表达：{raw_reply}||理由：{reason}")
+                    logger.info(f"想要表达：{raw_reply}||理由：{reason}||生成回复: {content}\n")
-                    logger.info(f"最终回复: {content}\n")
 
             except Exception as llm_e:
                 # 精简报错信息
@@ -501,7 +464,8 @@ class DefaultReplyer:
 
         return keywords_reaction_prompt
 
-    async def build_prompt_reply_context(self, reply_data=None, available_actions: List[str] = None) -> str:
+    async def build_prompt_reply_context(
+        self, reply_data=None, available_actions: List[str] = None) -> str:
         """
         构建回复器上下文
 
@@ -620,20 +584,23 @@ class DefaultReplyer:
             "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。"
         )
 
-        if is_group_chat:
+        if sender and target:
-            if sender:
+            if is_group_chat:
-                reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
+                if sender:
-            elif target:
+                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
-                reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
+                elif target:
-            else:
+                    reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
-                reply_target_block = "现在，你想要在群里发言或者回复消息。"
+                else:
-        else:  # private chat
+                    reply_target_block = "现在，你想要在群里发言或者回复消息。"
-            if sender:
+            else:  # private chat
-                reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
+                if sender:
-            elif target:
+                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
-                reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
+                elif target:
-            else:
+                    reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
-                reply_target_block = "现在，你想要回复。"
+                else:
+                    reply_target_block = "现在，你想要回复。"
+        else:
+            reply_target_block = ""
 
         mood_prompt = mood_manager.get_mood_prompt()
 
@@ -641,175 +608,176 @@ class DefaultReplyer:
         if prompt_info:
             prompt_info = await global_prompt_manager.format_prompt("knowledge_prompt", prompt_info=prompt_info)
 
-        # --- Choose template based on chat type ---
+        
+        template_name = "default_generator_prompt"
         if is_group_chat:
-            template_name = "default_generator_prompt"
-            # Group specific formatting variables (already fetched or default)
             chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1")
             chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2")
-
+        else:
-            prompt = await global_prompt_manager.format_prompt(
-                template_name,
-                expression_habits_block=expression_habits_block,
-                chat_target=chat_target_1,
-                chat_info=chat_talking_prompt,
-                memory_block=memory_block,
-                tool_info_block=tool_info_block,
-                knowledge_prompt=prompt_info,
-                extra_info_block=extra_info_block,
-                relation_info_block=relation_info,
-                time_block=time_block,
-                reply_target_block=reply_target_block,
-                moderation_prompt=moderation_prompt_block,
-                keywords_reaction_prompt=keywords_reaction_prompt,
-                identity=indentify_block,
-                target_message=target,
-                sender_name=sender,
-                config_expression_style=global_config.expression.expression_style,
-                action_descriptions=action_descriptions,
-                chat_target_2=chat_target_2,
-                mood_prompt=mood_prompt,
-            )
-        else:  # Private chat
-            template_name = "default_generator_private_prompt"
-            # 在私聊时获取对方的昵称信息
             chat_target_name = "对方"
             if self.chat_target_info:
                 chat_target_name = (
                     self.chat_target_info.get("person_name") or self.chat_target_info.get("user_nickname") or "对方"
                 )
-            chat_target_1 = f"你正在和 {chat_target_name} 聊天"
+            chat_target_1 = await global_prompt_manager.get_prompt_async(
-            prompt = await global_prompt_manager.format_prompt(
+                "chat_target_private1",
-                template_name,
+                sender_name = chat_target_name
-                expression_habits_block=expression_habits_block,
+                )
-                chat_target=chat_target_1,
+            chat_target_2 = await global_prompt_manager.get_prompt_async(
-                chat_info=chat_talking_prompt,
+                "chat_target_private2",
-                memory_block=memory_block,
+                sender_name = chat_target_name
-                tool_info_block=tool_info_block,
+                )
-                knowledge_prompt=prompt_info,
+        
-                relation_info_block=relation_info,
+        prompt = await global_prompt_manager.format_prompt(
-                extra_info_block=extra_info_block,
+            template_name,
-                time_block=time_block,
+            expression_habits_block=expression_habits_block,
-                keywords_reaction_prompt=keywords_reaction_prompt,
+            chat_target=chat_target_1,
-                identity=indentify_block,
+            chat_info=chat_talking_prompt,
-                target_message=target,
+            memory_block=memory_block,
-                sender_name=sender,
+            tool_info_block=tool_info_block,
-                config_expression_style=global_config.expression.expression_style,
+            knowledge_prompt=prompt_info,
-            )
+            extra_info_block=extra_info_block,
+            relation_info_block=relation_info,
+            time_block=time_block,
+            reply_target_block=reply_target_block,
+            moderation_prompt=moderation_prompt_block,
+            keywords_reaction_prompt=keywords_reaction_prompt,
+            identity=indentify_block,
+            target_message=target,
+            sender_name=sender,
+            config_expression_style=global_config.expression.expression_style,
+            action_descriptions=action_descriptions,
+            chat_target_2=chat_target_2,
+            mood_prompt=mood_prompt,
+        )
 
         return prompt
 
     async def build_prompt_rewrite_context(
         self,
-        reason,
+        reply_data: Dict[str, Any],
-        raw_reply,
+        raw_reply: str = "",
-        reply_to,
+        reason: str = "",
     ) -> str:
-        sender = ""
-        target = ""
-        if ":" in reply_to or "：" in reply_to:
-            # 使用正则表达式匹配中文或英文冒号
-            parts = re.split(pattern=r"[:：]", string=reply_to, maxsplit=1)
-            if len(parts) == 2:
-                sender = parts[0].strip()
-                target = parts[1].strip()
-
         chat_stream = self.chat_stream
-
+        chat_id = chat_stream.stream_id
+        person_info_manager = get_person_info_manager()
+        bot_person_id = person_info_manager.get_person_id("system", "bot_id")
         is_group_chat = bool(chat_stream.group_info)
         
-        message_list_before_now = get_raw_msg_before_timestamp_with_chat(
+        reply_to = reply_data.get("reply_to", "none")
-            chat_id=chat_stream.stream_id,
+        sender, target = self._parse_reply_target(reply_to)
+
+
+        message_list_before_now_half = get_raw_msg_before_timestamp_with_chat(
+            chat_id=chat_id,
             timestamp=time.time(),
-            limit=global_config.chat.max_context_size,
+            limit=int(global_config.chat.max_context_size * 0.5),
         )
-        chat_talking_prompt = build_readable_messages(
+        chat_talking_prompt_half = build_readable_messages(
-            message_list_before_now,
+            message_list_before_now_half,
             replace_bot_name=True,
-            merge_messages=True,
+            merge_messages=False,
             timestamp_mode="relative",
             read_mark=0.0,
-            truncate=True,
+            show_actions=True,
         )
 
-        expression_learner = get_expression_learner()
+        # 并行执行2个构建任务
-        (
+        expression_habits_block, relation_info= await asyncio.gather(
-            learnt_style_expressions,
+            self.build_expression_habits(chat_talking_prompt_half, target),
-            learnt_grammar_expressions,
+            self.build_relation_info(reply_data, chat_talking_prompt_half),
-            personality_expressions,
+        )
-        ) = expression_learner.get_expression_by_chat_id(chat_stream.stream_id)
 
-        style_habbits = []
+        keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target)
-        grammar_habbits = []
-        # 1. learnt_expressions加权随机选3条
-        if learnt_style_expressions:
-            weights = [expr["count"] for expr in learnt_style_expressions]
-            selected_learnt = weighted_sample_no_replacement(learnt_style_expressions, weights, 3)
-            for expr in selected_learnt:
-                if isinstance(expr, dict) and "situation" in expr and "style" in expr:
-                    style_habbits.append(f"当{expr['situation']}时，使用 {expr['style']}")
-        # 2. learnt_grammar_expressions加权随机选3条
-        if learnt_grammar_expressions:
-            weights = [expr["count"] for expr in learnt_grammar_expressions]
-            selected_learnt = weighted_sample_no_replacement(learnt_grammar_expressions, weights, 3)
-            for expr in selected_learnt:
-                if isinstance(expr, dict) and "situation" in expr and "style" in expr:
-                    grammar_habbits.append(f"当{expr['situation']}时，使用 {expr['style']}")
-        # 3. personality_expressions随机选1条
-        if personality_expressions:
-            expr = random.choice(personality_expressions)
-            if isinstance(expr, dict) and "situation" in expr and "style" in expr:
-                style_habbits.append(f"当{expr['situation']}时，使用 {expr['style']}")
         
-        style_habbits_str = "\n".join(style_habbits)
+        time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-        grammar_habbits_str = "\n".join(grammar_habbits)
+        
+        bot_name = global_config.bot.nickname
+        if global_config.bot.alias_names:
+            bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}"
+        else:
+            bot_nickname = ""
+        short_impression = await person_info_manager.get_value(bot_person_id, "short_impression")
+        try:
+            if isinstance(short_impression, str) and short_impression.strip():
+                short_impression = ast.literal_eval(short_impression)
+            elif not short_impression:
+                logger.warning("short_impression为空，使用默认值")
+                short_impression = ["友好活泼", "人类"]
+        except (ValueError, SyntaxError) as e:
+            logger.error(f"解析short_impression失败: {e}, 原始值: {short_impression}")
+            short_impression = ["友好活泼", "人类"]
+        # 确保short_impression是列表格式且有足够的元素
+        if not isinstance(short_impression, list) or len(short_impression) < 2:
+            logger.warning(f"short_impression格式不正确: {short_impression}, 使用默认值")
+            short_impression = ["友好活泼", "人类"]
+        personality = short_impression[0]
+        identity = short_impression[1]
+        prompt_personality = personality + "，" + identity
+        indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}："
+
+        moderation_prompt_block = (
+            "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。"
+        )
+        
+        if sender and target:
+            if is_group_chat:
+                if sender:
+                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
+                elif target:
+                    reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
+                else:
+                    reply_target_block = "现在，你想要在群里发言或者回复消息。"
+            else:  # private chat
+                if sender:
+                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
+                elif target:
+                    reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
+                else:
+                    reply_target_block = "现在，你想要回复。"
+        else:
+            reply_target_block = ""
+
+        mood_prompt = mood_manager.get_mood_prompt()
 
-        logger.debug("开始构建 focus prompt")
 
-        # --- Choose template based on chat type ---
         if is_group_chat:
-            template_name = "default_expressor_prompt"
-            # Group specific formatting variables (already fetched or default)
             chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1")
-            # chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2")
+            chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2")
-
+        else:
-            prompt = await global_prompt_manager.format_prompt(
-                template_name,
-                style_habbits=style_habbits_str,
-                grammar_habbits=grammar_habbits_str,
-                chat_target=chat_target_1,
-                chat_info=chat_talking_prompt,
-                bot_name=global_config.bot.nickname,
-                prompt_personality="",
-                reason=reason,
-                raw_reply=raw_reply,
-                sender_name=sender,
-                target_message=target,
-                config_expression_style=global_config.expression.expression_style,
-            )
-        else:  # Private chat
-            template_name = "default_expressor_private_prompt"
-            # 在私聊时获取对方的昵称信息
             chat_target_name = "对方"
             if self.chat_target_info:
                 chat_target_name = (
                     self.chat_target_info.get("person_name") or self.chat_target_info.get("user_nickname") or "对方"
                 )
-            chat_target_1 = f"你正在和 {chat_target_name} 聊天"
+            chat_target_1 = await global_prompt_manager.get_prompt_async(
-            prompt = await global_prompt_manager.format_prompt(
+                "chat_target_private1",
-                template_name,
+                sender_name = chat_target_name
-                style_habbits=style_habbits_str,
+                )
-                grammar_habbits=grammar_habbits_str,
+            chat_target_2 = await global_prompt_manager.get_prompt_async(
-                chat_target=chat_target_1,
+                "chat_target_private2",
-                chat_info=chat_talking_prompt,
+                sender_name = chat_target_name
-                bot_name=global_config.bot.nickname,
+                )
-                prompt_personality="",
+        
-                reason=reason,
+        template_name = "default_expressor_prompt"
-                raw_reply=raw_reply,
+
-                sender_name=sender,
+        prompt = await global_prompt_manager.format_prompt(
-                target_message=target,
+            template_name,
-                config_expression_style=global_config.expression.expression_style,
+            expression_habits_block=expression_habits_block,
-            )
+            relation_info_block=relation_info,
+            chat_target=chat_target_1,
+            time_block=time_block,
+            chat_info=chat_talking_prompt_half,
+            identity=indentify_block,
+            chat_target_2=chat_target_2,
+            reply_target_block=reply_target_block,
+            raw_reply=raw_reply,
+            reason=reason,
+            config_expression_style=global_config.expression.expression_style,
+            keywords_reaction_prompt=keywords_reaction_prompt,
+            moderation_prompt=moderation_prompt_block,
+        )
 
         return prompt
 

src/main.py

@@ -205,7 +205,7 @@ class MainSystem:
         expression_learner = get_expression_learner()
         while True:
             await asyncio.sleep(global_config.expression.learning_interval)
-            if global_config.expression.enable_expression_learning:
+            if global_config.expression.enable_expression_learning and global_config.expression.enable_expression:
                 logger.info("[表达方式学习] 开始学习表达方式...")
                 await expression_learner.learn_and_store_expression()
                 logger.info("[表达方式学习] 表达方式学习完成")