@prom.codes/memory-mcp 0.3.0 → 0.3.2

package/dist/bin.js

@@ -506,6 +506,377 @@ var PrometheusEmbeddingProvider = class {
   }
 };
 
+// ../rerank-voyage/dist/index.js
+var DEFAULT_MODEL = "rerank-2.5";
+var DEFAULT_BASE_URL = "https://api.voyageai.com/v1";
+var DEFAULT_BATCH3 = 100;
+var DEFAULT_RETRIES3 = 6;
+var DEFAULT_BACKOFF3 = 2e3;
+var DEFAULT_RETRY_MAX2 = 6e4;
+function parseRetryAfterMs2(value, now = Date.now()) {
+  if (value === null)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  if (/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) {
+    const secs = Number(trimmed);
+    if (!Number.isFinite(secs) || secs < 0)
+      return null;
+    return Math.round(secs * 1e3);
+  }
+  if (!/[A-Za-z]/.test(trimmed))
+    return null;
+  const ts = Date.parse(trimmed);
+  if (!Number.isFinite(ts))
+    return null;
+  const delta = ts - now;
+  return delta > 0 ? delta : 0;
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable3(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var VoyageRerankProvider = class {
+  name;
+  model;
+  region;
+  #baseUrl;
+  #apiKey;
+  #batchSize;
+  #maxRetries;
+  #retryBaseMs;
+  #retryMaxMs;
+  #fetch;
+  constructor(opts) {
+    if (typeof opts.apiKey !== "string" || opts.apiKey === "") {
+      throw new Error("VoyageRerankProvider: apiKey is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`VoyageRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    this.model = opts.model ?? DEFAULT_MODEL;
+    this.name = opts.name ?? `voyage:${this.model}`;
+    this.region = opts.region ?? "us";
+    this.#baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.#apiKey = opts.apiKey;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH3;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES3;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF3;
+    this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX2;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    for (let start = 0; start < candidates.length; start += this.#batchSize) {
+      const slice = candidates.slice(start, start + this.#batchSize);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+    }
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const body = {
+      query,
+      documents: batch.map((c) => c.text),
+      model: this.model,
+      return_documents: false,
+      truncation: true
+    };
+    const init = {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.#apiKey}`
+      },
+      body: JSON.stringify(body)
+    };
+    if (signal !== void 0)
+      init.signal = signal;
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      try {
+        const res = await this.#fetch(`${this.#baseUrl}/rerank`, init);
+        if (res.status === 429 || res.status >= 500 && res.status < 600) {
+          lastError = new Error(`${this.name}: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
+          await sleep3(backoff, signal);
+          continue;
+        }
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw nonRetryable3(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+        }
+        const payload = await res.json();
+        return this.#decode(payload, batch.length);
+      } catch (err) {
+        if (err?.name === "AbortError")
+          throw err;
+        if (err?.nonRetryable === true)
+          throw err;
+        if (attempt >= this.#maxRetries)
+          throw err;
+        lastError = err;
+        attempt += 1;
+        await sleep3(this.#computeBackoff(attempt, null), signal);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`${this.name}: exhausted ${this.#maxRetries} retries`);
+  }
+  #computeBackoff(attempt, retryAfterHeader) {
+    const exp = this.#retryBaseMs * 2 ** Math.max(0, attempt - 1);
+    const advised = parseRetryAfterMs2(retryAfterHeader);
+    const lower = advised === null ? exp : Math.max(exp, advised);
+    return Math.min(lower, this.#retryMaxMs);
+  }
+  #decode(payload, expected) {
+    if (!Array.isArray(payload.data) || payload.data.length !== expected) {
+      throw nonRetryable3(`${this.name}: expected ${expected} rerank rows, got ${payload.data?.length ?? 0}`);
+    }
+    return payload.data.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
+        throw nonRetryable3(`${this.name}: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
+        throw nonRetryable3(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevance_score };
+    });
+  }
+};
+
+// ../rerank-openai-compat/dist/index.js
+var DEFAULT_MODEL2 = "bge-reranker-base";
+var DEFAULT_BATCH4 = 100;
+var DEFAULT_RETRIES4 = 6;
+var DEFAULT_BACKOFF4 = 2e3;
+var DEFAULT_RETRY_MAX3 = 6e4;
+var DEFAULT_TIMEOUT = 18e4;
+function parseRetryAfterMs3(value, now = Date.now()) {
+  if (value === null)
+    return null;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  if (/^[0-9]+(\.[0-9]+)?$/.test(trimmed)) {
+    const secs = Number(trimmed);
+    if (!Number.isFinite(secs) || secs < 0)
+      return null;
+    return Math.round(secs * 1e3);
+  }
+  if (!/[A-Za-z]/.test(trimmed))
+    return null;
+  const ts = Date.parse(trimmed);
+  if (!Number.isFinite(ts))
+    return null;
+  const delta = ts - now;
+  return delta > 0 ? delta : 0;
+}
+function sleep4(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable4(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var OpenAICompatRerankProvider = class {
+  name;
+  model;
+  region;
+  #baseUrl;
+  #apiKey;
+  #batchSize;
+  #maxRetries;
+  #retryBaseMs;
+  #retryMaxMs;
+  #timeoutMs;
+  #fetch;
+  constructor(opts) {
+    if (typeof opts.baseUrl !== "string" || opts.baseUrl === "") {
+      throw new Error("OpenAICompatRerankProvider: baseUrl is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`OpenAICompatRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    if (opts.timeoutMs !== void 0 && (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 0)) {
+      throw new Error(`OpenAICompatRerankProvider: timeoutMs must be a non-negative integer (0 disables), got ${opts.timeoutMs}`);
+    }
+    this.model = opts.model ?? DEFAULT_MODEL2;
+    this.name = opts.name ?? `openai-compat:${this.model}`;
+    this.region = opts.region ?? "self-hosted";
+    this.#baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.#apiKey = opts.apiKey === void 0 || opts.apiKey === "" ? void 0 : opts.apiKey;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH4;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES4;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF4;
+    this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX3;
+    this.#timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    for (let start = 0; start < candidates.length; start += this.#batchSize) {
+      const slice = candidates.slice(start, start + this.#batchSize);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+    }
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const body = {
+      query,
+      documents: batch.map((c) => c.text),
+      model: this.model,
+      return_documents: false
+    };
+    const headers = { "content-type": "application/json" };
+    if (this.#apiKey !== void 0)
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    const payloadJson = JSON.stringify(body);
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      const controller = new AbortController();
+      let timedOut = false;
+      let timer;
+      if (this.#timeoutMs > 0) {
+        timer = setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, this.#timeoutMs);
+      }
+      const onParentAbort = () => controller.abort();
+      if (signal !== void 0) {
+        if (signal.aborted)
+          controller.abort();
+        else
+          signal.addEventListener("abort", onParentAbort, { once: true });
+      }
+      const init = {
+        method: "POST",
+        headers,
+        body: payloadJson,
+        signal: controller.signal
+      };
+      try {
+        const res = await this.#fetch(`${this.#baseUrl}/rerank`, init);
+        if (res.status === 429 || res.status >= 500 && res.status < 600) {
+          lastError = new Error(`${this.name}: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
+          await sleep4(backoff, signal);
+          continue;
+        }
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw nonRetryable4(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+        }
+        const payload = await res.json();
+        return this.#decode(payload, batch.length);
+      } catch (err) {
+        const isAbort = err?.name === "AbortError";
+        if (isAbort && !timedOut)
+          throw err;
+        if (!isAbort && err?.nonRetryable === true)
+          throw err;
+        const normalized = timedOut ? new Error(`${this.name}: request timed out after ${this.#timeoutMs}ms`) : err;
+        if (attempt >= this.#maxRetries)
+          throw normalized;
+        lastError = normalized;
+        attempt += 1;
+        await sleep4(this.#computeBackoff(attempt, null), signal);
+      } finally {
+        if (timer !== void 0)
+          clearTimeout(timer);
+        if (signal !== void 0)
+          signal.removeEventListener("abort", onParentAbort);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`${this.name}: exhausted ${this.#maxRetries} retries`);
+  }
+  #computeBackoff(attempt, retryAfterHeader) {
+    const exp = this.#retryBaseMs * 2 ** Math.max(0, attempt - 1);
+    const advised = parseRetryAfterMs3(retryAfterHeader);
+    const lower = advised === null ? exp : Math.max(exp, advised);
+    return Math.min(lower, this.#retryMaxMs);
+  }
+  #decode(payload, expected) {
+    if (!Array.isArray(payload.results) || payload.results.length !== expected) {
+      throw nonRetryable4(`${this.name}: expected ${expected} rerank rows, got ${payload.results?.length ?? 0}`);
+    }
+    return payload.results.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
+        throw nonRetryable4(`${this.name}: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
+        throw nonRetryable4(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevance_score };
+    });
+  }
+};
+
 // dist/api-key.js
 var KEY_PATTERN = /^prom_(live|test)_[A-Za-z0-9]{10,}$/;
 var API_KEY_ENV = "PROMETHEUS_API_KEY";
@@ -747,6 +1118,7 @@ function rowToRecord(row) {
 var SqliteMemoryBackend = class {
   db;
   embedder;
+  reranker;
   /** Record ids whose vector is missing/stale, awaiting a batched embed. */
   pendingEmbed = /* @__PURE__ */ new Set();
   closed = false;
@@ -761,6 +1133,7 @@ var SqliteMemoryBackend = class {
     this.db.exec(VEC_SCHEMA);
     this.db.exec(`INSERT INTO agent_memory_fts (agent_memory_fts) VALUES ('rebuild')`);
     this.embedder = opts.embedder;
+    this.reranker = opts.reranker;
     if (this.embedder !== void 0)
       this.queueUnembedded();
   }
@@ -871,15 +1244,44 @@ var SqliteMemoryBackend = class {
         vecHits = [];
       }
     }
-    if (vecHits.length === 0)
-      return ftsHits.slice(0, finalLimit);
-    if (ftsHits.length === 0)
-      return vecHits.slice(0, finalLimit);
-    const fused = reciprocalRankFusion([
-      { id: "fts", items: ftsHits.map((h) => ({ key: h.record.id, payload: h })) },
-      { id: "vec", items: vecHits.map((h) => ({ key: h.record.id, payload: h })) }
-    ], { limit: finalLimit });
-    return fused.map((f) => f.payload);
+    let pool;
+    if (vecHits.length === 0) {
+      pool = ftsHits;
+    } else if (ftsHits.length === 0) {
+      pool = vecHits;
+    } else {
+      pool = reciprocalRankFusion([
+        { id: "fts", items: ftsHits.map((h) => ({ key: h.record.id, payload: h })) },
+        { id: "vec", items: vecHits.map((h) => ({ key: h.record.id, payload: h })) }
+      ], { limit: poolLimit }).map((f) => f.payload);
+    }
+    const reranked = await this.rerankPool(input.query, pool, finalLimit);
+    return reranked.slice(0, finalLimit);
+  }
+  /**
+   * Reorder a first-stage pool with the cross-encoder reranker, scoring each
+   * candidate's `key + value` jointly against the query. Returns the pool
+   * unchanged when no reranker is configured, the pool is trivial, or the
+   * provider errors.
+   */
+  async rerankPool(query, pool, topK) {
+    if (this.reranker === void 0 || pool.length <= 1)
+      return pool;
+    try {
+      const candidates = pool.map((h) => ({
+        id: h.record.id,
+        text: `${h.record.key}
+${h.record.value}`
+      }));
+      const hits = await this.reranker.rerank(query, candidates, { topK });
+      if (hits.length === 0)
+        return pool;
+      const byId = new Map(pool.map((h) => [h.record.id, h]));
+      const reordered = hits.map((h) => byId.get(h.id)).filter((h) => h !== void 0);
+      return reordered.length > 0 ? reordered : pool;
+    } catch {
+      return pool;
+    }
   }
   /** FTS5 BM25 keyword channel → ranked hits (best first). */
   ftsSearch(input, limit) {
@@ -1149,17 +1551,64 @@ function discoverMemoryEmbedder(env) {
   }
   return { id: "none", embedder: void 0 };
 }
+function discoverMemoryReranker(env) {
+  const forced = (env.PROMETHEUS_MEMORY_RERANK_PROVIDER ?? "none").toLowerCase();
+  if (forced === "" || forced === "none")
+    return { id: "none", provider: null };
+  if (forced === "voyage") {
+    const apiKey = env.VOYAGE_API_KEY;
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error('PROMETHEUS_MEMORY_RERANK_PROVIDER="voyage" requires VOYAGE_API_KEY.');
+    }
+    const provider = new VoyageRerankProvider({
+      name: "voyage-rerank",
+      apiKey,
+      model: env.VOYAGE_RERANK_MODEL ?? "rerank-2.5",
+      region: "us",
+      baseUrl: env.VOYAGE_BASE_URL ?? "https://api.voyageai.com/v1",
+      maxRetries: intEnv(env, "VOYAGE_RERANK_MAX_RETRIES", 6),
+      retryBaseMs: intEnv(env, "VOYAGE_RERANK_RETRY_BASE_MS", 2e3),
+      batchSize: intEnv(env, "VOYAGE_RERANK_BATCH", 100)
+    });
+    return { id: "voyage", provider };
+  }
+  if (forced === "bge" || forced === "generic") {
+    const baseUrl = env.PROMETHEUS_MEMORY_RERANK_ENDPOINT;
+    if (baseUrl === void 0 || baseUrl === "") {
+      throw new Error(`PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" requires PROMETHEUS_MEMORY_RERANK_ENDPOINT.`);
+    }
+    const model = env.PROMETHEUS_MEMORY_RERANK_MODEL ?? "bge-reranker-base";
+    const provider = new OpenAICompatRerankProvider({
+      name: env.PROMETHEUS_MEMORY_RERANK_NAME ?? `bge-rerank:${model}`,
+      model,
+      region: "self-hosted",
+      baseUrl,
+      maxRetries: intEnv(env, "PROMETHEUS_MEMORY_RERANK_MAX_RETRIES", 6),
+      retryBaseMs: intEnv(env, "PROMETHEUS_MEMORY_RERANK_RETRY_BASE_MS", 2e3),
+      batchSize: intEnv(env, "PROMETHEUS_MEMORY_RERANK_BATCH", 100),
+      timeoutMs: intEnv(env, "PROMETHEUS_MEMORY_RERANK_TIMEOUT_MS", 18e4),
+      ...env.PROMETHEUS_MEMORY_RERANK_API_KEY ? { apiKey: env.PROMETHEUS_MEMORY_RERANK_API_KEY } : {}
+    });
+    return { id: "bge", provider };
+  }
+  throw new Error(`unknown PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" (expected "none", "voyage", or "bge")`);
+}
 function composeFromEnv(opts) {
   const env = opts.env;
   const override = (opts.workspaceRootOverride ?? "").trim();
   const envRoot = (env.PROMETHEUS_WORKSPACE_ROOT ?? "").trim();
-  const workspaceRoot = resolve(override !== "" ? override : envRoot !== "" ? envRoot : process.cwd());
+  const claudeRoot = (env.CLAUDE_PROJECT_DIR ?? "").trim();
+  const workspaceRoot = resolve(override !== "" ? override : envRoot !== "" ? envRoot : claudeRoot !== "" ? claudeRoot : process.cwd());
   const projectId = projectIdFor(workspaceRoot);
   const projectName = basename(workspaceRoot) || workspaceRoot;
   const rawDbPath = env.PROMETHEUS_MEMORY_DB_PATH;
   const dbPath = rawDbPath !== void 0 && rawDbPath !== "" ? rawDbPath : defaultMemoryDbPath();
   const { id: embedderId, embedder } = discoverMemoryEmbedder(env);
-  const backend = new SqliteMemoryBackend(dbPath, embedder !== void 0 ? { embedder } : {});
+  const { id: rerankerId, provider: reranker } = discoverMemoryReranker(env);
+  const backend = new SqliteMemoryBackend(dbPath, {
+    ...embedder !== void 0 ? { embedder } : {},
+    ...reranker !== null ? { reranker } : {}
+  });
   return {
     backend,
     workspaceRoot,
@@ -1168,6 +1617,8 @@ function composeFromEnv(opts) {
     dbPath,
     embeddingsEnabled: embedder !== void 0,
     embedderId,
+    reranker,
+    rerankerId,
     close: () => backend.close()
   };
 }
@@ -1760,6 +2211,8 @@ var SERVER_INSTRUCTIONS = "Persistent agent memory for this workspace. At the ST
 async function main() {
   const env = process.env;
   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;
   const transport = new StdioServerTransport();
   const server = new McpServer2(SERVER_IDENTITY, {
     capabilities: { tools: {} },
@@ -1784,12 +2237,12 @@ 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)"}
+    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}
 `);
     registerTools(server, composed);
   };
-  if (explicitRoot !== "") {
-    boot(void 0, "PROMETHEUS_WORKSPACE_ROOT");
+  if (eagerVia !== null) {
+    boot(void 0, eagerVia);
     await server.connect(transport);
     return;
   }

package/package.json

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