@usewhisper/mcp-server 0.2.3 → 0.4.0

package/dist/chunk-LMEYV4JD.js

@@ -0,0 +1,368 @@
+// ../src/engine/memory/temporal.ts
+import OpenAI from "openai";
+var openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY || ""
+});
+var TEMPORAL_PARSING_PROMPT = `You are an expert temporal query parser. Extract temporal constraints from user queries.
+
+**Your job:**
+1. Identify if the query has temporal constraints
+2. Extract relative time references (today, yesterday, last week, etc.)
+3. Extract absolute dates if mentioned
+4. Calculate date ranges if applicable
+
+**Relative Terms:**
+- "today" \u2192 filter to documentDate = questionDate
+- "yesterday" \u2192 documentDate = questionDate - 1 day
+- "last week" \u2192 documentDate in range [questionDate - 7 days, questionDate]
+- "last month" \u2192 documentDate in range [questionDate - 30 days, questionDate]
+- "last year" \u2192 documentDate in range [questionDate - 365 days, questionDate]
+- "this week" \u2192 current week
+- "this month" \u2192 current month
+
+**Examples:**
+- "What did I say about vacation yesterday?" \u2192 relative: "yesterday"
+- "Tell me about meetings last week" \u2192 relative: "last_week"
+- "What happened on January 15?" \u2192 absoluteDate: "2024-01-15"
+- "Show me everything from last month" \u2192 relative: "last_month"
+- "What's my favorite color?" \u2192 no temporal constraint`;
+async function parseTemporalQuery(query, questionDate) {
+  const prompt = `${TEMPORAL_PARSING_PROMPT}
+
+**Query:** "${query}"
+**Question asked on:** ${questionDate.toISOString()}
+
+Extract temporal information and return JSON:
+{
+  "hasTemporalConstraint": boolean,
+  "relative": "today|yesterday|last_week|last_month|last_year|this_week|this_month|null",
+  "absoluteDate": "ISO date string or null",
+  "dateRange": { "start": "ISO", "end": "ISO" } or null
+}
+
+Return ONLY the JSON, no other text.`;
+  try {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      // Faster model for parsing
+      max_tokens: 512,
+      temperature: 0,
+      messages: [{ role: "user", content: prompt }],
+      response_format: { type: "json_object" }
+    });
+    const text = response.choices[0]?.message?.content?.trim();
+    if (!text) {
+      return { hasTemporalConstraint: false };
+    }
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\{[\s\S]*\}/);
+    const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+    const parsed = JSON.parse(jsonStr);
+    if (parsed.relative) {
+      const range = calculateRelativeDateRange(parsed.relative, questionDate);
+      parsed.dateRange = range;
+      parsed.absoluteDate = range.start;
+    } else if (parsed.absoluteDate) {
+      parsed.absoluteDate = new Date(parsed.absoluteDate);
+    }
+    if (parsed.dateRange) {
+      parsed.dateRange = {
+        start: new Date(parsed.dateRange.start),
+        end: new Date(parsed.dateRange.end)
+      };
+    }
+    return parsed;
+  } catch (error) {
+    console.error("Temporal parsing failed:", error);
+    return { hasTemporalConstraint: false };
+  }
+}
+function calculateRelativeDateRange(relative, from) {
+  const start = new Date(from);
+  const end = new Date(from);
+  switch (relative) {
+    case "today":
+      start.setHours(0, 0, 0, 0);
+      end.setHours(23, 59, 59, 999);
+      break;
+    case "yesterday":
+      start.setDate(start.getDate() - 1);
+      start.setHours(0, 0, 0, 0);
+      end.setDate(end.getDate() - 1);
+      end.setHours(23, 59, 59, 999);
+      break;
+    case "last_week":
+      start.setDate(start.getDate() - 7);
+      start.setHours(0, 0, 0, 0);
+      end.setHours(23, 59, 59, 999);
+      break;
+    case "this_week":
+      const dayOfWeek = start.getDay();
+      const diff = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
+      start.setDate(start.getDate() + diff);
+      start.setHours(0, 0, 0, 0);
+      end.setHours(23, 59, 59, 999);
+      break;
+    case "last_month":
+      start.setDate(start.getDate() - 30);
+      start.setHours(0, 0, 0, 0);
+      end.setHours(23, 59, 59, 999);
+      break;
+    case "this_month":
+      start.setDate(1);
+      start.setHours(0, 0, 0, 0);
+      end.setHours(23, 59, 59, 999);
+      break;
+    case "last_year":
+      start.setFullYear(start.getFullYear() - 1);
+      start.setHours(0, 0, 0, 0);
+      end.setHours(23, 59, 59, 999);
+      break;
+    default:
+      start.setFullYear(1970);
+      end.setFullYear(2100);
+  }
+  return { start, end };
+}
+async function extractEventDate(memoryContent, documentDate) {
+  const prompt = `Extract the event date from this memory.
+
+**Important distinction:**
+- documentDate: When this was said/written
+- eventDate: When the event actually occurred/will occur
+
+**Memory:** "${memoryContent}"
+**Document Date (when this was said):** ${documentDate.toISOString()}
+
+**Examples:**
+- "User said they have a meeting tomorrow" \u2192 eventDate = documentDate + 1 day
+- "User attended conference on Jan 15" \u2192 eventDate = Jan 15 of appropriate year
+- "User's favorite color is blue" \u2192 eventDate = null (no event, just a fact)
+- "Meeting happened yesterday" \u2192 eventDate = documentDate - 1 day
+
+Return JSON:
+{
+  "hasEvent": boolean,
+  "eventDate": "ISO date string or null",
+  "reasoning": "brief explanation"
+}`;
+  try {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      max_tokens: 256,
+      temperature: 0,
+      messages: [{ role: "user", content: prompt }],
+      response_format: { type: "json_object" }
+    });
+    const text = response.choices[0]?.message?.content?.trim();
+    if (!text) {
+      return null;
+    }
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\{[\s\S]*\}/);
+    const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+    const result = JSON.parse(jsonStr);
+    if (result.hasEvent && result.eventDate) {
+      return new Date(result.eventDate);
+    }
+    return null;
+  } catch (error) {
+    console.error("Event date extraction failed:", error);
+    return null;
+  }
+}
+function calculateTemporalRelevance(memoryDate, questionDate, decayFactor = 0.1) {
+  const daysDiff = Math.abs(
+    (questionDate.getTime() - memoryDate.getTime()) / (1e3 * 60 * 60 * 24)
+  );
+  const score = Math.exp(-decayFactor * daysDiff);
+  return score;
+}
+
+// ../src/engine/memory/relations.ts
+import OpenAI2 from "openai";
+var openai2 = new OpenAI2({
+  apiKey: process.env.OPENAI_API_KEY || ""
+});
+var RELATION_DETECTION_PROMPT = `You are an expert at detecting relationships between memories in a knowledge graph.
+
+**Relation Types:**
+
+1. **updates** - New memory supersedes/replaces old memory (state mutation)
+   Example:
+   - Old: "User's favorite color is blue"
+   - New: "User's favorite color is green"
+   - Relation: updates (green replaces blue)
+
+2. **extends** - New memory adds detail to existing memory without contradiction (refinement)
+   Example:
+   - Old: "John works at Google"
+   - New: "John works at Google as a Senior Engineer"
+   - Relation: extends (adds job title)
+
+3. **derives** - New memory is inferred from existing memory/memories (inference)
+   Example:
+   - Memory 1: "User prefers dark mode"
+   - Memory 2: "User prefers high contrast"
+   - New: "User likely has vision preferences for accessibility"
+   - Relation: derives (inferred from both)
+
+4. **contradicts** - New memory conflicts with existing memory (conflict detection)
+   Example:
+   - Old: "Meeting scheduled for 3pm"
+   - New: "Meeting scheduled for 4pm"
+   - Relation: contradicts (should trigger update)
+
+5. **supports** - New memory provides evidence/support for existing memory
+   Example:
+   - Memory 1: "User is interested in ML"
+   - New: "User enrolled in ML course"
+   - Relation: supports (confirms interest)
+
+**Important:**
+- Only detect relations when there's a clear, meaningful connection
+- Be conservative - if unsure, don't create a relation
+- "updates" should invalidate the old memory (set validUntil)
+- "extends" keeps the old memory valid but adds information
+- "contradicts" should flag for review/resolution`;
+async function detectRelations(newMemory, existingMemories) {
+  if (existingMemories.length === 0) {
+    return [];
+  }
+  const relevantMemories = filterRelevantMemories(newMemory, existingMemories);
+  if (relevantMemories.length === 0) {
+    return [];
+  }
+  const prompt = `${RELATION_DETECTION_PROMPT}
+
+**New memory:**
+"${newMemory.content}"
+Type: ${newMemory.memoryType}
+Entities: ${newMemory.entityMentions.join(", ")}
+
+**Existing memories to check against:**
+${relevantMemories.map((m, i) => `${i}. "${m.content}" (Type: ${m.memoryType}, Date: ${m.documentDate?.toISOString() || "unknown"})`).join("\n")}
+
+Analyze if the new memory relates to any existing memories.
+
+Return a JSON array of relations:
+[{
+  "toMemoryIndex": 0,
+  "relationType": "updates|extends|derives|contradicts|supports",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation why this relation exists"
+}]
+
+Return ONLY the JSON array. If no relations found, return [].`;
+  try {
+    const response = await openai2.chat.completions.create({
+      model: "gpt-4o",
+      max_tokens: 2048,
+      temperature: 0,
+      messages: [{ role: "user", content: prompt }],
+      response_format: { type: "json_object" }
+    });
+    const text = response.choices[0]?.message?.content?.trim();
+    if (!text) {
+      return [];
+    }
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\[[\s\S]*\]/);
+    const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+    const relations = JSON.parse(jsonStr);
+    if (!Array.isArray(relations)) {
+      return [];
+    }
+    return relations.filter((r) => r.confidence >= 0.7).map((r) => ({
+      toMemoryId: relevantMemories[r.toMemoryIndex].id,
+      relationType: r.relationType,
+      confidence: r.confidence,
+      reasoning: r.reasoning
+    }));
+  } catch (error) {
+    console.error("Relation detection failed:", error);
+    return [];
+  }
+}
+function filterRelevantMemories(newMemory, existingMemories) {
+  return existingMemories.filter((existing) => {
+    const sharedEntities = newMemory.entityMentions.some(
+      (entity) => existing.entityMentions.includes(entity)
+    );
+    if (sharedEntities) {
+      return true;
+    }
+    const newWords = extractKeywords(newMemory.content);
+    const existingWords = extractKeywords(existing.content);
+    const overlap = newWords.filter((w) => existingWords.includes(w));
+    return overlap.length >= 2;
+  });
+}
+function extractKeywords(text) {
+  const stopWords = /* @__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",
+    "can",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "at",
+    "by",
+    "from",
+    "with",
+    "about"
+  ]);
+  return text.toLowerCase().split(/\W+/).filter((word) => word.length > 3 && !stopWords.has(word)).slice(0, 10);
+}
+function shouldInvalidateMemory(relationType) {
+  return relationType === "updates" || relationType === "contradicts";
+}
+function buildRelationGraph(relations) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const relation of relations) {
+    if (!graph.has(relation.fromMemoryId)) {
+      graph.set(relation.fromMemoryId, []);
+    }
+    graph.get(relation.fromMemoryId).push({
+      memoryId: relation.toMemoryId,
+      relationType: relation.relationType
+    });
+    if (!graph.has(relation.toMemoryId)) {
+      graph.set(relation.toMemoryId, []);
+    }
+    graph.get(relation.toMemoryId).push({
+      memoryId: relation.fromMemoryId,
+      relationType: `inverse_${relation.relationType}`
+    });
+  }
+  return graph;
+}
+
+export {
+  parseTemporalQuery,
+  extractEventDate,
+  calculateTemporalRelevance,
+  detectRelations,
+  shouldInvalidateMemory,
+  buildRelationGraph
+};