@melandlabs/memory-store 0.2.7 → 0.3.1

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { M as MemoryStoreConfig } from './config-Ll6ktm4D.js';
+import { M as MemoryStoreConfig } from './config-2Q092MUz.js';
 
 /**
  * @melandlabs/memory-store/mcp — MCP server entry.

package/dist/mcp.js

@@ -1,8 +1,8 @@
 import { buildMemoryRecordEmbeddingDocument } from '@melandlabs/ai/memory';
 import { ChromaVectorStore } from '@melandlabs/rag';
 import { mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { dirname, join } from 'path';
+import { dirname } from 'path';
+import { getOpenContextPath } from '@melandlabs/env-config';
 import { SQLiteRawMessageManager } from '@melandlabs/sqlite';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -187,7 +187,7 @@ __export(sqlite_raw_message_store_exports, {
 function resolveSQLiteRawMessageDbPath(dbPath) {
   if (dbPath && dbPath.length > 0) return dbPath;
   const fromEnv = process.env.MEMORY_STORE_DB_PATH?.trim();
-  return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_SQLITE_PATH;
+  return fromEnv && fromEnv.length > 0 ? fromEnv : getOpenContextPath("memory", "store.db");
 }
 function isSQLiteRawMessageStorageAvailable(_env) {
   return true;
@@ -221,12 +221,11 @@ async function lexicalSearchRawMessages(input) {
   }
   return mgr.lexicalSearchMessages(input);
 }
-var manager, DEFAULT_SQLITE_PATH;
+var manager;
 var init_sqlite_raw_message_store = __esm({
   "src/storage/sqlite-raw-message-store.ts"() {
     init_chroma_memory_index();
     manager = null;
-    DEFAULT_SQLITE_PATH = join(homedir(), ".opencontext", "memory", "store.db");
   }
 });
 
@@ -240,7 +239,7 @@ __export(raw_message_store_exports, {
   getRawMessageStorageBackend: () => getRawMessageStorageBackend,
   isRawMessageStorageAvailable: () => isRawMessageStorageAvailable
 });
-function resolveBackend(env) {
+function resolveBackend(_env) {
   const explicit = process.env.OPENCONTEXT_MEMORY_STORE_BACKEND?.trim().toLowerCase();
   if (explicit === "postgres") return "postgres";
   return "sqlite";
@@ -373,6 +372,12 @@ function mergeUnifiedMemorySearchResults(results, limit, options = {}) {
 function normalizeUnifiedMemoryMergeStrategy(value) {
   return value === "rrf" ? "rrf" : "similarity";
 }
+function normalizeUnifiedMemoryReasoningStrategy(value, defaultStrategy = "none") {
+  if (value === "rewrite" || value === "iterative") {
+    return value;
+  }
+  return defaultStrategy;
+}
 var DEFAULT_RRF_K = 60;
 function mergeUnifiedMemorySearchResultsRrf(lists, limit, k = DEFAULT_RRF_K) {
   if (!Array.isArray(lists) || lists.length === 0) {
@@ -395,7 +400,13 @@ function mergeUnifiedMemorySearchResultsRrf(lists, limit, k = DEFAULT_RRF_K) {
       }
     }
   }
-  const ranked = order.map((key) => scores.get(key)).sort((a, b) => {
+  const ranked = order.map((key) => {
+    const entry = scores.get(key);
+    if (!entry) {
+      throw new Error(`Invariant violation: missing RRF score for key "${key}"`);
+    }
+    return entry;
+  }).sort((a, b) => {
     if (b.rrf !== a.rrf) {
       return b.rrf - a.rrf;
     }
@@ -440,14 +451,222 @@ function isRawMemorySemanticResult(result) {
 function deriveLexicalKeywords(query) {
   return query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length >= 2).slice(0, 16);
 }
+function parseDateBoundary(value, role) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const dateOnlyMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (dateOnlyMatch) {
+    const year = Number.parseInt(dateOnlyMatch[1], 10);
+    const month = Number.parseInt(dateOnlyMatch[2], 10) - 1;
+    const day = Number.parseInt(dateOnlyMatch[3], 10);
+    if (role === "from") {
+      return Date.UTC(year, month, day);
+    }
+    return Date.UTC(year, month, day + 1) - 1;
+  }
+  const parsed = Date.parse(trimmed);
+  if (Number.isNaN(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+function getCandidateTimestamp(metadata) {
+  for (const key of ["timestamp", "createdAt", "time"]) {
+    const value = metadata[key];
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = Date.parse(value);
+      if (!Number.isNaN(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return void 0;
+}
+function filterByDateRange(items, dateFrom, dateTo) {
+  if (!dateFrom && !dateTo) {
+    return items;
+  }
+  const fromMs = dateFrom ? parseDateBoundary(dateFrom, "from") : void 0;
+  const toMs = dateTo ? parseDateBoundary(dateTo, "to") : void 0;
+  if (fromMs === void 0 && toMs === void 0) {
+    return items;
+  }
+  return items.filter((item) => {
+    const ts = getCandidateTimestamp(item.metadata);
+    if (ts === void 0) {
+      return true;
+    }
+    if (fromMs !== void 0 && ts < fromMs) {
+      return false;
+    }
+    if (toMs !== void 0 && ts > toMs) {
+      return false;
+    }
+    return true;
+  });
+}
+async function embedQueryVariant(embedQuery, input, query) {
+  return embedQuery({
+    userId: input.userId,
+    query,
+    authToken: input.authToken
+  });
+}
+async function runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit, threshold, logger) {
+  const filters = input.botIds && input.botIds.length > 0 ? input.botIds.map((botId) => ({ botId })) : [{}];
+  let semantic = [];
+  if (isRawMessageChromaEnabled()) {
+    try {
+      semantic = (await Promise.all(
+        filters.map((filter) => {
+          const botId = "botId" in filter ? filter.botId : void 0;
+          return searchRawMessagesWithChroma({
+            userId: input.userId,
+            queryEmbedding,
+            limit,
+            threshold,
+            botId
+          });
+        })
+      )).flat().map(toMemoryResult);
+      logger.log?.("[memory-store] Raw message semantic search completed", {
+        backend: "chroma",
+        dimensions: queryEmbedding.length,
+        count: semantic.length
+      });
+    } catch (error) {
+      logger.warn?.(
+        "[memory-store] Chroma raw message search failed; falling back to database search:",
+        error
+      );
+    }
+  } else if (typeof deps.searchRawMessagesAnn === "function") {
+    const searchRawMessagesAnn = deps.searchRawMessagesAnn;
+    semantic = (await Promise.all(
+      filters.map(
+        (filter) => searchRawMessagesAnn({
+          userId: input.userId,
+          queryEmbedding,
+          limit,
+          threshold,
+          botId: "botId" in filter ? filter.botId : void 0
+        })
+      )
+    )).flat().filter(isRawMemorySemanticResult).map(toMemoryResult);
+  }
+  if (semantic.length === 0) {
+    try {
+      const { getRawMessageManager: getRawMessageManager2 } = await Promise.resolve().then(() => (init_raw_message_store(), raw_message_store_exports));
+      const manager2 = await getRawMessageManager2();
+      if (typeof manager2.searchMessagesSemantically === "function") {
+        const results = await manager2.searchMessagesSemantically({
+          userId: input.userId,
+          queryEmbedding,
+          limit,
+          threshold
+        });
+        semantic = results.map((r) => ({
+          type: "memory",
+          id: r.id,
+          content: r.content,
+          similarity: r.similarity,
+          metadata: r.metadata ?? {}
+        }));
+      }
+    } catch (error) {
+      logger.warn?.("[memory-store] SQLite semantic search failed:", error);
+    }
+  }
+  return semantic;
+}
+function mergeByMaxScore(lists) {
+  const best = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const hit of list) {
+      const existing = best.get(hit.id);
+      if (!existing || hit.similarity > existing.similarity) {
+        best.set(hit.id, hit);
+      }
+    }
+  }
+  return Array.from(best.values()).sort((a, b) => b.similarity - a.similarity);
+}
+function toIterativeRecallCandidate(hit) {
+  return {
+    id: hit.id,
+    content: hit.content,
+    similarity: hit.similarity,
+    metadata: hit.metadata
+  };
+}
+async function runLexicalSearchForKeywords(deps, input, keywords, limit, logger) {
+  if (keywords.length === 0) {
+    return [];
+  }
+  if (typeof deps.searchRawMessagesLexical === "function") {
+    try {
+      const filters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
+      const searchRawMessagesLexical = deps.searchRawMessagesLexical;
+      return (await Promise.all(
+        filters.map(
+          (botId) => searchRawMessagesLexical({
+            userId: input.userId,
+            keywords,
+            limit: Math.ceil(limit / filters.length),
+            botId
+          })
+        )
+      )).flat().filter(isRawMemorySemanticResult).map((hit) => ({
+        ...toMemoryResult(hit),
+        metadata: { ...hit.metadata, scoring: "bm25" }
+      }));
+    } catch (error) {
+      logger.warn?.("[memory-store] lexical memory search failed:", error);
+    }
+  }
+  try {
+    const { lexicalSearchRawMessages: lexicalSearchRawMessages2 } = await Promise.resolve().then(() => (init_sqlite_raw_message_store(), sqlite_raw_message_store_exports));
+    const filters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
+    return (await Promise.all(
+      filters.map(
+        (botId) => lexicalSearchRawMessages2({
+          userId: input.userId,
+          keywords,
+          limit: Math.ceil(limit / filters.length),
+          botId
+        })
+      )
+    )).flat().filter(Boolean).map(
+      (r) => toMemoryResult(
+        r
+      )
+    );
+  } catch (error) {
+    logger.warn?.("[memory-store] SQLite lexical search failed:", error);
+  }
+  return [];
+}
 function createUnifiedSearch(deps = {}) {
   const logger = deps.logger ?? console;
+  function resolveReasoningStrategy(input) {
+    const requested = normalizeUnifiedMemoryReasoningStrategy(input.reasoningStrategy);
+    if (requested !== "none") {
+      return requested;
+    }
+    return normalizeUnifiedMemoryReasoningStrategy(deps.reasoning?.defaultStrategy, "none");
+  }
   async function searchUnifiedMemory(input) {
     const query = input.query.trim();
     const sources = normalizeUnifiedMemorySearchSources(input.sources);
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
     const mergeStrategy = normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy);
+    const reasoningStrategy = resolveReasoningStrategy(input);
     const warnings = [];
     if (!query) {
       return {
@@ -459,10 +678,21 @@ function createUnifiedSearch(deps = {}) {
       };
     }
     let memorySubs;
+    const reasoningInfo = { strategy: reasoningStrategy };
+    if (input.dateFrom || input.dateTo) {
+      reasoningInfo.dateRange = { from: input.dateFrom, to: input.dateTo };
+    }
     if (sources.includes("memory")) {
       if (isRawMessageStorageAvailable()) {
         try {
-          memorySubs = await runMemorySource(input, limit, threshold, warnings);
+          memorySubs = await runMemorySource(
+            input,
+            limit,
+            threshold,
+            warnings,
+            reasoningStrategy,
+            reasoningInfo
+          );
         } catch (error) {
           logger.warn?.("[memory-store] memory source failed:", error);
           warnings.push({
@@ -541,121 +771,155 @@ function createUnifiedSearch(deps = {}) {
       limit,
       strategy: mergeStrategy
     });
-    return {
+    const output = {
       query: input.query,
       sources,
       results: merged,
       count: merged.length,
       warnings
     };
+    if (reasoningInfo && (reasoningInfo.strategy !== "none" || reasoningInfo.dateRange !== void 0)) {
+      output.reasoning = reasoningInfo;
+    }
+    return output;
   }
-  async function runMemorySource(input, limit, threshold, warnings) {
+  async function runMemorySource(input, limit, threshold, warnings, reasoningStrategy = "none", reasoningInfo) {
+    if (reasoningStrategy === "iterative" && !deps.reasoning?.iterativePlanner) {
+      warnings.push({
+        source: "memory",
+        code: "memory_iterative_planner_not_configured",
+        message: "Iterative reasoning requested but no iterativePlanner is configured; falling back to default search."
+      });
+      if (reasoningInfo) reasoningInfo.degraded = true;
+    }
+    if (reasoningStrategy === "rewrite" && !deps.reasoning?.queryRewriter) {
+      warnings.push({
+        source: "memory",
+        code: "memory_query_rewrite_not_configured",
+        message: "Rewrite reasoning requested but no queryRewriter is configured; falling back to default search."
+      });
+      if (reasoningInfo) reasoningInfo.degraded = true;
+    }
+    if (reasoningStrategy === "iterative" && deps.reasoning?.iterativePlanner) {
+      const planner = deps.reasoning.iterativePlanner;
+      const result = await planner.plan({
+        query: input.query,
+        dateFrom: input.dateFrom,
+        dateTo: input.dateTo,
+        executor: {
+          search: async (request) => {
+            const keywords2 = request.keywords.length > 0 ? request.keywords : deriveLexicalKeywords(input.query);
+            const lexicalHits = await runLexicalSearchForKeywords(deps, input, keywords2, limit, logger);
+            let semanticHits = [];
+            if (typeof deps.embedQuery === "function") {
+              try {
+                const semanticQuery = keywords2.join(" ");
+                const queryEmbedding = await embedQueryVariant(deps.embedQuery, input, semanticQuery);
+                semanticHits = await runSemanticSearchForEmbedding(
+                  deps,
+                  input,
+                  queryEmbedding,
+                  limit,
+                  threshold,
+                  logger
+                );
+              } catch (error) {
+                logger.warn?.(
+                  "[memory-store] Iterative semantic search failed; using lexical results only:",
+                  error
+                );
+              }
+            }
+            const candidates = filterByDateRange(
+              mergeByMaxScore([
+                lexicalHits.map(toIterativeRecallCandidate),
+                semanticHits.map(toIterativeRecallCandidate)
+              ]),
+              request.dateFrom,
+              request.dateTo
+            );
+            return { candidates };
+          }
+        }
+      });
+      if (reasoningInfo) {
+        reasoningInfo.iterations = result.stats.iterations;
+        reasoningInfo.evidenceCount = result.evidence.length;
+        if (planner.lastDegraded?.()) {
+          reasoningInfo.degraded = true;
+        }
+      }
+      const semantic2 = result.evidence.map((candidate) => ({
+        type: "memory",
+        id: candidate.id,
+        content: candidate.content,
+        similarity: candidate.similarity,
+        metadata: { ...candidate.metadata, reasoning: "iterative" }
+      }));
+      return { semantic: semantic2, lexical: [] };
+    }
     if (typeof deps.embedQuery !== "function") {
       warnings.push({
         source: "memory",
         code: "memory_lexical_search_fallback",
         message: "Semantic search not configured, using keyword search as fallback"
       });
-      const { lexicalSearchRawMessages: lexicalSearchRawMessages2 } = await Promise.resolve().then(() => (init_sqlite_raw_message_store(), sqlite_raw_message_store_exports));
-      const keywords = deriveLexicalKeywords(input.query);
-      let lexical2 = [];
-      if (keywords.length > 0) {
-        try {
-          const filters2 = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
-          const results = await Promise.all(
-            filters2.map(
-              (botId) => lexicalSearchRawMessages2({
-                userId: input.userId,
-                keywords,
-                limit: Math.ceil(limit / filters2.length),
-                botId
-              })
-            )
-          );
-          lexical2 = results.flat().filter(Boolean).map(toMemoryResult);
-        } catch (error) {
-          logger.warn?.("[memory-store] Default lexical search failed:", error);
-        }
-      }
+      const keywords2 = deriveLexicalKeywords(input.query);
+      const lexical2 = filterByDateRange(
+        await runLexicalSearchForKeywords(deps, input, keywords2, limit, logger),
+        input.dateFrom,
+        input.dateTo
+      );
       return { semantic: [], lexical: lexical2 };
     }
-    const queryEmbedding = await deps.embedQuery({
-      userId: input.userId,
-      query: input.query,
-      authToken: input.authToken
-    });
-    const filters = input.botIds && input.botIds.length > 0 ? input.botIds.map((botId) => ({ botId })) : [{}];
     let semantic = [];
-    if (isRawMessageChromaEnabled()) {
+    const embedQuery = deps.embedQuery;
+    if (reasoningStrategy === "rewrite" && deps.reasoning?.queryRewriter) {
       try {
-        semantic = (await Promise.all(
-          filters.map((filter) => {
-            const botId = "botId" in filter ? filter.botId : void 0;
-            return searchRawMessagesWithChroma({
-              userId: input.userId,
-              queryEmbedding,
-              limit,
-              threshold,
-              botId
-            });
-          })
-        )).flat().map(toMemoryResult);
-        logger.log?.("[memory-store] Raw message semantic search completed", {
-          backend: "chroma",
-          dimensions: queryEmbedding.length,
-          count: semantic.length
+        const variants = await deps.reasoning.queryRewriter.rewrite({
+          query: input.query,
+          userId: input.userId,
+          authToken: input.authToken
         });
-      } catch (error) {
-        logger.warn?.(
-          "[memory-store] Chroma raw message search failed; falling back to database search:",
-          error
+        if (reasoningInfo) {
+          reasoningInfo.rewrittenQueries = variants;
+          if (deps.reasoning.queryRewriter.lastDegraded?.()) {
+            reasoningInfo.degraded = true;
+          }
+        }
+        const embeddings = await Promise.all(
+          variants.map((variant) => embedQueryVariant(embedQuery, input, variant))
         );
+        const lists = await Promise.all(
+          embeddings.map(
+            (embedding) => runSemanticSearchForEmbedding(deps, input, embedding, limit, threshold, logger)
+          )
+        );
+        semantic = mergeByMaxScore(lists);
+      } catch (error) {
+        logger.warn?.("[memory-store] Query rewriting failed; falling back to original query:", error);
+        warnings.push({
+          source: "memory",
+          code: "memory_query_rewrite_failed",
+          message: `Query rewriting failed: ${error.message ?? "Unknown error"}. Using original query.`
+        });
+        if (reasoningInfo) reasoningInfo.degraded = true;
       }
-    } else if (typeof deps.searchRawMessagesAnn === "function") {
-      semantic = (await Promise.all(
-        filters.map(
-          (filter) => deps.searchRawMessagesAnn({
-            userId: input.userId,
-            queryEmbedding,
-            limit,
-            threshold,
-            botId: "botId" in filter ? filter.botId : void 0
-          })
-        )
-      )).flat().filter(isRawMemorySemanticResult).map(toMemoryResult);
     }
     if (semantic.length === 0) {
-      try {
-        const { getRawMessageManager: getRawMessageManager2 } = await Promise.resolve().then(() => (init_raw_message_store(), raw_message_store_exports));
-        const manager2 = await getRawMessageManager2();
-        if (typeof manager2.searchMessagesSemantically === "function") {
-          const results = await manager2.searchMessagesSemantically({
-            userId: input.userId,
-            queryEmbedding,
-            limit,
-            threshold
-          });
-          semantic = results.map((r) => ({
-            type: "memory",
-            id: r.id,
-            content: r.content,
-            similarity: r.similarity,
-            metadata: r.metadata ?? {}
-          }));
-        }
-      } catch (error) {
-        logger.warn?.("[memory-store] SQLite semantic search failed:", error);
-      }
+      const queryEmbedding = await embedQueryVariant(embedQuery, input, input.query);
+      semantic = await runSemanticSearchForEmbedding(deps, input, queryEmbedding, limit, threshold, logger);
     }
     let lexical = [];
-    if (typeof deps.searchRawMessagesLexical === "function") {
-      const keywords = deriveLexicalKeywords(input.query);
-      if (keywords.length > 0) {
+    const keywords = deriveLexicalKeywords(input.query);
+    if (keywords.length > 0) {
+      if (typeof deps.searchRawMessagesLexical === "function") {
         try {
           const lexFilters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
+          const searchRawMessagesLexical = deps.searchRawMessagesLexical;
           lexical = (await Promise.all(
             lexFilters.map(
-              (botId) => deps.searchRawMessagesLexical({
+              (botId) => searchRawMessagesLexical({
                 userId: input.userId,
                 keywords,
                 limit,
@@ -674,20 +938,24 @@ function createUnifiedSearch(deps = {}) {
             message: error.message ?? "memory_lexical_search_failed"
           });
         }
+      } else if (input.mergeStrategy === "rrf") {
+        warnings.push({
+          source: "memory",
+          code: "memory_lexical_search_not_configured",
+          message: "RRF merge requested but lexical search is not configured; falling back to semantic-only RRF."
+        });
       }
-    } else if (input.mergeStrategy === "rrf") {
-      warnings.push({
-        source: "memory",
-        code: "memory_lexical_search_not_configured",
-        message: "RRF merge requested but lexical search is not configured; falling back to semantic-only RRF."
-      });
     }
-    return { semantic, lexical };
+    return {
+      semantic: filterByDateRange(semantic, input.dateFrom, input.dateTo),
+      lexical: filterByDateRange(lexical, input.dateFrom, input.dateTo)
+    };
   }
   async function searchRawMemorySemantically(input) {
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
-    const sub = await runMemorySource(input, limit, threshold, []);
+    const reasoningStrategy = resolveReasoningStrategy(input);
+    const sub = await runMemorySource(input, limit, threshold, [], reasoningStrategy);
     return mergeAcrossSources({
       memorySubs: sub,
       insightHits: [],
@@ -814,6 +1082,7 @@ async function startMcpServer(options = {}) {
     {
       title: "Search Unified Memory",
       description: "Semantic search across raw messages (always), and optionally insights and uploaded knowledge.",
+      // biome-ignore lint/suspicious/noExplicitAny: MCP SDK expects Zod schema type
       inputSchema: searchSchema
     },
     async (args) => {
@@ -829,6 +1098,7 @@ async function startMcpServer(options = {}) {
     {
       title: "Write Raw Message",
       description: "Persist a single raw message to the user's memory store.",
+      // biome-ignore lint/suspicious/noExplicitAny: MCP SDK expects Zod schema type
       inputSchema: writeSchema
     },
     async (args) => {
@@ -868,6 +1138,7 @@ async function startMcpServer(options = {}) {
     {
       title: "Get Raw Message",
       description: "Fetch a single raw message by its message id.",
+      // biome-ignore lint/suspicious/noExplicitAny: MCP SDK expects Zod schema type
       inputSchema: getSchema
     },
     async (args) => {