@prom.codes/memory-mcp 0.4.1 → 0.5.1

package/dist/bin.js

@@ -4,10 +4,189 @@
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// ../shared/dist/types.js
+var GRAMMAR_LANGUAGE_IDS = [
+  "typescript",
+  "tsx",
+  "javascript",
+  "python",
+  "php",
+  "go",
+  "rust",
+  "java",
+  "csharp",
+  "c",
+  "cpp",
+  "ruby",
+  "kotlin",
+  "html"
+];
+var DOCUMENT_LANGUAGE_IDS = [
+  "markdown",
+  "text",
+  "json",
+  "yaml",
+  "toml"
+];
+var LANGUAGE_IDS = [
+  ...GRAMMAR_LANGUAGE_IDS,
+  ...DOCUMENT_LANGUAGE_IDS
+];
+
+// ../shared/dist/update-check.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+async function packageIdentity(binImportMetaUrl) {
+  try {
+    const binPath = fileURLToPath(binImportMetaUrl);
+    const pkgPath = join(binPath, "..", "..", "package.json");
+    const raw = await readFile(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.name !== "string" || typeof parsed.version !== "string") {
+      return null;
+    }
+    return { name: parsed.name, version: parsed.version };
+  } catch {
+    return null;
+  }
+}
+async function maybeNotifyUpdate(binImportMetaUrl, env = process.env) {
+  try {
+    const id = await packageIdentity(binImportMetaUrl);
+    if (id === null)
+      return;
+    await checkForUpdate({ name: id.name, version: id.version, env });
+  } catch {
+  }
+}
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 1500;
+var OPT_OUT_RE = /^(1|true|yes|on)$/i;
+function parseSemver(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(v.trim());
+  if (m === null)
+    return null;
+  return {
+    core: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] ?? null
+  };
+}
+function isNewerVersion(latest, current) {
+  const a = parseSemver(latest);
+  const b = parseSemver(current);
+  if (a === null || b === null)
+    return false;
+  for (let i = 0; i < 3; i++) {
+    if (a.core[i] > b.core[i])
+      return true;
+    if (a.core[i] < b.core[i])
+      return false;
+  }
+  if (a.pre === null && b.pre !== null)
+    return true;
+  return false;
+}
+function cachePath(dir, name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  return join(dir, `.update-check-${safe}.json`);
+}
+async function readCache(path2) {
+  try {
+    const raw = await readFile(path2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.checkedAt !== "number")
+      return null;
+    return {
+      checkedAt: parsed.checkedAt,
+      latest: typeof parsed.latest === "string" ? parsed.latest : null
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCache(path2, data) {
+  try {
+    await writeFile(path2, JSON.stringify(data), "utf8");
+  } catch {
+  }
+}
+async function fetchLatest(name, fetchImpl, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const url = `https://registry.npmjs.org/${name.replace("/", "%2F")}/latest`;
+    const res = await fetchImpl(url, {
+      signal: controller.signal,
+      headers: { accept: "application/vnd.npm.install-v1+json" }
+    });
+    if (!res.ok)
+      return null;
+    const body = await res.json();
+    return typeof body.version === "string" ? body.version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function checkForUpdate(options) {
+  const { name, version, env = process.env, log = (line) => process.stderr.write(line), fetch: fetchImpl = globalThis.fetch, cacheDir = join(homedir(), ".prometheus"), cacheTtlMs = DEFAULT_TTL_MS, timeoutMs = DEFAULT_TIMEOUT_MS, force = false } = options;
+  const base = {
+    latest: null,
+    current: version
+  };
+  if (OPT_OUT_RE.test(env.PROMETHEUS_NO_UPDATE_CHECK ?? "")) {
+    return { ...base, checked: false, updateAvailable: false, reason: "opted-out" };
+  }
+  if (parseSemver(version) === null || version === "0.0.0") {
+    return { ...base, checked: false, updateAvailable: false, reason: "invalid-version" };
+  }
+  if (typeof fetchImpl !== "function") {
+    return { ...base, checked: false, updateAvailable: false, reason: "error" };
+  }
+  const file = cachePath(cacheDir, name);
+  const now = Date.now();
+  if (!force) {
+    const cached = await readCache(file);
+    if (cached !== null && now - cached.checkedAt < cacheTtlMs) {
+      const updateAvailable2 = cached.latest !== null && isNewerVersion(cached.latest, version);
+      if (updateAvailable2)
+        notify(log, name, version, cached.latest);
+      return {
+        ...base,
+        latest: cached.latest,
+        checked: false,
+        updateAvailable: updateAvailable2,
+        reason: "throttled"
+      };
+    }
+  }
+  await mkdir(cacheDir, { recursive: true }).catch(() => void 0);
+  const latest = await fetchLatest(name, fetchImpl, timeoutMs);
+  await writeCache(file, { checkedAt: now, latest });
+  if (latest === null) {
+    return { ...base, checked: true, updateAvailable: false, reason: "error" };
+  }
+  const updateAvailable = isNewerVersion(latest, version);
+  if (updateAvailable)
+    notify(log, name, version, latest);
+  return { ...base, latest, checked: true, updateAvailable };
+}
+function notify(log, name, current, latest) {
+  log(`${name}: a newer version (${latest}) is available \u2014 you are on ${current}. npx users get it automatically on the next restart; for a global install run \`npm update -g ${name}\`. (Set PROMETHEUS_NO_UPDATE_CHECK=1 to silence.)
+`);
+}
+
+// ../shared/dist/index.js
+var PROMETHEUS_VERSION = "0.1.0";
+
 // dist/composition.js
 import { createHash } from "node:crypto";
-import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { basename, join as join2, resolve } from "node:path";
 
 // ../embeddings-openai-compat/dist/index.js
 var DEFAULT_BATCH = 96;
@@ -999,6 +1178,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 +1479,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 +1495,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 +1597,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 +1621,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
@@ -1601,7 +1874,7 @@ function projectIdFor(workspaceRoot) {
   return createHash("sha256").update(abs).digest("hex").slice(0, 16);
 }
 function defaultMemoryDbPath() {
-  return join(homedir(), ".prometheus", "memory.db");
+  return join2(homedir2(), ".prometheus", "memory.db");
 }
 function intEnv(env, name, def) {
   const raw = env[name];
@@ -1752,6 +2025,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 +2089,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,12 +2107,14 @@ function composeFromEnv(opts) {
     rerankerId,
     extractor,
     extractorId,
+    rewriter,
+    rewriterId,
     close: () => backend.close()
   };
 }
 
 // dist/roots.js
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function rootFromClient(server, timeoutMs = 2500) {
   let supportsRoots = false;
   try {
@@ -1807,7 +2135,7 @@ async function rootFromClient(server, timeoutMs = 2500) {
     const uri = typeof r?.uri === "string" ? r.uri : "";
     if (uri.startsWith("file://")) {
       try {
-        return fileURLToPath(uri);
+        return fileURLToPath2(uri);
       } catch {
       }
     }
@@ -1818,38 +2146,6 @@ async function rootFromClient(server, timeoutMs = 2500) {
 // dist/server.js
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
-// ../shared/dist/types.js
-var GRAMMAR_LANGUAGE_IDS = [
-  "typescript",
-  "tsx",
-  "javascript",
-  "python",
-  "php",
-  "go",
-  "rust",
-  "java",
-  "csharp",
-  "c",
-  "cpp",
-  "ruby",
-  "kotlin",
-  "html"
-];
-var DOCUMENT_LANGUAGE_IDS = [
-  "markdown",
-  "text",
-  "json",
-  "yaml",
-  "toml"
-];
-var LANGUAGE_IDS = [
-  ...GRAMMAR_LANGUAGE_IDS,
-  ...DOCUMENT_LANGUAGE_IDS
-];
-
-// ../shared/dist/index.js
-var PROMETHEUS_VERSION = "0.1.0";
-
 // dist/tools.js
 import { z } from "zod";
 
@@ -1970,8 +2266,8 @@ function assertNoSecrets(text) {
 
 // dist/setup.js
 import { existsSync } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join4 } from "node:path";
 var MEMORY_RUNTIMES = [
   "claude-code",
   "cursor",
@@ -2015,13 +2311,13 @@ alwaysApply: true
 var TARGETS = {
   "claude-code": { relPath: "CLAUDE.md", mode: "block", detect: "CLAUDE.md" },
   cursor: {
-    relPath: join3(".cursor", "rules", "prometheus-memory.mdc"),
+    relPath: join4(".cursor", "rules", "prometheus-memory.mdc"),
     mode: "file",
     fileContent: CURSOR_FRONTMATTER + withMarkers(RULE_BLOCK) + "\n",
     detect: ".cursor"
   },
   augment: {
-    relPath: join3(".augment", "rules", "prometheus-memory.md"),
+    relPath: join4(".augment", "rules", "prometheus-memory.md"),
     mode: "file",
     fileContent: withMarkers(RULE_BLOCK) + "\n",
     detect: ".augment"
@@ -2029,7 +2325,7 @@ var TARGETS = {
   agents: { relPath: "AGENTS.md", mode: "block", detect: "AGENTS.md" }
 };
 function detectRuntimes(workspaceRoot) {
-  const found = MEMORY_RUNTIMES.filter((rt) => existsSync(join3(workspaceRoot, TARGETS[rt].detect)));
+  const found = MEMORY_RUNTIMES.filter((rt) => existsSync(join4(workspaceRoot, TARGETS[rt].detect)));
   return found.length > 0 ? found : ["agents"];
 }
 function upsertBlock(existing, block) {
@@ -2044,15 +2340,15 @@ function upsertBlock(existing, block) {
 }
 async function installRuntime(workspaceRoot, runtime) {
   const target = TARGETS[runtime];
-  const absPath = join3(workspaceRoot, target.relPath);
+  const absPath = join4(workspaceRoot, target.relPath);
   const exists = existsSync(absPath);
-  const before = exists ? await readFile2(absPath, "utf-8") : "";
+  const before = exists ? await readFile3(absPath, "utf-8") : "";
   const after = target.mode === "file" ? target.fileContent : upsertBlock(before, RULE_BLOCK);
   if (exists && before === after) {
     return { runtime, path: absPath, action: "unchanged" };
   }
-  await mkdir2(dirname2(absPath), { recursive: true });
-  await writeFile2(absPath, after, "utf-8");
+  await mkdir3(dirname2(absPath), { recursive: true });
+  await writeFile3(absPath, after, "utf-8");
   return { runtime, path: absPath, action: exists ? "updated" : "created" };
 }
 
@@ -2414,6 +2710,7 @@ async function main() {
   const explicitRoot = (env.PROMETHEUS_WORKSPACE_ROOT ?? "").trim();
   const claudeRoot = (env.CLAUDE_PROJECT_DIR ?? "").trim();
   const eagerVia = explicitRoot !== "" ? "PROMETHEUS_WORKSPACE_ROOT" : claudeRoot !== "" ? "CLAUDE_PROJECT_DIR" : null;
+  void maybeNotifyUpdate(import.meta.url, env);
   const transport = new StdioServerTransport();
   const server = new McpServer2(SERVER_IDENTITY, {
     capabilities: { tools: {} },
@@ -2438,7 +2735,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.1",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {