memory-pulse-mcp-server 0.1.14 → 0.1.15

package/dist/index.js

@@ -27,11 +27,11 @@ var MemoryType;
   MemoryType2["SESSION"] = "session";
 })(MemoryType || (MemoryType = {}));
 var SearchStrategy;
-(function(SearchStrategy2) {
-  SearchStrategy2["EXACT"] = "exact";
-  SearchStrategy2["FULLTEXT"] = "fulltext";
-  SearchStrategy2["SEMANTIC"] = "semantic";
-  SearchStrategy2["AUTO"] = "auto";
+(function(SearchStrategy3) {
+  SearchStrategy3["EXACT"] = "exact";
+  SearchStrategy3["FULLTEXT"] = "fulltext";
+  SearchStrategy3["SEMANTIC"] = "semantic";
+  SearchStrategy3["AUTO"] = "auto";
 })(SearchStrategy || (SearchStrategy = {}));
 
 // ../core/dist/features.js
@@ -270,6 +270,425 @@ function deserializeVector(s) {
   return Array.from(buffer);
 }
 
+// ../core/dist/keywords.js
+var CHINESE_STOP_WORDS = /* @__PURE__ */ new Set([
+  "\u7684",
+  "\u662F",
+  "\u5728",
+  "\u4E86",
+  "\u548C",
+  "\u4E0E",
+  "\u6216",
+  "\u6709",
+  "\u8FD9",
+  "\u90A3",
+  "\u6211",
+  "\u4F60",
+  "\u4ED6",
+  "\u5979",
+  "\u5B83",
+  "\u4EEC",
+  "\u4E0D",
+  "\u4E5F",
+  "\u5C31",
+  "\u90FD",
+  "\u4E3A",
+  "\u88AB",
+  "\u7740",
+  "\u8BA9",
+  "\u628A",
+  "\u7ED9",
+  "\u4ECE",
+  "\u5230",
+  "\u5BF9",
+  "\u4E8E",
+  "\u4F46",
+  "\u800C",
+  "\u53CA",
+  "\u8FD8",
+  "\u4EE5",
+  "\u6240",
+  "\u5982",
+  "\u5219",
+  "\u7B49",
+  "\u8BE5",
+  "\u8FD9\u4E2A",
+  "\u90A3\u4E2A",
+  "\u4E00\u4E2A",
+  "\u4EC0\u4E48",
+  "\u600E\u4E48",
+  "\u5982\u4F55",
+  "\u53EF\u4EE5",
+  "\u9700\u8981",
+  "\u4F7F\u7528",
+  "\u8FDB\u884C",
+  "\u901A\u8FC7",
+  "\u5DF2\u7ECF",
+  "\u7136\u540E",
+  "\u56E0\u4E3A",
+  "\u6240\u4EE5",
+  "\u5982\u679C",
+  "\u867D\u7136",
+  "\u4F46\u662F",
+  "\u800C\u4E14",
+  "\u6216\u8005",
+  "\u4EE5\u53CA",
+  "\u5173\u4E8E",
+  "\u5176\u4E2D",
+  "\u4E4B\u540E",
+  "\u4E4B\u524D",
+  "\u76EE\u524D"
+]);
+var ENGLISH_STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "also",
+  "now",
+  "here",
+  "there",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "you",
+  "he",
+  "she",
+  "it",
+  "we",
+  "they",
+  "me",
+  "him",
+  "her",
+  "us",
+  "them",
+  "my",
+  "your",
+  "his",
+  "its",
+  "our",
+  "their",
+  "mine",
+  "yours",
+  "hers",
+  "ours",
+  "theirs"
+]);
+var STOP_WORDS = /* @__PURE__ */ new Set([...CHINESE_STOP_WORDS, ...ENGLISH_STOP_WORDS]);
+var SPECIAL_PATTERNS = [
+  // API 路径: /api/users, /v1/auth/login
+  /\/[a-z][a-z0-9\-_\/]*/gi,
+  // HTTP 方法 + 路径: GET /api/users
+  /\b(GET|POST|PUT|DELETE|PATCH)\s+\/[a-z][a-z0-9\-_\/]*/gi,
+  // 驼峰命名: getUserById, handleSubmit
+  /\b[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*\b/g,
+  // 帕斯卡命名: UserService, AuthController
+  /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g,
+  // 常量命名: MAX_RETRY, API_KEY
+  /\b[A-Z][A-Z0-9_]{2,}\b/g,
+  // 版本号: 1.0.0, v2.3.1
+  /\bv?\d+\.\d+(?:\.\d+)?(?:-[a-z]+(?:\.\d+)?)?\b/gi,
+  // 端口号: :3000, :8080
+  /:\d{2,5}\b/g,
+  // 文件扩展名: .ts, .tsx, .vue
+  /\.[a-z]{2,4}\b/gi,
+  // 数据库/技术名词: PostgreSQL, MongoDB, Redis
+  /\b(?:PostgreSQL|MySQL|MongoDB|Redis|SQLite|Prisma|Docker|Kubernetes|K8s|Node\.js|React|Vue|Angular|Next\.js|Express|NestJS|GraphQL|REST|JWT|OAuth|WebSocket|CORS|HTTPS?|API|SDK|CLI|CI\/CD|AWS|GCP|Azure)\b/gi
+];
+function isStopWord(word) {
+  return STOP_WORDS.has(word.toLowerCase());
+}
+function basicTokenize(text) {
+  const tokens = [];
+  const words = text.split(/[\s\n\r\t,，。.;；:：!！?？(（)）\[\]{}""''`<>《》【】、\-=+*\/\\|~@#$%^&]+/);
+  for (const word of words) {
+    if (word.length < 2)
+      continue;
+    if (/[\u4e00-\u9fa5]/.test(word)) {
+      const chineseChars = word.match(/[\u4e00-\u9fa5]+/g) || [];
+      for (const chars of chineseChars) {
+        if (chars.length >= 2 && chars.length <= 8) {
+          tokens.push(chars);
+        }
+        if (chars.length > 2) {
+          for (let i = 0; i < chars.length - 1; i++) {
+            tokens.push(chars.substring(i, i + 2));
+          }
+        }
+      }
+      const englishParts = word.match(/[a-zA-Z0-9_]+/g) || [];
+      tokens.push(...englishParts.filter((p) => p.length >= 2));
+    } else {
+      tokens.push(word);
+    }
+  }
+  return tokens;
+}
+function extractSpecialPatterns(text) {
+  const keywords = [];
+  for (const pattern of SPECIAL_PATTERNS) {
+    const matches = text.match(pattern) || [];
+    keywords.push(...matches);
+  }
+  return keywords;
+}
+function extractTextFromObject(obj, depth = 0) {
+  if (depth > 5)
+    return "";
+  if (typeof obj === "string") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => extractTextFromObject(item, depth + 1)).join(" ");
+  }
+  if (obj && typeof obj === "object") {
+    const texts = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (["id", "createdAt", "updatedAt", "timestamp", "version"].includes(key)) {
+        continue;
+      }
+      if (typeof key === "string" && key.length > 2) {
+        texts.push(key);
+      }
+      texts.push(extractTextFromObject(value, depth + 1));
+    }
+    return texts.join(" ");
+  }
+  return "";
+}
+function getTopKeywords(words, limit = 30) {
+  const frequency = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    const normalized = word.toLowerCase();
+    if (isStopWord(normalized))
+      continue;
+    if (normalized.length < 2)
+      continue;
+    frequency.set(normalized, (frequency.get(normalized) || 0) + 1);
+  }
+  return Array.from(frequency.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([word]) => word);
+}
+function extractKeywords(content, rawContext) {
+  const allKeywords = [];
+  const contentText = content || "";
+  allKeywords.push(...basicTokenize(contentText));
+  allKeywords.push(...extractSpecialPatterns(contentText));
+  if (rawContext) {
+    const contextText = extractTextFromObject(rawContext);
+    allKeywords.push(...basicTokenize(contextText));
+    allKeywords.push(...extractSpecialPatterns(contextText));
+  }
+  const topKeywords = getTopKeywords(allKeywords, 30);
+  const specialKeywords = extractSpecialPatterns(contentText + " " + extractTextFromObject(rawContext));
+  const uniqueSpecial = [...new Set(specialKeywords)].slice(0, 10);
+  const result = [.../* @__PURE__ */ new Set([...uniqueSpecial, ...topKeywords])];
+  return result.slice(0, 40);
+}
+function jaccardSimilarity(keywords1, keywords2) {
+  if (keywords1.length === 0 && keywords2.length === 0)
+    return 0;
+  const set1 = new Set(keywords1.map((k) => k.toLowerCase()));
+  const set2 = new Set(keywords2.map((k) => k.toLowerCase()));
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function getKeywordIntersection(keywords1, keywords2) {
+  const set1 = new Set(keywords1.map((k) => k.toLowerCase()));
+  const set2 = new Set(keywords2.map((k) => k.toLowerCase()));
+  return [...set1].filter((x) => set2.has(x));
+}
+
+// ../core/dist/auto-relation.js
+var DEFAULT_CONFIG = {
+  threshold: 0.3,
+  maxRelations: 10,
+  crossProject: true,
+  timeWindowDays: 30
+};
+var TYPE_RELATION_MATRIX = {
+  decision: { solution: 0.8, config: 0.7, code: 0.6, error: 0.5, session: 0.4, decision: 0.9 },
+  solution: { error: 0.9, decision: 0.8, code: 0.7, config: 0.6, session: 0.4, solution: 0.8 },
+  config: { code: 0.8, decision: 0.7, error: 0.6, solution: 0.5, session: 0.4, config: 0.9 },
+  code: { config: 0.8, error: 0.7, solution: 0.6, decision: 0.5, session: 0.4, code: 0.8 },
+  error: { solution: 0.9, code: 0.7, config: 0.6, decision: 0.5, session: 0.4, error: 0.7 },
+  session: { decision: 0.6, solution: 0.5, config: 0.4, code: 0.4, error: 0.4, session: 0.5 }
+};
+function getTypeRelationScore(type1, type2) {
+  return TYPE_RELATION_MATRIX[type1]?.[type2] ?? 0.5;
+}
+function getTimeProximityScore(time1, time2) {
+  const date1 = new Date(time1);
+  const date2 = new Date(time2);
+  const diffHours = Math.abs(date1.getTime() - date2.getTime()) / (1e3 * 60 * 60);
+  if (diffHours <= 24)
+    return 1;
+  if (diffHours <= 72)
+    return 0.8;
+  if (diffHours <= 168)
+    return 0.6;
+  if (diffHours <= 720)
+    return 0.4;
+  return 0.2;
+}
+function calculateSimilarity(memory1, memory2) {
+  const reasons = [];
+  const keywords1 = memory1.searchable?.keywords || [];
+  const keywords2 = memory2.searchable?.keywords || [];
+  const keywordScore = jaccardSimilarity(keywords1, keywords2);
+  if (keywordScore > 0.2) {
+    const overlap = getKeywordIntersection(keywords1, keywords2);
+    if (overlap.length > 0) {
+      reasons.push(`\u5173\u952E\u8BCD\u91CD\u53E0: ${overlap.slice(0, 5).join(", ")}`);
+    }
+  }
+  const tags1 = memory1.meta?.tags || [];
+  const tags2 = memory2.meta?.tags || [];
+  const tagScore = jaccardSimilarity(tags1, tags2);
+  if (tagScore > 0) {
+    const tagOverlap = getKeywordIntersection(tags1, tags2);
+    if (tagOverlap.length > 0) {
+      reasons.push(`\u6807\u7B7E\u91CD\u53E0: ${tagOverlap.join(", ")}`);
+    }
+  }
+  const type1 = memory1.meta?.type || "code";
+  const type2 = memory2.meta?.type || "code";
+  const typeScore = getTypeRelationScore(type1, type2);
+  const timeScore = getTimeProximityScore(memory1.createdAt || memory1.meta?.timestamp || /* @__PURE__ */ new Date(), memory2.createdAt || memory2.meta?.timestamp || /* @__PURE__ */ new Date());
+  const score = keywordScore * 0.4 + tagScore * 0.3 + typeScore * 0.2 + timeScore * 0.1;
+  return {
+    score,
+    reason: reasons.length > 0 ? reasons.join("; ") : "\u7EFC\u5408\u76F8\u4F3C",
+    details: {
+      keywordScore,
+      tagScore,
+      typeScore,
+      timeScore
+    }
+  };
+}
+function findRelatedMemories(newMemory, candidates, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const results = [];
+  for (const candidate of candidates) {
+    if (candidate.meta?.id === newMemory.meta?.id)
+      continue;
+    const similarity = calculateSimilarity(newMemory, candidate);
+    if (similarity.score >= cfg.threshold) {
+      results.push({ memory: candidate, similarity });
+    }
+  }
+  return results.sort((a, b) => b.similarity.score - a.similarity.score).slice(0, cfg.maxRelations);
+}
+function generateAutoRelations(newMemoryId, relatedCandidates) {
+  return relatedCandidates.map((candidate) => ({
+    sourceId: newMemoryId,
+    targetId: candidate.memory.meta?.id || "",
+    type: "relatedTo",
+    confidence: candidate.similarity.score,
+    isAutoGenerated: true,
+    reason: candidate.similarity.reason
+  }));
+}
+function inferProjectGroup(projectId) {
+  const suffixPatterns = [
+    /-backend$/i,
+    /-frontend$/i,
+    /-api$/i,
+    /-web$/i,
+    /-app$/i,
+    /-admin$/i,
+    /-client$/i,
+    /-server$/i,
+    /-service$/i,
+    /-shared$/i,
+    /-common$/i,
+    /-core$/i
+  ];
+  for (const pattern of suffixPatterns) {
+    if (pattern.test(projectId)) {
+      return projectId.replace(pattern, "");
+    }
+  }
+  return null;
+}
+
 // ../storage/dist/schema.js
 function migrateEmbeddingColumn(db) {
   const columns = db.pragma("table_info(memories)");
@@ -280,6 +699,40 @@ function migrateEmbeddingColumn(db) {
     console.log("\u2705 \u8FC1\u79FB\u5B8C\u6210");
   }
 }
+function initProjectGroupsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS project_groups (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      projects TEXT NOT NULL DEFAULT '[]',  -- JSON\u6570\u7EC4
+      createdAt TEXT NOT NULL,
+      updatedAt TEXT NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_project_groups_name ON project_groups(name);
+  `);
+}
+function initMemoryRelationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_relations (
+      id TEXT PRIMARY KEY,
+      sourceId TEXT NOT NULL,
+      targetId TEXT NOT NULL,
+      type TEXT NOT NULL,  -- replaces | relatedTo | impacts
+      confidence REAL DEFAULT 1.0,
+      isAutoGenerated INTEGER DEFAULT 0,  -- 0=false, 1=true
+      reason TEXT,
+      createdAt TEXT NOT NULL,
+      UNIQUE(sourceId, targetId, type)
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_memory_relations_source ON memory_relations(sourceId);
+    CREATE INDEX IF NOT EXISTS idx_memory_relations_target ON memory_relations(targetId);
+    CREATE INDEX IF NOT EXISTS idx_memory_relations_type ON memory_relations(type);
+  `);
+}
 function initSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS memories (
@@ -370,6 +823,8 @@ function initSchema(db) {
     END;
   `);
   migrateEmbeddingColumn(db);
+  initProjectGroupsTable(db);
+  initMemoryRelationsTable(db);
 }
 
 // ../storage/dist/cache.js
@@ -1169,6 +1624,157 @@ var SQLiteStorage = class {
       recentCount: recentResult.count
     };
   }
+  // ========== 项目组管理 ==========
+  /**
+   * 创建或更新项目组
+   */
+  async setProjectGroup(group) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(`
+      INSERT INTO project_groups (id, name, projects, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET
+        projects = excluded.projects,
+        updatedAt = excluded.updatedAt
+    `);
+    stmt.run(`pg_${nanoid()}`, group.name, JSON.stringify(group.projects), now, now);
+    return { success: true };
+  }
+  /**
+   * 获取项目组
+   */
+  async getProjectGroup(name) {
+    const stmt = this.db.prepare("SELECT * FROM project_groups WHERE name = ?");
+    const row = stmt.get(name);
+    if (!row)
+      return null;
+    return {
+      name: row.name,
+      projects: JSON.parse(row.projects)
+    };
+  }
+  /**
+   * 获取项目所属的项目组
+   */
+  async getProjectGroupByProject(projectId) {
+    const stmt = this.db.prepare("SELECT * FROM project_groups");
+    const rows = stmt.all();
+    for (const row of rows) {
+      const projects = JSON.parse(row.projects);
+      if (projects.includes(projectId)) {
+        return {
+          name: row.name,
+          projects
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * 获取所有项目组
+   */
+  async getAllProjectGroups() {
+    const stmt = this.db.prepare("SELECT * FROM project_groups");
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      name: row.name,
+      projects: JSON.parse(row.projects)
+    }));
+  }
+  /**
+   * 删除项目组
+   */
+  async deleteProjectGroup(name) {
+    const stmt = this.db.prepare("DELETE FROM project_groups WHERE name = ?");
+    const result = stmt.run(name);
+    return { success: result.changes > 0 };
+  }
+  // ========== 记忆关系管理 ==========
+  /**
+   * 批量创建记忆关系
+   */
+  async createRelations(relations) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO memory_relations (id, sourceId, targetId, type, confidence, isAutoGenerated, reason, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    let count = 0;
+    for (const rel of relations) {
+      const result = stmt.run(`rel_${nanoid()}`, rel.sourceId, rel.targetId, rel.type, rel.confidence, rel.isAutoGenerated ? 1 : 0, rel.reason || null, now);
+      if (result.changes > 0)
+        count++;
+    }
+    return { success: true, count };
+  }
+  /**
+   * 获取记忆的所有关系
+   */
+  async getMemoryRelations(memoryId, options) {
+    let sql = "SELECT * FROM memory_relations WHERE (sourceId = ? OR targetId = ?)";
+    const params = [memoryId, memoryId];
+    if (options?.includeAutoGenerated === false) {
+      sql += " AND isAutoGenerated = 0";
+    }
+    if (options?.type) {
+      sql += " AND type = ?";
+      params.push(options.type);
+    }
+    sql += " ORDER BY createdAt DESC";
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      sourceId: row.sourceId,
+      targetId: row.targetId,
+      type: row.type,
+      confidence: row.confidence,
+      isAutoGenerated: row.isAutoGenerated === 1,
+      reason: row.reason
+    }));
+  }
+  /**
+   * 删除记忆关系
+   */
+  async deleteRelation(sourceId, targetId, type) {
+    let sql = "DELETE FROM memory_relations WHERE sourceId = ? AND targetId = ?";
+    const params = [sourceId, targetId];
+    if (type) {
+      sql += " AND type = ?";
+      params.push(type);
+    }
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...params);
+    return { success: result.changes > 0 };
+  }
+  /**
+   * 搜索候选关联记忆（用于自动关联）
+   */
+  async searchCandidates(params) {
+    if (params.keywords.length === 0 || params.projectIds.length === 0) {
+      return [];
+    }
+    const limit = params.limit || 50;
+    let sql = "SELECT * FROM memories WHERE 1=1";
+    const sqlParams = [];
+    const projectPlaceholders = params.projectIds.map(() => "?").join(", ");
+    sql += ` AND projectId IN (${projectPlaceholders})`;
+    sqlParams.push(...params.projectIds);
+    if (params.excludeId) {
+      sql += " AND id != ?";
+      sqlParams.push(params.excludeId);
+    }
+    const keywordConditions = params.keywords.map(() => "(summary LIKE ? OR fullText LIKE ? OR keywords LIKE ?)").join(" OR ");
+    sql += ` AND (${keywordConditions})`;
+    params.keywords.forEach((keyword) => {
+      const pattern = `%${keyword}%`;
+      sqlParams.push(pattern, pattern, pattern);
+    });
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    sqlParams.push(limit);
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...sqlParams);
+    return rows.map(this.rowToMemory);
+  }
 };
 
 // ../storage/dist/postgresql-storage.js
@@ -1752,6 +2358,170 @@ var PostgreSQLStorage = class {
   async close() {
     await this.prisma.$disconnect();
   }
+  // ========== 项目组管理 ==========
+  /**
+   * 创建或更新项目组
+   */
+  async setProjectGroup(group) {
+    await this.prisma.projectGroup.upsert({
+      where: { name: group.name },
+      update: { projects: group.projects },
+      create: {
+        name: group.name,
+        projects: group.projects
+      }
+    });
+    return { success: true };
+  }
+  /**
+   * 获取项目组
+   */
+  async getProjectGroup(name) {
+    const row = await this.prisma.projectGroup.findUnique({
+      where: { name }
+    });
+    if (!row)
+      return null;
+    return {
+      name: row.name,
+      projects: row.projects
+    };
+  }
+  /**
+   * 获取项目所属的项目组
+   */
+  async getProjectGroupByProject(projectId) {
+    const rows = await this.prisma.projectGroup.findMany();
+    for (const row of rows) {
+      if (row.projects.includes(projectId)) {
+        return {
+          name: row.name,
+          projects: row.projects
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * 获取所有项目组
+   */
+  async getAllProjectGroups() {
+    const rows = await this.prisma.projectGroup.findMany();
+    return rows.map((row) => ({
+      name: row.name,
+      projects: row.projects
+    }));
+  }
+  /**
+   * 删除项目组
+   */
+  async deleteProjectGroup(name) {
+    try {
+      await this.prisma.projectGroup.delete({
+        where: { name }
+      });
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+  // ========== 记忆关系管理 ==========
+  /**
+   * 批量创建记忆关系
+   */
+  async createRelations(relations) {
+    let count = 0;
+    for (const rel of relations) {
+      try {
+        await this.prisma.memoryRelation.create({
+          data: {
+            sourceId: rel.sourceId,
+            targetId: rel.targetId,
+            type: rel.type,
+            confidence: rel.confidence,
+            isAutoGenerated: rel.isAutoGenerated,
+            reason: rel.reason || null
+          }
+        });
+        count++;
+      } catch {
+      }
+    }
+    return { success: true, count };
+  }
+  /**
+   * 获取记忆的所有关系
+   */
+  async getMemoryRelations(memoryId, options) {
+    const where = {
+      OR: [
+        { sourceId: memoryId },
+        { targetId: memoryId }
+      ]
+    };
+    if (options?.includeAutoGenerated === false) {
+      where.isAutoGenerated = false;
+    }
+    if (options?.type) {
+      where.type = options.type;
+    }
+    const rows = await this.prisma.memoryRelation.findMany({
+      where,
+      orderBy: { createdAt: "desc" }
+    });
+    return rows.map((row) => ({
+      sourceId: row.sourceId,
+      targetId: row.targetId,
+      type: row.type,
+      confidence: row.confidence,
+      isAutoGenerated: row.isAutoGenerated,
+      reason: row.reason || ""
+    }));
+  }
+  /**
+   * 删除记忆关系
+   */
+  async deleteRelation(sourceId, targetId, type) {
+    try {
+      const where = {
+        sourceId,
+        targetId
+      };
+      if (type) {
+        where.type = type;
+      }
+      await this.prisma.memoryRelation.deleteMany({ where });
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+  /**
+   * 搜索候选关联记忆（用于自动关联）
+   */
+  async searchCandidates(params) {
+    if (params.keywords.length === 0 || params.projectIds.length === 0) {
+      return [];
+    }
+    const limit = params.limit || 50;
+    const keywordConditions = params.keywords.flatMap((keyword) => [
+      { summary: { contains: keyword, mode: "insensitive" } },
+      { fullText: { contains: keyword, mode: "insensitive" } }
+    ]);
+    const where = {
+      projectId: { in: params.projectIds },
+      OR: keywordConditions
+    };
+    if (params.excludeId) {
+      where.id = { not: params.excludeId };
+    }
+    const rows = await this.prisma.memory.findMany({
+      where,
+      orderBy: { timestamp: "desc" },
+      take: limit
+    });
+    return rows.map(this.rowToMemory);
+  }
 };
 
 // src/index.ts
@@ -1838,6 +2608,121 @@ function createStorage() {
   return new SQLiteStorage(dbPath);
 }
 var storage = createStorage();
+async function processAutoRelations(newMemoryId, projectId, content, rawContext) {
+  try {
+    const keywords = extractKeywords(content, rawContext);
+    if (keywords.length === 0) {
+      return { relationsCreated: 0 };
+    }
+    let projectIds = [projectId];
+    if (storage.getProjectGroupByProject) {
+      const group = await storage.getProjectGroupByProject(projectId);
+      if (group) {
+        projectIds = group.projects;
+      } else {
+        const inferredGroup = inferProjectGroup(projectId);
+        if (inferredGroup && storage.getAllProjectGroups) {
+          const allGroups = await storage.getAllProjectGroups();
+          const sameGroupProjects = allGroups.filter((g) => g.projects.some((p) => inferProjectGroup(p) === inferredGroup)).flatMap((g) => g.projects);
+          if (sameGroupProjects.length > 0) {
+            projectIds = [.../* @__PURE__ */ new Set([projectId, ...sameGroupProjects])];
+          }
+        }
+      }
+    }
+    if (!storage.searchCandidates) {
+      return { relationsCreated: 0 };
+    }
+    const candidates = await storage.searchCandidates({
+      keywords,
+      projectIds,
+      excludeId: newMemoryId,
+      limit: 50
+      // 搜索更多候选以提高关联质量
+    });
+    if (candidates.length === 0) {
+      return { relationsCreated: 0 };
+    }
+    const newMemory = await storage.getById(newMemoryId);
+    if (!newMemory) {
+      return { relationsCreated: 0 };
+    }
+    const relatedCandidates = findRelatedMemories(newMemory, candidates, {
+      threshold: 0.3,
+      // 相似度阈值
+      maxRelations: 10,
+      // 最多关联 10 条
+      crossProject: true
+    });
+    if (relatedCandidates.length === 0) {
+      return { relationsCreated: 0 };
+    }
+    const relations = generateAutoRelations(newMemoryId, relatedCandidates);
+    if (storage.createRelations && relations.length > 0) {
+      const result = await storage.createRelations(relations);
+      return { relationsCreated: result.count };
+    }
+    return { relationsCreated: 0 };
+  } catch (error) {
+    console.error("\u81EA\u52A8\u5173\u8054\u5904\u7406\u5931\u8D25:", error);
+    return { relationsCreated: 0 };
+  }
+}
+async function getProjectGroupProjectIds(projectId) {
+  try {
+    if (storage.getProjectGroupByProject) {
+      const group = await storage.getProjectGroupByProject(projectId);
+      if (group) {
+        return group.projects;
+      }
+    }
+    const inferredGroup = inferProjectGroup(projectId);
+    if (inferredGroup && storage.getAllProjectGroups) {
+      const allGroups = await storage.getAllProjectGroups();
+      for (const group of allGroups) {
+        if (group.projects.some((p) => inferProjectGroup(p) === inferredGroup)) {
+          return group.projects;
+        }
+      }
+    }
+    return [projectId];
+  } catch (error) {
+    console.error("\u83B7\u53D6\u9879\u76EE\u7EC4\u5931\u8D25:", error);
+    return [projectId];
+  }
+}
+async function expandRelationChain(memories, depth = 1) {
+  if (depth <= 0 || memories.length === 0) {
+    return [];
+  }
+  try {
+    const relatedMemories = [];
+    const seenIds = new Set(memories.map((m) => m.meta?.id));
+    for (const memory of memories) {
+      const memoryId = memory.meta?.id;
+      if (!memoryId) continue;
+      if (storage.getMemoryRelations) {
+        const relations = await storage.getMemoryRelations(memoryId, {
+          includeAutoGenerated: true
+        });
+        for (const relation of relations) {
+          const targetId = relation.targetId;
+          if (!seenIds.has(targetId)) {
+            seenIds.add(targetId);
+            const relatedMemory = await storage.getById(targetId);
+            if (relatedMemory) {
+              relatedMemories.push(relatedMemory);
+            }
+          }
+        }
+      }
+    }
+    return relatedMemories;
+  } catch (error) {
+    console.error("\u6269\u5C55\u5173\u7CFB\u94FE\u5931\u8D25:", error);
+    return [];
+  }
+}
 var tools = [
   {
     name: "mpulse_store",
@@ -2031,13 +2916,19 @@ var tools = [
 3. \u67E5\u8BE2\u5173\u952E\u8BCD\uFF1A"\u9879\u76EE\u4E0A\u4E0B\u6587 \u67B6\u6784\u51B3\u7B56 \u672A\u5B8C\u6210\u4EFB\u52A1 \u914D\u7F6E\u4FE1\u606F"
 4. \u5206\u6790\u8FD4\u56DE\u7ED3\u679C\u540E\u518D\u6267\u884C\u5176\u4ED6\u64CD\u4F5C
 
+\u{1F517} \u667A\u80FD\u5173\u8054\u529F\u80FD\uFF1A
+- \u81EA\u52A8\u8DE8\u9879\u76EE\u641C\u7D22\uFF1A\u5982\u679C\u9879\u76EE\u5728\u540C\u4E00\u9879\u76EE\u7EC4\uFF08\u5982 frontend/backend\uFF09\uFF0C\u4F1A\u81EA\u52A8\u641C\u7D22\u6240\u6709\u5173\u8054\u9879\u76EE
+- \u5173\u7CFB\u94FE\u6269\u5C55\uFF1A\u9ED8\u8BA4\u8FD4\u56DE\u76F8\u5173\u8054\u7684\u8BB0\u5FC6\uFF0C\u8BBE\u7F6E expandRelations: true \u53EF\u83B7\u53D6\u66F4\u6DF1\u5C42\u5173\u8054
+- \u7ED3\u679C\u8BF4\u660E\uFF1Amemories \u662F\u76F4\u63A5\u5339\u914D\uFF0CrelatedMemories \u662F\u901A\u8FC7\u5173\u7CFB\u94FE\u6269\u5C55\u7684\u5173\u8054\u8BB0\u5FC6
+
 \u8C03\u7528\u793A\u4F8B\uFF1A
 mpulse_recall({
   query: "\u9879\u76EE\u4E0A\u4E0B\u6587 \u67B6\u6784\u51B3\u7B56 \u672A\u5B8C\u6210\u4EFB\u52A1",
-  projectId: "\u4ECE\u5DE5\u4F5C\u76EE\u5F55\u63D0\u53D6\u7684\u9879\u76EE\u540D"
+  projectId: "\u4ECE\u5DE5\u4F5C\u76EE\u5F55\u63D0\u53D6\u7684\u9879\u76EE\u540D",
+  expandRelations: true
 })
 
-\u8FD4\u56DE\u5185\u5BB9\uFF1A\u5386\u53F2\u51B3\u7B56\u3001\u5DF2\u89E3\u51B3\u95EE\u9898\u3001\u914D\u7F6E\u4FE1\u606F\u3001\u672A\u5B8C\u6210\u4EFB\u52A1\u7B49`,
+\u8FD4\u56DE\u5185\u5BB9\uFF1A\u5386\u53F2\u51B3\u7B56\u3001\u5DF2\u89E3\u51B3\u95EE\u9898\u3001\u914D\u7F6E\u4FE1\u606F\u3001\u672A\u5B8C\u6210\u4EFB\u52A1\u3001\u5173\u8054\u8BB0\u5FC6\u7B49`,
     inputSchema: {
       type: "object",
       properties: {
@@ -2047,7 +2938,7 @@ mpulse_recall({
         },
         projectId: {
           type: "string",
-          description: "\u9879\u76EE ID"
+          description: "\u9879\u76EE ID\uFF08\u4F1A\u81EA\u52A8\u6269\u5C55\u5230\u9879\u76EE\u7EC4\u5185\u6240\u6709\u9879\u76EE\uFF09"
         },
         type: {
           type: "string",
@@ -2067,6 +2958,14 @@ mpulse_recall({
         limit: {
           type: "number",
           description: "\u8FD4\u56DE\u6570\u91CF"
+        },
+        expandRelations: {
+          type: "boolean",
+          description: "\u662F\u5426\u6269\u5C55\u5173\u7CFB\u94FE\uFF08\u9ED8\u8BA4 true\uFF09"
+        },
+        relationDepth: {
+          type: "number",
+          description: "\u5173\u7CFB\u94FE\u6269\u5C55\u6DF1\u5EA6\uFF08\u9ED8\u8BA4 1\uFF09"
         }
       },
       required: ["query"]
@@ -2121,6 +3020,50 @@ mpulse_recall({
       },
       required: ["memoryId"]
     }
+  },
+  // ========== 项目组管理工具 ==========
+  {
+    name: "mpulse_set_project_group",
+    description: `\u8BBE\u7F6E\u9879\u76EE\u7EC4\uFF0C\u5C06\u76F8\u5173\u9879\u76EE\u5173\u8054\u5728\u4E00\u8D77\u3002
+\u5173\u8054\u540E\uFF0C\u68C0\u7D22\u65F6\u4F1A\u81EA\u52A8\u8DE8\u9879\u76EE\u641C\u7D22\uFF0C\u5B58\u50A8\u65F6\u4F1A\u81EA\u52A8\u5EFA\u7ACB\u8DE8\u9879\u76EE\u5173\u8054\u3002
+\u4F8B\u5982\uFF1A\u5C06 myapp-frontend \u548C myapp-backend \u5173\u8054\u4E3A\u4E00\u4E2A\u9879\u76EE\u7EC4\u3002`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "\u9879\u76EE\u7EC4\u540D\u79F0\uFF08\u5982 myapp\uFF09"
+        },
+        projects: {
+          type: "array",
+          items: { type: "string" },
+          description: '\u9879\u76EE ID \u5217\u8868\uFF08\u5982 ["myapp-frontend", "myapp-backend", "myapp-api"]\uFF09'
+        }
+      },
+      required: ["name", "projects"]
+    }
+  },
+  {
+    name: "mpulse_get_project_groups",
+    description: "\u83B7\u53D6\u6240\u6709\u9879\u76EE\u7EC4\u914D\u7F6E",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "mpulse_delete_project_group",
+    description: "\u5220\u9664\u9879\u76EE\u7EC4",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "\u9879\u76EE\u7EC4\u540D\u79F0"
+        }
+      },
+      required: ["name"]
+    }
   }
 ];
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -2444,80 +3387,141 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     switch (name) {
       case "mpulse_store": {
+        const content = args.content;
+        const rawContext = args.rawContext;
+        const projectId = args.projectId;
         const result = await storage.store({
-          content: args.content,
-          rawContext: args.rawContext,
-          projectId: args.projectId,
+          content,
+          rawContext,
+          projectId,
           type: args.type,
           tags: args.tags,
           sessionId: args.sessionId
         });
+        let autoRelationResult = { relationsCreated: 0 };
+        if (result.success && result.id) {
+          autoRelationResult = await processAutoRelations(
+            result.id,
+            projectId,
+            content,
+            rawContext
+          );
+        }
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(result, null, 2)
+              text: JSON.stringify({
+                ...result,
+                autoRelations: autoRelationResult.relationsCreated
+              }, null, 2)
             }
           ]
         };
       }
       case "mpulse_store_decision": {
+        const projectId = args.projectId;
         const decisionParams = {
           question: args.question,
           options: args.options,
           chosen: args.chosen,
           reason: args.reason,
-          projectId: args.projectId,
+          projectId,
           tags: args.tags,
           sessionId: args.sessionId
         };
         const result = await storage.storeDecision(decisionParams);
+        let autoRelationResult = { relationsCreated: 0 };
+        if (result.success && result.id) {
+          const content = `${decisionParams.question} ${decisionParams.chosen} ${decisionParams.reason}`;
+          autoRelationResult = await processAutoRelations(
+            result.id,
+            projectId,
+            content,
+            { options: decisionParams.options }
+          );
+        }
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(result, null, 2)
+              text: JSON.stringify({
+                ...result,
+                autoRelations: autoRelationResult.relationsCreated
+              }, null, 2)
             }
           ]
         };
       }
       case "mpulse_store_solution": {
+        const projectId = args.projectId;
         const solutionParams = {
           problem: args.problem,
           rootCause: args.rootCause,
           solution: args.solution,
           prevention: args.prevention,
           relatedIssues: args.relatedIssues,
-          projectId: args.projectId,
+          projectId,
           tags: args.tags,
           sessionId: args.sessionId,
           artifacts: args.artifacts
         };
         const result = await storage.storeSolution(solutionParams);
+        let autoRelationResult = { relationsCreated: 0 };
+        if (result.success && result.id) {
+          const content = `${solutionParams.problem} ${solutionParams.rootCause} ${solutionParams.solution}`;
+          autoRelationResult = await processAutoRelations(
+            result.id,
+            projectId,
+            content,
+            { artifacts: solutionParams.artifacts }
+          );
+        }
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(result, null, 2)
+              text: JSON.stringify({
+                ...result,
+                autoRelations: autoRelationResult.relationsCreated
+              }, null, 2)
             }
           ]
         };
       }
       case "mpulse_store_session": {
+        const projectId = args.projectId;
         const sessionParams = {
           summary: args.summary,
           decisions: args.decisions,
           unfinishedTasks: args.unfinishedTasks,
           nextSteps: args.nextSteps,
-          projectId: args.projectId,
+          projectId,
           sessionId: args.sessionId
         };
         const result = await storage.storeSession(sessionParams);
+        let autoRelationResult = { relationsCreated: 0 };
+        if (result.success && result.id) {
+          const decisionsText = (sessionParams.decisions || []).join(" ");
+          const content = `${sessionParams.summary} ${decisionsText}`;
+          autoRelationResult = await processAutoRelations(
+            result.id,
+            projectId,
+            content,
+            {
+              unfinishedTasks: sessionParams.unfinishedTasks,
+              nextSteps: sessionParams.nextSteps
+            }
+          );
+        }
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(result, null, 2)
+              text: JSON.stringify({
+                ...result,
+                autoRelations: autoRelationResult.relationsCreated
+              }, null, 2)
             }
           ]
         };
@@ -2525,20 +3529,38 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "mpulse_recall": {
         const query = args.query;
         const strategy = args.strategy || "fulltext";
+        const projectId = args.projectId;
+        const expandRelations = args.expandRelations !== false;
+        const relationDepth = args.relationDepth || 1;
+        let projectIds;
+        if (projectId) {
+          projectIds = await getProjectGroupProjectIds(projectId);
+        }
         const filters = {
           query,
-          projectId: args.projectId,
+          // 如果有多个项目，使用 projectIds；否则使用 projectId
+          ...projectIds && projectIds.length > 1 ? { projectIds } : { projectId },
           type: args.type,
           tags: args.tags,
           strategy,
-          limit: args.limit
+          limit: args.limit,
+          expandRelations,
+          relationDepth
         };
         const result = await storage.recall(filters);
+        let relatedMemories = result.relatedMemories || [];
+        if (expandRelations && relatedMemories.length === 0 && result.memories.length > 0) {
+          relatedMemories = await expandRelationChain(result.memories, relationDepth);
+        }
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(result, null, 2)
+              text: JSON.stringify({
+                ...result,
+                relatedMemories,
+                projectsSearched: projectIds
+              }, null, 2)
             }
           ]
         };
@@ -2576,6 +3598,64 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           ]
         };
       }
+      // ========== 项目组管理 ==========
+      case "mpulse_set_project_group": {
+        const groupConfig = {
+          name: args.name,
+          projects: args.projects
+        };
+        if (!storage.setProjectGroup) {
+          throw new Error("\u5F53\u524D\u5B58\u50A8\u4E0D\u652F\u6301\u9879\u76EE\u7EC4\u529F\u80FD");
+        }
+        const result = await storage.setProjectGroup(groupConfig);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ...result,
+                group: groupConfig,
+                message: `\u9879\u76EE\u7EC4 "${groupConfig.name}" \u5DF2\u8BBE\u7F6E\uFF0C\u5305\u542B ${groupConfig.projects.length} \u4E2A\u9879\u76EE`
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_get_project_groups": {
+        if (!storage.getAllProjectGroups) {
+          throw new Error("\u5F53\u524D\u5B58\u50A8\u4E0D\u652F\u6301\u9879\u76EE\u7EC4\u529F\u80FD");
+        }
+        const groups = await storage.getAllProjectGroups();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                groups,
+                total: groups.length
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      case "mpulse_delete_project_group": {
+        const name2 = args.name;
+        if (!storage.deleteProjectGroup) {
+          throw new Error("\u5F53\u524D\u5B58\u50A8\u4E0D\u652F\u6301\u9879\u76EE\u7EC4\u529F\u80FD");
+        }
+        const result = await storage.deleteProjectGroup(name2);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ...result,
+                message: result.success ? `\u9879\u76EE\u7EC4 "${name2}" \u5DF2\u5220\u9664` : `\u9879\u76EE\u7EC4 "${name2}" \u5220\u9664\u5931\u8D25\u6216\u4E0D\u5B58\u5728`
+              }, null, 2)
+            }
+          ]
+        };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }