mem0/cli/node/src/index.ts

#!/usr/bin/env node

/**
 * Main CLI application — the entrypoint for `mem0`.
 */

import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { Command } from "commander";
import { AuthError, type Backend, getBackend } from "./backend/index.js";
import { colors, printError, printWarning } from "./branding.js";
import type { Mem0Config } from "./config.js";
import { loadConfig, saveConfig } from "./config.js";
import { richFormatHelp } from "./help.js";
import { setAgentMode } from "./state.js";
import { captureEvent } from "./telemetry.js";
import { CLI_VERSION } from "./version.js";

const program = new Command();

// ── Validated user identity (set by getBackendAndConfig) ─────────────────

let _validatedUserEmail: string | undefined;

// ── Helpers ──────────────────────────────────────────────────────────────

async function getBackendAndConfig(
	apiKey?: string,
	baseUrl?: string,
): Promise<{ backend: Backend; config: Mem0Config }> {
	const config = loadConfig();

	if (apiKey) config.platform.apiKey = apiKey;
	if (baseUrl) config.platform.baseUrl = baseUrl;

	if (!config.platform.apiKey) {
		printError(
			"No API key configured.",
			"Run 'mem0 init' or set MEM0_API_KEY environment variable.",
		);
		process.exit(1);
	}

	const backend = getBackend(config);

	// Validate the API key upfront with a fast timeout
	try {
		const pingData = (await Promise.race([
			backend.ping(),
			new Promise<never>((_, reject) =>
				setTimeout(() => reject(new Error("timeout")), 5000),
			),
		])) as Record<string, unknown>;

		const email = pingData?.user_email as string | undefined;
		if (email) {
			_validatedUserEmail = email;
			if (config.platform.userEmail !== email) {
				config.platform.userEmail = email;
				try {
					saveConfig(config);
				} catch {
					/* ignore */
				}
			}
		}
	} catch (e) {
		if (e instanceof AuthError) {
			printError(
				"Invalid or expired API key.",
				"Run 'mem0 init' or set MEM0_API_KEY environment variable.",
			);
			process.exit(1);
		}
		// Network error / timeout — warn but proceed
		printWarning(
			"Could not validate API key (network issue). Proceeding anyway.",
		);
	}

	return { backend, config };
}

async function getBackendOnly(
	apiKey?: string,
	baseUrl?: string,
): Promise<Backend> {
	return (await getBackendAndConfig(apiKey, baseUrl)).backend;
}

function checkAgentMode(): boolean {
	const rootOpts = program.opts();
	const isAgent = !!(rootOpts.json || rootOpts.agent);
	if (isAgent) setAgentMode(true);
	return isAgent;
}

/**
 * Resolve entity IDs: CLI flag > config default > undefined.
 *
 * If any explicit ID is provided, only use explicit IDs (don't mix
 * in defaults for other entity types which would over-filter).
 * If no explicit IDs, fall back to all configured defaults.
 */
function resolveIds(
	config: Mem0Config,
	opts: {
		userId?: string;
		agentId?: string;
		appId?: string;
		runId?: string;
	},
): { userId?: string; agentId?: string; appId?: string; runId?: string } {
	const hasExplicit = !!(
		opts.userId ||
		opts.agentId ||
		opts.appId ||
		opts.runId
	);
	if (hasExplicit) {
		return {
			userId: opts.userId || undefined,
			agentId: opts.agentId || undefined,
			appId: opts.appId || undefined,
			runId: opts.runId || undefined,
		};
	}
	return {
		userId: config.defaults.userId || undefined,
		agentId: config.defaults.agentId || undefined,
		appId: config.defaults.appId || undefined,
		runId: config.defaults.runId || undefined,
	};
}

/**
 * Resolve graph tri-state: --no-graph > --graph > config default.
 */
function resolveGraph(
	config: Mem0Config,
	opts: { graph?: boolean; noGraph?: boolean },
): boolean {
	if (opts.noGraph) return false;
	if (opts.graph) return true;
	return config.defaults.enableGraph;
}

// ── Main program ──────────────────────────────────────────────────────────

program
	.name("mem0")
	.description(
		`◆ Mem0 CLI v${CLI_VERSION} · Node.js SDK\n\nThe Memory Layer for AI Agents`,
	)
	.option("--version", "Show version and exit.")
	.on("option:version", () => {
		console.log(`  ${colors.brand("◆ Mem0")} CLI v${CLI_VERSION}`);
		process.exit(0);
	})
	.option("--json", "Output as JSON for agent/programmatic use.")
	.option(
		"--agent",
		"Output as JSON for agent/programmatic use. (alias: --json)",
	)
	.usage("<command> [options]")
	.helpOption("--help", "Show this message and exit.")
	.addHelpCommand(false)
	.configureHelp({ formatHelp: richFormatHelp });

// ── Telemetry hook ───────────────────────────────────────────────────────

program.hook("preAction", (_thisCommand, actionCommand) => {
	try {
		const commandName = actionCommand.name();
		const parentName = actionCommand.parent?.name();
		const fullCommand =
			parentName && parentName !== "mem0"
				? `${parentName}.${commandName}`
				: commandName;
		const isAgent = !!(program.opts().json || program.opts().agent);
		captureEvent(
			`cli.${fullCommand}`,
			{
				command: fullCommand,
				is_agent: isAgent,
			},
			_validatedUserEmail,
		);
	} catch {
		/* silently swallow */
	}
});

// ── Init ──────────────────────────────────────────────────────────────────

program
	.command("init")
	.description("Interactive setup wizard for mem0 CLI.")
	.option("--api-key <key>", "API key (skip prompt).")
	.option("-u, --user-id <id>", "Default user ID (skip prompt).")
	.option("--email <email>", "Login via email verification code.")
	.option(
		"--code <code>",
		"Verification code (use with --email for non-interactive login).",
	)
	.option("--force", "Overwrite existing config without confirmation.", false)
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 init\n  $ mem0 init --api-key m0-xxx --user-id alice\n  $ mem0 init --email you@example.com\n  $ mem0 init --email you@example.com --code 123456",
	)
	.action(async (opts) => {
		const { runInit } = await import("./commands/init.js");
		await runInit({
			apiKey: opts.apiKey,
			userId: opts.userId,
			email: opts.email,
			code: opts.code,
			force: opts.force,
		});
	});

// ── Memory: add ───────────────────────────────────────────────────────────

program
	.command("add [text]")
	.description("Add a memory from text, messages, file, or stdin.")
	.option("-u, --user-id <id>", "Scope to user.")
	.option("--agent-id <id>", "Scope to agent.")
	.option("--app-id <id>", "Scope to app.")
	.option("--run-id <id>", "Scope to run.")
	.option("--messages <json>", "Conversation messages as JSON.")
	.option("-f, --file <path>", "Read messages from JSON file.")
	.option("-m, --metadata <json>", "Custom metadata as JSON.")
	.option("--immutable", "Prevent future updates.", false)
	.option("--no-infer", "Skip inference, store raw.")
	.option("--expires <date>", "Expiration date (YYYY-MM-DD).")
	.option("--categories <value>", "Categories (JSON array or comma-separated).")
	.option("--graph", "Enable graph memory extraction.", false)
	.option("--no-graph", "Disable graph memory extraction.")
	.option("-o, --output <format>", "Output format: text, json, quiet.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		'\nExamples:\n  $ mem0 add "I prefer dark mode" --user-id alice\n  $ echo "text" | mem0 add -u alice\n  $ mem0 add --file msgs.json -u alice -o json',
	)
	.action(async (text, opts) => {
		const { cmdAdd } = await import("./commands/memory.js");
		const isAgent = checkAgentMode();
		const { backend, config } = await getBackendAndConfig(
			opts.apiKey,
			opts.baseUrl,
		);
		const ids = resolveIds(config, opts);
		const enableGraph = resolveGraph(config, opts);
		const output = isAgent ? "agent" : opts.output;
		await cmdAdd(backend, text, { ...ids, ...opts, enableGraph, output });
	});

// ── Memory: search ────────────────────────────────────────────────────────

program
	.command("search [query]")
	.description(
		"Query your memory store — semantic, keyword, or hybrid retrieval.",
	)
	.option("-u, --user-id <id>", "Filter by user.")
	.option("--agent-id <id>", "Filter by agent.")
	.option("--app-id <id>", "Filter by app.")
	.option("--run-id <id>", "Filter by run.")
	.option(
		"-k, --top-k <n>",
		"Number of results.",
		(v) => Number.parseInt(v),
		10,
	)
	.option(
		"--threshold <n>",
		"Minimum similarity score.",
		(v) => Number.parseFloat(v),
		0.3,
	)
	.option("--rerank", "Enable reranking (Platform only).", false)
	.option("--keyword", "Use keyword search.", false)
	.option("--filter <json>", "Advanced filter expression (JSON).")
	.option("--fields <list>", "Specific fields to return (comma-separated).")
	.option("--graph", "Enable graph in search.", false)
	.option("--no-graph", "Disable graph in search.")
	.option("-o, --output <format>", "Output: text, json, table.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		'\nExamples:\n  $ mem0 search "preferences" --user-id alice\n  $ mem0 search "tools" -u alice -o json -k 5\n  $ echo "preferences" | mem0 search -u alice',
	)
	.action(async (query, opts) => {
		let resolvedQuery = query;
		if (!resolvedQuery && !process.stdin.isTTY) {
			resolvedQuery = fs.readFileSync(0, "utf-8").trim();
		}
		if (!resolvedQuery) {
			printError("No query provided. Pass a query argument or pipe via stdin.");
			process.exit(1);
		}
		const { cmdSearch } = await import("./commands/memory.js");
		const isAgent = checkAgentMode();
		const { backend, config } = await getBackendAndConfig(
			opts.apiKey,
			opts.baseUrl,
		);
		const ids = resolveIds(config, opts);
		const enableGraph = resolveGraph(config, opts);
		const output = isAgent ? "agent" : opts.output;
		await cmdSearch(backend, resolvedQuery, {
			...ids,
			topK: opts.topK,
			threshold: opts.threshold,
			rerank: opts.rerank,
			keyword: opts.keyword,
			filterJson: opts.filter,
			fields: opts.fields,
			enableGraph,
			output,
		});
	});

// ── Memory: get ───────────────────────────────────────────────────────────

program
	.command("get <memoryId>")
	.description("Get a specific memory by ID.")
	.option("-o, --output <format>", "Output: text, json.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 get abc-123-def-456\n  $ mem0 get abc-123-def-456 -o json",
	)
	.action(async (memoryId, opts) => {
		const { cmdGet } = await import("./commands/memory.js");
		const isAgent = checkAgentMode();
		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
		const output = isAgent ? "agent" : opts.output;
		await cmdGet(backend, memoryId, { output });
	});

// ── Memory: list ──────────────────────────────────────────────────────────

program
	.command("list")
	.description("List memories with optional filters.")
	.option("-u, --user-id <id>", "Filter by user.")
	.option("--agent-id <id>", "Filter by agent.")
	.option("--app-id <id>", "Filter by app.")
	.option("--run-id <id>", "Filter by run.")
	.option("--page <n>", "Page number.", (v) => Number.parseInt(v), 1)
	.option(
		"--page-size <n>",
		"Results per page.",
		(v) => Number.parseInt(v),
		100,
	)
	.option("--category <name>", "Filter by category.")
	.option("--after <date>", "Created after (YYYY-MM-DD).")
	.option("--before <date>", "Created before (YYYY-MM-DD).")
	.option("--graph", "Enable graph in listing.", false)
	.option("--no-graph", "Disable graph in listing.")
	.option("-o, --output <format>", "Output: text, json, table.", "table")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 list -u alice\n  $ mem0 list --category prefs --after 2024-01-01 -o json",
	)
	.action(async (opts) => {
		const { cmdList } = await import("./commands/memory.js");
		const isAgent = checkAgentMode();
		const { backend, config } = await getBackendAndConfig(
			opts.apiKey,
			opts.baseUrl,
		);
		const ids = resolveIds(config, opts);
		const enableGraph = resolveGraph(config, opts);
		const output = isAgent ? "agent" : opts.output;
		await cmdList(backend, {
			...ids,
			page: opts.page,
			pageSize: opts.pageSize,
			category: opts.category,
			after: opts.after,
			before: opts.before,
			enableGraph,
			output,
		});
	});

// ── Memory: update ────────────────────────────────────────────────────────

program
	.command("update <memoryId> [text]")
	.description("Update a memory's text or metadata.")
	.option("-m, --metadata <json>", "Update metadata (JSON).")
	.option("-o, --output <format>", "Output: text, json, quiet.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		`\nExamples:\n  $ mem0 update abc-123 "new text"\n  $ mem0 update abc-123 --metadata '{"key":"val"}'\n  $ echo "new text" | mem0 update abc-123`,
	)
	.action(async (memoryId, text, opts) => {
		let resolvedText = text;
		if (!resolvedText && !opts.metadata && !process.stdin.isTTY) {
			resolvedText = fs.readFileSync(0, "utf-8").trim();
		}
		const { cmdUpdate } = await import("./commands/memory.js");
		const isAgent = checkAgentMode();
		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
		const output = isAgent ? "agent" : opts.output;
		await cmdUpdate(backend, memoryId, resolvedText, {
			metadata: opts.metadata,
			output,
		});
	});

// ── Memory: delete (consolidated) ─────────────────────────────────────────

program
	.command("delete [memoryId]")
	.description("Delete a memory, all memories matching a scope, or an entity.")
	.option("--all", "Delete all memories matching scope filters.", false)
	.option(
		"--entity",
		"Delete the entity itself and all its memories (cascade).",
		false,
	)
	.option("--project", "With --all: delete ALL memories project-wide.", false)
	.option("--dry-run", "Show what would be deleted without deleting.", false)
	.option("--force", "Skip confirmation.", false)
	.option("-u, --user-id <id>", "Scope to user.")
	.option("--agent-id <id>", "Scope to agent.")
	.option("--app-id <id>", "Scope to app.")
	.option("--run-id <id>", "Scope to run.")
	.option("-o, --output <format>", "Output: text, json, quiet.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		[
			"\nExamples:",
			"  $ mem0 delete abc-123-def-456              # single memory",
			"  $ mem0 delete --all -u alice --force        # all memories for user",
			"  $ mem0 delete --all --project --force       # project-wide wipe",
			"  $ mem0 delete --entity -u alice --force     # entity + all its memories",
		].join("\n"),
	)
	.action(async (memoryId, opts) => {
		const isAgent = checkAgentMode();
		const output = isAgent ? "agent" : opts.output;
		// ── Mutual-exclusion checks ──
		if (memoryId && opts.all) {
			printError("Cannot combine <memoryId> with --all. Use one or the other.");
			process.exit(1);
		}
		if (memoryId && opts.entity) {
			printError(
				"Cannot combine <memoryId> with --entity. Use one or the other.",
			);
			process.exit(1);
		}
		if (opts.all && opts.entity) {
			printError("Cannot combine --all with --entity. Use one or the other.");
			process.exit(1);
		}
		if (!memoryId && !opts.all && !opts.entity) {
			printError(
				"Specify a memory ID, --all, or --entity.\n" +
					"  mem0 delete <id>              Delete a single memory\n" +
					"  mem0 delete --all [scope]     Delete all memories matching scope\n" +
					"  mem0 delete --entity [scope]  Delete an entity and all its memories",
			);
			process.exit(1);
		}

		// ── Dispatch: single memory ──
		if (memoryId) {
			const { cmdDelete } = await import("./commands/memory.js");
			const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
			await cmdDelete(backend, memoryId, {
				output,
				dryRun: opts.dryRun,
				force: opts.force,
			});
			return;
		}

		// ── Dispatch: --all ──
		if (opts.all) {
			const { cmdDeleteAll } = await import("./commands/memory.js");
			const { backend, config } = await getBackendAndConfig(
				opts.apiKey,
				opts.baseUrl,
			);
			const ids = opts.project
				? {
						userId: undefined,
						agentId: undefined,
						appId: undefined,
						runId: undefined,
					}
				: resolveIds(config, opts);
			await cmdDeleteAll(backend, {
				force: opts.force,
				dryRun: opts.dryRun,
				all: opts.project,
				...ids,
				output,
			});
			return;
		}

		// ── Dispatch: --entity ──
		if (opts.entity) {
			const { cmdEntitiesDelete } = await import("./commands/entities.js");
			const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
			await cmdEntitiesDelete(backend, { ...opts, output });
			return;
		}
	});

// ── Config subcommands ────────────────────────────────────────────────────

const configCmd = program
	.command("config")
	.description("Manage mem0 configuration.")
	.addHelpCommand(false);

configCmd
	.command("show")
	.description("Display current configuration (secrets redacted).")
	.option("-o, --output <format>", "Output: text, json.", "text")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 config show\n  $ mem0 config show -o json",
	)
	.action(async (opts) => {
		const { cmdConfigShow } = await import("./commands/config.js");
		const isAgent = checkAgentMode();
		const output = isAgent ? "agent" : opts.output;
		cmdConfigShow({ output });
	});

configCmd
	.command("get <key>")
	.description("Get a configuration value.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 config get platform.api_key\n  $ mem0 config get defaults.user_id",
	)
	.action(async (key) => {
		const { cmdConfigGet } = await import("./commands/config.js");
		checkAgentMode();
		cmdConfigGet(key);
	});

configCmd
	.command("set <key> <value>")
	.description("Set a configuration value.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 config set defaults.user_id alice\n  $ mem0 config set platform.base_url https://api.mem0.ai",
	)
	.action(async (key, value) => {
		const { cmdConfigSet } = await import("./commands/config.js");
		checkAgentMode();
		cmdConfigSet(key, value);
	});

// ── Entity subcommand group ───────────────────────────────────────────────

const entityCmd = program
	.command("entity")
	.description("Manage entities.")
	.addHelpCommand(false)
	.configureHelp({ formatHelp: richFormatHelp });

entityCmd
	.command("list <entityType>")
	.description("List all entities of a given type.")
	.option("-o, --output <format>", "Output: table, json.", "table")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 entity list users\n  $ mem0 entity list agents -o json",
	)
	.action(async (entityType, opts) => {
		const { cmdEntitiesList } = await import("./commands/entities.js");
		const isAgent = checkAgentMode();
		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
		const output = isAgent ? "agent" : opts.output;
		await cmdEntitiesList(backend, entityType, { output });
	});

entityCmd
	.command("delete")
	.description("Delete an entity and ALL its memories (cascade).")
	.option("--dry-run", "Show what would be deleted without deleting.", false)
	.option("-u, --user-id <id>", "Scope to user.")
	.option("--agent-id <id>", "Scope to agent.")
	.option("--app-id <id>", "Scope to app.")
	.option("--run-id <id>", "Scope to run.")
	.option("--force", "Skip confirmation.", false)
	.option("-o, --output <format>", "Output: text, json, quiet.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 entity delete --user-id alice --force\n  $ mem0 entity delete --user-id alice --dry-run",
	)
	.action(async (opts) => {
		const { cmdEntitiesDelete } = await import("./commands/entities.js");
		const isAgent = checkAgentMode();
		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
		const output = isAgent ? "agent" : opts.output;
		await cmdEntitiesDelete(backend, { ...opts, output });
	});

// ── Event subcommands ─────────────────────────────────────────────────────

const eventCmd = program
	.command("event")
	.description("Inspect background processing events.")
	.addHelpCommand(false)
	.configureHelp({ formatHelp: richFormatHelp });

eventCmd
	.command("list")
	.description("List recent background processing events.")
	.option("-o, --output <format>", "Output: table, json.", "table")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 event list\n  $ mem0 event list -o json",
	)
	.action(async (opts) => {
		const { cmdEventList } = await import("./commands/events.js");
		const isAgent = checkAgentMode();
		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
		const output = isAgent ? "agent" : opts.output;
		await cmdEventList(backend, { output });
	});

eventCmd
	.command("status <eventId>")
	.description("Check the status of a specific background event.")
	.option("-o, --output <format>", "Output: text, json.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 event status <event-id>\n  $ mem0 event status <event-id> -o json",
	)
	.action(async (eventId, opts) => {
		const { cmdEventStatus } = await import("./commands/events.js");
		const isAgent = checkAgentMode();
		const backend = await getBackendOnly(opts.apiKey, opts.baseUrl);
		const output = isAgent ? "agent" : opts.output;
		await cmdEventStatus(backend, eventId, { output });
	});

// ── Utility commands ──────────────────────────────────────────────────────

program
	.command("status")
	.description("Check connectivity and authentication.")
	.option("-o, --output <format>", "Output: text, json.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText("after", "\nExamples:\n  $ mem0 status\n  $ mem0 status -o json")
	.action(async (opts) => {
		const { cmdStatus } = await import("./commands/utils.js");
		const isAgent = checkAgentMode();
		const { backend, config } = await getBackendAndConfig(
			opts.apiKey,
			opts.baseUrl,
		);
		const output = isAgent ? "agent" : opts.output;
		await cmdStatus(backend, {
			userId: config.defaults.userId || undefined,
			agentId: config.defaults.agentId || undefined,
			output,
		});
	});

program
	.command("import <filePath>")
	.description("Import memories from a JSON file.")
	.option("-u, --user-id <id>", "Override user ID.")
	.option("--agent-id <id>", "Override agent ID.")
	.option("-o, --output <format>", "Output: text, json.", "text")
	.option("--api-key <key>", "Override API key.")
	.option("--base-url <url>", "Override API base URL.")
	.addHelpText(
		"after",
		"\nExamples:\n  $ mem0 import data.json --user-id alice\n  $ mem0 import data.json -u alice -o json",
	)
	.action(async (filePath, opts) => {
		const { cmdImport } = await import("./commands/utils.js");
		const isAgent = checkAgentMode();
		const { backend, config } = await getBackendAndConfig(
			opts.apiKey,
			opts.baseUrl,
		);
		const ids = resolveIds(config, opts);
		const output = isAgent ? "agent" : opts.output;
		await cmdImport(backend, filePath, {
			userId: ids.userId,
			agentId: ids.agentId,
			output,
		});
	});

// ── Help (machine-readable) ──────────────────────────────────────────────

program
	.command("help")
	.description(
		"Show help. Use --json for machine-readable output (for LLM agents).",
	)
	.option("--json", "Output machine-readable JSON for LLM agents.", false)
	.addHelpText("after", "\nExamples:\n  $ mem0 help\n  $ mem0 help --json")
	.action((opts) => {
		// opts.json is set when `mem0 help --json` is used (subcommand flag).
		// program.opts().json is set when the root --json global flag was used first.
		if (opts.json || program.opts().json) {
			// Load spec from parent directory
			const __dirname = path.dirname(fileURLToPath(import.meta.url));
			const specPath = path.join(__dirname, "..", "..", "cli-spec.json");
			if (fs.existsSync(specPath)) {
				const spec = JSON.parse(fs.readFileSync(specPath, "utf-8"));
				console.log(JSON.stringify(spec, null, 2));
			} else {
				console.log(
					JSON.stringify(
						{
							name: "mem0",
							version: CLI_VERSION,
							description: "The Memory Layer for AI Agents",
						},
						null,
						2,
					),
				);
			}
		} else {
			const { brand: b } = colors;
			console.log(
				`${b("◆ Mem0 CLI")} v${CLI_VERSION} · Node.js SDK\n  The Memory Layer for AI Agents\n`,
			);
			console.log("Usage: mem0 <command> [OPTIONS]\n");
			console.log("Commands:");
			console.log(
				"  add              Add a memory from text, messages, file, or stdin",
			);
			console.log(
				"  search           Query your memory store (semantic, keyword, hybrid)",
			);
			console.log("  get              Get a specific memory by ID");
			console.log("  list             List memories with optional filters");
			console.log("  update           Update a memory's text or metadata");
			console.log(
				"  delete           Delete a memory, all memories, or an entity",
			);
			console.log("  import           Import memories from a JSON file");
			console.log("  config           Manage configuration (show, get, set)");
			console.log("  entity           Manage entities (list, delete)");
			console.log(
				"  event            Inspect background events (list, status)",
			);
			console.log("  init             Interactive setup wizard");
			console.log("  status           Check connectivity and authentication");
			console.log();
			console.log("  mem0 <command> --help    Get help for a command");
			console.log(
				"  mem0 help --json         Machine-readable help (for LLM agents)",
			);
			console.log();
		}
	});

// ── Entrypoint ────────────────────────────────────────────────────────────

program.parse();