koishi-plugin-group-memory 2.0.0 → 2.1.0

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "koishi-plugin-group-memory",
-  "version": "2.0.0",
-  "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

@@ -17,16 +17,59 @@ const MessageFields = {
 
 // --- 配置架构 ---
 exports.Config = Schema.object({
-  // ... 其他配置保持不变 ...
+  // --- 存储设置 ---
+  maxContext: Schema.number()
+    .default(20)
+    .min(1)
+    .max(100)
+    .description('每个会话保留最近多少条消息作为上下文。'),
+
+  timeWindow: Schema.number()
+    .default(3600000)
+    .min(0)
+    .step(60000)
+    .description('只保留最近 N 毫秒内的消息。设置为 0 表示不限制时间。'),
+
+  // --- 记录设置 ---
+  recordPrivateChat: Schema.boolean()
+    .default(true)
+    .description('是否记录私聊消息。'),
+
+  recordGroupChat: Schema.boolean()
+    .default(true)
+    .description('是否记录群聊消息。'),
+
+  // --- 触发条件（用于中间件模式） ---
+  triggerOnAt: Schema.boolean()
+    .default(true)
+    .description('当消息中包含 @机器人 时，触发上下文注入。'),
+
+  triggerOnReply: Schema.boolean()
+    .default(true)
+    .description('当消息是回复机器人的消息时，触发上下文注入。'),
+
+  // --- 内容处理 ---
+  cleanMentions: Schema.boolean()
+    .default(true)
+    .description('发送给 AI 前，是否移除消息中的 @ 符号。'),
+
+  cleanImages: Schema.boolean()
+    .default(true)
+    .description('是否移除图片/媒体占位符。'),
+
+  // --- 调试 ---
+  verbose: Schema.boolean()
+    .default(false)
+    .description('是否在控制台打印注入的上下文 (调试用)。'),
 
   // ============================================
-  // 新增：日志显示功能
+  // 新增：日志显示功能（修复版）
   // ============================================
   logLevel: Schema.union([
     Schema.const('none').description('不输出日志'),
     Schema.const('simple').description('简易模式：输出易于理解的操作摘要'),
     Schema.const('detailed').description('详细模式：输出完整的 JSON 格式日志'),
-  ]).default('simple').description('日志输出级别'),
+  ]).default('detailed').description('日志输出级别（默认详细，便于调试）'),  // 改为默认 detailed
 
   logDatabaseOps: Schema.boolean()
     .default(true)
@@ -40,6 +83,10 @@ exports.Config = Schema.object({
     .default(true)
     .description('是否记录对外部插件的 API 调用'),
 
+  logMessageReceive: Schema.boolean()
+    .default(true)
+    .description('是否记录接收到的原始消息'),
+
   logContentPreview: Schema.boolean()
     .default(true)
     .description('是否在简易模式下预览消息内容（只显示前30个字符）'),
@@ -51,6 +98,10 @@ exports.Config = Schema.object({
   logTimestamp: Schema.boolean()
     .default(true)
     .description('是否在日志中显示时间戳'),
+
+  logMiddlewarePriority: Schema.boolean()
+    .default(true)
+    .description('是否记录中间件执行优先级信息'),
 });
 
 exports.schema = exports.Config;
@@ -61,19 +112,20 @@ 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',
-    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',
@@ -83,39 +135,25 @@ exports.apply = (ctx, config) => {
       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 = {
+    receive: '📥',
     db: '🗄️',
     cache: '⚡',
     inject: '📎',
@@ -127,137 +165,210 @@ exports.apply = (ctx, config) => {
     info: 'ℹ️',
     debug: '🔍',
     memory: '🧠',
-    cleanup: '🧹'
+    cleanup: '🧹',
+    middleware: '🔄'
   };
 
-  // 简易日志函数
-  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)}`);
+  // 增强的日志函数 - 确保立即输出
+  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 {
-        logger.info(logMessage);
+        const msg = simpleMsg || `收到消息: ${details.userName} ${details.contentPreview}`;
+        logger.info(`${timestamp}${icon} ${color(msg, colors.fg.cyan)}`);
       }
-    } 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.logLevel === 'none') return;
       if (!config.logDatabaseOps) return;
+      
+      const timestamp = getTimestamp();
+      const icon = icons.db;
+      
       if (config.logLevel === 'detailed') {
-        logDetailed('db', operation, details);
-      } else if (config.logLevel === 'simple') {
-        logSimple('db', simpleMsg || `${operation} 操作`, details);
+        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') {
-        logDetailed('inject', operation, details);
-      } else if (config.logLevel === 'simple') {
-        logSimple('inject', simpleMsg || `上下文注入: ${operation}`, details);
+        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') {
-        logDetailed('api', operation, details);
-      } else if (config.logLevel === 'simple') {
-        logSimple('api', simpleMsg || `API调用: ${operation}`, details);
+        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') {
-        logDetailed('command', cmd, { user, ...details });
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'command',
+          command: cmd,
+          user,
+          ...details
+        }, null, 2)}`);
       } else {
-        logSimple('command', simpleMsg, details);
+        logger.info(`${timestamp}${icon} ${simpleMsg}`);
       }
     },
     
+    // 错误日志
     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);
+      
+      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') {
-        logDetailed('success', '成功', { message: msg, ...details });
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'success',
+          message: msg,
+          ...details
+        }, null, 2)}`);
       } else {
-        logSimple('success', `✅ ${msg}`, details);
+        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') {
-        logDetailed('cache', operation, details);
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'cache',
+          operation,
+          ...details
+        }, null, 2)}`);
       } else {
-        logSimple('cache', `缓存 ${operation}`, details);
+        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') {
-        logDetailed('cleanup', '清理', { count, ...details });
+        logger.info(`${timestamp}${icon} ${JSON.stringify({
+          type: 'cleanup',
+          count,
+          ...details
+        }, null, 2)}`);
       } else {
-        logSimple('cleanup', simpleMsg, details);
+        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}`);
       }
     }
   };
@@ -280,10 +391,10 @@ exports.apply = (ctx, config) => {
       await new Promise(resolve => setTimeout(resolve, 100));
     }
     sessionLocks.set(sessionId, true);
-    log.cache('锁定', { sessionId, action: 'lock' });
+    log.cache('锁定', { sessionId });
     return () => {
       sessionLocks.delete(sessionId);
-      log.cache('解锁', { sessionId, action: 'unlock' });
+      log.cache('解锁', { sessionId });
     };
   };
 
@@ -294,30 +405,35 @@ exports.apply = (ctx, config) => {
     index: ['session_id', 'session_type', 'timestamp']
   });
   
-  log.success('数据库表初始化完成', { table: 'group_memory_messages' });
+  log.success('数据库表初始化完成');
 
   // --- 辅助函数：生成会话ID ---
   const generateSessionId = (session) => {
     const result = !session.groupId 
-      ? { sessionId: `private:${session.userId}`, sessionType: 'private' }
+      ? { 
+          sessionId: `private:${session.userId}`, 
+          sessionType: 'private' 
+        }
       : { 
           sessionId: `group:${session.groupId}`,
-          separateId: config.supportSeparateContext ? `${session.groupId}:user:${session.userId}` : undefined,
+          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}`);
+    }, `会话ID: ${result.sessionId}`);
     
     return result;
   };
 
   // --- 辅助函数：清理内容 ---
   const cleanContent = (content, session) => {
+    if (!content) return '';
+    
     let text = content;
-    const originalLength = text.length;
+    const originalPreview = text.substring(0, 30);
 
     if (config.cleanMentions && session) {
       text = text.replace(new RegExp(`<@${session.selfId}>`, 'g'), '')
@@ -335,10 +451,9 @@ exports.apply = (ctx, config) => {
     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} 字符`);
+      original: originalPreview,
+      result: result.substring(0, 30)
+    }, `内容清理: ${originalPreview} -> ${result.substring(0, 30)}`);
     
     return result;
   };
@@ -361,29 +476,28 @@ exports.apply = (ctx, config) => {
       }
     }
     if (cleaned > 0) {
-      log.cache('清理过期缓存', { cleaned, ttl: CACHE_TTL });
+      log.cache('清理过期缓存', { cleaned });
     }
   };
   setInterval(cleanupCache, CACHE_TTL);
 
   // --- 核心 API：获取上下文 ---
   const getContext = async (sessionId, limit = null) => {
-    log.api('getContext', { sessionId, limit }, `获取上下文: ${sessionId}`);
+    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, age, count: cached.length }, `缓存命中: ${sessionId} (${cached.length}条)`);
+        log.cache('命中', { sessionId, count: cached.length });
         return cached;
       } else {
-        log.cache('过期', { sessionId, age }, `缓存过期: ${sessionId}`);
+        log.cache('过期', { sessionId, age });
       }
     }
 
     const maxMessages = limit ? limit * 2 : config.maxContext * 2;
-    log.db('查询', { sessionId, maxMessages }, `查询数据库: ${sessionId}`);
+    log.db('查询', { sessionId, maxMessages });
 
     try {
       let history = await ctx.database.get('group_memory_messages',
@@ -401,13 +515,12 @@ exports.apply = (ctx, config) => {
         const before = history.length;
         const cutoff = Date.now() - config.timeWindow;
         history = history.filter(msg => msg.timestamp >= cutoff);
-        log.db('时间窗口过滤', { before, after: history.length, cutoff }, `过滤时间窗口: ${before} -> ${history.length}条`);
+        log.db('时间窗口过滤', { before, after: history.length });
       }
 
-      // 更新缓存
       memoryCache.set(sessionId, history);
       cacheTimestamps.set(sessionId, Date.now());
-      log.cache('更新', { sessionId, count: history.length }, `更新缓存: ${sessionId} (${history.length}条)`);
+      log.cache('更新', { sessionId, count: history.length });
 
       return history;
     } catch (error) {
@@ -418,7 +531,7 @@ exports.apply = (ctx, config) => {
 
   // --- 核心 API：保存消息 ---
   const saveMessage = async (sessionId, role, content, userId = 'system', userName = 'System') => {
-    log.api('saveMessage', { sessionId, role, userId }, `保存消息: ${role} @ ${sessionId}`);
+    log.api('saveMessage', { sessionId, role, userId });
     
     const release = await lockSession(sessionId);
     
@@ -435,14 +548,18 @@ exports.apply = (ctx, config) => {
         timestamp: Date.now(),
       };
 
-      log.db('创建', messageData, `插入消息: ${role} (${content.substring(0, 30)}...)`);
+      log.db('创建', { 
+        sessionId, 
+        role, 
+        userName,
+        contentPreview: content.substring(0, 30)
+      });
 
       await ctx.database.create('group_memory_messages', messageData);
 
-      // 使缓存失效
       memoryCache.delete(sessionId);
       cacheTimestamps.delete(sessionId);
-      log.cache('失效', { sessionId }, `缓存失效: ${sessionId}`);
+      log.cache('失效', { sessionId });
 
       // 异步清理旧消息
       cleanupOldMessages(sessionId).catch(err => {
@@ -460,7 +577,7 @@ exports.apply = (ctx, config) => {
 
   // --- API：删除最后一条消息 ---
   const deleteLastMessage = async (sessionId, role) => {
-    log.api('deleteLastMessage', { sessionId, role }, `删除最后一条 ${role} 消息: ${sessionId}`);
+    log.api('deleteLastMessage', { sessionId, role });
     
     const release = await lockSession(sessionId);
     
@@ -474,14 +591,13 @@ exports.apply = (ctx, config) => {
       );
       
       if (lastMessage && lastMessage.length > 0) {
-        log.db('删除', { id: lastMessage[0].id }, `删除消息 ID: ${lastMessage[0].id}`);
+        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;
       }
       
-      log.db('删除', { sessionId, role }, `未找到要删除的消息`);
       return false;
     } catch (error) {
       log.error('删除消息失败', error);
@@ -493,17 +609,17 @@ exports.apply = (ctx, config) => {
 
   // --- API：清空上下文 ---
   const clearContext = async (sessionId) => {
-    log.api('clearContext', { sessionId }, `清空上下文: ${sessionId}`);
+    log.api('clearContext', { sessionId });
     
     const release = await lockSession(sessionId);
     
     try {
       const count = await ctx.database.remove('group_memory_messages', { session_id: sessionId });
-      log.db('清空', { sessionId, count }, `清空了 ${count} 条消息`);
+      log.db('清空', { sessionId, count });
       
       memoryCache.delete(sessionId);
       cacheTimestamps.delete(sessionId);
-      log.cache('失效', { sessionId }, `缓存失效: ${sessionId}`);
+      log.cache('失效', { sessionId });
       
       return true;
     } catch (error) {
@@ -527,23 +643,18 @@ exports.apply = (ctx, config) => {
       const maxMessages = config.maxContext * 2;
       let toDelete = [];
 
-      // 按数量限制
       if (allMessages.length > maxMessages) {
         allMessages.sort((a, b) => a.id - b.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 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 });
@@ -551,7 +662,7 @@ exports.apply = (ctx, config) => {
         memoryCache.delete(sessionId);
         cacheTimestamps.delete(sessionId);
         
-        log.cleanup(uniqueIds.length, { sessionId, ids: uniqueIds });
+        log.cleanup(uniqueIds.length, { sessionId });
       }
     } catch (error) {
       log.error('清理旧消息失败', error);
@@ -568,69 +679,140 @@ exports.apply = (ctx, config) => {
     deleteLastMessage,
   };
 
-  log.success('API 接口已暴露', { methods: ['getContext', 'saveMessage', 'clearContext', 'deleteLastMessage'] });
+  log.success('API 接口已暴露');
 
-  // --- 中间件1: 记录所有消息 ---
+  // ============================================
+  // 修复：中间件 - 记录所有消息（提高优先级）
+  // ============================================
   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();
+    }
 
-    if (/^[./\\]/.test(trimmed)) 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)) {
+      log.middleware('忽略命令消息');
+      return next();
+    }
 
     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;
-
-    log.db('记录消息', {
+    
+    log.db('准备保存消息', {
       sessionId,
       sessionType,
       userId: session.userId,
       userName,
-      content: cleanText
-    }, `📝 ${userName}: ${cleanText.substring(0, 30)}...`);
-
-    saveMessage(sessionId, 'user', cleanText, session.userId, userName).catch(err => {
-      log.error('异步保存消息失败', err);
+      contentPreview: cleanText.substring(0, 30)
     });
 
+    // 立即保存并等待完成，确保日志输出
+    try {
+      await saveMessage(sessionId, 'user', cleanText, session.userId, userName);
+      log.success(`消息已保存: ${sessionId}`);
+    } catch (err) {
+      log.error('保存消息失败', err);
+    }
+
     return next();
-  }, -100);
+  }, 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}\\b`).test(session.content));
-      if (isAtBot) shouldInject = true;
+      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 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 => {
@@ -818,16 +1000,15 @@ exports.apply = (ctx, config) => {
     memoryCache.clear();
     cacheTimestamps.clear();
     sessionLocks.clear();
-    log.success('插件卸载完成', {});
+    log.success('插件卸载完成');
   });
 
-  // 启动日志
-  log.success('Group Memory 插件已加载', {
+  // 最终确认日志
+  log.success('✅ Group Memory 插件已完全加载，等待消息...');
+  log.info('当前配置:', {
+    recordPrivateChat: config.recordPrivateChat,
+    recordGroupChat: config.recordGroupChat,
     logLevel: config.logLevel,
-    databaseOps: config.logDatabaseOps,
-    contextInject: config.logContextInject,
-    apiCalls: config.logApiCalls
+    maxContext: config.maxContext
   });
-
-  logger.info(`Group Memory 插件已加载，日志级别: ${config.logLevel}`);
 };