@usewhisper/mcp-server 0.1.0 → 0.3.0

package/dist/consolidation-2GCKI4RE.js

@@ -0,0 +1,220 @@
+import {
+  db,
+  embedSingle
+} from "./chunk-MEFLJ4PV.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../src/engine/memory/consolidation.ts
+import OpenAI from "openai";
+var openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY || ""
+});
+async function findDuplicateMemories(params) {
+  const {
+    projectId,
+    userId,
+    similarityThreshold = 0.95,
+    limit = 50
+  } = params;
+  const maxMemories = Math.min(Math.max(limit, 10), 100);
+  const memories = await db.memory.findMany({
+    where: {
+      projectId,
+      userId,
+      isActive: true,
+      validUntil: null
+    },
+    orderBy: { importance: "desc" },
+    take: maxMemories
+  });
+  const clusters = [];
+  const processed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < memories.length; i++) {
+    const memory = memories[i];
+    if (processed.has(memory.id)) continue;
+    const similar = [];
+    const candidates = memories.slice(i + 1);
+    const batchSimilarities = await calculateBatchSimilarity(memory.id, candidates.map((c) => c.id));
+    for (let j = 0; j < candidates.length; j++) {
+      const other = candidates[j];
+      if (processed.has(other.id)) continue;
+      const similarity = batchSimilarities[j];
+      if (similarity >= similarityThreshold) {
+        similar.push({ ...other, similarity });
+        processed.add(other.id);
+      }
+    }
+    if (similar.length > 0) {
+      clusters.push({
+        representative: memory,
+        duplicates: similar,
+        similarity: similar.reduce((sum, m) => sum + m.similarity, 0) / similar.length
+      });
+      processed.add(memory.id);
+    }
+  }
+  return clusters;
+}
+async function calculateBatchSimilarity(memoryId, otherIds) {
+  if (otherIds.length === 0) return [];
+  const placeholders = otherIds.map((_, i) => `(m1.embedding <=> $${i + 2}::vector)`).join(" + ");
+  const conditions = otherIds.map((id, i) => `m2.id = $${i + 2}`).join(" OR ");
+  const result = await db.$queryRaw`
+    SELECT
+      1 - (m1.embedding <=> m2.embedding) as similarity,
+      m2.id as id
+    FROM memories m1, memories m2
+    WHERE m1.id = ${memoryId} AND (${conditions})
+  `;
+  const similarityMap = new Map(result.map((r) => [r.id, r.similarity]));
+  return otherIds.map((id) => similarityMap.get(id) || 0);
+}
+async function mergeDuplicateMemories(cluster) {
+  const memories = [cluster.representative, ...cluster.duplicates];
+  const prompt = `You are merging duplicate memories into a single, comprehensive memory.
+
+**Memories to merge:**
+${memories.map(
+    (m, i) => `${i + 1}. "${m.content}" (confidence: ${m.confidence}, date: ${m.documentDate?.toISOString() || "unknown"})`
+  ).join("\n")}
+
+**Instructions:**
+1. Combine all unique information from these memories
+2. Resolve any contradictions by keeping the most recent or most confident information
+3. Extract all unique entity mentions
+4. Use the highest confidence score
+5. Keep the most recent document date
+
+Return JSON:
+{
+  "merged_content": "comprehensive merged memory",
+  "entity_mentions": ["list", "of", "entities"],
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation of how you merged"
+}`;
+  const response = await openai.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) {
+    throw new Error("Failed to merge memories");
+  }
+  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);
+  const embedding = await embedSingle(result.merged_content);
+  const mergedMemory = await db.memory.create({
+    data: {
+      projectId: cluster.representative.projectId,
+      orgId: cluster.representative.orgId,
+      userId: cluster.representative.userId,
+      sessionId: cluster.representative.sessionId,
+      memoryType: cluster.representative.memoryType,
+      content: result.merged_content,
+      embedding,
+      entityMentions: result.entity_mentions || [],
+      confidence: result.confidence || cluster.representative.confidence,
+      documentDate: cluster.representative.documentDate,
+      eventDate: cluster.representative.eventDate,
+      validFrom: /* @__PURE__ */ new Date(),
+      importance: Math.max(...memories.map((m) => m.importance || 0.5)),
+      metadata: {
+        mergedFrom: memories.map((m) => m.id),
+        mergeReasoning: result.reasoning,
+        mergedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+  for (const memory of memories) {
+    await db.memory.update({
+      where: { id: memory.id },
+      data: {
+        isActive: false,
+        validUntil: /* @__PURE__ */ new Date(),
+        supersededBy: mergedMemory.id
+      }
+    });
+  }
+  return mergedMemory.id;
+}
+async function consolidateMemories(params) {
+  const { projectId, userId, similarityThreshold = 0.95, dryRun = false } = params;
+  console.log(`\u{1F50D} Finding duplicate memories in project ${projectId}...`);
+  const clusters = await findDuplicateMemories({
+    projectId,
+    userId,
+    similarityThreshold
+  });
+  console.log(`\u{1F4CA} Found ${clusters.length} memory clusters`);
+  if (dryRun) {
+    for (const cluster of clusters) {
+      console.log(`
+Cluster (similarity: ${cluster.similarity.toFixed(2)}):`);
+      console.log(`  Representative: "${cluster.representative.content}"`);
+      console.log(`  Duplicates: ${cluster.duplicates.length}`);
+      cluster.duplicates.forEach((d) => {
+        console.log(`    - "${d.content}"`);
+      });
+    }
+    return {
+      clustersFound: clusters.length,
+      memoriesMerged: 0,
+      memoriesDeactivated: 0
+    };
+  }
+  let memoriesMerged = 0;
+  let memoriesDeactivated = 0;
+  for (const cluster of clusters) {
+    try {
+      console.log(`\u{1F517} Merging cluster with ${cluster.duplicates.length + 1} memories...`);
+      await mergeDuplicateMemories(cluster);
+      memoriesMerged++;
+      memoriesDeactivated += cluster.duplicates.length + 1;
+      console.log(`\u2705 Merged successfully`);
+    } catch (error) {
+      console.error(`\u274C Failed to merge cluster:`, error);
+    }
+  }
+  console.log(
+    `
+\u2705 Consolidation complete: ${memoriesMerged} clusters merged, ${memoriesDeactivated} memories deactivated`
+  );
+  return {
+    clustersFound: clusters.length,
+    memoriesMerged,
+    memoriesDeactivated
+  };
+}
+async function scheduledConsolidation(orgId) {
+  console.log(`\u{1F504} Running scheduled consolidation for org ${orgId}...`);
+  const projects = await db.project.findMany({
+    where: { orgId }
+  });
+  for (const project of projects) {
+    try {
+      const result = await consolidateMemories({
+        projectId: project.id,
+        similarityThreshold: 0.92
+        // Slightly lower for scheduled runs
+      });
+      if (result.memoriesMerged > 0) {
+        console.log(
+          `\u{1F4CA} Project ${project.name}: merged ${result.memoriesMerged} clusters`
+        );
+      }
+    } catch (error) {
+      console.error(`Failed to consolidate project ${project.name}:`, error);
+    }
+  }
+  console.log("\u2705 Scheduled consolidation complete");
+}
+export {
+  consolidateMemories,
+  findDuplicateMemories,
+  mergeDuplicateMemories,
+  scheduledConsolidation
+};

package/dist/consolidation-4JOPW6BG.js

@@ -0,0 +1,220 @@
+import {
+  db,
+  embedSingle
+} from "./chunk-3WGYBAYR.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../src/engine/memory/consolidation.ts
+import OpenAI from "openai";
+var openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY || ""
+});
+async function findDuplicateMemories(params) {
+  const {
+    projectId,
+    userId,
+    similarityThreshold = 0.95,
+    limit = 50
+  } = params;
+  const maxMemories = Math.min(Math.max(limit, 10), 100);
+  const memories = await db.memory.findMany({
+    where: {
+      projectId,
+      userId,
+      isActive: true,
+      validUntil: null
+    },
+    orderBy: { importance: "desc" },
+    take: maxMemories
+  });
+  const clusters = [];
+  const processed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < memories.length; i++) {
+    const memory = memories[i];
+    if (processed.has(memory.id)) continue;
+    const similar = [];
+    const candidates = memories.slice(i + 1);
+    const batchSimilarities = await calculateBatchSimilarity(memory.id, candidates.map((c) => c.id));
+    for (let j = 0; j < candidates.length; j++) {
+      const other = candidates[j];
+      if (processed.has(other.id)) continue;
+      const similarity = batchSimilarities[j];
+      if (similarity >= similarityThreshold) {
+        similar.push({ ...other, similarity });
+        processed.add(other.id);
+      }
+    }
+    if (similar.length > 0) {
+      clusters.push({
+        representative: memory,
+        duplicates: similar,
+        similarity: similar.reduce((sum, m) => sum + m.similarity, 0) / similar.length
+      });
+      processed.add(memory.id);
+    }
+  }
+  return clusters;
+}
+async function calculateBatchSimilarity(memoryId, otherIds) {
+  if (otherIds.length === 0) return [];
+  const placeholders = otherIds.map((_, i) => `(m1.embedding <=> $${i + 2}::vector)`).join(" + ");
+  const conditions = otherIds.map((id, i) => `m2.id = $${i + 2}`).join(" OR ");
+  const result = await db.$queryRaw`
+    SELECT
+      1 - (m1.embedding <=> m2.embedding) as similarity,
+      m2.id as id
+    FROM memories m1, memories m2
+    WHERE m1.id = ${memoryId} AND (${conditions})
+  `;
+  const similarityMap = new Map(result.map((r) => [r.id, r.similarity]));
+  return otherIds.map((id) => similarityMap.get(id) || 0);
+}
+async function mergeDuplicateMemories(cluster) {
+  const memories = [cluster.representative, ...cluster.duplicates];
+  const prompt = `You are merging duplicate memories into a single, comprehensive memory.
+
+**Memories to merge:**
+${memories.map(
+    (m, i) => `${i + 1}. "${m.content}" (confidence: ${m.confidence}, date: ${m.documentDate?.toISOString() || "unknown"})`
+  ).join("\n")}
+
+**Instructions:**
+1. Combine all unique information from these memories
+2. Resolve any contradictions by keeping the most recent or most confident information
+3. Extract all unique entity mentions
+4. Use the highest confidence score
+5. Keep the most recent document date
+
+Return JSON:
+{
+  "merged_content": "comprehensive merged memory",
+  "entity_mentions": ["list", "of", "entities"],
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation of how you merged"
+}`;
+  const response = await openai.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) {
+    throw new Error("Failed to merge memories");
+  }
+  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);
+  const embedding = await embedSingle(result.merged_content);
+  const mergedMemory = await db.memory.create({
+    data: {
+      projectId: cluster.representative.projectId,
+      orgId: cluster.representative.orgId,
+      userId: cluster.representative.userId,
+      sessionId: cluster.representative.sessionId,
+      memoryType: cluster.representative.memoryType,
+      content: result.merged_content,
+      embedding,
+      entityMentions: result.entity_mentions || [],
+      confidence: result.confidence || cluster.representative.confidence,
+      documentDate: cluster.representative.documentDate,
+      eventDate: cluster.representative.eventDate,
+      validFrom: /* @__PURE__ */ new Date(),
+      importance: Math.max(...memories.map((m) => m.importance || 0.5)),
+      metadata: {
+        mergedFrom: memories.map((m) => m.id),
+        mergeReasoning: result.reasoning,
+        mergedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+  for (const memory of memories) {
+    await db.memory.update({
+      where: { id: memory.id },
+      data: {
+        isActive: false,
+        validUntil: /* @__PURE__ */ new Date(),
+        supersededBy: mergedMemory.id
+      }
+    });
+  }
+  return mergedMemory.id;
+}
+async function consolidateMemories(params) {
+  const { projectId, userId, similarityThreshold = 0.95, dryRun = false } = params;
+  console.log(`\u{1F50D} Finding duplicate memories in project ${projectId}...`);
+  const clusters = await findDuplicateMemories({
+    projectId,
+    userId,
+    similarityThreshold
+  });
+  console.log(`\u{1F4CA} Found ${clusters.length} memory clusters`);
+  if (dryRun) {
+    for (const cluster of clusters) {
+      console.log(`
+Cluster (similarity: ${cluster.similarity.toFixed(2)}):`);
+      console.log(`  Representative: "${cluster.representative.content}"`);
+      console.log(`  Duplicates: ${cluster.duplicates.length}`);
+      cluster.duplicates.forEach((d) => {
+        console.log(`    - "${d.content}"`);
+      });
+    }
+    return {
+      clustersFound: clusters.length,
+      memoriesMerged: 0,
+      memoriesDeactivated: 0
+    };
+  }
+  let memoriesMerged = 0;
+  let memoriesDeactivated = 0;
+  for (const cluster of clusters) {
+    try {
+      console.log(`\u{1F517} Merging cluster with ${cluster.duplicates.length + 1} memories...`);
+      await mergeDuplicateMemories(cluster);
+      memoriesMerged++;
+      memoriesDeactivated += cluster.duplicates.length + 1;
+      console.log(`\u2705 Merged successfully`);
+    } catch (error) {
+      console.error(`\u274C Failed to merge cluster:`, error);
+    }
+  }
+  console.log(
+    `
+\u2705 Consolidation complete: ${memoriesMerged} clusters merged, ${memoriesDeactivated} memories deactivated`
+  );
+  return {
+    clustersFound: clusters.length,
+    memoriesMerged,
+    memoriesDeactivated
+  };
+}
+async function scheduledConsolidation(orgId) {
+  console.log(`\u{1F504} Running scheduled consolidation for org ${orgId}...`);
+  const projects = await db.project.findMany({
+    where: { orgId }
+  });
+  for (const project of projects) {
+    try {
+      const result = await consolidateMemories({
+        projectId: project.id,
+        similarityThreshold: 0.92
+        // Slightly lower for scheduled runs
+      });
+      if (result.memoriesMerged > 0) {
+        console.log(
+          `\u{1F4CA} Project ${project.name}: merged ${result.memoriesMerged} clusters`
+        );
+      }
+    } catch (error) {
+      console.error(`Failed to consolidate project ${project.name}:`, error);
+    }
+  }
+  console.log("\u2705 Scheduled consolidation complete");
+}
+export {
+  consolidateMemories,
+  findDuplicateMemories,
+  mergeDuplicateMemories,
+  scheduledConsolidation
+};

package/dist/consolidation-FOVQTWNQ.js

@@ -0,0 +1,222 @@
+import {
+  db,
+  embedSingle
+} from "./chunk-3WGYBAYR.js";
+import {
+  Anthropic
+} from "./chunk-H3HSKH2P.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../src/engine/memory/consolidation.ts
+var anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY || ""
+});
+async function findDuplicateMemories(params) {
+  const {
+    projectId,
+    userId,
+    similarityThreshold = 0.95,
+    limit = 50
+  } = params;
+  const maxMemories = Math.min(Math.max(limit, 10), 100);
+  const memories = await db.memory.findMany({
+    where: {
+      projectId,
+      userId,
+      isActive: true,
+      validUntil: null
+    },
+    orderBy: { importance: "desc" },
+    take: maxMemories
+  });
+  const clusters = [];
+  const processed = /* @__PURE__ */ new Set();
+  for (let i = 0; i < memories.length; i++) {
+    const memory = memories[i];
+    if (processed.has(memory.id)) continue;
+    const similar = [];
+    const candidates = memories.slice(i + 1);
+    const batchSimilarities = await calculateBatchSimilarity(memory.id, candidates.map((c) => c.id));
+    for (let j = 0; j < candidates.length; j++) {
+      const other = candidates[j];
+      if (processed.has(other.id)) continue;
+      const similarity = batchSimilarities[j];
+      if (similarity >= similarityThreshold) {
+        similar.push({ ...other, similarity });
+        processed.add(other.id);
+      }
+    }
+    if (similar.length > 0) {
+      clusters.push({
+        representative: memory,
+        duplicates: similar,
+        similarity: similar.reduce((sum, m) => sum + m.similarity, 0) / similar.length
+      });
+      processed.add(memory.id);
+    }
+  }
+  return clusters;
+}
+async function calculateBatchSimilarity(memoryId, otherIds) {
+  if (otherIds.length === 0) return [];
+  const placeholders = otherIds.map((_, i) => `(m1.embedding <=> $${i + 2}::vector)`).join(" + ");
+  const conditions = otherIds.map((id, i) => `m2.id = $${i + 2}`).join(" OR ");
+  const result = await db.$queryRaw`
+    SELECT
+      1 - (m1.embedding <=> m2.embedding) as similarity,
+      m2.id as id
+    FROM memories m1, memories m2
+    WHERE m1.id = ${memoryId} AND (${conditions})
+  `;
+  const similarityMap = new Map(result.map((r) => [r.id, r.similarity]));
+  return otherIds.map((id) => similarityMap.get(id) || 0);
+}
+async function mergeDuplicateMemories(cluster) {
+  const memories = [cluster.representative, ...cluster.duplicates];
+  const prompt = `You are merging duplicate memories into a single, comprehensive memory.
+
+**Memories to merge:**
+${memories.map(
+    (m, i) => `${i + 1}. "${m.content}" (confidence: ${m.confidence}, date: ${m.documentDate?.toISOString() || "unknown"})`
+  ).join("\n")}
+
+**Instructions:**
+1. Combine all unique information from these memories
+2. Resolve any contradictions by keeping the most recent or most confident information
+3. Extract all unique entity mentions
+4. Use the highest confidence score
+5. Keep the most recent document date
+
+Return JSON:
+{
+  "merged_content": "comprehensive merged memory",
+  "entity_mentions": ["list", "of", "entities"],
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation of how you merged"
+}`;
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-5-20250929",
+    // Fixed: was "claude-sonnet-4.5" (wrong format)
+    max_tokens: 2048,
+    temperature: 0,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = response.content.find((c) => c.type === "text");
+  if (!text || text.type !== "text") {
+    throw new Error("Failed to merge memories");
+  }
+  const jsonMatch = text.text.match(/```json\n?([\s\S]*?)\n?```/) || text.text.match(/\{[\s\S]*\}/);
+  const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text.text;
+  const result = JSON.parse(jsonStr);
+  const embedding = await embedSingle(result.merged_content);
+  const mergedMemory = await db.memory.create({
+    data: {
+      projectId: cluster.representative.projectId,
+      orgId: cluster.representative.orgId,
+      userId: cluster.representative.userId,
+      sessionId: cluster.representative.sessionId,
+      memoryType: cluster.representative.memoryType,
+      content: result.merged_content,
+      embedding,
+      entityMentions: result.entity_mentions || [],
+      confidence: result.confidence || cluster.representative.confidence,
+      documentDate: cluster.representative.documentDate,
+      eventDate: cluster.representative.eventDate,
+      validFrom: /* @__PURE__ */ new Date(),
+      importance: Math.max(...memories.map((m) => m.importance || 0.5)),
+      metadata: {
+        mergedFrom: memories.map((m) => m.id),
+        mergeReasoning: result.reasoning,
+        mergedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+  for (const memory of memories) {
+    await db.memory.update({
+      where: { id: memory.id },
+      data: {
+        isActive: false,
+        validUntil: /* @__PURE__ */ new Date(),
+        supersededBy: mergedMemory.id
+      }
+    });
+  }
+  return mergedMemory.id;
+}
+async function consolidateMemories(params) {
+  const { projectId, userId, similarityThreshold = 0.95, dryRun = false } = params;
+  console.log(`\u{1F50D} Finding duplicate memories in project ${projectId}...`);
+  const clusters = await findDuplicateMemories({
+    projectId,
+    userId,
+    similarityThreshold
+  });
+  console.log(`\u{1F4CA} Found ${clusters.length} memory clusters`);
+  if (dryRun) {
+    for (const cluster of clusters) {
+      console.log(`
+Cluster (similarity: ${cluster.similarity.toFixed(2)}):`);
+      console.log(`  Representative: "${cluster.representative.content}"`);
+      console.log(`  Duplicates: ${cluster.duplicates.length}`);
+      cluster.duplicates.forEach((d) => {
+        console.log(`    - "${d.content}"`);
+      });
+    }
+    return {
+      clustersFound: clusters.length,
+      memoriesMerged: 0,
+      memoriesDeactivated: 0
+    };
+  }
+  let memoriesMerged = 0;
+  let memoriesDeactivated = 0;
+  for (const cluster of clusters) {
+    try {
+      console.log(`\u{1F517} Merging cluster with ${cluster.duplicates.length + 1} memories...`);
+      await mergeDuplicateMemories(cluster);
+      memoriesMerged++;
+      memoriesDeactivated += cluster.duplicates.length + 1;
+      console.log(`\u2705 Merged successfully`);
+    } catch (error) {
+      console.error(`\u274C Failed to merge cluster:`, error);
+    }
+  }
+  console.log(
+    `
+\u2705 Consolidation complete: ${memoriesMerged} clusters merged, ${memoriesDeactivated} memories deactivated`
+  );
+  return {
+    clustersFound: clusters.length,
+    memoriesMerged,
+    memoriesDeactivated
+  };
+}
+async function scheduledConsolidation(orgId) {
+  console.log(`\u{1F504} Running scheduled consolidation for org ${orgId}...`);
+  const projects = await db.project.findMany({
+    where: { orgId }
+  });
+  for (const project of projects) {
+    try {
+      const result = await consolidateMemories({
+        projectId: project.id,
+        similarityThreshold: 0.92
+        // Slightly lower for scheduled runs
+      });
+      if (result.memoriesMerged > 0) {
+        console.log(
+          `\u{1F4CA} Project ${project.name}: merged ${result.memoriesMerged} clusters`
+        );
+      }
+    } catch (error) {
+      console.error(`Failed to consolidate project ${project.name}:`, error);
+    }
+  }
+  console.log("\u2705 Scheduled consolidation complete");
+}
+export {
+  consolidateMemories,
+  findDuplicateMemories,
+  mergeDuplicateMemories,
+  scheduledConsolidation
+};