refactor(scoring): 重构评分系统使用统一API替代插件内部实现

将原有的兴趣度评分系统重构为使用统一的评分API，移除了插件内部实现并更新了所有相关引用。主要变更包括：
- 替换 chatter_interest_scoring_system 为 scoring_api
- 移除 interest_scoring.py 文件，统一使用 src/plugin_system/apis/scoring_api
- 更新关系追踪器以使用统一API，保持向后兼容性
- 简化了多个模块中的关系分获取逻辑

src/chat/energy_system/energy_manager.py

@@ -199,16 +199,16 @@ class RelationshipEnergyCalculator(EnergyCalculator):
         if not user_id:
             return 0.3
 
-        # 使用插件内部的兴趣度评分系统获取关系分
+        # 使用统一的评分API获取关系分
         try:
-            from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system
+            from src.plugin_system.apis.scoring_api import scoring_api
 
-            relationship_score = await chatter_interest_scoring_system._calculate_relationship_score(user_id)
-            logger.debug(f"使用插件内部系统计算关系分: {relationship_score:.3f}")
-            return max(0.0, min(1.0, relationship_score))
+            relationship_score = await scoring_api.get_user_relationship_score(user_id)
+            logger.debug(f"使用统一评分API计算关系分: {relationship_score:.3f}")
+            return relationship_score
 
         except Exception as e:
-            logger.warning(f"插件内部关系分计算失败，使用默认值: {e}")
+            logger.warning(f"关系分计算失败，使用默认值: {e}")
             return 0.3  # 默认基础分
 
     def get_weight(self) -> float:

src/chat/message_receive/chat_stream.py

@@ -405,18 +405,18 @@ class ChatStream:
 
     async def _get_user_relationship_score(self) -> float:
         """获取用户关系分"""
-        # 使用插件内部的兴趣度评分系统
+        # 使用统一的评分API
         try:
-            from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system
+            from src.plugin_system.apis.scoring_api import scoring_api
 
             if self.user_info and hasattr(self.user_info, "user_id"):
                 user_id = str(self.user_info.user_id)
-                relationship_score = await chatter_interest_scoring_system._calculate_relationship_score(user_id)
+                relationship_score = await scoring_api.get_user_relationship_score(user_id)
                 logger.debug(f"ChatStream {self.stream_id}: 用户关系分 = {relationship_score:.3f}")
-                return max(0.0, min(1.0, relationship_score))
+                return relationship_score
 
         except Exception as e:
-            logger.warning(f"ChatStream {self.stream_id}: 插件内部关系分计算失败: {e}")
+            logger.warning(f"ChatStream {self.stream_id}: 关系分计算失败: {e}")
 
         # 默认基础分
         return 0.3

src/chat/message_receive/optimized_chat_stream.py

@@ -436,17 +436,17 @@ class OptimizedChatStream:
     async def _get_user_relationship_score(self) -> float:
         """获取用户关系分"""
         try:
-            from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system
+            from src.plugin_system.apis.scoring_api import scoring_api
 
             effective_user_info = self._get_effective_user_info()
             if effective_user_info and hasattr(effective_user_info, "user_id"):
                 user_id = str(effective_user_info.user_id)
-                relationship_score = await chatter_interest_scoring_system._calculate_relationship_score(user_id)
+                relationship_score = await scoring_api.get_user_relationship_score(user_id)
                 logger.debug(f"OptimizedChatStream {self.stream_id}: 用户关系分 = {relationship_score:.3f}")
-                return max(0.0, min(1.0, relationship_score))
+                return relationship_score
 
         except Exception as e:
-            logger.warning(f"OptimizedChatStream {self.stream_id}: 插件内部关系分计算失败: {e}")
+            logger.warning(f"OptimizedChatStream {self.stream_id}: 关系分计算失败: {e}")
 
         return 0.3
 

src/chat/replyer/default_generator.py

@@ -1770,49 +1770,42 @@ class DefaultReplyer:
             logger.warning(f"未找到用户 {sender} 的ID，跳过信息提取")
             return f"你完全不认识{sender}，不理解ta的相关信息。"
 
-        # 使用AFC关系追踪器获取关系信息
+        # 使用统一评分API获取关系信息
         try:
-            # 创建关系追踪器实例
-            from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system
-            from src.plugins.built_in.affinity_flow_chatter.relationship_tracker import ChatterRelationshipTracker
+            from src.plugin_system.apis.scoring_api import scoring_api
 
-            relationship_tracker = ChatterRelationshipTracker(chatter_interest_scoring_system)
-            if relationship_tracker:
-                # 获取用户信息以获取真实的user_id
-                user_info = await person_info_manager.get_values(person_id, ["user_id", "platform"])
-                user_id = user_info.get("user_id", "unknown")
+            # 获取用户信息以获取真实的user_id
+            user_info = await person_info_manager.get_values(person_id, ["user_id", "platform"])
+            user_id = user_info.get("user_id", "unknown")
 
-                # 从数据库获取关系数据
-                relationship_data = await relationship_tracker._get_user_relationship_from_db(user_id)
-                if relationship_data:
-                    relationship_text = relationship_data.get("relationship_text", "")
-                    relationship_score = relationship_data.get("relationship_score", 0.3)
+            # 从统一API获取关系数据
+            relationship_data = await scoring_api.get_user_relationship_data(user_id)
+            if relationship_data:
+                relationship_text = relationship_data.get("relationship_text", "")
+                relationship_score = relationship_data.get("relationship_score", 0.3)
 
-                    # 构建丰富的关系信息描述
-                    if relationship_text:
-                        # 转换关系分数为描述性文本
-                        if relationship_score >= 0.8:
-                            relationship_level = "非常亲密的朋友"
-                        elif relationship_score >= 0.6:
-                            relationship_level = "好朋友"
-                        elif relationship_score >= 0.4:
-                            relationship_level = "普通朋友"
-                        elif relationship_score >= 0.2:
-                            relationship_level = "认识的人"
-                        else:
-                            relationship_level = "陌生人"
-
-                        return f"你与{sender}的关系：{relationship_level}（关系分：{relationship_score:.2f}/1.0）。{relationship_text}"
+                # 构建丰富的关系信息描述
+                if relationship_text:
+                    # 转换关系分数为描述性文本
+                    if relationship_score >= 0.8:
+                        relationship_level = "非常亲密的朋友"
+                    elif relationship_score >= 0.6:
+                        relationship_level = "好朋友"
+                    elif relationship_score >= 0.4:
+                        relationship_level = "普通朋友"
+                    elif relationship_score >= 0.2:
+                        relationship_level = "认识的人"
                     else:
-                        return f"你与{sender}是初次见面，关系分：{relationship_score:.2f}/1.0。"
+                        relationship_level = "陌生人"
+
+                    return f"你与{sender}的关系：{relationship_level}（关系分：{relationship_score:.2f}/1.0）。{relationship_text}"
                 else:
-                    return f"你完全不认识{sender}，这是第一次互动。"
+                    return f"你与{sender}是初次见面，关系分：{relationship_score:.2f}/1.0。"
             else:
-                logger.warning("AFC关系追踪器未初始化，使用默认关系信息")
-                return f"你与{sender}是普通朋友关系。"
+                return f"你完全不认识{sender}，这是第一次互动。"
 
         except Exception as e:
-            logger.error(f"获取AFC关系信息失败: {e}")
+            logger.error(f"获取关系信息失败: {e}")
             return f"你与{sender}是普通朋友关系。"
 
     async def _store_chat_memory_async(self, reply_to: str, reply_message: dict[str, Any] | None = None):