@gethmy/mcp 2.3.2 → 2.3.3

package/dist/lib/consolidation.js

@@ -1,388 +0,0 @@
-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: 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 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);
-          }
-        }
-      }
-    }
-    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()
-            }
-          });
-          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 {}
-            }
-            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.consolidated++;
-          }
-        } catch {}
-      } else {
-        result.consolidated++;
-      }
-      result.details.push(detail);
-    }
-  }
-  return result;
-}
-function synthesizeClusterContent(cluster, type) {
-  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);
-    }
-  }
-  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(`
-`);
-}
-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 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
-};