@usewhisper/mcp-server 0.1.0 → 0.3.0

package/dist/chunk-B3VWOHUA.js

@@ -0,0 +1,271 @@
+import {
+  buildRelationGraph,
+  calculateTemporalRelevance,
+  parseTemporalQuery
+} from "./chunk-5KIJNY6Z.js";
+import {
+  db,
+  embedSingle
+} from "./chunk-3WGYBAYR.js";
+
+// ../src/engine/memory/search.ts
+async function searchMemories(params) {
+  const {
+    query,
+    questionDate,
+    userId,
+    projectId,
+    orgId,
+    sessionId,
+    topK = 10,
+    includeInactive = false,
+    memoryTypes
+  } = params;
+  const temporal = params.temporalFilter || await parseTemporalQuery(query, questionDate);
+  const queryEmbedding = await embedSingle(query);
+  const semanticResults = await vectorSearchMemories({
+    embedding: queryEmbedding,
+    userId,
+    projectId,
+    orgId,
+    sessionId,
+    temporal,
+    includeInactive,
+    memoryTypes,
+    limit: topK * 3
+    // Get more for reranking
+  });
+  if (semanticResults.length === 0) {
+    return [];
+  }
+  const enriched = await enrichWithRelations(semanticResults, topK * 2);
+  const scored = enriched.map((memory) => ({
+    ...memory,
+    temporalScore: memory.documentDate ? calculateTemporalRelevance(memory.documentDate, questionDate) : 0.5
+  }));
+  const combined = scored.map((m) => ({
+    ...m,
+    finalScore: m.similarity * 0.7 + m.temporalScore * 0.3
+  }));
+  combined.sort((a, b) => b.finalScore - a.finalScore);
+  const topMemories = combined.slice(0, topK);
+  const results = await injectSourceChunks(topMemories);
+  return results;
+}
+async function vectorSearchMemories(params) {
+  const {
+    embedding,
+    userId,
+    projectId,
+    orgId,
+    sessionId,
+    temporal,
+    includeInactive,
+    memoryTypes,
+    limit
+  } = params;
+  const whereConditions = [
+    { projectId }
+  ];
+  if (orgId) {
+    whereConditions.push({ orgId });
+  }
+  if (userId) {
+    whereConditions.push({ userId });
+  }
+  if (sessionId) {
+    whereConditions.push({ sessionId });
+  }
+  if (!includeInactive) {
+    whereConditions.push({ isActive: true });
+  }
+  whereConditions.push({
+    OR: [
+      { validUntil: null },
+      { validUntil: { gt: /* @__PURE__ */ new Date() } }
+    ]
+  });
+  if (memoryTypes && memoryTypes.length > 0) {
+    whereConditions.push({
+      memoryType: { in: memoryTypes }
+    });
+  }
+  if (temporal.hasTemporalConstraint && temporal.dateRange) {
+    whereConditions.push({
+      documentDate: {
+        gte: temporal.dateRange.start,
+        lte: temporal.dateRange.end
+      }
+    });
+  }
+  const embeddingStr = `[${embedding.join(",")}]`;
+  const results = await db.$queryRaw`
+    SELECT
+      id,
+      content,
+      "memoryType",
+      "entityMentions",
+      confidence,
+      version,
+      "documentDate",
+      "eventDate",
+      "validFrom",
+      "validUntil",
+      "sourceChunkId",
+      metadata,
+      1 - (embedding <=> ${embeddingStr}::vector) as similarity
+    FROM memories
+    WHERE
+      "projectId" = ${projectId}
+      ${orgId ? db.$queryRaw`AND "orgId" = ${orgId}` : db.$queryRaw``}
+      ${userId ? db.$queryRaw`AND "userId" = ${userId}` : db.$queryRaw``}
+      ${sessionId ? db.$queryRaw`AND "sessionId" = ${sessionId}` : db.$queryRaw``}
+      ${!includeInactive ? db.$queryRaw`AND "isActive" = true` : db.$queryRaw``}
+      AND ("validUntil" IS NULL OR "validUntil" > NOW())
+      ${memoryTypes && memoryTypes.length > 0 ? db.$queryRaw`AND "memoryType" = ANY(${memoryTypes})` : db.$queryRaw``}
+      ${temporal.hasTemporalConstraint && temporal.dateRange ? db.$queryRaw`AND "documentDate" >= ${temporal.dateRange.start} AND "documentDate" <= ${temporal.dateRange.end}` : db.$queryRaw``}
+    ORDER BY similarity DESC
+    LIMIT ${limit}
+  `;
+  return results;
+}
+async function enrichWithRelations(memories, maxTotal) {
+  if (memories.length === 0) {
+    return [];
+  }
+  const memoryIds = memories.map((m) => m.id);
+  const relations = await db.memoryRelation.findMany({
+    where: {
+      OR: [
+        { fromMemoryId: { in: memoryIds } },
+        { toMemoryId: { in: memoryIds } }
+      ]
+    }
+  });
+  if (relations.length === 0) {
+    return memories;
+  }
+  const graph = buildRelationGraph(relations);
+  const relatedIds = /* @__PURE__ */ new Set();
+  for (const memory of memories) {
+    const neighbors = graph.get(memory.id) || [];
+    for (const neighbor of neighbors.slice(0, 3)) {
+      relatedIds.add(neighbor.memoryId);
+    }
+  }
+  memoryIds.forEach((id) => relatedIds.delete(id));
+  if (relatedIds.size === 0) {
+    return memories;
+  }
+  const related = await db.memory.findMany({
+    where: {
+      id: { in: Array.from(relatedIds) },
+      isActive: true
+    },
+    take: maxTotal - memories.length
+  });
+  const relatedWithScores = related.map((m) => ({
+    ...m,
+    similarity: 0.6,
+    // Lower score for related but not directly matched
+    isRelated: true
+  }));
+  return [...memories, ...relatedWithScores];
+}
+async function injectSourceChunks(memories) {
+  const chunkIds = memories.map((m) => m.sourceChunkId).filter((id) => id !== null);
+  if (chunkIds.length === 0) {
+    return memories.map((m) => ({
+      memory: {
+        id: m.id,
+        content: m.content,
+        memoryType: m.memoryType,
+        entityMentions: m.entityMentions || [],
+        confidence: m.confidence,
+        version: m.version,
+        temporal: {
+          documentDate: m.documentDate,
+          eventDate: m.eventDate,
+          validFrom: m.validFrom,
+          validUntil: m.validUntil
+        }
+      },
+      similarity: m.similarity
+    }));
+  }
+  const chunks = await db.chunk.findMany({
+    where: {
+      id: { in: chunkIds }
+    },
+    select: {
+      id: true,
+      content: true,
+      metadata: true
+    }
+  });
+  const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+  return memories.map((m) => ({
+    memory: {
+      id: m.id,
+      content: m.content,
+      memoryType: m.memoryType,
+      entityMentions: m.entityMentions || [],
+      confidence: m.confidence,
+      version: m.version,
+      temporal: {
+        documentDate: m.documentDate,
+        eventDate: m.eventDate,
+        validFrom: m.validFrom,
+        validUntil: m.validUntil
+      }
+    },
+    chunk: m.sourceChunkId && chunkMap.has(m.sourceChunkId) ? {
+      id: chunkMap.get(m.sourceChunkId).id,
+      content: chunkMap.get(m.sourceChunkId).content,
+      metadata: chunkMap.get(m.sourceChunkId).metadata
+    } : void 0,
+    similarity: m.similarity,
+    relations: m.isRelated ? [] : void 0
+  }));
+}
+async function getSessionMemories(params) {
+  const { sessionId, projectId, limit = 50, sinceDate } = params;
+  const where = {
+    sessionId,
+    projectId,
+    isActive: true
+  };
+  if (sinceDate) {
+    where.createdAt = { gte: sinceDate };
+  }
+  return db.memory.findMany({
+    where,
+    orderBy: {
+      createdAt: "desc"
+    },
+    take: limit
+  });
+}
+async function getUserProfile(params) {
+  const { userId, projectId, memoryTypes, limit = 50 } = params;
+  const where = {
+    userId,
+    projectId,
+    isActive: true,
+    scope: "USER"
+  };
+  if (memoryTypes) {
+    where.memoryType = { in: memoryTypes };
+  }
+  return db.memory.findMany({
+    where,
+    orderBy: { importance: "desc" },
+    take: Math.min(limit, 100)
+  });
+}
+
+export {
+  searchMemories,
+  getSessionMemories,
+  getUserProfile
+};