@gethmy/mcp 2.3.1 → 2.3.2

package/dist/lib/consolidation.js

@@ -1,303 +1,388 @@
-/**
- * Smart Memory Consolidation
- *
- * Clusters similar draft/episode memories and merges them into
- * consolidated reference entities to reduce noise and improve retrieval.
- */
-import { findSimilarEntities } from "./graph-expansion.js";
-/**
- * Consolidate similar draft/episode memories into reference entities.
- *
- * 1. Lists all draft and episode tier entities in scope
- * 2. Groups by entity type
- * 3. For each type group, finds clusters via embedding similarity
- * 4. Merges clusters into new reference entities with part_of relations
- */
-export async function consolidateMemories(client, workspaceId, projectId, options) {
-    const dryRun = options?.dryRun !== false; // default true
-    const minClusterSize = options?.minClusterSize ?? 3; // raised from 2 to reduce noise
-    const result = {
-        consolidated: 0,
-        clustersFound: 0,
-        entitiesProcessed: 0,
-        details: [],
-    };
-    // Step 1: Fetch all draft and episode entities
-    const listResult = await client.listMemoryEntities({
-        workspace_id: workspaceId,
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/graph-expansion.ts
+async function autoExpandGraph(client, entityId, title, content, _tags, workspaceId, projectId, maxRelations = 5) {
+  try {
+    const contentSnippet = content.slice(0, 200).trim();
+    const query = [title, contentSnippet].filter(Boolean).join(" ");
+    let candidates = [];
+    const { entities } = await client.searchMemoryEntities(workspaceId, query, {
+      project_id: projectId,
+      limit: 20
+    });
+    candidates = entities.filter((e) => e.id !== entityId).slice(0, maxRelations);
+    if (candidates.length === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const retry = await client.searchMemoryEntities(workspaceId, query, {
         project_id: projectId,
-        limit: 100,
+        limit: 20
+      });
+      candidates = retry.entities.filter((e) => e.id !== entityId).slice(0, maxRelations);
+    }
+    let relationsCreated = 0;
+    for (const candidate of candidates) {
+      try {
+        await client.createMemoryRelation({
+          source_id: entityId,
+          target_id: candidate.id,
+          relation_type: "relates_to",
+          confidence: 0.6
+        });
+        relationsCreated++;
+      } catch (err) {
+        const status = err?.status;
+        if (status !== 409) {}
+      }
+    }
+    return { relationsCreated };
+  } catch {
+    return { relationsCreated: 0 };
+  }
+}
+async function findSimilarEntities(client, title, content, workspaceId, options) {
+  const contentSnippet = content.slice(0, 200).trim();
+  const query = [title, contentSnippet].filter(Boolean).join(" ");
+  try {
+    const { entities } = await client.searchMemoryEntities(workspaceId, query, {
+      project_id: options?.projectId,
+      limit: options?.limit ?? 20,
+      type: options?.type
     });
-    const allEntities = (listResult.entities || []).filter((e) => e.memory_tier === "draft" || e.memory_tier === "episode");
-    result.entitiesProcessed = allEntities.length;
-    if (allEntities.length < minClusterSize)
-        return result;
-    // Step 2: Group by type
-    const typeGroups = new Map();
-    for (const entity of allEntities) {
-        const group = typeGroups.get(entity.type) || [];
-        group.push(entity);
-        typeGroups.set(entity.type, group);
+    const minScore = options?.minRrfScore ?? 0;
+    const excludeSet = new Set(options?.excludeIds || []);
+    return entities.filter((e) => {
+      if (excludeSet.has(e.id))
+        return false;
+      if (minScore > 0 && (e.rrf_score ?? 0) < minScore)
+        return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+var CAUSAL_LOOKUP = [
+  {
+    sourceType: "error",
+    targetType: "solution",
+    relation: "resolved_by",
+    direction: "forward"
+  },
+  {
+    sourceType: "solution",
+    targetType: "error",
+    relation: "resolved_by",
+    direction: "reverse"
+  },
+  {
+    sourceType: "lesson",
+    targetType: "error",
+    relation: "learned_from",
+    direction: "forward"
+  }
+];
+async function linkCrossTypeNeighbors(client, entityId, entityType, title, content, workspaceId, projectId) {
+  const rules = CAUSAL_LOOKUP.filter((r) => r.sourceType === entityType);
+  if (rules.length === 0)
+    return { relationsCreated: 0 };
+  let relationsCreated = 0;
+  for (const rule of rules) {
+    try {
+      const matches = await findSimilarEntities(client, title, content, workspaceId, {
+        projectId,
+        limit: 10,
+        minRrfScore: 0.04,
+        excludeIds: [entityId],
+        type: rule.targetType
+      });
+      for (const match of matches.slice(0, 3)) {
+        const sourceId = rule.direction === "forward" ? entityId : match.id;
+        const targetId = rule.direction === "forward" ? match.id : entityId;
+        try {
+          await client.createMemoryRelation({
+            source_id: sourceId,
+            target_id: targetId,
+            relation_type: rule.relation,
+            confidence: 0.65
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    } catch {}
+  }
+  return { relationsCreated };
+}
+
+// src/consolidation.ts
+async function consolidateMemories(client, workspaceId, projectId, options) {
+  const dryRun = options?.dryRun !== false;
+  const minClusterSize = options?.minClusterSize ?? 3;
+  const result = {
+    consolidated: 0,
+    clustersFound: 0,
+    entitiesProcessed: 0,
+    details: []
+  };
+  const listResult = await client.listMemoryEntities({
+    workspace_id: workspaceId,
+    project_id: projectId,
+    limit: 100
+  });
+  const allEntities = (listResult.entities || []).filter((e) => e.memory_tier === "draft" || e.memory_tier === "episode");
+  result.entitiesProcessed = allEntities.length;
+  if (allEntities.length < minClusterSize)
+    return result;
+  const typeGroups = new Map;
+  for (const entity of allEntities) {
+    const group = typeGroups.get(entity.type) || [];
+    group.push(entity);
+    typeGroups.set(entity.type, group);
+  }
+  for (const [type, entities] of typeGroups) {
+    if (entities.length < minClusterSize)
+      continue;
+    const clustered = new Set;
+    const clusters = [];
+    for (const entity of entities) {
+      if (clustered.has(entity.id))
+        continue;
+      const similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, {
+        projectId,
+        limit: 20,
+        minRrfScore: 0.01,
+        excludeIds: [...clustered]
+      });
+      const entityIdSet = new Set(entities.map((e) => e.id));
+      const clusterMembers = similar.filter((s) => entityIdSet.has(s.id) && !clustered.has(s.id) && s.id !== entity.id && s.type === type);
+      if (clusterMembers.length >= minClusterSize - 1) {
+        const cluster = [
+          entity,
+          ...clusterMembers.slice(0, 5).map((s) => {
+            return entities.find((e) => e.id === s.id) || entity;
+          })
+        ];
+        const uniqueCluster = [];
+        const seen = new Set;
+        for (const member of cluster) {
+          if (!seen.has(member.id)) {
+            seen.add(member.id);
+            uniqueCluster.push(member);
+          }
+        }
+        if (uniqueCluster.length >= minClusterSize) {
+          clusters.push(uniqueCluster);
+          for (const member of uniqueCluster) {
+            clustered.add(member.id);
+          }
+        }
+      }
     }
-    // Step 3: Find clusters within each type group
-    for (const [type, entities] of typeGroups) {
-        if (entities.length < minClusterSize)
-            continue;
-        const clustered = new Set();
-        const clusters = [];
-        for (const entity of entities) {
-            if (clustered.has(entity.id))
-                continue;
-            // Search for similar entities using embedding-based search
-            const similar = await findSimilarEntities(client, entity.title, entity.content, workspaceId, {
-                projectId,
-                limit: 20,
-                minRrfScore: 0.01,
-                excludeIds: [...clustered],
-            });
-            // Filter to only entities in our current type group that aren't yet clustered
-            const entityIdSet = new Set(entities.map((e) => e.id));
-            const clusterMembers = similar.filter((s) => entityIdSet.has(s.id) &&
-                !clustered.has(s.id) &&
-                s.id !== entity.id &&
-                s.type === type);
-            if (clusterMembers.length >= minClusterSize - 1) {
-                const cluster = [
-                    entity,
-                    ...clusterMembers.slice(0, 5).map((s) => {
-                        // Map back to full entity from our list
-                        return entities.find((e) => e.id === s.id) || entity;
-                    }),
-                ];
-                // Deduplicate by id
-                const uniqueCluster = [];
-                const seen = new Set();
-                for (const member of cluster) {
-                    if (!seen.has(member.id)) {
-                        seen.add(member.id);
-                        uniqueCluster.push(member);
-                    }
-                }
-                if (uniqueCluster.length >= minClusterSize) {
-                    clusters.push(uniqueCluster);
-                    for (const member of uniqueCluster) {
-                        clustered.add(member.id);
-                    }
-                }
+    for (const cluster of clusters) {
+      result.clustersFound++;
+      const mergedTitle = deriveClusterTitle(cluster, type);
+      const memberTitles = cluster.map((e) => e.title);
+      const mergedContent = synthesizeClusterContent(cluster, type);
+      const maxConfidence = Math.max(...cluster.map((e) => e.confidence));
+      const allTags = [...new Set(cluster.flatMap((e) => e.tags || []))];
+      const detail = {
+        clusterSize: cluster.length,
+        mergedTitle,
+        memberTitles
+      };
+      if (!dryRun) {
+        try {
+          const createResult = await client.createMemoryEntity({
+            workspace_id: workspaceId,
+            project_id: projectId,
+            type,
+            scope: "project",
+            memory_tier: "reference",
+            title: mergedTitle,
+            content: mergedContent,
+            confidence: maxConfidence,
+            tags: [...allTags.slice(0, 15), "consolidated"],
+            metadata: {
+              source: "consolidation",
+              member_ids: cluster.map((e) => e.id),
+              consolidated_at: new Date().toISOString()
             }
-        }
-        // Step 4: Create consolidated entities for each cluster
-        for (const cluster of clusters) {
-            result.clustersFound++;
-            // Derive title from most common words across cluster titles
-            const mergedTitle = deriveClusterTitle(cluster, type);
-            const memberTitles = cluster.map((e) => e.title);
-            // Synthesize content: extract unique knowledge from each member,
-            // not just a bullet list of titles. Each member's content is trimmed
-            // to its first meaningful paragraph (skipping headers and metadata).
-            const mergedContent = synthesizeClusterContent(cluster, type);
-            // Max confidence from cluster members
-            const maxConfidence = Math.max(...cluster.map((e) => e.confidence));
-            // Union of all tags (deduped)
-            const allTags = [...new Set(cluster.flatMap((e) => e.tags || []))];
-            const detail = {
-                clusterSize: cluster.length,
-                mergedTitle,
-                memberTitles,
-            };
-            if (!dryRun) {
-                try {
-                    // Create consolidated reference entity
-                    const createResult = await client.createMemoryEntity({
-                        workspace_id: workspaceId,
-                        project_id: projectId,
-                        type,
-                        scope: "project",
-                        memory_tier: "reference",
-                        title: mergedTitle,
-                        content: mergedContent,
-                        confidence: maxConfidence,
-                        tags: [...allTags.slice(0, 15), "consolidated"],
-                        metadata: {
-                            source: "consolidation",
-                            member_ids: cluster.map((e) => e.id),
-                            consolidated_at: new Date().toISOString(),
-                        },
-                    });
-                    const newEntity = createResult.entity;
-                    if (newEntity?.id) {
-                        detail.entityId = newEntity.id;
-                        // Create part_of relations from members → consolidated entity
-                        for (const member of cluster) {
-                            try {
-                                await client.createMemoryRelation({
-                                    source_id: member.id,
-                                    target_id: newEntity.id,
-                                    relation_type: "part_of",
-                                    confidence: 0.8,
-                                });
-                            }
-                            catch {
-                                // Skip duplicate relations
-                            }
-                        }
-                        // Downgrade member confidence by 0.3 (min 0.1)
-                        for (const member of cluster) {
-                            try {
-                                const newConf = Math.max(member.confidence - 0.3, 0.1);
-                                await client.updateMemoryEntity(member.id, {
-                                    confidence: newConf,
-                                    metadata: {
-                                        consolidated_into: newEntity.id,
-                                        original_confidence: member.confidence,
-                                    },
-                                });
-                            }
-                            catch {
-                                // Non-fatal
-                            }
-                        }
-                        result.consolidated++;
-                    }
-                }
-                catch {
-                    // Non-fatal: consolidation failure for one cluster shouldn't block others
-                }
+          });
+          const newEntity = createResult.entity;
+          if (newEntity?.id) {
+            detail.entityId = newEntity.id;
+            for (const member of cluster) {
+              try {
+                await client.createMemoryRelation({
+                  source_id: member.id,
+                  target_id: newEntity.id,
+                  relation_type: "part_of",
+                  confidence: 0.8
+                });
+              } catch {}
             }
-            else {
-                result.consolidated++;
+            for (const member of cluster) {
+              try {
+                const newConf = Math.max(member.confidence - 0.3, 0.1);
+                await client.updateMemoryEntity(member.id, {
+                  confidence: newConf,
+                  metadata: {
+                    consolidated_into: newEntity.id,
+                    original_confidence: member.confidence
+                  }
+                });
+              } catch {}
             }
-            result.details.push(detail);
-        }
+            result.consolidated++;
+          }
+        } catch {}
+      } else {
+        result.consolidated++;
+      }
+      result.details.push(detail);
     }
-    return result;
+  }
+  return result;
 }
-/**
- * Synthesize cluster content by extracting unique, actionable knowledge
- * from each member entity. Skips boilerplate (headers, metadata, agent names)
- * and deduplicates similar lines across members.
- */
 function synthesizeClusterContent(cluster, type) {
-    // Lines to skip: headers, agent metadata, timestamps, progress percentages
-    const SKIP_PATTERNS = [
-        /^##\s/,
-        /^Agent:/,
-        /^Duration:/,
-        /^Labels:/,
-        /^Progress:/,
-        /^Session status:/,
-        /^Completed at/,
-        /^Final state:/,
-        /^Related:/,
-        /^When working on:/,
-        /^\d+\.\s+.+\(\d+%,\s*\+\d+%\)/, // procedure step with progress percentages
-        /^Last updated:/,
-        /^Recurring pattern:/,
-        /^Consolidated from/,
-    ];
-    const seenLines = new Set();
-    const knowledgeLines = [];
-    for (const entity of cluster) {
-        const lines = entity.content.split("\n").map((l) => l.trim());
-        for (const line of lines) {
-            if (!line || line.length < 20)
-                continue;
-            if (SKIP_PATTERNS.some((p) => p.test(line)))
-                continue;
-            // Normalize for dedup: lowercase, strip markdown formatting
-            const normalized = line
-                .toLowerCase()
-                .replace(/[*_`#[\]]/g, "")
-                .trim();
-            if (seenLines.has(normalized))
-                continue;
-            seenLines.add(normalized);
-            knowledgeLines.push(line);
-        }
-    }
-    if (knowledgeLines.length === 0) {
-        // Fallback: if no knowledge was extractable, use a compact summary
-        return `${cluster.length} related ${type} entities consolidated. Original titles:\n${cluster.map((e) => `- ${e.title}`).join("\n")}`;
+  const SKIP_PATTERNS = [
+    /^##\s/,
+    /^Agent:/,
+    /^Duration:/,
+    /^Labels:/,
+    /^Progress:/,
+    /^Session status:/,
+    /^Completed at/,
+    /^Final state:/,
+    /^Related:/,
+    /^When working on:/,
+    /^\d+\.\s+.+\(\d+%,\s*\+\d+%\)/,
+    /^Last updated:/,
+    /^Recurring pattern:/,
+    /^Consolidated from/
+  ];
+  const seenLines = new Set;
+  const knowledgeLines = [];
+  for (const entity of cluster) {
+    const lines = entity.content.split(`
+`).map((l) => l.trim());
+    for (const line of lines) {
+      if (!line || line.length < 20)
+        continue;
+      if (SKIP_PATTERNS.some((p) => p.test(line)))
+        continue;
+      const normalized = line.toLowerCase().replace(/[*_`#[\]]/g, "").trim();
+      if (seenLines.has(normalized))
+        continue;
+      seenLines.add(normalized);
+      knowledgeLines.push(line);
     }
-    // Cap at ~400 tokens worth of content (1600 chars)
-    const MAX_CHARS = 1600;
-    const result = [
-        `Consolidated knowledge from ${cluster.length} ${type} entities:\n`,
-    ];
-    let charCount = result[0].length;
-    for (const line of knowledgeLines) {
-        if (charCount + line.length + 3 > MAX_CHARS)
-            break;
-        result.push(`- ${line}`);
-        charCount += line.length + 3;
-    }
-    return result.join("\n");
+  }
+  if (knowledgeLines.length === 0) {
+    return `${cluster.length} related ${type} entities consolidated. Original titles:
+${cluster.map((e) => `- ${e.title}`).join(`
+`)}`;
+  }
+  const MAX_CHARS = 1600;
+  const result = [
+    `Consolidated knowledge from ${cluster.length} ${type} entities:
+`
+  ];
+  let charCount = result[0].length;
+  for (const line of knowledgeLines) {
+    if (charCount + line.length + 3 > MAX_CHARS)
+      break;
+    result.push(`- ${line}`);
+    charCount += line.length + 3;
+  }
+  return result.join(`
+`);
 }
-/**
- * Derive a cluster title from the most common meaningful words across member titles.
- */
 function deriveClusterTitle(cluster, type) {
-    const stopWords = new Set([
-        "the",
-        "a",
-        "an",
-        "is",
-        "are",
-        "was",
-        "were",
-        "be",
-        "been",
-        "being",
-        "have",
-        "has",
-        "had",
-        "do",
-        "does",
-        "did",
-        "will",
-        "shall",
-        "would",
-        "should",
-        "may",
-        "might",
-        "can",
-        "could",
-        "of",
-        "in",
-        "to",
-        "for",
-        "with",
-        "on",
-        "at",
-        "from",
-        "by",
-        "and",
-        "or",
-        "but",
-        "not",
-        "session",
-        "blocker",
-        "pattern",
-        "solution",
-        "error",
-        "task",
-        "mid-session",
-    ]);
-    const wordCounts = new Map();
-    for (const entity of cluster) {
-        const words = entity.title
-            .toLowerCase()
-            .split(/\W+/)
-            .filter((w) => w.length > 2 && !stopWords.has(w));
-        for (const word of words) {
-            wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
-        }
+  const stopWords = new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "shall",
+    "would",
+    "should",
+    "may",
+    "might",
+    "can",
+    "could",
+    "of",
+    "in",
+    "to",
+    "for",
+    "with",
+    "on",
+    "at",
+    "from",
+    "by",
+    "and",
+    "or",
+    "but",
+    "not",
+    "session",
+    "blocker",
+    "pattern",
+    "solution",
+    "error",
+    "task",
+    "mid-session"
+  ]);
+  const wordCounts = new Map;
+  for (const entity of cluster) {
+    const words = entity.title.toLowerCase().split(/\W+/).filter((w) => w.length > 2 && !stopWords.has(w));
+    for (const word of words) {
+      wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
     }
-    // Sort by frequency, take top 4 for more descriptive titles
-    const topWords = [...wordCounts.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 4)
-        .map(([word]) => word[0].toUpperCase() + word.slice(1));
-    const suffix = topWords.length > 0 ? topWords.join(" / ") : "Various";
-    return `${type[0].toUpperCase() + type.slice(1)}: ${suffix}`;
+  }
+  const topWords = [...wordCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4).map(([word]) => word[0].toUpperCase() + word.slice(1));
+  const suffix = topWords.length > 0 ? topWords.join(" / ") : "Various";
+  return `${type[0].toUpperCase() + type.slice(1)}: ${suffix}`;
 }
+export {
+  consolidateMemories
+};