@prom.codes/memory-mcp 0.2.1 → 0.3.1

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // dist/bin.js
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // dist/composition.js
@@ -1150,7 +1151,10 @@ function discoverMemoryEmbedder(env) {
 }
 function composeFromEnv(opts) {
   const env = opts.env;
-  const workspaceRoot = resolve(env.PROMETHEUS_WORKSPACE_ROOT ?? process.cwd());
+  const override = (opts.workspaceRootOverride ?? "").trim();
+  const envRoot = (env.PROMETHEUS_WORKSPACE_ROOT ?? "").trim();
+  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;
@@ -1169,6 +1173,36 @@ function composeFromEnv(opts) {
   };
 }
 
+// dist/roots.js
+import { fileURLToPath } from "node:url";
+async function rootFromClient(server, timeoutMs = 2500) {
+  let supportsRoots = false;
+  try {
+    supportsRoots = server.getClientCapabilities()?.roots != null;
+  } catch {
+    return null;
+  }
+  if (!supportsRoots)
+    return null;
+  let res;
+  try {
+    res = await server.listRoots(void 0, { timeout: timeoutMs });
+  } catch {
+    return null;
+  }
+  const roots = res?.roots ?? [];
+  for (const r of roots) {
+    const uri = typeof r?.uri === "string" ? r.uri : "";
+    if (uri.startsWith("file://")) {
+      try {
+        return fileURLToPath(uri);
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
 // dist/server.js
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
@@ -1722,37 +1756,67 @@ var SERVER_IDENTITY = {
   title: "prom.codes Memory"
 };
 var SERVER_INSTRUCTIONS = "Persistent agent memory for this workspace. At the START of a session or task, call memory_read to recall facts, decisions and procedures from earlier sessions. When the user states a durable preference, decision or correction, store it with memory_write. Use memory_search for keyword recall when memory_read is not specific enough. At the END of a session, consolidate what was learned with memory_capture. Run memory_setup once per workspace to install the memory protocol into runtime rule files. Never store secrets, API keys or credentials \u2014 such writes are rejected.";
-function createServer(deps, options = {}) {
-  const identity = { ...SERVER_IDENTITY, ...options.identity ?? {} };
-  const capabilities = options.capabilities ?? { tools: {} };
-  const server = new McpServer(identity, {
-    capabilities,
-    instructions: SERVER_INSTRUCTIONS
-  });
-  registerTools(server, deps);
-  return server;
-}
 
 // dist/bin.js
 async function main() {
-  const composed = composeFromEnv({ env: process.env });
-  process.stderr.write(`prometheus-memory-mcp: workspace=${composed.workspaceRoot} project=${composed.projectName} (${composed.projectId}) db=${composed.dbPath} embed=${composed.embedderId}${composed.embeddingsEnabled ? "" : " (keyword-only)"}
-`);
-  const server = createServer(composed);
+  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: {} },
+    instructions: SERVER_INSTRUCTIONS
+  });
+  let composed = null;
   const shutdown = async (signal) => {
     process.stderr.write(`prometheus-memory-mcp: received ${signal}, shutting down
 `);
     try {
       await server.close();
     } finally {
-      await composed.close();
+      if (composed !== null)
+        await composed.close();
       process.exit(0);
     }
   };
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);
+  const boot = (override, via) => {
+    composed = composeFromEnv({
+      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)"}
+`);
+    registerTools(server, composed);
+  };
+  if (eagerVia !== null) {
+    boot(void 0, eagerVia);
+    await server.connect(transport);
+    return;
+  }
+  let booted = false;
+  const resolveAndBoot = async () => {
+    if (booted)
+      return;
+    booted = true;
+    try {
+      const fromRoots = await rootFromClient(server.server);
+      boot(fromRoots ?? process.cwd(), fromRoots !== null ? "MCP roots" : "cwd fallback (client advertised no roots)");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`prometheus-memory-mcp: fatal during boot: ${message}
+`);
+      process.exit(1);
+    }
+  };
+  server.server.oninitialized = () => {
+    void resolveAndBoot();
+  };
   await server.connect(transport);
+  const t = setTimeout(() => void resolveAndBoot(), 5e3);
+  t.unref?.();
 }
 main().catch((err) => {
   const message = err instanceof Error ? err.message : String(err);

package/package.json

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