重构数据库交互以使用 Peewee ORM

- 更新数据库连接和模型定义，以便使用 Peewee for SQLite。
- 在消息存储和检索功能中，用 Peewee ORM 查询替换 MongoDB 查询。
- 为 Messages、ThinkingLog 和 OnlineTime 引入了新的模型，以方便结构化数据存储。
- 增强了数据库操作的错误处理和日志记录。
- 删除了过时的 MongoDB 集合管理代码。
- 通过利用 Peewee 内置的查询和数据操作方法来提升性能。

src/common/database/database.py

@@ -1,5 +1,6 @@
 import os
 from pymongo import MongoClient
+from peewee import SqliteDatabase
 from pymongo.database import Database
 from rich.traceback import install
 
@@ -57,4 +58,15 @@ class DBWrapper:
 
 
 # 全局数据库访问点
-db: Database = DBWrapper()
+memory_db: Database = DBWrapper()
+
+# 定义数据库文件路径
+ROOT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
+_DB_DIR = os.path.join(ROOT_PATH, "data")
+_DB_FILE = os.path.join(_DB_DIR, "MaiBot.db")
+
+# 确保数据库目录存在
+os.makedirs(_DB_DIR, exist_ok=True)
+
+# 全局 Peewee SQLite 数据库访问点
+db = SqliteDatabase(_DB_FILE)

src/common/database/database_model.py

@@ -1,9 +1,10 @@
-from peewee import Model, DoubleField, IntegerField, SqliteDatabase, BooleanField, TextField, FloatField
-
+from peewee import Model, DoubleField, IntegerField, BooleanField, TextField, FloatField, DateTimeField
+from .database import db
+import datetime
 # 请在此处定义您的数据库实例。
 # 您需要取消注释并配置适合您的数据库的部分。
 # 例如，对于 SQLite:
-db = SqliteDatabase('my_application.db')
+# db = SqliteDatabase('MaiBot.db')
 #
 # 对于 PostgreSQL:
 # db = PostgresqlDatabase('your_db_name', user='your_user', password='your_password',
@@ -69,17 +70,16 @@ class LLMUsage(BaseModel):
     """
     用于存储 API 使用日志数据的模型。
     """
-    model_name = TextField()
-    user_id = TextField()
-    request_type = TextField()
+    model_name = TextField(index=True) # 添加索引
+    user_id = TextField(index=True) # 添加索引
+    request_type = TextField(index=True) # 添加索引
     endpoint = TextField()
     prompt_tokens = IntegerField()
     completion_tokens = IntegerField()
     total_tokens = IntegerField()
     cost = DoubleField()
     status = TextField()
-    # timestamp: "$date": "2025-05-01T18:52:50.870Z" (存储为字符串)
-    timestamp = TextField()
+    timestamp = DateTimeField(index=True) # 更改为 DateTimeField 并添加索引
 
     class Meta:
         # 如果 BaseModel.Meta.database 已设置，则此模型将继承该数据库配置。
@@ -177,6 +177,8 @@ class OnlineTime(BaseModel):
     # timestamp: "$date": "2025-05-01T18:52:18.191Z" (存储为字符串)
     timestamp = TextField()
     duration = IntegerField()  # 时长，单位分钟
+    start_timestamp = DateTimeField(default=datetime.datetime.now)
+    end_timestamp = DateTimeField(index=True)
 
     class Meta:
         # database = db # 继承自 BaseModel
@@ -202,3 +204,39 @@ class PersonInfo(BaseModel):
         # database = db # 继承自 BaseModel
         table_name = 'person_info'
 
+class Knowledges(BaseModel):
+    """
+    用于存储知识库条目的模型。
+    """
+    content = TextField()  # 知识内容的文本
+    embedding = TextField()  # 知识内容的嵌入向量，存储为 JSON 字符串的浮点数列表
+    # 可以添加其他元数据字段，如 source, create_time 等
+
+    class Meta:
+        # database = db # 继承自 BaseModel
+        table_name = 'knowledges'
+
+
+class ThinkingLog(BaseModel):
+    chat_id = TextField(index=True)
+    trigger_text = TextField(null=True)
+    response_text = TextField(null=True)
+    
+    # Store complex dicts/lists as JSON strings
+    trigger_info_json = TextField(null=True)
+    response_info_json = TextField(null=True)
+    timing_results_json = TextField(null=True)
+    chat_history_json = TextField(null=True)
+    chat_history_in_thinking_json = TextField(null=True)
+    chat_history_after_response_json = TextField(null=True)
+    heartflow_data_json = TextField(null=True)
+    reasoning_data_json = TextField(null=True)
+
+    # Add a timestamp for the log entry itself
+    # Ensure you have: from peewee import DateTimeField
+    # And: import datetime
+    created_at = DateTimeField(default=datetime.datetime.now) 
+
+    class Meta:
+        table_name = 'thinking_logs'
+

src/common/message_repository.py

@@ -1,11 +1,19 @@
-from common.database.database import db
+from src.common.database.database_model import Messages # 更改导入
 from src.common.logger import get_module_logger
 import traceback
 from typing import List, Any, Optional
+from peewee import Model  # 添加 Peewee Model 导入
 
 logger = get_module_logger(__name__)
 
 
+def _model_to_dict(model_instance: Model) -> dict[str, Any]:
+    """
+    将 Peewee 模型实例转换为字典。
+    """
+    return model_instance.__data__
+
+
 def find_messages(
     message_filter: dict[str, Any],
     sort: Optional[List[tuple[str, int]]] = None,
@@ -16,39 +24,72 @@ def find_messages(
     根据提供的过滤器、排序和限制条件查找消息。
 
     Args:
-        message_filter: MongoDB 查询过滤器。
-        sort: MongoDB 排序条件列表，例如 [('time', 1)]。仅在 limit 为 0 时生效。
+        message_filter: 查询过滤器字典，键为模型字段名，值为期望值。
+        sort: 排序条件列表，例如 [('time', 1)] (1 for asc, -1 for desc)。仅在 limit 为 0 时生效。
         limit: 返回的最大文档数，0表示不限制。
         limit_mode: 当 limit > 0 时生效。 'earliest' 表示获取最早的记录， 'latest' 表示获取最新的记录（结果仍按时间正序排列）。默认为 'latest'。
 
     Returns:
-        消息文档列表，如果出错则返回空列表。
+        消息字典列表，如果出错则返回空列表。
     """
     try:
-        query = db.messages.find(message_filter)
+        query = Messages.select()
+
+        # 应用过滤器
+        if message_filter:
+            conditions = []
+            for key, value in message_filter.items():
+                if hasattr(Messages, key):
+                    conditions.append(getattr(Messages, key) == value)
+                else:
+                    logger.warning(
+                        f"过滤器键 '{key}' 在 Messages 模型中未找到。将跳过此条件。"
+                    )
+            if conditions:
+                # 使用 *conditions 将所有条件以 AND 连接
+                query = query.where(*conditions)
 
         if limit > 0:
             if limit_mode == "earliest":
                 # 获取时间最早的 limit 条记录，已经是正序
-                query = query.sort([("time", 1)]).limit(limit)
-                results = list(query)
+                query = query.order_by(Messages.time.asc()).limit(limit)
+                peewee_results = list(query)
             else:  # 默认为 'latest'
                 # 获取时间最晚的 limit 条记录
-                query = query.sort([("time", -1)]).limit(limit)
-                latest_results = list(query)
+                query = query.order_by(Messages.time.desc()).limit(limit)
+                latest_results_peewee = list(query)
                 # 将结果按时间正序排列
-                # 假设消息文档中总是有 'time' 字段且可排序
-                results = sorted(latest_results, key=lambda msg: msg.get("time"))
+                peewee_results = sorted(
+                    latest_results_peewee, key=lambda msg: msg.time
+                )
         else:
             # limit 为 0 时，应用传入的 sort 参数
             if sort:
-                query = query.sort(sort)
-            results = list(query)
+                peewee_sort_terms = []
+                for field_name, direction in sort:
+                    if hasattr(Messages, field_name):
+                        field = getattr(Messages, field_name)
+                        if direction == 1:  # ASC
+                            peewee_sort_terms.append(field.asc())
+                        elif direction == -1:  # DESC
+                            peewee_sort_terms.append(field.desc())
+                        else:
+                            logger.warning(
+                                f"字段 '{field_name}' 的排序方向 '{direction}' 无效。将跳过此排序条件。"
+                            )
+                    else:
+                        logger.warning(
+                            f"排序字段 '{field_name}' 在 Messages 模型中未找到。将跳过此排序条件。"
+                        )
+                if peewee_sort_terms:
+                    query = query.order_by(*peewee_sort_terms)
+            peewee_results = list(query)
 
+        results = [_model_to_dict(msg) for msg in peewee_results]
         return results
     except Exception as e:
         log_message = (
-            f"查找消息失败 (filter={message_filter}, sort={sort}, limit={limit}, limit_mode={limit_mode}): {e}\n"
+            f"使用 Peewee 查找消息失败 (filter={message_filter}, sort={sort}, limit={limit}, limit_mode={limit_mode}): {e}\n"
             + traceback.format_exc()
         )
         logger.error(log_message)
@@ -60,18 +101,35 @@ def count_messages(message_filter: dict[str, Any]) -> int:
     根据提供的过滤器计算消息数量。
 
     Args:
-        message_filter: MongoDB 查询过滤器。
+        message_filter: 查询过滤器字典，键为模型字段名，值为期望值。
 
     Returns:
         符合条件的消息数量，如果出错则返回 0。
     """
     try:
-        count = db.messages.count_documents(message_filter)
+        query = Messages.select()
+
+        # 应用过滤器
+        if message_filter:
+            conditions = []
+            for key, value in message_filter.items():
+                if hasattr(Messages, key):
+                    conditions.append(getattr(Messages, key) == value)
+                else:
+                    logger.warning(
+                        f"计数时，过滤器键 '{key}' 在 Messages 模型中未找到。将跳过此条件。"
+                    )
+            if conditions:
+                query = query.where(*conditions)
+
+        count = query.count()
         return count
     except Exception as e:
-        log_message = f"计数消息失败 (message_filter={message_filter}): {e}\n" + traceback.format_exc()
+        log_message = f"使用 Peewee 计数消息失败 (message_filter={message_filter}): {e}\n" + traceback.format_exc()
         logger.error(log_message)
         return 0
 
 
 # 你可以在这里添加更多与 messages 集合相关的数据库操作函数，例如 find_one_message, insert_message 等。
+# 注意：对于 Peewee，插入操作通常是 Messages.create(...) 或 instance.save()。
+# 查找单个消息可以是 Messages.get_or_none(...) 或 query.first()。