koishi-plugin-ll-mc 2.0.0 → 2.1.0

package/index.js

@@ -1,55 +1,82 @@
 'use strict'
 
-// koishi-plugin-ll-mc v2.0.0（重做版）
-// 消息统计插件：群成员发言排行 + 跨群发言排行（群名正确）
-// 官方QQ机器人（官机）原生适配：
-//   - 昵称：优先取消息自带昵称（官机消息自带 member.nick / author.username，零API）
-//   - 群名：getGuild（需在QQ开放平台申请"获取群信息"权限）+ 配置手动指定兜底
-// 纯文本排行，不依赖 puppeteer/canvas/图片生成，任何环境都能跑
-
-const { Schema } = require('koishi')
+// koishi-plugin-ll-mc v2.1.0（照抄 astrbot_plugin_message_stats 功能 + 新增群排行）
+// 参考：https://github.com/xiaoruange39/astrbot_plugin_message_stats
+// 移植到 Koishi 的功能：
+//   - 发言榜（今日/昨日/本周/本月/本年/去年/总榜，文字或图片）
+//   - 群发言榜（新增：跨群排行，群名正确）
+//   - 我的发言 / 发言榜帮助
+//   - 设置发言榜数量 / 设置发言榜图片 / 清除发言榜单
+//   - 定时推送（自动 + 手动）
+// 官机（官方QQ）适配：昵称取消息自带，群名走 getGuild + groupNameMap 手动指定兜底
+
+const { Schema, h } = require('koishi')
 
 exports.name = 'll-mc'
 
-exports.usage = `消息统计插件：群成员发言排行 + 跨群发言排行。
+exports.usage = `消息统计插件（移植自 astrbot_plugin_message_stats，并新增群排行）。
 
 ## 命令
 
-- \`mc.排行 [周期] [人数]\`：本群成员发言排行。周期：今日/本周/本月/总榜（默认总榜），如 \`mc.排行 今日 10\`
-- \`mc.群排行 [周期] [人数]\`：所有群的发言排行（群名正确显示），当前群带 ★
-- \`mc.我的\`：自己的发言统计（今日/本周/本月/总榜）
+- \`发言榜 [周期] [人数]\`：本群成员发言排行。周期：今日/昨日/本周/本月/本年/去年/总榜（默认总榜）
+- \`群发言榜 [周期] [人数]\`：**所有群的发言排行（群名正确显示）**，当前群带 ★
+- \`今日发言榜\` / \`本周发言榜\` / \`本月发言榜\`：快捷查看
+- \`我的发言\`：自己的发言统计
+- \`设置发言榜数量 <N>\`：设置本群排行显示人数
+- \`设置发言榜图片 <auto|文字|图片>\`：设置本群排行显示模式（auto=有图片服务用图片，否则文字）
+- \`清除发言榜单\`：清空本群统计
+- \`手动推送发言榜 [周期]\`：立即向定时目标群推送排行
+- \`发言榜定时状态\`：查看定时推送配置
 
-## 官机（官方QQ机器人）说明
+## 定时推送（设置页配置）
 
-- **群名**：官机消息里不带群名，插件通过 \`getGuild\` 接口获取。需要在 QQ 开放平台申请「获取群信息」权限（否则群名显示为 openid）；也可以在配置 \`groupNameMap\` 里手动指定（键=群openid，值=群名），一次填好永久正确
-- **昵称**：官机消息自带昵称，无需接口权限；申请「获取群成员信息」后更完整
-- **群ID**：官机显示的是 openid，非数字群号，属正常现象
+- \`timerEnabled\`：启用后每天到点自动推送排行
+- \`timerTime\`：推送时间（HH:MM）
+- \`timerType\`：推送内容类型（day=昨日 / week=本周 / month=本月）
+- \`timerGroups\`：推送目标群（留空=推送给所有有数据的群）
 
-## 配置
+## 官机说明
 
-- \`rankLimit\`：排行默认显示人数
-- \`ignoredGroups\`：不统计的群（填群ID）
-- \`groupNameMap\`：手动指定群名（群openid → 群名）
-- \`refreshGroupNameInterval\`：群名刷新间隔（秒，默认3600）
-- \`countBots\`：是否统计机器人自己的发言（默认否）
+- **群名**：官机消息不带群名，插件用 \`getGuild\` 获取（需在 QQ 开放平台申请「获取群信息」权限）；也可在 \`groupNameMap\` 手动指定（openid → 群名），保证群排行群名正确
+- **昵称**：官机消息自带昵称，零接口权限
+- **图片排行**：需要安装 \`koishi-plugin-puppeteer\` 才显示图片，否则自动降级为文字
 `
 
 const Config = Schema.object({
   rankLimit: Schema.number()
     .min(1).max(100).default(20)
     .description('排行默认显示人数'),
+  imageMode: Schema.union([
+    Schema.const('auto').description('自动：有图片服务用图片，否则文字'),
+    Schema.const('text').description('始终文字'),
+    Schema.const('image').description('始终图片（无服务时降级文字）'),
+  ]).default('auto').description('排行显示模式'),
   ignoredGroups: Schema.array(String)
     .default([])
     .description('不统计的群（填群ID，官机填 openid）'),
   groupNameMap: Schema.dict(String)
     .default({})
-    .description('手动指定群名：键=群ID（官机填 openid），值=群名。用于官机无法自动获取群名时保证"群排行"群名正确'),
+    .description('手动指定群名：键=群ID（官机 openid），值=群名。保证群排行群名正确'),
   refreshGroupNameInterval: Schema.number()
     .min(60).default(3600)
-    .description('群名自动刷新间隔（秒）。官机获取群名需要"获取群信息"权限，无权限时只会尝试一次并降级'),
+    .description('群名自动刷新间隔（秒）'),
   countBots: Schema.boolean()
     .default(false)
     .description('是否统计机器人自己的发言'),
+  timerEnabled: Schema.boolean()
+    .default(false)
+    .description('定时推送：启用后每天到点自动推送排行'),
+  timerTime: Schema.string()
+    .default('00:00')
+    .description('定时推送时间（HH:MM，24小时制）'),
+  timerType: Schema.union([
+    Schema.const('day').description('昨日发言榜'),
+    Schema.const('week').description('本周发言榜'),
+    Schema.const('month').description('本月发言榜'),
+  ]).default('day').description('定时推送的内容类型'),
+  timerGroups: Schema.array(String)
+    .default([])
+    .description('定时推送目标群（留空=所有有数据的群）'),
   verbose: Schema.boolean()
     .default(false)
     .description('调试：控制台打印统计详情'),
@@ -63,7 +90,6 @@ function apply(ctx, config) {
   const logger = ctx.logger('ll-mc')
 
   // ===== 数据表 =====
-  // ll_mc_stats: 每群每人每天计数
   ctx.model.extend('ll_mc_stats', {
     channelId: 'string',
     userId: 'string',
@@ -71,18 +97,25 @@ function apply(ctx, config) {
     date: 'string',
     count: 'unsigned',
   }, { primary: ['channelId', 'userId', 'date'] })
-  // ll_mc_groups: 群名缓存（channelId -> 群名）
   ctx.model.extend('ll_mc_groups', {
     channelId: 'string',
     name: 'string',
     platform: 'string',
+    botSid: 'string',
     updatedAt: 'timestamp',
   }, { primary: ['channelId'] })
+  ctx.model.extend('ll_mc_settings', {
+    channelId: 'string',
+    rankLimit: 'unsigned',
+    imageMode: 'string',
+  }, { primary: ['channelId'] })
 
-  // ===== 内存缓存 =====
-  const nameCache = new Map()       // channelId -> { name, t }
-  const lastNameRefresh = new Map() // channelId -> timestamp
-  const warnThrottle = new Map()    // key -> timestamp（同类警告10分钟一次）
+  // ===== 缓存 =====
+  const nameCache = new Map()
+  const settingsCache = new Map()
+  const lastNameRefresh = new Map()
+  const warnThrottle = new Map()
+  let firedTimer = { date: '' }
 
   function throttledWarn(key, message) {
     const now = Date.now()
@@ -95,36 +128,47 @@ function apply(ctx, config) {
   function dateStr(d) {
     return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
   }
-  function todayStr() {
-    return dateStr(new Date())
+  function nowHM() {
+    const d = new Date()
+    return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
   }
-  // 解析周期：返回 { key, label, start }，start 为日期范围起点（含当天），null=全部
+  // 解析周期 → { key, label, start, end }（end 可空）
   function parsePeriod(period) {
     const p = String(period || '').trim()
     const now = new Date()
-    if (!p || /总|全部|all/i.test(p)) return { key: 'all', label: '总榜', start: null }
-    if (/周/.test(p)) {
+    if (!p || /总|全部|all/i.test(p)) return { key: 'all', label: '总榜', start: null, end: null }
+    if (/去年/.test(p)) {
+      const y = now.getFullYear() - 1
+      return { key: 'lastyear', label: '去年', start: `${y}-01-01`, end: `${y}-12-31` }
+    }
+    if (/本年|今年|年/.test(p)) {
+      return { key: 'year', label: '本年', start: `${now.getFullYear()}-01-01`, end: null }
+    }
+    if (/本?周/.test(p)) {
       const d = new Date(now)
-      d.setDate(d.getDate() - ((d.getDay() + 6) % 7)) // 周一
-      return { key: 'week', label: '本周', start: dateStr(d) }
+      d.setDate(d.getDate() - ((d.getDay() + 6) % 7))
+      return { key: 'week', label: '本周', start: dateStr(d), end: null }
+    }
+    if (/本?月/.test(p)) {
+      return { key: 'month', label: '本月', start: `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-01`, end: null }
     }
-    if (/月/.test(p)) {
-      return { key: 'month', label: '本月', start: `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-01` }
+    if (/昨|昨天|昨日/.test(p)) {
+      const d = new Date(now)
+      d.setDate(d.getDate() - 1)
+      return { key: 'yesterday', label: '昨日', start: dateStr(d), end: dateStr(d) }
     }
-    if (/日|天/.test(p)) return { key: 'day', label: '今日', start: todayStr() }
+    if (/今|今?日|天/.test(p)) return { key: 'day', label: '今日', start: dateStr(now), end: dateStr(now) }
     return null
   }
 
-  // ===== 昵称解析（官机优先取消息自带） =====
+  // ===== 昵称解析 =====
   async function resolveNick(session, userId) {
     const author = session.author
     if (author?.nick) return String(author.nick)
     if (author?.name) return String(author.name)
-    // 官机：原始事件自带 member.nick / author.username，零 API
     const raw = session.event?._data?.d
     if (raw?.member?.nick) return String(raw.member.nick)
     if (raw?.author?.username) return String(raw.author.username)
-    // 兜底：getGuildMember（需"获取群成员信息"权限，失败降级为 ID）
     if (session.guildId && !session.isDirect && typeof session.bot?.getGuildMember === 'function') {
       try {
         const member = await session.bot.getGuildMember(session.guildId, userId)
@@ -139,15 +183,15 @@ function apply(ctx, config) {
   }
 
   // ===== 群名 =====
-  async function setGroupName(guildId, name) {
+  async function setGroupName(guildId, name, botSid) {
     if (!name || name === guildId) return
     nameCache.set(guildId, { name, t: Date.now() })
     try {
       await ctx.database.upsert('ll_mc_groups', [{
-        channelId: guildId, name, platform: '', updatedAt: Date.now(),
+        channelId: guildId, name, platform: '', botSid: botSid || '', updatedAt: Date.now(),
       }], ['channelId'])
     }
-    catch { /* 忽略写入失败 */ }
+    catch { /* 忽略 */ }
   }
   async function getGroupName(guildId) {
     if (config.groupNameMap[guildId]) return config.groupNameMap[guildId]
@@ -163,28 +207,31 @@ function apply(ctx, config) {
     catch { /* 忽略 */ }
     return guildId
   }
-  // 收到消息时刷新群名（节流；官机走 getGuild）
+  async function getGroupBotSid(guildId) {
+    try {
+      const rows = await ctx.database.get('ll_mc_groups', { channelId: guildId })
+      return rows[0]?.botSid || ''
+    }
+    catch { return '' }
+  }
   async function refreshGroupName(session) {
     const guildId = session.guildId
     const now = Date.now()
     if ((lastNameRefresh.get(guildId) || 0) > now - config.refreshGroupNameInterval * 1000) return
     lastNameRefresh.set(guildId, now)
-    // 1. OneBot：消息自带群名
     if (session.event?.channel?.name) {
-      await setGroupName(guildId, session.event.channel.name)
+      await setGroupName(guildId, session.event.channel.name, session.bot?.sid)
       return
     }
-    // 2. 手动指定
     if (config.groupNameMap[guildId]) {
-      await setGroupName(guildId, config.groupNameMap[guildId])
+      await setGroupName(guildId, config.groupNameMap[guildId], session.bot?.sid)
       return
     }
-    // 3. 官机：getGuild（内部 getGuildInfo，需"获取群信息"权限）
     if (typeof session.bot?.getGuild === 'function') {
       try {
         const g = await session.bot.getGuild(guildId)
         if (g?.name) {
-          await setGroupName(guildId, g.name)
+          await setGroupName(guildId, g.name, session.bot?.sid)
           return
         }
       }
@@ -194,6 +241,39 @@ function apply(ctx, config) {
     }
   }
 
+  // ===== 群设置 =====
+  async function getGroupSettings(guildId) {
+    const cached = settingsCache.get(guildId)
+    if (cached) return cached
+    let s = { rankLimit: config.rankLimit, imageMode: config.imageMode }
+    try {
+      const rows = await ctx.database.get('ll_mc_settings', { channelId: guildId })
+      if (rows[0]) {
+        s = {
+          rankLimit: rows[0].rankLimit || config.rankLimit,
+          imageMode: rows[0].imageMode || config.imageMode,
+        }
+      }
+    }
+    catch { /* 忽略 */ }
+    settingsCache.set(guildId, s)
+    return s
+  }
+  async function setGroupSettings(guildId, patch) {
+    const cur = await getGroupSettings(guildId)
+    const next = { ...cur, ...patch }
+    settingsCache.set(guildId, next)
+    try {
+      await ctx.database.upsert('ll_mc_settings', [{
+        channelId: guildId,
+        rankLimit: next.rankLimit,
+        imageMode: next.imageMode,
+      }], ['channelId'])
+    }
+    catch { /* 忽略 */ }
+    return next
+  }
+
   // ===== 消息统计 =====
   ctx.on('message', async (session) => {
     try {
@@ -202,7 +282,6 @@ function apply(ctx, config) {
       const userId = session.userId
       if (!config.countBots && session.selfId === session.userId) return
       if (config.ignoredGroups.includes(guildId)) return
-
       const date = todayStr()
       const rows = await ctx.database.get('ll_mc_stats', { channelId: guildId, userId, date })
       const count = (rows[0]?.count || 0) + 1
@@ -215,15 +294,18 @@ function apply(ctx, config) {
     catch (e) {
       logger.warn('[ll-mc] 消息统计失败:', e?.message)
     }
-    // 群名刷新独立于计数，失败不影响统计
     refreshGroupName(session).catch(() => {})
   })
+  function todayStr() {
+    return dateStr(new Date())
+  }
 
-  // ===== 排行聚合 =====
-  // 返回 [{ key, nick/name, count }] 按 count 降序
+  // ===== 聚合 =====
   async function aggregateStats(range, groupBy) {
-    const query = range.start ? { date: { $gte: range.start } } : {}
-    const rows = await ctx.database.get('ll_mc_stats', query)
+    const cond = {}
+    if (range.start) cond.date = { $gte: range.start }
+    if (range.end) cond.date = { ...(cond.date || {}), $lte: range.end }
+    const rows = await ctx.database.get('ll_mc_stats', cond)
     const map = new Map()
     for (const row of rows) {
       const key = groupBy === 'user' ? `${row.channelId}:${row.userId}` : row.channelId
@@ -236,74 +318,190 @@ function apply(ctx, config) {
       .sort((a, b) => b.count - a.count)
   }
 
-  // ===== 命令：本群成员排行 =====
+  // ===== 图片渲染（puppeteer，可选） =====
+  async function renderRankImage(title, subtitle, rows) {
+    try {
+      if (typeof ctx.puppeteer?.page !== 'function') return null
+      const page = await ctx.puppeteer.page()
+      const body = rows.map((r, i) => `
+        <div class="row">
+          <div class="no">${i + 1}</div>
+          <div class="name">${escapeHtml(r.name)}${r.mark ? ' <span class="star">★</span>' : ''}</div>
+          <div class="bar"><div class="fill" style="width:${r.percent}%"></div></div>
+          <div class="count">${r.count} 条</div>
+        </div>`).join('')
+      await page.setContent(`<!DOCTYPE html><html><head><meta charset="utf-8"><style>
+        body{margin:0;background:linear-gradient(135deg,#1a1a2e,#16213e);font-family:sans-serif;color:#fff;padding:24px;width:900px}
+        .title{font-size:28px;font-weight:bold;margin-bottom:4px}
+        .sub{font-size:14px;color:#8a94b8;margin-bottom:16px}
+        .row{display:flex;align-items:center;background:rgba(255,255,255,.06);border-radius:10px;padding:10px 14px;margin-bottom:8px}
+        .no{width:36px;font-size:18px;font-weight:bold;color:#ffd166;flex-shrink:0}
+        .name{width:220px;font-size:16px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;flex-shrink:0}
+        .star{color:#ffd166}
+        .bar{flex:1;height:10px;background:rgba(255,255,255,.12);border-radius:5px;margin:0 12px;overflow:hidden}
+        .fill{height:100%;background:linear-gradient(90deg,#06b6d4,#3b82f6);border-radius:5px}
+        .count{width:80px;text-align:right;font-size:15px;color:#a5f3fc;flex-shrink:0}
+      </style></head><body>
+        <div class="title">${escapeHtml(title)}</div>
+        <div class="sub">${escapeHtml(subtitle)}</div>
+        ${body}
+      </body></html>`, { waitUntil: 'networkidle0' })
+      await page.waitForSelector('.title')
+      const buf = await page.screenshot({ type: 'png' })
+      await page.close().catch(() => {})
+      return buf
+    }
+    catch (e) {
+      logger.warn('[ll-mc] 排行图片渲染失败，降级文字:', e?.message)
+      return null
+    }
+  }
+  function escapeHtml(s) {
+    return String(s == null ? '' : s).replace(/[&<>"']/g, c => ({
+      '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+    }[c]))
+  }
+
+  // ===== 命令：发言榜（成员） =====
   async function memberRanking(session, period, limit) {
     if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
     const range = parsePeriod(period)
-    if (!range) return '❌ 周期参数无效，可用：今日 / 本周 / 本月 / 总榜'
-    const n = Math.min(Math.max(limit || config.rankLimit, 1), 100)
+    if (!range) return '❌ 周期参数无效，可用：今日/昨日/本周/本月/本年/去年/总榜'
+    const gs = await getGroupSettings(session.guildId)
+    const n = Math.min(Math.max(limit || gs.rankLimit || config.rankLimit, 1), 100)
     const list = await aggregateStats(range, 'user')
-    const inRange = list.filter(x => x.key.startsWith(`${session.guildId}:`))
-    const mine = inRange.find(x => x.key === `${session.guildId}:${session.userId}`)
-    const mineRank = mine ? inRange.indexOf(mine) + 1 : 0
+    const inGroup = list.filter(x => x.key.startsWith(`${session.guildId}:`))
+    const mine = inGroup.find(x => x.key === `${session.guildId}:${session.userId}`)
+    const top = inGroup.slice(0, n)
     const groupRows = await ctx.database.get('ll_mc_stats', { channelId: session.guildId })
-    const total = groupRows.reduce((s, r) => s + (r.count || 0), 0)
-    const totalInRange = inRange.reduce((s, x) => s + x.count, 0)
-
-    const lines = [`📊 ${range.label}发言排行 TOP ${Math.min(n, inRange.length)}（本群）`]
-    inRange.slice(0, n).forEach((x, i) => {
+    const totalAll = groupRows.reduce((s, r) => s + (r.count || 0), 0)
+    const totalRange = inGroup.reduce((s, x) => s + x.count, 0)
+
+    const title = `${range.label}发言排行 TOP ${Math.min(n, inGroup.length)}`
+    const subtitle = `本群${range.label}共 ${totalRange} 条 · 历史累计 ${totalAll} 条`
+    const rows = top.map(x => {
+      const isMine = x.key === `${session.guildId}:${session.userId}`
+      return { name: x.nick || x.key.split(':')[1], count: x.count, percent: Math.max(top[0].count ? Math.round(x.count / top[0].count * 100) : 0, 2), mark: isMine }
+    })
+    const buf = await renderRankImage(title, subtitle, rows)
+    if (buf) return h.image(buf)
+    const lines = [`📊 ${title}`]
+    top.forEach((x, i) => {
       const mark = x.key === `${session.guildId}:${session.userId}` ? ' ★' : ''
       lines.push(`${i + 1}. ${x.nick || x.key.split(':')[1]} · ${x.count}条${mark}`)
     })
-    lines.push(`—— 本群${range.label}共 ${totalInRange} 条发言，历史累计 ${total} 条`)
-    if (mineRank) lines.push(`我的排名：第 ${mineRank} 名（${mine.count}条）`)
+    lines.push(`—— ${subtitle}`)
+    if (mine) lines.push(`我的排名：第 ${inGroup.indexOf(mine) + 1} 名（${mine.count}条）`)
     return lines.join('\n')
   }
 
-  // ===== 命令：跨群排行（群名正确） =====
+  // ===== 命令：群发言榜（新增） =====
   async function groupRanking(session, period, limit) {
     const range = parsePeriod(period)
-    if (!range) return '❌ 周期参数无效，可用：今日 / 本周 / 本月 / 总榜'
-    const n = Math.min(Math.max(limit || config.rankLimit, 1), 100)
+    if (!range) return '❌ 周期参数无效，可用：今日/昨日/本周/本月/本年/去年/总榜'
+    const gs = session.guildId ? await getGroupSettings(session.guildId) : { rankLimit: config.rankLimit }
+    const n = Math.min(Math.max(limit || gs.rankLimit || config.rankLimit, 1), 100)
     const list = await aggregateStats(range, 'group')
+    const top = list.slice(0, n)
     const current = session.guildId
-    const lines = [`🏆 群${range.label}发言排行 TOP ${Math.min(n, list.length)}`]
-    for (let i = 0; i < Math.min(n, list.length); i++) {
-      const x = list[i]
+    const rows = []
+    for (const x of top) {
+      const name = await getGroupName(x.key)
+      rows.push({ name, count: x.count, percent: Math.max(top[0].count ? Math.round(x.count / top[0].count * 100) : 0, 2), mark: x.key === current })
+    }
+    const title = `群${range.label}发言排行 TOP ${Math.min(n, top.length)}`
+    const subtitle = '跨群排行 · 群名来自 getGuild（需"获取群信息"权限）或 groupNameMap'
+    const buf = await renderRankImage(title, subtitle, rows)
+    if (buf) return h.image(buf)
+    const lines = [`🏆 ${title}`]
+    for (let i = 0; i < top.length; i++) {
+      const x = top[i]
       const name = await getGroupName(x.key)
       const mark = x.key === current ? ' ★当前群' : ''
       lines.push(`${i + 1}. ${name} · ${x.count}条${mark}`)
     }
-    lines.push('（群名来自 getGuild 接口，需申请"获取群信息"权限；或用 groupNameMap 手动指定）')
+    lines.push(`—— ${subtitle}`)
     return lines.join('\n')
   }
 
-  // ===== 命令：我的统计 =====
+  // ===== 命令：我的发言 =====
   async function myStats(session) {
     if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
     const guildId = session.guildId
     const userId = session.userId
-    const periods = [
-      { key: 'day', label: '今日' },
-      { key: 'week', label: '本周' },
-      { key: 'month', label: '本月' },
-      { key: 'all', label: '总榜' },
-    ]
+    const labels = [['day', '今日'], ['yesterday', '昨日'], ['week', '本周'], ['month', '本月'], ['year', '本年'], ['all', '总榜']]
     const lines = ['👤 我的发言统计（本群）']
-    for (const p of periods) {
-      const range = parsePeriod(p.label)
-      const query = range.start
-        ? { channelId: guildId, userId, date: { $gte: range.start } }
-        : { channelId: guildId, userId }
-      const rows = await ctx.database.get('ll_mc_stats', query)
-      const total = rows.reduce((s, r) => s + (r.count || 0), 0)
-      lines.push(`${p.label}：${total} 条`)
+    for (const [key, label] of labels) {
+      const range = parsePeriod(label === '总榜' ? '' : label)
+      const cond = { channelId: guildId, userId }
+      if (range.start) cond.date = { $gte: range.start }
+      if (range.end) cond.date = { ...(cond.date || {}), $lte: range.end }
+      const rows = await ctx.database.get('ll_mc_stats', cond)
+      lines.push(`${label}：${rows.reduce((s, r) => s + (r.count || 0), 0)} 条`)
     }
     return lines.join('\n')
   }
 
+  // ===== 命令：定时推送 =====
+  async function pushRanking(period) {
+    const range = parsePeriod(period || (config.timerType === 'week' ? '本周' : config.timerType === 'month' ? '本月' : '昨日'))
+    if (!range) return '❌ 周期参数无效'
+    const list = await aggregateStats(range, 'group')
+    const targets = config.timerGroups && config.timerGroups.length
+      ? config.timerGroups
+      : list.map(x => x.key)
+    let sent = 0
+    const failed = []
+    for (const guildId of targets) {
+      try {
+        const botSid = await getGroupBotSid(guildId)
+        const bot = botSid ? (ctx.bots || []).find(b => b.sid === botSid) : (ctx.bots || []).find(b => b.online)
+        if (!bot || typeof bot.sendMessage !== 'function') {
+          failed.push(guildId)
+          continue
+        }
+        const gs = await getGroupSettings(guildId)
+        const n = gs.rankLimit || config.rankLimit
+        const rows = await ctx.database.get('ll_mc_stats', {
+          channelId: guildId,
+          ...(range.start ? { date: { $gte: range.start } } : {}),
+          ...(range.end ? { date: { $lte: range.end } } : {}),
+        })
+        const perUser = new Map()
+        for (const r of rows) {
+          const item = perUser.get(r.userId) || { count: 0, nick: r.nick }
+          item.count += r.count || 0
+          if (r.nick) item.nick = r.nick
+          perUser.set(r.userId, item)
+        }
+        const sorted = [...perUser.entries()].map(([uid, item]) => ({ uid, ...item }))
+          .sort((a, b) => b.count - a.count)
+          .slice(0, n)
+        const name = await getGroupName(guildId)
+        const lines = [`📊 ${name} ${range.label}发言榜 TOP ${Math.min(n, sorted.length)}`]
+        sorted.forEach((x, i) => lines.push(`${i + 1}. ${x.nick || x.uid} · ${x.count}条`))
+        await bot.sendMessage(guildId, lines.join('\n'))
+        sent++
+      }
+      catch (e) {
+        logger.warn(`[ll-mc] 推送 ${guildId} 失败: ${e?.message}`)
+        failed.push(guildId)
+      }
+    }
+    return `✅ 定时推送完成：成功 ${sent} 群${failed.length ? `，失败 ${failed.length} 群` : ''}`
+  }
+  const timer = setInterval(async () => {
+    const hm = nowHM()
+    if (!config.timerEnabled || config.timerTime !== hm) return
+    const today = todayStr()
+    if (firedTimer.date === today) return
+    firedTimer.date = today
+    logger.info(`[ll-mc] 定时推送触发 @ ${hm}`)
+    await pushRanking('')
+  }, 30000)
+  ctx.on('dispose', () => clearInterval(timer))
+
   // ===== 命令注册 =====
-  // 解析 "周期 [人数]" 或 "[人数]"，两种顺序都支持
   function parseArgs(text) {
     const parts = String(text || '').trim().split(/\s+/).filter(Boolean)
     let period = ''
@@ -315,27 +513,57 @@ function apply(ctx, config) {
     return { period, limit }
   }
 
-  ctx.command('mc.排行 [args:text]', '本群成员发言排行（今日/本周/本月/总榜）')
-    .alias('排行')
+  ctx.command('发言榜 [args:text]', '本群成员发言排行（今日/昨日/本周/本月/本年/去年/总榜）')
+    .alias('水群榜', '发言排行', 'mc.排行')
     .action(async ({ session }, args) => {
       const { period, limit } = parseArgs(args)
       return await memberRanking(session, period, limit)
     })
-
-  ctx.command('mc.群排行 [args:text]', '跨群发言排行（群名正确）')
-    .alias('群排行')
+  ctx.command('群发言榜 [args:text]', '所有群的发言排行（群名正确）')
+    .alias('群排行', 'mc.群排行')
     .action(async ({ session }, args) => {
       const { period, limit } = parseArgs(args)
       return await groupRanking(session, period, limit)
     })
-
-  ctx.command('mc.我的', '我的发言统计')
-    .alias('我的发言')
+  for (const [kw, period] of [['今日发言榜', '今日'], ['本周发言榜', '本周'], ['本月发言榜', '本月']]) {
+    ctx.command(kw, `查看${period}发言排行`).alias(`mc.${kw}`)
+      .action(async ({ session }) => memberRanking(session, period, 0))
+  }
+  ctx.command('我的发言', '我的发言统计').alias('查看发言', 'mc.我的')
+    .action(async ({ session }) => myStats(session))
+  ctx.command('发言榜帮助', '查看帮助').alias('发言帮助', '发言榜菜单')
+    .action(() => exports.usage.replace(/^`|`$/g, ''))
+  ctx.command('设置发言榜数量 <limit:number>', '设置本群排行显示人数')
+    .action(async ({ session }, limit) => {
+      if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+      const n = Math.min(Math.max(limit || config.rankLimit, 1), 100)
+      await setGroupSettings(session.guildId, { rankLimit: n })
+      return `✅ 本群排行显示人数已设为 ${n}`
+    })
+  ctx.command('设置发言榜图片 <mode:text>', '设置本群排行显示模式（auto/文字/图片）')
+    .action(async ({ session }, mode) => {
+      if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+      const m = /图|image/i.test(mode) ? 'image' : /文|text/i.test(mode) ? 'text' : 'auto'
+      await setGroupSettings(session.guildId, { imageMode: m })
+      return `✅ 本群排行模式已设为 ${m}（auto=有图片服务用图片）`
+    })
+  ctx.command('清除发言榜单', '清空本群统计')
     .action(async ({ session }) => {
-      return await myStats(session)
+      if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+      await ctx.database.remove('ll_mc_stats', { channelId: session.guildId })
+      return '✅ 本群发言统计已清空'
+    })
+  ctx.command('手动推送发言榜 [period:text]', '立即向定时目标群推送排行')
+    .action(async ({ session }, period) => {
+      return await pushRanking(period || '')
+    })
+  ctx.command('发言榜定时状态', '查看定时推送配置')
+    .action(() => {
+      const t = config.timerType === 'week' ? '本周' : config.timerType === 'month' ? '本月' : '昨日'
+      return `⏰ 定时推送：${config.timerEnabled ? '已启用' : '未启用'}\n时间：${config.timerTime}\n内容：${t}发言榜\n目标群：${config.timerGroups.length ? config.timerGroups.join(', ') : '所有有数据的群'}`
     })
 
-  logger.info('[ll-mc] 已启动：mc.排行 / mc.群排行 / mc.我的')
+  logger.info('[ll-mc] 已启动：发言榜 / 群发言榜 / 我的发言 / 定时推送')
 }
 
 exports.apply = apply

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-ll-mc",
   "description": "消息统计插件（重做版）：群成员发言排行 + 跨群发言排行，官方QQ机器人原生适配",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "main": "index.js",
   "files": [
     "index.js"