memory-pulse-mcp-server 0.1.16 → 0.1.17

package/dist/index.js

@@ -270,6 +270,93 @@ function deserializeVector(s) {
   return Array.from(buffer);
 }
 
+// ../core/dist/encoding.js
+var TYPE_IMPORTANCE = {
+  decision: 0.9,
+  solution: 0.8,
+  error: 0.7,
+  config: 0.6,
+  code: 0.5,
+  session: 0.4
+};
+function getTypeImportance(type) {
+  return TYPE_IMPORTANCE[type] ?? 0.5;
+}
+function flattenObject(obj, prefix, depth = 0) {
+  if (depth > 3)
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value === null || value === void 0)
+      continue;
+    if (typeof value === "string") {
+      if (value.length > 500)
+        continue;
+      parts.push(key, value);
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      parts.push(key, String(value));
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string" && item.length <= 200) {
+          parts.push(item);
+        } else if (typeof item === "number") {
+          parts.push(String(item));
+        } else if (item && typeof item === "object" && !Array.isArray(item)) {
+          parts.push(flattenObject(item, fullKey, depth + 1));
+        }
+      }
+    } else if (typeof value === "object") {
+      parts.push(flattenObject(value, fullKey, depth + 1));
+    }
+  }
+  return parts.filter(Boolean).join(" ");
+}
+function extractTextFromContext(rawContext, maxDepth = 3) {
+  const texts = [];
+  function walk(obj, depth) {
+    if (depth > maxDepth)
+      return;
+    for (const value of Object.values(obj)) {
+      if (value === null || value === void 0)
+        continue;
+      if (typeof value === "string") {
+        if (value.length > 0 && value.length <= 1e3) {
+          texts.push(value);
+        }
+      } else if (typeof value === "number") {
+        texts.push(String(value));
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "string" && item.length <= 500) {
+            texts.push(item);
+          } else if (item && typeof item === "object" && !Array.isArray(item)) {
+            walk(item, depth + 1);
+          }
+        }
+      } else if (typeof value === "object") {
+        walk(value, depth + 1);
+      }
+    }
+  }
+  walk(rawContext, 0);
+  return texts.join(" ");
+}
+function encodeMemoryText(params) {
+  const parts = [params.summary];
+  const dataText = flattenObject(params.data);
+  if (dataText) {
+    parts.push(dataText);
+  }
+  if (params.rawContext) {
+    const contextText = extractTextFromContext(params.rawContext);
+    if (contextText) {
+      parts.push(contextText);
+    }
+  }
+  return parts.filter(Boolean).join(" ");
+}
+
 // ../core/dist/keywords.js
 var CHINESE_STOP_WORDS = /* @__PURE__ */ new Set([
   "\u7684",
@@ -544,7 +631,40 @@ function getTopKeywords(words, limit = 30) {
   }
   return Array.from(frequency.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([word]) => word);
 }
-function extractKeywords(content, rawContext) {
+function extractFromData(data, maxDepth = 2) {
+  const keywords = [];
+  function walk(obj, depth) {
+    if (depth > maxDepth)
+      return;
+    for (const [key, value] of Object.entries(obj)) {
+      if (["id", "createdAt", "updatedAt", "timestamp"].includes(key))
+        continue;
+      if (key.length >= 2)
+        keywords.push(key);
+      if (typeof value === "string" && value.length >= 1 && value.length <= 500)
+        keywords.push(value);
+      if (typeof value === "number" && isFinite(value))
+        keywords.push(String(value));
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "string" && item.length >= 1 && item.length <= 200)
+            keywords.push(item);
+          if (typeof item === "number" && isFinite(item))
+            keywords.push(String(item));
+          if (item && typeof item === "object" && !Array.isArray(item)) {
+            walk(item, depth + 1);
+          }
+        }
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        walk(value, depth + 1);
+      }
+    }
+  }
+  walk(data, 0);
+  return keywords;
+}
+function extractKeywords(content, rawContext, data) {
   const allKeywords = [];
   const contentText = content || "";
   allKeywords.push(...basicTokenize(contentText));
@@ -554,6 +674,15 @@ function extractKeywords(content, rawContext) {
     allKeywords.push(...basicTokenize(contextText));
     allKeywords.push(...extractSpecialPatterns(contextText));
   }
+  if (data && Object.keys(data).length > 0) {
+    const dataKeywords = extractFromData(data);
+    for (const kw of dataKeywords) {
+      allKeywords.push(...basicTokenize(kw));
+      allKeywords.push(...extractSpecialPatterns(kw));
+      if (kw.length >= 2)
+        allKeywords.push(kw);
+    }
+  }
   const topKeywords = getTopKeywords(allKeywords, 30);
   const specialKeywords = extractSpecialPatterns(contentText + " " + extractTextFromObject(rawContext));
   const uniqueSpecial = [...new Set(specialKeywords)].slice(0, 10);
@@ -2100,6 +2229,13 @@ var PostgreSQLStorage = class {
     const id = `mem_${nanoid2()}`;
     const timestamp = /* @__PURE__ */ new Date();
     const memoryType = params.type || MemoryType.CODE;
+    const keywords = extractKeywords(params.content, params.rawContext, params.data);
+    const fullText = encodeMemoryText({
+      summary: params.content,
+      data: params.data,
+      rawContext: params.rawContext
+    });
+    const importance = getTypeImportance(memoryType);
     await this.prisma.memory.create({
       data: {
         id,
@@ -2109,17 +2245,28 @@ var PostgreSQLStorage = class {
         type: memoryType,
         tags: params.tags || [],
         summary: params.content,
-        // data 存储关键结构化数据（精简版），context 存储完整原始数据（完整版）
         data: params.data,
         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
+        keywords: [.../* @__PURE__ */ new Set([...params.tags || [], ...keywords])],
+        fullText,
+        importance
       }
     });
+    if (params.relations) {
+      const referencedIds = [
+        ...params.relations.relatedTo || [],
+        ...params.relations.replaces || [],
+        ...params.relations.impacts || [],
+        ...params.relations.derivedFrom ? [params.relations.derivedFrom] : []
+      ];
+      if (referencedIds.length > 0) {
+        await this.onMemoryReferenced(referencedIds);
+      }
+    }
     if (params.relations) {
       const relationRecords = [];
       if (params.relations.relatedTo) {
@@ -2150,7 +2297,7 @@ var PostgreSQLStorage = class {
     if (this.cache) {
       this.cache.invalidateProject(params.projectId);
     }
-    await this.autoRelate(id, params.projectId, params.tags || []);
+    await this.autoRelate(id, params.projectId, keywords);
     return { id, success: true };
   }
   /**
@@ -2160,8 +2307,17 @@ var PostgreSQLStorage = class {
     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];
+    const decisionData = { chosen: params.chosen, reason: params.reason };
+    const rawContext = {
+      question: params.question,
+      analysis: params.analysis,
+      options: params.options,
+      chosen: params.chosen,
+      reason: params.reason
+    };
+    const fullText = encodeMemoryText({ summary, data: decisionData, rawContext });
+    const keywords = extractKeywords(summary, rawContext, decisionData);
+    const importance = getTypeImportance(MemoryType.DECISION);
     await this.prisma.memory.create({
       data: {
         id,
@@ -2171,20 +2327,15 @@ var PostgreSQLStorage = class {
         type: MemoryType.DECISION,
         tags: params.tags || [],
         summary,
-        data: {},
+        data: decisionData,
         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
+        context: rawContext,
+        keywords: [.../* @__PURE__ */ new Set([...params.tags || [], ...keywords])],
+        fullText,
+        importance
       }
     });
     if (params.relations) {
@@ -2227,8 +2378,17 @@ var PostgreSQLStorage = class {
     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 || []];
+    const solutionData = { problem: params.problem, solution: params.solution, ...params.artifacts || {} };
+    const rawContext = {
+      problem: params.problem,
+      rootCause: params.rootCause,
+      solution: params.solution,
+      prevention: params.prevention,
+      relatedIssues: params.relatedIssues
+    };
+    const fullText = encodeMemoryText({ summary, data: solutionData, rawContext });
+    const keywords = extractKeywords(summary, rawContext, solutionData);
+    const importance = getTypeImportance(MemoryType.SOLUTION);
     await this.prisma.memory.create({
       data: {
         id,
@@ -2238,20 +2398,15 @@ var PostgreSQLStorage = class {
         type: MemoryType.SOLUTION,
         tags: params.tags || [],
         summary,
-        data: params.artifacts || {},
+        data: solutionData,
         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
+        context: rawContext,
+        keywords: [.../* @__PURE__ */ new Set([...params.tags || [], ...keywords])],
+        fullText,
+        importance
       }
     });
     if (params.relations) {
@@ -2294,8 +2449,20 @@ var PostgreSQLStorage = class {
     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 || []];
+    const sessionData = {
+      decisions: params.decisions || [],
+      nextSteps: params.nextSteps || [],
+      unfinishedTasks: params.unfinishedTasks || []
+    };
+    const rawContext = {
+      summary: params.summary,
+      decisions: params.decisions,
+      unfinishedTasks: params.unfinishedTasks,
+      nextSteps: params.nextSteps
+    };
+    const fullText = encodeMemoryText({ summary, data: sessionData, rawContext });
+    const keywords = extractKeywords(summary, rawContext, sessionData);
+    const importance = getTypeImportance(MemoryType.SESSION);
     await this.prisma.memory.create({
       data: {
         id,
@@ -2305,19 +2472,15 @@ var PostgreSQLStorage = class {
         type: MemoryType.SESSION,
         tags: [],
         summary,
-        data: {},
+        data: sessionData,
         replaces: params.relations?.replaces || [],
         relatedTo: params.relations?.relatedTo || [],
         impacts: params.relations?.impacts || [],
         derivedFrom: params.relations?.derivedFrom || null,
-        context: {
-          summary: params.summary,
-          decisions: params.decisions,
-          unfinishedTasks: params.unfinishedTasks,
-          nextSteps: params.nextSteps
-        },
-        keywords,
-        fullText
+        context: rawContext,
+        keywords: [...new Set(keywords)],
+        fullText,
+        importance
       }
     });
     if (params.relations) {
@@ -2354,12 +2517,12 @@ var PostgreSQLStorage = class {
     return { id, success: true };
   }
   /**
-   * 检索记忆（新算法：多维度搜索 + 智能降级 + 关系链融合）
+   * 检索记忆（仿人脑：线索触发 + 扩散激活 + 相关性排序）
    *
-   * 核心功能：
-   * 1. 多维度搜索：projectId/summary/fullText/tags/keywords
-   * 2. 智能降级：无结果时自动放宽条件
-   * 3. 关系链融合：自动扩展关联记忆
+   * 1. tsvector 全文搜索（AND 优先，降级 OR）
+   * 2. 综合评分 = 文本相关性 * 重要性 * 时间衰减 * 频率增强
+   * 3. 扩散激活：关联记忆参与混合排序
+   * 4. 用进废退：命中时更新 access_count
    */
   async recall(filters) {
     const startTime = Date.now();
@@ -2374,26 +2537,38 @@ var PostgreSQLStorage = class {
     const offset = filters.offset || 0;
     const expandRelations = filters.expandRelations !== false;
     const relationDepth = filters.relationDepth || 1;
-    let dbStartTime = Date.now();
-    const searchResult = await this.multiDimensionSearch(filters, limit, offset);
-    let results = searchResult.memories;
-    let total = searchResult.total;
-    if (results.length === 0 && filters.query) {
-      if (filters.projectId || filters.projectIds && filters.projectIds.length > 0) {
-        const degradedResult = await this.multiDimensionSearch({ ...filters, query: void 0 }, limit, offset);
-        results = degradedResult.memories;
-        total = degradedResult.total;
+    const dbStartTime = Date.now();
+    let results = [];
+    let total = 0;
+    if (filters.query && filters.query.trim()) {
+      const tsvResult = await this.tsvectorSearch(filters, limit, offset, "and");
+      if (tsvResult.memories.length > 0) {
+        results = tsvResult.memories;
+        total = tsvResult.total;
+      } else {
+        const orResult = await this.tsvectorSearch(filters, limit, offset, "or");
+        results = orResult.memories;
+        total = orResult.total;
       }
       if (results.length === 0) {
-        const globalResult = await this.multiDimensionSearch({ ...filters, projectId: void 0, projectIds: void 0 }, limit, offset);
-        results = globalResult.memories;
-        total = globalResult.total;
+        const fallback = await this.multiDimensionSearch(filters, limit, offset);
+        results = fallback.memories;
+        total = fallback.total;
       }
+    } else {
+      const searchResult = await this.multiDimensionSearch(filters, limit, offset);
+      results = searchResult.memories;
+      total = searchResult.total;
     }
     let relatedMemories;
     if (expandRelations && results.length > 0) {
       relatedMemories = await this.expandRelatedMemories(results, relationDepth);
     }
+    if (results.length > 0) {
+      const hitIds = results.map((m) => m.meta.id);
+      this.onMemoryAccessed(hitIds).catch(() => {
+      });
+    }
     const dbEndTime = Date.now();
     const took = Date.now() - startTime;
     const dbTime = dbEndTime - dbStartTime;
@@ -2415,6 +2590,122 @@ var PostgreSQLStorage = class {
     }
     return result;
   }
+  /**
+   * tsvector 全文搜索（核心检索引擎）
+   * 使用 PostgreSQL ts_rank_cd + 重要性 + 时间衰减 + 频率增强 综合评分
+   */
+  async tsvectorSearch(filters, limit, offset, mode) {
+    const query = filters.query?.trim();
+    if (!query)
+      return { memories: [], total: 0 };
+    const words = query.split(/\s+/).filter((w) => w.length > 0);
+    const operator = mode === "and" ? " & " : " | ";
+    const tsTerms = [];
+    for (const word of words) {
+      if (/[\u4e00-\u9fa5]/.test(word)) {
+        for (const char of word) {
+          if (/[\u4e00-\u9fa5]/.test(char))
+            tsTerms.push(char);
+        }
+      } else {
+        tsTerms.push(word.toLowerCase());
+      }
+    }
+    if (tsTerms.length === 0)
+      return { memories: [], total: 0 };
+    const tsqueryStr = tsTerms.join(operator);
+    let projectFilter = "";
+    const params = [tsqueryStr, limit, offset];
+    let paramIdx = 4;
+    if (filters.projectIds && filters.projectIds.length > 0) {
+      projectFilter = `AND "projectId" = ANY($${paramIdx})`;
+      params.push(filters.projectIds);
+      paramIdx++;
+    } else if (filters.projectId) {
+      projectFilter = `AND "projectId" = $${paramIdx}`;
+      params.push(filters.projectId);
+      paramIdx++;
+    }
+    let typeFilter = "";
+    if (filters.type) {
+      typeFilter = `AND type = $${paramIdx}`;
+      params.push(filters.type);
+      paramIdx++;
+    }
+    const sql = `
+      SELECT *,
+        ts_rank_cd(tsv, to_tsquery('simple', $1)) AS text_score,
+        (
+          ts_rank_cd(tsv, to_tsquery('simple', $1))
+          * COALESCE(importance, 0.5)
+          * EXP(-0.693 * EXTRACT(EPOCH FROM (NOW() - timestamp)) / (30.0 * 86400.0))
+          * (1.0 + LN(1.0 + COALESCE(access_count, 0) + COALESCE(reference_count, 0)) * 0.2)
+        ) AS brain_score
+      FROM memories
+      WHERE tsv @@ to_tsquery('simple', $1)
+        ${projectFilter}
+        ${typeFilter}
+      ORDER BY brain_score DESC
+      LIMIT $2 OFFSET $3
+    `;
+    const countSql = `
+      SELECT COUNT(*) as total
+      FROM memories
+      WHERE tsv @@ to_tsquery('simple', $1)
+        ${projectFilter}
+        ${typeFilter}
+    `;
+    try {
+      const [rows, countResult] = await Promise.all([
+        this.prisma.$queryRawUnsafe(sql, ...params),
+        this.prisma.$queryRawUnsafe(countSql, ...params.slice(0, 1).concat(params.slice(3)))
+      ]);
+      const memories = rows.map((row) => this.rawRowToMemory(row));
+      const total = Number(countResult[0]?.total || 0);
+      return { memories, total };
+    } catch (error) {
+      console.warn("tsvector search failed, falling back:", error.message);
+      return { memories: [], total: 0 };
+    }
+  }
+  /**
+   * 将原始 SQL 查询行转换为 Memory 对象
+   * 与 rowToMemory 类似，但处理的是原始 SQL 返回的 snake_case 字段
+   */
+  rawRowToMemory(row) {
+    return {
+      meta: {
+        id: row.id,
+        projectId: row.projectId,
+        sessionId: row.sessionId,
+        timestamp: row.timestamp instanceof Date ? row.timestamp.toISOString() : row.timestamp,
+        type: row.type,
+        tags: row.tags || [],
+        version: row.version,
+        importance: row.importance ?? 0.5,
+        accessCount: row.access_count ?? 0,
+        referenceCount: row.reference_count ?? 0,
+        lastAccessedAt: row.last_accessed_at ? row.last_accessed_at instanceof Date ? row.last_accessed_at.toISOString() : row.last_accessed_at : void 0
+      },
+      content: {
+        summary: row.summary,
+        data: (typeof row.data === "string" ? JSON.parse(row.data) : row.data) || {},
+        rawContext: (typeof row.context === "string" ? JSON.parse(row.context) : row.context) || void 0
+      },
+      relations: {
+        replaces: row.replaces || void 0,
+        relatedTo: row.relatedTo || row.relatedto || void 0,
+        impacts: row.impacts || void 0,
+        derivedFrom: row.derivedFrom || row.derivedfrom || void 0
+      },
+      searchable: {
+        keywords: row.keywords || [],
+        fullText: row.fullText || row.fulltext || ""
+      },
+      createdAt: row.createdAt instanceof Date ? row.createdAt.toISOString() : row.createdat || row.createdAt || "",
+      updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : row.updatedat || row.updatedAt || ""
+    };
+  }
   /**
    * 扩展关联记忆
    *
@@ -2822,7 +3113,11 @@ var PostgreSQLStorage = class {
         timestamp: row.timestamp.toISOString(),
         type: row.type,
         tags: row.tags || [],
-        version: row.version
+        version: row.version,
+        importance: row.importance ?? 0.5,
+        accessCount: row.accessCount ?? 0,
+        referenceCount: row.referenceCount ?? 0,
+        lastAccessedAt: row.lastAccessedAt?.toISOString() ?? void 0
       },
       content: {
         summary: row.summary,
@@ -2892,6 +3187,31 @@ var PostgreSQLStorage = class {
   /**
    * 关闭数据库连接
    */
+  // ========== 用进废退：访问/引用计数 ==========
+  /**
+   * 批量更新访问计数（查询命中时异步调用）
+   */
+  async onMemoryAccessed(memoryIds) {
+    if (memoryIds.length === 0)
+      return;
+    try {
+      await this.prisma.$executeRawUnsafe(`UPDATE memories SET access_count = access_count + 1, last_accessed_at = NOW() WHERE id = ANY($1)`, memoryIds);
+    } catch (error) {
+      console.warn("\u66F4\u65B0\u8BBF\u95EE\u8BA1\u6570\u5931\u8D25:", error.message);
+    }
+  }
+  /**
+   * 批量更新引用计数（被其他记忆引用时调用）
+   */
+  async onMemoryReferenced(memoryIds) {
+    if (memoryIds.length === 0)
+      return;
+    try {
+      await this.prisma.$executeRawUnsafe(`UPDATE memories SET reference_count = reference_count + 1 WHERE id = ANY($1)`, memoryIds);
+    } catch (error) {
+      console.warn("\u66F4\u65B0\u5F15\u7528\u8BA1\u6570\u5931\u8D25:", error.message);
+    }
+  }
   async close() {
     await this.prisma.$disconnect();
   }