@usewhisper/mcp-server 0.3.0 → 0.5.0

package/dist/chunk-LMEYV4JD.js

@@ -1,368 +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
-};
+// ../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
+};