@usewhisper/mcp-server 0.2.3 → 0.3.0

package/dist/chunk-52VJYCZ7.js

@@ -0,0 +1,455 @@
+import {
+  detectRelations,
+  extractEventDate,
+  shouldInvalidateMemory
+} from "./chunk-LMEYV4JD.js";
+import {
+  db,
+  embedSingle
+} from "./chunk-3WGYBAYR.js";
+
+// ../src/engine/memory/extractor.ts
+import OpenAI from "openai";
+var openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY || ""
+});
+var EXTRACTION_PROMPT = `You are an expert memory extraction system. Your job is to extract atomic, unambiguous memories from conversation chunks.
+
+**Critical Rules:**
+1. Each memory must be a SINGLE fact/preference/event/relationship
+2. Resolve ALL pronouns (he/she/it/they/them) to actual names using context
+3. Resolve ALL ambiguous references ("the company", "that project") to specific entities
+4. Extract temporal information when events occurred (not when mentioned)
+5. Be conservative - only extract high-confidence memories
+
+**Memory Types:**
+- factual: Objective facts ("John works at Google")
+- preference: User preferences ("Sarah prefers dark mode")
+- event: Events with timestamps ("Team met on Jan 15, 2024")
+- relationship: Relationships ("Alex reports to Maria")
+- opinion: Subjective views ("User thinks Python is easier than Rust")
+- goal: Future intentions ("User wants to learn machine learning")
+- instruction: Persistent instructions ("Always use formal tone with clients")
+
+**Disambiguation:**
+- Replace "he" \u2192 actual name using context
+- Replace "she" \u2192 actual name using context
+- Replace "it" \u2192 specific thing using context
+- Replace "the company" \u2192 company name
+- Replace "that project" \u2192 project name
+
+**Example:**
+Input: "He said he prefers using React. The project will launch next week."
+Context: Previous message: "Alex joined the team yesterday. He's working on the dashboard project."
+
+Bad Output:
+- "He prefers React" \u274C (ambiguous)
+- "The project launches next week" \u274C (what project?)
+
+Good Output:
+- content: "Alex prefers using React for development"
+  type: preference
+  entities: ["Alex", "React"]
+  eventDate: null
+
+- content: "Dashboard project launch scheduled for [specific date if mentioned]"
+  type: event
+  entities: ["Dashboard project"]
+  eventDate: [calculated date] or null if not specific`;
+async function extractMemories(chunk, context) {
+  const contextStr = buildContextString(context);
+  const prompt = `${EXTRACTION_PROMPT}
+
+${contextStr}
+
+**Current chunk to analyze:**
+${chunk}
+
+**Document Date (when this was said):** ${context.documentDate.toISOString()}
+
+Extract memories and return a JSON array. For each memory:
+{
+  "content": "clear, unambiguous statement with no pronouns",
+  "memoryType": "factual|preference|event|relationship|opinion|goal|instruction",
+  "entityMentions": ["list", "of", "entities", "mentioned"],
+  "eventDate": "ISO date string or null",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation of extraction"
+}
+
+Return ONLY the JSON array, no other text.`;
+  try {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4o",
+      max_tokens: 4096,
+      temperature: 0,
+      // Deterministic for extraction
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ],
+      response_format: { type: "json_object" }
+    });
+    const text = response.choices[0]?.message?.content?.trim();
+    if (!text) {
+      throw new Error("No text response from OpenAI");
+    }
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\[[\s\S]*\]/);
+    const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+    const rawMemories = JSON.parse(jsonStr);
+    if (!Array.isArray(rawMemories)) {
+      console.error("Expected array of memories, got:", rawMemories);
+      return [];
+    }
+    return rawMemories.map((m) => ({
+      content: m.content,
+      memoryType: m.memoryType,
+      entityMentions: m.entityMentions || [],
+      eventDate: m.eventDate ? new Date(m.eventDate) : null,
+      confidence: m.confidence || 0.7,
+      reasoning: m.reasoning
+    }));
+  } catch (error) {
+    console.error("Memory extraction failed:", error);
+    return [];
+  }
+}
+function buildContextString(context) {
+  const parts = [];
+  if (context.previousMessages && context.previousMessages.length > 0) {
+    parts.push("**Context from previous messages:**");
+    parts.push(context.previousMessages.slice(-5).join("\n"));
+  }
+  if (context.entityContext && context.entityContext.size > 0) {
+    parts.push("\n**Known entities:**");
+    context.entityContext.forEach((name, pronoun) => {
+      parts.push(`- "${pronoun}" refers to ${name}`);
+    });
+  }
+  if (parts.length === 0) {
+    return "**Context:** None available";
+  }
+  return parts.join("\n");
+}
+function buildEntityContext(recentMemories) {
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const memory of recentMemories) {
+    for (const entity of memory.entityMentions) {
+      if (/^[A-Z][a-z]+(?:\s[A-Z][a-z]+)*$/.test(entity)) {
+        entityMap.set("he", entity);
+        entityMap.set("she", entity);
+        entityMap.set("they", entity);
+      }
+    }
+  }
+  return entityMap;
+}
+function validateMemory(memory) {
+  if (memory.confidence < 0.6) {
+    return false;
+  }
+  if (memory.content.length < 10) {
+    return false;
+  }
+  const pronouns = /\b(he|she|it|they|them|his|her|their)\b/i;
+  if (pronouns.test(memory.content)) {
+    console.warn("Memory contains unresolved pronouns:", memory.content);
+    return false;
+  }
+  const vagueRefs = /\b(the company|that project|this thing|the system)\b/i;
+  if (vagueRefs.test(memory.content)) {
+    console.warn("Memory contains vague references:", memory.content);
+    return false;
+  }
+  return true;
+}
+
+// ../src/engine/memory/ingest.ts
+async function ingestSession(params) {
+  const { sessionId, projectId, orgId, userId, messages } = params;
+  const result = {
+    memoriesCreated: 0,
+    relationsCreated: 0,
+    memoriesInvalidated: 0,
+    errors: []
+  };
+  if (messages.length === 0) {
+    return result;
+  }
+  try {
+    const context = {
+      sessionId,
+      userId: userId || "unknown",
+      projectId,
+      orgId,
+      documentDate: messages[messages.length - 1].timestamp,
+      previousMessages: messages.slice(0, -1).map((m) => `${m.role}: ${m.content}`)
+    };
+    const recentMemories = await db.memory.findMany({
+      where: {
+        sessionId,
+        projectId,
+        isActive: true
+      },
+      orderBy: {
+        createdAt: "desc"
+      },
+      take: 20,
+      select: {
+        content: true,
+        entityMentions: true
+      }
+    });
+    context.entityContext = buildEntityContext(recentMemories);
+    const latestMessage = messages[messages.length - 1].content;
+    const extractedMemories = await extractMemories(latestMessage, context);
+    const validMemories = extractedMemories.filter(validateMemory);
+    if (validMemories.length === 0) {
+      return result;
+    }
+    const existingMemories = await db.memory.findMany({
+      where: {
+        projectId,
+        userId,
+        isActive: true
+      },
+      orderBy: {
+        createdAt: "desc"
+      },
+      take: 100,
+      // Check against last 100 memories
+      select: {
+        id: true,
+        content: true,
+        memoryType: true,
+        entityMentions: true,
+        documentDate: true
+      }
+    });
+    for (const extracted of validMemories) {
+      try {
+        const relations = await detectRelations(
+          {
+            content: extracted.content,
+            memoryType: extracted.memoryType,
+            entityMentions: extracted.entityMentions
+          },
+          existingMemories
+        );
+        const eventDate = extracted.eventDate || await extractEventDate(
+          extracted.content,
+          context.documentDate
+        );
+        const embedding = await embedSingle(extracted.content);
+        const embeddingStr = `[${embedding.join(",")}]`;
+        const [memory] = await db.$queryRaw`
+          INSERT INTO "memories" (
+            id, "projectId", "orgId", "userId", "sessionId", "memoryType", 
+            content, embedding, "entityMentions", confidence, "documentDate", 
+            "eventDate", "validFrom", metadata, "createdAt", "updatedAt"
+          )
+          VALUES (
+            gen_random_uuid(), ${projectId}, ${orgId || null}, ${userId || null}, 
+            ${sessionId}, ${extracted.memoryType}, ${extracted.content}, 
+            ${embeddingStr}::vector, ${extracted.entityMentions}, ${extracted.confidence}, 
+            ${context.documentDate}, ${eventDate}, NOW(), 
+            ${JSON.stringify({
+          reasoning: extracted.reasoning,
+          extractedFrom: "session_ingestion"
+        })}::jsonb, NOW(), NOW()
+          )
+          RETURNING *
+        `;
+        result.memoriesCreated++;
+        for (const relation of relations) {
+          try {
+            await db.memoryRelation.create({
+              data: {
+                fromMemoryId: memory.id,
+                toMemoryId: relation.toMemoryId,
+                relationType: relation.relationType,
+                confidence: relation.confidence,
+                reasoning: relation.reasoning
+              }
+            });
+            result.relationsCreated++;
+            if (shouldInvalidateMemory(relation.relationType)) {
+              await db.memory.update({
+                where: { id: relation.toMemoryId },
+                data: {
+                  validUntil: /* @__PURE__ */ new Date(),
+                  supersededBy: memory.id
+                }
+              });
+              const oldMemory = await db.memory.findUnique({
+                where: { id: relation.toMemoryId },
+                select: { version: true }
+              });
+              if (oldMemory) {
+                await db.memory.update({
+                  where: { id: memory.id },
+                  data: { version: oldMemory.version + 1 }
+                });
+              }
+              result.memoriesInvalidated++;
+            }
+          } catch (error) {
+            result.errors.push(`Failed to create relation: ${error}`);
+          }
+        }
+      } catch (error) {
+        result.errors.push(`Failed to process memory: ${error}`);
+      }
+    }
+    return result;
+  } catch (error) {
+    result.errors.push(`Ingestion failed: ${error}`);
+    return result;
+  }
+}
+async function ingestChunk(params) {
+  const { chunkId, chunkContent, projectId, orgId, documentDate, metadata } = params;
+  const result = {
+    memoriesCreated: 0,
+    relationsCreated: 0,
+    memoriesInvalidated: 0,
+    errors: []
+  };
+  try {
+    const context = {
+      sessionId: `chunk_${chunkId}`,
+      userId: "system",
+      projectId,
+      orgId,
+      documentDate
+    };
+    const extractedMemories = await extractMemories(chunkContent, context);
+    const validMemories = extractedMemories.filter(validateMemory);
+    for (const extracted of validMemories) {
+      const eventDate = extracted.eventDate || await extractEventDate(
+        extracted.content,
+        documentDate
+      );
+      const embedding = await embedSingle(extracted.content);
+      await db.memory.create({
+        data: {
+          projectId,
+          orgId,
+          memoryType: extracted.memoryType,
+          content: extracted.content,
+          embedding,
+          entityMentions: extracted.entityMentions,
+          confidence: extracted.confidence,
+          documentDate,
+          eventDate,
+          validFrom: /* @__PURE__ */ new Date(),
+          sourceChunkId: chunkId,
+          scope: "DOCUMENT",
+          // Document-level scope
+          metadata: {
+            ...metadata,
+            reasoning: extracted.reasoning
+          }
+        }
+      });
+      result.memoriesCreated++;
+    }
+    return result;
+  } catch (error) {
+    result.errors.push(`Chunk ingestion failed: ${error}`);
+    return result;
+  }
+}
+async function ingestChunksBatch(params) {
+  const { chunks, projectId, orgId, documentDate } = params;
+  const aggregateResult = {
+    memoriesCreated: 0,
+    relationsCreated: 0,
+    memoriesInvalidated: 0,
+    errors: []
+  };
+  const batchSize = 10;
+  for (let i = 0; i < chunks.length; i += batchSize) {
+    const batch = chunks.slice(i, i + batchSize);
+    const results = await Promise.all(
+      batch.map(
+        (chunk) => ingestChunk({
+          chunkId: chunk.id,
+          chunkContent: chunk.content,
+          projectId,
+          orgId,
+          documentDate,
+          metadata: chunk.metadata
+        })
+      )
+    );
+    for (const result of results) {
+      aggregateResult.memoriesCreated += result.memoriesCreated;
+      aggregateResult.relationsCreated += result.relationsCreated;
+      aggregateResult.memoriesInvalidated += result.memoriesInvalidated;
+      aggregateResult.errors.push(...result.errors);
+    }
+  }
+  return aggregateResult;
+}
+async function updateMemory(params) {
+  const { memoryId, newContent, reasoning } = params;
+  const oldMemory = await db.memory.findUnique({
+    where: { id: memoryId }
+  });
+  if (!oldMemory) {
+    throw new Error("Memory not found");
+  }
+  const embedding = await embedSingle(newContent);
+  const newMemory = await db.memory.create({
+    data: {
+      projectId: oldMemory.projectId,
+      orgId: oldMemory.orgId,
+      userId: oldMemory.userId,
+      sessionId: oldMemory.sessionId,
+      memoryType: oldMemory.memoryType,
+      content: newContent,
+      embedding,
+      entityMentions: oldMemory.entityMentions,
+      confidence: oldMemory.confidence,
+      documentDate: oldMemory.documentDate,
+      eventDate: oldMemory.eventDate,
+      validFrom: /* @__PURE__ */ new Date(),
+      version: oldMemory.version + 1,
+      scope: oldMemory.scope,
+      metadata: {
+        ...oldMemory.metadata,
+        updateReasoning: reasoning
+      }
+    }
+  });
+  await db.memory.update({
+    where: { id: memoryId },
+    data: {
+      validUntil: /* @__PURE__ */ new Date(),
+      supersededBy: newMemory.id
+    }
+  });
+  await db.memoryRelation.create({
+    data: {
+      fromMemoryId: newMemory.id,
+      toMemoryId: memoryId,
+      relationType: "updates",
+      confidence: 1,
+      reasoning: reasoning || "Manual update"
+    }
+  });
+  return {
+    newMemoryId: newMemory.id,
+    oldMemoryId: memoryId
+  };
+}
+
+export {
+  ingestSession,
+  ingestChunk,
+  ingestChunksBatch,
+  updateMemory
+};

package/dist/chunk-5KBZQHDL.js

@@ -0,0 +1,189 @@
+// ../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) {
+  if (!memoryDate) return 0.5;
+  const memDate = typeof memoryDate === "string" ? new Date(memoryDate) : memoryDate;
+  if (!(memDate instanceof Date) || isNaN(memDate.getTime())) {
+    return 0.5;
+  }
+  const daysDiff = Math.abs(
+    (questionDate.getTime() - memDate.getTime()) / (1e3 * 60 * 60 * 24)
+  );
+  const score = Math.exp(-decayFactor * daysDiff);
+  return score;
+}
+
+export {
+  parseTemporalQuery,
+  extractEventDate,
+  calculateTemporalRelevance
+};