@chongyan/autospec 1.0.1

package/plugins/hooks/lib/project-evolution/memory-manager.js

@@ -0,0 +1,346 @@
+/**
+ * Project-Evolve Memory Manager
+ * 评测记忆管理器 - 负责记忆的CRUD、生命周期管理、持久化
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+class MemoryManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.memoryPath = path.join(projectRoot, '.autospec', 'memory');
+    this.indexPath = path.join(this.memoryPath, 'index.yaml');
+  }
+
+  /**
+   * 初始化记忆系统
+   */
+  init() {
+    // 创建目录结构
+    const dirs = [
+      this.memoryPath,
+      path.join(this.memoryPath, 'discovered'),
+      path.join(this.memoryPath, 'patterns'),
+      path.join(this.memoryPath, 'preferences'),
+      path.join(this.memoryPath, 'evolution'),
+      path.join(this.memoryPath, 'embeddings')
+    ];
+
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+
+    // 创建初始索引
+    if (!fs.existsSync(this.indexPath)) {
+      this.saveIndex({
+        version: '1.0',
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        memories: [],
+        stats: {
+          total: 0,
+          learning: 0,
+          validated: 0,
+          deprecated: 0
+        }
+      });
+    }
+
+    return this;
+  }
+
+  /**
+   * 加载记忆索引
+   */
+  loadIndex() {
+    if (!fs.existsSync(this.indexPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(this.indexPath, 'utf8');
+    return this.parseYaml(content);
+  }
+
+  /**
+   * 保存记忆索引
+   */
+  saveIndex(index) {
+    index.updated_at = new Date().toISOString();
+    fs.writeFileSync(this.indexPath, this.stringifyYaml(index));
+  }
+
+  /**
+   * 添加记忆
+   */
+  addMemory(memory) {
+    const index = this.loadIndex();
+
+    // 生成唯一ID
+    memory.id = memory.id || this.generateId();
+    memory.meta = memory.meta || {};
+    memory.meta.created_at = new Date().toISOString();
+    memory.meta.updated_at = new Date().toISOString();
+    memory.meta.status = memory.meta.status || 'learning';
+    memory.meta.version = memory.meta.version || '1.0';
+
+    // 保存记忆文件
+    const memoryPath = this.getMemoryPath(memory.id, memory.meta.status);
+    fs.writeFileSync(memoryPath, this.stringifyYaml(memory));
+
+    // 更新索引
+    index.memories.push({
+      id: memory.id,
+      name: memory.meta.name,
+      category: memory.meta.category,
+      status: memory.meta.status,
+      created_at: memory.meta.created_at,
+      updated_at: memory.meta.updated_at
+    });
+
+    this.updateStats(index);
+    this.saveIndex(index);
+
+    return memory.id;
+  }
+
+  /**
+   * 获取记忆
+   */
+  getMemory(id) {
+    const index = this.loadIndex();
+    const entry = index.memories.find(m => m.id === id);
+
+    if (!entry) {
+      return null;
+    }
+
+    const memoryPath = this.getMemoryPath(id, entry.status);
+
+    if (!fs.existsSync(memoryPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(memoryPath, 'utf8');
+    return this.parseYaml(content);
+  }
+
+  /**
+   * 更新记忆
+   */
+  updateMemory(id, updates) {
+    const memory = this.getMemory(id);
+
+    if (!memory) {
+      throw new Error(`Memory not found: ${id}`);
+    }
+
+    // 应用更新
+    Object.assign(memory, updates);
+    memory.meta.updated_at = new Date().toISOString();
+
+    // 如果状态变化，移动文件
+    const oldStatus = memory.meta.status;
+    const newStatus = updates.meta?.status || oldStatus;
+
+    if (oldStatus !== newStatus) {
+      const oldPath = this.getMemoryPath(id, oldStatus);
+      const newPath = this.getMemoryPath(id, newStatus);
+
+      if (fs.existsSync(oldPath)) {
+        fs.unlinkSync(oldPath);
+      }
+      fs.writeFileSync(newPath, this.stringifyYaml(memory));
+    } else {
+      const memoryPath = this.getMemoryPath(id, memory.meta.status);
+      fs.writeFileSync(memoryPath, this.stringifyYaml(memory));
+    }
+
+    // 更新索引
+    const index = this.loadIndex();
+    const entry = index.memories.find(m => m.id === id);
+
+    if (entry) {
+      entry.name = memory.meta.name;
+      entry.category = memory.meta.category;
+      entry.status = memory.meta.status;
+      entry.updated_at = memory.meta.updated_at;
+    }
+
+    this.updateStats(index);
+    this.saveIndex(index);
+
+    return memory;
+  }
+
+  /**
+   * 删除记忆
+   */
+  deleteMemory(id) {
+    const memory = this.getMemory(id);
+
+    if (!memory) {
+      return false;
+    }
+
+    // 删除文件
+    const memoryPath = this.getMemoryPath(id, memory.meta.status);
+
+    if (fs.existsSync(memoryPath)) {
+      fs.unlinkSync(memoryPath);
+    }
+
+    // 更新索引
+    const index = this.loadIndex();
+    index.memories = index.memories.filter(m => m.id !== id);
+
+    this.updateStats(index);
+    this.saveIndex(index);
+
+    return true;
+  }
+
+  /**
+   * 查询记忆
+   */
+  queryMemories(options = {}) {
+    const index = this.loadIndex();
+    let results = index.memories;
+
+    // 按状态过滤
+    if (options.status) {
+      results = results.filter(m => m.status === options.status);
+    }
+
+    // 按类别过滤
+    if (options.category) {
+      results = results.filter(m => m.category === options.category);
+    }
+
+    // 加载完整记忆
+    if (options.full) {
+      results = results.map(m => this.getMemory(m.id));
+    }
+
+    return results;
+  }
+
+  /**
+   * 获取记忆文件路径
+   */
+  getMemoryPath(id, status) {
+    const dir = path.join(this.memoryPath, status === 'validated' ? 'patterns' : 'discovered');
+    return path.join(dir, `${id}.yaml`);
+  }
+
+  /**
+   * 更新统计信息
+   */
+  updateStats(index) {
+    index.stats = {
+      total: index.memories.length,
+      learning: index.memories.filter(m => m.status === 'learning').length,
+      validated: index.memories.filter(m => m.status === 'validated').length,
+      deprecated: index.memories.filter(m => m.status === 'deprecated').length
+    };
+  }
+
+  /**
+   * 生成唯一ID
+   */
+  generateId() {
+    return crypto.randomUUID();
+  }
+
+  /**
+   * 解析YAML（简化版）
+   */
+  parseYaml(content) {
+    // 实际项目中使用 yaml 库
+    // 这里简化处理
+    try {
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+
+  /**
+   * 序列化为YAML（简化版）
+   */
+  stringifyYaml(obj) {
+    // 实际项目中使用 yaml 库
+    // 这里简化处理
+    return JSON.stringify(obj, null, 2);
+  }
+
+  /**
+   * 导出记忆包
+   */
+  exportMemoryPackage(name) {
+    const index = this.loadIndex();
+    const validatedMemories = index.memories.filter(m => m.status === 'validated');
+
+    const package = {
+      name: name,
+      version: '1.0',
+      exported_at: new Date().toISOString(),
+      memories: validatedMemories.map(m => this.getMemory(m.id))
+    };
+
+    return package;
+  }
+
+  /**
+   * 导入记忆包
+   */
+  importMemoryPackage(packageData, options = {}) {
+    for (const memory of packageData.memories) {
+      // 重置状态为 learning
+      memory.meta.status = 'learning';
+      memory.meta.imported_from = packageData.name;
+      memory.meta.imported_at = new Date().toISOString();
+
+      // 检查是否已存在
+      const existing = this.getMemory(memory.id);
+
+      if (existing && !options.overwrite) {
+        continue; // 跳过已存在的
+      }
+
+      this.addMemory(memory);
+    }
+
+    return packageData.memories.length;
+  }
+
+  /**
+   * 获取记忆统计
+   */
+  getStats() {
+    const index = this.loadIndex();
+    return index.stats;
+  }
+
+  /**
+   * 记录执行episode
+   */
+  recordEpisode(episode) {
+    const episodesDir = path.join(this.memoryPath, 'evolution', 'episodes');
+
+    if (!fs.existsSync(episodesDir)) {
+      fs.mkdirSync(episodesDir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const episodePath = path.join(episodesDir, `episode-${timestamp}.yaml`);
+
+    fs.writeFileSync(episodePath, this.stringifyYaml(episode));
+
+    return episodePath;
+  }
+}
+
+module.exports = MemoryManager;