koishi-plugin-group-memory 1.2.0 → 2.0.0

package/package.json

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

package/src/index.js

@@ -4,219 +4,559 @@ exports.name = 'group-memory';
 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(),
-});
+const MessageFields = {
+  id: 'unsigned',
+  session_id: 'string(255)',
+  session_type: 'string(50)',
+  user_id: 'string(100)',
+  user_name: 'string(255)',
+  role: 'string(50)',
+  content: 'text',
+  timestamp: 'unsigned',
+};
 
 // --- 配置架构 ---
 exports.Config = Schema.object({
-  // --- 存储设置 ---
-  maxContext: Schema.number()
-    .default(20)
-    .min(1)
-    .max(100)
-    .description('每个会话保留最近多少条消息作为上下文。'),
-
-  timeWindow: Schema.number()
-    .default(3600000) // 1小时
-    .min(0)
-    .step(60000) // 1分钟步进
-    .description('只保留最近 N 毫秒内的消息。设置为 0 表示不限制时间，只按条数限制。'),
-
-  // --- 记录设置 ---
-  recordPrivateChat: Schema.boolean()
+  // ... 其他配置保持不变 ...
+
+  // ============================================
+  // 新增：日志显示功能
+  // ============================================
+  logLevel: Schema.union([
+    Schema.const('none').description('不输出日志'),
+    Schema.const('simple').description('简易模式：输出易于理解的操作摘要'),
+    Schema.const('detailed').description('详细模式：输出完整的 JSON 格式日志'),
+  ]).default('simple').description('日志输出级别'),
+
+  logDatabaseOps: Schema.boolean()
     .default(true)
-    .description('是否记录私聊消息。'),
+    .description('是否记录数据库操作（增删改查）'),
 
-  recordGroupChat: Schema.boolean()
+  logContextInject: Schema.boolean()
     .default(true)
-    .description('是否记录群聊消息。'),
+    .description('是否记录上下文注入操作'),
 
-  // --- 触发条件（用于中间件模式） ---
-  triggerOnAt: Schema.boolean()
+  logApiCalls: Schema.boolean()
     .default(true)
-    .description('当消息中包含 @机器人 时，触发上下文注入。'),
+    .description('是否记录对外部插件的 API 调用'),
 
-  triggerOnReply: Schema.boolean()
+  logContentPreview: Schema.boolean()
     .default(true)
-    .description('当消息是回复机器人的消息时，触发上下文注入。'),
+    .description('是否在简易模式下预览消息内容（只显示前30个字符）'),
 
-  // --- 内容处理 ---
-  cleanMentions: Schema.boolean()
+  logColorOutput: Schema.boolean()
     .default(true)
-    .description('发送给 AI 前，是否移除消息中的 @ 符号 (避免 AI 困惑)。'),
+    .description('是否使用颜色区分不同类型的日志（需终端支持）'),
 
-  cleanImages: Schema.boolean()
+  logTimestamp: Schema.boolean()
     .default(true)
-    .description('是否移除图片/媒体占位符 (如 [图片])。'),
-
-  // --- 调试 ---
-  verbose: Schema.boolean()
-    .default(false)
-    .description('是否在控制台打印注入的上下文 (调试用)。'),
+    .description('是否在日志中显示时间戳'),
 });
 
 exports.schema = exports.Config;
 
-// --- 声明依赖注入 ---
 exports.inject = ['database'];
 
 exports.apply = (ctx, config) => {
   const logger = ctx.logger('group-memory');
 
-  // 内存缓存（用于快速访问，数据库持久化）
+  // ============================================
+  // 日志增强模块
+  // ============================================
+  
+  // 颜色代码（仅在启用时使用）
+  const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    underscore: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    
+    fg: {
+      black: '\x1b[30m',
+      red: '\x1b[31m',
+      green: '\x1b[32m',
+      yellow: '\x1b[33m',
+      blue: '\x1b[34m',
+      magenta: '\x1b[35m',
+      cyan: '\x1b[36m',
+      white: '\x1b[37m',
+      crimson: '\x1b[38m'
+    },
+    bg: {
+      black: '\x1b[40m',
+      red: '\x1b[41m',
+      green: '\x1b[42m',
+      yellow: '\x1b[43m',
+      blue: '\x1b[44m',
+      magenta: '\x1b[45m',
+      cyan: '\x1b[46m',
+      white: '\x1b[47m',
+      crimson: '\x1b[48m'
+    }
+  };
+
+  // 是否启用颜色
+  const useColor = config.logColorOutput && process.stdout.isTTY;
+
+  // 颜色辅助函数
+  const color = (text, colorCode) => {
+    if (!useColor) return text;
+    return `${colorCode}${text}${colors.reset}`;
+  };
+
+  // 格式化时间戳
+  const getTimestamp = () => {
+    if (!config.logTimestamp) return '';
+    const now = new Date();
+    return `[${now.toLocaleTimeString()}.${now.getMilliseconds().toString().padStart(3, '0')}] `;
+  };
+
+  // 日志类型图标
+  const icons = {
+    db: '🗄️',
+    cache: '⚡',
+    inject: '📎',
+    api: '🔌',
+    command: '⌨️',
+    error: '❌',
+    warning: '⚠️',
+    success: '✅',
+    info: 'ℹ️',
+    debug: '🔍',
+    memory: '🧠',
+    cleanup: '🧹'
+  };
+
+  // 简易日志函数
+  const logSimple = (type, message, data = null) => {
+    if (config.logLevel === 'none') return;
+    
+    const timestamp = getTimestamp();
+    const icon = icons[type] || '📝';
+    let colorFn;
+    
+    switch(type) {
+      case 'error': colorFn = (t) => color(t, colors.fg.red); break;
+      case 'warning': colorFn = (t) => color(t, colors.fg.yellow); break;
+      case 'success': colorFn = (t) => color(t, colors.fg.green); break;
+      case 'db': colorFn = (t) => color(t, colors.fg.cyan); break;
+      case 'inject': colorFn = (t) => color(t, colors.fg.magenta); break;
+      case 'api': colorFn = (t) => color(t, colors.fg.blue); break;
+      default: colorFn = (t) => t;
+    }
+    
+    const logMessage = `${timestamp}${icon} ${colorFn(message)}`;
+    
+    if (data && config.logContentPreview) {
+      let preview = '';
+      if (typeof data === 'string') {
+        preview = data.length > 30 ? data.substring(0, 30) + '...' : data;
+      } else if (data.content) {
+        preview = data.content.length > 30 ? data.content.substring(0, 30) + '...' : data.content;
+      }
+      if (preview) {
+        logger.info(`${logMessage} ${color(`"${preview}"`, colors.fg.yellow)}`);
+      } else {
+        logger.info(logMessage);
+      }
+    } else {
+      logger.info(logMessage);
+    }
+  };
+
+  // 详细日志函数
+  const logDetailed = (type, operation, details) => {
+    if (config.logLevel !== 'detailed') return;
+    
+    const timestamp = getTimestamp();
+    const icon = icons[type] || '📝';
+    
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      type,
+      operation,
+      ...details
+    };
+    
+    logger.info(`${timestamp}${icon} ${JSON.stringify(logEntry, null, 2)}`);
+  };
+
+  // 统一日志接口
+  const log = {
+    db: (operation, details, simpleMsg) => {
+      if (!config.logDatabaseOps) return;
+      if (config.logLevel === 'detailed') {
+        logDetailed('db', operation, details);
+      } else if (config.logLevel === 'simple') {
+        logSimple('db', simpleMsg || `${operation} 操作`, details);
+      }
+    },
+    
+    inject: (operation, details, simpleMsg) => {
+      if (!config.logContextInject) return;
+      if (config.logLevel === 'detailed') {
+        logDetailed('inject', operation, details);
+      } else if (config.logLevel === 'simple') {
+        logSimple('inject', simpleMsg || `上下文注入: ${operation}`, details);
+      }
+    },
+    
+    api: (operation, details, simpleMsg) => {
+      if (!config.logApiCalls) return;
+      if (config.logLevel === 'detailed') {
+        logDetailed('api', operation, details);
+      } else if (config.logLevel === 'simple') {
+        logSimple('api', simpleMsg || `API调用: ${operation}`, details);
+      }
+    },
+    
+    command: (cmd, user, details) => {
+      if (config.logLevel === 'none') return;
+      const simpleMsg = `命令 ${cmd} 由 ${user} 执行`;
+      if (config.logLevel === 'detailed') {
+        logDetailed('command', cmd, { user, ...details });
+      } else {
+        logSimple('command', simpleMsg, details);
+      }
+    },
+    
+    error: (msg, error) => {
+      if (config.logLevel === 'none') return;
+      const errorDetails = error ? { message: error.message, stack: error.stack } : {};
+      if (config.logLevel === 'detailed') {
+        logDetailed('error', '错误', { message: msg, ...errorDetails });
+      } else {
+        logSimple('error', `❌ ${msg}`, error);
+      }
+    },
+    
+    success: (msg, details) => {
+      if (config.logLevel === 'none') return;
+      if (config.logLevel === 'detailed') {
+        logDetailed('success', '成功', { message: msg, ...details });
+      } else {
+        logSimple('success', `✅ ${msg}`, details);
+      }
+    },
+    
+    cache: (operation, details) => {
+      if (config.logLevel === 'none') return;
+      if (config.logLevel === 'detailed') {
+        logDetailed('cache', operation, details);
+      } else {
+        logSimple('cache', `缓存 ${operation}`, details);
+      }
+    },
+    
+    cleanup: (count, details) => {
+      if (config.logLevel === 'none') return;
+      const simpleMsg = `清理了 ${count} 条过期消息`;
+      if (config.logLevel === 'detailed') {
+        logDetailed('cleanup', '清理', { count, ...details });
+      } else {
+        logSimple('cleanup', simpleMsg, details);
+      }
+    }
+  };
+
+  // 内存缓存
   const memoryCache = new Map();
+  const CACHE_TTL = 5 * 60 * 1000;
+  const cacheTimestamps = new Map();
+
+  // 会话锁
+  const sessionLocks = new Map();
+  
+  const lockSession = async (sessionId, timeout = 30000) => {
+    const startTime = Date.now();
+    while (sessionLocks.has(sessionId)) {
+      if (Date.now() - startTime > timeout) {
+        log.error(`获取会话锁超时: ${sessionId}`);
+        throw new Error(`获取会话锁超时: ${sessionId}`);
+      }
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    sessionLocks.set(sessionId, true);
+    log.cache('锁定', { sessionId, action: 'lock' });
+    return () => {
+      sessionLocks.delete(sessionId);
+      log.cache('解锁', { sessionId, action: 'unlock' });
+    };
+  };
 
   // 确保数据库表存在
-  ctx.database.extend('group_memory_messages', MessageSchema, {
+  ctx.database.extend('group_memory_messages', MessageFields, {
     autoInc: true,
+    primary: 'id',
+    index: ['session_id', 'session_type', 'timestamp']
   });
+  
+  log.success('数据库表初始化完成', { table: 'group_memory_messages' });
 
   // --- 辅助函数：生成会话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 result = !session.groupId 
+      ? { sessionId: `private:${session.userId}`, sessionType: 'private' }
+      : { 
+          sessionId: `group:${session.groupId}`,
+          separateId: config.supportSeparateContext ? `${session.groupId}:user:${session.userId}` : undefined,
+          sessionType: 'group'
+        };
+    
+    log.db('生成会话ID', {
+      input: { userId: session.userId, groupId: session.groupId },
+      output: result
+    }, `生成会话ID: ${result.sessionId}`);
+    
+    return result;
   };
 
   // --- 辅助函数：清理内容 ---
   const cleanContent = (content, session) => {
     let text = content;
+    const originalLength = text.length;
 
-    if (config.cleanMentions) {
-      text = text.replace(new RegExp(`@${session.selfId}`, 'g'), '');
-      text = text.replace(/@\S+/g, (match) => match.replace('@', ''));
+    if (config.cleanMentions && session) {
+      text = text.replace(new RegExp(`<@${session.selfId}>`, 'g'), '')
+                 .replace(new RegExp(`@${session.selfId}\\b`, 'g'), '')
+                 .replace(/@(\S+)/g, '$1');
     }
 
     if (config.cleanImages) {
-      text = text.replace(/\[图片\]/g, '[图片已省略]');
-      text = text.replace(/\[表情.*?\]/g, '');
-      text = text.replace(/\[CQ:.*?\]/g, '');
+      text = text.replace(/\[图片\]/g, '[图片]')
+                 .replace(/\[表情.*?\]/g, '')
+                 .replace(/\[CQ:.*?\]/g, '')
+                 .replace(/!?\[.*?\]\(.*?\)/g, '[链接]');
     }
 
-    return text.trim();
+    const result = text.trim() || '[空消息]';
+    
+    log.db('清理内容', {
+      original: { length: originalLength, preview: content.substring(0, 30) },
+      result: { length: result.length, preview: result.substring(0, 30) },
+      operations: { cleanMentions: config.cleanMentions, cleanImages: config.cleanImages }
+    }, `清理内容: ${originalLength} -> ${result.length} 字符`);
+    
+    return result;
   };
 
-  // --- 核心 API：获取上下文（供其他插件调用） ---
+  // --- 辅助函数：格式化时间 ---
+  const formatTime = (timestamp) => {
+    const date = new Date(timestamp);
+    return `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+  };
+
+  // --- 清理缓存 ---
+  const cleanupCache = () => {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [sessionId, timestamp] of cacheTimestamps.entries()) {
+      if (now - timestamp > CACHE_TTL) {
+        memoryCache.delete(sessionId);
+        cacheTimestamps.delete(sessionId);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      log.cache('清理过期缓存', { cleaned, ttl: CACHE_TTL });
+    }
+  };
+  setInterval(cleanupCache, CACHE_TTL);
+
+  // --- 核心 API：获取上下文 ---
   const getContext = async (sessionId, limit = null) => {
+    log.api('getContext', { sessionId, limit }, `获取上下文: ${sessionId}`);
+    
+    // 尝试从缓存获取
+    if (memoryCache.has(sessionId)) {
+      const cached = memoryCache.get(sessionId);
+      const age = Date.now() - cacheTimestamps.get(sessionId);
+      if (age < CACHE_TTL) {
+        log.cache('命中', { sessionId, age, count: cached.length }, `缓存命中: ${sessionId} (${cached.length}条)`);
+        return cached;
+      } else {
+        log.cache('过期', { sessionId, age }, `缓存过期: ${sessionId}`);
+      }
+    }
+
     const maxMessages = limit ? limit * 2 : config.maxContext * 2;
+    log.db('查询', { sessionId, maxMessages }, `查询数据库: ${sessionId}`);
 
     try {
-      // 从数据库获取
       let history = await ctx.database.get('group_memory_messages',
         { session_id: sessionId },
         {
-          fields: ['id', 'session_id', 'role', 'content', 'timestamp', 'user_name'],
+          fields: ['id', 'session_id', 'role', 'content', 'timestamp', 'user_name', 'user_id'],
           orderBy: { id: 'desc' },
           limit: maxMessages
         }
       );
 
-      // 反转数组以恢复时间顺序
       history.reverse();
 
-      // 如果时间窗口设置，进行过滤
       if (config.timeWindow > 0) {
+        const before = history.length;
         const cutoff = Date.now() - config.timeWindow;
-        history = history.filter(msg => new Date(msg.timestamp).getTime() >= cutoff);
+        history = history.filter(msg => msg.timestamp >= cutoff);
+        log.db('时间窗口过滤', { before, after: history.length, cutoff }, `过滤时间窗口: ${before} -> ${history.length}条`);
       }
 
+      // 更新缓存
+      memoryCache.set(sessionId, history);
+      cacheTimestamps.set(sessionId, Date.now());
+      log.cache('更新', { sessionId, count: history.length }, `更新缓存: ${sessionId} (${history.length}条)`);
+
       return history;
     } catch (error) {
-      logger.error('获取上下文失败:', error.message);
+      log.error('获取上下文失败', error);
       return [];
     }
   };
 
-  // --- 核心 API：保存消息（供其他插件调用） ---
+  // --- 核心 API：保存消息 ---
   const saveMessage = async (sessionId, role, content, userId = 'system', userName = 'System') => {
+    log.api('saveMessage', { sessionId, role, userId }, `保存消息: ${role} @ ${sessionId}`);
+    
+    const release = await lockSession(sessionId);
+    
     try {
-      // 解析 sessionId 获取 sessionType
       const sessionType = sessionId.startsWith('private:') ? 'private' : 'group';
 
-      // 保存到数据库
-      await ctx.database.create('group_memory_messages', {
+      const messageData = {
         session_id: sessionId,
         session_type: sessionType,
         user_id: userId,
         user_name: userName,
         role: role,
         content: content,
-        timestamp: new Date(),
-      });
+        timestamp: Date.now(),
+      };
+
+      log.db('创建', messageData, `插入消息: ${role} (${content.substring(0, 30)}...)`);
 
-      // 清理旧消息
-      await cleanupOldMessages(sessionId);
+      await ctx.database.create('group_memory_messages', messageData);
+
+      // 使缓存失效
+      memoryCache.delete(sessionId);
+      cacheTimestamps.delete(sessionId);
+      log.cache('失效', { sessionId }, `缓存失效: ${sessionId}`);
+
+      // 异步清理旧消息
+      cleanupOldMessages(sessionId).catch(err => {
+        log.error('异步清理失败', err);
+      });
 
       return true;
     } catch (error) {
-      logger.error('保存消息失败:', error.message);
+      log.error('保存消息失败', error);
+      return false;
+    } finally {
+      release();
+    }
+  };
+
+  // --- API：删除最后一条消息 ---
+  const deleteLastMessage = async (sessionId, role) => {
+    log.api('deleteLastMessage', { sessionId, role }, `删除最后一条 ${role} 消息: ${sessionId}`);
+    
+    const release = await lockSession(sessionId);
+    
+    try {
+      const lastMessage = await ctx.database.get('group_memory_messages',
+        { session_id: sessionId, role: role },
+        {
+          orderBy: { id: 'desc' },
+          limit: 1
+        }
+      );
+      
+      if (lastMessage && lastMessage.length > 0) {
+        log.db('删除', { id: lastMessage[0].id }, `删除消息 ID: ${lastMessage[0].id}`);
+        await ctx.database.remove('group_memory_messages', { id: lastMessage[0].id });
+        memoryCache.delete(sessionId);
+        cacheTimestamps.delete(sessionId);
+        return true;
+      }
+      
+      log.db('删除', { sessionId, role }, `未找到要删除的消息`);
+      return false;
+    } catch (error) {
+      log.error('删除消息失败', error);
       return false;
+    } finally {
+      release();
     }
   };
 
-  // --- 核心 API：清空上下文（供其他插件调用） ---
+  // --- API：清空上下文 ---
   const clearContext = async (sessionId) => {
+    log.api('clearContext', { sessionId }, `清空上下文: ${sessionId}`);
+    
+    const release = await lockSession(sessionId);
+    
     try {
-      await ctx.database.remove('group_memory_messages', { session_id: sessionId });
+      const count = await ctx.database.remove('group_memory_messages', { session_id: sessionId });
+      log.db('清空', { sessionId, count }, `清空了 ${count} 条消息`);
+      
       memoryCache.delete(sessionId);
+      cacheTimestamps.delete(sessionId);
+      log.cache('失效', { sessionId }, `缓存失效: ${sessionId}`);
+      
       return true;
     } catch (error) {
-      logger.error('清空上下文失败:', error.message);
+      log.error('清空上下文失败', error);
       return false;
+    } finally {
+      release();
     }
   };
 
   // --- 辅助函数：清理旧消息 ---
   const cleanupOldMessages = async (sessionId) => {
+    const release = await lockSession(sessionId);
+    
     try {
-      // 获取当前消息数量
       const allMessages = await ctx.database.get('group_memory_messages',
         { session_id: sessionId },
         { fields: ['id', 'timestamp'] }
       );
 
       const maxMessages = config.maxContext * 2;
+      let toDelete = [];
 
-      // 如果超过最大数量，删除最旧的消息
+      // 按数量限制
       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 });
-        }
+        const excess = allMessages.slice(0, allMessages.length - maxMessages);
+        toDelete.push(...excess);
+        log.db('数量限制', { total: allMessages.length, max: maxMessages, excess: excess.length });
       }
 
-      // 如果时间窗口设置，删除过期的消息
+      // 按时间窗口限制
       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 });
-        }
+        const expired = allMessages.filter(msg => msg.timestamp < cutoff);
+        toDelete.push(...expired);
+        log.db('时间窗口限制', { cutoff, expired: expired.length });
+      }
+
+      // 批量删除
+      if (toDelete.length > 0) {
+        const uniqueIds = [...new Set(toDelete.map(msg => msg.id))];
+        await ctx.database.remove('group_memory_messages', { id: uniqueIds });
+        
+        memoryCache.delete(sessionId);
+        cacheTimestamps.delete(sessionId);
+        
+        log.cleanup(uniqueIds.length, { sessionId, ids: uniqueIds });
       }
     } catch (error) {
-      logger.error('清理旧消息失败:', error.message);
+      log.error('清理旧消息失败', error);
+    } finally {
+      release();
     }
   };
 
@@ -225,8 +565,11 @@ exports.apply = (ctx, config) => {
     getContext,
     saveMessage,
     clearContext,
+    deleteLastMessage,
   };
 
+  log.success('API 接口已暴露', { methods: ['getContext', 'saveMessage', 'clearContext', 'deleteLastMessage'] });
+
   // --- 中间件1: 记录所有消息 ---
   ctx.middleware(async (session, next) => {
     if (session.selfId === session.userId) return next();
@@ -234,43 +577,46 @@ exports.apply = (ctx, config) => {
     const trimmed = session.content?.trim() || '';
     if (!trimmed) return next();
 
-    // 忽略命令消息
     if (/^[./\\]/.test(trimmed)) return next();
 
-    const { sessionId, sessionType } = generateSessionId(session);
+    const sessionInfo = generateSessionId(session);
+    const sessionId = sessionInfo.separateId || sessionInfo.sessionId;
+    const sessionType = sessionInfo.sessionType;
 
-    // 根据配置决定是否记录
     if (sessionType === 'private' && !config.recordPrivateChat) return next();
     if (sessionType === 'group' && !config.recordGroupChat) return next();
 
     const cleanText = cleanContent(session.content, session);
     const userName = session.author?.nickname || session.userId;
 
-    // 保存到数据库
-    await saveMessage(sessionId, 'user', cleanText, session.userId, userName);
+    log.db('记录消息', {
+      sessionId,
+      sessionType,
+      userId: session.userId,
+      userName,
+      content: cleanText
+    }, `📝 ${userName}: ${cleanText.substring(0, 30)}...`);
 
-    if (config.verbose) {
-      logger.info(`记录消息 [${sessionType}] ${userName}: ${cleanText.substring(0, 50)}...`);
-    }
+    saveMessage(sessionId, 'user', cleanText, session.userId, userName).catch(err => {
+      log.error('异步保存消息失败', err);
+    });
 
     return next();
-  }, true);
+  }, -100);
 
-  // --- 中间件2: 上下文注入（可选功能） ---
+  // --- 中间件2: 上下文注入 ---
   ctx.middleware(async (session, 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));
+                      (session.content && new RegExp(`<@${session.selfId}>|@${session.selfId}\\b`).test(session.content));
       if (isAtBot) shouldInject = true;
     }
 
-    // 检查是否回复机器人
     if (!shouldInject && config.triggerOnReply && session.quote) {
       if (session.quote.userId === session.selfId) {
         shouldInject = true;
@@ -279,42 +625,57 @@ exports.apply = (ctx, config) => {
 
     if (!shouldInject) return next();
 
-    const { sessionId } = generateSessionId(session);
+    const sessionInfo = generateSessionId(session);
+    const sessionId = sessionInfo.separateId || sessionInfo.sessionId;
+    
     const history = await getContext(sessionId);
 
     if (history.length === 0) return next();
 
-    // 构建上下文前缀
+    // 构建上下文
     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请结合以上上下文回答以下问题：`;
+    
+    const contextPrefix = `【对话历史】\n${contextLines.join('\n')}\n---`;
 
     let originalContent = session.content || '';
 
     if (config.cleanMentions) {
       originalContent = originalContent.replace(new RegExp(`<@${session.selfId}>`, 'g'), '')
-                                       .replace(new RegExp(`@${session.selfId}`, 'g'), '')
+                                       .replace(new RegExp(`@${session.selfId}\\b`, 'g'), '')
                                        .trim();
     }
 
-    // 修改 session.content，添加上下文前缀
-    session.content = `${contextPrefix}\n${originalContent}`;
+    // 记录注入信息
+    log.inject('注入上下文', {
+      sessionId,
+      historyCount: history.length,
+      originalLength: session.content?.length || 0,
+      newLength: contextPrefix.length + originalContent.length,
+      timeRange: history.length > 0 ? {
+        from: formatTime(history[0].timestamp),
+        to: formatTime(history[history.length-1].timestamp)
+      } : null
+    }, `注入 ${history.length} 条历史到会话 ${sessionId}`);
 
-    if (config.verbose) {
-      logger.info(`[GroupMemory] ${sessionId} 触发上下文注入。历史条数: ${history.length}`);
-    }
+    session.content = `${contextPrefix}\n${originalContent}`;
 
     return next();
-  }, 100);
+  }, 0);
 
-  // --- 命令：查看当前会话的上下文 ---
+  // --- 命令：查看上下文 ---
   ctx.command('memory-view [count]', '查看当前会话的历史记录')
     .alias('mem-view')
     .action(async ({ session }, count = 5) => {
-      const { sessionId, sessionType } = generateSessionId(session);
+      const sessionInfo = generateSessionId(session);
+      const sessionId = sessionInfo.separateId || sessionInfo.sessionId;
+      const sessionType = sessionInfo.sessionType;
+      
+      log.command('memory-view', session.userId, { sessionId, count });
+
       const history = await getContext(sessionId, parseInt(count));
 
       if (history.length === 0) {
@@ -332,16 +693,23 @@ exports.apply = (ctx, config) => {
       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 sessionInfo = generateSessionId(session);
+      const sessionId = sessionInfo.separateId || sessionInfo.sessionId;
+      const sessionType = sessionInfo.sessionType;
+      
+      log.command('memory-clear', session.userId, { sessionId });
+
       const result = await clearContext(sessionId);
 
       if (result) {
+        log.success(`清空会话 ${sessionId} 成功`);
         return `✅ 已清空当前${sessionType === 'private' ? '私聊' : '群聊'}的对话记忆！`;
       } else {
+        log.error(`清空会话 ${sessionId} 失败`);
         return '❌ 清空记忆失败，请查看日志。';
       }
     });
@@ -355,13 +723,25 @@ exports.apply = (ctx, config) => {
         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` +
+        const status = `🧠 Group Memory 插件状态\n` +
                `总消息数: ${allMessages.length}\n` +
                `私聊消息: ${privateCount.length}\n` +
                `群聊消息: ${groupCount.length}\n` +
                `最大上下文: ${config.maxContext} 轮\n` +
-               `时间窗口: ${config.timeWindow > 0 ? config.timeWindow / 60000 + ' 分钟' : '无限制'}`;
+               `时间窗口: ${config.timeWindow > 0 ? config.timeWindow / 60000 + ' 分钟' : '无限制'}\n` +
+               `独立上下文支持: ${config.supportSeparateContext ? '✅' : '❌'}\n` +
+               `日志级别: ${config.logLevel === 'none' ? '❌' : config.logLevel === 'simple' ? '📝 简易' : '📊 详细'}`;
+
+        log.command('memory-status', 'system', { 
+          total: allMessages.length,
+          private: privateCount.length,
+          group: groupCount.length,
+          logLevel: config.logLevel
+        });
+
+        return status;
       } catch (error) {
+        log.error('获取状态失败', error);
         return `❌ 获取状态失败: ${error.message}`;
       }
     });
@@ -374,23 +754,80 @@ exports.apply = (ctx, config) => {
         return '⚠️ 时间窗口设置为 0，不会清理任何消息。';
       }
 
+      log.command('memory-cleanup', 'system', {});
+
       try {
-        const allMessages = await ctx.database.get('group_memory_messages', {}, { fields: ['id', 'timestamp'] });
+        const allMessages = await ctx.database.get('group_memory_messages', {}, { fields: ['id', 'timestamp', 'session_id'] });
         const cutoff = Date.now() - config.timeWindow;
-        let deletedCount = 0;
-
+        const expiredByTime = allMessages.filter(msg => msg.timestamp < cutoff);
+        
+        // 按数量限制清理
+        const sessions = {};
         for (const msg of allMessages) {
-          if (new Date(msg.timestamp).getTime() < cutoff) {
-            await ctx.database.remove('group_memory_messages', { id: msg.id });
-            deletedCount++;
+          if (!sessions[msg.session_id]) {
+            sessions[msg.session_id] = [];
           }
+          sessions[msg.session_id].push(msg);
+        }
+
+        const expiredByCount = [];
+        for (const [sessionId, msgs] of Object.entries(sessions)) {
+          msgs.sort((a, b) => a.id - b.id);
+          if (msgs.length > config.maxContext * 2) {
+            expiredByCount.push(...msgs.slice(0, msgs.length - config.maxContext * 2));
+          }
+        }
+
+        // 合并去重
+        const toDelete = [...new Set([...expiredByTime, ...expiredByCount].map(msg => msg.id))];
+        
+        if (toDelete.length > 0) {
+          await ctx.database.remove('group_memory_messages', { id: toDelete });
+          
+          // 清空相关缓存
+          const affectedSessions = [...new Set(allMessages
+            .filter(msg => toDelete.includes(msg.id))
+            .map(msg => msg.session_id))];
+          affectedSessions.forEach(sid => {
+            memoryCache.delete(sid);
+            cacheTimestamps.delete(sid);
+          });
+          
+          log.cleanup(toDelete.length, { affectedSessions: affectedSessions.length });
         }
 
-        return `🧹 清理完成，删除了 ${deletedCount} 条过期消息。`;
+        return `🧹 清理完成，删除了 ${toDelete.length} 条过期消息。`;
       } catch (error) {
+        log.error('清理失败', error);
         return `❌ 清理失败: ${error.message}`;
       }
     });
 
-  logger.info('Group Memory 插件已加载');
+  // 清理定时器
+  const cleanupTimer = setInterval(() => {
+    if (config.timeWindow > 0) {
+      ctx.command('memory-cleanup').execute({}).catch(err => {
+        log.error('自动清理失败', err);
+      });
+    }
+  }, 3600000);
+
+  // 插件卸载时清理
+  ctx.on('dispose', () => {
+    clearInterval(cleanupTimer);
+    memoryCache.clear();
+    cacheTimestamps.clear();
+    sessionLocks.clear();
+    log.success('插件卸载完成', {});
+  });
+
+  // 启动日志
+  log.success('Group Memory 插件已加载', {
+    logLevel: config.logLevel,
+    databaseOps: config.logDatabaseOps,
+    contextInject: config.logContextInject,
+    apiCalls: config.logApiCalls
+  });
+
+  logger.info(`Group Memory 插件已加载，日志级别: ${config.logLevel}`);
 };