koishi-plugin-group-memory 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-group-memory",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "智能群聊记忆中间件：自动记录上下文，在@或回复时注入前情提要，支持时间窗口过滤与内容清洗",
   "main": "./src/index.js",
   "scripts": {

package/src/index.js

@@ -1,16 +1,28 @@
 const { Schema } = require('koishi');
 
 exports.name = 'group-memory';
-exports.usage = '自动记录群聊上下文，并在用户@机器人或回复机器人时，将前情提要注入给 AI 插件';
+exports.usage = '自动记录群聊和私聊上下文，并为 AI 插件提供历史记录查询接口。支持数据库存储，群聊共享上下文，私聊独立上下文。';
+
+// --- 数据库表结构 ---
+const MessageSchema = Schema.object({
+  id: Schema.number().role('primary').required(),
+  session_id: Schema.string().required(), // 会话ID：private:{userId} 或 group:{groupId}
+  session_type: Schema.string().required(), // 'private' 或 'group'
+  user_id: Schema.string().required(),
+  user_name: Schema.string().default(''),
+  role: Schema.string().required(), // 'user' 或 'assistant'
+  content: Schema.string().required(),
+  timestamp: Schema.date().required(),
+});
 
-// --- 修复：移除所有可能导致错误的 UI 方法 ---
+// --- 配置架构 ---
 exports.Config = Schema.object({
-  // --- 记忆设置 ---
+  // --- 存储设置 ---
   maxContext: Schema.number()
     .default(20)
     .min(1)
     .max(100)
-    .description('每个群保留最近多少条消息作为上下文。'),
+    .description('每个会话保留最近多少条消息作为上下文。'),
 
   timeWindow: Schema.number()
     .default(3600000) // 1小时
@@ -18,7 +30,16 @@ exports.Config = Schema.object({
     .step(60000) // 1分钟步进
     .description('只保留最近 N 毫秒内的消息。设置为 0 表示不限制时间，只按条数限制。'),
 
-  // --- 触发条件 ---
+  // --- 记录设置 ---
+  recordPrivateChat: Schema.boolean()
+    .default(true)
+    .description('是否记录私聊消息。'),
+
+  recordGroupChat: Schema.boolean()
+    .default(true)
+    .description('是否记录群聊消息。'),
+
+  // --- 触发条件（用于中间件模式） ---
   triggerOnAt: Schema.boolean()
     .default(true)
     .description('当消息中包含 @机器人 时，触发上下文注入。'),
@@ -27,11 +48,6 @@ exports.Config = Schema.object({
     .default(true)
     .description('当消息是回复机器人的消息时，触发上下文注入。'),
 
-  // --- 适配设置 ---
-  targetPlugins: Schema.array(String)
-    .default([])
-    .description('目标 AI 插件的名称列表。留空则对所有满足条件的消息生效。'),
-
   // --- 内容处理 ---
   cleanMentions: Schema.boolean()
     .default(true)
@@ -41,30 +57,46 @@ exports.Config = Schema.object({
     .default(true)
     .description('是否移除图片/媒体占位符 (如 [图片])。'),
 
-  // prefixTemplate: Schema.string() // 这个配置项比较复杂，不适合用 Schema.string() 来定义
-  //   .default(...)
-  //   .textarea() // 导致错误
-  //   .rows(5)    // 导致错误
-  //   ...
-  // 我们将其移除，让其成为一个纯粹的代码逻辑，默认值直接在 apply 函数中硬编码。
-
   // --- 调试 ---
   verbose: Schema.boolean()
     .default(false)
     .description('是否在控制台打印注入的上下文 (调试用)。'),
 });
 
-// --- 关键：显式导出 schema ---
 exports.schema = exports.Config;
 
+// --- 声明依赖注入 ---
+exports.inject = ['database'];
+
 exports.apply = (ctx, config) => {
-  const groupChats = new Map();
+  const logger = ctx.logger('group-memory');
+
+  // 内存缓存（用于快速访问，数据库持久化）
+  const memoryCache = new Map();
+
+  // 确保数据库表存在
+  ctx.database.extend('group_memory_messages', MessageSchema, {
+    autoInc: true,
+  });
+
+  // --- 辅助函数：生成会话ID ---
+  // 私聊: private:{userId}
+  // 群聊: group:{groupId}（所有人共享）
+  const generateSessionId = (session) => {
+    if (!session.groupId) {
+      return { sessionId: `private:${session.userId}`, sessionType: 'private' };
+    } else {
+      return { sessionId: `group:${session.groupId}`, sessionType: 'group' };
+    }
+  };
 
+  // --- 辅助函数：格式化时间 ---
   const formatTime = (timestamp) => {
     const date = new Date(timestamp);
     return `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
   };
 
+  // --- 辅助函数：清理内容 ---
   const cleanContent = (content, session) => {
     let text = content;
 
@@ -82,56 +114,163 @@ exports.apply = (ctx, config) => {
     return text.trim();
   };
 
+  // --- 核心 API：获取上下文（供其他插件调用） ---
+  const getContext = async (sessionId, limit = null) => {
+    const maxMessages = limit ? limit * 2 : config.maxContext * 2;
+
+    try {
+      // 从数据库获取
+      let history = await ctx.database.get('group_memory_messages',
+        { session_id: sessionId },
+        {
+          fields: ['id', 'session_id', 'role', 'content', 'timestamp', 'user_name'],
+          orderBy: { id: 'desc' },
+          limit: maxMessages
+        }
+      );
+
+      // 反转数组以恢复时间顺序
+      history.reverse();
+
+      // 如果时间窗口设置，进行过滤
+      if (config.timeWindow > 0) {
+        const cutoff = Date.now() - config.timeWindow;
+        history = history.filter(msg => new Date(msg.timestamp).getTime() >= cutoff);
+      }
+
+      return history;
+    } catch (error) {
+      logger.error('获取上下文失败:', error.message);
+      return [];
+    }
+  };
+
+  // --- 核心 API：保存消息（供其他插件调用） ---
+  const saveMessage = async (sessionId, role, content, userId = 'system', userName = 'System') => {
+    try {
+      // 解析 sessionId 获取 sessionType
+      const sessionType = sessionId.startsWith('private:') ? 'private' : 'group';
+
+      // 保存到数据库
+      await ctx.database.create('group_memory_messages', {
+        session_id: sessionId,
+        session_type: sessionType,
+        user_id: userId,
+        user_name: userName,
+        role: role,
+        content: content,
+        timestamp: new Date(),
+      });
+
+      // 清理旧消息
+      await cleanupOldMessages(sessionId);
+
+      return true;
+    } catch (error) {
+      logger.error('保存消息失败:', error.message);
+      return false;
+    }
+  };
+
+  // --- 核心 API：清空上下文（供其他插件调用） ---
+  const clearContext = async (sessionId) => {
+    try {
+      await ctx.database.remove('group_memory_messages', { session_id: sessionId });
+      memoryCache.delete(sessionId);
+      return true;
+    } catch (error) {
+      logger.error('清空上下文失败:', error.message);
+      return false;
+    }
+  };
+
+  // --- 辅助函数：清理旧消息 ---
+  const cleanupOldMessages = async (sessionId) => {
+    try {
+      // 获取当前消息数量
+      const allMessages = await ctx.database.get('group_memory_messages',
+        { session_id: sessionId },
+        { fields: ['id', 'timestamp'] }
+      );
+
+      const maxMessages = config.maxContext * 2;
+
+      // 如果超过最大数量，删除最旧的消息
+      if (allMessages.length > maxMessages) {
+        // 按 ID 排序（ID 是自增的，代表时间顺序）
+        allMessages.sort((a, b) => a.id - b.id);
+        const toDelete = allMessages.slice(0, allMessages.length - maxMessages);
+        for (const msg of toDelete) {
+          await ctx.database.remove('group_memory_messages', { id: msg.id });
+        }
+      }
+
+      // 如果时间窗口设置，删除过期的消息
+      if (config.timeWindow > 0) {
+        const cutoff = Date.now() - config.timeWindow;
+        const expiredMessages = allMessages.filter(msg =>
+          new Date(msg.timestamp).getTime() < cutoff
+        );
+        for (const msg of expiredMessages) {
+          await ctx.database.remove('group_memory_messages', { id: msg.id });
+        }
+      }
+    } catch (error) {
+      logger.error('清理旧消息失败:', error.message);
+    }
+  };
+
+  // --- 将 API 暴露给其他插件 ---
+  ctx['group-memory'] = {
+    getContext,
+    saveMessage,
+    clearContext,
+  };
+
+  // --- 中间件1: 记录所有消息 ---
   ctx.middleware(async (session, next) => {
-    if (!session.groupId) return next();
     if (session.selfId === session.userId) return next();
 
     const trimmed = session.content?.trim() || '';
-    if (/^[./\\]/.test(trimmed)) return next();
     if (!trimmed) return next();
 
-    const groupId = session.groupId;
-    if (!groupChats.has(groupId)) {
-      groupChats.set(groupId, []);
-    }
+    // 忽略命令消息
+    if (/^[./\\]/.test(trimmed)) return next();
 
-    const history = groupChats.get(groupId);
-    const now = Date.now();
+    const { sessionId, sessionType } = generateSessionId(session);
 
-    const cleanText = cleanContent(session.content, session);
+    // 根据配置决定是否记录
+    if (sessionType === 'private' && !config.recordPrivateChat) return next();
+    if (sessionType === 'group' && !config.recordGroupChat) return next();
 
-    history.push({
-      user: session.author?.nickname || session.userId,
-      content: cleanText,
-      time: now,
-      timeStr: formatTime(now)
-    });
+    const cleanText = cleanContent(session.content, session);
+    const userName = session.author?.nickname || session.userId;
 
-    while (history.length > config.maxContext) {
-      history.shift();
-    }
+    // 保存到数据库
+    await saveMessage(sessionId, 'user', cleanText, session.userId, userName);
 
-    if (config.timeWindow > 0) {
-      const cutoff = now - config.timeWindow;
-      while (history.length > 0 && history[0].time < cutoff) {
-        history.shift();
-      }
+    if (config.verbose) {
+      logger.info(`记录消息 [${sessionType}] ${userName}: ${cleanText.substring(0, 50)}...`);
     }
 
     return next();
   }, true);
 
+  // --- 中间件2: 上下文注入（可选功能） ---
   ctx.middleware(async (session, next) => {
-    if (!session.groupId) return next();
+    if (!session.groupId && !config.recordPrivateChat) return next();
+    if (session.groupId && !config.recordGroupChat) return next();
 
     let shouldInject = false;
 
+    // 检查是否 @ 机器人
     if (config.triggerOnAt) {
       const isAtBot = session.parsed?.bots?.includes(session.selfId) ||
                       (session.content && new RegExp(`<@${session.selfId}>|@${session.selfId}`).test(session.content));
       if (isAtBot) shouldInject = true;
     }
 
+    // 检查是否回复机器人
     if (!shouldInject && config.triggerOnReply && session.quote) {
       if (session.quote.userId === session.selfId) {
         shouldInject = true;
@@ -140,15 +279,18 @@ exports.apply = (ctx, config) => {
 
     if (!shouldInject) return next();
 
-    const groupId = session.groupId;
-    const history = groupChats.get(groupId) || [];
+    const { sessionId } = generateSessionId(session);
+    const history = await getContext(sessionId);
 
     if (history.length === 0) return next();
 
-    // --- 修复：将 prefixTemplate 的逻辑移回 apply 函数内部 ---
-    // 由于 Schema 无法处理函数类型的配置，我们将模板逻辑放在这里
-    const contextLines = history.map(msg => `${msg.timeStr} ${msg.user}: ${msg.content}`);
-    const contextPrefix = `【群聊前情提要】\n${contextLines.join('\n')}\n---\n请结合以上上下文回答以下问题：`;
+    // 构建上下文前缀
+    const contextLines = history.map(msg => {
+      const timeStr = formatTime(msg.timestamp);
+      const userName = msg.user_name || 'Unknown';
+      return `${timeStr} ${userName}: ${msg.content}`;
+    });
+    const contextPrefix = `【对话前情提要】\n${contextLines.join('\n')}\n---\n请结合以上上下文回答以下问题：`;
 
     let originalContent = session.content || '';
 
@@ -158,12 +300,97 @@ exports.apply = (ctx, config) => {
                                        .trim();
     }
 
+    // 修改 session.content，添加上下文前缀
     session.content = `${contextPrefix}\n${originalContent}`;
 
     if (config.verbose) {
-      console.log(`[GroupMemory] 群 ${groupId} 触发上下文注入。历史条数: ${history.length}`);
+      logger.info(`[GroupMemory] ${sessionId} 触发上下文注入。历史条数: ${history.length}`);
     }
 
     return next();
   }, 100);
+
+  // --- 命令：查看当前会话的上下文 ---
+  ctx.command('memory-view [count]', '查看当前会话的历史记录')
+    .alias('mem-view')
+    .action(async ({ session }, count = 5) => {
+      const { sessionId, sessionType } = generateSessionId(session);
+      const history = await getContext(sessionId, parseInt(count));
+
+      if (history.length === 0) {
+        return `📭 当前${sessionType === 'private' ? '私聊' : '群聊'}暂无历史记录。`;
+      }
+
+      const lines = history.map((msg, index) => {
+        const timeStr = formatTime(msg.timestamp);
+        const role = msg.role === 'user' ? '👤' : '🤖';
+        const userName = msg.user_name || 'Unknown';
+        const content = msg.content.substring(0, 50) + (msg.content.length > 50 ? '...' : '');
+        return `${index + 1}. ${timeStr} ${role} ${userName}: ${content}`;
+      });
+
+      return `📜 ${sessionType === 'private' ? '私聊' : '群聊'}历史记录 (最近${history.length}条)：\n${lines.join('\n')}`;
+    });
+
+  // --- 命令：清空当前会话的上下文 ---
+  ctx.command('memory-clear', '清空当前会话的历史记录')
+    .alias('mem-clear')
+    .action(async ({ session }) => {
+      const { sessionId, sessionType } = generateSessionId(session);
+      const result = await clearContext(sessionId);
+
+      if (result) {
+        return `✅ 已清空当前${sessionType === 'private' ? '私聊' : '群聊'}的对话记忆！`;
+      } else {
+        return '❌ 清空记忆失败，请查看日志。';
+      }
+    });
+
+  // --- 命令：查看插件状态 ---
+  ctx.command('memory-status', '查看 memory 插件状态')
+    .alias('mem-status')
+    .action(async () => {
+      try {
+        const allMessages = await ctx.database.get('group_memory_messages', {}, { fields: ['id'] });
+        const privateCount = await ctx.database.get('group_memory_messages', { session_type: 'private' }, { fields: ['id'] });
+        const groupCount = await ctx.database.get('group_memory_messages', { session_type: 'group' }, { fields: ['id'] });
+
+        return `🧠 Group Memory 插件状态\n` +
+               `总消息数: ${allMessages.length}\n` +
+               `私聊消息: ${privateCount.length}\n` +
+               `群聊消息: ${groupCount.length}\n` +
+               `最大上下文: ${config.maxContext} 轮\n` +
+               `时间窗口: ${config.timeWindow > 0 ? config.timeWindow / 60000 + ' 分钟' : '无限制'}`;
+      } catch (error) {
+        return `❌ 获取状态失败: ${error.message}`;
+      }
+    });
+
+  // --- 命令：清理过期消息 ---
+  ctx.command('memory-cleanup', '清理所有过期的历史记录')
+    .alias('mem-cleanup')
+    .action(async () => {
+      if (config.timeWindow === 0) {
+        return '⚠️ 时间窗口设置为 0，不会清理任何消息。';
+      }
+
+      try {
+        const allMessages = await ctx.database.get('group_memory_messages', {}, { fields: ['id', 'timestamp'] });
+        const cutoff = Date.now() - config.timeWindow;
+        let deletedCount = 0;
+
+        for (const msg of allMessages) {
+          if (new Date(msg.timestamp).getTime() < cutoff) {
+            await ctx.database.remove('group_memory_messages', { id: msg.id });
+            deletedCount++;
+          }
+        }
+
+        return `🧹 清理完成，删除了 ${deletedCount} 条过期消息。`;
+      } catch (error) {
+        return `❌ 清理失败: ${error.message}`;
+      }
+    });
+
+  logger.info('Group Memory 插件已加载');
 };