@prom.codes/memory-mcp 0.5.0 → 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;
@@ -1695,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];
@@ -1935,7 +2114,7 @@ function composeFromEnv(opts) {
 }
 
 // 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 +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 {
       }
     }
@@ -1967,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";
 
@@ -2119,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",
@@ -2164,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"
@@ -2178,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) {
@@ -2193,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" };
 }
 
@@ -2563,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: {} },

package/package.json

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