koishi-plugin-group-memory 1.2.1 → 2.1.0

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "koishi-plugin-group-memory",
-  "version": "1.2.1",
-  "description": "智能群聊记忆中间件：自动记录上下文，在@或回复时注入前情提要，支持时间窗口过滤与内容清洗",
-  "main": "./src/index.js",
+  "version": "2.1.0",
+  "description": "群聊和私聊上下文记忆插件，为 AI 插件提供历史记录查询接口。支持数据库持久化、自动清理、上下文注入，可与其他 AI 插件无缝协作",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src"
+  ],
   "scripts": {
+    "build": "atsc -b",
+    "build:watch": "atsc -b -w",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -11,32 +18,45 @@
     "plugin",
     "memory",
     "context",
-    "group-chat",
+    "chat-history",
+    "group-memory",
+    "database",
+    "cache",
     "ai",
-    "middleware",
-    "deepseek",
-    "openai"
+    "llm",
+    "conversation",
+    "history"
   ],
   "author": "YourName",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "https://github.com/yourusername/koishi-plugin-group-memory"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/koishi-plugin-group-memory/issues"
   },
+  "homepage": "https://github.com/yourusername/koishi-plugin-group-memory#readme",
   "koishi": {
     "description": {
-      "en": "Smart group chat memory middleware. Automatically records context and injects summaries when @mentioned or replied. Supports time-window filtering, content cleaning (mentions/images), and custom templates. Perfect for making AI bots aware of ongoing conversations.",
-      "zh": "智能群聊记忆中间件。自动记录群内闲聊上下文，当用户 @机器人 或回复机器人时，自动将“前情提要”注入给 AI 插件。支持按时间/条数过滤记忆、自动清洗 @符号和图片、自定义提示词模板。是让 AI 机器人拥有“群聊感知力”的必备插件。"
+      "en": "Group and private chat memory plugin. Provides history query interface for AI plugins. Supports database persistence, auto-cleanup, context injection, and seamless collaboration with other AI plugins.",
+      "zh": "群聊和私聊上下文记忆插件，为 AI 插件提供历史记录查询接口。支持数据库持久化、自动清理、上下文注入，可与其他 AI 插件无缝协作。"
     },
     "service": {
-      "required": [],
+      "required": ["database"],
       "optional": []
     }
   },
   "peerDependencies": {
     "koishi": "^4.16.0"
   },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "atsc": "^1.2.0",
+    "typescript": "^5.0.0"
+  },
   "engines": {
     "node": ">=18.0.0"
-  }
+  },
+  "dependencies": {}
 }

package/src/index.js

@@ -4,17 +4,16 @@ exports.name = 'group-memory';
 exports.usage = '自动记录群聊和私聊上下文，并为 AI 插件提供历史记录查询接口。支持数据库存储，群聊共享上下文，私聊独立上下文。';
 
 // --- 数据库表结构 ---
-const MessageSchema = Schema.object({
-  id: Schema.number().role('primary').required(),
-  session_id: Schema.string().required(),
-  session_type: Schema.string().required(),
-  user_id: Schema.string().required(),
-  user_name: Schema.string().default(''),
-  role: Schema.string().required(),
-  content: Schema.string().required(),
-  timestamp: Schema.number().required(),  // 改为 number
-});
-
+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({
@@ -26,10 +25,10 @@ exports.Config = Schema.object({
     .description('每个会话保留最近多少条消息作为上下文。'),
 
   timeWindow: Schema.number()
-    .default(3600000) // 1小时
+    .default(3600000)
     .min(0)
-    .step(60000) // 1分钟步进
-    .description('只保留最近 N 毫秒内的消息。设置为 0 表示不限制时间，只按条数限制。'),
+    .step(60000)
+    .description('只保留最近 N 毫秒内的消息。设置为 0 表示不限制时间。'),
 
   // --- 记录设置 ---
   recordPrivateChat: Schema.boolean()
@@ -52,170 +51,623 @@ exports.Config = Schema.object({
   // --- 内容处理 ---
   cleanMentions: Schema.boolean()
     .default(true)
-    .description('发送给 AI 前，是否移除消息中的 @ 符号 (避免 AI 困惑)。'),
+    .description('发送给 AI 前，是否移除消息中的 @ 符号。'),
 
   cleanImages: Schema.boolean()
     .default(true)
-    .description('是否移除图片/媒体占位符 (如 [图片])。'),
+    .description('是否移除图片/媒体占位符。'),
 
   // --- 调试 ---
   verbose: Schema.boolean()
     .default(false)
     .description('是否在控制台打印注入的上下文 (调试用)。'),
+
+  // ============================================
+  // 新增：日志显示功能（修复版）
+  // ============================================
+  logLevel: Schema.union([
+    Schema.const('none').description('不输出日志'),
+    Schema.const('simple').description('简易模式：输出易于理解的操作摘要'),
+    Schema.const('detailed').description('详细模式：输出完整的 JSON 格式日志'),
+  ]).default('detailed').description('日志输出级别（默认详细，便于调试）'),  // 改为默认 detailed
+
+  logDatabaseOps: Schema.boolean()
+    .default(true)
+    .description('是否记录数据库操作（增删改查）'),
+
+  logContextInject: Schema.boolean()
+    .default(true)
+    .description('是否记录上下文注入操作'),
+
+  logApiCalls: Schema.boolean()
+    .default(true)
+    .description('是否记录对外部插件的 API 调用'),
+
+  logMessageReceive: Schema.boolean()
+    .default(true)
+    .description('是否记录接收到的原始消息'),
+
+  logContentPreview: Schema.boolean()
+    .default(true)
+    .description('是否在简易模式下预览消息内容（只显示前30个字符）'),
+
+  logColorOutput: Schema.boolean()
+    .default(true)
+    .description('是否使用颜色区分不同类型的日志（需终端支持）'),
+
+  logTimestamp: Schema.boolean()
+    .default(true)
+    .description('是否在日志中显示时间戳'),
+
+  logMiddlewarePriority: Schema.boolean()
+    .default(true)
+    .description('是否记录中间件执行优先级信息'),
 });
 
 exports.schema = exports.Config;
 
-// --- 声明依赖注入 ---
 exports.inject = ['database'];
 
 exports.apply = (ctx, config) => {
   const logger = ctx.logger('group-memory');
 
-  // 内存缓存（用于快速访问，数据库持久化）
+  // ============================================
+  // 日志增强模块（修复版）
+  // ============================================
+  
+  // 立即输出启动日志，确认插件已加载
+  logger.info('='.repeat(50));
+  logger.info('🧠 Group Memory 插件正在初始化...');
+  logger.info(`日志级别: ${config.logLevel}`);
+  logger.info(`记录私聊: ${config.recordPrivateChat}`);
+  logger.info(`记录群聊: ${config.recordGroupChat}`);
+  logger.info('='.repeat(50));
+
+  // 颜色代码
+  const colors = {
+    reset: '\x1b[0m',
+    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',
+    }
+  };
+
+  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 = {
+    receive: '📥',
+    db: '🗄️',
+    cache: '⚡',
+    inject: '📎',
+    api: '🔌',
+    command: '⌨️',
+    error: '❌',
+    warning: '⚠️',
+    success: '✅',
+    info: 'ℹ️',
+    debug: '🔍',
+    memory: '🧠',
+    cleanup: '🧹',
+    middleware: '🔄'
+  };
+
+  // 增强的日志函数 - 确保立即输出
+  const log = {
+    // 接收消息日志
+    receive: (session, details, simpleMsg) => {
+      if (config.logLevel === 'none') return;
+      if (!config.logMessageReceive) return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.receive;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'receive',
+          ...details
+        }, null, 2)}`);
+      } else {
+        const msg = simpleMsg || `收到消息: ${details.userName} ${details.contentPreview}`;
+        logger.info(`${timestamp}${icon} ${color(msg, colors.fg.cyan)}`);
+      }
+    },
+    
+    // 数据库操作日志
+    db: (operation, details, simpleMsg) => {
+      if (config.logLevel === 'none') return;
+      if (!config.logDatabaseOps) return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.db;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'database',
+          operation,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${simpleMsg || `数据库 ${operation}`}`);
+      }
+    },
+    
+    // 上下文注入日志
+    inject: (operation, details, simpleMsg) => {
+      if (config.logLevel === 'none') return;
+      if (!config.logContextInject) return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.inject;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'inject',
+          operation,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${simpleMsg || `上下文注入: ${operation}`}`);
+      }
+    },
+    
+    // API调用日志
+    api: (operation, details, simpleMsg) => {
+      if (config.logLevel === 'none') return;
+      if (!config.logApiCalls) return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.api;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'api',
+          operation,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${simpleMsg || `API: ${operation}`}`);
+      }
+    },
+    
+    // 中间件日志
+    middleware: (msg, details) => {
+      if (config.logLevel === 'none') return;
+      if (!config.logMiddlewarePriority) return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.middleware;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'middleware',
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${msg}`);
+      }
+    },
+    
+    // 命令日志
+    command: (cmd, user, details) => {
+      if (config.logLevel === 'none') return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.command;
+      const simpleMsg = `命令 ${cmd} 由 ${user} 执行`;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'command',
+          command: cmd,
+          user,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${simpleMsg}`);
+      }
+    },
+    
+    // 错误日志
+    error: (msg, error) => {
+      if (config.logLevel === 'none') return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.error;
+      const errorMsg = error ? `${msg}: ${error.message}` : msg;
+      
+      logger.error(`${timestamp}${icon} ${color(errorMsg, colors.fg.red)}`);
+      
+      if (config.logLevel === 'detailed' && error?.stack) {
+        logger.error(error.stack);
+      }
+    },
+    
+    // 成功日志
+    success: (msg, details) => {
+      if (config.logLevel === 'none') return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.success;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'success',
+          message: msg,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${color(msg, colors.fg.green)}`);
+      }
+    },
+    
+    // 缓存日志
+    cache: (operation, details) => {
+      if (config.logLevel === 'none') return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.cache;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'cache',
+          operation,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} 缓存 ${operation}`);
+      }
+    },
+    
+    // 清理日志
+    cleanup: (count, details) => {
+      if (config.logLevel === 'none') return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.cleanup;
+      const simpleMsg = `清理了 ${count} 条过期消息`;
+      
+      if (config.logLevel === 'detailed') {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'cleanup',
+          count,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${simpleMsg}`);
+      }
+    },
+    
+    // 信息日志
+    info: (msg, details) => {
+      if (config.logLevel === 'none') return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.info;
+      
+      if (config.logLevel === 'detailed' && details) {
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          message: msg,
+          ...details
+        }, null, 2)}`);
+      } else {
+        logger.info(`${timestamp}${icon} ${msg}`);
+      }
+    }
+  };
+
+  // 内存缓存
   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 });
+    return () => {
+      sessionLocks.delete(sessionId);
+      log.cache('解锁', { sessionId });
+    };
+  };
 
   // 确保数据库表存在
-  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('数据库表初始化完成');
 
   // --- 辅助函数：生成会话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 ? `group:${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) => {
+    if (!content) return '';
+    
     let text = content;
+    const originalPreview = text.substring(0, 30);
 
-    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: originalPreview,
+      result: result.substring(0, 30)
+    }, `内容清理: ${originalPreview} -> ${result.substring(0, 30)}`);
+    
+    return result;
+  };
+
+  // --- 辅助函数：格式化时间 ---
+  const formatTime = (timestamp) => {
+    const date = new Date(timestamp);
+    return `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
   };
 
-  // --- 核心 API：获取上下文（供其他插件调用） ---
+  // --- 清理缓存 ---
+  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 });
+    }
+  };
+  setInterval(cleanupCache, CACHE_TTL);
+
+  // --- 核心 API：获取上下文 ---
   const getContext = async (sessionId, limit = null) => {
+    log.api('getContext', { sessionId, limit });
+    
+    if (memoryCache.has(sessionId)) {
+      const cached = memoryCache.get(sessionId);
+      const age = Date.now() - cacheTimestamps.get(sessionId);
+      if (age < CACHE_TTL) {
+        log.cache('命中', { sessionId, count: cached.length });
+        return cached;
+      } else {
+        log.cache('过期', { sessionId, age });
+      }
+    }
+
     const maxMessages = limit ? limit * 2 : config.maxContext * 2;
+    log.db('查询', { sessionId, maxMessages });
 
     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 => msg.timestamp >= cutoff);
+        log.db('时间窗口过滤', { before, after: history.length });
       }
 
+      memoryCache.set(sessionId, history);
+      cacheTimestamps.set(sessionId, Date.now());
+      log.cache('更新', { sessionId, count: 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 });
+    
+    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: Date.now(),  // ← 修改这里
+        timestamp: Date.now(),
+      };
+
+      log.db('创建', { 
+        sessionId, 
+        role, 
+        userName,
+        contentPreview: content.substring(0, 30)
       });
 
-      // 清理旧消息
-      await cleanupOldMessages(sessionId);
+      await ctx.database.create('group_memory_messages', messageData);
+
+      memoryCache.delete(sessionId);
+      cacheTimestamps.delete(sessionId);
+      log.cache('失效', { sessionId });
+
+      // 异步清理旧消息
+      cleanupOldMessages(sessionId).catch(err => {
+        log.error('异步清理失败', err);
+      });
 
       return true;
     } catch (error) {
-      logger.error('保存消息失败:', error.message);
+      log.error('保存消息失败', error);
       return false;
+    } finally {
+      release();
     }
   };
 
-  // --- 核心 API：清空上下文（供其他插件调用） ---
+  // --- API：删除最后一条消息 ---
+  const deleteLastMessage = async (sessionId, role) => {
+    log.api('deleteLastMessage', { sessionId, role });
+    
+    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 });
+        await ctx.database.remove('group_memory_messages', { id: lastMessage[0].id });
+        memoryCache.delete(sessionId);
+        cacheTimestamps.delete(sessionId);
+        return true;
+      }
+      
+      return false;
+    } catch (error) {
+      log.error('删除消息失败', error);
+      return false;
+    } finally {
+      release();
+    }
+  };
+
+  // --- API：清空上下文 ---
   const clearContext = async (sessionId) => {
+    log.api('clearContext', { 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 });
+      
       memoryCache.delete(sessionId);
+      cacheTimestamps.delete(sessionId);
+      log.cache('失效', { 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);
       }
 
-      // 如果时间窗口设置，删除过期的消息
       if (config.timeWindow > 0) {
         const cutoff = Date.now() - config.timeWindow;
-        const expiredMessages = allMessages.filter(msg => msg.timestamp < 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);
+      }
+
+      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 });
       }
     } catch (error) {
-      logger.error('清理旧消息失败:', error.message);
+      log.error('清理旧消息失败', error);
+    } finally {
+      release();
     }
   };
 
@@ -224,96 +676,188 @@ exports.apply = (ctx, config) => {
     getContext,
     saveMessage,
     clearContext,
+    deleteLastMessage,
   };
 
-  // --- 中间件1: 记录所有消息 ---
+  log.success('API 接口已暴露');
+
+  // ============================================
+  // 修复：中间件 - 记录所有消息（提高优先级）
+  // ============================================
   ctx.middleware(async (session, next) => {
-    if (session.selfId === session.userId) return next();
+    // 记录中间件执行
+    log.middleware('执行消息记录中间件', {
+      userId: session.userId,
+      groupId: session.groupId,
+      content: session.content?.substring(0, 30)
+    });
+
+    if (session.selfId === session.userId) {
+      log.middleware('忽略机器人自身消息');
+      return next();
+    }
 
     const trimmed = session.content?.trim() || '';
-    if (!trimmed) return next();
+    if (!trimmed) {
+      log.middleware('忽略空消息');
+      return next();
+    }
+
+    // 记录原始消息接收
+    const contentPreview = trimmed.substring(0, 50) + (trimmed.length > 50 ? '...' : '');
+    const userName = session.author?.nickname || session.userId;
+    const chatType = !session.groupId ? '私聊' : '群聊';
+    
+    log.receive(session, {
+      userId: session.userId,
+      userName,
+      groupId: session.groupId,
+      content: trimmed,
+      contentPreview,
+      chatType
+    }, `${chatType} ${userName}: ${contentPreview}`);
 
     // 忽略命令消息
-    if (/^[./\\]/.test(trimmed)) return next();
+    if (/^[./\\]/.test(trimmed)) {
+      log.middleware('忽略命令消息');
+      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();
+    if (sessionType === 'private' && !config.recordPrivateChat) {
+      log.middleware('私聊记录已禁用');
+      return next();
+    }
+    if (sessionType === 'group' && !config.recordGroupChat) {
+      log.middleware('群聊记录已禁用');
+      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,
+      contentPreview: cleanText.substring(0, 30)
+    });
 
-    if (config.verbose) {
-      logger.info(`记录消息 [${sessionType}] ${userName}: ${cleanText.substring(0, 50)}...`);
+    // 立即保存并等待完成，确保日志输出
+    try {
+      await saveMessage(sessionId, 'user', cleanText, session.userId, userName);
+      log.success(`消息已保存: ${sessionId}`);
+    } catch (err) {
+      log.error('保存消息失败', err);
     }
 
     return next();
-  }, true);
+  }, 100); // 提高优先级到 100，确保先执行
 
-  // --- 中间件2: 上下文注入（可选功能） ---
+  // ============================================
+  // 中间件2: 上下文注入（保持优先级 0）
+  // ============================================
   ctx.middleware(async (session, next) => {
-    if (!session.groupId && !config.recordPrivateChat) return next();
-    if (session.groupId && !config.recordGroupChat) return next();
+    log.middleware('执行上下文注入中间件', {
+      userId: session.userId,
+      groupId: session.groupId
+    });
+
+    if (!session.groupId && !config.recordPrivateChat) {
+      log.middleware('私聊注入已禁用');
+      return next();
+    }
+    if (session.groupId && !config.recordGroupChat) {
+      log.middleware('群聊注入已禁用');
+      return next();
+    }
 
     let shouldInject = false;
+    let injectReason = '';
 
     // 检查是否 @ 机器人
     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;
+                      (session.content && new RegExp(`<@${session.selfId}>|@${session.selfId}\\b`).test(session.content));
+      if (isAtBot) {
+        shouldInject = true;
+        injectReason = '@机器人';
+      }
     }
 
     // 检查是否回复机器人
     if (!shouldInject && config.triggerOnReply && session.quote) {
       if (session.quote.userId === session.selfId) {
         shouldInject = true;
+        injectReason = '回复机器人';
       }
     }
 
-    if (!shouldInject) return next();
+    if (!shouldInject) {
+      log.middleware('无需注入上下文');
+      return next();
+    }
+
+    log.info(`触发上下文注入: ${injectReason}`);
 
-    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();
+    if (history.length === 0) {
+      log.middleware('无历史记录可注入');
+      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) {
@@ -331,16 +875,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 '❌ 清空记忆失败，请查看日志。';
       }
     });
@@ -354,13 +905,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}`;
       }
     });
@@ -373,23 +936,79 @@ 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 (msg.timestamp < 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);
         }
 
-        return `🧹 清理完成，删除了 ${deletedCount} 条过期消息。`;
+        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 `🧹 清理完成，删除了 ${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 插件已完全加载，等待消息...');
+  log.info('当前配置:', {
+    recordPrivateChat: config.recordPrivateChat,
+    recordGroupChat: config.recordGroupChat,
+    logLevel: config.logLevel,
+    maxContext: config.maxContext
+  });
 };