inspiration-agent 0.0.1

package/dist/services/memory.manager.js

@@ -0,0 +1,486 @@
+const logger = require("../utils/logger");
+const tiktoken = require("tiktoken");
+
+const MEMORY_EXPIRY_DAYS = 30;
+const MAX_LONG_TERM_MEMORIES = 1000;
+const MIN_IMPORTANCE_THRESHOLD = 1;
+
+let encoder = null;
+
+function getEncoder() {
+  if (!encoder) {
+    encoder = tiktoken.get_encoding("cl100k_base");
+  }
+  return encoder;
+}
+
+class MemoryManager {
+  constructor(dbService, shortTermLimit = 20) {
+    this.dbService = dbService;
+    this.shortTermMemory = [];
+    this.shortTermLimit = shortTermLimit;
+    this.maxContextTokens = 100000;
+    this._archiveQueue = [];
+    this._isArchiving = false;
+  }
+
+  async _processArchiveQueue() {
+    if (this._isArchiving) return;
+    this._isArchiving = true;
+
+    while (this._archiveQueue.length > 0) {
+      const message = this._archiveQueue.shift();
+      try {
+        const memoryType = this.determineMemoryType(message);
+
+        const validTypes = ["important", "identity", "preference"];
+        if (validTypes.includes(memoryType)) {
+          await this.dbService.saveLongTermMemory({
+            type: memoryType,
+            content: message.content,
+            keywords: this.extractKeywords(message.content),
+            importance: this.calculateImportance(message),
+          });
+          logger.debug(`已归档记忆: ${memoryType}`);
+        }
+      } catch (error) {
+        logger.error(`归档记忆失败: ${error.message}`);
+      }
+    }
+
+    this._isArchiving = false;
+  }
+
+  async cleanupExpiredMemories() {
+    try {
+      const expiryDate = new Date();
+      expiryDate.setDate(expiryDate.getDate() - MEMORY_EXPIRY_DAYS);
+
+      const sql = `
+        DELETE FROM long_term_memory 
+        WHERE importance < ? 
+        AND last_accessed < datetime(?)
+      `;
+
+      const result = await new Promise((resolve, reject) => {
+        this.dbService.db.run(
+          sql,
+          [MIN_IMPORTANCE_THRESHOLD, expiryDate.toISOString()],
+          function (err) {
+            if (err) reject(err);
+            else resolve({ deleted: this.changes });
+          }
+        );
+      });
+
+      if (result.deleted > 0) {
+        logger.info(`已清理 ${result.deleted} 条过期记忆`);
+      }
+
+      return result;
+    } catch (error) {
+      logger.error(`清理过期记忆失败: ${error.message}`);
+      return { deleted: 0 };
+    }
+  }
+
+  async pruneMemoriesIfNecessary() {
+    try {
+      const countResult = await new Promise((resolve, reject) => {
+        this.dbService.db.get("SELECT COUNT(*) as count FROM long_term_memory", [], (err, row) => {
+          if (err) reject(err);
+          else resolve(row);
+        });
+      });
+
+      if (countResult.count > MAX_LONG_TERM_MEMORIES) {
+        const deleteCount = countResult.count - MAX_LONG_TERM_MEMORIES;
+
+        const sql = `
+          DELETE FROM long_term_memory 
+          WHERE id IN (
+            SELECT id FROM long_term_memory 
+            ORDER BY importance ASC, last_accessed ASC 
+            LIMIT ?
+          )
+        `;
+
+        const result = await new Promise((resolve, reject) => {
+          this.dbService.db.run(sql, [deleteCount], function (err) {
+            if (err) reject(err);
+            else resolve({ deleted: this.changes });
+          });
+        });
+
+        logger.info(`已修剪 ${result.deleted} 条低优先级记忆`);
+        return result;
+      }
+
+      return { deleted: 0 };
+    } catch (error) {
+      logger.error(`修剪记忆失败: ${error.message}`);
+      return { deleted: 0 };
+    }
+  }
+
+  /**
+   * 估算文本的 token 数量
+   * 使用更保守的估算：中文字符约 2 tokens，英文单词约 1.5 tokens
+   * @param {string} text - 要估算的文本
+   * @returns {number} 估算的 token 数量
+   */
+  estimateTokens(text) {
+    if (!text) return 0;
+    try {
+      const enc = getEncoder();
+      return enc.encode(text).length;
+    } catch (error) {
+      logger.warn(`tiktoken 编码失败，使用备用估算: ${error.message}`);
+      return Math.ceil(text.length / 4);
+    }
+  }
+
+  /**
+   * 计算消息数组的总 token 数量
+   * @param {Array} messages - 消息数组
+   * @returns {number} 总 token 数量
+   */
+  calculateTotalTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+      total += this.estimateTokens(msg.content || "");
+      if (msg.role) {
+        total += 5;
+      }
+    }
+    return total;
+  }
+
+  limitContextLength(messages) {
+    let totalTokens = this.calculateTotalTokens(messages);
+
+    if (totalTokens <= this.maxContextTokens) {
+      return messages;
+    }
+
+    const limitedMessages = [];
+    const droppedMessages = [];
+    let currentTokens = 0;
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      const msgTokens = this.estimateTokens(msg.content || "") + (msg.role ? 5 : 0);
+
+      if (currentTokens + msgTokens > this.maxContextTokens) {
+        droppedMessages.unshift(msg);
+        continue;
+      }
+
+      limitedMessages.unshift(msg);
+      currentTokens += msgTokens;
+    }
+
+    if (droppedMessages.length > 0) {
+      logger.debug(`丢弃 ${droppedMessages.length} 条超出上下文限制的消息`);
+    }
+
+    logger.debug(`\n========== 上下文长度限制 ==========`);
+    logger.debug(`原始 token 数: ${totalTokens}`);
+    logger.debug(`限制后 token 数: ${currentTokens}`);
+    logger.debug(`最大 token 限制: ${this.maxContextTokens}`);
+    logger.debug(`消息数量: ${messages.length} -> ${limitedMessages.length}`);
+    logger.debug(`已归档消息: ${droppedMessages.length}`);
+    logger.debug(`===================================\n`);
+
+    return limitedMessages;
+  }
+
+  addMessage(role, content) {
+    this.shortTermMemory.push({ role, content, timestamp: Date.now() });
+
+    while (this.shortTermMemory.length > this.shortTermLimit) {
+      this.shortTermMemory.shift();
+    }
+  }
+
+  async archiveToLongTerm(message) {
+    this._archiveQueue.push(message);
+    await this._processArchiveQueue();
+  }
+
+  async archiveAllShortTerm() {
+    for (const msg of this.shortTermMemory) {
+      this._archiveQueue.push(msg);
+    }
+    await this._processArchiveQueue();
+  }
+
+  determineMemoryType(message) {
+    const content = message.content.toLowerCase();
+
+    if (
+      content.includes("记住") ||
+      content.includes("记得") ||
+      content.includes("重要") ||
+      content.includes("关键") ||
+      content.includes("别忘了") ||
+      content.includes("不要忘记") ||
+      content.includes("帮我记") ||
+      content.includes("记录一下") ||
+      content.includes("记下来")
+    ) {
+      return "important";
+    }
+
+    if (
+      content.includes("偏好") ||
+      content.includes("喜欢") ||
+      content.includes("不喜欢") ||
+      content.includes("习惯") ||
+      content.includes("我通常") ||
+      content.includes("我一般")
+    ) {
+      return "preference";
+    }
+
+    if (content.includes("任务") || content.includes("计划") || content.includes("目标")) {
+      return "task";
+    }
+
+    if (
+      content.includes("名字") ||
+      content.includes("身份") ||
+      content.includes("职业") ||
+      content.includes("我是") ||
+      content.includes("我叫") ||
+      content.includes("我的名字")
+    ) {
+      return "identity";
+    }
+
+    if (content.includes("文件") || content.includes("路径") || content.includes("目录")) {
+      return "file_info";
+    }
+
+    return "conversation";
+  }
+
+  calculateImportance(message) {
+    let importance = 5;
+
+    const content = message.content.toLowerCase();
+
+    if (content.includes("重要") || content.includes("关键")) {
+      importance += 5;
+    }
+
+    if (
+      content.includes("记住") ||
+      content.includes("记得") ||
+      content.includes("别忘了") ||
+      content.includes("不要忘记")
+    ) {
+      importance += 4;
+    }
+
+    if (content.includes("我是") || content.includes("我叫") || content.includes("我的名字")) {
+      importance += 3;
+    }
+
+    if (content.includes("喜欢") || content.includes("偏好") || content.includes("习惯")) {
+      importance += 2;
+    }
+
+    if (message.role === "user") {
+      importance += 1;
+    }
+
+    return Math.min(importance, 10);
+  }
+
+  extractKeywords(content) {
+    const keywords = [];
+
+    const patterns = [
+      /文件[路径]*[:：]\s*([^\s,，。！？]+)/g,
+      /名字[是]*[:：]\s*([^\s,，。！？]+)/g,
+      /偏好[是]*[:：]\s*([^\s,，。！？]+)/g,
+      /任务[是]*[:：]\s*([^\s,，。！？]+)/g,
+      /记住[:：]?\s*([^\s,，。！？]+)/g,
+      /记得[:：]?\s*([^\s,，。！？]+)/g,
+      /我是([^\s,，。！？]+)/g,
+      /我叫([^\s,，。！？]+)/g,
+      /我的名字[是]*([^\s,，。！？]+)/g,
+    ];
+
+    patterns.forEach((pattern) => {
+      const matches = content.match(pattern);
+      if (matches) {
+        matches.forEach((match) => {
+          const keyword = match
+            .replace(
+              /文件[路径]*[:：]\s*|名字[是]*[:：]\s*|偏好[是]*[:：]\s*|任务[是]*[:：]\s*|记住[:：]?\s*|记得[:：]?\s*|我是|我叫|我的名字[是]*/g,
+              ""
+            )
+            .trim();
+          if (keyword && keyword.length > 0 && keyword.length < 50) {
+            keywords.push(keyword);
+          }
+        });
+      }
+    });
+
+    const importantWords = content.match(/[\u4e00-\u9fa5]{2,8}/g) || [];
+    importantWords.slice(0, 5).forEach((word) => {
+      if (
+        !keywords.includes(word) &&
+        !["这是", "那个", "这个", "什么", "怎么", "如何"].includes(word)
+      ) {
+        keywords.push(word);
+      }
+    });
+
+    return keywords;
+  }
+
+  /**
+   * 搜索相关的长期记忆
+   * @param {string} query - 搜索关键词
+   * @param {number} limit - 返回结果数量限制，默认 5
+   * @returns {Promise<Array>} 相关记忆数组
+   */
+  async searchRelevantMemories(query, limit = 5) {
+    try {
+      const memories = await this.dbService.searchLongTermMemories(query, limit);
+
+      memories.forEach((memory) => {
+        this.dbService.updateMemoryAccess(memory.id);
+      });
+
+      return memories;
+    } catch (error) {
+      logger.error(`搜索记忆失败: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * 获取最近的长期记忆
+   * @param {string|null} type - 记忆类型过滤，null 表示不过滤
+   * @param {number} limit - 返回结果数量限制，默认 10
+   * @returns {Promise<Array>} 记忆数组
+   */
+  async getRecentMemories(type = null, limit = 10) {
+    try {
+      return await this.dbService.getLongTermMemories(type, limit);
+    } catch (error) {
+      logger.error(`获取记忆失败: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * 获取短期记忆上下文
+   * @returns {Array} 短期记忆数组（不含 timestamp）
+   */
+  getShortTermContext() {
+    return this.shortTermMemory.map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+    }));
+  }
+
+  async buildFullContext(userMessage) {
+    const shortTerm = this.getShortTermContext();
+
+    const importantMemories = await this.getImportantMemories();
+
+    const keywords = this.extractKeywords(userMessage);
+
+    let relevantMemories = [];
+    if (keywords.length > 0) {
+      relevantMemories = await this.searchRelevantMemories(keywords.join(" "), 3);
+    }
+
+    const allMemories = [...importantMemories];
+    for (const mem of relevantMemories) {
+      if (!allMemories.find((m) => m.id === mem.id)) {
+        allMemories.push(mem);
+      }
+    }
+
+    const memoryContext = allMemories.map((mem) => ({
+      role: "system",
+      content: `[长期记忆] ${mem.type}: ${mem.content}`,
+    }));
+
+    const fullContext = [...memoryContext, ...shortTerm];
+
+    return this.limitContextLength(fullContext);
+  }
+
+  async getImportantMemories() {
+    try {
+      const importantTypes = ["important", "identity", "preference"];
+      const memories = [];
+
+      for (const type of importantTypes) {
+        const typeMemories = await this.dbService.getLongTermMemories(type, 5);
+        for (const mem of typeMemories) {
+          if (!memories.find((m) => m.id === mem.id)) {
+            memories.push(mem);
+          }
+        }
+      }
+
+      return memories;
+    } catch (error) {
+      logger.error(`获取重要记忆失败: ${error.message}`);
+      return [];
+    }
+  }
+
+  clearShortTerm() {
+    this.shortTermMemory = [];
+    logger.info("短期记忆已清空");
+  }
+
+  async clearShortTermAsync() {
+    this.shortTermMemory = [];
+    logger.info("短期记忆已清空");
+  }
+
+  async getStats() {
+    let longTermCount = 0;
+    try {
+      const result = await new Promise((resolve, reject) => {
+        this.dbService.db.get("SELECT COUNT(*) as count FROM long_term_memory", [], (err, row) => {
+          if (err) reject(err);
+          else resolve(row);
+        });
+      });
+      longTermCount = result.count;
+    } catch (error) {
+      logger.error(`获取长期记忆统计失败: ${error.message}`);
+    }
+
+    return {
+      shortTermCount: this.shortTermMemory?.length || 0,
+      shortTermLimit: this.shortTermLimit || 20,
+      longTermCount: longTermCount || 0,
+      maxLongTermMemories: MAX_LONG_TERM_MEMORIES,
+      memoryExpiryDays: MEMORY_EXPIRY_DAYS,
+      archiveQueueLength: this._archiveQueue?.length || 0,
+    };
+  }
+
+  async performMaintenance() {
+    logger.info("开始记忆维护...");
+    const expired = await this.cleanupExpiredMemories();
+    const pruned = await this.pruneMemoriesIfNecessary();
+    logger.info(`记忆维护完成: 清理 ${expired.deleted} 条过期, 修剪 ${pruned.deleted} 条低优先级`);
+    return { expired: expired.deleted, pruned: pruned.deleted };
+  }
+}
+
+module.exports = MemoryManager;

package/dist/services/message.queue.js

@@ -0,0 +1,157 @@
+const logger = require("../utils/logger");
+
+class MessageQueue {
+  constructor() {
+    this.queue = [];
+    this.isProcessing = false;
+    this.currentMessage = null;
+    this.messageHandlers = new Map();
+    this.maxQueueSize = 100;
+    this.stats = {
+      totalReceived: 0,
+      totalProcessed: 0,
+      totalDropped: 0,
+    };
+  }
+
+  enqueue(message, source = "unknown", metadata = {}) {
+    this.stats.totalReceived++;
+
+    if (this.queue.length >= this.maxQueueSize) {
+      this.stats.totalDropped++;
+      logger.warn(`消息队列已满，丢弃消息: ${source}`);
+      return false;
+    }
+
+    const queueItem = {
+      id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      message,
+      source,
+      metadata,
+      enqueuedAt: Date.now(),
+    };
+
+    this.queue.push(queueItem);
+    logger.debug(`消息入队: ${queueItem.id} (来源: ${source}, 队列长度: ${this.queue.length})`);
+
+    if (!this.isProcessing) {
+      this.processNext();
+    }
+
+    return true;
+  }
+
+  async processNext() {
+    if (this.isProcessing || this.queue.length === 0) {
+      return;
+    }
+
+    this.isProcessing = true;
+    const item = this.queue.shift();
+    this.currentMessage = item;
+
+    const waitTime = Date.now() - item.enqueuedAt;
+    logger.info(`开始处理消息: ${item.id} (等待时间: ${waitTime}ms, 来源: ${item.source})`);
+
+    try {
+      const handler = this.messageHandlers.get(item.source);
+      if (handler) {
+        const result = await handler(item.message, item.metadata);
+        logger.info(`消息处理完成: ${item.id}`);
+        this.stats.totalProcessed++;
+
+        if (item.metadata.onComplete) {
+          logger.debug(`执行消息完成回调: ${item.id}`);
+          try {
+            await item.metadata.onComplete(result);
+            logger.debug(`消息完成回调执行完毕: ${item.id}`);
+          } catch (callbackError) {
+            logger.error(`消息完成回调执行失败: ${item.id}`, callbackError);
+          }
+        }
+
+        return result;
+      } else {
+        logger.warn(`未找到消息处理器: ${item.source}`);
+      }
+    } catch (error) {
+      logger.error(`消息处理失败: ${item.id} - ${error.message}`);
+    } finally {
+      this.currentMessage = null;
+      this.isProcessing = false;
+
+      if (this.queue.length > 0) {
+        setImmediate(() => this.processNext());
+      }
+    }
+  }
+
+  registerHandler(source, handler) {
+    this.messageHandlers.set(source, handler);
+    logger.debug(`注册消息处理器: ${source}`);
+  }
+
+  unregisterHandler(source) {
+    this.messageHandlers.delete(source);
+    logger.debug(`注销消息处理器: ${source}`);
+  }
+
+  getStatus() {
+    return {
+      queueLength: this.queue.length,
+      isProcessing: this.isProcessing,
+      currentMessageId: this.currentMessage?.id || null,
+      maxQueueSize: this.maxQueueSize,
+      stats: { ...this.stats },
+      handlers: Array.from(this.messageHandlers.keys()),
+    };
+  }
+
+  clear() {
+    const dropped = this.queue.length;
+    this.queue = [];
+    this.stats.totalDropped += dropped;
+    logger.info(`消息队列已清空，丢弃 ${dropped} 条消息`);
+    return dropped;
+  }
+
+  peek() {
+    return this.queue.length > 0 ? this.queue[0] : null;
+  }
+
+  getQueueLength() {
+    return this.queue.length;
+  }
+
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+
+  isIdle() {
+    return !this.isProcessing && this.queue.length === 0;
+  }
+
+  async waitForIdle(timeout = 300000) {
+    const startTime = Date.now();
+
+    return new Promise((resolve) => {
+      const checkIdle = () => {
+        if (this.isIdle()) {
+          resolve(true);
+          return;
+        }
+
+        if (Date.now() - startTime > timeout) {
+          resolve(false);
+          return;
+        }
+
+        setTimeout(checkIdle, 100);
+      };
+
+      checkIdle();
+    });
+  }
+}
+
+module.exports = MessageQueue;