ai-memory-claw 1.0.0

package/src/memory-system.ts

@@ -0,0 +1,304 @@
+/**
+ * 记忆系统核心模块
+ * 
+ * 提供记忆的存储、搜索、管理功能
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { type Memory, type MemoryInput, type MemoryStats, type SearchOptions, type SearchResult, generateMemoryId } from './types';
+import { type MemoryConfig } from './config';
+import { EmbeddingGenerator } from './embedding';
+
+export class MemorySystem {
+  private config: MemoryConfig;
+  private dataDir: string;
+  private memories: Map<string, Memory> = new Map();
+  private categoryIndex: Map<string, Set<string>> = new Map();
+  private embeddingGenerator: EmbeddingGenerator;
+  private initialized: boolean = false;
+  
+  constructor(dataDir: string, config: MemoryConfig) {
+    this.dataDir = dataDir;
+    this.config = config;
+    this.embeddingGenerator = new EmbeddingGenerator();
+  }
+  
+  /**
+   * 初始化记忆系统
+   */
+  async initialize(): Promise<void> {
+    // 确保目录存在
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    
+    // 初始化向量生成器
+    await this.embeddingGenerator.initialize();
+    
+    // 加载已有记忆
+    await this.loadMemories();
+    
+    this.initialized = true;
+  }
+  
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+  
+  /**
+   * 搜索记忆
+   */
+  async search(query: string, options: SearchOptions): Promise<Memory[]> {
+    // 1. 生成查询向量
+    const queryVector = await this.embeddingGenerator.embed(query);
+    
+    // 2. 计算相似度
+    const results: SearchResult[] = [];
+    
+    for (const memory of this.memories.values()) {
+      if (memory.embedding.length === 0) continue;
+      
+      const score = this.embeddingGenerator.cosineSimilarity(
+        queryVector,
+        memory.embedding
+      );
+      
+      if (score >= options.threshold) {
+        results.push({ memory, score });
+      }
+    }
+    
+    // 3. 排序
+    results.sort((a, b) => b.score - a.score);
+    
+    // 4. 强化前N个记忆
+    for (const result of results.slice(0, options.limit)) {
+      await this.enhance(result.memory.id);
+    }
+    
+    // 5. 返回结果
+    return results.slice(0, options.limit).map(r => r.memory);
+  }
+  
+  /**
+   * 存储记忆
+   */
+  async store(input: MemoryInput): Promise<Memory> {
+    const id = generateMemoryId(input.category, input.subCategory);
+    
+    // 生成向量
+    const text = `${input.content.task} ${input.content.process}`;
+    const embedding = await this.embeddingGenerator.embed(text);
+    
+    const memory: Memory = {
+      id,
+      taskDescription: input.content.task,
+      category: input.category,
+      subCategory: input.subCategory,
+      cluster: `${input.subCategory}-cluster`,
+      content: input.content,
+      embedding,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      lastAccessedAt: new Date(),
+      version: 1,
+      diffs: [],
+      mergedFrom: [],
+      confidence: 0.8,
+      usageCount: 0,
+      importance: input.importance,
+      tags: input.tags || [],
+      encrypted: false,
+      autoCleanup: false
+    };
+    
+    // 保存到内存
+    this.memories.set(id, memory);
+    this.addToCategoryIndex(memory);
+    
+    // 保存到文件
+    await this.saveMemoryToFile(memory);
+    
+    return memory;
+  }
+  
+  /**
+   * 强化记忆
+   */
+  async enhance(memoryId: string): Promise<void> {
+    const memory = this.memories.get(memoryId);
+    if (!memory) return;
+    
+    memory.usageCount++;
+    memory.lastAccessedAt = new Date();
+    memory.updatedAt = new Date();
+    
+    // 提升重要性
+    if (memory.importance !== 'critical') {
+      const levels: ('low' | 'medium' | 'high' | 'critical')[] = 
+        ['low', 'medium', 'high', 'critical'];
+      const idx = levels.indexOf(memory.importance);
+      if (idx < levels.length - 1 && memory.usageCount > 3) {
+        memory.importance = levels[idx + 1];
+      }
+    }
+    
+    await this.saveMemoryToFile(memory);
+  }
+  
+  /**
+   * 获取所有记忆
+   */
+  getAllMemories(): Memory[] {
+    return Array.from(this.memories.values());
+  }
+  
+  /**
+   * 获取记忆统计
+   */
+  getStats(): MemoryStats {
+    const memories = this.getAllMemories();
+    
+    const byCategory: Record<string, number> = {};
+    const byImportance: Record<string, number> = {};
+    let totalUsage = 0;
+    
+    for (const m of memories) {
+      byCategory[m.category] = (byCategory[m.category] || 0) + 1;
+      byImportance[m.importance] = (byImportance[m.importance] || 0) + 1;
+      totalUsage += m.usageCount;
+    }
+    
+    return {
+      total: memories.length,
+      byCategory,
+      byImportance,
+      averageUsage: memories.length > 0 ? totalUsage / memories.length : 0
+    };
+  }
+  
+  /**
+   * 按类别获取记忆
+   */
+  getMemoriesByCategory(category: string): Memory[] {
+    const ids = this.categoryIndex.get(category);
+    if (!ids) return [];
+    return Array.from(ids).map(id => this.memories.get(id)).filter(Boolean) as Memory[];
+  }
+  
+  /**
+   * 获取记忆
+   */
+  getMemory(id: string): Memory | undefined {
+    return this.memories.get(id);
+  }
+  
+  /**
+   * 删除记忆
+   */
+  async delete(id: string): Promise<boolean> {
+    const memory = this.memories.get(id);
+    if (!memory) return false;
+    
+    // 从内存中删除
+    this.memories.delete(id);
+    this.removeFromCategoryIndex(memory);
+    
+    // 从文件中删除
+    const filePath = this.getMemoryFilePath(memory);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+    
+    return true;
+  }
+  
+  /**
+   * 加载记忆到内存
+   */
+  private async loadMemories(): Promise<void> {
+    if (!fs.existsSync(this.dataDir)) return;
+    
+    const categories = fs.readdirSync(this.dataDir);
+    
+    for (const category of categories) {
+      const categoryPath = path.join(this.dataDir, category);
+      if (!fs.statSync(categoryPath).isDirectory()) continue;
+      
+      const subCategories = fs.readdirSync(categoryPath);
+      
+      for (const subCategory of subCategories) {
+        const subCategoryPath = path.join(categoryPath, subCategory);
+        if (!fs.statSync(subCategoryPath).isDirectory()) continue;
+        
+        const files = fs.readdirSync(subCategoryPath);
+        
+        for (const file of files) {
+          if (!file.endsWith('.json') || file === 'index.json') continue;
+          
+          try {
+            const content = fs.readFileSync(
+              path.join(subCategoryPath, file),
+              'utf-8'
+            );
+            const memory = JSON.parse(content) as Memory;
+            memory.createdAt = new Date(memory.createdAt);
+            memory.updatedAt = new Date(memory.updatedAt);
+            memory.lastAccessedAt = new Date(memory.lastAccessedAt);
+            
+            this.memories.set(memory.id, memory);
+            this.addToCategoryIndex(memory);
+          } catch (e) {
+            console.error(`加载记忆失败: ${file}`, e);
+          }
+        }
+      }
+    }
+  }
+  
+  /**
+   * 保存记忆到文件
+   */
+  private async saveMemoryToFile(memory: Memory): Promise<void> {
+    const dir = path.join(this.dataDir, memory.category, memory.subCategory);
+    
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    const filePath = path.join(dir, `${memory.id}.json`);
+    await fs.promises.writeFile(filePath, JSON.stringify(memory, null, 2));
+  }
+  
+  /**
+   * 获取记忆文件路径
+   */
+  private getMemoryFilePath(memory: Memory): string {
+    return path.join(this.dataDir, memory.category, memory.subCategory, `${memory.id}.json`);
+  }
+  
+  /**
+   * 添加到分类索引
+   */
+  private addToCategoryIndex(memory: Memory): void {
+    if (!this.categoryIndex.has(memory.category)) {
+      this.categoryIndex.set(memory.category, new Set());
+    }
+    this.categoryIndex.get(memory.category)!.add(memory.id);
+  }
+  
+  /**
+   * 从分类索引中移除
+   */
+  private removeFromCategoryIndex(memory: Memory): void {
+    const set = this.categoryIndex.get(memory.category);
+    if (set) {
+      set.delete(memory.id);
+      if (set.size === 0) {
+        this.categoryIndex.delete(memory.category);
+      }
+    }
+  }
+}

package/src/test.ts

@@ -0,0 +1,116 @@
+/**
+ * 简单测试脚本
+ * 用于验证核心功能
+ */
+
+import { MemorySystem } from './memory-system';
+import { defaultMemoryConfig } from './config';
+import { TriggerAnalyzer } from './triggers';
+import { CategoryAnalyzer } from './category';
+import { AutoRecall } from './auto-recall';
+import { AutoCapture } from './auto-capture';
+
+async function runTests() {
+  console.log('🧪 开始测试...\n');
+  
+  // 测试1: 关键词分析
+  console.log('📝 测试1: 关键词分析');
+  const trigger = new TriggerAnalyzer();
+  
+  const testCases = [
+    { text: '记住我的密码是123456', expected: 'critical' },
+    { text: '我决定使用Docker', expected: 'high' },
+    { text: '帮我写个Python脚本', expected: 'medium' },
+    { text: '谢谢你的帮助', expected: 'low' },
+  ];
+  
+  for (const tc of testCases) {
+    const result = trigger.analyze(tc.text);
+    const pass = result === tc.expected ? '✅' : '❌';
+    console.log(`  ${pass} "${tc.text}" => ${result} (期望: ${tc.expected})`);
+  }
+  
+  // 测试2: 分类分析
+  console.log('\n📝 测试2: 分类分析');
+  const category = new CategoryAnalyzer();
+  
+  const categoryTests = [
+    { text: '帮我写个Python脚本', expected: '代码开发' },
+    { text: '配置Docker环境', expected: '系统运维' },
+    { text: '帮我写份报告', expected: '文档撰写' },
+    { text: '分析销售数据', expected: '数据分析' },
+  ];
+  
+  for (const tc of categoryTests) {
+    const result = category.analyze(tc.text);
+    const pass = result.category === tc.expected ? '✅' : '❌';
+    console.log(`  ${pass} "${tc.text}" => ${result.category} (期望: ${tc.expected})`);
+  }
+  
+  // 测试3: 记忆系统
+  console.log('\n📝 测试3: 记忆系统');
+  const memorySystem = new MemorySystem('./test-data', defaultMemoryConfig);
+  await memorySystem.initialize();
+  
+  // 存储测试
+  const memory1 = await memorySystem.store({
+    content: {
+      task: '帮我写个Python脚本',
+      process: '创建了script.py',
+      result: '完成',
+      insights: []
+    },
+    category: '代码开发',
+    subCategory: '脚本',
+    importance: 'medium'
+  });
+  console.log(`  ✅ 存储记忆: ${memory1.id}`);
+  
+  // 搜索测试
+  const searchResults = await memorySystem.search('Python脚本', {
+    limit: 3,
+    threshold: 0.1
+  });
+  console.log(`  ✅ 搜索结果: 找到 ${searchResults.length} 条`);
+  
+  // 统计测试
+  const stats = memorySystem.getStats();
+  console.log(`  ✅ 统计: ${stats.total} 条记忆`);
+  
+  // 测试4: 自动召回
+  console.log('\n📝 测试4: 自动召回');
+  const autoRecall = new AutoRecall(memorySystem, defaultMemoryConfig);
+  const recallResult = await autoRecall.execute({
+    prompt: '之前让我写的脚本在哪？'
+  });
+  if (recallResult) {
+    console.log(`  ✅ 自动召回成功`);
+    console.log(`     ${recallResult.prependContext.slice(0, 100)}...`);
+  } else {
+    console.log(`  ⚠️  无相关记忆返回`);
+  }
+  
+  // 测试5: 自动捕获
+  console.log('\n📝 测试5: 自动捕获');
+  const autoCapture = new AutoCapture(memorySystem, defaultMemoryConfig);
+  await autoCapture.execute({
+    messages: [
+      { role: 'user', content: '帮我创建一个备份脚本' },
+      { role: 'assistant', content: '已创建backup.ps1' }
+    ]
+  });
+  
+  const stats2 = memorySystem.getStats();
+  console.log(`  ✅ 自动捕获后: ${stats2.total} 条记忆`);
+  
+  console.log('\n🎉 测试完成！');
+  
+  // 清理测试数据
+  const fs = await import('fs');
+  if (fs.existsSync('./test-data')) {
+    fs.rmSync('./test-data', { recursive: true });
+    console.log('🧹 已清理测试数据');
+  }
+}
+
+runTests().catch(console.error);

package/src/triggers.ts

@@ -0,0 +1,126 @@
+/**
+ * 关键词分析模块
+ * 
+ * 分析文本内容，判断重要性等级，提取标签
+ */
+
+import type { ImportanceLevel } from './types';
+
+export class TriggerAnalyzer {
+  // 关键信息 - importance = critical
+  private criticalPatterns = [
+    // 中文
+    /记住|别忘了|提醒我|提醒/i,
+    /密码|账号|身份|银行卡|信用卡/i,
+    /\+\d{10,}/,                    // 电话
+    /[\w.-]+@[\w.-]+\.\w+/,         // 邮箱
+    // 英文
+    /remember|don't forget|remind me/i,
+    /password|account|identity|card/i
+  ];
+  
+  // 重要决策 - importance = high
+  private highPatterns = [
+    // 中文
+    /决定|选择|采用|否决|定下来/i,
+    /配置|安装|部署|设置/i,
+    /偏好|喜欢|讨厌|想要/i,
+    // 英文
+    /decide|decided|choose|use|adopt/i,
+    /config|install|deploy|setup/i,
+    /prefer|like|hate|want/i
+  ];
+  
+  // 一般工作 - importance = medium
+  private mediumPatterns = [
+    // 中文
+    /实现|修复|创建|帮助|完成|解决了/i,
+    /写|做|生成|处理|分析/i,
+    /实现|添加|新增|重构|优化/i,
+    // 英文
+    /implement|fix|create|help|complete|build/i,
+    /write|make|generate|process|analyze/i,
+    /add|new|refactor|optimize/i
+  ];
+  
+  // 低价值 - importance = low
+  private lowPatterns = [
+    // 中文
+    /^你好|^谢谢|^再见|^好的/i,
+    /请问|没什么|随便/i,
+    // 英文
+    /^(hi|hello|thanks|bye|ok|okay)$/i,
+    /nothing|just|whatever/i
+  ];
+  
+  /**
+   * 分析文本，返回重要性等级
+   */
+  analyze(content: string): ImportanceLevel {
+    const lower = content.toLowerCase();
+    
+    if (this.criticalPatterns.some(p => p.test(lower))) {
+      return 'critical';
+    }
+    if (this.highPatterns.some(p => p.test(lower))) {
+      return 'high';
+    }
+    if (this.lowPatterns.some(p => p.test(lower))) {
+      return 'low';
+    }
+    if (this.mediumPatterns.some(p => p.test(lower))) {
+      return 'medium';
+    }
+    
+    // 默认中等
+    return 'medium';
+  }
+  
+  /**
+   * 提取标签
+   */
+  extractTags(content: string): string[] {
+    const tags: string[] = [];
+    const lower = content.toLowerCase();
+    
+    // 标签映射
+    const tagPatterns: Record<string, RegExp[]> = {
+      // 技术相关
+      '代码': [/代码|编程|函数|脚本/i, /code|program|script/i],
+      '配置': [/配置|设置|安装/i, /config|setup|install/i],
+      '数据': [/数据|分析|统计/i, /data|analysis|stat/i],
+      '文档': [/文档|报告|文章/i, /doc|report|article/i],
+      '决策': [/决定|选择|采用/i, /decide|choose|adopt/i],
+      '问题': [/错误|bug|问题|故障/i, /error|bug|issue|problem/i],
+      '完成': [/完成|解决了|实现了/i, /done|completed|implemented/i],
+      '创建': [/创建|新建/i, /create|new/i],
+      // 偏好相关
+      '偏好': [/喜欢|偏好|讨厌|想要/i, /prefer|like|hate|want/i],
+      // 个人信息
+      '记住': [/记住|别忘了/i, /remember|don't forget/i],
+      '重要': [/重要|关键|永远|永不/i, /important|critical|always|never/i]
+    };
+    
+    for (const [tag, patterns] of Object.entries(tagPatterns)) {
+      if (patterns.some(p => p.test(lower))) {
+        tags.push(tag);
+      }
+    }
+    
+    return tags;
+  }
+  
+  /**
+   * 检测是否包含关键信息
+   */
+  hasCriticalInfo(content: string): boolean {
+    return this.analyze(content) === 'critical';
+  }
+  
+  /**
+   * 检测是否低价值内容
+   */
+  isLowValue(content: string): boolean {
+    return this.analyze(content) === 'low';
+  }
+}