@bcmyguest/openmem 0.0.0-stage → 0.6.3

package/cli/install-coding-agent.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Install coding-agent session memory for Claude Code, Codex, OpenCode, Cursor CLI.
+ * All providers: unified MCP + in-repo session hooks.
+ * Optional: --hindsight-plugin also runs @vectorize-io/hindsight-coding-agents (Hindsight stacks only).
+ */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CODING_AGENTS, DEFAULT_AGENT_IDS } from "./coding-agent/agents.mjs";
+import { AGENT_IDS, PROVIDER_CAPABILITIES } from "./coding-agent/capabilities.mjs";
+import { installSessionShim } from "./coding-agent/install-shim.mjs";
+import { installAgentAccess } from "./coding-agent/install-access.mjs";
+import { prepareAgentRuntime } from "./coding-agent/runtime.mjs";
+import { SHIM_AGENT_IDS } from "./coding-agent/hook-harnesses.mjs";
+import { resolveMemoryProvider } from "./install-memory-mcp.mjs";
+import { isMainModule } from "./is-main.mjs";
+import { resolveHindsightApiUrl } from "./mcp/context.mjs";
+import { resolveStackRoot } from "./stack.mjs";
+import { runInstallMemoryMcp } from "./install-memory-mcp.mjs";
+
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const BIN = "openmem-install-coding-agent";
+
+const HELP = `${BIN}: wire session memory for coding agents
+
+Usage:
+  npx openmem install-coding-agent [--yes] [--dry-run] [--agents a,b] [--hindsight-plugin]
+
+Default agents: ${DEFAULT_AGENT_IDS.join(", ")}
+All known agents: ${CODING_AGENTS.map((a) => a.id).join(", ")}
+
+Every provider gets install-mcp + openmem session hooks (SessionStart / prompt / Stop).
+With --hindsight-plugin and MEMORY_PROVIDER=hindsight, also runs hindsight-coding-agents install.
+`;
+
+function parseArgs(argv) {
+  const flags = {
+    yes: false,
+    dry: false,
+    help: false,
+    hindsightPlugin: false,
+    agents: [...DEFAULT_AGENT_IDS],
+    unknown: [],
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes" || a === "-y") flags.yes = true;
+    else if (a === "--dry-run") flags.dry = true;
+    else if (a === "--help" || a === "-h") flags.help = true;
+    else if (a === "--hindsight-plugin") flags.hindsightPlugin = true;
+    else if (a === "--agents") flags.agents = String(argv[++i] || "").split(",").map((s) => s.trim()).filter(Boolean);
+    else flags.unknown.push(a);
+  }
+  return flags;
+}
+
+function h() {
+  return {
+    info: (m) => console.log(m),
+    ok: (m) => console.log(m),
+    warn: (m) => console.warn(m),
+  };
+}
+
+export async function runInstallCodingAgent(opts) {
+  const home = opts.home;
+  const env = opts.env || process.env;
+  const flags = opts.flags;
+  for (const agentId of flags.agents) {
+    if (!AGENT_IDS.includes(agentId)) {
+      opts.h?.warn(`Unknown agent "${agentId}" (known: ${AGENT_IDS.join(", ")})`);
+    }
+  }
+  const provider = resolveMemoryProvider(home, env);
+  const caps = PROVIDER_CAPABILITIES[provider] || {};
+  opts.h?.info(`Provider ${provider}: capabilities ${JSON.stringify(caps)}`);
+
+  const shimAgents = flags.agents.filter((id) => SHIM_AGENT_IDS.includes(id) || id === "opencode");
+  const runtimeRoot = prepareAgentRuntime({
+    home, repoRoot: opts.repoRoot, stackRoot: opts.stackRoot, dry: flags.dry || !flags.yes, h: opts.h || h(),
+  });
+  if (flags.dry) {
+    opts.h?.info("dry-run: would run install-mcp --yes");
+    installSessionShim({ home, repoRoot: runtimeRoot, agents: shimAgents, dry: true, h: opts.h || h() });
+    installAgentAccess({ home, runtimeRoot, stackRoot: opts.stackRoot, agents: flags.agents, dry: true, h: opts.h || h() });
+    if (flags.hindsightPlugin && provider === "hindsight") {
+      const apiUrl = resolveHindsightApiUrl({ home, stackRoot: opts.stackRoot, env });
+      opts.h?.info(
+        `dry-run: would also run npx @vectorize-io/hindsight-coding-agents install ${flags.agents.join(" ")} --server self-hosted --api-url ${apiUrl}`,
+      );
+    }
+    return { provider, ran: false };
+  }
+  if (!flags.yes) {
+    opts.h?.warn("Re-run with --yes to install MCP + session hooks");
+    return { provider, ran: false };
+  }
+
+  await runInstallMemoryMcp({
+    home,
+    repoRoot: runtimeRoot,
+    stackRoot: opts.stackRoot,
+    flags: { yes: true, dry: false, notebooklm: false, notebooklmOnly: false, providerOnly: false, noUnifiedMcp: false, help: false, unknown: [] },
+    env,
+    h: opts.h || h(),
+  });
+  installSessionShim({
+    home,
+    repoRoot: runtimeRoot,
+    agents: shimAgents,
+    dry: false,
+    h: opts.h || h(),
+  });
+  installAgentAccess({
+    home, runtimeRoot, stackRoot: opts.stackRoot, agents: flags.agents, dry: false, h: opts.h || h(),
+  });
+
+  if (flags.hindsightPlugin && provider === "hindsight") {
+    const apiUrl = resolveHindsightApiUrl({ home, stackRoot: opts.stackRoot, env });
+    const cmd = ["npx", "-y", "@vectorize-io/hindsight-coding-agents", "install", ...flags.agents, "--server", "self-hosted", "--api-url", apiUrl];
+    opts.h?.info(`Also installing upstream Hindsight plugin: ${cmd.join(" ")}`);
+    const r = spawnSync(cmd[0], cmd.slice(1), { stdio: "inherit", env });
+    return { provider, ran: true, status: r.status ?? 1 };
+  }
+
+  for (const agentId of flags.agents) {
+    if (shimAgents.includes(agentId)) {
+      opts.h?.info(`  ${agentId}: openmem session hooks + unified MCP`);
+    } else {
+      const row = CODING_AGENTS.find((a) => a.id === agentId);
+      opts.h?.info(`  ${agentId}: ${row?.sessionPath || "unified MCP memory_*"}`);
+    }
+  }
+  return { provider, ran: true, status: 0 };
+}
+
+async function main() {
+  const flags = parseArgs(process.argv.slice(2));
+  if (flags.help || flags.unknown.length) {
+    console.log(HELP);
+    process.exit(flags.unknown.length ? 2 : 0);
+  }
+  const home = process.env.HOME || "";
+  const sr = resolveStackRoot({ pkgRoot: PKG_ROOT });
+  const out = await runInstallCodingAgent({
+    home,
+    repoRoot: PKG_ROOT,
+    stackRoot: sr.root,
+    flags,
+    env: process.env,
+    h: h(),
+  });
+  return typeof out.status === "number" ? out.status : 0;
+}
+
+if (isMainModule(import.meta.url)) {
+  main().then(
+    (code) => process.exit(code ?? 0),
+    (err) => {
+      console.error(err);
+      process.exit(1);
+    },
+  );
+}

package/cli/install-memory-mcp.mjs

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+/**
+ * Install memory-related MCP servers into ~/.cursor/mcp.json only.
+ *
+ *   openmem-install-mcp [--yes] [--dry-run] [--notebooklm] [--notebooklm-only] [--provider-only]
+ *   npm run install-mcp -- …
+ *
+ * Provider: MEMORY_PROVIDER → ~/.config/hindsight/wizard.conf → hindsight.
+ * NotebookLM MCP: notebooklm.yml enabled:true and/or --notebooklm (unless --provider-only).
+ * Never writes machine paths into the shipped config/coding-agent.json template.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { fileURLToPath } from "node:url";
+import { isMainModule } from "./is-main.mjs";
+import { setNotebooklmAccessEnabled } from "../wizard/lib/notebooklm-agent-access.mjs";
+import { envValue } from "../wizard/lib/paths.mjs";
+import { installNotebooklmMcp } from "../providers/hindsight/lib/notebooklm-mcp-install.mjs";
+import {
+  cogneeMcpEntry,
+  installCogneeMcp as installCogneeMcpFromProvider,
+  resolveCogneeApiUrl,
+} from "../providers/cognee/lib/cognee-mcp-install.mjs";
+import {
+  installMem0Mcp as installMem0McpFromProvider,
+  mem0McpEntry,
+  mem0McpScriptPath,
+  mergeMem0McpServer,
+  resolveMem0ApiUrl,
+} from "../providers/mem0/lib/mcp-install.mjs";
+import { installUnifiedMcp } from "./mcp/unified-mcp-install.mjs";
+import { resolveStackRoot } from "./stack.mjs";
+
+export { mem0McpEntry, mergeMem0McpServer, resolveMem0ApiUrl };
+
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const BIN = "openmem-install-mcp";
+const DEFAULT_PROVIDER = "hindsight";
+/** Sibling MCP servers this tool must never rewrite (merge targets mem0/cognee stay off this list). */
+export const PROTECTED_MCP_SERVERS = Object.freeze(["hindsight", "codegraph", "notebooklm"]);
+
+const HELP = `${BIN}: merge MCP servers into ~/.cursor/mcp.json
+
+By default merges the openmem unified MCP (memory_add/search/recall/forget on the
+active provider). Also NotebookLM when sync is enabled or --notebooklm. Native mem0/Cognee
+MCP: --provider-only. Skip unified: --no-unified-mcp. Hindsight session memory still uses
+the hindsight-coding-agents plugin.
+
+Usage:
+  ${BIN} [flags]
+  npx openmem install-mcp [flags]
+  npm run install-mcp -- [flags]             # checkout
+
+Flags:
+  --yes               no confirmation prompts
+  --dry-run           print actions; write nothing
+  --notebooklm        force NotebookLM MCP + notebooklmAccess.enabled
+  --notebooklm-only   only NotebookLM step (skip provider MCP)
+  --provider-only     only provider MCP (skip NotebookLM)
+  --no-unified-mcp    skip merging the openmem unified MCP server
+  -h, --help          this help
+
+Provider resolution: MEMORY_PROVIDER, else wizard.conf, else hindsight.
+NotebookLM is also detected when ~/.config/hindsight/notebooklm.yml has enabled: true.
+`;
+
+/**
+ * @typedef {{
+ *   yes: boolean,
+ *   dry: boolean,
+ *   notebooklm: boolean,
+ *   notebooklmOnly: boolean,
+ *   providerOnly: boolean,
+ *   noUnifiedMcp: boolean,
+ *   help: boolean,
+ *   unknown: string[],
+ * }} InstallMcpFlags
+ */
+
+/**
+ * @param {string[]} argv
+ * @returns {InstallMcpFlags}
+ */
+export function parseInstallMcpArgs(argv) {
+  /** @type {InstallMcpFlags} */
+  const flags = {
+    yes: false,
+    dry: false,
+    notebooklm: false,
+    notebooklmOnly: false,
+    providerOnly: false,
+    noUnifiedMcp: false,
+    help: false,
+    unknown: [],
+  };
+  for (const arg of argv) {
+    switch (arg) {
+      case "--yes":
+      case "-y":
+        flags.yes = true;
+        break;
+      case "--dry-run":
+        flags.dry = true;
+        break;
+      case "--notebooklm":
+        flags.notebooklm = true;
+        break;
+      case "--notebooklm-only":
+        flags.notebooklmOnly = true;
+        break;
+      case "--provider-only":
+        flags.providerOnly = true;
+        break;
+      case "--no-unified-mcp":
+        flags.noUnifiedMcp = true;
+        break;
+      case "-h":
+      case "--help":
+        flags.help = true;
+        break;
+      default:
+        flags.unknown.push(arg);
+        break;
+    }
+  }
+  return flags;
+}
+
+/**
+ * @param {string} home
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string}
+ */
+export function resolveMemoryProvider(home, env = process.env) {
+  const fromEnv = String(env.MEMORY_PROVIDER || "").trim();
+  if (fromEnv) return fromEnv;
+  const conf = path.join(home, ".config/hindsight/wizard.conf");
+  const fromConf = envValue(conf, "MEMORY_PROVIDER").trim();
+  if (fromConf) return fromConf;
+  return DEFAULT_PROVIDER;
+}
+
+/**
+ * True when notebooklm.yml has a top-level `enabled: true` (same regex as the wizard).
+ * @param {string} notebookFile
+ */
+export function notebooklmEnabledInYml(notebookFile) {
+  if (!fs.existsSync(notebookFile)) return false;
+  try {
+    return /^enabled:\s*true\b/m.test(fs.readFileSync(notebookFile, "utf8"));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {{ home: string, flags: InstallMcpFlags }} opts
+ */
+export function shouldInstallNotebooklm({ home, flags }) {
+  if (flags.providerOnly) return false;
+  if (flags.notebooklm || flags.notebooklmOnly) return true;
+  return notebooklmEnabledInYml(path.join(home, ".config/hindsight/notebooklm.yml"));
+}
+
+/**
+ * Merge one named MCP server; refuse to mutate protected sibling keys.
+ * @param {Record<string, any>} mcp
+ * @param {string} name
+ * @param {Record<string, any>} entry
+ * @param {{ protect?: string[] }} [opts]
+ * @returns {{ mcp: Record<string, any>, changed: boolean, skipped?: string, refused?: string }}
+ */
+export function mergeNamedMcpServer(mcp, name, entry, opts = {}) {
+  const protect = opts.protect || PROTECTED_MCP_SERVERS;
+  if (protect.includes(name) && name !== "notebooklm") {
+    // notebooklm is updated only via mergeNotebooklmMcpServer / installNotebooklmMcp.
+    return { mcp, changed: false, refused: `refusing to merge protected MCP name "${name}"` };
+  }
+  const out = { ...mcp };
+  const servers = { ...(mcp.mcpServers && typeof mcp.mcpServers === "object" ? mcp.mcpServers : {}) };
+  const before = Object.fromEntries(protect.map((k) => [k, servers[k]]));
+  const prev = servers[name];
+  const same = prev && JSON.stringify(prev) === JSON.stringify(entry);
+  if (same) {
+    return { mcp: { ...out, mcpServers: servers }, changed: false, skipped: "already configured" };
+  }
+  servers[name] = entry;
+  for (const k of protect) {
+    if (k === name) continue;
+    if (before[k] !== undefined && servers[k] !== before[k]) {
+      return { mcp, changed: false, refused: `refusing to alter ${k} MCP entry` };
+    }
+  }
+  return { mcp: { ...out, mcpServers: servers }, changed: true };
+}
+
+/**
+ * Back-compat alias: real mem0 MCP entry (node launcher → npx @yeyuan98/mem0-mcp).
+ * Prefer mem0McpEntry({ apiUrl, scriptPath, envFile }) for new code.
+ * @param {string} apiUrl
+ */
+export function mem0McpPlaceholderEntry(apiUrl) {
+  return mem0McpEntry({
+    apiUrl,
+    scriptPath: mem0McpScriptPath(PKG_ROOT),
+  });
+}
+
+/**
+ * Cognee stdio MCP entry (node + script + COGNEE_API_URL). No API key.
+ * @param {string} scriptPath absolute path
+ * @param {string} [apiUrl]
+ */
+export function cogneeMcpStubEntry(scriptPath, apiUrl) {
+  return cogneeMcpEntry(scriptPath, apiUrl);
+}
+
+/**
+ * @param {string} mcpPath
+ * @returns {Record<string, any>}
+ */
+export function readMcpJson(mcpPath) {
+  if (!fs.existsSync(mcpPath)) return {};
+  return JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+}
+
+/**
+ * @param {string} mcpPath
+ * @param {Record<string, any>} mcp
+ * @param {{ dry?: boolean }} [opts]
+ */
+export function writeMcpJson(mcpPath, mcp, opts = {}) {
+  if (opts.dry) return;
+  fs.mkdirSync(path.dirname(mcpPath), { recursive: true });
+  fs.writeFileSync(mcpPath, `${JSON.stringify(mcp, null, 2)}\n`);
+}
+
+/** @param {{ info: Function, ok: Function, warn: Function }} h */
+function makeLogger() {
+  return {
+    info: (/** @type {string} */ m) => console.log(`  ${m}`),
+    ok: (/** @type {string} */ m) => console.log(`✓ ${m}`),
+    warn: (/** @type {string} */ m) => console.warn(`! ${m}`),
+  };
+}
+
+/**
+ * @param {string} question
+ * @returns {Promise<boolean>}
+ */
+function confirmProceed(question) {
+  if (!process.stdin.isTTY) return Promise.resolve(true);
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${question} [Y/n] `, (answer) => {
+      rl.close();
+      const a = String(answer || "").trim().toLowerCase();
+      resolve(a === "" || a === "y" || a === "yes");
+    });
+  });
+}
+
+/**
+ * @param {{
+ *   home: string,
+ *   repoRoot: string,
+ *   stackRoot: string,
+ *   flags: InstallMcpFlags,
+ *   env?: NodeJS.ProcessEnv,
+ *   h?: { info: Function, ok: Function, warn: Function },
+ *   confirm?: (q: string) => Promise<boolean>,
+ * }} opts
+ */
+export async function runInstallMemoryMcp(opts) {
+  const home = opts.home;
+  const repoRoot = opts.repoRoot;
+  const stackRoot = opts.stackRoot;
+  const flags = opts.flags;
+  const env = opts.env || process.env;
+  const h = opts.h || makeLogger();
+  const ask = opts.confirm || confirmProceed;
+
+  if (flags.notebooklmOnly && flags.providerOnly) {
+    throw new Error("--notebooklm-only and --provider-only are mutually exclusive");
+  }
+
+  const provider = resolveMemoryProvider(home, env);
+  const doNotebooklm = shouldInstallNotebooklm({ home, flags });
+  const doProvider = !flags.notebooklmOnly;
+
+  const plan = [];
+  if (doNotebooklm) plan.push("notebooklmAccess + notebooklm MCP");
+  if (doProvider) {
+    if (provider === "mem0") plan.push("mem0 MCP (@yeyuan98/mem0-mcp via cli/mem0-mcp.mjs)");
+    else if (provider === "cognee") plan.push("cognee MCP (read-only health/search)");
+    else if (provider === "hindsight") plan.push("hindsight note (coding-agents plugin separate)");
+    else plan.push(`provider=${provider} (no MCP handler)`);
+  }
+  if (!flags.noUnifiedMcp) plan.push("openmem unified MCP (memory_add/search/recall/forget)");
+
+  h.info(`provider=${provider}`);
+  h.info(`plan: ${plan.length ? plan.join("; ") : "(nothing)"}`);
+
+  if (!plan.length) {
+    h.info("nothing to install");
+    return { provider, didNotebooklm: false, didProvider: false };
+  }
+
+  if (!flags.yes && !flags.dry) {
+    const ok = await ask(`Apply MCP changes to ${path.join(home, ".cursor/mcp.json")}?`);
+    if (!ok) {
+      h.warn("aborted");
+      return { provider, didNotebooklm: false, didProvider: false, aborted: true };
+    }
+  }
+
+  let didNotebooklm = false;
+  if (doNotebooklm) {
+    const agentPath = path.join(home, ".hindsight", "coding-agent.json");
+    const templatePath = path.join(repoRoot, "config/coding-agent.json");
+    if (flags.dry) {
+      const planAccess = setNotebooklmAccessEnabled(agentPath, templatePath, true, { dry: true });
+      h.info(
+        `[dry-run] ${planAccess.action} ${agentPath} with notebooklmAccess.enabled=true; merge notebooklm MCP into ~/.cursor/mcp.json`,
+      );
+    } else {
+      const result = setNotebooklmAccessEnabled(agentPath, templatePath, true);
+      h.ok(
+        `notebooklmAccess.enabled=true in ${agentPath}` +
+          (result.action === "materialized" ? " (copied from symlink → regular file)" : ""),
+      );
+      await installNotebooklmMcp({ home, repoRoot, agentJson: agentPath, dry: false }, h);
+    }
+    didNotebooklm = true;
+  }
+
+  let didProvider = false;
+  if (doProvider) {
+    if (provider === "hindsight") {
+      h.info(
+        "hindsight coding-agents plugin is separate: run `openmem setup` / `npx @vectorize-io/hindsight-coding-agents install …`",
+      );
+      didProvider = true;
+    } else if (provider === "mem0") {
+      await installMem0ProviderMcp({ home, repoRoot, stackRoot, flags, env, h });
+      didProvider = true;
+    } else if (provider === "cognee") {
+      await installCogneeMcp({ home, repoRoot, stackRoot, flags, env, h });
+      didProvider = true;
+    } else {
+      h.warn(`no MCP install handler for provider "${provider}"`);
+    }
+  }
+
+  let didUnified = false;
+  if (!flags.noUnifiedMcp) {
+    const u = installUnifiedMcp(
+      { home, repoRoot, stackRoot, provider, dry: flags.dry },
+      h,
+    );
+    didUnified = u.changed || flags.dry;
+  }
+
+  if (!flags.dry && (didNotebooklm || didUnified || (didProvider && provider !== "hindsight"))) {
+    h.ok("Restart Cursor Agent so it picks up MCP changes");
+  }
+
+  return { provider, didNotebooklm, didProvider, didUnified };
+}
+
+/**
+ * @param {{ home: string, stackRoot: string, flags: InstallMcpFlags, env: NodeJS.ProcessEnv, h: any, repoRoot: string }} opts
+ */
+async function installMem0ProviderMcp({ home, stackRoot, flags, env, h, repoRoot }) {
+  await installMem0McpFromProvider({ home, repoRoot, stackRoot, dry: flags.dry, env }, h);
+}
+
+/**
+ * @param {{
+ *   home: string,
+ *   repoRoot: string,
+ *   stackRoot: string,
+ *   flags: InstallMcpFlags,
+ *   env: NodeJS.ProcessEnv,
+ *   h: any,
+ * }} opts
+ */
+async function installCogneeMcp({ home, repoRoot, stackRoot, flags, env, h }) {
+  const apiUrl = resolveCogneeApiUrl({ home, stackRoot, repoRoot, env });
+  await installCogneeMcpFromProvider(
+    { home, repoRoot, dry: flags.dry, cogneeUrl: apiUrl },
+    h,
+  );
+}
+
+async function main(argv) {
+  const flags = parseInstallMcpArgs(argv);
+  if (flags.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (flags.unknown.length) {
+    console.error(`${BIN}: unknown option(s): ${flags.unknown.join(", ")}`);
+    console.error(HELP);
+    process.exit(2);
+  }
+
+  const home = process.env.HOME || os.homedir();
+  const stack = resolveStackRoot({ pkgRoot: PKG_ROOT, env: process.env, home });
+  // Code (MCP scripts, templates) comes from the package; .env lives in the stack root.
+  const repoRoot = PKG_ROOT;
+  const stackRoot = stack.root;
+
+  try {
+    await runInstallMemoryMcp({ home, repoRoot, stackRoot, flags });
+  } catch (err) {
+    console.error(`${BIN}: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  main(process.argv.slice(2));
+}

package/cli/is-main.mjs

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * True when this module is the process entrypoint. Compares realpaths so npm
+ * `.bin/*` symlinks into `node_modules/<pkg>/cli/*.mjs` still count as main.
+ *
+ * @param {string} metaUrl import.meta.url of the caller
+ */
+export function isMainModule(metaUrl) {
+  if (!process.argv[1]) return false;
+  try {
+    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(metaUrl));
+  } catch {
+    return path.resolve(process.argv[1]) === path.resolve(fileURLToPath(metaUrl));
+  }
+}

package/cli/mcp/context.mjs

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { envValue } from "../../wizard/lib/paths.mjs";
+import { resolveMemoryProvider } from "../install-memory-mcp.mjs";
+import { resolveMem0ApiUrl, resolveMem0EnvFilePath } from "../../providers/mem0/lib/mcp-install.mjs";
+import { resolveCogneeApiUrl } from "../../providers/cognee/lib/cognee-mcp-install.mjs";
+import { readKey } from "../../providers/mem0/lib/env-file.mjs";
+
+const DEFAULT_HINDSIGHT_PORT = 8888;
+
+/**
+ * @param {{ home: string, stackRoot: string, env?: NodeJS.ProcessEnv }} opts
+ */
+export function resolveHindsightApiUrl({ home, stackRoot, env = process.env }) {
+  const candidates = [
+    env.HINDSIGHT_URL,
+    env.PM_HINDSIGHT_URL,
+    envValue(path.join(stackRoot, ".env"), "HINDSIGHT_URL"),
+    envValue(path.join(home, ".config/hindsight/wizard.conf"), "HINDSIGHT_URL"),
+  ];
+  const url = candidates.map((v) => String(v || "").trim()).find(Boolean);
+  if (url) return url.replace(/\/+$/, "");
+  const portCandidates = [
+    env.HINDSIGHT_PORT,
+    envValue(path.join(stackRoot, ".env"), "HINDSIGHT_PORT"),
+    envValue(path.join(home, ".config/hindsight/wizard.conf"), "HINDSIGHT_PORT"),
+  ];
+  const port = portCandidates.map((v) => String(v || "").trim()).find(Boolean) || String(DEFAULT_HINDSIGHT_PORT);
+  return `http://127.0.0.1:${port}`;
+}
+
+/**
+ * @param {{ home: string, stackRoot: string, repoRoot: string, env?: NodeJS.ProcessEnv }} opts
+ */
+export function resolveMcpContext(opts) {
+  const env = opts.env || process.env;
+  const home = opts.home;
+  const stackRoot = opts.stackRoot;
+  const provider = resolveMemoryProvider(home, env);
+  /** @type {{ provider: string, hindsightUrl?: string, mem0?: { baseUrl: string, apiKey?: string }, cognee?: { baseUrl: string, apiKey?: string } }} */
+  const ctx = { provider };
+  if (provider === "hindsight") {
+    ctx.hindsightUrl = resolveHindsightApiUrl({ home, stackRoot, env });
+  } else if (provider === "mem0") {
+    const baseUrl = resolveMem0ApiUrl({ home, stackRoot, env });
+    const envFile = resolveMem0EnvFilePath({ home, stackRoot, env });
+    let apiKey = String(env.MEM0_API_KEY || "").trim();
+    if (!apiKey) {
+      try {
+        apiKey = readKey(envFile) || "";
+      } catch {
+        apiKey = "";
+      }
+    }
+    ctx.mem0 = { baseUrl, apiKey: apiKey || undefined };
+  } else if (provider === "cognee") {
+    const baseUrl = resolveCogneeApiUrl({ home, stackRoot, repoRoot: opts.repoRoot, env });
+    const apiKey = String(env.COGNEE_API_KEY || "").trim() || undefined;
+    ctx.cognee = { baseUrl, apiKey };
+  }
+  return ctx;
+}

package/cli/mcp/export/cognee-dataset-name.mjs

@@ -0,0 +1,12 @@
+import crypto from "node:crypto";
+
+const SLUG_MAX = 40;
+
+/** Match `indexer/sinks/cognee.py` `dataset_name(bank)`. */
+export function cogneeDatasetName(bank) {
+  const raw = String(bank ?? "");
+  let slug = raw.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  slug = slug.slice(0, SLUG_MAX).replace(/^_+|_+$/g, "") || "bank";
+  const hash = crypto.createHash("sha256").update(raw).digest("hex").slice(0, 8);
+  return `${slug}_${hash}`;
+}