@usewhisper/mcp-server 0.2.3 → 0.3.0

package/dist/oracle-FKRTQUUG.js

@@ -0,0 +1,282 @@
+import {
+  db,
+  embedSingle
+} from "./chunk-MEFLJ4PV.js";
+import "./chunk-QGM4M3NI.js";
+
+// ../src/engine/oracle.ts
+import OpenAI from "openai";
+var openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY || ""
+});
+var MAX_DOCUMENT_CHUNKS = 500;
+async function buildDocumentTree(documentId) {
+  const document = await db.document.findUnique({
+    where: { id: documentId },
+    include: {
+      chunks: {
+        orderBy: { chunkIndex: "asc" },
+        take: MAX_DOCUMENT_CHUNKS
+      }
+    }
+  });
+  if (!document) {
+    throw new Error("Document not found");
+  }
+  const root = {
+    id: document.id,
+    content: document.title,
+    type: "document",
+    children: [],
+    metadata: document.metadata
+  };
+  const sectionMap = /* @__PURE__ */ new Map();
+  for (const chunk of document.chunks) {
+    const sectionPath = chunk.metadata?.sectionPath || chunk.sectionPath || "root";
+    if (!sectionMap.has(sectionPath)) {
+      const sectionNode = {
+        id: `${documentId}::${sectionPath}`,
+        content: sectionPath,
+        type: "section",
+        children: [],
+        metadata: { path: sectionPath }
+      };
+      sectionMap.set(sectionPath, sectionNode);
+      root.children.push(sectionNode);
+    }
+    const section = sectionMap.get(sectionPath);
+    section.children.push({
+      id: chunk.id,
+      content: chunk.content,
+      type: "chunk",
+      children: [],
+      metadata: chunk.metadata,
+      embedding: chunk.embedding
+    });
+  }
+  return {
+    root,
+    depth: calculateDepth(root),
+    nodeCount: countNodes(root)
+  };
+}
+function calculateDepth(node) {
+  if (node.children.length === 0) return 1;
+  return 1 + Math.max(...node.children.map(calculateDepth));
+}
+function countNodes(node) {
+  return 1 + node.children.reduce((sum, child) => sum + countNodes(child), 0);
+}
+async function oracleSearch(params) {
+  const { query, projectId, topK = 5, maxDepth = 3 } = params;
+  console.log(`\u{1F52E} Oracle search: "${query}"`);
+  const queryEmbedding = await embedSingle(query);
+  const documents = await db.document.findMany({
+    where: { projectId },
+    take: 10,
+    include: {
+      _count: {
+        select: { chunks: true }
+      }
+    }
+  });
+  console.log(`[Oracle] Found ${documents.length} documents in project`);
+  const results = [];
+  for (const doc of documents) {
+    if (doc._count.chunks === 0) {
+      console.log(`[Oracle] Skipping document ${doc.id} - no chunks`);
+      continue;
+    }
+    console.log(`[Oracle] Building tree for document: ${doc.title} (${doc._count.chunks} chunks)`);
+    try {
+      const tree = await buildDocumentTree(doc.id);
+      console.log(`[Oracle] Tree built: ${tree.nodeCount} nodes, depth: ${tree.depth}`);
+      if (tree.nodeCount === 0) {
+        continue;
+      }
+      const traversalResults = await guidedTraversal({
+        tree,
+        query,
+        queryEmbedding,
+        maxDepth,
+        topK
+      });
+      console.log(`[Oracle] Traversal found ${traversalResults.length} results for ${doc.title}`);
+      results.push(...traversalResults);
+    } catch (err) {
+      console.error(`[Oracle] Error building tree for document ${doc.id}:`, err.message);
+    }
+  }
+  console.log(`[Oracle] Total results before filtering: ${results.length}`);
+  results.sort((a, b) => b.relevance - a.relevance);
+  const finalResults = results.slice(0, topK);
+  console.log(`[Oracle] Returning ${finalResults.length} results`);
+  return finalResults;
+}
+async function guidedTraversal(params) {
+  const {
+    tree,
+    query,
+    queryEmbedding,
+    maxDepth,
+    topK,
+    currentNode = tree.root,
+    currentDepth = 0,
+    path = ""
+  } = params;
+  const results = [];
+  if (currentDepth >= maxDepth) {
+    return results;
+  }
+  if (currentNode.type === "chunk") {
+    const relevance = currentNode.embedding ? cosineSimilarity(queryEmbedding, currentNode.embedding) : 0;
+    if (relevance > 0.3) {
+      results.push({
+        content: currentNode.content,
+        path,
+        relevance
+      });
+    }
+    return results;
+  }
+  const childScores = await Promise.all(
+    currentNode.children.map(async (child) => {
+      const score = await scoreNode(child, query, queryEmbedding);
+      return { child, score };
+    })
+  );
+  childScores.sort((a, b) => b.score - a.score);
+  const topChildren = childScores.slice(0, Math.min(3, childScores.length));
+  for (const { child, score } of topChildren) {
+    if (score > 0.2) {
+      const childPath = path ? `${path} > ${child.content.substring(0, 30)}` : child.content;
+      const childResults = await guidedTraversal({
+        tree,
+        query,
+        queryEmbedding,
+        maxDepth,
+        topK,
+        currentNode: child,
+        currentDepth: currentDepth + 1,
+        path: childPath
+      });
+      results.push(...childResults);
+    }
+  }
+  return results;
+}
+async function scoreNode(node, query, queryEmbedding) {
+  if (node.embedding) {
+    return cosineSimilarity(queryEmbedding, node.embedding);
+  }
+  const queryWords = query.toLowerCase().split(/\s+/);
+  const nodeWords = node.content.toLowerCase().split(/\s+/);
+  const overlap = queryWords.filter((w) => nodeWords.includes(w)).length;
+  return overlap / queryWords.length;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function oracleResearch(params) {
+  const { question, projectId, maxSteps = 5 } = params;
+  const steps = [];
+  let currentQuery = question;
+  for (let step = 1; step <= maxSteps; step++) {
+    console.log(`\u{1F52E} Oracle step ${step}: ${currentQuery}`);
+    const results = await oracleSearch({
+      query: currentQuery,
+      projectId,
+      topK: 5
+    });
+    const reasoning = await reasonAboutResults(currentQuery, results, question);
+    steps.push({
+      step,
+      query: currentQuery,
+      results,
+      reasoning: reasoning.thought
+    });
+    if (reasoning.hasAnswer) {
+      return {
+        answer: reasoning.answer,
+        steps
+      };
+    }
+    currentQuery = reasoning.nextQuery || question;
+  }
+  const finalAnswer = await synthesizeAnswer(question, steps);
+  return {
+    answer: finalAnswer,
+    steps
+  };
+}
+async function reasonAboutResults(query, results, originalQuestion) {
+  const prompt = `You are analyzing search results to answer a question.
+
+**Original question:** ${originalQuestion}
+**Current query:** ${query}
+
+**Search results:**
+${results.map((r, i) => `${i + 1}. ${r.content} (relevance: ${r.relevance.toFixed(2)})`).join("\n")}
+
+Analyze these results:
+1. Do they answer the original question?
+2. What information is still missing?
+3. What should be the next search query?
+
+Return JSON:
+{
+  "thought": "your analysis",
+  "hasAnswer": true or false,
+  "answer": "the answer if you have it" or null,
+  "nextQuery": "next search query" or null
+}`;
+  const response = await openai.chat.completions.create({
+    model: "gpt-4o",
+    max_tokens: 1024,
+    temperature: 0,
+    messages: [{ role: "user", content: prompt }],
+    response_format: { type: "json_object" }
+  });
+  const text = response.choices[0]?.message?.content?.trim();
+  if (!text) {
+    return {
+      thought: "Analysis failed",
+      hasAnswer: false
+    };
+  }
+  const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\{[\s\S]*\}/);
+  const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+  return JSON.parse(jsonStr);
+}
+async function synthesizeAnswer(question, steps) {
+  const prompt = `Synthesize a final answer from multiple research steps.
+
+**Question:** ${question}
+
+**Research steps:**
+${steps.map((s) => `Step ${s.step}: ${s.query}
+  ${s.reasoning}`).join("\n\n")}
+
+Provide a comprehensive answer based on all the information gathered.`;
+  const response = await openai.chat.completions.create({
+    model: "gpt-4o",
+    max_tokens: 2048,
+    temperature: 0,
+    messages: [{ role: "user", content: prompt }]
+  });
+  return response.choices[0]?.message?.content || "Unable to synthesize answer";
+}
+export {
+  buildDocumentTree,
+  oracleResearch,
+  oracleSearch
+};

package/dist/search-EG6TYWWW.js

@@ -0,0 +1,13 @@
+import {
+  getSessionMemories,
+  getUserProfile,
+  searchMemories
+} from "./chunk-T7KMSTWP.js";
+import "./chunk-5KBZQHDL.js";
+import "./chunk-3WGYBAYR.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  getSessionMemories,
+  getUserProfile,
+  searchMemories
+};

package/dist/search-I22QQA7T.js

@@ -0,0 +1,13 @@
+import {
+  getSessionMemories,
+  getUserProfile,
+  searchMemories
+} from "./chunk-PPGYJJED.js";
+import "./chunk-LMEYV4JD.js";
+import "./chunk-3WGYBAYR.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  getSessionMemories,
+  getUserProfile,
+  searchMemories
+};

package/dist/search-T7H5G6DW.js

@@ -0,0 +1,13 @@
+import {
+  getSessionMemories,
+  getUserProfile,
+  searchMemories
+} from "./chunk-TWEIYHI6.js";
+import "./chunk-5KBZQHDL.js";
+import "./chunk-MEFLJ4PV.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  getSessionMemories,
+  getUserProfile,
+  searchMemories
+};