ai-memory-claw 1.0.0

package/src/category.ts

@@ -0,0 +1,149 @@
+/**
+ * 分类分析模块
+ * 
+ * 分析对话内容，判断主分类和子分类
+ */
+
+export class CategoryAnalyzer {
+  // 分类关键词映射
+  private categoryKeywords: Record<string, string[]> = {
+    '代码开发': [
+      '代码', '编程', '脚本', 'Python', 'JavaScript', '开发', '函数', 'bug',
+      'code', 'program', 'script', 'python', 'javascript', 'coding', 'function', 'bug'
+    ],
+    '系统运维': [
+      '部署', '服务器', '运维', 'Docker', '配置', '安装', '备份',
+      'deploy', 'server', 'docker', 'config', 'install', 'backup'
+    ],
+    '文档撰写': [
+      '文档', '报告', '文章', '写作', '撰写', '总结',
+      'document', 'report', 'article', 'write', 'summary'
+    ],
+    '数据分析': [
+      '分析', '数据', '统计', '图表', '可视化', 'CSV', 'Excel',
+      'analysis', 'data', 'statistics', 'chart', 'visualization', 'csv', 'excel'
+    ],
+    '创作设定': [
+      '角色', '故事', '世界观', '创作', '小说', '设定',
+      'character', 'story', 'world', 'creative', 'novel', 'setting'
+    ],
+    '用户偏好': [
+      '喜欢', '偏好', '习惯', '讨厌', '想要', '口味',
+      'prefer', 'like', 'hate', 'want', 'habit', 'taste'
+    ],
+    '日常事务': [
+      '日程', '邮件', '安排', '提醒', '天气', '时间',
+      'schedule', 'email', 'remind', 'weather', 'time'
+    ]
+  };
+  
+  /**
+   * 分析内容，返回分类
+   */
+  analyze(content: string): { category: string; subCategory: string } {
+    const lower = content.toLowerCase();
+    let bestCategory = '其他';
+    let maxScore = 0;
+    
+    // 1. 查找最佳匹配分类
+    for (const [category, keywords] of Object.entries(this.categoryKeywords)) {
+      let score = 0;
+      for (const keyword of keywords) {
+        if (lower.includes(keyword.toLowerCase())) {
+          score += 1;
+        }
+      }
+      if (score > maxScore) {
+        maxScore = score;
+        bestCategory = category;
+      }
+    }
+    
+    // 2. 确定子分类
+    const subCategory = this.getSubCategory(content, bestCategory);
+    
+    return {
+      category: bestCategory,
+      subCategory
+    };
+  }
+  
+  /**
+   * 获取子分类
+   */
+  private getSubCategory(content: string, category: string): string {
+    const lower = content.toLowerCase();
+    
+    if (category === '代码开发') {
+      if (/python|脚本/.test(lower)) return '脚本';
+      if (/web|前端|html|css|react|vue/.test(lower)) return '前端';
+      if (/api|后端|server|node/.test(lower)) return '后端';
+      if (/bug|debug|错误/.test(lower)) return '调试';
+      if (/算法|数据结构/.test(lower)) return '算法';
+      return '通用';
+    }
+    
+    if (category === '系统运维') {
+      if (/docker|容器/.test(lower)) return '容器';
+      if (/部署|发布/.test(lower)) return '部署';
+      if (/备份|恢复/.test(lower)) return '备份';
+      if (/服务器|server/.test(lower)) return '服务器';
+      if (/监控|日志/.test(lower)) return '监控';
+      return '通用';
+    }
+    
+    if (category === '文档撰写') {
+      if (/需求|规格/.test(lower)) return '需求文档';
+      if (/技术|开发/.test(lower)) return '技术文档';
+      if (/用户|手册/.test(lower)) return '用户手册';
+      return '通用';
+    }
+    
+    if (category === '数据分析') {
+      if (/可视化|图表/.test(lower)) return '可视化';
+      if (/统计|报表/.test(lower)) return '统计分析';
+      if (/机器学习|ai|人工智能/.test(lower)) return '机器学习';
+      return '通用';
+    }
+    
+    if (category === '创作设定') {
+      if (/角色|人物/.test(lower)) return '角色设定';
+      if (/世界观|背景/.test(lower)) return '世界观';
+      if (/剧情|情节/.test(lower)) return '剧情';
+      return '通用';
+    }
+    
+    if (category === '用户偏好') {
+      if (/饮食|口味/.test(lower)) return '饮食偏好';
+      if (/工作|学习/.test(lower)) return '工作习惯';
+      if (/工具|软件/.test(lower)) return '工具偏好';
+      return '通用';
+    }
+    
+    return '通用';
+  }
+  
+  /**
+   * 获取所有分类
+   */
+  getAllCategories(): string[] {
+    return Object.keys(this.categoryKeywords);
+  }
+  
+  /**
+   * 获取分类的中文名称
+   */
+  getCategoryDisplayName(category: string): string {
+    const displayNames: Record<string, string> = {
+      '代码开发': '代码开发',
+      '系统运维': '系统运维',
+      '文档撰写': '文档撰写',
+      '数据分析': '数据分析',
+      '创作设定': '创作设定',
+      '用户偏好': '用户偏好',
+      '日常事务': '日常事务',
+      '其他': '其他'
+    };
+    return displayNames[category] || category;
+  }
+}

package/src/config.ts

@@ -0,0 +1,74 @@
+/**
+ * 配置管理模块
+ * 
+ * 定义插件配置类型和默认配置
+ */
+
+// 默认触发关键词
+export const DEFAULT_TRIGGER_KEYWORDS = [
+  "记得", "之前", "上次", "以前", "查一下", "看看之前的记忆",
+  "用一下之前的", "参考之前的", "以前是怎么做的", "你还记得吗",
+  "记忆里", "历史上", "之前那次"
+];
+
+export type MemoryConfig = {
+  dataDir: string;
+  autoRecall: boolean;
+  autoCapture: boolean;
+  captureStrategy: "always" | "selective";
+  autoRecallInNewSession: boolean;
+  newSessionMemoryLimit: number;
+  manualTriggerEnabled: boolean;
+  manualTriggerKeywords: string[];
+  manualRecallLimit: number;
+  recallThreshold: number;
+  recallLimit: number;
+  captureMaxChars: number;
+  enableSummary: boolean;
+  enableForget: boolean;
+  enableIntegration: boolean;
+  forgetIntervalDays: number;
+  integrationThreshold: number;
+};
+
+export const defaultMemoryConfig: MemoryConfig = {
+  dataDir: "~/.ai-memory-claw/data",
+  autoRecall: true,
+  autoCapture: true,
+  captureStrategy: "always",
+  autoRecallInNewSession: true,
+  newSessionMemoryLimit: 1,
+  manualTriggerEnabled: true,
+  manualTriggerKeywords: DEFAULT_TRIGGER_KEYWORDS,
+  manualRecallLimit: 3,
+  recallThreshold: 0.6,
+  recallLimit: 2,
+  captureMaxChars: 500,
+  enableSummary: true,
+  enableForget: true,
+  enableIntegration: true,
+  forgetIntervalDays: 7,
+  integrationThreshold: 0.8
+};
+
+export function mergeWithDefaults(pluginConfig: Partial<MemoryConfig>): MemoryConfig {
+  return {
+    dataDir: pluginConfig.dataDir || defaultMemoryConfig.dataDir,
+    autoRecall: pluginConfig.autoRecall ?? defaultMemoryConfig.autoRecall,
+    autoCapture: pluginConfig.autoCapture ?? defaultMemoryConfig.autoCapture,
+    captureStrategy: pluginConfig.captureStrategy || defaultMemoryConfig.captureStrategy,
+    autoRecallInNewSession: pluginConfig.autoRecallInNewSession ?? defaultMemoryConfig.autoRecallInNewSession,
+    newSessionMemoryLimit: pluginConfig.newSessionMemoryLimit ?? defaultMemoryConfig.newSessionMemoryLimit,
+    manualTriggerEnabled: pluginConfig.manualTriggerEnabled ?? defaultMemoryConfig.manualTriggerEnabled,
+    manualTriggerKeywords: pluginConfig.manualTriggerKeywords || defaultMemoryConfig.manualTriggerKeywords,
+    manualRecallLimit: pluginConfig.manualRecallLimit ?? defaultMemoryConfig.manualRecallLimit,
+    recallThreshold: pluginConfig.recallThreshold ?? defaultMemoryConfig.recallThreshold,
+    recallLimit: pluginConfig.recallLimit ?? defaultMemoryConfig.recallLimit,
+    captureMaxChars: pluginConfig.captureMaxChars ?? defaultMemoryConfig.captureMaxChars,
+    enableSummary: pluginConfig.enableSummary ?? defaultMemoryConfig.enableSummary,
+    enableForget: pluginConfig.enableForget ?? defaultMemoryConfig.enableForget,
+    enableIntegration: pluginConfig.enableIntegration ?? defaultMemoryConfig.enableIntegration,
+    forgetIntervalDays: pluginConfig.forgetIntervalDays ?? defaultMemoryConfig.forgetIntervalDays,
+    integrationThreshold: pluginConfig.integrationThreshold ?? defaultMemoryConfig.integrationThreshold
+  };
+}

package/src/embedding.ts

@@ -0,0 +1,149 @@
+/**
+ * 向量嵌入模块
+ * 
+ * 将文本转换为向量表示，用于相似度搜索
+ * 支持多种嵌入模型
+ */
+
+export class EmbeddingGenerator {
+  private cache: Map<string, number[]> = new Map();
+  private vectorDim: number = 384;
+  private initialized: boolean = false;
+  
+  constructor() {
+    // 使用简单的384维向量
+  }
+  
+  async initialize(): Promise<void> {
+    this.initialized = true;
+  }
+  
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+  
+  /**
+   * 生成文本向量
+   */
+  async embed(text: string): Promise<number[]> {
+    // 1. 检查缓存
+    const cacheKey = text.slice(0, 100);
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey)!;
+    }
+    
+    // 2. 生成向量 (关键词向量化)
+    const vector = this.keywordEmbedding(text);
+    
+    // 3. 缓存结果
+    this.cache.set(cacheKey, vector);
+    
+    return vector;
+  }
+  
+  /**
+   * 关键词向量化 - 简单的基于关键词的向量化
+   */
+  private keywordEmbedding(text: string): number[] {
+    const vector = new Array(this.vectorDim).fill(0);
+    
+    // 分词
+    const words = this.tokenize(text);
+    const wordFreq = new Map<string, number>();
+    
+    for (const word of words) {
+      wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+    }
+    
+    // 填充向量
+    let idx = 0;
+    for (const [word, freq] of wordFreq.entries()) {
+      for (let i = 0; i < word.length && idx < this.vectorDim; i++) {
+        // 使用字符编码 + 词频
+        vector[idx] += (word.charCodeAt(i) * freq) / words.length;
+        idx = (idx + 1) % this.vectorDim;
+      }
+    }
+    
+    // 归一化
+    return this.normalize(vector);
+  }
+  
+  /**
+   * 分词
+   */
+  private tokenize(text: string): string[] {
+    // 中英文分词
+    const tokens: string[] = [];
+    let current = '';
+    
+    for (const char of text.toLowerCase()) {
+      if (/[\u4e00-\u9fa5]/.test(char)) {
+        // 中文字符
+        if (current.length > 0) {
+          tokens.push(...current.split(/\s+/).filter(t => t));
+          current = '';
+        }
+        tokens.push(char);
+      } else if (/[a-zA-Z0-9]/.test(char)) {
+        // 英文字母或数字
+        current += char;
+      } else {
+        // 标点符号
+        if (current.length > 0) {
+          tokens.push(...current.split(/\s+/).filter(t => t));
+          current = '';
+        }
+      }
+    }
+    
+    if (current.length > 0) {
+      tokens.push(...current.split(/\s+/).filter(t => t));
+    }
+    
+    return tokens;
+  }
+  
+  /**
+   * 向量归一化
+   */
+  private normalize(vector: number[]): number[] {
+    const norm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+    if (norm === 0) return vector;
+    return vector.map(val => val / norm);
+  }
+  
+  /**
+   * 余弦相似度计算
+   */
+  cosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) return 0;
+    
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    return denominator === 0 ? 0 : dotProduct / denominator;
+  }
+  
+  /**
+   * 清除缓存
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+  
+  /**
+   * 获取缓存大小
+   */
+  getCacheSize(): number {
+    return this.cache.size;
+  }
+}

package/src/forgetter.ts

@@ -0,0 +1,129 @@
+/**
+ * 遗忘机制模块
+ * 
+ * 自动删除低价值记忆，保持存储效率
+ */
+
+import { MemorySystem } from './memory-system';
+import type { Memory } from './types';
+
+export interface ForgetResult {
+  id: string;
+  action: 'deleted' | 'compressed';
+  reason: string;
+}
+
+export class Forgrtter {
+  private memorySystem: MemorySystem;
+  
+  constructor(memorySystem: MemorySystem) {
+    this.memorySystem = memorySystem;
+  }
+  
+  /**
+   * 检查并执行遗忘
+   */
+  async checkAndForget(): Promise<ForgetResult[]> {
+    const results: ForgetResult[] = [];
+    const memories = this.memorySystem.getAllMemories();
+    const now = Date.now();
+    
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    
+    for (const memory of memories) {
+      const lastAccess = new Date(memory.lastAccessedAt).getTime();
+      const daysSinceAccess = (now - lastAccess) / DAY_MS;
+      const importanceScore = this.getImportanceScore(memory.importance);
+      
+      let shouldForget = false;
+      let reason = '';
+      
+      // 遗忘条件
+      if (daysSinceAccess > 30 && importanceScore < 0.3) {
+        // 30天未访问 + 低重要性 = 直接删除
+        shouldForget = true;
+        reason = '30天未访问 + 低重要性';
+      } else if (daysSinceAccess > 60 && importanceScore < 0.5) {
+        // 60天未访问 + 中低重要性 = 直接删除
+        shouldForget = true;
+        reason = '60天未访问 + 中低重要性';
+      } else if (daysSinceAccess > 90) {
+        // 90天未访问 = 直接删除
+        shouldForget = true;
+        reason = '90天未访问';
+      }
+      
+      if (shouldForget) {
+        await this.memorySystem.delete(memory.id);
+        results.push({
+          id: memory.id,
+          action: 'deleted',
+          reason
+        });
+      }
+    }
+    
+    if (results.length > 0) {
+      console.log(`[Forgrtter] 已遗忘 ${results.length} 条记忆`);
+    }
+    
+    return results;
+  }
+  
+  /**
+   * 获取重要性分数
+   */
+  private getImportanceScore(importance: string): number {
+    switch (importance) {
+      case 'critical': return 1.0;
+      case 'high': return 0.7;
+      case 'medium': return 0.5;
+      case 'low': return 0.2;
+      default: return 0.5;
+    }
+  }
+  
+  /**
+   * 获取遗忘候选列表
+   */
+  getForgetCandidates(): { memory: Memory; score: number; reason: string }[] {
+    const candidates: { memory: Memory; score: number; reason: string }[] = [];
+    const memories = this.memorySystem.getAllMemories();
+    const now = Date.now();
+    
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    
+    for (const memory of memories) {
+      const lastAccess = new Date(memory.lastAccessedAt).getTime();
+      const daysSinceAccess = (now - lastAccess) / DAY_MS;
+      const importanceScore = this.getImportanceScore(memory.importance);
+      
+      // 计算遗忘分数 (越高越应该遗忘)
+      let forgetScore = 0;
+      let reason = '';
+      
+      if (daysSinceAccess > 30 && importanceScore < 0.3) {
+        forgetScore = 0.9;
+        reason = '30天未访问 + 低重要性';
+      } else if (daysSinceAccess > 60 && importanceScore < 0.5) {
+        forgetScore = 0.7;
+        reason = '60天未访问 + 中低重要性';
+      } else if (daysSinceAccess > 90) {
+        forgetScore = 0.5;
+        reason = '90天未访问';
+      } else if (daysSinceAccess > 14 && importanceScore < 0.3) {
+        forgetScore = 0.3;
+        reason = '14天未访问 + 低重要性';
+      }
+      
+      if (forgetScore > 0) {
+        candidates.push({ memory, score: forgetScore, reason });
+      }
+    }
+    
+    // 按遗忘分数排序
+    candidates.sort((a, b) => b.score - a.score);
+    
+    return candidates;
+  }
+}

package/src/integrator.ts

@@ -0,0 +1,197 @@
+/**
+ * 记忆整合模块
+ * 
+ * 自动将相似记忆整合为记忆簇
+ */
+
+import { MemorySystem } from './memory-system';
+import { type MemoryConfig } from './config';
+import type { Memory } from './types';
+
+export interface IntegrationResult {
+  clusterId: string;
+  action: 'merged' | 'updated';
+  memoryIds: string[];
+}
+
+export class Integrator {
+  private memorySystem: MemorySystem;
+  private config: MemoryConfig;
+  
+  constructor(memorySystem: MemorySystem, config: MemoryConfig) {
+    this.memorySystem = memorySystem;
+    this.config = config;
+  }
+  
+  /**
+   * 执行记忆整合
+   */
+  async integrate(): Promise<IntegrationResult[]> {
+    const results: IntegrationResult[] = [];
+    const memories = this.memorySystem.getAllMemories();
+    
+    if (memories.length < 2) {
+      return results;
+    }
+    
+    // 按分类分组
+    const byCategory = new Map<string, Memory[]>();
+    
+    for (const memory of memories) {
+      const key = `${memory.category}/${memory.subCategory}`;
+      if (!byCategory.has(key)) {
+        byCategory.set(key, []);
+      }
+      byCategory.get(key)!.push(memory);
+    }
+    
+    // 对每个分类进行检查
+    for (const [categoryKey, categoryMemories] of byCategory.entries()) {
+      if (categoryMemories.length < 2) continue;
+      
+      // 查找相似记忆
+      const similarPairs = this.findSimilarPairs(categoryMemories);
+      
+      for (const pair of similarPairs) {
+        // 可以选择合并或保留
+        const result = await this.processSimilarPair(pair);
+        if (result) {
+          results.push(result);
+        }
+      }
+    }
+    
+    if (results.length > 0) {
+      console.log(`[Integrator] 已整合 ${results.length} 组记忆`);
+    }
+    
+    return results;
+  }
+  
+  /**
+   * 查找相似记忆对
+   */
+  private findSimilarPairs(memories: Memory[]): { m1: Memory; m2: Memory; score: number }[] {
+    const pairs: { m1: Memory; m2: Memory; score: number }[] = [];
+    const threshold = this.config.integrationThreshold;
+    
+    for (let i = 0; i < memories.length; i++) {
+      for (let j = i + 1; j < memories.length; j++) {
+        const m1 = memories[i];
+        const m2 = memories[j];
+        
+        // 检查是否已处理过
+        if (m1.mergedFrom?.includes(m2.id) || m2.mergedFrom?.includes(m1.id)) {
+          continue;
+        }
+        
+        // 简单的文本相似度计算
+        const score = this.calculateSimilarity(
+          m1.content.task + ' ' + m1.content.result,
+          m2.content.task + ' ' + m2.content.result
+        );
+        
+        if (score >= threshold) {
+          pairs.push({ m1, m2, score });
+        }
+      }
+    }
+    
+    return pairs;
+  }
+  
+  /**
+   * 计算文本相似度
+   */
+  private calculateSimilarity(text1: string, text2: string): number {
+    const words1 = new Set(this.tokenize(text1));
+    const words2 = new Set(this.tokenize(text2));
+    
+    if (words1.size === 0 || words2.size === 0) return 0;
+    
+    let intersection = 0;
+    for (const word of words1) {
+      if (words2.has(word)) intersection++;
+    }
+    
+    const union = words1.size + words2.size - intersection;
+    return union > 0 ? intersection / union : 0;
+  }
+  
+  /**
+   * 分词
+   */
+  private tokenize(text: string): string[] {
+    return text
+      .toLowerCase()
+      .replace(/[^\w\u4e00-\u9fa5]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 1);
+  }
+  
+  /**
+   * 处理相似记忆对
+   */
+  private async processSimilarPair(pair: { m1: Memory; m2: Memory; score: number }): Promise<IntegrationResult | null> {
+    const { m1, m2, score } = pair;
+    
+    // 简单策略：保留访问次数多的，删除访问次数少的
+    const keep = m1.usageCount >= m2.usageCount ? m1 : m2;
+    const remove = m1.usageCount >= m2.usageCount ? m2 : m1;
+    
+    // 更新被保留的记忆
+    keep.mergedFrom = keep.mergedFrom || [];
+    keep.mergedFrom.push(remove.id);
+    keep.version++;
+    keep.updatedAt = new Date();
+    
+    // 添加合并记录到摘要
+    if (keep.content.insights) {
+      keep.content.insights.push(`[整合] 合并了记忆 ${remove.id.slice(0, 8)}，相似度 ${(score * 100).toFixed(0)}%`);
+    }
+    
+    // 删除被合并的记忆
+    await this.memorySystem.delete(remove.id);
+    
+    return {
+      clusterId: keep.id,
+      action: 'merged',
+      memoryIds: [m1.id, m2.id]
+    };
+  }
+  
+  /**
+   * 获取整合候选列表
+   */
+  getIntegrationCandidates(): { m1: Memory; m2: Memory; score: number }[] {
+    const candidates: { m1: Memory; m2: Memory; score: number }[] = [];
+    const memories = this.memorySystem.getAllMemories();
+    const threshold = this.config.integrationThreshold;
+    
+    for (let i = 0; i < memories.length; i++) {
+      for (let j = i + 1; j < memories.length; j++) {
+        const m1 = memories[i];
+        const m2 = memories[j];
+        
+        // 跳过已合并的
+        if (m1.mergedFrom?.includes(m2.id) || m2.mergedFrom?.includes(m1.id)) {
+          continue;
+        }
+        
+        const score = this.calculateSimilarity(
+          m1.content.task + ' ' + m1.content.result,
+          m2.content.task + ' ' + m2.content.result
+        );
+        
+        if (score >= threshold) {
+          candidates.push({ m1, m2, score });
+        }
+      }
+    }
+    
+    // 按相似度排序
+    candidates.sort((a, b) => b.score - a.score);
+    
+    return candidates;
+  }
+}