@prom.codes/memory-mcp 0.4.1 → 0.5.0

package/dist/bin.js

@@ -999,6 +999,79 @@ function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+// dist/rewrite.js
+var SYSTEM_PROMPT2 = "You help search an AI agent's long-term memory of a software project and its conversations. Given a question, write ONE short hypothetical memory entry (1\u20132 sentences, plain statements) that \u2014 if it existed \u2014 would directly answer it. Use concrete nouns, names and likely phrasings a developer would store. Do NOT answer that you don't know, do NOT add preamble or quotes \u2014 output only the hypothetical statement.";
+var OpenAICompatRewriter = class {
+  name;
+  model;
+  #url;
+  #apiKey;
+  #maxRetries;
+  #retryBaseMs;
+  #maxTokens;
+  #temperature;
+  #fetch;
+  constructor(opts) {
+    this.name = opts.name;
+    this.model = opts.model;
+    this.#url = `${opts.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+    this.#apiKey = opts.apiKey;
+    this.#maxRetries = opts.maxRetries ?? 2;
+    this.#retryBaseMs = opts.retryBaseMs ?? 400;
+    this.#maxTokens = opts.maxTokens ?? 160;
+    this.#temperature = opts.temperature ?? 0;
+    this.#fetch = opts.fetchImpl ?? fetch;
+  }
+  async rewrite(query, opts) {
+    const trimmed = query.trim();
+    if (trimmed === "")
+      return [];
+    const n = Math.max(1, opts?.n ?? 1);
+    const body = JSON.stringify({
+      model: this.model,
+      temperature: this.#temperature,
+      max_tokens: this.#maxTokens,
+      n,
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT2 },
+        { role: "user", content: `Question: ${trimmed}` }
+      ]
+    });
+    const headers = { "content-type": "application/json" };
+    if (this.#apiKey !== void 0 && this.#apiKey !== "") {
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    }
+    for (let attempt = 0; attempt <= this.#maxRetries; attempt++) {
+      try {
+        const res = await this.#fetch(this.#url, {
+          method: "POST",
+          headers,
+          body,
+          ...opts?.signal ? { signal: opts.signal } : {}
+        });
+        if (res.status === 429 || res.status >= 500) {
+        } else if (!res.ok) {
+          return [];
+        } else {
+          const json = await res.json();
+          const out = [];
+          for (const c of json.choices ?? []) {
+            const t = (c.message?.content ?? "").trim();
+            if (t !== "")
+              out.push(t.slice(0, 1e3));
+          }
+          return out;
+        }
+      } catch {
+      }
+      if (attempt < this.#maxRetries) {
+        await new Promise((r) => setTimeout(r, this.#retryBaseMs * 2 ** attempt));
+      }
+    }
+    return [];
+  }
+};
+
 // dist/sqlite.js
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
@@ -1227,6 +1300,7 @@ var SqliteMemoryBackend = class {
   db;
   embedder;
   reranker;
+  rewriter;
   /** Record ids whose vector is missing/stale, awaiting a batched embed. */
   pendingEmbed = /* @__PURE__ */ new Set();
   closed = false;
@@ -1242,6 +1316,7 @@ var SqliteMemoryBackend = class {
     this.db.exec(`INSERT INTO agent_memory_fts (agent_memory_fts) VALUES ('rebuild')`);
     this.embedder = opts.embedder;
     this.reranker = opts.reranker;
+    this.rewriter = opts.rewriter;
     if (this.embedder !== void 0)
       this.queueUnembedded();
   }
@@ -1343,11 +1418,12 @@ var SqliteMemoryBackend = class {
       return [];
     const finalLimit = input.limit ?? 20;
     const poolLimit = Math.max(finalLimit * 4, 40);
-    const ftsHits = this.ftsSearch(input, poolLimit);
+    const channelInput = await this.applyRewrite(input);
+    const ftsHits = this.ftsSearch(channelInput, poolLimit);
     let vecHits = [];
     if (this.embedder !== void 0) {
       try {
-        vecHits = await this.vectorSearch(input, poolLimit);
+        vecHits = await this.vectorSearch(channelInput, poolLimit);
       } catch {
         vecHits = [];
       }
@@ -1366,6 +1442,24 @@ var SqliteMemoryBackend = class {
     const reranked = input.rerank === false ? pool : await this.rerankPool(input.query, pool, finalLimit);
     return reranked.slice(0, finalLimit);
   }
+  /**
+   * M4: rewrite the query for the retrieval channels (HyDE concat). Returns the
+   * input unchanged when no rewriter is configured or it errors/empties.
+   */
+  async applyRewrite(input) {
+    if (this.rewriter === void 0 || input.rewrite === false)
+      return input;
+    try {
+      const docs = await this.rewriter.rewrite(input.query, { n: 1 });
+      const hyp = docs[0]?.trim();
+      if (hyp)
+        return { ...input, query: `${input.query}
+
+${hyp}` };
+    } catch {
+    }
+    return input;
+  }
   /**
    * Reorder a first-stage pool with the cross-encoder reranker, scoring each
    * candidate's `key + value` jointly against the query. Returns the pool
@@ -1752,6 +1846,57 @@ function discoverMemoryExtractor(env) {
   }
   throw new Error(`unknown PROMETHEUS_MEMORY_EXTRACT_PROVIDER="${forced}" (expected "none", "mistral", "openai", or "generic")`);
 }
+function discoverMemoryRewriter(env) {
+  const forced = (env.PROMETHEUS_MEMORY_REWRITE_PROVIDER ?? "none").toLowerCase();
+  if (forced === "" || forced === "none")
+    return { id: "none", provider: null };
+  if (forced === "mistral") {
+    const apiKey = env.MISTRAL_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error('PROMETHEUS_MEMORY_REWRITE_PROVIDER="mistral" requires MISTRAL_API_KEY.');
+    }
+    return {
+      id: "mistral",
+      provider: new OpenAICompatRewriter({
+        name: "mistral-rewrite",
+        model: env.PROMETHEUS_MEMORY_REWRITE_MODEL ?? "mistral-small-latest",
+        baseUrl: env.MISTRAL_BASE_URL ?? "https://api.mistral.ai/v1",
+        apiKey
+      })
+    };
+  }
+  if (forced === "openai") {
+    const apiKey = env.OPENAI_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error('PROMETHEUS_MEMORY_REWRITE_PROVIDER="openai" requires OPENAI_API_KEY.');
+    }
+    return {
+      id: "openai",
+      provider: new OpenAICompatRewriter({
+        name: "openai-rewrite",
+        model: env.PROMETHEUS_MEMORY_REWRITE_MODEL ?? "gpt-4o-mini",
+        baseUrl: env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+        apiKey
+      })
+    };
+  }
+  if (forced === "generic" || forced === "openai-compat") {
+    const baseUrl = env.PROMETHEUS_MEMORY_REWRITE_ENDPOINT;
+    if (baseUrl === void 0 || baseUrl === "") {
+      throw new Error(`PROMETHEUS_MEMORY_REWRITE_PROVIDER="${forced}" requires PROMETHEUS_MEMORY_REWRITE_ENDPOINT.`);
+    }
+    return {
+      id: "generic",
+      provider: new OpenAICompatRewriter({
+        name: env.PROMETHEUS_MEMORY_REWRITE_NAME ?? "generic-rewrite",
+        model: env.PROMETHEUS_MEMORY_REWRITE_MODEL ?? "default",
+        baseUrl,
+        ...env.PROMETHEUS_MEMORY_REWRITE_API_KEY ? { apiKey: env.PROMETHEUS_MEMORY_REWRITE_API_KEY } : {}
+      })
+    };
+  }
+  throw new Error(`unknown PROMETHEUS_MEMORY_REWRITE_PROVIDER="${forced}" (expected "none", "mistral", "openai", or "generic")`);
+}
 function composeFromEnv(opts) {
   const env = opts.env;
   const override = (opts.workspaceRootOverride ?? "").trim();
@@ -1765,9 +1910,11 @@ function composeFromEnv(opts) {
   const { id: embedderId, embedder } = discoverMemoryEmbedder(env);
   const { id: rerankerId, provider: reranker } = discoverMemoryReranker(env);
   const { id: extractorId, provider: extractor } = discoverMemoryExtractor(env);
+  const { id: rewriterId, provider: rewriter } = discoverMemoryRewriter(env);
   const backend = new SqliteMemoryBackend(dbPath, {
     ...embedder !== void 0 ? { embedder } : {},
-    ...reranker !== null ? { reranker } : {}
+    ...reranker !== null ? { reranker } : {},
+    ...rewriter !== null ? { rewriter } : {}
   });
   return {
     backend,
@@ -1781,6 +1928,8 @@ function composeFromEnv(opts) {
     rerankerId,
     extractor,
     extractorId,
+    rewriter,
+    rewriterId,
     close: () => backend.close()
   };
 }
@@ -2438,7 +2587,7 @@ async function main() {
       env,
       ...override !== void 0 && override !== "" ? { workspaceRootOverride: override } : {}
     });
-    process.stderr.write(`prometheus-memory-mcp: workspace=${composed.workspaceRoot} (via ${via}) project=${composed.projectName} (${composed.projectId}) db=${composed.dbPath} embed=${composed.embedderId}${composed.embeddingsEnabled ? "" : " (keyword-only)"} rerank=${composed.rerankerId} extract=${composed.extractorId}
+    process.stderr.write(`prometheus-memory-mcp: workspace=${composed.workspaceRoot} (via ${via}) project=${composed.projectName} (${composed.projectId}) db=${composed.dbPath} embed=${composed.embedderId}${composed.embeddingsEnabled ? "" : " (keyword-only)"} rerank=${composed.rerankerId} extract=${composed.extractorId} rewrite=${composed.rewriterId}
 `);
     registerTools(server, composed);
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prom.codes/memory-mcp",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {