memory-pulse-mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,2051 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// ../storage/dist/sqlite-storage.js
+import Database from "better-sqlite3";
+import { nanoid } from "nanoid";
+
+// ../core/dist/types.js
+var MemoryType;
+(function(MemoryType2) {
+  MemoryType2["DECISION"] = "decision";
+  MemoryType2["SOLUTION"] = "solution";
+  MemoryType2["CONFIG"] = "config";
+  MemoryType2["CODE"] = "code";
+  MemoryType2["ERROR"] = "error";
+  MemoryType2["SESSION"] = "session";
+})(MemoryType || (MemoryType = {}));
+var SearchStrategy;
+(function(SearchStrategy2) {
+  SearchStrategy2["EXACT"] = "exact";
+  SearchStrategy2["FULLTEXT"] = "fulltext";
+  SearchStrategy2["SEMANTIC"] = "semantic";
+  SearchStrategy2["AUTO"] = "auto";
+})(SearchStrategy || (SearchStrategy = {}));
+
+// ../storage/dist/schema.js
+function initSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      projectId TEXT NOT NULL,
+      sessionId TEXT,
+      timestamp TEXT NOT NULL,
+      type TEXT NOT NULL,
+      tags TEXT, -- JSON\u6570\u7EC4: ["tag1", "tag2"]
+      version INTEGER DEFAULT 1,
+
+      -- content
+      summary TEXT NOT NULL,
+      data TEXT, -- JSON\u5BF9\u8C61
+
+      -- relations
+      replaces TEXT, -- JSON\u6570\u7EC4
+      relatedTo TEXT, -- JSON\u6570\u7EC4
+      impacts TEXT, -- JSON\u6570\u7EC4
+      derivedFrom TEXT,
+
+      -- context\uFF08\u7279\u5B9A\u7C7B\u578B\u7684\u4E0A\u4E0B\u6587\u6570\u636E\uFF09
+      context TEXT, -- JSON\u5BF9\u8C61
+
+      -- searchable
+      keywords TEXT, -- JSON\u6570\u7EC4
+      fullText TEXT,
+
+      -- \u65F6\u95F4\u6233
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL,
+
+      -- \u7D22\u5F15\u5B57\u6BB5
+      UNIQUE(id)
+    );
+  `);
+  db.exec(`
+    -- \u9879\u76EEID\u7D22\u5F15\uFF08\u9891\u7E41\u6309\u9879\u76EE\u67E5\u8BE2\uFF09
+    CREATE INDEX IF NOT EXISTS idx_memories_projectId ON memories(projectId);
+
+    -- \u4F1A\u8BDDID\u7D22\u5F15
+    CREATE INDEX IF NOT EXISTS idx_memories_sessionId ON memories(sessionId);
+
+    -- \u7C7B\u578B\u7D22\u5F15
+    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+
+    -- \u65F6\u95F4\u6233\u7D22\u5F15\uFF08\u7528\u4E8E\u65F6\u95F4\u7EBF\u67E5\u8BE2\uFF09
+    CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp DESC);
+
+    -- \u590D\u5408\u7D22\u5F15\uFF08\u9879\u76EE+\u7C7B\u578B\uFF09- \u7528\u4E8E\u6309\u9879\u76EE\u548C\u7C7B\u578B\u8FC7\u6EE4
+    CREATE INDEX IF NOT EXISTS idx_memories_project_type ON memories(projectId, type);
+
+    -- \u590D\u5408\u7D22\u5F15\uFF08\u9879\u76EE+\u65F6\u95F4\uFF09- \u7528\u4E8E\u9879\u76EE\u65F6\u95F4\u7EBF\u67E5\u8BE2\uFF0C\u6027\u80FD\u63D0\u5347\u663E\u8457
+    CREATE INDEX IF NOT EXISTS idx_memories_project_timestamp ON memories(projectId, timestamp DESC);
+
+    -- \u590D\u5408\u7D22\u5F15\uFF08\u9879\u76EE+\u7C7B\u578B+\u65F6\u95F4\uFF09- \u7528\u4E8E\u6309\u9879\u76EE\u548C\u7C7B\u578B\u8FC7\u6EE4\u7684\u65F6\u95F4\u7EBF
+    CREATE INDEX IF NOT EXISTS idx_memories_project_type_timestamp ON memories(projectId, type, timestamp DESC);
+
+    -- \u90E8\u5206\u7D22\u5F15\uFF08\u4EC5\u7D22\u5F15\u6709\u4F1A\u8BDD\u7684\u8BB0\u5FC6\uFF09- \u51CF\u5C11\u7D22\u5F15\u5927\u5C0F
+    CREATE INDEX IF NOT EXISTS idx_memories_session_active ON memories(sessionId, timestamp DESC)
+      WHERE sessionId IS NOT NULL;
+  `);
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      summary,
+      fullText,
+      tokenize = 'unicode61'
+    );
+  `);
+  db.exec(`
+    -- \u63D2\u5165\u89E6\u53D1\u5668
+    CREATE TRIGGER IF NOT EXISTS memories_fts_insert AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, summary, fullText)
+      VALUES (new.rowid, new.summary, new.fullText);
+    END;
+
+    -- \u66F4\u65B0\u89E6\u53D1\u5668
+    CREATE TRIGGER IF NOT EXISTS memories_fts_update AFTER UPDATE ON memories BEGIN
+      UPDATE memories_fts
+      SET summary = new.summary, fullText = new.fullText
+      WHERE rowid = new.rowid;
+    END;
+
+    -- \u5220\u9664\u89E6\u53D1\u5668
+    CREATE TRIGGER IF NOT EXISTS memories_fts_delete AFTER DELETE ON memories BEGIN
+      DELETE FROM memories_fts WHERE rowid = old.rowid;
+    END;
+  `);
+}
+
+// ../storage/dist/cache.js
+var LRUCache = class {
+  capacity;
+  cache;
+  head;
+  tail;
+  hits;
+  misses;
+  constructor(capacity = 100) {
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+    this.head = null;
+    this.tail = null;
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * 生成缓存 key
+   */
+  static generateKey(filters) {
+    const parts = [
+      filters.query || "",
+      filters.projectId || "",
+      filters.type || "",
+      filters.sessionId || "",
+      filters.strategy || "",
+      filters.limit || "",
+      filters.offset || "",
+      (filters.tags || []).sort().join(",")
+    ];
+    return parts.join("|");
+  }
+  /**
+   * 获取缓存
+   */
+  get(key) {
+    const node = this.cache.get(key);
+    if (!node) {
+      this.misses++;
+      return null;
+    }
+    this.moveToHead(node);
+    this.hits++;
+    return {
+      ...node.value,
+      metrics: {
+        dbTime: node.value.metrics?.dbTime || 0,
+        parseTime: node.value.metrics?.parseTime || 0,
+        strategyTime: node.value.metrics?.strategyTime,
+        cacheHit: true
+      }
+    };
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, value) {
+    let node = this.cache.get(key);
+    if (node) {
+      node.value = value;
+      this.moveToHead(node);
+    } else {
+      node = {
+        key,
+        value,
+        prev: null,
+        next: null
+      };
+      this.cache.set(key, node);
+      this.addToHead(node);
+      if (this.cache.size > this.capacity) {
+        const removed = this.removeTail();
+        if (removed) {
+          this.cache.delete(removed.key);
+        }
+      }
+    }
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+    this.head = null;
+    this.tail = null;
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * 失效指定项目的所有缓存
+   */
+  invalidateProject(projectId) {
+    const keysToDelete = [];
+    for (const [key, _] of this.cache) {
+      if (key.includes(`|${projectId}|`)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      const node = this.cache.get(key);
+      if (node) {
+        this.removeNode(node);
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * 获取缓存统计
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      capacity: this.capacity,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+  // ========== 双向链表操作 ==========
+  addToHead(node) {
+    node.next = this.head;
+    node.prev = null;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+  }
+  removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+  }
+  moveToHead(node) {
+    this.removeNode(node);
+    this.addToHead(node);
+  }
+  removeTail() {
+    const node = this.tail;
+    if (node) {
+      this.removeNode(node);
+    }
+    return node;
+  }
+};
+
+// ../storage/dist/sqlite-storage.js
+var SQLiteStorage = class {
+  db;
+  cache;
+  constructor(dbPath = ":memory:", options) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    initSchema(this.db);
+    this.cache = options?.enableCache !== false ? new LRUCache(options?.cacheSize || 100) : null;
+  }
+  /**
+   * 通用存储方法
+   */
+  async store(params) {
+    const id = `mem_${nanoid()}`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const memoryType = params.type || MemoryType.CODE;
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (
+        id, projectId, sessionId, timestamp, type, tags,
+        summary, data, replaces, relatedTo, impacts, derivedFrom,
+        context, keywords, fullText, createdAt, updatedAt
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?
+      )
+    `);
+    stmt.run(
+      id,
+      params.projectId,
+      params.sessionId || null,
+      timestamp,
+      memoryType,
+      params.tags ? JSON.stringify(params.tags) : null,
+      params.content,
+      // summary
+      JSON.stringify(params.rawContext),
+      // data
+      params.relations?.replaces ? JSON.stringify(params.relations.replaces) : null,
+      params.relations?.relatedTo ? JSON.stringify(params.relations.relatedTo) : null,
+      params.relations?.impacts ? JSON.stringify(params.relations.impacts) : null,
+      params.relations?.derivedFrom || null,
+      JSON.stringify(params.rawContext),
+      // context
+      params.tags ? JSON.stringify(params.tags) : null,
+      // keywords
+      params.content,
+      // fullText
+      timestamp,
+      timestamp
+    );
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 存储决策记忆
+   */
+  async storeDecision(params) {
+    const id = `mem_${nanoid()}`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = `[\u51B3\u7B56] ${params.question}`;
+    const fullText = `${params.question} ${params.options.map((o) => o.name).join(" ")} ${params.reason}`;
+    const keywords = [...params.tags || [], ...params.options.map((o) => o.name), params.chosen];
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (
+        id, projectId, sessionId, timestamp, type, tags,
+        summary, data, replaces, relatedTo, impacts, derivedFrom,
+        context, keywords, fullText, createdAt, updatedAt
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?
+      )
+    `);
+    stmt.run(
+      id,
+      params.projectId,
+      params.sessionId || null,
+      timestamp,
+      MemoryType.DECISION,
+      params.tags ? JSON.stringify(params.tags) : null,
+      summary,
+      JSON.stringify({}),
+      // data为空
+      params.relations?.replaces ? JSON.stringify(params.relations.replaces) : null,
+      params.relations?.relatedTo ? JSON.stringify(params.relations.relatedTo) : null,
+      params.relations?.impacts ? JSON.stringify(params.relations.impacts) : null,
+      params.relations?.derivedFrom || null,
+      JSON.stringify({
+        question: params.question,
+        options: params.options,
+        chosen: params.chosen,
+        reason: params.reason
+      }),
+      JSON.stringify(keywords),
+      fullText,
+      timestamp,
+      timestamp
+    );
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 存储解决方案记忆
+   */
+  async storeSolution(params) {
+    const id = `mem_${nanoid()}`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = `[\u65B9\u6848] ${params.problem}`;
+    const fullText = `${params.problem} ${params.rootCause} ${params.solution} ${params.prevention || ""} ${params.relatedIssues?.join(" ") || ""}`;
+    const keywords = [...params.tags || [], ...params.relatedIssues || []];
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (
+        id, projectId, sessionId, timestamp, type, tags,
+        summary, data, replaces, relatedTo, impacts, derivedFrom,
+        context, keywords, fullText, createdAt, updatedAt
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?
+      )
+    `);
+    stmt.run(id, params.projectId, params.sessionId || null, timestamp, MemoryType.SOLUTION, params.tags ? JSON.stringify(params.tags) : null, summary, JSON.stringify(params.artifacts || {}), params.relations?.replaces ? JSON.stringify(params.relations.replaces) : null, params.relations?.relatedTo ? JSON.stringify(params.relations.relatedTo) : null, params.relations?.impacts ? JSON.stringify(params.relations.impacts) : null, params.relations?.derivedFrom || null, JSON.stringify({
+      problem: params.problem,
+      rootCause: params.rootCause,
+      solution: params.solution,
+      prevention: params.prevention,
+      relatedIssues: params.relatedIssues
+    }), JSON.stringify(keywords), fullText, timestamp, timestamp);
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 存储会话记忆
+   */
+  async storeSession(params) {
+    const id = `mem_${nanoid()}`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = `[\u4F1A\u8BDD] ${params.summary}`;
+    const fullText = `${params.summary} ${params.decisions?.join(" ") || ""} ${params.unfinishedTasks?.join(" ") || ""} ${params.nextSteps?.join(" ") || ""}`;
+    const keywords = [...params.decisions || [], ...params.unfinishedTasks || []];
+    const stmt = this.db.prepare(`
+      INSERT INTO memories (
+        id, projectId, sessionId, timestamp, type, tags,
+        summary, data, replaces, relatedTo, impacts, derivedFrom,
+        context, keywords, fullText, createdAt, updatedAt
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?
+      )
+    `);
+    stmt.run(
+      id,
+      params.projectId,
+      params.sessionId || id,
+      // 使用当前id作为sessionId
+      timestamp,
+      MemoryType.SESSION,
+      null,
+      // tags
+      summary,
+      JSON.stringify({}),
+      null,
+      // replaces
+      null,
+      // relatedTo
+      null,
+      // impacts
+      null,
+      // derivedFrom
+      JSON.stringify({
+        summary: params.summary,
+        decisions: params.decisions,
+        unfinishedTasks: params.unfinishedTasks,
+        nextSteps: params.nextSteps
+      }),
+      JSON.stringify(keywords),
+      fullText,
+      timestamp,
+      timestamp
+    );
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 检索记忆
+   */
+  async recall(filters) {
+    const startTime = Date.now();
+    if (this.cache) {
+      const cacheKey = LRUCache.generateKey(filters);
+      const cached = this.cache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    const strategy = filters.strategy || SearchStrategy.AUTO;
+    const limit = filters.limit || 10;
+    const offset = filters.offset || 0;
+    let actualStrategy;
+    let results;
+    let dbStartTime;
+    let dbEndTime;
+    let parseStartTime;
+    const strategyStartTime = Date.now();
+    if (strategy === SearchStrategy.EXACT || strategy === SearchStrategy.AUTO) {
+      dbStartTime = Date.now();
+      results = this.exactSearch(filters, limit, offset);
+      dbEndTime = Date.now();
+      actualStrategy = SearchStrategy.EXACT;
+      if (results.length === 0 && strategy === SearchStrategy.AUTO) {
+        dbStartTime = Date.now();
+        results = this.fulltextSearch(filters, limit, offset);
+        dbEndTime = Date.now();
+        actualStrategy = SearchStrategy.FULLTEXT;
+      }
+    } else if (strategy === SearchStrategy.FULLTEXT) {
+      dbStartTime = Date.now();
+      results = this.fulltextSearch(filters, limit, offset);
+      dbEndTime = Date.now();
+      actualStrategy = SearchStrategy.FULLTEXT;
+    } else {
+      dbStartTime = Date.now();
+      results = this.fulltextSearch(filters, limit, offset);
+      dbEndTime = Date.now();
+      actualStrategy = SearchStrategy.FULLTEXT;
+    }
+    const strategyTime = Date.now() - strategyStartTime;
+    const took = Date.now() - startTime;
+    const dbTime = dbEndTime - dbStartTime;
+    const parseTime = took - dbTime - strategyTime;
+    const result = {
+      memories: results,
+      total: results.length,
+      strategy: actualStrategy,
+      took,
+      metrics: {
+        dbTime,
+        parseTime: Math.max(0, parseTime),
+        // 确保非负
+        strategyTime,
+        cacheHit: false
+        // 数据库查询，标记为未命中
+      }
+    };
+    if (this.cache) {
+      const cacheKey = LRUCache.generateKey(filters);
+      this.cache.set(cacheKey, result);
+    }
+    return result;
+  }
+  /**
+   * L1: 精确匹配检索
+   */
+  exactSearch(filters, limit, offset) {
+    let sql = "SELECT * FROM memories WHERE 1=1";
+    const params = [];
+    if (filters.projectId) {
+      sql += " AND projectId = ?";
+      params.push(filters.projectId);
+    }
+    if (filters.type) {
+      sql += " AND type = ?";
+      params.push(filters.type);
+    }
+    if (filters.sessionId) {
+      sql += " AND sessionId = ?";
+      params.push(filters.sessionId);
+    }
+    if (filters.query) {
+      sql += " AND (summary LIKE ? OR fullText LIKE ?)";
+      params.push(`%${filters.query}%`, `%${filters.query}%`);
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * L2: 全文搜索（FTS5）
+   */
+  fulltextSearch(filters, limit, offset) {
+    let sql = "SELECT * FROM memories WHERE 1=1";
+    const params = [];
+    if (filters.projectId) {
+      sql += " AND projectId = ?";
+      params.push(filters.projectId);
+    }
+    if (filters.type) {
+      sql += " AND type = ?";
+      params.push(filters.type);
+    }
+    if (filters.sessionId) {
+      sql += " AND sessionId = ?";
+      params.push(filters.sessionId);
+    }
+    if (filters.query) {
+      sql += " AND (summary LIKE ? OR fullText LIKE ?)";
+      params.push(`%${filters.query}%`, `%${filters.query}%`);
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * 获取时间线
+   */
+  async getTimeline(options) {
+    let sql = "SELECT * FROM memories WHERE projectId = ?";
+    const params = [options.projectId];
+    if (options.type) {
+      sql += " AND type = ?";
+      params.push(options.type);
+    }
+    if (options.dateRange) {
+      sql += " AND timestamp >= ? AND timestamp <= ?";
+      params.push(options.dateRange[0], options.dateRange[1]);
+    }
+    sql += " ORDER BY timestamp DESC";
+    if (options.limit) {
+      sql += " LIMIT ?";
+      params.push(options.limit);
+    }
+    if (options.offset) {
+      sql += " OFFSET ?";
+      params.push(options.offset);
+    }
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params);
+    const memories = rows.map(this.rowToMemory);
+    const entries = memories.map((memory, index) => ({
+      memory,
+      prevMemoryId: index > 0 ? memories[index - 1].meta.id : void 0,
+      nextMemoryId: index < memories.length - 1 ? memories[index + 1].meta.id : void 0
+    }));
+    return {
+      entries,
+      total: entries.length
+    };
+  }
+  /**
+   * 获取关系链
+   */
+  async getRelations(options) {
+    const memory = await this.getById(options.memoryId);
+    if (!memory) {
+      throw new Error(`Memory ${options.memoryId} not found`);
+    }
+    const depth = options.depth || 1;
+    const relatedNodes = [];
+    if (depth > 0) {
+      const relatedIds = [
+        ...memory.relations.replaces || [],
+        ...memory.relations.relatedTo || [],
+        ...memory.relations.impacts || []
+      ];
+      if (memory.relations.derivedFrom) {
+        relatedIds.push(memory.relations.derivedFrom);
+      }
+      for (const relatedId of relatedIds) {
+        const relatedMemory = await this.getById(relatedId);
+        if (relatedMemory) {
+          let nestedRelated = void 0;
+          if (depth > 1) {
+            const nestedResult = await this.getRelations({
+              memoryId: relatedId,
+              depth: depth - 1
+            });
+            nestedRelated = nestedResult.related;
+          }
+          relatedNodes.push({
+            memory: relatedMemory,
+            related: nestedRelated
+          });
+        }
+      }
+    }
+    return {
+      memory,
+      related: relatedNodes.length > 0 ? relatedNodes : void 0
+    };
+  }
+  /**
+   * 删除记忆
+   */
+  async delete(memoryId) {
+    if (this.cache) {
+      const memory = this.db.prepare("SELECT projectId FROM memories WHERE id = ?").get(memoryId);
+      if (memory) {
+        this.cache.invalidateProject(memory.projectId);
+      }
+    }
+    const stmt = this.db.prepare("DELETE FROM memories WHERE id = ?");
+    const result = stmt.run(memoryId);
+    return { success: result.changes > 0 };
+  }
+  /**
+   * 更新记忆
+   */
+  async update(memoryId, updates) {
+    const fields = [];
+    const params = [];
+    if (updates.content) {
+      if (updates.content.summary) {
+        fields.push("summary = ?");
+        params.push(updates.content.summary);
+      }
+      if (updates.content.data !== void 0) {
+        fields.push("data = ?");
+        params.push(JSON.stringify(updates.content.data));
+      }
+    }
+    if (updates.meta?.tags) {
+      fields.push("tags = ?");
+      params.push(JSON.stringify(updates.meta.tags));
+    }
+    if (updates.relations) {
+      if (updates.relations.replaces) {
+        fields.push("replaces = ?");
+        params.push(JSON.stringify(updates.relations.replaces));
+      }
+      if (updates.relations.relatedTo) {
+        fields.push("relatedTo = ?");
+        params.push(JSON.stringify(updates.relations.relatedTo));
+      }
+      if (updates.relations.impacts) {
+        fields.push("impacts = ?");
+        params.push(JSON.stringify(updates.relations.impacts));
+      }
+      if (updates.relations.derivedFrom) {
+        fields.push("derivedFrom = ?");
+        params.push(updates.relations.derivedFrom);
+      }
+    }
+    if (fields.length === 0) {
+      return { success: false };
+    }
+    fields.push("updatedAt = ?");
+    params.push((/* @__PURE__ */ new Date()).toISOString());
+    params.push(memoryId);
+    const sql = `UPDATE memories SET ${fields.join(", ")} WHERE id = ?`;
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...params);
+    if (this.cache && result.changes > 0) {
+      const memory = this.db.prepare("SELECT projectId FROM memories WHERE id = ?").get(memoryId);
+      if (memory) {
+        this.cache.invalidateProject(memory.projectId);
+      }
+    }
+    return { success: result.changes > 0 };
+  }
+  /**
+   * 根据 ID 获取单个记忆
+   */
+  async getById(id) {
+    const stmt = this.db.prepare("SELECT * FROM memories WHERE id = ?");
+    const row = stmt.get(id);
+    return row ? this.rowToMemory(row) : null;
+  }
+  /**
+   * 将数据库行转换为Memory对象
+   */
+  rowToMemory(row) {
+    return {
+      meta: {
+        id: row.id,
+        projectId: row.projectId,
+        sessionId: row.sessionId,
+        timestamp: row.timestamp,
+        type: row.type,
+        tags: row.tags ? JSON.parse(row.tags) : [],
+        version: row.version
+      },
+      content: {
+        summary: row.summary,
+        data: row.data ? JSON.parse(row.data) : {}
+      },
+      relations: {
+        replaces: row.replaces ? JSON.parse(row.replaces) : void 0,
+        relatedTo: row.relatedTo ? JSON.parse(row.relatedTo) : void 0,
+        impacts: row.impacts ? JSON.parse(row.impacts) : void 0,
+        derivedFrom: row.derivedFrom || void 0
+      },
+      searchable: {
+        keywords: row.keywords ? JSON.parse(row.keywords) : [],
+        fullText: row.fullText
+      },
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  /**
+   * 关闭数据库连接
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// ../storage/dist/postgresql-storage.js
+import { PrismaClient } from "@prisma/client";
+import { nanoid as nanoid2 } from "nanoid";
+var PostgreSQLStorage = class {
+  prisma;
+  cache;
+  constructor(databaseUrl, options) {
+    this.prisma = new PrismaClient({
+      datasources: databaseUrl ? {
+        db: { url: databaseUrl }
+      } : void 0
+    });
+    this.cache = options?.enableCache !== false ? new LRUCache(options?.cacheSize || 100) : null;
+  }
+  /**
+   * 通用存储方法
+   */
+  async store(params) {
+    const id = `mem_${nanoid2()}`;
+    const timestamp = /* @__PURE__ */ new Date();
+    const memoryType = params.type || MemoryType.CODE;
+    await this.prisma.memory.create({
+      data: {
+        id,
+        projectId: params.projectId,
+        sessionId: params.sessionId || null,
+        timestamp,
+        type: memoryType,
+        tags: params.tags || [],
+        summary: params.content,
+        data: params.rawContext,
+        replaces: params.relations?.replaces || [],
+        relatedTo: params.relations?.relatedTo || [],
+        impacts: params.relations?.impacts || [],
+        derivedFrom: params.relations?.derivedFrom || null,
+        context: params.rawContext,
+        keywords: params.tags || [],
+        fullText: params.content
+      }
+    });
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 存储决策记忆
+   */
+  async storeDecision(params) {
+    const id = `mem_${nanoid2()}`;
+    const timestamp = /* @__PURE__ */ new Date();
+    const summary = `[\u51B3\u7B56] ${params.question}`;
+    const fullText = `${params.question} ${params.options.map((o) => o.name).join(" ")} ${params.reason}`;
+    const keywords = [...params.tags || [], ...params.options.map((o) => o.name), params.chosen];
+    await this.prisma.memory.create({
+      data: {
+        id,
+        projectId: params.projectId,
+        sessionId: params.sessionId || null,
+        timestamp,
+        type: MemoryType.DECISION,
+        tags: params.tags || [],
+        summary,
+        data: {},
+        replaces: params.relations?.replaces || [],
+        relatedTo: params.relations?.relatedTo || [],
+        impacts: params.relations?.impacts || [],
+        derivedFrom: params.relations?.derivedFrom || null,
+        context: {
+          question: params.question,
+          analysis: params.analysis,
+          options: params.options,
+          chosen: params.chosen,
+          reason: params.reason
+        },
+        keywords,
+        fullText
+      }
+    });
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 存储解决方案记忆
+   */
+  async storeSolution(params) {
+    const id = `mem_${nanoid2()}`;
+    const timestamp = /* @__PURE__ */ new Date();
+    const summary = `[\u65B9\u6848] ${params.problem}`;
+    const fullText = `${params.problem} ${params.rootCause} ${params.solution} ${params.prevention || ""} ${params.relatedIssues?.join(" ") || ""}`;
+    const keywords = [...params.tags || [], ...params.relatedIssues || []];
+    await this.prisma.memory.create({
+      data: {
+        id,
+        projectId: params.projectId,
+        sessionId: params.sessionId || null,
+        timestamp,
+        type: MemoryType.SOLUTION,
+        tags: params.tags || [],
+        summary,
+        data: params.artifacts || {},
+        replaces: params.relations?.replaces || [],
+        relatedTo: params.relations?.relatedTo || [],
+        impacts: params.relations?.impacts || [],
+        derivedFrom: params.relations?.derivedFrom || null,
+        context: {
+          problem: params.problem,
+          rootCause: params.rootCause,
+          solution: params.solution,
+          prevention: params.prevention,
+          relatedIssues: params.relatedIssues
+        },
+        keywords,
+        fullText
+      }
+    });
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 存储会话记忆
+   */
+  async storeSession(params) {
+    const id = `mem_${nanoid2()}`;
+    const timestamp = /* @__PURE__ */ new Date();
+    const summary = `[\u4F1A\u8BDD] ${params.summary}`;
+    const fullText = `${params.summary} ${params.decisions?.join(" ") || ""} ${params.unfinishedTasks?.join(" ") || ""} ${params.nextSteps?.join(" ") || ""}`;
+    const keywords = [...params.decisions || [], ...params.unfinishedTasks || []];
+    await this.prisma.memory.create({
+      data: {
+        id,
+        projectId: params.projectId,
+        sessionId: params.sessionId || id,
+        timestamp,
+        type: MemoryType.SESSION,
+        tags: [],
+        summary,
+        data: {},
+        replaces: [],
+        relatedTo: [],
+        impacts: [],
+        derivedFrom: null,
+        context: {
+          summary: params.summary,
+          decisions: params.decisions,
+          unfinishedTasks: params.unfinishedTasks,
+          nextSteps: params.nextSteps
+        },
+        keywords,
+        fullText
+      }
+    });
+    if (this.cache) {
+      this.cache.invalidateProject(params.projectId);
+    }
+    return { id, success: true };
+  }
+  /**
+   * 检索记忆
+   */
+  async recall(filters) {
+    const startTime = Date.now();
+    if (this.cache) {
+      const cacheKey = LRUCache.generateKey(filters);
+      const cached = this.cache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    const strategy = filters.strategy || SearchStrategy.AUTO;
+    const limit = filters.limit || 10;
+    const offset = filters.offset || 0;
+    let actualStrategy;
+    let results;
+    let dbStartTime;
+    let dbEndTime;
+    const strategyStartTime = Date.now();
+    if (strategy === SearchStrategy.EXACT || strategy === SearchStrategy.AUTO) {
+      dbStartTime = Date.now();
+      results = await this.exactSearch(filters, limit, offset);
+      dbEndTime = Date.now();
+      actualStrategy = SearchStrategy.EXACT;
+      if (results.length === 0 && strategy === SearchStrategy.AUTO) {
+        dbStartTime = Date.now();
+        results = await this.fulltextSearch(filters, limit, offset);
+        dbEndTime = Date.now();
+        actualStrategy = SearchStrategy.FULLTEXT;
+      }
+    } else if (strategy === SearchStrategy.FULLTEXT) {
+      dbStartTime = Date.now();
+      results = await this.fulltextSearch(filters, limit, offset);
+      dbEndTime = Date.now();
+      actualStrategy = SearchStrategy.FULLTEXT;
+    } else {
+      dbStartTime = Date.now();
+      results = await this.fulltextSearch(filters, limit, offset);
+      dbEndTime = Date.now();
+      actualStrategy = SearchStrategy.FULLTEXT;
+    }
+    const strategyTime = Date.now() - strategyStartTime;
+    const took = Date.now() - startTime;
+    const dbTime = dbEndTime - dbStartTime;
+    const parseTime = took - dbTime - strategyTime;
+    const result = {
+      memories: results,
+      total: results.length,
+      strategy: actualStrategy,
+      took,
+      metrics: {
+        dbTime,
+        parseTime: Math.max(0, parseTime),
+        // 确保非负
+        strategyTime,
+        cacheHit: false
+        // 数据库查询，标记为未命中
+      }
+    };
+    if (this.cache) {
+      const cacheKey = LRUCache.generateKey(filters);
+      this.cache.set(cacheKey, result);
+    }
+    return result;
+  }
+  /**
+   * L1: 精确匹配检索
+   */
+  async exactSearch(filters, limit, offset) {
+    const where = {};
+    if (filters.projectId) {
+      where.projectId = filters.projectId;
+    }
+    if (filters.type) {
+      where.type = filters.type;
+    }
+    if (filters.sessionId) {
+      where.sessionId = filters.sessionId;
+    }
+    if (filters.query) {
+      where.OR = [
+        { summary: { contains: filters.query, mode: "insensitive" } },
+        { fullText: { contains: filters.query, mode: "insensitive" } }
+      ];
+    }
+    const rows = await this.prisma.memory.findMany({
+      where,
+      orderBy: { timestamp: "desc" },
+      take: limit,
+      skip: offset
+    });
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * L2: 全文搜索（PostgreSQL）
+   */
+  async fulltextSearch(filters, limit, offset) {
+    const where = {};
+    if (filters.projectId) {
+      where.projectId = filters.projectId;
+    }
+    if (filters.type) {
+      where.type = filters.type;
+    }
+    if (filters.sessionId) {
+      where.sessionId = filters.sessionId;
+    }
+    if (filters.query) {
+      where.OR = [
+        { summary: { contains: filters.query, mode: "insensitive" } },
+        { fullText: { contains: filters.query, mode: "insensitive" } }
+      ];
+    }
+    const rows = await this.prisma.memory.findMany({
+      where,
+      orderBy: { timestamp: "desc" },
+      take: limit,
+      skip: offset
+    });
+    return rows.map(this.rowToMemory);
+  }
+  /**
+   * 获取时间线
+   */
+  async getTimeline(options) {
+    const where = {
+      projectId: options.projectId
+    };
+    if (options.type) {
+      where.type = options.type;
+    }
+    if (options.dateRange) {
+      where.timestamp = {
+        gte: new Date(options.dateRange[0]),
+        lte: new Date(options.dateRange[1])
+      };
+    }
+    const memories = await this.prisma.memory.findMany({
+      where,
+      orderBy: { timestamp: "desc" },
+      take: options.limit,
+      skip: options.offset
+    });
+    const converted = memories.map(this.rowToMemory);
+    const entries = converted.map((memory, index) => ({
+      memory,
+      prevMemoryId: index > 0 ? converted[index - 1].meta.id : void 0,
+      nextMemoryId: index < converted.length - 1 ? converted[index + 1].meta.id : void 0
+    }));
+    return {
+      entries,
+      total: entries.length
+    };
+  }
+  /**
+   * 获取关系链
+   */
+  async getRelations(options) {
+    const memory = await this.getMemoryById(options.memoryId);
+    if (!memory) {
+      throw new Error(`Memory ${options.memoryId} not found`);
+    }
+    const depth = options.depth || 1;
+    const relatedNodes = [];
+    if (depth > 0) {
+      const relatedIds = [
+        ...memory.relations.replaces || [],
+        ...memory.relations.relatedTo || [],
+        ...memory.relations.impacts || []
+      ];
+      if (memory.relations.derivedFrom) {
+        relatedIds.push(memory.relations.derivedFrom);
+      }
+      for (const relatedId of relatedIds) {
+        const relatedMemory = await this.getMemoryById(relatedId);
+        if (relatedMemory) {
+          let nestedRelated = void 0;
+          if (depth > 1) {
+            const nestedResult = await this.getRelations({
+              memoryId: relatedId,
+              depth: depth - 1
+            });
+            nestedRelated = nestedResult.related;
+          }
+          relatedNodes.push({
+            memory: relatedMemory,
+            related: nestedRelated
+          });
+        }
+      }
+    }
+    return {
+      memory,
+      related: relatedNodes.length > 0 ? relatedNodes : void 0
+    };
+  }
+  /**
+   * 根据 ID 获取单个记忆
+   */
+  async getById(id) {
+    const row = await this.prisma.memory.findUnique({
+      where: { id }
+    });
+    return row ? this.rowToMemory(row) : null;
+  }
+  /**
+   * 删除记忆
+   */
+  async delete(memoryId) {
+    try {
+      if (this.cache) {
+        const memory = await this.prisma.memory.findUnique({
+          where: { id: memoryId },
+          select: { projectId: true }
+        });
+        if (memory) {
+          this.cache.invalidateProject(memory.projectId);
+        }
+      }
+      await this.prisma.memory.delete({
+        where: { id: memoryId }
+      });
+      return { success: true };
+    } catch (error) {
+      return { success: false };
+    }
+  }
+  /**
+   * 更新记忆
+   */
+  async update(memoryId, updates) {
+    try {
+      const data = {};
+      if (updates.content) {
+        if (updates.content.summary) {
+          data.summary = updates.content.summary;
+        }
+        if (updates.content.data !== void 0) {
+          data.data = updates.content.data;
+        }
+      }
+      if (updates.meta?.tags) {
+        data.tags = updates.meta.tags;
+      }
+      if (updates.relations) {
+        if (updates.relations.replaces) {
+          data.replaces = updates.relations.replaces;
+        }
+        if (updates.relations.relatedTo) {
+          data.relatedTo = updates.relations.relatedTo;
+        }
+        if (updates.relations.impacts) {
+          data.impacts = updates.relations.impacts;
+        }
+        if (updates.relations.derivedFrom) {
+          data.derivedFrom = updates.relations.derivedFrom;
+        }
+      }
+      if (Object.keys(data).length === 0) {
+        return { success: false };
+      }
+      await this.prisma.memory.update({
+        where: { id: memoryId },
+        data
+      });
+      if (this.cache) {
+        const memory = await this.prisma.memory.findUnique({
+          where: { id: memoryId },
+          select: { projectId: true }
+        });
+        if (memory) {
+          this.cache.invalidateProject(memory.projectId);
+        }
+      }
+      return { success: true };
+    } catch (error) {
+      return { success: false };
+    }
+  }
+  /**
+   * 根据ID获取记忆
+   */
+  async getMemoryById(id) {
+    const row = await this.prisma.memory.findUnique({
+      where: { id }
+    });
+    return row ? this.rowToMemory(row) : null;
+  }
+  /**
+   * 将Prisma行转换为Memory对象
+   */
+  rowToMemory(row) {
+    return {
+      meta: {
+        id: row.id,
+        projectId: row.projectId,
+        sessionId: row.sessionId,
+        timestamp: row.timestamp.toISOString(),
+        type: row.type,
+        tags: row.tags || [],
+        version: row.version
+      },
+      content: {
+        summary: row.summary,
+        data: row.data || {}
+      },
+      relations: {
+        replaces: row.replaces || void 0,
+        relatedTo: row.relatedTo || void 0,
+        impacts: row.impacts || void 0,
+        derivedFrom: row.derivedFrom || void 0
+      },
+      searchable: {
+        keywords: row.keywords || [],
+        fullText: row.fullText
+      },
+      createdAt: row.createdAt.toISOString(),
+      updatedAt: row.updatedAt.toISOString()
+    };
+  }
+  /**
+   * 关闭数据库连接
+   */
+  async close() {
+    await this.prisma.$disconnect();
+  }
+};
+
+// src/index.ts
+var server = new Server(
+  {
+    name: "elb-memory-pulse",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+      prompts: {}
+    }
+  }
+);
+var storageType = process.env.MEMORY_STORAGE || "sqlite";
+function createStorage() {
+  if (storageType === "postgresql") {
+    const databaseUrl = process.env.DATABASE_URL;
+    if (!databaseUrl) {
+      console.error("\u9519\u8BEF: \u4F7F\u7528 PostgreSQL \u5B58\u50A8\u9700\u8981\u8BBE\u7F6E DATABASE_URL \u73AF\u5883\u53D8\u91CF");
+      process.exit(1);
+    }
+    console.error(`Memory Pulse \u4F7F\u7528 PostgreSQL \u5B58\u50A8: ${databaseUrl.replace(/:[^:@]+@/, ":****@")}`);
+    return new PostgreSQLStorage(databaseUrl);
+  }
+  const dbPath = process.env.MEMORY_DB_PATH || "./memory.db";
+  console.error(`Memory Pulse \u4F7F\u7528 SQLite \u5B58\u50A8: ${dbPath}`);
+  return new SQLiteStorage(dbPath);
+}
+var storage = createStorage();
+var tools = [
+  {
+    name: "mpulse_store",
+    description: "\u667A\u80FD\u5B58\u50A8\u8BB0\u5FC6\uFF0CAI \u81EA\u52A8\u5206\u7C7B\u548C\u7ED3\u6784\u5316",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "AI \u603B\u7ED3\u7684\u5185\u5BB9"
+        },
+        rawContext: {
+          type: "object",
+          description: "\u5B8C\u6574\u539F\u59CB\u6570\u636E\uFF08\u4E0D\u538B\u7F29\uFF09"
+        },
+        projectId: {
+          type: "string",
+          description: "\u9879\u76EE ID"
+        },
+        type: {
+          type: "string",
+          enum: ["decision", "solution", "config", "code", "error", "session"],
+          description: "\u8BB0\u5FC6\u7C7B\u578B\uFF08\u53EF\u9009\uFF0C\u4E0D\u586B\u5219\u9ED8\u8BA4\u4E3A code\uFF09"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u6807\u7B7E"
+        },
+        sessionId: {
+          type: "string",
+          description: "\u4F1A\u8BDD ID\uFF08\u53EF\u9009\uFF09"
+        }
+      },
+      required: ["content", "rawContext", "projectId"]
+    }
+  },
+  {
+    name: "mpulse_store_decision",
+    description: "\u5B58\u50A8\u67B6\u6784\u51B3\u7B56\uFF08\u5F3A\u5236\u5B57\u6BB5\uFF0C\u9632\u6B62 AI \u5077\u61D2\uFF09",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: {
+          type: "string",
+          description: "\u51B3\u7B56\u95EE\u9898"
+        },
+        options: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              pros: { type: "array", items: { type: "string" } },
+              cons: { type: "array", items: { type: "string" } }
+            },
+            required: ["name", "pros", "cons"]
+          },
+          description: "\u8003\u8651\u7684\u9009\u9879"
+        },
+        chosen: {
+          type: "string",
+          description: "\u9009\u62E9\u7684\u65B9\u6848"
+        },
+        reason: {
+          type: "string",
+          description: "\u9009\u62E9\u7406\u7531"
+        },
+        projectId: {
+          type: "string",
+          description: "\u9879\u76EE ID"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u6807\u7B7E"
+        },
+        sessionId: {
+          type: "string",
+          description: "\u4F1A\u8BDD ID\uFF08\u53EF\u9009\uFF09"
+        }
+      },
+      required: ["question", "options", "chosen", "reason", "projectId"]
+    }
+  },
+  {
+    name: "mpulse_store_solution",
+    description: "\u5B58\u50A8\u95EE\u9898\u89E3\u51B3\u65B9\u6848",
+    inputSchema: {
+      type: "object",
+      properties: {
+        problem: {
+          type: "string",
+          description: "\u95EE\u9898\u63CF\u8FF0"
+        },
+        rootCause: {
+          type: "string",
+          description: "\u6839\u56E0\u5206\u6790"
+        },
+        solution: {
+          type: "string",
+          description: "\u89E3\u51B3\u65B9\u6848"
+        },
+        prevention: {
+          type: "string",
+          description: "\u5982\u4F55\u9884\u9632"
+        },
+        relatedIssues: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u5173\u8054\u95EE\u9898"
+        },
+        projectId: {
+          type: "string",
+          description: "\u9879\u76EE ID"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u6807\u7B7E"
+        },
+        sessionId: {
+          type: "string",
+          description: "\u4F1A\u8BDD ID\uFF08\u53EF\u9009\uFF09"
+        },
+        artifacts: {
+          type: "object",
+          description: "\u76F8\u5173\u6587\u4EF6\uFF08\u4EE3\u7801\u7247\u6BB5\u7B49\uFF09"
+        }
+      },
+      required: ["problem", "rootCause", "solution", "projectId"]
+    }
+  },
+  {
+    name: "mpulse_store_session",
+    description: "\u5B58\u50A8\u4F1A\u8BDD\u603B\u7ED3\uFF08\u4F1A\u8BDD\u7ED3\u675F\u65F6\u8C03\u7528\uFF09",
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "\u672C\u6B21\u4F1A\u8BDD\u603B\u7ED3"
+        },
+        decisions: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u672C\u6B21\u505A\u51FA\u7684\u51B3\u7B56"
+        },
+        unfinishedTasks: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u672A\u5B8C\u6210\u7684\u4EFB\u52A1"
+        },
+        nextSteps: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u4E0B\u6B21\u4ECE\u54EA\u7EE7\u7EED"
+        },
+        projectId: {
+          type: "string",
+          description: "\u9879\u76EE ID"
+        },
+        sessionId: {
+          type: "string",
+          description: "\u4F1A\u8BDD ID"
+        }
+      },
+      required: ["summary", "projectId", "sessionId"]
+    }
+  },
+  {
+    name: "mpulse_recall",
+    description: "\u68C0\u7D22\u8BB0\u5FC6\uFF08\u591A\u7B56\u7565\uFF1A\u7CBE\u786E\u3001\u5168\u6587\u3001\u8BED\u4E49\uFF09",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "\u67E5\u8BE2\u5185\u5BB9"
+        },
+        projectId: {
+          type: "string",
+          description: "\u9879\u76EE ID"
+        },
+        type: {
+          type: "string",
+          enum: ["decision", "solution", "config", "code", "error", "session"],
+          description: "\u8BB0\u5FC6\u7C7B\u578B"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u6807\u7B7E\u8FC7\u6EE4"
+        },
+        strategy: {
+          type: "string",
+          enum: ["exact", "fulltext", "semantic"],
+          description: "\u68C0\u7D22\u7B56\u7565"
+        },
+        limit: {
+          type: "number",
+          description: "\u8FD4\u56DE\u6570\u91CF"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "mpulse_timeline",
+    description: "\u67E5\u770B\u9879\u76EE\u7684\u65F6\u95F4\u7EBF\u89C6\u56FE",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "\u9879\u76EE ID"
+        },
+        dateRange: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u65E5\u671F\u8303\u56F4 [start, end]"
+        },
+        type: {
+          type: "string",
+          enum: ["decision", "solution", "config", "code", "error", "session"],
+          description: "\u8BB0\u5FC6\u7C7B\u578B"
+        },
+        limit: {
+          type: "number",
+          description: "\u8FD4\u56DE\u6570\u91CF"
+        },
+        offset: {
+          type: "number",
+          description: "\u5206\u9875\u504F\u79FB"
+        }
+      },
+      required: ["projectId"]
+    }
+  },
+  {
+    name: "mpulse_relations",
+    description: "\u67E5\u8BE2\u8BB0\u5FC6\u7684\u5173\u7CFB\u94FE",
+    inputSchema: {
+      type: "object",
+      properties: {
+        memoryId: {
+          type: "string",
+          description: "\u8BB0\u5FC6 ID"
+        },
+        depth: {
+          type: "number",
+          description: "\u9012\u5F52\u6DF1\u5EA6"
+        }
+      },
+      required: ["memoryId"]
+    }
+  }
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools
+}));
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: [
+    {
+      uri: "memory://projects",
+      name: "\u6240\u6709\u9879\u76EE\u8BB0\u5FC6",
+      description: "\u5217\u51FA\u6240\u6709\u9879\u76EE ID",
+      mimeType: "application/json"
+    }
+  ]
+}));
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const uri = request.params.uri;
+  try {
+    if (uri === "memory://projects") {
+      const allMemories = await storage.recall({ query: "", limit: 1e4 });
+      const projects = new Set(allMemories.memories.map((m) => m.meta.projectId));
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                projects: Array.from(projects),
+                total: projects.size
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const projectMatch = uri.match(/^memory:\/\/project\/(.+)$/);
+    if (projectMatch) {
+      const projectId = decodeURIComponent(projectMatch[1]);
+      const result = await storage.recall({ query: "", projectId, limit: 1e3 });
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                projectId,
+                memories: result.memories,
+                total: result.total
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const memoryMatch = uri.match(/^memory:\/\/memory\/(.+)$/);
+    if (memoryMatch) {
+      const memoryId = decodeURIComponent(memoryMatch[1]);
+      const result = await storage.getRelations({ memoryId, depth: 0 });
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(result.memory, null, 2)
+          }
+        ]
+      };
+    }
+    const sessionMatch = uri.match(/^memory:\/\/session\/(.+)$/);
+    if (sessionMatch) {
+      const sessionId = decodeURIComponent(sessionMatch[1]);
+      const result = await storage.recall({ query: "", sessionId, limit: 1e3 });
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                sessionId,
+                memories: result.memories,
+                total: result.total
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    throw new Error(`Unknown resource URI: ${uri}`);
+  } catch (error) {
+    throw new Error(
+      `Failed to read resource ${uri}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+});
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+  prompts: [
+    {
+      name: "analyze-decision",
+      description: "\u5206\u6790\u9879\u76EE\u4E2D\u7684\u67B6\u6784\u51B3\u7B56",
+      arguments: [
+        {
+          name: "projectId",
+          description: "\u9879\u76EE ID",
+          required: true
+        }
+      ]
+    },
+    {
+      name: "summarize-session",
+      description: "\u603B\u7ED3\u4F1A\u8BDD\u4E2D\u7684\u5DE5\u4F5C\u5185\u5BB9",
+      arguments: [
+        {
+          name: "sessionId",
+          description: "\u4F1A\u8BDD ID",
+          required: true
+        }
+      ]
+    },
+    {
+      name: "find-related",
+      description: "\u67E5\u627E\u4E0E\u7279\u5B9A\u4E3B\u9898\u76F8\u5173\u7684\u8BB0\u5FC6",
+      arguments: [
+        {
+          name: "topic",
+          description: "\u4E3B\u9898\u5173\u952E\u8BCD",
+          required: true
+        },
+        {
+          name: "projectId",
+          description: "\u9879\u76EE ID\uFF08\u53EF\u9009\uFF09",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "review-project",
+      description: "\u56DE\u987E\u9879\u76EE\u7684\u53D1\u5C55\u5386\u7A0B",
+      arguments: [
+        {
+          name: "projectId",
+          description: "\u9879\u76EE ID",
+          required: true
+        },
+        {
+          name: "type",
+          description: "\u8BB0\u5FC6\u7C7B\u578B\uFF08\u53EF\u9009\uFF1Adecision, solution, session\uFF09",
+          required: false
+        }
+      ]
+    }
+  ]
+}));
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  if (!args) {
+    throw new Error("Missing required arguments");
+  }
+  try {
+    switch (name) {
+      case "analyze-decision": {
+        const projectId = args.projectId;
+        const decisions = await storage.recall({
+          query: "",
+          projectId,
+          type: "decision",
+          limit: 100
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `\u8BF7\u5206\u6790\u9879\u76EE "${projectId}" \u4E2D\u7684\u67B6\u6784\u51B3\u7B56\u3002
+
+\u627E\u5230\u4E86 ${decisions.total} \u4E2A\u51B3\u7B56\u8BB0\u5F55\uFF1A
+
+${decisions.memories.map((m, idx) => {
+                  const data = m.content.data;
+                  return `
+${idx + 1}. ${data.question || m.content.summary}
+   \u9009\u62E9\uFF1A${data.chosen || "\u672A\u77E5"}
+   \u7406\u7531\uFF1A${data.reason || "\u672A\u63D0\u4F9B"}
+   \u65F6\u95F4\uFF1A${m.meta.timestamp}
+`;
+                }).join("\n")}
+
+\u8BF7\u603B\u7ED3\uFF1A
+1. \u4E3B\u8981\u7684\u6280\u672F\u9009\u578B\u6709\u54EA\u4E9B\uFF1F
+2. \u51B3\u7B56\u7684\u6F14\u8FDB\u8D8B\u52BF\u5982\u4F55\uFF1F
+3. \u662F\u5426\u5B58\u5728\u53EF\u80FD\u7684\u6280\u672F\u503A\u52A1\uFF1F
+4. \u6709\u54EA\u4E9B\u503C\u5F97\u8BB0\u5F55\u7684\u7ECF\u9A8C\u6559\u8BAD\uFF1F`
+              }
+            }
+          ]
+        };
+      }
+      case "summarize-session": {
+        const sessionId = args.sessionId;
+        const memories = await storage.recall({
+          query: "",
+          sessionId,
+          limit: 100
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `\u8BF7\u603B\u7ED3\u4F1A\u8BDD "${sessionId}" \u7684\u5DE5\u4F5C\u5185\u5BB9\u3002
+
+\u4F1A\u8BDD\u5305\u542B ${memories.total} \u6761\u8BB0\u5FC6\uFF1A
+
+${memories.memories.map((m, idx) => `${idx + 1}. [${m.meta.type}] ${m.content.summary}`).join("\n")}
+
+\u8BF7\u751F\u6210\u4E00\u4E2A\u7B80\u6D01\u7684\u5DE5\u4F5C\u603B\u7ED3\uFF0C\u5305\u62EC\uFF1A
+1. \u4E3B\u8981\u5B8C\u6210\u7684\u4EFB\u52A1
+2. \u505A\u51FA\u7684\u91CD\u8981\u51B3\u7B56
+3. \u9047\u5230\u7684\u95EE\u9898\u548C\u89E3\u51B3\u65B9\u6848
+4. \u672A\u5B8C\u6210\u7684\u4EFB\u52A1\uFF08\u5982\u6709\uFF09
+5. \u4E0B\u4E00\u6B65\u8BA1\u5212\u5EFA\u8BAE`
+              }
+            }
+          ]
+        };
+      }
+      case "find-related": {
+        const topic = args.topic;
+        const projectId = args.projectId;
+        const related = await storage.recall({
+          query: topic,
+          projectId,
+          limit: 20
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `\u67E5\u627E\u4E0E "${topic}" \u76F8\u5173\u7684\u8BB0\u5FC6${projectId ? `\uFF08\u9879\u76EE\uFF1A${projectId}\uFF09` : ""}\u3002
+
+\u627E\u5230 ${related.total} \u6761\u76F8\u5173\u8BB0\u5FC6\uFF1A
+
+${related.memories.map(
+                  (m, idx) => `
+${idx + 1}. ${m.content.summary}
+   \u7C7B\u578B\uFF1A${m.meta.type}
+   \u9879\u76EE\uFF1A${m.meta.projectId}
+   \u65F6\u95F4\uFF1A${m.meta.timestamp}
+`
+                ).join("\n")}
+
+\u8BF7\u5206\u6790\u8FD9\u4E9B\u8BB0\u5FC6\u4E4B\u95F4\u7684\u5173\u8054\u6027\uFF0C\u5E76\u63D0\u4F9B\uFF1A
+1. \u8FD9\u4E9B\u8BB0\u5FC6\u56F4\u7ED5\u4EC0\u4E48\u4E3B\u9898\uFF1F
+2. \u662F\u5426\u5B58\u5728\u6F14\u8FDB\u5173\u7CFB\uFF1F
+3. \u6709\u54EA\u4E9B\u6709\u4EF7\u503C\u7684\u7ECF\u9A8C\u53EF\u4EE5\u590D\u7528\uFF1F`
+              }
+            }
+          ]
+        };
+      }
+      case "review-project": {
+        const projectId = args.projectId;
+        const type = args.type;
+        const timeline = await storage.getTimeline({
+          projectId,
+          type,
+          limit: 100
+        });
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `\u56DE\u987E\u9879\u76EE "${projectId}" \u7684\u53D1\u5C55\u5386\u7A0B${type ? `\uFF08\u7C7B\u578B\uFF1A${type}\uFF09` : ""}\u3002
+
+\u65F6\u95F4\u7EBF\u5305\u542B ${timeline.total} \u6761\u8BB0\u5F55\uFF1A
+
+${timeline.entries.map((entry, idx) => {
+                  const m = entry.memory;
+                  return `${idx + 1}. [${new Date(m.meta.timestamp).toLocaleDateString()}] ${m.content.summary}`;
+                }).join("\n")}
+
+\u8BF7\u751F\u6210\u9879\u76EE\u56DE\u987E\u62A5\u544A\uFF0C\u5305\u62EC\uFF1A
+1. \u9879\u76EE\u8D77\u6E90\u548C\u521D\u59CB\u76EE\u6807
+2. \u5173\u952E\u91CC\u7A0B\u7891\u548C\u51B3\u7B56\u70B9
+3. \u9047\u5230\u7684\u6311\u6218\u548C\u89E3\u51B3\u65B9\u6848
+4. \u5F53\u524D\u72B6\u6001\u548C\u672A\u6765\u65B9\u5411
+5. \u7ECF\u9A8C\u603B\u7ED3\u548C\u6539\u8FDB\u5EFA\u8BAE`
+              }
+            }
+          ]
+        };
+      }
+      default:
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to generate prompt ${name}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  if (!args) {
+    throw new Error("Missing required arguments");
+  }
+  try {
+    switch (name) {
+      case "mpulse_store": {
+        const result = await storage.store({
+          content: args.content,
+          rawContext: args.rawContext,
+          projectId: args.projectId,
+          type: args.type,
+          tags: args.tags,
+          sessionId: args.sessionId
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_store_decision": {
+        const decisionParams = {
+          question: args.question,
+          options: args.options,
+          chosen: args.chosen,
+          reason: args.reason,
+          projectId: args.projectId,
+          tags: args.tags,
+          sessionId: args.sessionId
+        };
+        const result = await storage.storeDecision(decisionParams);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_store_solution": {
+        const solutionParams = {
+          problem: args.problem,
+          rootCause: args.rootCause,
+          solution: args.solution,
+          prevention: args.prevention,
+          relatedIssues: args.relatedIssues,
+          projectId: args.projectId,
+          tags: args.tags,
+          sessionId: args.sessionId,
+          artifacts: args.artifacts
+        };
+        const result = await storage.storeSolution(solutionParams);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_store_session": {
+        const sessionParams = {
+          summary: args.summary,
+          decisions: args.decisions,
+          unfinishedTasks: args.unfinishedTasks,
+          nextSteps: args.nextSteps,
+          projectId: args.projectId,
+          sessionId: args.sessionId
+        };
+        const result = await storage.storeSession(sessionParams);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_recall": {
+        const filters = {
+          query: args.query,
+          projectId: args.projectId,
+          type: args.type,
+          tags: args.tags,
+          strategy: args.strategy,
+          limit: args.limit
+        };
+        const result = await storage.recall(filters);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_timeline": {
+        const options = {
+          projectId: args.projectId,
+          dateRange: args.dateRange,
+          type: args.type,
+          limit: args.limit,
+          offset: args.offset
+        };
+        const result = await storage.getTimeline(options);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_relations": {
+        const options = {
+          memoryId: args.memoryId,
+          depth: args.depth
+        };
+        const result = await storage.getRelations(options);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Memory Pulse (\u8BB0\u5FC6\u8109\u640F) MCP Server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map