ai-memory-claw 1.0.0

package/openclaw.plugin.json

@@ -0,0 +1,145 @@
+{
+  "id": "ai-memory-claw",
+  "name": "AI Memory Claw",
+  "description": "AI渐进式记忆系统 - 无感运行版",
+  "uiHints": {
+    "dataDir": {
+      "label": "数据存储目录",
+      "placeholder": "~/.ai-memory-claw/data",
+      "help": "记忆数据存储的目录路径"
+    },
+    "autoRecall": {
+      "label": "自动召回",
+      "help": "对话前自动搜索并注入相关记忆"
+    },
+    "autoCapture": {
+      "label": "自动捕获",
+      "help": "对话后自动生成记忆"
+    },
+    "captureStrategy": {
+      "label": "捕获策略",
+      "help": "always=每次都存, selective=关键词匹配才存"
+    },
+    "autoRecallInNewSession": {
+      "label": "新会话召回",
+      "help": "新会话（首次对话）时自动注入1条最相关记忆"
+    },
+    "newSessionMemoryLimit": {
+      "label": "新会话召回数量",
+      "help": "新会话时注入的记忆数量（建议1条）"
+    },
+    "manualTriggerEnabled": {
+      "label": "手动触发",
+      "help": "用户消息包含关键词时触发召回"
+    },
+    "manualRecallLimit": {
+      "label": "手动召回数量",
+      "help": "手动触发时注入的记忆数量"
+    },
+    "recallThreshold": {
+      "label": "召回阈值",
+      "help": "相似度阈值，0-1之间，越高越严格"
+    },
+    "recallLimit": {
+      "label": "召回数量",
+      "help": "每次召回的记忆数量上限"
+    },
+    "enableForget": {
+      "label": "启用遗忘",
+      "help": "自动删除低价值记忆"
+    },
+    "enableIntegration": {
+      "label": "启用整合",
+      "help": "自动合并相似记忆"
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "dataDir": {
+        "type": "string",
+        "default": "~/.ai-memory-claw/data"
+      },
+      "autoRecall": {
+        "type": "boolean",
+        "default": true
+      },
+      "autoCapture": {
+        "type": "boolean",
+        "default": true
+      },
+      "captureStrategy": {
+        "type": "string",
+        "enum": ["always", "selective"],
+        "default": "always"
+      },
+      "autoRecallInNewSession": {
+        "type": "boolean",
+        "default": true
+      },
+      "newSessionMemoryLimit": {
+        "type": "number",
+        "default": 1,
+        "minimum": 1,
+        "maximum": 5
+      },
+      "manualTriggerEnabled": {
+        "type": "boolean",
+        "default": true
+      },
+      "manualTriggerKeywords": {
+        "type": "array",
+        "items": { "type": "string" },
+        "default": ["记得", "之前", "上次", "以前", "查一下", "看看之前的记忆", "用一下之前的", "参考之前的", "以前是怎么做的", "你还记得吗", "记忆里", "历史上", "之前那次"]
+      },
+      "manualRecallLimit": {
+        "type": "number",
+        "default": 3,
+        "minimum": 1,
+        "maximum": 10
+      },
+      "recallThreshold": {
+        "type": "number",
+        "default": 0.6,
+        "minimum": 0,
+        "maximum": 1
+      },
+      "recallLimit": {
+        "type": "number",
+        "default": 2,
+        "minimum": 1,
+        "maximum": 10
+      },
+      "captureMaxChars": {
+        "type": "number",
+        "default": 500,
+        "minimum": 100,
+        "maximum": 2000
+      },
+      "enableSummary": {
+        "type": "boolean",
+        "default": true
+      },
+      "enableForget": {
+        "type": "boolean",
+        "default": true
+      },
+      "enableIntegration": {
+        "type": "boolean",
+        "default": true
+      },
+      "forgetIntervalDays": {
+        "type": "number",
+        "default": 7,
+        "minimum": 1,
+        "maximum": 30
+      },
+      "integrationThreshold": {
+        "type": "number",
+        "default": 0.8,
+        "minimum": 0.5,
+        "maximum": 1
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "ai-memory-claw",
+  "version": "1.0.0",
+  "description": "AI渐进式记忆系统 OpenClaw 插件 - 无感运行版",
+  "main": "index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "ai-memory",
+    "openclaw",
+    "memory-system",
+    "ai-memory"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "chroma-js": "^2.4.2",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^9.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}

package/src/auto-capture.ts

@@ -0,0 +1,211 @@
+/**
+ * 自动捕获模块
+ * 
+ * 在对话结束后自动生成记忆并存储
+ * 强制记忆机制：每次对话 100% 生成记忆
+ */
+
+import { MemorySystem } from './memory-system';
+import { type MemoryConfig } from './config';
+import { TriggerAnalyzer } from './triggers';
+import { CategoryAnalyzer } from './category';
+
+export class AutoCapture {
+  private memorySystem: MemorySystem;
+  private config: MemoryConfig;
+  private triggerAnalyzer: TriggerAnalyzer;
+  private categoryAnalyzer: CategoryAnalyzer;
+  
+  constructor(memorySystem: MemorySystem, config: MemoryConfig) {
+    this.memorySystem = memorySystem;
+    this.config = config;
+    this.triggerAnalyzer = new TriggerAnalyzer();
+    this.categoryAnalyzer = new CategoryAnalyzer();
+  }
+  
+  /**
+   * 执行自动捕获
+   * 在 agent_end 钩子中调用
+   */
+  async execute(event: any): Promise<void> {
+    try {
+      // 1. 检查存储策略
+      if (this.config.captureStrategy === 'selective') {
+        // 关键词模式：检查是否需要存储
+        const hasKeyword = this.checkShouldCapture(event.messages);
+        if (!hasKeyword) {
+          return;
+        }
+      }
+      
+      // 2. 生成对话摘要
+      const summary = this.generateSummary(event.messages);
+      if (!summary) {
+        return;
+      }
+      
+      // 3. 分析分类
+      const { category, subCategory } = this.categoryAnalyzer.analyze(summary.task);
+      
+      // 4. 判断重要性
+      const importance = this.triggerAnalyzer.analyze(summary.task);
+      
+      // 5. 提取标签
+      const tags = this.triggerAnalyzer.extractTags(summary.task);
+      
+      // 6. 强制存储 (100% 执行)
+      await this.memorySystem.store({
+        content: summary,
+        category,
+        subCategory,
+        importance,
+        tags
+      });
+      
+      console.log(`[AutoCapture] 已存储记忆: ${category}/${subCategory} [${importance}]`);
+      
+    } catch (error) {
+      console.error('[AutoCapture] 执行失败:', error);
+    }
+  }
+  
+  /**
+   * 检查是否应该捕获 (selective 模式)
+   */
+  private checkShouldCapture(messages: any[]): boolean {
+    const allText = this.extractAllText(messages);
+    const importance = this.triggerAnalyzer.analyze(allText);
+    // critical/high/medium 都存储，只过滤 low
+    return importance !== 'low';
+  }
+  
+  /**
+   * 提取所有文本
+   */
+  private extractAllText(messages: any[]): string {
+    const texts: string[] = [];
+    
+    for (const msg of messages) {
+      if (typeof msg.content === 'string') {
+        texts.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === 'text' && block.text) {
+            texts.push(block.text);
+          }
+        }
+      }
+    }
+    
+    return texts.join(' ');
+  }
+  
+  /**
+   * 生成对话摘要
+   */
+  private generateSummary(messages: any[]): {
+    task: string;
+    process: string;
+    result: string;
+    insights: string[];
+  } | null {
+    // 提取用户消息和 AI 回复
+    const userMessages: string[] = [];
+    const assistantMessages: string[] = [];
+    
+    for (const msg of messages) {
+      const content = this.extractMessageContent(msg);
+      if (!content) continue;
+      
+      if (msg.role === 'user') {
+        userMessages.push(content);
+      } else if (msg.role === 'assistant') {
+        assistantMessages.push(content);
+      }
+    }
+    
+    if (userMessages.length === 0) {
+      return null;
+    }
+    
+    // 取最后一条用户消息作为任务
+    let lastUserMsg = userMessages[userMessages.length - 1];
+    let lastAssistantMsg = assistantMessages[assistantMessages.length - 1] || '';
+    
+    // 过滤掉召回的上下文（避免递归嵌套）
+    lastUserMsg = this.filterRecallContext(lastUserMsg);
+    lastAssistantMsg = this.filterRecallContext(lastAssistantMsg);
+    
+    // 限制长度
+    const maxLen = this.config.captureMaxChars;
+    
+    return {
+      task: this.truncate(lastUserMsg, maxLen),
+      process: this.extractProcess(lastAssistantMsg),
+      result: this.truncate(lastAssistantMsg, maxLen),
+      insights: this.extractInsights(lastAssistantMsg)
+    };
+  }
+  
+  /**
+   * 提取消息内容
+   */
+  private extractMessageContent(msg: any): string {
+    if (typeof msg.content === 'string') {
+      return msg.content;
+    }
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === 'text' && block.text) {
+          return block.text;
+        }
+      }
+    }
+    return '';
+  }
+  
+  /**
+   * 过滤掉召回的上下文内容
+   * 防止递归嵌套
+   */
+  private filterRecallContext(text: string): string {
+    // 移除 <relevant-memories>...</relevant-memories> 标签及内容
+    return text.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>/gi, '').trim();
+  }
+  
+  /**
+   * 提取处理过程
+   */
+  private extractProcess(assistantMsg: string): string {
+    // 简单提取：取前100字作为处理过程
+    return assistantMsg.slice(0, 100);
+  }
+  
+  /**
+   * 提取洞察
+   */
+  private extractInsights(assistantMsg: string): string[] {
+    const insights: string[] = [];
+    
+    // 简单的洞察提取
+    if (/完成|解决|修复/i.test(assistantMsg)) {
+      insights.push('任务已完成');
+    }
+    if (/错误|失败|问题/i.test(assistantMsg)) {
+      insights.push('遇到问题');
+    }
+    if (/建议|可以|推荐/i.test(assistantMsg)) {
+      insights.push('提供了建议');
+    }
+    
+    return insights;
+  }
+  
+  /**
+   * 截断文本
+   */
+  private truncate(text: string, maxLen: number): string {
+    if (text.length <= maxLen) return text;
+    return text.slice(0, maxLen) + '...';
+  }
+}

package/src/auto-recall.ts

@@ -0,0 +1,180 @@
+/**
+ * 自动召回模块
+ * 
+ * 在 AI 回复前自动搜索相关记忆并注入上下文
+ * 触发逻辑：
+ * 1. 新会话（第一条消息）自动召回1条
+ * 2. 手动触发（关键词）
+ */
+
+import { MemorySystem } from './memory-system';
+import { type MemoryConfig } from './config';
+import type { Memory } from './types';
+
+export class AutoRecall {
+  private memorySystem: MemorySystem;
+  private config: MemoryConfig;
+  
+  constructor(memorySystem: MemorySystem, config: MemoryConfig) {
+    this.memorySystem = memorySystem;
+    this.config = config;
+  }
+  
+  /**
+   * 执行自动召回
+   * @param event 钩子事件
+   */
+  async execute(event: any): Promise<{ prependContext: string } | void> {
+    try {
+      // 1. 提取用户输入
+      const prompt = this.extractUserPrompt(event.prompt);
+      if (!prompt || prompt.length < 3) {
+        return;
+      }
+      
+      // 2. 检查是否为新会话（第一条用户消息）
+      const isFirstMessage = this.isFirstUserMessage(event);
+      
+      // 3. 检查是否包含触发关键词
+      const hasKeyword = this.hasTriggerKeyword(prompt);
+      
+      let memories: Memory[] = [];
+      
+      if (hasKeyword) {
+        // 手动触发模式：有关键词
+        console.log('[AutoRecall] 检测到触发关键词，搜索相关记忆...');
+        memories = await this.memorySystem.search(prompt, {
+          limit: this.config.manualRecallLimit,
+          threshold: this.config.recallThreshold
+        });
+        console.log(`[AutoRecall] 手动触发召回 ${memories.length} 条`);
+        
+      } else if (isFirstMessage && this.config.autoRecallInNewSession) {
+        // 新会话自动触发
+        console.log('[AutoRecall] 新会话，自动搜索相关记忆...');
+        memories = await this.memorySystem.search(prompt, {
+          limit: this.config.newSessionMemoryLimit,
+          threshold: this.config.recallThreshold
+        });
+        console.log(`[AutoRecall] 新会话召回 ${memories.length} 条`);
+      } else {
+        // 非新会话但仍尝试召回（使用较低阈值）
+        console.log('[AutoRecall] 尝试召回相关记忆...');
+        memories = await this.memorySystem.search(prompt, {
+          limit: 1,
+          threshold: 0.3  // 较低阈值，扩大召回范围
+        });
+        console.log(`[AutoRecall] 召回 ${memories.length} 条`);
+      }
+      
+      if (memories.length === 0) {
+        return;
+      }
+      
+      // 4. 格式化并返回
+      const context = this.formatMemories(memories);
+      return { prependContext: context };
+      
+    } catch (error) {
+      console.error('[AutoRecall] 执行失败:', error);
+    }
+  }
+  
+  /**
+   * 判断是否为第一条用户消息（新会话）
+   */
+  private isFirstUserMessage(event: any): boolean {
+    // 从 event.messages 中计算用户消息数量
+    const messages = event.messages || [];
+    
+    // 过滤出用户消息
+    const userMessages = messages.filter((m: any) => m.role === 'user');
+    
+    // 如果没有用户消息或只有1条，返回 true（新会话）
+    return userMessages.length <= 1;
+  }
+  
+  /**
+   * 重置会话状态（新会话开始时调用）
+   */
+  public resetSession(): void {
+    console.log('[AutoRecall] 会话状态已重置');
+  }
+
+  /**
+   * 检查是否包含触发关键词
+   */
+  private hasTriggerKeyword(prompt: string): boolean {
+    const keywords = this.config.manualTriggerKeywords || [];
+    const lowerPrompt = prompt.toLowerCase();
+    
+    for (const keyword of keywords) {
+      if (lowerPrompt.includes(keyword)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  /**
+   * 从事件中提取用户输入
+   */
+  private extractUserPrompt(prompt: any): string {
+    if (typeof prompt === 'string') {
+      return prompt;
+    }
+    
+    if (Array.isArray(prompt)) {
+      // 取最后一条用户消息
+      for (let i = prompt.length - 1; i >= 0; i--) {
+        const msg = prompt[i];
+        if (msg.role === 'user') {
+          if (typeof msg.content === 'string') {
+            return msg.content;
+          }
+          if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+              if (block.type === 'text' && block.text) {
+                return block.text;
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    return '';
+  }
+  
+  /**
+   * 格式化记忆为上下文字符串
+   */
+  private formatMemories(memories: Memory[]): string {
+    const lines = memories.map((m, i) => {
+      const date = new Date(m.createdAt).toLocaleDateString('zh-CN');
+      const importance = this.getImportanceEmoji(m.importance);
+      
+      return `${i + 1}. ${importance} [${date}] ${m.category}/${m.subCategory}
+  任务: ${m.content.task}
+  结果: ${m.content.result}`;
+    });
+    
+    return `<relevant-memories>
+以下是你之前与用户交流的相关记忆，供参考：
+${lines.join('\n\n')}
+</relevant-memories>`;
+  }
+  
+  /**
+   * 获取重要性emoji
+   */
+  private getImportanceEmoji(importance: string): string {
+    switch (importance) {
+      case 'critical': return '⭐';
+      case 'high': return '🔥';
+      case 'medium': return '📝';
+      case 'low': return '💤';
+      default: return '📝';
+    }
+  }
+}