Undefined-bot 2.1.0__py3-none-any.whl

Undefined/utils/history.py

@@ -0,0 +1,284 @@
+"""历史记录管理"""
+
+import json
+import logging
+import os
+from datetime import datetime
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# 历史记录文件路径
+HISTORY_DIR = os.path.join("data", "history")
+MAX_HISTORY = 10000  # 统一 10000 条限制
+
+
+class MessageHistoryManager:
+    """消息历史管理器"""
+
+    def __init__(self) -> None:
+        self._message_history: dict[str, list[dict[str, Any]]] = {}
+        self._private_message_history: dict[str, list[dict[str, Any]]] = {}
+        # 确保目录存在
+        os.makedirs(HISTORY_DIR, exist_ok=True)
+        # 加载历史
+        self._load_all_histories()
+
+    def _get_group_history_path(self, group_id: int) -> str:
+        """获取群消息历史文件路径"""
+        return os.path.join(HISTORY_DIR, f"group_{group_id}.json")
+
+    def _get_private_history_path(self, user_id: int) -> str:
+        """获取私聊消息历史文件路径"""
+        return os.path.join(HISTORY_DIR, f"private_{user_id}.json")
+
+    def _save_history_to_file(self, history: list[dict[str, Any]], path: str) -> None:
+        """保存历史记录到文件（最多 10000 条）"""
+        try:
+            # 只保留最近的 MAX_HISTORY 条
+            truncated_history = (
+                history[-MAX_HISTORY:] if len(history) > MAX_HISTORY else history
+            )
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump(truncated_history, f, ensure_ascii=False, indent=2)
+            logger.debug(f"[历史记录] 已成功保存历史到 {path}")
+        except Exception as e:
+            logger.error(f"[历史记录错误] 保存历史记录失败 {path}: {e}")
+
+    def _load_history_from_file(self, path: str) -> list[dict[str, Any]]:
+        """从文件加载历史记录"""
+        try:
+            if os.path.exists(path):
+                with open(path, "r", encoding="utf-8") as f:
+                    history = json.load(f)
+                    if isinstance(history, list):
+                        # 兼容旧格式：补充缺失的字段
+                        for msg in history:
+                            if "type" not in msg:
+                                msg["type"] = (
+                                    "private" if "private" in path else "group"
+                                )
+                            if "chat_id" not in msg:
+                                if "group_" in path:
+                                    msg["chat_id"] = msg.get("user_id", "")
+                                else:
+                                    msg["chat_id"] = msg.get("user_id", "")
+                            if "timestamp" not in msg:
+                                msg["timestamp"] = ""
+                            if "chat_name" not in msg:
+                                if msg["type"] == "group":
+                                    msg["chat_name"] = f"群{msg.get('chat_id', '')}"
+                                else:
+                                    msg["chat_name"] = f"QQ用户{msg.get('chat_id', '')}"
+                        # 只保留最近的 MAX_HISTORY 条
+                        return (
+                            history[-MAX_HISTORY:]
+                            if len(history) > MAX_HISTORY
+                            else history
+                        )
+        except Exception as e:
+            logger.error(f"加载历史记录失败 {path}: {e}")
+        return []
+
+    def _load_all_histories(self) -> None:
+        """启动时加载所有历史记录"""
+        if not os.path.exists(HISTORY_DIR):
+            logger.info("历史消息目录不存在，跳过加载")
+            return
+
+        # 加载群消息历史
+        group_count = 0
+        for filename in os.listdir(HISTORY_DIR):
+            if filename.startswith("group_") and filename.endswith(".json"):
+                try:
+                    group_id_str = filename[6:-5]  # 提取群号
+                    path = os.path.join(HISTORY_DIR, filename)
+                    self._message_history[group_id_str] = self._load_history_from_file(
+                        path
+                    )
+                    group_count += 1
+                    logger.debug(
+                        f"[历史记录] 已加载群 {group_id_str} 历史消息: {len(self._message_history[group_id_str])} 条"
+                    )
+                except Exception as e:
+                    logger.error(f"[历史记录错误] 加载群历史失败 {filename}: {e}")
+
+        logger.info(f"[历史记录] 共加载了 {group_count} 个群聊的历史记录")
+
+        # 加载私聊消息历史
+        private_count = 0
+        for filename in os.listdir(HISTORY_DIR):
+            if filename.startswith("private_") and filename.endswith(".json"):
+                try:
+                    user_id_str = filename[8:-5]  # 提取用户ID
+                    path = os.path.join(HISTORY_DIR, filename)
+                    self._private_message_history[user_id_str] = (
+                        self._load_history_from_file(path)
+                    )
+                    private_count += 1
+                    logger.debug(
+                        f"[历史记录] 已加载私聊 {user_id_str} 历史消息: {len(self._private_message_history[user_id_str])} 条"
+                    )
+                except Exception as e:
+                    logger.error(f"[历史记录错误] 加载私聊历史失败 {filename}: {e}")
+
+        logger.info(f"[历史记录] 共加载了 {private_count} 个私聊会话的历史记录")
+
+    def add_group_message(
+        self,
+        group_id: int,
+        sender_id: int,
+        text_content: str,
+        sender_card: str = "",
+        sender_nickname: str = "",
+        group_name: str = "",
+    ) -> None:
+        """保存群消息到历史记录"""
+        group_id_str = str(group_id)
+        sender_id_str = str(sender_id)
+
+        if group_id_str not in self._message_history:
+            self._message_history[group_id_str] = []
+
+        display_name = sender_card or sender_nickname or sender_id_str
+
+        self._message_history[group_id_str].append(
+            {
+                "type": "group",
+                "chat_id": group_id_str,
+                "chat_name": group_name or f"群{group_id_str}",
+                "user_id": sender_id_str,
+                "display_name": display_name,
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "message": text_content,
+            }
+        )
+
+        if len(self._message_history[group_id_str]) > MAX_HISTORY:
+            self._message_history[group_id_str] = self._message_history[group_id_str][
+                -MAX_HISTORY:
+            ]
+
+        self._save_history_to_file(
+            self._message_history[group_id_str], self._get_group_history_path(group_id)
+        )
+
+    def add_private_message(
+        self,
+        user_id: int,
+        text_content: str,
+        display_name: str = "",
+        user_name: str = "",
+    ) -> None:
+        """保存私聊消息到历史记录"""
+        user_id_str = str(user_id)
+
+        if user_id_str not in self._private_message_history:
+            self._private_message_history[user_id_str] = []
+
+        self._private_message_history[user_id_str].append(
+            {
+                "type": "private",
+                "chat_id": user_id_str,
+                "chat_name": user_name or f"QQ用户{user_id_str}",
+                "user_id": user_id_str,
+                "display_name": display_name or user_name or user_id_str,
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "message": text_content,
+            }
+        )
+
+        if len(self._private_message_history[user_id_str]) > MAX_HISTORY:
+            self._private_message_history[user_id_str] = self._private_message_history[
+                user_id_str
+            ][-MAX_HISTORY:]
+
+        self._save_history_to_file(
+            self._private_message_history[user_id_str],
+            self._get_private_history_path(user_id),
+        )
+
+    def get_recent(
+        self,
+        chat_id: str,
+        msg_type: str,
+        start: int,
+        end: int,
+    ) -> list[dict[str, Any]]:
+        """获取指定的历史消息"""
+        if msg_type == "group":
+            if chat_id not in self._message_history:
+                return []
+            history = self._message_history[chat_id]
+        elif msg_type == "private":
+            if chat_id not in self._private_message_history:
+                return []
+            history = self._private_message_history[chat_id]
+        else:
+            return []
+
+        total = len(history)
+        if total == 0:
+            return []
+
+        actual_start = total - end
+        actual_end = total - start
+
+        if actual_start < 0:
+            actual_start = 0
+        if actual_end > total:
+            actual_end = total
+        if actual_start >= actual_end:
+            return []
+
+        return history[actual_start:actual_end]
+
+    def get_recent_private(self, user_id: int, count: int) -> list[dict[str, Any]]:
+        """获取最近的私聊消息"""
+        user_id_str = str(user_id)
+        if user_id_str not in self._private_message_history:
+            return []
+        return self._private_message_history[user_id_str][-count:] if count > 0 else []
+
+    def modify_last_group_message(
+        self,
+        group_id: int,
+        sender_id: int,
+        new_message: str,
+    ) -> None:
+        """修改群聊历史记录中指定用户的最后一条消息"""
+        group_id_str = str(group_id)
+        sender_id_str = str(sender_id)
+
+        if group_id_str not in self._message_history:
+            return
+
+        for i in range(len(self._message_history[group_id_str]) - 1, -1, -1):
+            msg = self._message_history[group_id_str][i]
+            if msg.get("user_id") == sender_id_str:
+                msg["message"] = new_message
+                self._save_history_to_file(
+                    self._message_history[group_id_str],
+                    self._get_group_history_path(group_id),
+                )
+                logger.info(f"已修改群聊 {group_id} 用户 {sender_id} 的最后一条消息")
+                break
+
+    def modify_last_private_message(
+        self,
+        user_id: int,
+        new_message: str,
+    ) -> None:
+        """修改私聊历史记录中最后一条消息"""
+        user_id_str = str(user_id)
+
+        if user_id_str not in self._private_message_history:
+            return
+
+        if self._private_message_history[user_id_str]:
+            self._private_message_history[user_id_str][-1]["message"] = new_message
+            self._save_history_to_file(
+                self._private_message_history[user_id_str],
+                self._get_private_history_path(user_id),
+            )
+            logger.info(f"已修改私聊用户 {user_id} 的最后一条消息")

Undefined/utils/scheduler.py

@@ -0,0 +1,286 @@
+"""
+任务调度器
+用于定时执行 AI 工具
+"""
+
+import logging
+import time
+from typing import Any, Optional
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from ..scheduled_task_storage import ScheduledTaskStorage
+
+logger = logging.getLogger(__name__)
+
+
+class TaskScheduler:
+    """任务调度器"""
+
+    def __init__(
+        self,
+        ai_client: Any,
+        sender: Any,
+        onebot_client: Any,
+        history_manager: Any,
+        task_storage: Optional[ScheduledTaskStorage] = None,
+    ) -> None:
+        """初始化调度器
+
+        参数:
+            ai_client: AI 客户端实例 (AIClient)
+            sender: 消息发送器实例 (MessageSender)
+            onebot_client: OneBot 客户端实例
+            history_manager: 历史记录管理器
+            task_storage: 任务持久化存储器
+        """
+        self.scheduler = AsyncIOScheduler()
+        self.ai = ai_client
+        self.sender = sender
+        self.onebot = onebot_client
+        self.history_manager = history_manager
+        self.storage = task_storage or ScheduledTaskStorage()
+
+        # 从存储加载任务
+        self.tasks: dict[str, Any] = self.storage.load_tasks()
+
+        # 确保 scheduler 在 event loop 中运行
+        if not self.scheduler.running:
+            self.scheduler.start()
+            logger.info("[任务调度] 任务调度服务已启动")
+
+        # 恢复已有的任务
+        self._recover_tasks()
+
+    def _recover_tasks(self) -> None:
+        """从存储中恢复任务并添加到调度器"""
+        if not self.tasks:
+            logger.info("[任务调度] 没有需要恢复的定时任务")
+            return
+
+        count = 0
+        for task_id, info in list(self.tasks.items()):
+            try:
+                trigger = CronTrigger.from_crontab(info["cron"])
+                self.scheduler.add_job(
+                    self._execute_tool_wrapper,
+                    trigger=trigger,
+                    id=task_id,
+                    args=[
+                        task_id,
+                        info["tool_name"],
+                        info["tool_args"],
+                        info["target_id"],
+                        info["target_type"],
+                    ],
+                    replace_existing=True,
+                )
+                count += 1
+                logger.debug(f"[任务调度] 已恢复任务: {task_id} ({info['tool_name']})")
+            except Exception as e:
+                logger.error(f"[任务调度错误] 恢复定时任务 {task_id} 失败: {e}")
+                # 如果任务恢复失败（如格式错误），保留在 self.tasks 中还是删除？
+                # 目前保留，由用户或后续逻辑处理
+
+        if count > 0:
+            logger.info(f"成功恢复 {count} 个定时任务")
+
+    def add_task(
+        self,
+        task_id: str,
+        tool_name: str,
+        tool_args: dict[str, Any],
+        cron_expression: str,
+        target_id: int | None = None,
+        target_type: str = "group",
+        task_name: str | None = None,
+        max_executions: int | None = None,
+    ) -> bool:
+        """添加定时任务
+
+        参数:
+            task_id: 任务唯一标识（用户指定或自动生成）
+            tool_name: 要执行的工具名称
+            tool_args: 工具参数
+            cron_expression: crontab 表达式 (分 时 日 月 周)
+            target_id: 结果发送目标 ID
+            target_type: 结果发送目标类型 (group/private)
+            task_name: 任务名称（用于标识，可读名称）
+            max_executions: 最大执行次数（None 表示无限）
+
+        返回:
+            是否添加成功
+        """
+        try:
+            trigger = CronTrigger.from_crontab(cron_expression)
+
+            self.scheduler.add_job(
+                self._execute_tool_wrapper,
+                trigger=trigger,
+                id=task_id,
+                args=[task_id, tool_name, tool_args, target_id, target_type],
+                replace_existing=True,
+            )
+
+            self.tasks[task_id] = {
+                "task_id": task_id,
+                "tool_name": tool_name,
+                "tool_args": tool_args,
+                "cron": cron_expression,
+                "target_id": target_id,
+                "target_type": target_type,
+                "task_name": task_name or "",
+                "max_executions": max_executions,
+                "current_executions": 0,
+            }
+
+            # 持久化保存
+            self.storage.save_all(self.tasks)
+
+            logger.info(
+                f"添加定时任务成功: {task_id} -> {tool_name} ({cron_expression})"
+            )
+            return True
+        except Exception as e:
+            logger.error(f"添加定时任务失败: {e}")
+            return False
+
+    def update_task(
+        self,
+        task_id: str,
+        cron_expression: str | None = None,
+        tool_name: str | None = None,
+        tool_args: dict[str, Any] | None = None,
+        task_name: str | None = None,
+        max_executions: int | None = None,
+    ) -> bool:
+        """修改定时任务（不支持修改 task_id）
+
+        参数:
+            task_id: 要修改的任务 ID
+            cron_expression: 新的 crontab 表达式
+            tool_name: 新的工具名称
+            tool_args: 新的工具参数
+            task_name: 新的任务名称
+            max_executions: 新的最大执行次数
+
+        返回:
+            是否修改成功
+        """
+        if task_id not in self.tasks:
+            logger.warning(f"修改定时任务失败: 任务不存在 {task_id}")
+            return False
+
+        try:
+            task_info = self.tasks[task_id]
+
+            if cron_expression is not None:
+                trigger = CronTrigger.from_crontab(cron_expression)
+                self.scheduler.reschedule_job(task_id, trigger=trigger)
+                task_info["cron"] = cron_expression
+
+            if tool_name is not None:
+                task_info["tool_name"] = tool_name
+
+            if tool_args is not None:
+                task_info["tool_args"] = tool_args
+
+            if task_name is not None:
+                task_info["task_name"] = task_name
+
+            if max_executions is not None:
+                task_info["max_executions"] = max_executions
+
+            # 持久化保存
+            self.storage.save_all(self.tasks)
+
+            logger.info(f"修改定时任务成功: {task_id}")
+            return True
+        except Exception as e:
+            logger.error(f"修改定时任务失败: {e}")
+            return False
+
+    def remove_task(self, task_id: str) -> bool:
+        """移除定时任务"""
+        try:
+            self.scheduler.remove_job(task_id)
+            if task_id in self.tasks:
+                del self.tasks[task_id]
+                # 持久化保存
+                self.storage.save_all(self.tasks)
+            logger.info(f"移除定时任务成功: {task_id}")
+            return True
+        except Exception as e:
+            logger.warning(f"移除定时任务失败 (可能不存在): {e}")
+            return False
+
+    def list_tasks(self) -> dict[str, Any]:
+        """列出所有任务"""
+        return self.tasks
+
+    async def _execute_tool_wrapper(
+        self,
+        task_id: str,
+        tool_name: str,
+        tool_args: dict[str, Any],
+        target_id: int | None,
+        target_type: str,
+    ) -> None:
+        """任务执行包装器"""
+        logger.info(f"[任务触发] 定时任务开始执行: ID={task_id}, 工具={tool_name}")
+        logger.debug(f"[任务详情] 参数={tool_args}, 目标={target_id}({target_type})")
+
+        try:
+            context = {
+                "scheduler": self,
+                "ai_client": self.ai,
+                "sender": self.sender,
+                "onebot_client": self.onebot,
+                "history_manager": self.history_manager,
+            }
+
+            start_time = time.perf_counter()
+            result = await self.ai._execute_tool(tool_name, tool_args, context)
+            duration = time.perf_counter() - start_time
+
+            if result and target_id:
+                msg = f"【定时任务执行结果】\n工具: {tool_name}\n结果:\n{result}"
+                if target_type == "group":
+                    await self.sender.send_group_message(target_id, msg)
+                else:
+                    await self.sender.send_private_message(target_id, msg)
+
+            logger.info(
+                f"[任务完成] 定时任务执行成功: ID={task_id}, 耗时={duration:.2f}s"
+            )
+
+            if task_id in self.tasks:
+                task_info = self.tasks[task_id]
+                task_info["current_executions"] = (
+                    task_info.get("current_executions", 0) + 1
+                )
+
+                # 持久化保存执行次数
+                self.storage.save_all(self.tasks)
+
+                max_executions = task_info.get("max_executions")
+                current_executions = task_info.get("current_executions", 0)
+
+                if max_executions is not None and current_executions >= max_executions:
+                    self.remove_task(task_id)
+                    logger.info(
+                        f"定时任务 {task_id} 已达到最大执行次数 {max_executions}，已自动删除"
+                    )
+
+        except Exception as e:
+            logger.exception(f"定时任务执行出错: {e}")
+            if target_id:
+                try:
+                    err_msg = f"【定时任务执行失败】\n工具: {tool_name}\n错误: {e}"
+                    if target_type == "group":
+                        await self.sender.send_group_message(target_id, err_msg)
+                    else:
+                        await self.sender.send_private_message(target_id, err_msg)
+                except Exception:
+                    pass