@prom.codes/memory-mcp 0.3.2 → 0.4.1

package/dist/bin.js

@@ -891,6 +891,114 @@ function requireApiKey(env) {
   return key;
 }
 
+// dist/extraction.js
+var SYSTEM_PROMPT = 'You extract durable, atomic facts from a coding agent\'s session notes for long-term project memory. Output ONLY a JSON array of objects {"key":..., "value":...}. Each fact must be ONE self-contained statement that will be useful in a FUTURE session: a decision, a convention, a preference, a stable configuration, or a learned fact about the project. `key` is a short kebab-case slug; `value` is the full fact in one sentence. DROP transient step-by-step narration, anything true only for this one session, and anything obvious. Never invent facts not supported by the notes. If there is nothing durable, output []. Output at most 12 facts.';
+function parseExtraction(raw, maxFacts = 12, maxValueChars = 2e3) {
+  const match = raw.match(/\[[\s\S]*\]/);
+  if (!match)
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(match[0]);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed))
+    return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of parsed) {
+    if (out.length >= maxFacts)
+      break;
+    if (typeof item !== "object" || item === null)
+      continue;
+    const rec = item;
+    const rawKey = typeof rec.key === "string" ? rec.key : "";
+    const value = typeof rec.value === "string" ? rec.value.trim() : "";
+    if (value === "")
+      continue;
+    const key = slugify(rawKey) || slugify(value).slice(0, 48);
+    if (key === "" || seen.has(key))
+      continue;
+    seen.add(key);
+    const fact = { key, value: value.slice(0, maxValueChars) };
+    out.push(typeof rec.confidence === "number" && rec.confidence >= 0 && rec.confidence <= 1 ? { ...fact, confidence: rec.confidence } : fact);
+  }
+  return out;
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+var OpenAICompatExtractor = class {
+  name;
+  model;
+  #url;
+  #apiKey;
+  #maxRetries;
+  #retryBaseMs;
+  #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 ?? 3;
+    this.#retryBaseMs = opts.retryBaseMs ?? 500;
+    this.#temperature = opts.temperature ?? 0;
+    this.#fetch = opts.fetchImpl ?? fetch;
+  }
+  async extract(text, opts) {
+    const trimmed = text.trim();
+    if (trimmed === "")
+      return [];
+    const body = JSON.stringify({
+      model: this.model,
+      temperature: this.#temperature,
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT },
+        { role: "user", content: `Session notes:
+
+${trimmed}` }
+      ]
+    });
+    const headers = { "content-type": "application/json" };
+    if (this.#apiKey !== void 0 && this.#apiKey !== "") {
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    }
+    let lastErr;
+    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) {
+          lastErr = new Error(`extractor HTTP ${res.status}`);
+        } else if (!res.ok) {
+          return [];
+        } else {
+          const json = await res.json();
+          const content = json.choices?.[0]?.message?.content ?? "";
+          return parseExtraction(content);
+        }
+      } catch (err) {
+        lastErr = err;
+      }
+      if (attempt < this.#maxRetries) {
+        await delay(this.#retryBaseMs * 2 ** attempt);
+      }
+    }
+    void lastErr;
+    return [];
+  }
+};
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
 // dist/sqlite.js
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
@@ -1255,7 +1363,7 @@ var SqliteMemoryBackend = class {
         { 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);
+    const reranked = input.rerank === false ? pool : await this.rerankPool(input.query, pool, finalLimit);
     return reranked.slice(0, finalLimit);
   }
   /**
@@ -1593,6 +1701,57 @@ function discoverMemoryReranker(env) {
   }
   throw new Error(`unknown PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" (expected "none", "voyage", or "bge")`);
 }
+function discoverMemoryExtractor(env) {
+  const forced = (env.PROMETHEUS_MEMORY_EXTRACT_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_EXTRACT_PROVIDER="mistral" requires MISTRAL_API_KEY.');
+    }
+    return {
+      id: "mistral",
+      provider: new OpenAICompatExtractor({
+        name: "mistral-extract",
+        model: env.PROMETHEUS_MEMORY_EXTRACT_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_EXTRACT_PROVIDER="openai" requires OPENAI_API_KEY.');
+    }
+    return {
+      id: "openai",
+      provider: new OpenAICompatExtractor({
+        name: "openai-extract",
+        model: env.PROMETHEUS_MEMORY_EXTRACT_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_EXTRACT_ENDPOINT;
+    if (baseUrl === void 0 || baseUrl === "") {
+      throw new Error(`PROMETHEUS_MEMORY_EXTRACT_PROVIDER="${forced}" requires PROMETHEUS_MEMORY_EXTRACT_ENDPOINT.`);
+    }
+    return {
+      id: "generic",
+      provider: new OpenAICompatExtractor({
+        name: env.PROMETHEUS_MEMORY_EXTRACT_NAME ?? "generic-extract",
+        model: env.PROMETHEUS_MEMORY_EXTRACT_MODEL ?? "default",
+        baseUrl,
+        ...env.PROMETHEUS_MEMORY_EXTRACT_API_KEY ? { apiKey: env.PROMETHEUS_MEMORY_EXTRACT_API_KEY } : {}
+      })
+    };
+  }
+  throw new Error(`unknown PROMETHEUS_MEMORY_EXTRACT_PROVIDER="${forced}" (expected "none", "mistral", "openai", or "generic")`);
+}
 function composeFromEnv(opts) {
   const env = opts.env;
   const override = (opts.workspaceRootOverride ?? "").trim();
@@ -1605,6 +1764,7 @@ function composeFromEnv(opts) {
   const dbPath = rawDbPath !== void 0 && rawDbPath !== "" ? rawDbPath : defaultMemoryDbPath();
   const { id: embedderId, embedder } = discoverMemoryEmbedder(env);
   const { id: rerankerId, provider: reranker } = discoverMemoryReranker(env);
+  const { id: extractorId, provider: extractor } = discoverMemoryExtractor(env);
   const backend = new SqliteMemoryBackend(dbPath, {
     ...embedder !== void 0 ? { embedder } : {},
     ...reranker !== null ? { reranker } : {}
@@ -1619,6 +1779,8 @@ function composeFromEnv(opts) {
     embedderId,
     reranker,
     rerankerId,
+    extractor,
+    extractorId,
     close: () => backend.close()
   };
 }
@@ -2048,7 +2210,7 @@ var setupInput = {
   runtimes: z.array(runtimeEnum).min(1).optional()
 };
 function registerTools(server, deps) {
-  const { backend, workspaceRoot, projectId, projectName, dbPath } = deps;
+  const { backend, workspaceRoot, projectId, projectName, dbPath, extractor } = deps;
   server.registerTool("read", {
     title: "Recall agent memory",
     description: "Read agent memory for this project along the scope chain (project \u2192 workspace \u2192 tenant \u2192 system; narrowest scope wins). Syncs `.prometheus/memories/*.md` first, then returns the resolved records plus a prompt-ready `woven` markdown block (token-capped). Call this at the START of a session or task to recall what earlier sessions learned.",
@@ -2112,6 +2274,41 @@ ${p.value}`)
     assertValueSize(texts);
     assertNoSecrets(texts);
     const scope = args.scope ?? "project";
+    let facts = args.facts ?? [];
+    let extractedCount = 0;
+    if (extractor) {
+      const prose = [args.plan ?? "", args.outcome ?? ""].join("\n").trim();
+      if (prose !== "") {
+        try {
+          const mined = await extractor.extract(prose);
+          const have = new Set(facts.map((f) => f.key));
+          const fresh = mined.filter((f) => {
+            if (have.has(f.key))
+              return false;
+            try {
+              assertNoSecrets(`${f.key}
+${f.value}`);
+            } catch {
+              return false;
+            }
+            have.add(f.key);
+            return true;
+          });
+          if (fresh.length > 0) {
+            facts = [
+              ...facts,
+              ...fresh.map((f) => ({
+                key: f.key,
+                value: f.value,
+                ...f.confidence !== void 0 ? { confidence: f.confidence } : {}
+              }))
+            ];
+            extractedCount = fresh.length;
+          }
+        } catch {
+        }
+      }
+    }
     const written = await backend.consolidate({
       projectId,
       scope,
@@ -2119,10 +2316,10 @@ ${p.value}`)
       sessionId: args.sessionId,
       plan: args.plan,
       outcome: args.outcome,
-      facts: args.facts,
+      facts,
       procedures: args.procedures
     });
-    return textResult({ written: written.map(recordToJson) });
+    return textResult({ written: written.map(recordToJson), extracted: extractedCount });
   });
   server.registerTool("search", {
     title: "Search agent memory",
@@ -2208,6 +2405,10 @@ var SERVER_IDENTITY = {
 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.";
 
 // dist/bin.js
+function looksLikeMissingNativeBinding(msg) {
+  return /bindings file|better_sqlite3\.node|could not locate the bindings|node_module_version|was compiled against a different|invalid elf|\.node['"\s]/i.test(msg);
+}
+var NATIVE_BINDING_HINT = '\nThis looks like the native `better-sqlite3` module failed to load \u2014 usually\nbecause npm `ignore-scripts=true` (corporate hardening) made `npx` skip the\nnative build, so the binary was never produced. Fix it once, keeping your\nhardening intact:\n  npm install -g @prom.codes/memory-mcp --ignore-scripts=false --foreground-scripts\nthen point Claude Code at the built binary instead of npx:\n  claude mcp add memory -- node "$(npm root -g)/@prom.codes/memory-mcp/dist/bin.js"\nDocs: https://prom.codes/docs/mcp/claude-code\n';
 async function main() {
   const env = process.env;
   const explicitRoot = (env.PROMETHEUS_WORKSPACE_ROOT ?? "").trim();
@@ -2237,7 +2438,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}
+    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}
 `);
     registerTools(server, composed);
   };
@@ -2258,6 +2459,8 @@ async function main() {
       const message = err instanceof Error ? err.message : String(err);
       process.stderr.write(`prometheus-memory-mcp: fatal during boot: ${message}
 `);
+      if (looksLikeMissingNativeBinding(message))
+        process.stderr.write(NATIVE_BINDING_HINT);
       process.exit(1);
     }
   };
@@ -2272,5 +2475,7 @@ main().catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
   process.stderr.write(`prometheus-memory-mcp: fatal: ${message}
 `);
+  if (looksLikeMissingNativeBinding(message))
+    process.stderr.write(NATIVE_BINDING_HINT);
   process.exit(1);
 });

package/package.json

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