foliko 1.0.10 → 1.0.13

package/.claude/settings.local.json

@@ -34,7 +34,10 @@
       "Bash(node -c plugins/default-plugins.js && node -c src/core/plugin-manager.js && echo \"Syntax OK\")",
       "Bash(node -c plugins/install-plugin.js && echo \"Syntax OK\")",
       "Bash(node -c cli/src/ui/chat-ui.js && echo \"Syntax OK\")",
-      "Bash(node -c plugins/default-plugins.js && echo \"Syntax OK\")"
+      "Bash(node -c plugins/default-plugins.js && echo \"Syntax OK\")",
+      "Bash(node -c plugins/scheduler-plugin.js && echo \"Syntax OK\")",
+      "Bash(node -c plugins/telegram-plugin.js && node -c plugins/scheduler-plugin.js && echo \"Syntax OK\")",
+      "Bash(node -c plugins/telegram-plugin.js && echo \"Syntax OK\")"
     ]
   }
 }

package/SPEC.md

@@ -304,8 +304,34 @@ const response = await agent.chat('你好')
 'agent:message'             // Agent消息
 'agent:tool-call'          // Agent调用工具
 'agent:tool-result'         // 工具执行结果
+'scheduler:task_created'   // 定时任务创建
+'scheduler:task_cancelled'  // 定时任务取消
+'scheduler:task_completed'  // 定时任务完成
+'scheduler:task_failed'     // 定时任务失败
+'scheduler:reminder'       // 定时提醒触发
+'think:thought_completed'  // 思考完成
+'think:reflection_needs_attention'  // 反思需要关注
 ```
 
+### 事件详情
+
+#### Scheduler 事件
+
+| 事件 | 数据 | 说明 |
+|------|------|------|
+| `scheduler:task_created` | `{ taskId, taskName, type, scheduleTime, cronExpression }` | 任务创建时触发 |
+| `scheduler:task_cancelled` | `{ taskId, taskName }` | 任务取消时触发 |
+| `scheduler:task_completed` | `{ taskId, taskName, type }` | 任务完成时触发 |
+| `scheduler:task_failed` | `{ taskId, taskName, error }` | 任务失败时触发 |
+| `scheduler:reminder` | `{ taskId, taskName, message, sessionId, llm }` | 提醒触发时触发 |
+
+#### Think 事件
+
+| 事件 | 数据 | 说明 |
+|------|------|------|
+| `think:thought_completed` | `thought` | 思考完成时触发 |
+| `think:reflection_needs_attention` | `{ thought, reason }` | 反思需要关注时触发 |
+
 ## 六、热重载机制
 
 ### 设计原则
@@ -384,6 +410,10 @@ agent.chat('请重载 my-plugin 插件')
 - 绑定主 Agent 持续对话
 - 支持 MarkdownV2
 - 图片/文档接收保存
+- 监听 `scheduler:reminder` 事件发送定时提醒
+
+**监听事件**：
+- `scheduler:reminder` - 接收定时任务提醒并发送到 Telegram
 
 **配置**：
 ```javascript
@@ -395,6 +425,53 @@ agent.chat('请重载 my-plugin 插件')
 }
 ```
 
+### 7.5 Scheduler Plugin (plugins/scheduler-plugin.js)
+
+**功能**：
+- 定时任务调度（Cron 表达式、相对时间、绝对时间）
+- 支持 LLM 自动检测（简单提醒直接显示，需要处理的任务启用 LLM）
+- 会话自动检测（自动发送到最近活跃的会话）
+- 事件系统（供其他插件监听和响应）
+
+**工具**：
+- `schedule_task` - 创建定时任务
+- `schedule_list` - 列出所有任务
+- `schedule_cancel` - 取消任务
+- `cron_examples` - Cron 表达式示例
+
+**schedule_task 参数**：
+```javascript
+{
+  name: '任务名称',           // 可选
+  scheduleTime: '10 minutes', // 必填，支持多种格式
+  message: '提醒内容',         // 必填
+  repeat: false,              // 可选，是否重复
+  cronExpression: '*/5 * * * *',  // 可选，Cron 表达式
+  sessionId: 'telegram_123', // 可选，会话 ID
+  llm: true                  // 可选，是否需要 LLM 处理（自动检测）
+}
+```
+
+**时间格式**：
+| 格式 | 示例 | 说明 |
+|------|------|------|
+| 相对时间 | `10 seconds`, `5 minutes`, `1 hour`, `2 days` | 多久后执行 |
+| 绝对时间 | `12:00`, `14:30:00` | 具体时间（次日开始） |
+| Cron | `*/5 * * * *`, `0 9 * * *` | Cron 表达式 |
+
+**自动 LLM 检测**：
+- 简单提醒（喝水、吃饭）→ 直接显示
+- 查询/分析任务（查看列表、分析数据）→ 启用 LLM
+
+**事件**：
+| 事件 | 时机 |
+|------|------|
+| `scheduler:task_created` | 任务创建时 |
+| `scheduler:task_cancelled` | 任务取消时 |
+| `scheduler:task_completed` | 任务完成时 |
+| `scheduler:task_failed` | 任务失败时 |
+| `scheduler:reminder` | 提醒触发时 |
+
 ## 八、使用示例
 
 ### 8.1 基础用法
@@ -491,7 +568,7 @@ class Framework {
 - [x] Session 管理 (`plugins/session-plugin.js`) - 多会话支持、历史记录
 - [x] Audit 审计日志 (`plugins/audit-plugin.js`) - 操作日志记录和查询
 - [x] Rules 规则引擎 (`plugins/rules-plugin.js`) - 权限控制、内容过滤
-- [x] Scheduler 定时任务 (`plugins/scheduler-plugin.js`) - Cron 调度
+- [x] Scheduler 定时任务 (`plugins/scheduler-plugin.js`) - Cron 调度、事件系统、自动 LLM 检测
 - [x] Storage 存储 (`plugins/storage-plugin.js`) - 键值对持久化存储
 - [x] SubAgent 子Agent (`plugins/subagent-plugin.js`) - 子Agent隔离工具集
 - [x] Email 插件 (`plugins/email.js`) - 邮件收发

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.0.10",
+  "version": "1.0.13",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "bin": {

package/plugins/scheduler-plugin.js

@@ -106,25 +106,60 @@ class SchedulerPlugin extends Plugin {
     // 注册调度工具
     framework.registerTool({
       name: 'schedule_task',
-      description: '设置定时提醒任务。支持多种时间格式：相对时间(1 minute, 2 hours)、具体时间(12:00)、Cron表达式(* * * * *)',
+      description: '设置定时提醒任务。支持多种时间格式：相对时间(1 minute, 2 hours)、具体时间(12:00)、Cron表达式(* * * * *)。系统会自动判断任务是否需要 LLM 处理。',
       inputSchema: z.object({
         name: z.string().optional().describe('任务名称'),
         scheduleTime: z.string().describe('执行时间。支持格式：\n- 相对时间: "1 minute", "2 hours", "1 day"\n- 具体时间: "12:00", "14:30"\n- Cron表达式: "*/5 * * * *" (每5分钟)'),
-        message: z.string().describe('提醒消息内容'),
+        message: z.string().describe('提醒消息内容。系统会自动判断：\n- 简单提醒（喝水、吃饭）直接显示\n- 需要查询/分析的任务（查看列表、分析数据）自动启用 LLM'),
         repeat: z.boolean().optional().describe('是否重复执行 (默认 false)'),
-        cronExpression: z.string().optional().describe('Cron 表达式 (当 repeat 为 true 时使用)')
+        cronExpression: z.string().optional().describe('Cron 表达式 (当 repeat 为 true 时使用)'),
+        sessionId: z.string().optional().describe('会话 ID（提醒将发送到该会话，不填则使用默认会话）'),
+        llm: z.boolean().optional().describe('是否需要 LLM 处理（自动检测，可手动覆盖）')
       }),
       execute: async (args) => {
         try {
-          const { scheduleTime, message, repeat, cronExpression } = args
+          const { scheduleTime, message, repeat, cronExpression, sessionId } = args
           const agent = this._getAgent()
           if (!agent) {
             return { success: false, error: 'Agent not available' }
           }
 
+          // 如果没有指定 sessionId，自动获取当前活跃会话
+          let targetSessionId = sessionId
+          if (!targetSessionId) {
+            const sessionPlugin = this._framework.pluginManager.get('session')
+            if (sessionPlugin) {
+              const sessions = sessionPlugin.listSessions()
+              // 获取最近的活跃会话
+              if (sessions.length > 0) {
+                // 按 lastActive 排序，取最新的
+                sessions.sort((a, b) => {
+                  const aTime = a.lastActive ? new Date(a.lastActive).getTime() : 0
+                  const bTime = b.lastActive ? new Date(b.lastActive).getTime() : 0
+                  return bTime - aTime
+                })
+                targetSessionId = sessions[0].id
+                console.log(`[Scheduler] Auto-detected active session: ${targetSessionId}`)
+              }
+            }
+          }
+
           const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
           let task
 
+          // 自动检测是否需要 LLM 处理
+          const LLM_KEYWORDS = [
+            '分析', '查询', '查看', '检查', '总结', '搜索', '获取',
+            'list', 'get', 'check', 'search', 'find', 'fetch',
+            '什么', '如何', '为什么', '什么时候', '多少', '谁',
+            '今天', '明天', '昨天', '这周', '这月', '今年'
+          ]
+          const messageLower = message.toLowerCase()
+          const needsLLM = args.llm === true || LLM_KEYWORDS.some(kw =>
+            message.includes(kw) || messageLower.includes(kw.toLowerCase())
+          )
+          const llmMode = needsLLM
+
           // 检测是否像 Cron 表达式
           const isCron = /^[\d*,\/-\s]+$/.test(scheduleTime) && scheduleTime.split(' ').length >= 5
 
@@ -144,7 +179,9 @@ class SchedulerPlugin extends Plugin {
               lastRun: null,
               runCount: 0,
               timer: null,
-              cronTask: null
+              cronTask: null,
+              sessionId: targetSessionId || null,
+              llm: llmMode
             }
 
             // 使用 node-cron 调度
@@ -164,7 +201,9 @@ class SchedulerPlugin extends Plugin {
               createdAt: new Date(),
               lastRun: null,
               runCount: 0,
-              timer: null
+              timer: null,
+              sessionId: targetSessionId || null,
+              llm: llmMode
             }
             task.timer = setTimeout(async () => {
               await this._executeTask(task)
@@ -186,7 +225,9 @@ class SchedulerPlugin extends Plugin {
               createdAt: new Date(),
               lastRun: null,
               runCount: 0,
-              timer: null
+              timer: null,
+              sessionId: targetSessionId || null,
+              llm: llmMode
             }
             task.timer = setTimeout(async () => {
               await this._executeTask(task)
@@ -196,6 +237,15 @@ class SchedulerPlugin extends Plugin {
           this._tasks.set(task.id, task)
           this._taskStats.total++
 
+          // 发送任务创建事件
+          this._framework.emit('scheduler:task_created', {
+            taskId: task.id,
+            taskName: task.name,
+            type: task.type,
+            scheduleTime,
+            cronExpression: task.cronExpression
+          })
+
           return {
             success: true,
             taskId: task.id,
@@ -203,7 +253,9 @@ class SchedulerPlugin extends Plugin {
             scheduleTime,
             executeAt: task.runAt ? task.runAt.toISOString() : null,
             cronExpression: task.cronExpression,
-            message: repeat ? '定时任务已创建 (重复执行)' : '提醒已设置'
+            message: repeat ? '定时任务已创建 (重复执行)' : '提醒已设置',
+            sessionId: sessionId || 'default',
+            llm: llmMode
           }
         } catch (err) {
           return { success: false, error: err.message }
@@ -249,7 +301,15 @@ class SchedulerPlugin extends Plugin {
           return { success: false, error: 'Task not found' }
         }
 
+        const taskName = task.name
         this._cancelTask(task)
+
+        // 发送任务取消事件
+        this._framework.emit('scheduler:task_cancelled', {
+          taskId: args.taskId,
+          taskName
+        })
+
         return { success: true, cancelled: args.taskId }
       }
     })
@@ -322,37 +382,61 @@ class SchedulerPlugin extends Plugin {
   }
 
   /**
-   * 执行任务 - 唤醒 Agent 发送消息
+   * 执行任务
    */
   async _executeTask(task) {
-    const agent = this._getAgent()
-    if (!agent) {
-      console.error('[Scheduler] Agent not available')
-      return
-    }
-
     console.log(`[Scheduler] Executing task: ${task.name} (${task.id})`)
     console.log(`[Scheduler] Message: ${task.message}`)
+    if (task.sessionId) {
+      console.log(`[Scheduler] Target session: ${task.sessionId}`)
+    }
+    console.log(`[Scheduler] LLM mode: ${task.llm ? 'enabled' : 'disabled'}`)
 
     task.lastRun = new Date()
     task.runCount++
     this._taskStats.running++
 
     try {
-      // 调用 Agent 的 chat 方法发送消息
-      const result = await agent.chat(task.message, {
-        isScheduledTask: true
-      })
+      if (task.llm) {
+        // LLM 模式：调用 Agent 处理
+        const agent = this._getAgent()
+        if (!agent) {
+          console.error('[Scheduler] Agent not available')
+          return
+        }
 
-      this._taskStats.completed++
+        const result = await agent.chat(task.message, {
+          isScheduledTask: true,
+          sessionId: task.sessionId
+        })
 
-      // 输出结果
-      if (result && result.message) {
-        console.log(`\n🔔 [定时提醒] ${result.message}\n`)
-      } else if (result && result.text) {
-        console.log(`\n🔔 [定时提醒] ${result.text}\n`)
+        this._taskStats.completed++
+
+        if (result && result.message) {
+          console.log(`\n🔔 [定时提醒] ${result.message}\n`)
+        } else if (result && result.text) {
+          console.log(`\n🔔 [定时提醒] ${result.text}\n`)
+        }
       } else {
+        // 直接显示模式：只显示提醒，不发 LLM
         console.log(`\n🔔 [定时提醒] ${task.message}\n`)
+
+        // 发送事件，让其他插件（如 telegram）处理通知
+        this._framework.emit('scheduler:reminder', {
+          taskId: task.id,
+          taskName: task.name,
+          message: task.message,
+          sessionId: task.sessionId,
+          llm: task.llm
+        })
+
+        this._framework.emit('scheduler:task_completed', {
+          taskId: task.id,
+          taskName: task.name,
+          type: task.type
+        })
+
+        this._taskStats.completed++
       }
 
       // 一次性任务执行后清理
@@ -360,11 +444,18 @@ class SchedulerPlugin extends Plugin {
         this._cleanupTask(task.id)
       }
 
-      return result
+      return { success: true }
     } catch (err) {
       this._taskStats.failed++
       console.error(`[Scheduler] Task ${task.name} failed: ${err.message}`)
 
+      // 发送任务失败事件
+      this._framework.emit('scheduler:task_failed', {
+        taskId: task.id,
+        taskName: task.name,
+        error: err.message
+      })
+
       // 一次性任务失败后也清理
       if (task.type === 'once' && !task.cronTask) {
         this._cleanupTask(task.id)

package/plugins/telegram-plugin.js

@@ -105,6 +105,12 @@ module.exports = function(Plugin) {
           this._framework.on('agent:created', (agent) => {
             console.log('[Telegram] New agent created:', agent.name)
           })
+
+          // 监听定时提醒事件
+          this._framework.on('scheduler:reminder', async (data) => {
+            console.log('[Telegram] Received scheduler reminder:', data)
+            await this._handleScheduledReminder(data)
+          })
         }
 
       } catch (err) {
@@ -112,6 +118,49 @@ module.exports = function(Plugin) {
       }
     }
 
+    /**
+     * 处理定时提醒
+     */
+    async _handleScheduledReminder(data) {
+      const { taskName, message, sessionId } = data
+
+      // 构建提醒消息
+      const reminderText = `🔔 [${taskName}]\n\n${message}`
+
+      // 如果有 sessionId 是 telegram 类型的，发送到对应 chat
+      if (sessionId && sessionId.startsWith('telegram_')) {
+        const chatId = sessionId.replace('telegram_', '')
+        try {
+          await this._bot.sendMessage(chatId, reminderText)
+          console.log(`[Telegram] Reminder sent to chat ${chatId}`)
+        } catch (err) {
+          console.error(`[Telegram] Failed to send reminder:`, err.message)
+        }
+        return
+      }
+
+      // 其他情况（包括 null 或其他 sessionId），发送到最近的 Telegram 会话
+      if (this._sessions.size > 0) {
+        // 按最后活跃时间排序
+        const sortedSessions = Array.from(this._sessions.entries())
+          .sort((a, b) => {
+            const aTime = a[1].lastActive ? new Date(a[1].lastActive).getTime() : 0
+            const bTime = b[1].lastActive ? new Date(b[1].lastActive).getTime() : 0
+            return bTime - aTime
+          })
+
+        const [chatId] = sortedSessions[0]
+        try {
+          await this._bot.sendMessage(chatId, reminderText)
+          console.log(`[Telegram] Reminder sent to chat ${chatId}`)
+        } catch (err) {
+          console.error(`[Telegram] Failed to send reminder to ${chatId}:`, err.message)
+        }
+      } else {
+        console.log('[Telegram] No active Telegram sessions to send reminder')
+      }
+    }
+
     /**
      * 获取主Agent
      */