@usewhisper/mcp-server 0.1.0 → 0.3.0

package/dist/consolidation-IFQ52E44.js

@@ -0,0 +1,210 @@
+import {
+  db,
+  embedSingle
+} from "./chunk-X2DL2GWT.js";
+
+// src/engine/memory/consolidation.ts
+import Anthropic from "@anthropic-ai/sdk";
+var anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY || ""
+});
+async function findDuplicateMemories(params) {
+  const { projectId, userId, similarityThreshold = 0.95, limit = 100 } = params;
+  const memories = await db.memory.findMany({
+    where: {
+      projectId,
+      userId,
+      isActive: true,
+      validUntil: null
+      // Only current versions
+    },
+    orderBy: {
+      importance: "desc"
+    },
+    take: limit * 2
+    // Get more to find duplicates
+  });
+  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 = [];
+    for (let j = i + 1; j < memories.length; j++) {
+      const other = memories[j];
+      if (processed.has(other.id)) continue;
+      const similarity = await calculateSimilarity(memory.id, other.id);
+      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 calculateSimilarity(memoryId1, memoryId2) {
+  const result = await db.$queryRaw`
+    SELECT
+      1 - (m1.embedding <=> m2.embedding) as similarity
+    FROM memories m1, memories m2
+    WHERE m1.id = ${memoryId1} AND m2.id = ${memoryId2}
+  `;
+  return result[0]?.similarity || 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",
+    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
+};
+//# sourceMappingURL=consolidation-IFQ52E44.js.map

package/dist/consolidation-IFQ52E44.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/memory/consolidation.ts"],"sourcesContent":["/**\n * Memory Consolidation - Deduplicate and merge similar memories\n * Prevents memory bloat and improves search accuracy\n */\n\nimport Anthropic from \"@anthropic-ai/sdk\";\nimport { db } from \"../../db/index.js\";\nimport { embedSingle } from \"../embeddings.js\";\n\nconst anthropic = new Anthropic({\n  apiKey: process.env.ANTHROPIC_API_KEY || \"\",\n});\n\ninterface MemoryCluster {\n  representative: any; // Most important memory in cluster\n  duplicates: any[]; // Similar memories to merge\n  similarity: number; // Average similarity score\n}\n\n/**\n * Find duplicate/similar memories using vector similarity\n */\nexport async function findDuplicateMemories(params: {\n  projectId: string;\n  userId?: string;\n  similarityThreshold?: number;\n  limit?: number;\n}): Promise<MemoryCluster[]> {\n  const { projectId, userId, similarityThreshold = 0.95, limit = 100 } = params;\n\n  // Get active memories\n  const memories = await db.memory.findMany({\n    where: {\n      projectId,\n      userId,\n      isActive: true,\n      validUntil: null, // Only current versions\n    },\n    orderBy: {\n      importance: \"desc\",\n    },\n    take: limit * 2, // Get more to find duplicates\n  });\n\n  const clusters: MemoryCluster[] = [];\n  const processed = new Set<string>();\n\n  for (let i = 0; i < memories.length; i++) {\n    const memory = memories[i];\n\n    if (processed.has(memory.id)) continue;\n\n    // Find similar memories\n    const similar: any[] = [];\n\n    for (let j = i + 1; j < memories.length; j++) {\n      const other = memories[j];\n\n      if (processed.has(other.id)) continue;\n\n      // Calculate cosine similarity (using raw SQL for vector ops)\n      const similarity = await calculateSimilarity(memory.id, other.id);\n\n      if (similarity >= similarityThreshold) {\n        similar.push({ ...other, similarity });\n        processed.add(other.id);\n      }\n    }\n\n    if (similar.length > 0) {\n      clusters.push({\n        representative: memory,\n        duplicates: similar,\n        similarity: similar.reduce((sum, m) => sum + m.similarity, 0) / similar.length,\n      });\n      processed.add(memory.id);\n    }\n  }\n\n  return clusters;\n}\n\n/**\n * Calculate cosine similarity between two memory embeddings\n */\nasync function calculateSimilarity(memoryId1: string, memoryId2: string): Promise<number> {\n  const result = await db.$queryRaw<any[]>`\n    SELECT\n      1 - (m1.embedding <=> m2.embedding) as similarity\n    FROM memories m1, memories m2\n    WHERE m1.id = ${memoryId1} AND m2.id = ${memoryId2}\n  `;\n\n  return result[0]?.similarity || 0;\n}\n\n/**\n * Merge duplicate memories using LLM\n */\nexport async function mergeDuplicateMemories(cluster: MemoryCluster): Promise<string> {\n  const memories = [cluster.representative, ...cluster.duplicates];\n\n  const prompt = `You are merging duplicate memories into a single, comprehensive memory.\n\n**Memories to merge:**\n${memories\n  .map(\n    (m, i) => `${i + 1}. \"${m.content}\" (confidence: ${m.confidence}, date: ${m.documentDate?.toISOString() || \"unknown\"})`\n  )\n  .join(\"\\n\")}\n\n**Instructions:**\n1. Combine all unique information from these memories\n2. Resolve any contradictions by keeping the most recent or most confident information\n3. Extract all unique entity mentions\n4. Use the highest confidence score\n5. Keep the most recent document date\n\nReturn JSON:\n{\n  \"merged_content\": \"comprehensive merged memory\",\n  \"entity_mentions\": [\"list\", \"of\", \"entities\"],\n  \"confidence\": 0.0-1.0,\n  \"reasoning\": \"brief explanation of how you merged\"\n}`;\n\n  const response = await anthropic.messages.create({\n    model: \"claude-sonnet-4.5\",\n    max_tokens: 2048,\n    temperature: 0.0,\n    messages: [{ role: \"user\", content: prompt }],\n  });\n\n  const text = response.content.find((c) => c.type === \"text\");\n  if (!text || text.type !== \"text\") {\n    throw new Error(\"Failed to merge memories\");\n  }\n\n  const jsonMatch = text.text.match(/```json\\n?([\\s\\S]*?)\\n?```/) || text.text.match(/\\{[\\s\\S]*\\}/);\n  const jsonStr = jsonMatch ? (jsonMatch[1] || jsonMatch[0]) : text.text;\n\n  const result = JSON.parse(jsonStr);\n\n  // Create merged memory\n  const embedding = await embedSingle(result.merged_content);\n\n  const mergedMemory = await db.memory.create({\n    data: {\n      projectId: cluster.representative.projectId,\n      orgId: cluster.representative.orgId,\n      userId: cluster.representative.userId,\n      sessionId: cluster.representative.sessionId,\n      memoryType: cluster.representative.memoryType,\n      content: result.merged_content,\n      embedding,\n      entityMentions: result.entity_mentions || [],\n      confidence: result.confidence || cluster.representative.confidence,\n      documentDate: cluster.representative.documentDate,\n      eventDate: cluster.representative.eventDate,\n      validFrom: new Date(),\n      importance: Math.max(...memories.map((m) => m.importance || 0.5)),\n      metadata: {\n        mergedFrom: memories.map((m) => m.id),\n        mergeReasoning: result.reasoning,\n        mergedAt: new Date().toISOString(),\n      },\n    },\n  });\n\n  // Deactivate old memories\n  for (const memory of memories) {\n    await db.memory.update({\n      where: { id: memory.id },\n      data: {\n        isActive: false,\n        validUntil: new Date(),\n        supersededBy: mergedMemory.id,\n      },\n    });\n  }\n\n  return mergedMemory.id;\n}\n\n/**\n * Run consolidation job on a project\n */\nexport async function consolidateMemories(params: {\n  projectId: string;\n  userId?: string;\n  similarityThreshold?: number;\n  dryRun?: boolean;\n}): Promise<{\n  clustersFound: number;\n  memoriesMerged: number;\n  memoriesDeactivated: number;\n}> {\n  const { projectId, userId, similarityThreshold = 0.95, dryRun = false } = params;\n\n  console.log(`🔍 Finding duplicate memories in project ${projectId}...`);\n\n  const clusters = await findDuplicateMemories({\n    projectId,\n    userId,\n    similarityThreshold,\n  });\n\n  console.log(`📊 Found ${clusters.length} memory clusters`);\n\n  if (dryRun) {\n    for (const cluster of clusters) {\n      console.log(`\\nCluster (similarity: ${cluster.similarity.toFixed(2)}):`);\n      console.log(`  Representative: \"${cluster.representative.content}\"`);\n      console.log(`  Duplicates: ${cluster.duplicates.length}`);\n      cluster.duplicates.forEach((d) => {\n        console.log(`    - \"${d.content}\"`);\n      });\n    }\n\n    return {\n      clustersFound: clusters.length,\n      memoriesMerged: 0,\n      memoriesDeactivated: 0,\n    };\n  }\n\n  // Merge clusters\n  let memoriesMerged = 0;\n  let memoriesDeactivated = 0;\n\n  for (const cluster of clusters) {\n    try {\n      console.log(`🔗 Merging cluster with ${cluster.duplicates.length + 1} memories...`);\n\n      await mergeDuplicateMemories(cluster);\n\n      memoriesMerged++;\n      memoriesDeactivated += cluster.duplicates.length + 1; // All memories in cluster\n\n      console.log(`✅ Merged successfully`);\n    } catch (error) {\n      console.error(`❌ Failed to merge cluster:`, error);\n    }\n  }\n\n  console.log(\n    `\\n✅ Consolidation complete: ${memoriesMerged} clusters merged, ${memoriesDeactivated} memories deactivated`\n  );\n\n  return {\n    clustersFound: clusters.length,\n    memoriesMerged,\n    memoriesDeactivated,\n  };\n}\n\n/**\n * Find memories that need consolidation (scheduled job)\n */\nexport async function scheduledConsolidation(orgId: string): Promise<void> {\n  console.log(`🔄 Running scheduled consolidation for org ${orgId}...`);\n\n  const projects = await db.project.findMany({\n    where: { orgId },\n  });\n\n  for (const project of projects) {\n    try {\n      const result = await consolidateMemories({\n        projectId: project.id,\n        similarityThreshold: 0.92, // Slightly lower for scheduled runs\n      });\n\n      if (result.memoriesMerged > 0) {\n        console.log(\n          `📊 Project ${project.name}: merged ${result.memoriesMerged} clusters`\n        );\n      }\n    } catch (error) {\n      console.error(`Failed to consolidate project ${project.name}:`, error);\n    }\n  }\n\n  console.log(\"✅ Scheduled consolidation complete\");\n}\n"],"mappings":"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","names":[]}

package/dist/context-sharing-4ITCNKG4.js

@@ -0,0 +1,307 @@
+import {
+  getSessionMemories
+} from "./chunk-T7KMSTWP.js";
+import "./chunk-EI5CE3EY.js";
+import "./chunk-5KBZQHDL.js";
+import {
+  db
+} from "./chunk-3WGYBAYR.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../node_modules/nanoid/index.js
+import { webcrypto as crypto } from "crypto";
+
+// ../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// ../src/engine/context-sharing.ts
+async function createSharedContext(params) {
+  const {
+    sessionId,
+    projectId,
+    orgId,
+    userId,
+    includeMemories = true,
+    includeMessages = true,
+    includeChunks = false,
+    expiryDays = 7,
+    metadata = {}
+  } = params;
+  const shareId = nanoid(12);
+  const session = await db.session.findUnique({
+    where: { id: sessionId }
+  });
+  if (!session) {
+    throw new Error("Session not found");
+  }
+  const shareData = {
+    sessionId,
+    projectId,
+    userId,
+    metadata
+  };
+  if (includeMemories) {
+    const memories = await getSessionMemories({
+      sessionId,
+      projectId,
+      limit: 200
+    });
+    shareData.memories = memories.map((m) => ({
+      id: m.id,
+      content: m.content,
+      type: m.memoryType,
+      entities: m.entityMentions,
+      confidence: m.confidence,
+      documentDate: m.documentDate?.toISOString(),
+      eventDate: m.eventDate?.toISOString()
+    }));
+  } else {
+    shareData.memories = [];
+  }
+  if (includeMessages) {
+    const messages = await db.message.findMany({
+      where: { sessionId },
+      orderBy: { createdAt: "asc" },
+      take: 500
+    });
+    shareData.messages = messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+      createdAt: m.createdAt.toISOString()
+    }));
+  } else {
+    shareData.messages = [];
+  }
+  if (includeChunks) {
+    const chunkIds = shareData.memories.map((m) => m.sourceChunkId).filter(Boolean).slice(0, 50);
+    if (chunkIds.length > 0) {
+      const chunks = await db.chunk.findMany({
+        where: {
+          id: { in: chunkIds }
+        },
+        select: {
+          id: true,
+          content: true,
+          metadata: true,
+          chunkType: true
+        },
+        take: 50
+      });
+      shareData.chunks = chunks;
+    } else {
+      shareData.chunks = [];
+    }
+  } else {
+    shareData.chunks = [];
+  }
+  const expiresAt = expiryDays ? new Date(Date.now() + expiryDays * 24 * 60 * 60 * 1e3) : null;
+  await db.$executeRaw`
+    INSERT INTO shared_contexts (
+      id, session_id, project_id, org_id, user_id,
+      share_data, expires_at, created_at, access_count
+    ) VALUES (
+      ${shareId}, ${sessionId}, ${projectId}, ${orgId}, ${userId || null},
+      ${JSON.stringify(shareData)}::jsonb, ${expiresAt}, NOW(), 0
+    )
+    ON CONFLICT (id) DO NOTHING
+  `;
+  const baseUrl = process.env.BASE_URL || "http://localhost:4000";
+  const shareUrl = `${baseUrl}/shared/${shareId}`;
+  return {
+    id: shareId,
+    sessionId,
+    projectId,
+    userId,
+    shareUrl,
+    memories: shareData.memories,
+    messages: shareData.messages,
+    chunks: shareData.chunks,
+    metadata,
+    createdAt: /* @__PURE__ */ new Date(),
+    expiresAt,
+    accessCount: 0
+  };
+}
+async function loadSharedContext(shareId) {
+  const result = await db.$queryRaw`
+    SELECT * FROM shared_contexts
+    WHERE id = ${shareId}
+    AND (expires_at IS NULL OR expires_at > NOW())
+  `;
+  if (result.length === 0) {
+    return null;
+  }
+  const row = result[0];
+  await db.$executeRaw`
+    UPDATE shared_contexts
+    SET access_count = access_count + 1,
+        last_accessed_at = NOW()
+    WHERE id = ${shareId}
+  `;
+  const baseUrl = process.env.BASE_URL || "http://localhost:4000";
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    projectId: row.project_id,
+    userId: row.user_id,
+    shareUrl: `${baseUrl}/shared/${shareId}`,
+    memories: row.share_data.memories || [],
+    messages: row.share_data.messages || [],
+    chunks: row.share_data.chunks || [],
+    metadata: row.share_data.metadata || {},
+    createdAt: row.created_at,
+    expiresAt: row.expires_at,
+    accessCount: row.access_count
+  };
+}
+async function resumeFromSharedContext(params) {
+  const { shareId, projectId, orgId, userId, newSessionId } = params;
+  const sharedContext = await loadSharedContext(shareId);
+  if (!sharedContext) {
+    throw new Error("Shared context not found or expired");
+  }
+  const sessionId = newSessionId || nanoid();
+  await db.session.create({
+    data: {
+      id: sessionId,
+      projectId,
+      orgId,
+      userId,
+      title: `Resumed from ${sharedContext.id}`,
+      metadata: {
+        resumedFrom: shareId,
+        originalSessionId: sharedContext.sessionId,
+        ...sharedContext.metadata
+      }
+    }
+  });
+  let memoriesRestored = 0;
+  for (const memory of sharedContext.memories) {
+    try {
+      await db.memory.create({
+        data: {
+          projectId,
+          orgId,
+          userId,
+          sessionId,
+          memoryType: memory.type,
+          content: memory.content,
+          entityMentions: memory.entities || [],
+          confidence: memory.confidence || 0.8,
+          documentDate: memory.documentDate ? new Date(memory.documentDate) : null,
+          eventDate: memory.eventDate ? new Date(memory.eventDate) : null,
+          validFrom: /* @__PURE__ */ new Date(),
+          metadata: {
+            restoredFrom: shareId
+          }
+        }
+      });
+      memoriesRestored++;
+    } catch (error) {
+      console.error("Failed to restore memory:", error);
+    }
+  }
+  for (const msg of sharedContext.messages) {
+    try {
+      await db.message.create({
+        data: {
+          sessionId,
+          role: msg.role,
+          content: msg.content,
+          metadata: {
+            restoredFrom: shareId,
+            originalTimestamp: msg.createdAt
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Failed to restore message:", error);
+    }
+  }
+  return {
+    sessionId,
+    memoriesRestored
+  };
+}
+async function cleanupExpiredContexts() {
+  const result = await db.$executeRaw`
+    DELETE FROM shared_contexts
+    WHERE expires_at IS NOT NULL
+    AND expires_at < NOW()
+  `;
+  return result;
+}
+async function listSharedContexts(params) {
+  const { userId, projectId, orgId, limit = 50 } = params;
+  const maxLimit = Math.min(limit, 100);
+  const whereClauses = [`org_id = ${orgId}`];
+  if (userId) whereClauses.push(`user_id = ${userId}`);
+  if (projectId) whereClauses.push(`project_id = ${projectId}`);
+  const results = await db.$queryRaw`
+    SELECT id, session_id, created_at, expires_at, access_count, share_data
+    FROM shared_contexts
+    WHERE ${db.Prisma.raw(whereClauses.join(" AND "))}
+    ORDER BY created_at DESC
+    LIMIT ${maxLimit}
+  `;
+  const baseUrl = process.env.BASE_URL || "http://localhost:4000";
+  return results.map((row) => ({
+    id: row.id,
+    shareUrl: `${baseUrl}/shared/${row.id}`,
+    createdAt: row.created_at,
+    expiresAt: row.expires_at,
+    accessCount: row.access_count,
+    metadata: row.share_data?.metadata || {}
+  }));
+}
+var SHARED_CONTEXTS_MIGRATION = `
+CREATE TABLE IF NOT EXISTS shared_contexts (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  org_id TEXT NOT NULL,
+  user_id TEXT,
+  share_data JSONB NOT NULL DEFAULT '{}',
+  expires_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  access_count INTEGER NOT NULL DEFAULT 0,
+  last_accessed_at TIMESTAMPTZ
+);
+
+CREATE INDEX IF NOT EXISTS idx_shared_contexts_org ON shared_contexts(org_id);
+CREATE INDEX IF NOT EXISTS idx_shared_contexts_user ON shared_contexts(user_id);
+CREATE INDEX IF NOT EXISTS idx_shared_contexts_expires ON shared_contexts(expires_at);
+CREATE INDEX IF NOT EXISTS idx_shared_contexts_session ON shared_contexts(session_id);
+`;
+export {
+  SHARED_CONTEXTS_MIGRATION,
+  cleanupExpiredContexts,
+  createSharedContext,
+  listSharedContexts,
+  loadSharedContext,
+  resumeFromSharedContext
+};