@bcmyguest/openmem 0.0.0-stage → 0.6.3

package/cli/mcp/export/cognee.mjs

@@ -0,0 +1,119 @@
+import { authHeaders } from "../../cognee-mcp.mjs";
+import { cogneeDatasetName } from "./cognee-dataset-name.mjs";
+
+const PAGE = 1000;
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function trimString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {string}
+ */
+function textFromRawData(raw) {
+  if (typeof raw === "string") return raw.trim();
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return textFromRecord(raw);
+  }
+  return "";
+}
+
+/**
+ * Read `text`, `content`, or nested `raw_data` / `rawData` from a plain object.
+ * @param {unknown} obj
+ * @returns {string}
+ */
+function textFromRecord(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return "";
+  const rec = /** @type {Record<string, unknown>} */ (obj);
+  for (const key of ["text", "content"]) {
+    const s = trimString(rec[key]);
+    if (s) return s;
+  }
+  const fromRaw = textFromRawData(rec.raw_data ?? rec.rawData);
+  if (fromRaw) return fromRaw;
+  return "";
+}
+
+/**
+ * Prefer full document bytes/text from a Cognee dataset data row over label-only fields.
+ * @param {Record<string, unknown>} item
+ * @returns {string}
+ */
+export function cogneeDataItemContent(item) {
+  const fromItem = textFromRecord(item);
+  if (fromItem) return fromItem;
+  const fromDoc = textFromRecord(item.document ?? item.doc);
+  if (fromDoc) return fromDoc;
+  return trimString(item.label) || trimString(item.name) || "";
+}
+
+/**
+ * @param {{ cognee?: { baseUrl: string, apiKey?: string } }} ctx
+ * @param {{ bank?: string }} args
+ * @param {typeof fetch} fetchFn
+ * @param {NodeJS.ProcessEnv} [env]
+ */
+export async function exportCognee(ctx, args, fetchFn, env = process.env) {
+  const base = ctx.cognee?.baseUrl?.replace(/\/+$/, "");
+  if (!base) throw new Error("Cognee API URL not configured");
+  const headers = { ...authHeaders(env) };
+  const bank = String(args.bank || "openmem-mcp").trim() || "openmem-mcp";
+  const datasetName = cogneeDatasetName(bank);
+
+  const listRes = await fetchFn(`${base}/api/v1/datasets`, { headers });
+  const listText = await listRes.text();
+  if (!listRes.ok) throw new Error(`GET /api/v1/datasets → ${listRes.status}: ${listText.slice(0, 400)}`);
+  let datasets;
+  try {
+    datasets = listText ? JSON.parse(listText) : [];
+  } catch {
+    throw new Error("GET /api/v1/datasets: invalid JSON");
+  }
+  const row = (Array.isArray(datasets) ? datasets : []).find(
+    (d) => d && typeof d === "object" && d.name === datasetName && d.id,
+  );
+  if (!row) {
+    return {
+      scope: { bank, dataset: datasetName },
+      records: [],
+      note: `No Cognee dataset named ${datasetName}; indexer may not have written to this bank yet.`,
+    };
+  }
+  const datasetId = String(row.id);
+  /** @type {object[]} */
+  const records = [];
+  let offset = 0;
+  while (true) {
+    const url = `${base}/api/v1/datasets/${encodeURIComponent(datasetId)}/data?limit=${PAGE}&offset=${offset}`;
+    const res = await fetchFn(url, { headers });
+    const text = await res.text();
+    if (!res.ok) throw new Error(`GET dataset data → ${res.status}: ${text.slice(0, 400)}`);
+    let page;
+    try {
+      page = text ? JSON.parse(text) : [];
+    } catch {
+      throw new Error("GET dataset data: invalid JSON");
+    }
+    if (!Array.isArray(page)) break;
+    for (const item of page) {
+      if (!item || typeof item !== "object") continue;
+      const meta = item.externalMetadata ?? item.external_metadata ?? {};
+      const body = cogneeDataItemContent(item);
+      records.push({
+        id: item.id != null ? String(item.id) : null,
+        content: body || `[cognee:${item.name || item.id}]`,
+        metadata: { cognee: { name: item.name ?? null, externalMetadata: meta } },
+        scope_key: bank,
+      });
+    }
+    if (page.length < PAGE) break;
+    offset += page.length;
+  }
+  return { scope: { bank, dataset: datasetName, dataset_id: datasetId }, records };
+}

package/cli/mcp/export/hindsight.mjs

@@ -0,0 +1,48 @@
+import { listBanks, listMemories } from "../../notebooklm-mcp.mjs";
+
+const PAGE = 500;
+
+/**
+ * @param {{ hindsightUrl?: string }} ctx
+ * @param {{ bank?: string }} args
+ * @param {typeof fetch} fetchFn
+ */
+export async function exportHindsight(ctx, args, fetchFn) {
+  const base = ctx.hindsightUrl;
+  if (!base) throw new Error("Hindsight API URL not configured");
+  const bankFilter = String(args.bank || "").trim();
+  const bankRows = await listBanks(base, fetchFn);
+  const bankIds = bankRows
+    .map((b) => b.bank_id || b.id || b.name || "")
+    .filter(Boolean);
+  const banks = bankFilter ? bankIds.filter((id) => id === bankFilter) : bankIds;
+  if (bankFilter && !banks.length) {
+    throw new Error(`bank not found: ${bankFilter}`);
+  }
+  /** @type {object[]} */
+  const records = [];
+  for (const bank of banks) {
+    let offset = 0;
+    while (true) {
+      const page = await listMemories(base, bank, "", { limit: PAGE, offset }, fetchFn);
+      const items = Array.isArray(page?.items) ? page.items : [];
+      for (const m of items) {
+        const content = String(m.text ?? m.content ?? "").trim();
+        if (!content) continue;
+        records.push({
+          id: m.id ?? m.memory_id ?? null,
+          content,
+          metadata: { type: m.type ?? null, ...(m.metadata && typeof m.metadata === "object" ? m.metadata : {}) },
+          scope_key: bank,
+        });
+      }
+      const total = Number.isFinite(page?.total) ? page.total : items.length;
+      offset += items.length;
+      if (!items.length || items.length < PAGE || offset >= total) break;
+    }
+  }
+  return {
+    scope: bankFilter ? { bank: bankFilter } : { all_banks: true, bank_count: banks.length },
+    records,
+  };
+}

package/cli/mcp/export/index.mjs

@@ -0,0 +1,26 @@
+/** Provider PMM export adapters (orchestrator: cli/mcp/portability.mjs). */
+
+import { exportCognee } from "./cognee.mjs";
+import { exportHindsight } from "./hindsight.mjs";
+import { exportMem0 } from "./mem0.mjs";
+
+export { exportHindsight } from "./hindsight.mjs";
+export { exportMem0 } from "./mem0.mjs";
+export { exportCognee } from "./cognee.mjs";
+export { cogneeDatasetName } from "./cognee-dataset-name.mjs";
+
+/**
+ * @param {string} provider
+ * @param {Record<string, unknown>} ctx
+ * @param {Record<string, unknown>} args
+ * @param {typeof fetch} fetchFn
+ */
+export async function runProviderExport(provider, ctx, args, fetchFn) {
+  if (provider === "mem0") {
+    const scopeBank = String(args.bank || "openmem-mcp").trim() || "openmem-mcp";
+    return exportMem0(ctx, { user_id: scopeBank }, fetchFn);
+  }
+  if (provider === "hindsight") return exportHindsight(ctx, args, fetchFn);
+  if (provider === "cognee") return exportCognee(ctx, args, fetchFn);
+  throw new Error(`export not supported for provider ${provider}`);
+}

package/cli/mcp/export/mem0.mjs

@@ -0,0 +1,31 @@
+/**
+ * @param {{ mem0?: { baseUrl: string, apiKey?: string } }} ctx
+ * @param {{ user_id: string }} scope
+ * @param {typeof fetch} fetchFn
+ */
+export async function exportMem0(ctx, scope, fetchFn) {
+  const base = ctx.mem0?.baseUrl;
+  const key = ctx.mem0?.apiKey;
+  if (!base) throw new Error("mem0 API URL not configured");
+  /** @type {Record<string, string>} */
+  const headers = {};
+  if (key) headers["X-API-Key"] = key;
+  const q = new URLSearchParams({ user_id: scope.user_id, top_k: "1000" });
+  const res = await fetchFn(`${base}/memories?${q}`, { headers });
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(`GET /memories → ${res.status}: ${text.slice(0, 200)}`);
+  }
+  if (!res.ok) throw new Error(`GET /memories → ${res.status}: ${text.slice(0, 400)}`);
+  const raw = Array.isArray(json) ? json : json.results || json.memories || [];
+  const records = raw.map((row) => ({
+    id: row.id ?? row.memory_id ?? null,
+    content: row.memory ?? row.text ?? row.content ?? JSON.stringify(row),
+    metadata: row.metadata ?? {},
+    scope_key: scope.user_id,
+  }));
+  return { scope, records };
+}

package/cli/mcp/llm-synthesize.mjs

@@ -0,0 +1,50 @@
+import path from "node:path";
+import { envValue } from "../../wizard/lib/paths.mjs";
+
+/** OpenAI-compatible chat URL for cross-provider reflect synthesis (optional). */
+export function resolveLlmChatUrl({ home, stackRoot, env = process.env }) {
+  const direct = String(env.PM_LLM_URL || env.OPENAI_API_BASE || "").trim();
+  if (direct) return direct.replace(/\/+$/, "").replace(/\/v1$/, "") + (direct.includes("/v1") ? "" : "/v1");
+  const fromEnv = envValue(path.join(stackRoot, ".env"), "LITELLM_URL");
+  if (fromEnv) return fromEnv.replace(/\/+$/, "");
+  const port = envValue(path.join(stackRoot, ".env"), "LITELLM_PORT") || "4000";
+  return `http://127.0.0.1:${String(port).trim()}/v1`;
+}
+
+export function resolveLlmModel(env = process.env) {
+  return String(env.PM_LLM_MODEL || env.PM_REFLECT_MODEL || "memory-reflect").trim() || "memory-reflect";
+}
+
+export function resolveLlmApiKey(env = process.env) {
+  return String(env.PM_LLM_API_KEY || env.LITELLM_MASTER_KEY || env.OPENAI_API_KEY || "").trim();
+}
+
+/**
+ * @param {{ query: string, context: string, model?: string, baseUrl: string, apiKey?: string }} opts
+ * @param {typeof fetch} fetchFn
+ */
+export async function synthesizeReflectAnswer(opts, fetchFn = fetch) {
+  const base = opts.baseUrl.replace(/\/+$/, "");
+  const url = `${base}/chat/completions`;
+  const headers = { "content-type": "application/json" };
+  if (opts.apiKey) headers.authorization = `Bearer ${opts.apiKey}`;
+  const body = {
+    model: opts.model || resolveLlmModel(),
+    messages: [
+      {
+        role: "system",
+        content:
+          "Summarize the following memory search hits as concise session context for a coding agent. " +
+          "Do not invent facts not present in the hits.",
+      },
+      { role: "user", content: `Question: ${opts.query}\n\nMemory hits:\n${opts.context}` },
+    ],
+    max_tokens: 1024,
+    temperature: 0.2,
+  };
+  const res = await fetchFn(url, { method: "POST", headers, body: JSON.stringify(body) });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`LLM synthesize → ${res.status}: ${text.slice(0, 300)}`);
+  const json = JSON.parse(text);
+  return json?.choices?.[0]?.message?.content?.trim() || text;
+}

package/cli/mcp/mem0-scope-id.mjs

@@ -0,0 +1,22 @@
+/** Same mapping as indexer/sinks/mem0.py scope_id (user_id / run_id). */
+import crypto from "node:crypto";
+
+export function mem0ScopeId(value) {
+  const s = String(value ?? "");
+  if (!/\s/.test(s)) return s;
+  let out = "";
+  let inSpace = false;
+  for (const ch of s) {
+    if (ch.trim() === "") {
+      if (!inSpace) {
+        out += "_";
+        inSpace = true;
+      }
+    } else {
+      out += ch;
+      inSpace = false;
+    }
+  }
+  const digest = crypto.createHash("sha256").update(s, "utf8").digest("hex").slice(0, 8);
+  return `${out}~${digest}`;
+}