better:日志系统现已可以动态更新

src/common/logger.py

@@ -122,6 +122,23 @@ SENDER_STYLE_CONFIG = {
     },
 }
 
+SCHEDULE_STYLE_CONFIG = {
+    "advanced": {
+        "console_format": (
+            "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+            "<level>{level: <8}</level> | "
+            "<cyan>{extra[module]: <12}</cyan> | "
+            "<light-yellow>在干嘛</light-yellow> | "
+            "<level>{message}</level>"
+        ),
+        "file_format": ("{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 在干嘛 | {message}"),
+    },
+    "simple": {
+        "console_format": ("<green>{time:MM-DD HH:mm}</green> | <cyan>在干嘛</cyan> | <cyan>{message}</cyan>"),
+        "file_format": ("{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 在干嘛 | {message}"),
+    },
+}
+
 LLM_STYLE_CONFIG = {
     "advanced": {
         "console_format": (
@@ -183,6 +200,7 @@ SENDER_STYLE_CONFIG = SENDER_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else SENDER
 LLM_STYLE_CONFIG = LLM_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else LLM_STYLE_CONFIG["advanced"]
 CHAT_STYLE_CONFIG = CHAT_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else CHAT_STYLE_CONFIG["advanced"]
 MOOD_STYLE_CONFIG = MOOD_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else MOOD_STYLE_CONFIG["advanced"]
+SCHEDULE_STYLE_CONFIG = SCHEDULE_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else SCHEDULE_STYLE_CONFIG["advanced"]
 
 def is_registered_module(record: dict) -> bool:
     """检查是否为已注册的模块"""

src/plugins/chat/__init__.py

@@ -79,10 +79,14 @@ async def start_background_tasks():
 
     # 只启动表情包管理任务
     asyncio.create_task(emoji_manager.start_periodic_check())
-    await bot_schedule.initialize()
-    bot_schedule.print_schedule()
 
 
+@driver.on_startup
+async def init_schedule():
+    """在 NoneBot2 启动时初始化日程系统"""
+    bot_schedule.initialize(name=global_config.BOT_NICKNAME, personality=global_config.PROMPT_PERSONALITY, behavior=global_config.PROMPT_SCHEDULE_GEN, interval=global_config.SCHEDULE_DOING_UPDATE_INTERVAL)
+    asyncio.create_task(bot_schedule.mai_schedule_start())
+
 @driver.on_startup
 async def init_relationships():
     """在 NoneBot2 启动时初始化关系管理器"""
@@ -157,13 +161,13 @@ async def print_mood_task():
     mood_manager.print_mood_status()
 
 
-@scheduler.scheduled_job("interval", seconds=7200, id="generate_schedule")
+# @scheduler.scheduled_job("interval", seconds=7200, id="generate_schedule")
-async def generate_schedule_task():
+# async def generate_schedule_task():
-    """每2小时尝试生成一次日程"""
+#     """每2小时尝试生成一次日程"""
-    logger.debug("尝试生成日程")
+#     logger.debug("尝试生成日程")
-    await bot_schedule.initialize()
+#     await bot_schedule.initialize()
-    if not bot_schedule.enable_output:
+#     if not bot_schedule.enable_output:
-        bot_schedule.print_schedule()
+#         bot_schedule.print_schedule()
 
 
 @scheduler.scheduled_job("interval", seconds=3600, id="remove_recalled_message")

src/plugins/chat/config.py

@@ -42,6 +42,7 @@ class BotConfig:
     # schedule
     ENABLE_SCHEDULE_GEN: bool = False  # 是否启用日程生成
     PROMPT_SCHEDULE_GEN = "无日程"
+    SCHEDULE_DOING_UPDATE_INTERVAL: int = 300  # 日程表更新间隔 单位秒
 
     # message
     MAX_CONTEXT_SIZE: int = 15  # 上下文最大消息数
@@ -219,6 +220,8 @@ class BotConfig:
             schedule_config = parent["schedule"]
             config.ENABLE_SCHEDULE_GEN = schedule_config.get("enable_schedule_gen", config.ENABLE_SCHEDULE_GEN)
             config.PROMPT_SCHEDULE_GEN = schedule_config.get("prompt_schedule_gen", config.PROMPT_SCHEDULE_GEN)
+            config.SCHEDULE_DOING_UPDATE_INTERVAL = schedule_config.get(
+                "schedule_doing_update_interval", config.SCHEDULE_DOING_UPDATE_INTERVAL)
             logger.info(
                 f"载入自定义日程prompt:{schedule_config.get('prompt_schedule_gen', config.PROMPT_SCHEDULE_GEN)}")
 

src/plugins/chat/llm_generator.py

@@ -51,13 +51,13 @@ class ResponseGenerator:
         # 从global_config中获取模型概率值并选择模型
         rand = random.random()
         if rand < global_config.MODEL_R1_PROBABILITY:
-            self.current_model_type = "r1"
+            self.current_model_type = "深深地"
             current_model = self.model_r1
         elif rand < global_config.MODEL_R1_PROBABILITY + global_config.MODEL_V3_PROBABILITY:
-            self.current_model_type = "v3"
+            self.current_model_type = "浅浅的"
             current_model = self.model_v3
         else:
-            self.current_model_type = "r1_distill"
+            self.current_model_type = "又浅又浅的"
             current_model = self.model_r1_distill
 
         logger.info(f"{global_config.BOT_NICKNAME}{self.current_model_type}思考中")

src/plugins/chat/prompt_builder.py

@@ -57,9 +57,7 @@ class PromptBuilder:
         mood_prompt = mood_manager.get_prompt()
 
         # 日程构建
-        # current_date = time.strftime("%Y-%m-%d", time.localtime())
+        schedule_prompt = f'''你现在正在做的事情是：{bot_schedule.get_current_num_task(num = 1,time_info = False)}'''
-        # current_time = time.strftime("%H:%M:%S", time.localtime())
-        # bot_schedule_now_time, bot_schedule_now_activity = bot_schedule.get_current_task()
 
         # 获取聊天上下文
         chat_in_group = True
@@ -173,8 +171,6 @@ class PromptBuilder:
         prompt_check_if_response = ""
         
         
-        # print(prompt)
-        
         return prompt, prompt_check_if_response
 
     def _build_initiative_prompt_select(self, group_id, probability_1=0.8, probability_2=0.1):

src/plugins/schedule/offline_llm.py

@@ -30,7 +30,7 @@ class LLMModel:
         data = {
             "model": self.model_name,
             "messages": [{"role": "user", "content": prompt}],
-            "temperature": 0.5,
+            "temperature": 0.7,
             **self.params,
         }
 

src/plugins/schedule/schedule_generator.py

@@ -1,159 +1,149 @@
 import datetime
-import json
+import os
-import re
+import sys
-from typing import Dict, Union
+from typing import Dict
-
+import asyncio
-from nonebot import get_driver
-
 # 添加项目根目录到 Python 路径
+root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
+sys.path.append(root_path)
 
-from src.plugins.chat.config import global_config
+from src.common.database import db # noqa: E402
-from ...common.database import db  # 使用正确的导入语法
+from src.common.logger import get_module_logger, SCHEDULE_STYLE_CONFIG, LogConfig # noqa: E402
-from ..models.utils_model import LLM_request
+from src.plugins.models.utils_model import LLM_request # noqa: E402
-from src.common.logger import get_module_logger
+from src.plugins.chat.config import global_config # noqa: E402
 
-logger = get_module_logger("scheduler")
 
-driver = get_driver()
+schedule_config = LogConfig(
-config = driver.config
+    # 使用海马体专用样式
+    console_format=SCHEDULE_STYLE_CONFIG["console_format"],
+    file_format=SCHEDULE_STYLE_CONFIG["file_format"],
+)   
+logger = get_module_logger("scheduler", config=schedule_config)
 
 
 class ScheduleGenerator:
-    enable_output: bool = True
+    # enable_output: bool = True
+
+    def __init__(self, ):
+        # 使用离线LLM模型
+        self.llm_scheduler_all = LLM_request(
+            model= global_config.llm_reasoning, temperature=0.9, max_tokens=2048,request_type="schedule")
+        self.llm_scheduler_doing = LLM_request(
+            model= global_config.llm_normal, temperature=0.9, max_tokens=2048,request_type="schedule")
         
-    def __init__(self):
-        # 根据global_config.llm_normal这一字典配置指定模型
-        # self.llm_scheduler = LLMModel(model = global_config.llm_normal,temperature=0.9)
-        self.llm_scheduler = LLM_request(model=global_config.llm_normal, temperature=0.9, request_type="scheduler")
         self.today_schedule_text = ""
-        self.today_schedule = {}
+        self.today_done_list = []
-        self.tomorrow_schedule_text = ""
+
-        self.tomorrow_schedule = {}
         self.yesterday_schedule_text = ""
-        self.yesterday_schedule = {}
+        self.yesterday_done_list = []
 
-    async def initialize(self):
+        self.name = ""
+        self.personality = ""
+        self.behavior = ""
+
+        self.start_time = datetime.datetime.now()
+        
+        self.schedule_doing_update_interval = 60 #最好大于60
+    
+    def initialize(self,name: str = "bot_name", personality: str = "你是一个爱国爱党的新时代青年", behavior: str = "你非常外向，喜欢尝试新事物和人交流",interval: int = 60):
+        """初始化日程系统"""
+        self.name = name
+        self.behavior = behavior
+        self.schedule_doing_update_interval = interval
+        
+        for pers in personality:
+            self.personality += pers + "\n"
+        
+
+    async def mai_schedule_start(self):
+        """启动日程系统，每5分钟执行一次move_doing，并在日期变化时重新检查日程"""
+        try:
+            logger.info(f"日程系统启动/刷新时间: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+            # 初始化日程
+            await self.check_and_create_today_schedule()
+            self.print_schedule()
+            
+            while True:
+                print(self.get_current_num_task(1, True))
+                
+                current_time = datetime.datetime.now()
+                
+                # 检查是否需要重新生成日程（日期变化）
+                if current_time.date() != self.start_time.date():
+                    logger.info("检测到日期变化，重新生成日程")
+                    self.start_time = current_time
+                    await self.check_and_create_today_schedule()
+                    self.print_schedule()
+                
+                # 执行当前活动
+                current_activity = await self.move_doing(mind_thinking="")
+                logger.info(f"当前活动: {current_activity}")
+                
+                await asyncio.sleep(self.schedule_doing_update_interval) 
+                
+        except Exception as e:
+            logger.error(f"日程系统运行时出错: {str(e)}")
+            logger.exception("详细错误信息：")
+
+    async def check_and_create_today_schedule(self):
+        """检查昨天的日程，并确保今天有日程安排
+        
+        Returns:
+            tuple: (today_schedule_text, today_schedule) 今天的日程文本和解析后的日程字典
+        """
         today = datetime.datetime.now()
-        tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
+        yesterday = today - datetime.timedelta(days=1)
-        yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
         
-        self.today_schedule_text, self.today_schedule = await self.generate_daily_schedule(target_date=today)
+        # 先检查昨天的日程
-        self.tomorrow_schedule_text, self.tomorrow_schedule = await self.generate_daily_schedule(
+        self.yesterday_schedule_text, self.yesterday_done_list = self.load_schedule_from_db(yesterday)
-            target_date=tomorrow, read_only=True
+        if self.yesterday_schedule_text:
-        )
+            logger.debug(f"已加载{yesterday.strftime('%Y-%m-%d')}的日程")
-        self.yesterday_schedule_text, self.yesterday_schedule = await self.generate_daily_schedule(
-            target_date=yesterday, read_only=True
-        )
         
-    async def generate_daily_schedule(
+        # 检查今天的日程
-        self, target_date: datetime.datetime = None, read_only: bool = False
+        self.today_schedule_text, self.today_done_list = self.load_schedule_from_db(today)
-    ) -> Dict[str, str]:
+        if not self.today_done_list:
+            self.today_done_list = []
+        if not self.today_schedule_text:
+            logger.info(f"{today.strftime('%Y-%m-%d')}的日程不存在，准备生成新的日程")
+            self.today_schedule_text = await self.generate_daily_schedule(target_date=today)
+
+        self.save_today_schedule_to_db()
+    
+    def construct_daytime_prompt(self, target_date: datetime.datetime):
         date_str = target_date.strftime("%Y-%m-%d")
         weekday = target_date.strftime("%A")
 
-        schedule_text = str
+        prompt =  f"你是{self.name}，{self.personality}，{self.behavior}"
+        prompt += f"你昨天的日程是：{self.yesterday_schedule_text}\n"
+        prompt += f"请为你生成{date_str}（{weekday}）的日程安排，结合你的个人特点和行为习惯\n"
+        prompt += "推测你的日程安排，包括你一天都在做什么，有什么发现和思考，具体一些，详细一些，需要1500字以上，精确到每半个小时，记得写明时间\n"
+        prompt += "直接返回你的日程，不要输出其他内容："
+        return prompt
     
-        existing_schedule = db.schedule.find_one({"date": date_str})
+    def construct_doing_prompt(self,time: datetime.datetime,mind_thinking: str = ""):
-        if existing_schedule:
+        now_time = time.strftime("%H:%M")
-            if self.enable_output:
+        if self.today_done_list:
-                logger.debug(f"{date_str}的日程已存在:")
+            previous_doings = self.get_current_num_task(10, True)
-            schedule_text = existing_schedule["schedule"]
+            # print(previous_doings)
-            # print(self.schedule_text)
-
-        elif not read_only:
-            logger.debug(f"{date_str}的日程不存在，准备生成新的日程。")
-            prompt = (
-                f"""我是{global_config.BOT_NICKNAME}，{global_config.PROMPT_SCHEDULE_GEN}，请为我生成{date_str}（{weekday}）的日程安排，包括："""
-                + """
-            1. 早上的学习和工作安排
-            2. 下午的活动和任务
-            3. 晚上的计划和休息时间
-            请按照时间顺序列出具体时间点和对应的活动，用一个时间点而不是时间段来表示时间，用JSON格式返回日程表，
-            仅返回内容，不要返回注释，不要添加任何markdown或代码块样式，时间采用24小时制，
-            格式为{"时间": "活动","时间": "活动",...}。"""
-            )
-
-            try:
-                schedule_text, _, _ = await self.llm_scheduler.generate_response(prompt)
-                db.schedule.insert_one({"date": date_str, "schedule": schedule_text})
-                self.enable_output = True
-            except Exception as e:
-                logger.error(f"生成日程失败: {str(e)}")
-                schedule_text = "生成日程时出错了"
-            # print(self.schedule_text)
         else:
-            if self.enable_output:
+            previous_doings = "你没做什么事情"
-                logger.debug(f"{date_str}的日程不存在。")
-            schedule_text = "忘了"
             
-            return schedule_text, None
         
-        schedule_form = self._parse_schedule(schedule_text)
+        prompt = f"你是{self.name}，{self.personality}，{self.behavior}"
-        return schedule_text, schedule_form
+        prompt += f"你今天的日程是：{self.today_schedule_text}\n"
+        if mind_thinking:
+            prompt += f"你脑子里在想：{mind_thinking}\n"
+        prompt += f"你之前做了的事情是：{previous_doings}，从之前到现在已经过去了{self.schedule_doing_update_interval/60}分钟了\n"
+        prompt += f"现在是{now_time}，结合你的个人特点和行为习惯,"
+        prompt += "推测你现在做什么，具体一些，详细一些\n"
+        prompt += "直接返回你在做的事情，不要输出其他内容："
+        return prompt
     
-    def _parse_schedule(self, schedule_text: str) -> Union[bool, Dict[str, str]]:
+    async def generate_daily_schedule(
-        """解析日程文本，转换为时间和活动的字典"""
+        self, target_date: datetime.datetime = None,) -> Dict[str, str]:
-        try:
+        daytime_prompt = self.construct_daytime_prompt(target_date)
-            reg = r"\{(.|\r|\n)+\}"
+        daytime_response,_ = await self.llm_scheduler_all.generate_response_async(daytime_prompt)
-            matched = re.search(reg, schedule_text)[0]
+        return daytime_response
-            schedule_dict = json.loads(matched)
-            self._check_schedule_validity(schedule_dict)
-            return schedule_dict
-        except json.JSONDecodeError:
-            logger.exception("解析日程失败: {}".format(schedule_text))
-            return False
-        except ValueError as e:
-            logger.exception(f"解析日程失败: {str(e)}")
-            return False
-        except Exception as e:
-            logger.exception(f"解析日程发生错误:{str(e)}")
-            return False
-
-    def _check_schedule_validity(self, schedule_dict: Dict[str, str]):
-        """检查日程是否合法"""
-        if not schedule_dict:
-            return
-        for time_str in schedule_dict.keys():
-            try:
-                self._parse_time(time_str)
-            except ValueError:
-                raise ValueError("日程时间格式不正确") from None
-
-    def _parse_time(self, time_str: str) -> str:
-        """解析时间字符串，转换为时间"""
-        return datetime.datetime.strptime(time_str, "%H:%M")
-
-    def get_current_task(self) -> str:
-        """获取当前时间应该进行的任务"""
-        current_time = datetime.datetime.now().strftime("%H:%M")
-
-        # 找到最接近当前时间的任务
-        closest_time = None
-        min_diff = float("inf")
-
-        # 检查今天的日程
-        if not self.today_schedule:
-            return "摸鱼"
-        for time_str in self.today_schedule.keys():
-            diff = abs(self._time_diff(current_time, time_str))
-            if closest_time is None or diff < min_diff:
-                closest_time = time_str
-                min_diff = diff
-
-        # 检查昨天的日程中的晚间任务
-        if self.yesterday_schedule:
-            for time_str in self.yesterday_schedule.keys():
-                if time_str >= "20:00":  # 只考虑晚上8点之后的任务
-                    # 计算与昨天这个时间点的差异（需要加24小时）
-                    diff = abs(self._time_diff(current_time, time_str))
-                    if diff < min_diff:
-                        closest_time = time_str
-                        min_diff = diff
-                        return closest_time, self.yesterday_schedule[closest_time]
-
-        if closest_time:
-            return closest_time, self.today_schedule[closest_time]
-        return "摸鱼"
 
     def _time_diff(self, time1: str, time2: str) -> int:
         """计算两个时间字符串之间的分钟差"""
@@ -174,14 +164,127 @@ class ScheduleGenerator:
 
     def print_schedule(self):
         """打印完整的日程安排"""
-        if not self._parse_schedule(self.today_schedule_text):
+        if not self.today_schedule_text:
-            logger.warning("今日日程有误，将在两小时后重新生成")
+            logger.warning("今日日程有误，将在下次运行时重新生成")
             db.schedule.delete_one({"date": datetime.datetime.now().strftime("%Y-%m-%d")})
         else:
             logger.info("=== 今日日程安排 ===")
-            for time_str, activity in self.today_schedule.items():
+            logger.info(self.today_schedule_text)
-                logger.info(f"时间[{time_str}]: 活动[{activity}]")
             logger.info("==================")
             self.enable_output = False
+
+    async def update_today_done_list(self):
+        # 更新数据库中的 today_done_list
+        today_str = datetime.datetime.now().strftime("%Y-%m-%d")
+        existing_schedule = db.schedule.find_one({"date": today_str})
+        
+        if existing_schedule:
+            # 更新数据库中的 today_done_list
+            db.schedule.update_one(
+                {"date": today_str},
+                {"$set": {"today_done_list": self.today_done_list}}
+            )
+            logger.debug(f"已更新{today_str}的已完成活动列表")
+        else:
+            logger.warning(f"未找到{today_str}的日程记录")
+
+    async def move_doing(self,mind_thinking: str = ""):
+        current_time = datetime.datetime.now()
+        doing_prompt = self.construct_doing_prompt(current_time,mind_thinking)
+        doing_response,_ = await self.llm_scheduler_doing.generate_response_async(doing_prompt)
+        self.today_done_list.append((current_time,doing_response))
+
+        await self.update_today_done_list()
+        
+        return doing_response
+
+    async def get_task_from_time_to_time(self, start_time: str, end_time: str):
+        """获取指定时间范围内的任务列表
+        
+        Args:
+            start_time (str): 开始时间，格式为"HH:MM"
+            end_time (str): 结束时间，格式为"HH:MM"
+            
+        Returns:
+            list: 时间范围内的任务列表
+        """
+        result = []
+        for task in self.today_done_list:
+            task_time = task[0]  # 获取任务的时间戳
+            task_time_str = task_time.strftime("%H:%M")
+            
+            # 检查任务时间是否在指定范围内
+            if self._time_diff(start_time, task_time_str) >= 0 and self._time_diff(task_time_str, end_time) >= 0:
+                result.append(task)
+        
+        return result
+
+    def get_current_num_task(self, num=1, time_info = False):
+        """获取最新加入的指定数量的日程
+        
+        Args:
+            num (int): 需要获取的日程数量，默认为1
+            
+        Returns:
+            list: 最新加入的日程列表
+        """
+        if not self.today_done_list:
+            return []
+            
+        # 确保num不超过列表长度
+        num = min(num, len(self.today_done_list))
+        pre_doings = ""
+        for doing in self.today_done_list[-num:]:
+            
+            if time_info:
+                time_str = doing[0].strftime("%H:%M")
+                pre_doings += time_str + "时，" + doing[1] + "\n"
+            else:
+                pre_doings += doing[1] + "\n"
+
+        # 返回最新的num条日程
+        return pre_doings
+
+    def save_today_schedule_to_db(self):
+        """保存日程到数据库，同时初始化 today_done_list"""
+        date_str = datetime.datetime.now().strftime("%Y-%m-%d")
+        schedule_data = {
+            "date": date_str,
+            "schedule": self.today_schedule_text,
+            "today_done_list": self.today_done_list if hasattr(self, 'today_done_list') else []
+        }
+        # 使用 upsert 操作，如果存在则更新，不存在则插入
+        db.schedule.update_one(
+            {"date": date_str},
+            {"$set": schedule_data},
+            upsert=True
+        )
+        logger.debug(f"已保存{date_str}的日程到数据库")
+
+    def load_schedule_from_db(self, date: datetime.datetime):
+        """从数据库加载日程，同时加载 today_done_list"""
+        date_str = date.strftime("%Y-%m-%d")
+        existing_schedule = db.schedule.find_one({"date": date_str})
+        
+        if existing_schedule:
+            schedule_text = existing_schedule["schedule"]
+            return schedule_text, existing_schedule.get("today_done_list", [])
+        else:
+            logger.debug(f"{date_str}的日程不存在")
+            return None, None
+
+async def main():
+    # 使用示例
+    scheduler = ScheduleGenerator()
+    scheduler.initialize(name="麦麦", personality="你叫麦麦，你19岁，是一个大二的女大学生，你有一头黑色短发，你会刷贴吧，你现在在学习心理学", behavior="你比较内向，一般熬夜比较晚，然后第二天早上10点起床吃早午饭",interval=60)
+    await scheduler.mai_schedule_start()
+    
+
+
 # 当作为组件导入时使用的实例
 bot_schedule = ScheduleGenerator()
+
+if __name__ == "__main__":
+    import asyncio
+    # 当直接运行此文件时执行
+    asyncio.run(main())

src/plugins/schedule/schedule_generator_pro.py

@@ -1,264 +0,0 @@
-import datetime
-import json
-import re
-import os
-import sys
-from typing import Dict, Union
-# 添加项目根目录到 Python 路径
-root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
-sys.path.append(root_path)
-
-from src.common.database import db # noqa: E402
-from src.common.logger import get_module_logger # noqa: E402
-from src.plugins.schedule.offline_llm import LLMModel # noqa: E402
-
-logger = get_module_logger("scheduler")
-
-
-class ScheduleGenerator:
-    enable_output: bool = True
-
-    def __init__(self, name: str = "bot_name", personality: str = "你是一个爱国爱党的新时代青年", behavior: str = "你非常外向，喜欢尝试新事物和人交流"):
-        # 使用离线LLM模型
-        self.llm_scheduler = LLMModel(model_name="Qwen/Qwen2.5-32B-Instruct", temperature=0.9)
-        
-        self.today_schedule_text = ""
-        self.today_done_list = []
-
-        self.yesterday_schedule_text = ""
-        self.yesterday_done_list = []
-
-        self.name = name
-        self.personality = personality
-        self.behavior = behavior
-
-        self.start_time = datetime.datetime.now()
-        
-        self.schedule_doing_update_interval = 60 #最好大于60
-
-    async def mai_schedule_start(self):
-        """启动日程系统，每5分钟执行一次move_doing，并在日期变化时重新检查日程"""
-        try:
-            logger.info(f"日程系统启动/刷新时间: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
-            # 初始化日程
-            await self.check_and_create_today_schedule()
-            self.print_schedule()
-            
-            while True:
-                print(self.get_current_num_task(1, True))
-                
-                current_time = datetime.datetime.now()
-                
-                # 检查是否需要重新生成日程（日期变化）
-                if current_time.date() != self.start_time.date():
-                    logger.info("检测到日期变化，重新生成日程")
-                    self.start_time = current_time
-                    await self.check_and_create_today_schedule()
-                    self.print_schedule()
-                
-                # 执行当前活动
-                current_activity = await self.move_doing()
-                logger.info(f"当前活动: {current_activity}")
-                
-                await asyncio.sleep(self.schedule_doing_update_interval) 
-                
-        except Exception as e:
-            logger.error(f"日程系统运行时出错: {str(e)}")
-            logger.exception("详细错误信息：")
-
-    async def check_and_create_today_schedule(self):
-        """检查昨天的日程，并确保今天有日程安排
-        
-        Returns:
-            tuple: (today_schedule_text, today_schedule) 今天的日程文本和解析后的日程字典
-        """
-        today = datetime.datetime.now()
-        yesterday = today - datetime.timedelta(days=1)
-        
-        # 先检查昨天的日程
-        self.yesterday_schedule_text, self.yesterday_done_list = self.load_schedule_from_db(yesterday)
-        if self.yesterday_schedule_text:
-            logger.debug(f"已加载{yesterday.strftime('%Y-%m-%d')}的日程")
-        
-        # 检查今天的日程
-        self.today_schedule_text, self.today_done_list = self.load_schedule_from_db(today)
-        if not self.today_done_list:
-            self.today_done_list = []
-        if not self.today_schedule_text:
-            logger.info(f"{today.strftime('%Y-%m-%d')}的日程不存在，准备生成新的日程")
-            self.today_schedule_text = await self.generate_daily_schedule(target_date=today)
-
-        self.save_today_schedule_to_db()
-    
-    def construct_daytime_prompt(self, target_date: datetime.datetime):
-        date_str = target_date.strftime("%Y-%m-%d")
-        weekday = target_date.strftime("%A")
-
-        prompt =  f"我是{self.name}，{self.personality}，{self.behavior}"
-        prompt += f"我昨天的日程是：{self.yesterday_schedule_text}\n"
-        prompt += f"请为我生成{date_str}（{weekday}）的日程安排，结合我的个人特点和行为习惯\n"
-        prompt += "推测我的日程安排，包括我一天都在做什么，有什么发现和思考，具体一些，详细一些，记得写明时间\n"
-        prompt += "直接返回我的日程，不要输出其他内容："
-        return prompt
-    
-    def construct_doing_prompt(self,time: datetime.datetime):
-        now_time = time.strftime("%H:%M")
-        if self.today_done_list:
-            previous_doing = self.get_current_num_task(10, True)
-            print(previous_doing)
-        else:
-            previous_doing = "我没做什么事情"
-            
-        
-        prompt = f"我是{self.name}，{self.personality}，{self.behavior}"
-        prompt += f"我今天的日程是：{self.today_schedule_text}\n"
-        prompt += f"我之前做了的事情是：{previous_doing}，从之前到现在已经过去了{self.schedule_doing_update_interval/60}分钟了\n"
-        prompt += f"现在是{now_time}，结合我的个人特点和行为习惯,"
-        prompt += "推测我现在做什么，具体一些，详细一些\n"
-        prompt += "直接返回我在做的事情，不要输出其他内容："
-        return prompt
-    
-    async def generate_daily_schedule(
-        self, target_date: datetime.datetime = None,) -> Dict[str, str]:
-        daytime_prompt = self.construct_daytime_prompt(target_date)
-        daytime_response,_ = await self.llm_scheduler.generate_response_async(daytime_prompt)
-        return daytime_response
-
-    def _time_diff(self, time1: str, time2: str) -> int:
-        """计算两个时间字符串之间的分钟差"""
-        if time1 == "24:00":
-            time1 = "23:59"
-        if time2 == "24:00":
-            time2 = "23:59"
-        t1 = datetime.datetime.strptime(time1, "%H:%M")
-        t2 = datetime.datetime.strptime(time2, "%H:%M")
-        diff = int((t2 - t1).total_seconds() / 60)
-        # 考虑时间的循环性
-        if diff < -720:
-            diff += 1440  # 加一天的分钟
-        elif diff > 720:
-            diff -= 1440  # 减一天的分钟
-        # print(f"时间1[{time1}]: 时间2[{time2}]，差值[{diff}]分钟")
-        return diff
-
-    def print_schedule(self):
-        """打印完整的日程安排"""
-        if not self.today_schedule_text:
-            logger.warning("今日日程有误，将在下次运行时重新生成")
-            db.schedule.delete_one({"date": datetime.datetime.now().strftime("%Y-%m-%d")})
-        else:
-            logger.info("=== 今日日程安排 ===")
-            logger.info(self.today_schedule_text)
-            logger.info("==================")
-            self.enable_output = False
-
-    async def update_today_done_list(self):
-        # 更新数据库中的 today_done_list
-        today_str = datetime.datetime.now().strftime("%Y-%m-%d")
-        existing_schedule = db.schedule.find_one({"date": today_str})
-        
-        if existing_schedule:
-            # 更新数据库中的 today_done_list
-            db.schedule.update_one(
-                {"date": today_str},
-                {"$set": {"today_done_list": self.today_done_list}}
-            )
-            logger.debug(f"已更新{today_str}的已完成活动列表")
-        else:
-            logger.warning(f"未找到{today_str}的日程记录")
-
-    async def move_doing(self):
-        current_time = datetime.datetime.now()
-        time_str = current_time.strftime("%H:%M")
-        doing_prompt = self.construct_doing_prompt(current_time)
-        doing_response,_ = await self.llm_scheduler.generate_response_async(doing_prompt)
-        self.today_done_list.append((current_time, time_str + "时，" + doing_response))
-
-        await self.update_today_done_list()
-        
-        return doing_response
-
-    async def get_task_from_time_to_time(self, start_time: str, end_time: str):
-        """获取指定时间范围内的任务列表
-        
-        Args:
-            start_time (str): 开始时间，格式为"HH:MM"
-            end_time (str): 结束时间，格式为"HH:MM"
-            
-        Returns:
-            list: 时间范围内的任务列表
-        """
-        result = []
-        for task in self.today_done_list:
-            task_time = task[0]  # 获取任务的时间戳
-            task_time_str = task_time.strftime("%H:%M")
-            
-            # 检查任务时间是否在指定范围内
-            if self._time_diff(start_time, task_time_str) >= 0 and self._time_diff(task_time_str, end_time) >= 0:
-                result.append(task)
-        
-        return result
-
-    def get_current_num_task(self, num=1, time_info = False):
-        """获取最新加入的指定数量的日程
-        
-        Args:
-            num (int): 需要获取的日程数量，默认为1
-            
-        Returns:
-            list: 最新加入的日程列表
-        """
-        if not self.today_done_list:
-            return []
-            
-        # 确保num不超过列表长度
-        num = min(num, len(self.today_done_list))
-        pre_doing = ""
-        for doing in self.today_done_list[-num:]:
-            pre_doing += doing[1]
-        
-        # 返回最新的num条日程
-        return pre_doing
-
-    def save_today_schedule_to_db(self):
-        """保存日程到数据库，同时初始化 today_done_list"""
-        date_str = datetime.datetime.now().strftime("%Y-%m-%d")
-        schedule_data = {
-            "date": date_str,
-            "schedule": self.today_schedule_text,
-            "today_done_list": self.today_done_list if hasattr(self, 'today_done_list') else []
-        }
-        # 使用 upsert 操作，如果存在则更新，不存在则插入
-        db.schedule.update_one(
-            {"date": date_str},
-            {"$set": schedule_data},
-            upsert=True
-        )
-        logger.debug(f"已保存{date_str}的日程到数据库")
-
-    def load_schedule_from_db(self, date: datetime.datetime):
-        """从数据库加载日程，同时加载 today_done_list"""
-        date_str = date.strftime("%Y-%m-%d")
-        existing_schedule = db.schedule.find_one({"date": date_str})
-        
-        if existing_schedule:
-            schedule_text = existing_schedule["schedule"]
-            return schedule_text, existing_schedule.get("today_done_list", [])
-        else:
-            logger.debug(f"{date_str}的日程不存在")
-            return None, None
-
-async def main():
-    # 使用示例
-    scheduler = ScheduleGenerator(name="麦麦", personality="你叫麦麦，你19岁，是一个大二的女大学生，你有一头黑色短发，你会刷贴吧，你现在在学习心理学", behavior="你比较内向，一般熬夜比较晚，然后第二天早上10点起床吃早午饭")
-    await scheduler.mai_schedule_start()
-    
-
-
-# 当作为组件导入时使用的实例
-bot_schedule = ScheduleGenerator()
-
-if __name__ == "__main__":
-    import asyncio
-    # 当直接运行此文件时执行
-    asyncio.run(main())

src/think_flow_demo/current_mind.py

@@ -5,6 +5,8 @@ from src.plugins.models.utils_model import LLM_request
 from src.plugins.chat.config import global_config
 import re
 import time
+from src.plugins.schedule.schedule_generator import bot_schedule
+
 class CuttentState:
     def __init__(self):
         self.willing = 0
@@ -57,10 +59,12 @@ class SubHeartflow:
         personality_info = open("src/think_flow_demo/personality_info.txt", "r", encoding="utf-8").read()
         current_thinking_info = self.current_mind
         mood_info = self.current_state.mood
-        related_memory_info = 'memory'
+        related_memory_info = ''
         message_stream_info = self.outer_world.talking_summary
+        schedule_info = bot_schedule.get_current_num_task(num = 2,time_info = False)
         
         prompt = ""
+        prompt += f"你刚刚在做的事情是：{schedule_info}\n"
         # prompt += f"麦麦的总体想法是：{self.main_heartflow_info}\n\n"
         prompt += f"{personality_info}\n"
         prompt += f"现在你正在上网，和qq群里的网友们聊天，群里正在聊的话题是：{message_stream_info}\n"

src/think_flow_demo/heartflow.py

@@ -2,6 +2,7 @@ from .current_mind import SubHeartflow
 from src.plugins.moods.moods import MoodManager
 from src.plugins.models.utils_model import LLM_request
 from src.plugins.chat.config import global_config
+from src.plugins.schedule.schedule_generator import bot_schedule
 import asyncio
 
 class CuttentState:
@@ -30,8 +31,8 @@ class Heartflow:
 
     async def heartflow_start_working(self):
         while True:
-            # await self.do_a_thinking()
+            await self.do_a_thinking()
-            await asyncio.sleep(60)
+            await asyncio.sleep(900)
     
     async def do_a_thinking(self):
         print("麦麦大脑袋转起来了")
@@ -43,9 +44,11 @@ class Heartflow:
         related_memory_info = 'memory'
         sub_flows_info = await self.get_all_subheartflows_minds()
         
+        schedule_info = bot_schedule.get_current_num_task(num = 5,time_info = True)
+        
         prompt = ""
+        prompt += f"你刚刚在做的事情是：{schedule_info}\n"
         prompt += f"{personality_info}\n"
-        # prompt += f"现在你正在上网，和qq群里的网友们聊天，群里正在聊的话题是：{message_stream_info}\n"
         prompt += f"你想起来{related_memory_info}。"
         prompt += f"刚刚你的主要想法是{current_thinking_info}。"
         prompt += f"你还有一些小想法，因为你在参加不同的群聊天，是你正在做的事情：{sub_flows_info}\n"

template/bot_config_template.toml

@@ -43,6 +43,7 @@ personality_3_probability = 0.1 # 第三种人格出现概率，请确保三个
 [schedule]
 enable_schedule_gen = true # 是否启用日程表(尚未完成)
 prompt_schedule_gen = "用几句话描述描述性格特点或行动规律，这个特征会用来生成日程表"
+schedule_doing_update_interval = 900 # 日程表更新间隔 单位秒
 
 [message]
 max_context_size = 15 # 麦麦获得的上文数量，建议15，太短太长都会导致脑袋尖尖