@prom.codes/memory-mcp 0.5.0 → 0.6.0

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;
@@ -1128,6 +1307,45 @@ function reciprocalRankFusion(lists, options = {}) {
   return options.limit !== void 0 && options.limit >= 0 ? merged.slice(0, options.limit) : merged;
 }
 
+// dist/temporal.js
+var RRF_K = 60;
+var DEFAULT_TEMPORAL_WEIGHT = 2;
+var RECENT_RE = /\b(latest|most[\s-]?recent|recently|recent|current|currently|now|nowadays|today|newest|up[\s-]?to[\s-]?date|so far)\b/i;
+var EARLIEST_RE = /\b(earliest|oldest|first|initial|initially|original|originally|at the (?:very )?(?:start|beginning)|back then)\b/i;
+function detectTemporalIntent(query) {
+  if (query === "")
+    return null;
+  const recent = RECENT_RE.test(query);
+  const earliest = EARLIEST_RE.test(query);
+  if (recent === earliest)
+    return null;
+  return { direction: recent ? "recent" : "earliest" };
+}
+function parseTimestamp(iso) {
+  if (iso === null || iso === void 0 || iso === "")
+    return null;
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? ms : null;
+}
+function applyTemporalRanking(hits, intent, getTimestampMs, weight = DEFAULT_TEMPORAL_WEIGHT) {
+  if (hits.length <= 1 || weight <= 0)
+    return [...hits];
+  const stamped = hits.map((hit, index) => ({ hit, index, ts: getTimestampMs(hit) })).filter((x) => x.ts !== null);
+  if (stamped.length <= 1)
+    return [...hits];
+  const byTime = [...stamped].sort((a, b) => intent.direction === "recent" ? b.ts - a.ts : a.ts - b.ts);
+  const tempRank = /* @__PURE__ */ new Map();
+  byTime.forEach((x, rank) => tempRank.set(x.index, rank));
+  const scored = hits.map((hit, index) => {
+    const posScore = 1 / (RRF_K + index);
+    const tr = tempRank.get(index);
+    const tempScore = tr === void 0 ? 0 : 1 / (RRF_K + tr);
+    return { hit, index, score: posScore + weight * tempScore };
+  });
+  scored.sort((a, b) => b.score - a.score || a.index - b.index);
+  return scored.map((s) => s.hit);
+}
+
 // dist/types.js
 var MEMORY_SCOPES = [
   "system",
@@ -1301,6 +1519,8 @@ var SqliteMemoryBackend = class {
   embedder;
   reranker;
   rewriter;
+  temporalEnabled;
+  temporalWeight;
   /** Record ids whose vector is missing/stale, awaiting a batched embed. */
   pendingEmbed = /* @__PURE__ */ new Set();
   closed = false;
@@ -1317,6 +1537,8 @@ var SqliteMemoryBackend = class {
     this.embedder = opts.embedder;
     this.reranker = opts.reranker;
     this.rewriter = opts.rewriter;
+    this.temporalEnabled = opts.temporal?.enabled ?? false;
+    this.temporalWeight = opts.temporal?.weight ?? DEFAULT_TEMPORAL_WEIGHT;
     if (this.embedder !== void 0)
       this.queueUnembedded();
   }
@@ -1440,7 +1662,20 @@ var SqliteMemoryBackend = class {
       ], { limit: poolLimit }).map((f) => f.payload);
     }
     const reranked = input.rerank === false ? pool : await this.rerankPool(input.query, pool, finalLimit);
-    return reranked.slice(0, finalLimit);
+    const temporalOn = input.temporal ?? this.temporalEnabled;
+    const ordered = temporalOn ? this.applyTemporal(input.query, reranked) : reranked;
+    return ordered.slice(0, finalLimit);
+  }
+  /**
+   * M5: blend the current order with a timestamp order when the query expresses
+   * a clear temporal direction. Uses `updatedAt` (falls back to `createdAt`) as
+   * the record's time. No-op when no intent is detected.
+   */
+  applyTemporal(query, hits) {
+    const intent = detectTemporalIntent(query);
+    if (intent === null)
+      return hits;
+    return applyTemporalRanking(hits, intent, (h) => parseTimestamp(h.record.updatedAt) ?? parseTimestamp(h.record.createdAt), this.temporalWeight);
   }
   /**
    * M4: rewrite the query for the retrieval channels (HyDE concat). Returns the
@@ -1695,7 +1930,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];
@@ -1897,6 +2132,18 @@ function discoverMemoryRewriter(env) {
   }
   throw new Error(`unknown PROMETHEUS_MEMORY_REWRITE_PROVIDER="${forced}" (expected "none", "mistral", "openai", or "generic")`);
 }
+function discoverMemoryTemporal(env) {
+  const raw = (env.PROMETHEUS_MEMORY_TEMPORAL ?? "off").toLowerCase();
+  const enabled = raw === "on" || raw === "1" || raw === "true" || raw === "yes";
+  const rawWeight = env.PROMETHEUS_MEMORY_TEMPORAL_WEIGHT;
+  let weight = DEFAULT_TEMPORAL_WEIGHT;
+  if (rawWeight !== void 0 && rawWeight !== "") {
+    const n = Number.parseFloat(rawWeight);
+    if (Number.isFinite(n) && n >= 0)
+      weight = n;
+  }
+  return { enabled, weight };
+}
 function composeFromEnv(opts) {
   const env = opts.env;
   const override = (opts.workspaceRootOverride ?? "").trim();
@@ -1911,10 +2158,12 @@ function composeFromEnv(opts) {
   const { id: rerankerId, provider: reranker } = discoverMemoryReranker(env);
   const { id: extractorId, provider: extractor } = discoverMemoryExtractor(env);
   const { id: rewriterId, provider: rewriter } = discoverMemoryRewriter(env);
+  const temporal = discoverMemoryTemporal(env);
   const backend = new SqliteMemoryBackend(dbPath, {
     ...embedder !== void 0 ? { embedder } : {},
     ...reranker !== null ? { reranker } : {},
-    ...rewriter !== null ? { rewriter } : {}
+    ...rewriter !== null ? { rewriter } : {},
+    temporal
   });
   return {
     backend,
@@ -1930,12 +2179,13 @@ function composeFromEnv(opts) {
     extractorId,
     rewriter,
     rewriterId,
+    temporalEnabled: temporal.enabled,
     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 {
@@ -1956,7 +2206,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 {
       }
     }
@@ -1967,38 +2217,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";
 
@@ -2119,8 +2337,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",
@@ -2164,13 +2382,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"
@@ -2178,7 +2396,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) {
@@ -2193,15 +2411,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" };
 }
 
@@ -2563,6 +2781,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: {} },
@@ -2587,7 +2806,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} rewrite=${composed.rewriterId}
+    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} temporal=${composed.temporalEnabled ? "on" : "off"}
 `);
     registerTools(server, composed);
   };

package/package.json

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