inspiration-agent 0.0.1

package/dist/tools/memory.tools.js

@@ -0,0 +1,393 @@
+const logger = require("../utils/logger");
+
+class MemoryTools {
+  constructor(memoryManager) {
+    this.memoryManager = memoryManager;
+  }
+
+  getFunctionDefinitions() {
+    return [
+      {
+        type: "function",
+        function: {
+          name: "save_memory",
+          description:
+            "将重要信息保存到长期记忆中。当用户明确要求记住某些信息，或者信息对后续对话非常重要时使用。长期记忆在清空上下文后仍然保留。",
+          parameters: {
+            type: "object",
+            properties: {
+              content: {
+                type: "string",
+                description: "要记住的内容",
+              },
+              type: {
+                type: "string",
+                enum: ["important", "identity", "preference", "task", "file_info", "general"],
+                description:
+                  "记忆类型: important(重要信息), identity(身份信息), preference(偏好), task(任务), file_info(文件信息), general(一般信息)",
+              },
+              importance: {
+                type: "integer",
+                minimum: 1,
+                maximum: 10,
+                description: "重要性分数，1-10，数字越大越重要。默认为5。",
+              },
+            },
+            required: ["content"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "save_short_term_memory",
+          description:
+            "将信息保存到短期记忆中。短期记忆仅在当前会话中有效，清空上下文后会丢失。用于临时存储不需要长期保存的信息。",
+          parameters: {
+            type: "object",
+            properties: {
+              role: {
+                type: "string",
+                enum: ["user", "assistant", "system"],
+                description: "消息角色，默认为 system",
+              },
+              content: {
+                type: "string",
+                description: "要保存的内容",
+              },
+            },
+            required: ["content"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "search_memories",
+          description: "搜索长期记忆中与关键词相关的内容。用于查找之前记住的信息。",
+          parameters: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "搜索关键词",
+              },
+              limit: {
+                type: "integer",
+                minimum: 1,
+                maximum: 20,
+                description: "返回结果数量限制，默认为5",
+              },
+            },
+            required: ["query"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "get_all_memories",
+          description: "获取所有长期记忆列表。用于查看已记住的所有信息。",
+          parameters: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: [
+                  "important",
+                  "identity",
+                  "preference",
+                  "task",
+                  "file_info",
+                  "general",
+                  "all",
+                ],
+                description: "记忆类型过滤，'all' 表示获取所有类型，默认为 'all'",
+              },
+              limit: {
+                type: "integer",
+                minimum: 1,
+                maximum: 50,
+                description: "返回结果数量限制，默认为20",
+              },
+            },
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "delete_memory",
+          description: "删除指定的长期记忆。当信息不再需要或已过时时使用。",
+          parameters: {
+            type: "object",
+            properties: {
+              memory_id: {
+                type: "integer",
+                description: "要删除的记忆ID",
+              },
+            },
+            required: ["memory_id"],
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "clear_short_term_memory",
+          description: "清空短期记忆。保留长期记忆，仅清除当前会话的临时记忆。",
+          parameters: {
+            type: "object",
+            properties: {},
+          },
+        },
+      },
+      {
+        type: "function",
+        function: {
+          name: "get_memory_stats",
+          description: "获取记忆统计信息，包括短期记忆和长期记忆的数量等。",
+          parameters: {
+            type: "object",
+            properties: {},
+          },
+        },
+      },
+    ];
+  }
+
+  async saveMemory(args) {
+    try {
+      const { content, type = "general", importance = 5 } = args;
+
+      if (!content || content.trim().length === 0) {
+        return {
+          success: false,
+          message: "记忆内容不能为空",
+        };
+      }
+
+      const memoryType = this._mapMemoryType(type);
+
+      await this.memoryManager.dbService.saveLongTermMemory({
+        type: memoryType,
+        content: content.trim(),
+        keywords: this._extractSimpleKeywords(content),
+        importance: Math.min(10, Math.max(1, importance)),
+      });
+
+      logger.info(`已保存长期记忆: [${memoryType}] ${content.substring(0, 50)}...`);
+
+      return {
+        success: true,
+        message: `已成功保存到长期记忆`,
+        memory: {
+          type: memoryType,
+          content: content.substring(0, 100),
+          importance,
+        },
+      };
+    } catch (error) {
+      logger.error(`保存长期记忆失败: ${error.message}`);
+      return {
+        success: false,
+        message: `保存记忆失败: ${error.message}`,
+      };
+    }
+  }
+
+  async saveShortTermMemory(args) {
+    try {
+      const { content, role = "system" } = args;
+
+      if (!content || content.trim().length === 0) {
+        return {
+          success: false,
+          message: "记忆内容不能为空",
+        };
+      }
+
+      this.memoryManager.addMessage(role, content.trim());
+
+      return {
+        success: true,
+        message: `已保存到短期记忆`,
+        memory: {
+          role,
+          content: content.substring(0, 100),
+        },
+      };
+    } catch (error) {
+      logger.error(`保存短期记忆失败: ${error.message}`);
+      return {
+        success: false,
+        message: `保存短期记忆失败: ${error.message}`,
+      };
+    }
+  }
+
+  async searchMemories(args) {
+    try {
+      const { query, limit = 5 } = args;
+
+      if (!query || query.trim().length === 0) {
+        return {
+          success: false,
+          message: "搜索关键词不能为空",
+        };
+      }
+
+      const memories = await this.memoryManager.searchRelevantMemories(query.trim(), limit);
+
+      return {
+        success: true,
+        message: `找到 ${memories.length} 条相关记忆`,
+        memories: memories.map((m) => ({
+          id: m.id,
+          type: m.type,
+          content: m.content,
+          importance: m.importance,
+          created_at: m.created_at,
+        })),
+      };
+    } catch (error) {
+      logger.error(`搜索记忆失败: ${error.message}`);
+      return {
+        success: false,
+        message: `搜索记忆失败: ${error.message}`,
+      };
+    }
+  }
+
+  async getAllMemories(args) {
+    try {
+      const { type = "all", limit = 20 } = args;
+
+      const memoryType = type === "all" ? null : this._mapMemoryType(type);
+      const memories = await this.memoryManager.dbService.getLongTermMemories(memoryType, limit);
+
+      return {
+        success: true,
+        message: `共有 ${memories.length} 条记忆`,
+        memories: memories.map((m) => ({
+          id: m.id,
+          type: m.type,
+          content: m.content,
+          importance: m.importance,
+          created_at: m.created_at,
+        })),
+      };
+    } catch (error) {
+      logger.error(`获取记忆列表失败: ${error.message}`);
+      return {
+        success: false,
+        message: `获取记忆列表失败: ${error.message}`,
+      };
+    }
+  }
+
+  async deleteMemory(args) {
+    try {
+      const { memory_id } = args;
+
+      if (!memory_id) {
+        return {
+          success: false,
+          message: "记忆ID不能为空",
+        };
+      }
+
+      const result = await this.memoryManager.dbService.deleteLongTermMemory(memory_id);
+
+      if (result.deleted) {
+        return {
+          success: true,
+          message: `已删除记忆 ID: ${memory_id}`,
+        };
+      } else {
+        return {
+          success: false,
+          message: `未找到记忆 ID: ${memory_id}`,
+        };
+      }
+    } catch (error) {
+      logger.error(`删除记忆失败: ${error.message}`);
+      return {
+        success: false,
+        message: `删除记忆失败: ${error.message}`,
+      };
+    }
+  }
+
+  async clearShortTermMemory() {
+    try {
+      this.memoryManager.clearShortTerm();
+
+      return {
+        success: true,
+        message: "已清空短期记忆，长期记忆保持不变",
+      };
+    } catch (error) {
+      logger.error(`清空短期记忆失败: ${error.message}`);
+      return {
+        success: false,
+        message: `清空短期记忆失败: ${error.message}`,
+      };
+    }
+  }
+
+  async getMemoryStats() {
+    try {
+      const stats = await this.memoryManager.getStats();
+
+      return {
+        success: true,
+        message: "记忆统计信息",
+        stats: {
+          shortTermCount: stats.shortTermCount,
+          shortTermLimit: stats.shortTermLimit,
+          longTermCount: stats.longTermCount,
+          maxLongTermMemories: stats.maxLongTermMemories,
+          memoryExpiryDays: stats.memoryExpiryDays,
+        },
+      };
+    } catch (error) {
+      logger.error(`获取记忆统计失败: ${error.message}`);
+      return {
+        success: false,
+        message: `获取记忆统计失败: ${error.message}`,
+      };
+    }
+  }
+
+  _mapMemoryType(type) {
+    const typeMap = {
+      important: "important",
+      identity: "identity",
+      preference: "preference",
+      task: "task",
+      file_info: "file_info",
+      general: "conversation",
+      conversation: "conversation",
+    };
+    return typeMap[type] || "conversation";
+  }
+
+  _extractSimpleKeywords(content) {
+    const keywords = [];
+    const words = content.match(/[\u4e00-\u9fa5]{2,8}/g) || [];
+    words.slice(0, 5).forEach((word) => {
+      if (
+        !keywords.includes(word) &&
+        !["这是", "那个", "这个", "什么", "怎么", "如何", "因为", "所以", "但是", "而且"].includes(
+          word
+        )
+      ) {
+        keywords.push(word);
+      }
+    });
+    return keywords;
+  }
+}
+
+module.exports = MemoryTools;