@bcmyguest/openmem 0.0.0-stage → 0.6.3

package/cli/coding-agent/install-shim.mjs

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import { SHIM_AGENT_IDS, SHIM_HARNESSES, SHIM_MARKER } from "./hook-harnesses.mjs";
+import { mergeOpencodeConfig, opencodeConfigPath } from "./opencode-config.mjs";
+
+function hookCommand(root, harnessId, phase) {
+  return `node ${JSON.stringify(path.join(root, "cli", "coding-agent", "hook-runner.mjs"))} ${harnessId} ${phase}`;
+}
+
+function nestedHookBlock(root, harnessId, phase, timeout) {
+  return {
+    hooks: [{ type: "command", command: hookCommand(root, harnessId, phase), timeout }],
+  };
+}
+
+function mergeNestedHooks(existing, root, harnessId, spec) {
+  const hooks = existing && typeof existing === "object" ? { ...existing } : {};
+  for (const [phase, meta] of Object.entries(spec.events)) {
+    const list = Array.isArray(hooks[meta.hook]) ? hooks[meta.hook].filter((e) => !JSON.stringify(e).includes(SHIM_MARKER)) : [];
+    hooks[meta.hook] = [...list, nestedHookBlock(root, harnessId, phase, meta.timeout)];
+  }
+  return hooks;
+}
+
+function mergeFlatHooks(existing, root, harnessId, spec) {
+  const hooks = existing && typeof existing === "object" ? { ...existing } : {};
+  for (const [phase, meta] of Object.entries(spec.events)) {
+    const list = Array.isArray(hooks[meta.hook]) ? hooks[meta.hook].filter((e) => !String(e?.command).includes(SHIM_MARKER)) : [];
+    hooks[meta.hook] = [
+      ...list,
+      { command: hookCommand(root, harnessId, phase), timeout: meta.timeout },
+    ];
+  }
+  return hooks;
+}
+
+function readJson(pathname) {
+  if (!fs.existsSync(pathname)) return {};
+  return JSON.parse(fs.readFileSync(pathname, "utf8"));
+}
+
+function writeJson(pathname, data) {
+  fs.mkdirSync(path.dirname(pathname), { recursive: true });
+  fs.writeFileSync(pathname, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+/**
+ * @param {{ home: string, repoRoot: string, agents: string[], dry: boolean, h?: { info: Function, ok: Function, warn: Function } }} opts
+ */
+export function installSessionShim(opts) {
+  const home = opts.home;
+  const h = opts.h || { info: () => {}, ok: () => {}, warn: () => {} };
+  const agents = opts.agents.filter((id) => SHIM_AGENT_IDS.includes(id) || id === "opencode");
+  const opencodePlugin = path.join(opts.repoRoot, "cli", "coding-agent", "opencode-plugin.mjs");
+  if (!agents.length) {
+    h.warn("no agents selected for session shim (claude-code, codex, cursor-cli, opencode)");
+    return { installed: [] };
+  }
+
+  const installed = [];
+  for (const agentId of agents) {
+    if (agentId === "opencode") {
+      const cfgPath = opencodeConfigPath(home);
+      if (opts.dry) {
+        h.info(`[dry-run] register opencode plugin ${opencodePlugin} in ${cfgPath}`);
+      } else {
+        mergeOpencodeConfig(home, "plugin", (existing) => {
+          const plugins = Array.isArray(existing)
+            ? existing.filter((p) => !/openmem|personal-memory/.test(String(p)))
+            : [];
+          return [...plugins, opencodePlugin];
+        });
+        h.ok(`opencode: registered openmem plugin in ${cfgPath}`);
+      }
+      installed.push("opencode");
+      continue;
+    }
+    const spec = SHIM_HARNESSES[agentId];
+    if (!spec) continue;
+    const cfgPath = spec.settingsPath(home);
+    if (opts.dry) {
+      h.info(`[dry-run] merge ${agentId} hooks in ${cfgPath}`);
+      installed.push(agentId);
+      continue;
+    }
+    const prev = readJson(cfgPath);
+    if (spec.configStyle === "nested") {
+      prev[spec.rootKey] = mergeNestedHooks(prev[spec.rootKey], opts.repoRoot, agentId, spec);
+    } else {
+      Object.assign(prev, mergeFlatHooks(prev, opts.repoRoot, agentId, spec));
+    }
+    writeJson(cfgPath, prev);
+    h.ok(`${agentId}: session hooks → ${cfgPath}`);
+    installed.push(agentId);
+  }
+  return { installed };
+}

package/cli/coding-agent/opencode-config.mjs

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function opencodeConfigPath(home) {
+  const dir = path.join(home, ".config", "opencode");
+  for (const name of ["opencode.jsonc", "opencode.json"]) {
+    const file = path.join(dir, name);
+    if (fs.existsSync(file)) return file;
+  }
+  return path.join(dir, "opencode.json");
+}
+
+function tokens(source) {
+  const out = [];
+  for (let i = 0; i < source.length;) {
+    if (/\s/.test(source[i])) { i++; continue; }
+    if (source.startsWith("//", i)) { i = source.indexOf("\n", i); if (i < 0) break; continue; }
+    if (source.startsWith("/*", i)) {
+      const end = source.indexOf("*/", i + 2);
+      if (end < 0) throw new SyntaxError("Unclosed JSONC comment");
+      i = end + 2;
+      continue;
+    }
+    const start = i;
+    if (source[i] === '"') {
+      i++;
+      while (i < source.length) {
+        if (source[i++] === '"') break;
+        if (source[i - 1] === "\\") i++;
+      }
+    } else if ("{}[]:,".includes(source[i])) i++;
+    else while (i < source.length && !/[\s{}\[\]:,]/.test(source[i]) && !source.startsWith("//", i) && !source.startsWith("/*", i)) i++;
+    out.push({ value: source.slice(start, i), start, end: i });
+  }
+  return out;
+}
+
+function parseJsonc(source) {
+  const list = tokens(source);
+  const compact = list.filter((token, i) => token.value !== "," || !["}", "]"].includes(list[i + 1]?.value));
+  return JSON.parse(compact.map((token) => token.value).join(""));
+}
+
+function fieldSpan(list, name) {
+  let depth = 0;
+  let found = null;
+  for (let i = 0; i < list.length; i++) {
+    const token = list[i];
+    if (depth === 1 && token.value.startsWith('"') && list[i + 1]?.value === ":" && JSON.parse(token.value) === name) {
+      const start = list[i + 2]?.start;
+      if (start === undefined) throw new SyntaxError(`Missing JSONC value for ${name}`);
+      let nested = 0;
+      let end = start;
+      for (let j = i + 2; j < list.length; j++) {
+        const value = list[j].value;
+        if (nested === 0 && (value === "," || value === "}")) break;
+        if (value === "{" || value === "[") nested++;
+        if (value === "}" || value === "]") nested--;
+        end = list[j].end;
+      }
+      found = { start, end };
+    }
+    if (token.value === "{" || token.value === "[") depth++;
+    if (token.value === "}" || token.value === "]") depth--;
+  }
+  return found;
+}
+
+/** Update one top-level JSONC field while retaining text and comments outside that field. */
+export function mergeOpencodeConfig(home, field, update) {
+  const file = opencodeConfigPath(home);
+  const source = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "{}\n";
+  const parsed = parseJsonc(source);
+  if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new SyntaxError("OpenCode config must be an object");
+  const value = update(parsed[field]);
+  const list = tokens(source);
+  const span = fieldSpan(list, field);
+  let output;
+  if (span) output = source.slice(0, span.start) + JSON.stringify(value, null, 2) + source.slice(span.end);
+  else {
+    const close = list.findLast((token) => token.value === "}");
+    if (!close) throw new SyntaxError("OpenCode config has no closing object brace");
+    const hasFields = Object.keys(parsed).length > 0;
+    const last = list[list.indexOf(close) - 1];
+    const separator = hasFields && last?.value !== "," ? "," : "";
+    output = source.slice(0, close.start) + `${separator}\n  ${JSON.stringify(field)}: ${JSON.stringify(value, null, 2)}\n` + source.slice(close.start);
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, output);
+  return file;
+}

package/cli/coding-agent/opencode-plugin.mjs

@@ -0,0 +1,96 @@
+import os from "node:os";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { bankFromCwd } from "./bank-from-cwd.mjs";
+import { accessAllowed, readAccessConfig } from "./access-policy.mjs";
+import { sessionRecall, sessionReflectOrSearch, sessionRetain } from "./session-facade.mjs";
+import { resolveMcpContext } from "../mcp/context.mjs";
+import { resolveStackRoot } from "../stack.mjs";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const MAX_SESSIONS = 128;
+const MAX_RETAIN_CHARS = 12000;
+function messageText(item) {
+  return (item.parts || []).filter((part) => part.type === "text" && part.text).map((part) => part.text).join("\n");
+}
+
+/** OpenCode v1 local plugin: prompt recall, system context, and per-turn retention. */
+export const PersonalMemoryPlugin = async ({ client, directory, worktree }) => {
+  const home = process.env.HOME || os.homedir();
+  let stackRoot;
+  try {
+    stackRoot = JSON.parse(fs.readFileSync(path.join(ROOT, "agent-runtime.json"), "utf8")).stackRoot;
+  } catch {
+    // A checkout uses its ordinary stack resolution.
+  }
+  const env = { ...process.env, PM_STACK_ROOT: process.env.PM_STACK_ROOT || stackRoot };
+  const stack = resolveStackRoot({ pkgRoot: ROOT, home, env });
+  const ctx = resolveMcpContext({ home, stackRoot: stack.root, repoRoot: ROOT, env });
+  const projectDir = worktree && path.parse(worktree).root !== worktree ? worktree : directory;
+  const accessConfig = readAccessConfig(home);
+  const allowed = accessAllowed(projectDir, accessConfig);
+  if (!allowed) {
+    return {
+      "chat.message": async () => {},
+      "experimental.chat.system.transform": async () => {},
+      event: async () => {},
+    };
+  }
+  const bank = bankFromCwd(projectDir, { home, mapPathToBank: accessConfig.mapPathToBank });
+  const injections = new Map();
+  const seen = new Map();
+
+  function remember(sessionID, messageID) {
+    seen.delete(sessionID);
+    seen.set(sessionID, messageID);
+    while (seen.size > MAX_SESSIONS) seen.delete(seen.keys().next().value);
+  }
+
+  return {
+    "chat.message": async (input, output) => {
+      const prompt = messageText(output).trim();
+      if (!prompt) return;
+      injections.delete(input.sessionID);
+      injections.set(input.sessionID, "");
+      while (injections.size > MAX_SESSIONS) injections.delete(injections.keys().next().value);
+      try {
+        const query = prompt.slice(0, 2000);
+        const context = seen.has(input.sessionID)
+          ? await sessionRecall(ctx, { query, bank, limit: 8 })
+          : await sessionReflectOrSearch(ctx, { query, bank, limit: 12 });
+        injections.set(input.sessionID, context);
+      } catch { /* Memory availability must not interrupt the prompt. */ }
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      const context = injections.get(input.sessionID);
+      if (context) output.system.push(`Personal memory for ${bank}:\n${context}`);
+    },
+    event: async ({ event }) => {
+      if (event.type !== "session.idle") return;
+      const sessionID = event.properties?.sessionID;
+      if (!sessionID || !injections.has(sessionID)) return;
+      try {
+        const response = await client.session.messages({ path: { id: sessionID } });
+        const messages = response.data || [];
+        const previous = seen.get(sessionID);
+        const lastIndex = previous ? messages.findIndex((item) => item.info?.id === previous) : -1;
+        // OpenCode may replace old message IDs when a session is compacted.
+        // In that case retain a bounded tail instead of silently losing the
+        // whole next turn. A small amount of overlap is preferable to a gap.
+        const fresh = previous && lastIndex >= 0 ? messages.slice(lastIndex + 1) : messages;
+        const content = fresh.map((item) => {
+          const text = messageText(item).trim();
+          return text ? `${item.info?.role || "message"}: ${text}` : "";
+        }).filter(Boolean).join("\n\n").slice(-MAX_RETAIN_CHARS);
+        if (content) await sessionRetain(ctx, { bank, content: `OpenCode session ${sessionID}:\n${content}` });
+        const last = messages.at(-1)?.info?.id;
+        if (last) remember(sessionID, last);
+      } catch {
+        // Memory availability must not interrupt OpenCode's session.
+      } finally {
+        injections.delete(sessionID);
+      }
+    },
+  };
+};

package/cli/coding-agent/runtime.mjs

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+
+const RUNTIME_ITEMS = ["cli", "providers", "wizard", "config", "skills", "package.json"];
+const RUNTIME_DEPS = ["@iarna/toml", "@clack/prompts", "yaml"];
+
+function packageRoot(requireFromSource, name) {
+  let dir = path.dirname(requireFromSource.resolve(name));
+  while (dir !== path.dirname(dir)) {
+    const manifest = path.join(dir, "package.json");
+    if (fs.existsSync(manifest) && JSON.parse(fs.readFileSync(manifest, "utf8")).name === name) return dir;
+    dir = path.dirname(dir);
+  }
+  throw new Error(`cannot locate ${name} for openmem runtime`);
+}
+
+/** Copy the agent runtime out of an ephemeral npx cache into a stable user path. */
+export function prepareAgentRuntime({ home, repoRoot, stackRoot, dry = false, h }) {
+  const dest = path.join(home, ".local", "share", "personal-memory", "agent-runtime");
+  if (dry) {
+    h?.info(`[dry-run] stage openmem agent runtime in ${dest}`);
+    return dest;
+  }
+  const requireFromSource = createRequire(path.join(repoRoot, "package.json"));
+  fs.mkdirSync(dest, { recursive: true });
+  for (const item of RUNTIME_ITEMS) {
+    fs.cpSync(path.join(repoRoot, item), path.join(dest, item), { recursive: true, force: true });
+  }
+  fs.rmSync(path.join(dest, "cli", "coding-agent", "opencode-plugin"), { recursive: true, force: true });
+  for (const name of RUNTIME_DEPS) {
+    const target = path.join(dest, "node_modules", name);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.cpSync(packageRoot(requireFromSource, name), target, { recursive: true, force: true });
+  }
+  fs.writeFileSync(path.join(dest, "agent-runtime.json"), `${JSON.stringify({ stackRoot }, null, 2)}\n`);
+  h?.ok(`openmem agent runtime → ${dest}`);
+  return dest;
+}

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

@@ -0,0 +1,62 @@
+import { callUnifiedTool } from "../mcp/memory-facade.mjs";
+
+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) {
+  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, HOOK_CONTEXT_MAX_CHARS);
+    }
+  } catch { /* use generic result text */ }
+  return toolText(result).slice(0, HOOK_CONTEXT_MAX_CHARS);
+}
+
+/** @param {ReturnType<import("../mcp/context.mjs").resolveMcpContext>} ctx */
+export async function sessionRecall(ctx, { query, bank, limit = 10, budget, maxTokens }, 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);
+}
+
+/** @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;
+}

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);
+  });
+}

package/cli/feed-sync.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/** Run indexer/feed_sync.py (RSS + OpenAlex → markdown cache). */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const script = path.join(PKG_ROOT, "indexer", "feed_sync.py");
+
+const r = spawnSync("python3", [script, ...process.argv.slice(2)], { stdio: "inherit", cwd: PKG_ROOT });
+process.exit(r.status ?? 1);