@bcmyguest/openmem 0.0.0-stage → 0.8.0

package/cli/coding-agent/session-facade.mjs

@@ -0,0 +1,86 @@
+import { callUnifiedTool } from "../mcp/memory-facade.mjs";
+import { recallBlock } from "./recall-frame.mjs";
+
+export const HOOK_CONTEXT_MAX_CHARS = 8000;
+
+function toolText(result) {
+  const t = result?.content?.[0]?.text;
+  if (!t) return "";
+  try {
+    const j = JSON.parse(t);
+    if (j?.result?.results) return JSON.stringify(j.result.results, null, 2);
+    if (j?.result) return typeof j.result === "string" ? j.result : JSON.stringify(j.result, null, 2);
+    return typeof j === "string" ? j : JSON.stringify(j, null, 2);
+  } catch {
+    return String(t);
+  }
+}
+
+function recallText(result, limit, maxChars = HOOK_CONTEXT_MAX_CHARS) {
+  try {
+    const value = JSON.parse(result?.content?.[0]?.text || "");
+    const hits = value?.result?.results;
+    if (Array.isArray(hits)) {
+      return hits.slice(0, limit)
+        .map((hit) => hit?.text ?? hit?.memory ?? hit?.content ?? "")
+        .filter((item) => typeof item === "string" && item.trim())
+        .join("\n\n")
+        .slice(0, maxChars);
+    }
+  } catch { /* use generic result text */ }
+  return toolText(result).slice(0, maxChars);
+}
+
+/**
+ * Hook or plugin recall text framed as untrusted data (recall-frame.mjs), at most HOOK_CONTEXT_MAX_CHARS
+ * characters frame included; "" for empty text.
+ */
+export function hookRecallBlock(text) {
+  return recallBlock(String(text ?? "").trim(), HOOK_CONTEXT_MAX_CHARS);
+}
+
+/** @param {ReturnType<import("../mcp/context.mjs").resolveMcpContext>} ctx */
+export async function sessionRecall(ctx, { query, bank, limit = 10, budget, maxTokens, maxChars }, fetchFn = fetch) {
+  const out = await callUnifiedTool(ctx, "memory_recall", { query, bank, limit, budget, maxTokens }, fetchFn);
+  if (out.isError) throw new Error(toolText(out));
+  return recallText(out, limit, maxChars);
+}
+
+/** @param {ReturnType<import("../mcp/context.mjs").resolveMcpContext>} ctx */
+export async function sessionRetain(ctx, { content, bank }, fetchFn = fetch) {
+  const text = String(content || "").trim();
+  if (!text) return;
+  const out = await callUnifiedTool(ctx, "memory_add", { content: text, bank, async: true }, fetchFn);
+  if (out.isError) throw new Error(toolText(out));
+}
+
+/** SessionStart context via unified memory_reflect (all providers). */
+export async function sessionReflectOrSearch(ctx, { query, bank, limit = 12 }, fetchFn = fetch) {
+  const out = await callUnifiedTool(ctx, "memory_reflect", { query, bank, limit }, fetchFn);
+  if (out.isError) throw new Error(toolText(out));
+  const body = toolText(out);
+  try {
+    const j = JSON.parse(body);
+    if (j.answer) return String(j.answer);
+    if (j.result) return typeof j.result === "string" ? j.result : JSON.stringify(j.result, null, 2);
+    if (j.hits) return String(j.hits);
+  } catch {
+    /* plain text */
+  }
+  return body;
+}
+
+/**
+ * True when the bank has pending or processing ingest (`memory_status` active > 0).
+ * Synchronous providers (mem0) and providers without ingest status (Cognee) report false.
+ */
+export async function sessionIngestActive(ctx, { bank }, fetchFn = fetch) {
+  const out = await callUnifiedTool(ctx, "memory_status", { bank }, fetchFn);
+  if (out.isError) throw new Error(toolText(out));
+  try {
+    const status = JSON.parse(out?.content?.[0]?.text || "");
+    return status?.supported !== false && Number(status?.active) > 0;
+  } catch {
+    return false;
+  }
+}

package/cli/coding-agent/toml-edit.mjs

@@ -0,0 +1,161 @@
+/**
+ * Text-preserving TOML edits: locate statements (table headers and key/value pairs) with a
+ * small lexer that understands strings, multi-line strings, comments and multi-line arrays,
+ * so an edit removes exactly one entry's text and leaves every other byte alone.
+ */
+
+const BARE_KEY = /[A-Za-z0-9_-]/;
+
+/** Offset just past the line break at or after `i` (or the end of the text). */
+function lineEnd(text, i) {
+  const nl = text.indexOf("\n", i);
+  return nl < 0 ? text.length : nl + 1;
+}
+
+/** Offset after the string starting at `i` (any of the four TOML string forms). */
+function skipString(text, i) {
+  const quote = text[i];
+  const triple = text.startsWith(quote.repeat(3), i);
+  if (triple) {
+    let j = i + 3;
+    while (j < text.length) {
+      if (quote === '"' && text[j] === "\\") { j += 2; continue; }
+      if (text.startsWith(quote.repeat(3), j)) {
+        j += 3;
+        // Up to two quotes may directly precede the closing delimiter.
+        for (let k = 0; k < 2 && text[j] === quote; k++) j++;
+        return j;
+      }
+      j++;
+    }
+    throw new SyntaxError("unterminated multi-line string");
+  }
+  let j = i + 1;
+  while (j < text.length && text[j] !== "\n") {
+    if (quote === '"' && text[j] === "\\") { j += 2; continue; }
+    if (text[j] === quote) return j + 1;
+    j++;
+  }
+  throw new SyntaxError("unterminated string");
+}
+
+/** Parse a dotted key at `i`; returns the segments and the offset after the key. */
+function parseKey(text, i) {
+  const parts = [];
+  for (;;) {
+    while (text[i] === " " || text[i] === "\t") i++;
+    if (text[i] === '"' || text[i] === "'") {
+      const end = skipString(text, i);
+      const raw = text.slice(i, end);
+      if (raw[0] === "'") parts.push(raw.slice(1, -1));
+      else {
+        try { parts.push(JSON.parse(raw)); } catch { parts.push(raw.slice(1, -1)); }
+      }
+      i = end;
+    } else {
+      const start = i;
+      while (i < text.length && BARE_KEY.test(text[i])) i++;
+      if (i === start) throw new SyntaxError(`bad key at offset ${start}`);
+      parts.push(text.slice(start, i));
+    }
+    while (text[i] === " " || text[i] === "\t") i++;
+    if (text[i] !== ".") return { parts, end: i };
+    i++;
+  }
+}
+
+/** Offset after a value starting at `i`, through the end of its last line (comment included). */
+function skipValue(text, i) {
+  let depth = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === '"' || c === "'") { i = skipString(text, i); continue; }
+    if (c === "#") { i = text.indexOf("\n", i); if (i < 0) return text.length; continue; }
+    if (c === "[" || c === "{") depth++;
+    else if (c === "]" || c === "}") depth--;
+    else if (c === "\n" && depth <= 0) return i + 1;
+    i++;
+  }
+  return text.length;
+}
+
+/**
+ * Statements of a TOML document in order: `{ kind: "table" | "array-table" | "kv", path, start, end }`.
+ * `path` is the full key path (a key/value pair includes its table's path); `start` is the
+ * offset of the statement's line and `end` the offset after its last line.
+ * @param {string} text
+ */
+export function tomlStatements(text) {
+  const out = [];
+  let table = [];
+  let i = 0;
+  while (i < text.length) {
+    const start = i;
+    while (text[i] === " " || text[i] === "\t" || text[i] === "\r") i++;
+    if (i >= text.length) break;
+    if (text[i] === "\n") { i++; continue; }
+    if (text[i] === "#") { i = lineEnd(text, i); continue; }
+    if (text[i] === "[") {
+      const array = text[i + 1] === "[";
+      const key = parseKey(text, i + (array ? 2 : 1));
+      table = key.parts;
+      out.push({ kind: array ? "array-table" : "table", path: table, start, end: lineEnd(text, key.end) });
+      i = lineEnd(text, key.end);
+      continue;
+    }
+    const key = parseKey(text, i);
+    if (text[key.end] !== "=") throw new SyntaxError(`expected "=" at offset ${key.end}`);
+    const end = skipValue(text, key.end + 1);
+    out.push({ kind: "kv", path: [...table, ...key.parts], start, end });
+    i = end;
+  }
+  return out;
+}
+
+const startsWith = (pathParts, prefix) => prefix.every((p, k) => pathParts[k] === p);
+
+/**
+ * Text spans to delete so no statement at or under `prefix` remains: whole tables (header through
+ * the table's last key/value pair, so comments that follow it stay) and single key/value pairs.
+ * @param {string} text
+ * @param {string[]} prefix
+ * @returns {{ start: number, end: number }[]}
+ */
+export function tomlSpansUnder(text, prefix) {
+  const statements = tomlStatements(text);
+  const spans = [];
+  for (let s = 0; s < statements.length; s++) {
+    const st = statements[s];
+    if (st.kind === "kv") {
+      if (startsWith(st.path, prefix)) spans.push({ start: st.start, end: st.end });
+      continue;
+    }
+    if (!startsWith(st.path, prefix)) continue;
+    let end = st.end;
+    let k = s + 1;
+    for (; k < statements.length && statements[k].kind === "kv"; k++) end = statements[k].end;
+    spans.push({ start: st.start, end });
+    s = k - 1;
+  }
+  return spans;
+}
+
+/** Remove `spans` from `text`, also dropping blank lines a removal would leave doubled. */
+export function removeSpans(text, spans) {
+  let out = text;
+  for (const { start, end } of [...spans].sort((a, b) => b.start - a.start)) {
+    let stop = end;
+    const before = out.slice(0, start);
+    if (start === 0 || /\n[ \t\r]*\n$/.test(before)) {
+      const m = /^(?:[ \t\r]*\n)+/.exec(out.slice(stop));
+      if (m) stop += m[0].length;
+    }
+    out = out.slice(0, start) + out.slice(stop);
+  }
+  return out;
+}
+
+/** Remove every statement at or under `prefix` (e.g. `["mcp_servers", "hindsight"]`). */
+export function removeTomlPath(text, prefix) {
+  return removeSpans(text, tomlSpansUnder(text, prefix));
+}

package/cli/cognee-mcp.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * Opt-in stdio MCP: read-only Cognee health + search against the local REST API.
+ * Base URL: COGNEE_API_URL / COGNEE_URL, else http://127.0.0.1:${COGNEE_PORT|8766}.
+ * Optional COGNEE_API_KEY → X-Api-Key (never written to mcp.json). Zero npm deps.
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isMainModule } from "./is-main.mjs";
+import { DEFAULT_PORT } from "../providers/cognee/lib/state.mjs";
+
+export { DEFAULT_PORT };
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string}
+ */
+export function resolveBaseUrl(env = process.env) {
+  const fromUrl = String(env.COGNEE_API_URL || env.COGNEE_URL || "").trim();
+  if (fromUrl) return fromUrl.replace(/\/+$/, "");
+  const port = String(env.COGNEE_PORT || DEFAULT_PORT).trim() || String(DEFAULT_PORT);
+  return `http://127.0.0.1:${port}`;
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {Record<string, string>}
+ */
+export function authHeaders(env = process.env) {
+  const key = String(env.COGNEE_API_KEY || "").trim();
+  return key ? { "X-Api-Key": key } : {};
+}
+
+/**
+ * @param {string} baseUrl
+ * @param {typeof fetch} [fetchFn]
+ * @param {NodeJS.ProcessEnv} [env]
+ */
+export async function healthCheck(baseUrl, fetchFn = fetch, env = process.env) {
+  const res = await fetchFn(`${baseUrl.replace(/\/+$/, "")}/health`, {
+    headers: { ...authHeaders(env) },
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`GET /health → ${res.status}: ${text.slice(0, 400)}`);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+/**
+ * @param {string} baseUrl
+ * @param {{ query: string, searchType?: string, datasets?: string[] }} body
+ * @param {typeof fetch} [fetchFn]
+ * @param {NodeJS.ProcessEnv} [env]
+ */
+export async function search(baseUrl, body, fetchFn = fetch, env = process.env) {
+  /** @type {Record<string, unknown>} */
+  const payload = {
+    searchType: body.searchType || "GRAPH_COMPLETION",
+    query: body.query,
+  };
+  if (Array.isArray(body.datasets) && body.datasets.length) {
+    payload.datasets = body.datasets.map(String);
+  }
+  const res = await fetchFn(`${baseUrl.replace(/\/+$/, "")}/api/v1/search`, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...authHeaders(env) },
+    body: JSON.stringify(payload),
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`POST /api/v1/search → ${res.status}: ${text.slice(0, 400)}`);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+const TOOLS = [
+  {
+    name: "cognee_health",
+    description: "GET /health on the local Cognee REST API. Confirms the stack is up.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "cognee_search",
+    description:
+      "POST /api/v1/search (read-only). Args: query (required), optional searchType (default GRAPH_COMPLETION), optional datasets[]. Does not add or cognify.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search / completion query" },
+        searchType: {
+          type: "string",
+          description: "Cognee searchType (default GRAPH_COMPLETION)",
+        },
+        datasets: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional dataset name filter",
+        },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+  },
+];
+
+function textResult(value, isError = false) {
+  const text = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  return { content: [{ type: "text", text }], isError };
+}
+
+/**
+ * @param {{ baseUrl: string, env?: NodeJS.ProcessEnv }} access
+ * @param {string} name
+ * @param {Record<string, unknown>} [args]
+ * @param {typeof fetch} [fetchFn]
+ */
+export async function callTool(access, name, args = {}, fetchFn = fetch) {
+  const env = access.env || process.env;
+  if (name === "cognee_health") {
+    return textResult(await healthCheck(access.baseUrl, fetchFn, env));
+  }
+  if (name === "cognee_search") {
+    const query = String(args.query || "").trim();
+    if (!query) return textResult("query is required", true);
+    /** @type {{ query: string, searchType?: string, datasets?: string[] }} */
+    const body = { query };
+    if (args.searchType != null && String(args.searchType).trim()) {
+      body.searchType = String(args.searchType).trim();
+    }
+    if (Array.isArray(args.datasets)) {
+      body.datasets = args.datasets.map(String);
+    }
+    return textResult({
+      query,
+      searchType: body.searchType || "GRAPH_COMPLETION",
+      result: await search(access.baseUrl, body, fetchFn, env),
+    });
+  }
+  return textResult(`unknown tool: ${name}`, true);
+}
+
+/**
+ * @param {Record<string, any>} msg
+ * @param {{ baseUrl: string, env?: NodeJS.ProcessEnv }} access
+ * @param {typeof fetch} [fetchFn]
+ */
+export async function handleMessage(msg, access, fetchFn = fetch) {
+  const { id, method, params } = msg;
+  if (method === "initialize") {
+    const protocolVersion =
+      typeof params?.protocolVersion === "string" && params.protocolVersion
+        ? params.protocolVersion
+        : "2024-11-05";
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: "cognee", version: "0.1.0" },
+      },
+    };
+  }
+  if (method === "notifications/initialized" || method === "initialized") return null;
+  if (method === "tools/list") return { jsonrpc: "2.0", id, result: { tools: TOOLS } };
+  if (method === "tools/call") {
+    try {
+      return { jsonrpc: "2.0", id, result: await callTool(access, params?.name, params?.arguments || {}, fetchFn) };
+    } catch (err) {
+      return { jsonrpc: "2.0", id, result: textResult(err instanceof Error ? err.message : String(err), true) };
+    }
+  }
+  if (method === "ping") return { jsonrpc: "2.0", id, result: {} };
+  if (id === undefined) return null;
+  return { jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${method}` } };
+}
+
+/** @param {"ndjson" | "content-length"} framing */
+function writeMessage(obj, framing = "ndjson") {
+  if (obj == null) return;
+  const body = JSON.stringify(obj);
+  // Cursor Agent CLI speaks NDJSON on stdio. Content-Length kept for LSP-style clients.
+  if (framing === "content-length") {
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+    return;
+  }
+  process.stdout.write(`${body}\n`);
+}
+
+/** Content-Length frames or NDJSON; reply using the same framing the request used. */
+export async function serveStdio(input, onMsg) {
+  let buf = Buffer.alloc(0);
+  for await (const chunk of input) {
+    buf = Buffer.concat([buf, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+    while (buf.length) {
+      const asStr = buf.toString("utf8");
+      const crlf = asStr.indexOf("\r\n\r\n");
+      const lf = asStr.indexOf("\n\n");
+      const headerEnd = crlf >= 0 ? crlf : lf;
+      const sepLen = crlf >= 0 ? 4 : lf >= 0 ? 2 : -1;
+      if (sepLen > 0 && /content-length\s*:/i.test(asStr.slice(0, headerEnd))) {
+        const m = /Content-Length:\s*(\d+)/i.exec(asStr.slice(0, headerEnd));
+        if (!m) {
+          buf = buf.subarray(Buffer.byteLength(asStr.slice(0, headerEnd + sepLen), "utf8"));
+          continue;
+        }
+        const len = Number(m[1]);
+        const headerBytes = Buffer.byteLength(asStr.slice(0, headerEnd + sepLen), "utf8");
+        if (buf.length < headerBytes + len) break;
+        const body = buf.subarray(headerBytes, headerBytes + len).toString("utf8");
+        buf = buf.subarray(headerBytes + len);
+        let msg;
+        try {
+          msg = JSON.parse(body);
+        } catch (err) {
+          writeMessage(
+            {
+              jsonrpc: "2.0",
+              id: null,
+              error: { code: -32700, message: `Parse error: ${err instanceof Error ? err.message : err}` },
+            },
+            "content-length",
+          );
+          continue;
+        }
+        writeMessage(await onMsg(msg), "content-length");
+        continue;
+      }
+      const nl = asStr.indexOf("\n");
+      if (nl < 0) break;
+      const line = asStr.slice(0, nl).trim();
+      buf = buf.subarray(Buffer.byteLength(asStr.slice(0, nl + 1), "utf8"));
+      if (!line.startsWith("{")) continue;
+      try {
+        writeMessage(await onMsg(JSON.parse(line)), "ndjson");
+      } catch {
+        /* skip bad line */
+      }
+    }
+  }
+}
+
+async function main() {
+  const baseUrl = resolveBaseUrl(process.env);
+  const access = { baseUrl, env: process.env };
+  process.stdin.resume();
+  await serveStdio(process.stdin, (msg) => handleMessage(msg, access));
+}
+
+if (isMainModule(import.meta.url)) {
+  main().catch((err) => {
+    console.error(`cognee-mcp: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  });
+}