@mem0/cli 0.1.0

package/dist/init-N25QFHYP.js

@@ -0,0 +1,161 @@
+import {
+  PlatformBackend
+} from "./chunk-O3XZVUUX.js";
+import {
+  createDefaultConfig,
+  saveConfig
+} from "./chunk-EJ5AQPMT.js";
+import {
+  colors,
+  printBanner,
+  printError,
+  printInfo,
+  printSuccess
+} from "./chunk-I7ABQZUR.js";
+
+// src/commands/init.ts
+import readline from "readline";
+var { brand, dim } = colors;
+function promptSecret(label) {
+  return new Promise((resolve, reject) => {
+    process.stdout.write(label);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    const chars = [];
+    const onData = (key) => {
+      for (const ch of key) {
+        if (ch === "\r" || ch === "\n") {
+          cleanup();
+          process.stdout.write("\n");
+          resolve(chars.join(""));
+          return;
+        }
+        if (ch === "") {
+          cleanup();
+          reject(new Error("Interrupted"));
+          return;
+        }
+        if (ch === "\x7F" || ch === "\b") {
+          if (chars.length > 0) {
+            chars.pop();
+            process.stdout.write("\b \b");
+          }
+        } else if (ch === "") {
+          process.stdout.write("\b \b".repeat(chars.length));
+          chars.length = 0;
+        } else if (ch >= " ") {
+          chars.push(ch);
+          process.stdout.write("*");
+        }
+      }
+    };
+    const cleanup = () => {
+      process.stdin.removeListener("data", onData);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    };
+    process.stdin.on("data", onData);
+  });
+}
+function promptLine(label, defaultValue) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = defaultValue ? `${label} [${defaultValue}]: ` : `${label}: `;
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+async function setupPlatform(config) {
+  console.log();
+  console.log(`  ${dim("Get your API key at https://app.mem0.ai/dashboard/api-keys")}`);
+  console.log();
+  process.stdout.write(`  ${brand("API Key")}: `);
+  const apiKey = await promptSecret("");
+  if (!apiKey) {
+    printError("API key is required.");
+    process.exit(1);
+  }
+  config.platform.apiKey = apiKey;
+}
+async function setupDefaults(config) {
+  console.log();
+  printInfo("Set default entity IDs (press Enter to skip).\n");
+  const userId = await promptLine(`  ${brand("Default User ID")} ${dim("(recommended)")}`, "mem0-cli");
+  if (userId) config.defaults.userId = userId;
+}
+async function validatePlatform(config) {
+  console.log();
+  printInfo("Validating connection...");
+  try {
+    const backend = new PlatformBackend(config.platform);
+    const status = await backend.status({
+      userId: config.defaults.userId || void 0,
+      agentId: config.defaults.agentId || void 0
+    });
+    if (status.connected) {
+      printSuccess("Connected to mem0 Platform!");
+    } else {
+      printError(
+        `Could not connect: ${status.error ?? "Unknown error"}`,
+        "Check your API key and try again."
+      );
+    }
+  } catch (e) {
+    printError(`Connection test failed: ${e instanceof Error ? e.message : e}`);
+  }
+}
+async function runInit(opts = {}) {
+  const config = createDefaultConfig();
+  if (opts.apiKey && opts.userId) {
+    config.platform.apiKey = opts.apiKey;
+    config.defaults.userId = opts.userId;
+    await validatePlatform(config);
+    saveConfig(config);
+    printSuccess("Configuration saved to ~/.mem0/config.json");
+    return;
+  }
+  if (!process.stdin.isTTY && (!opts.apiKey || !opts.userId)) {
+    printError(
+      "Non-interactive terminal detected and missing required flags.",
+      "Usage: mem0 init --api-key <key> --user-id <id>"
+    );
+    process.exit(1);
+  }
+  printBanner();
+  console.log();
+  printInfo("Welcome! Let's set up your mem0 CLI.\n");
+  if (opts.apiKey) {
+    config.platform.apiKey = opts.apiKey;
+  } else {
+    await setupPlatform(config);
+  }
+  if (opts.userId) {
+    config.defaults.userId = opts.userId;
+  } else {
+    await setupDefaults(config);
+  }
+  await validatePlatform(config);
+  saveConfig(config);
+  console.log();
+  printSuccess("Configuration saved to ~/.mem0/config.json");
+  console.log();
+  console.log(`  ${dim("Get started:")}`);
+  if (config.defaults.userId) {
+    console.log(`  ${dim('  mem0 add "I prefer dark mode"')}`);
+    console.log(`  ${dim('  mem0 search "preferences"')}`);
+  } else {
+    console.log(`  ${dim('  mem0 add "I prefer dark mode" --user-id alice')}`);
+    console.log(`  ${dim('  mem0 search "preferences" --user-id alice')}`);
+  }
+  console.log();
+}
+export {
+  runInit
+};

package/dist/memory-JYJGE4VO.js

@@ -0,0 +1,387 @@
+import {
+  formatAddResult,
+  formatJson,
+  formatMemoriesTable,
+  formatMemoriesText,
+  formatSingleMemory,
+  printResultSummary
+} from "./chunk-J7DYZDMM.js";
+import {
+  printError,
+  printInfo,
+  printScope,
+  printSuccess,
+  timedStatus
+} from "./chunk-I7ABQZUR.js";
+
+// src/commands/memory.ts
+import fs from "fs";
+async function cmdAdd(backend, text, opts) {
+  let msgs;
+  let content = text;
+  if (opts.file) {
+    try {
+      const raw = fs.readFileSync(opts.file, "utf-8");
+      msgs = JSON.parse(raw);
+    } catch (e) {
+      printError(`Failed to read file: ${e instanceof Error ? e.message : e}`);
+      process.exit(1);
+    }
+  } else if (opts.messages) {
+    try {
+      msgs = JSON.parse(opts.messages);
+    } catch (e) {
+      printError(`Invalid JSON in --messages: ${e instanceof Error ? e.message : e}`);
+      process.exit(1);
+    }
+  } else if (!content && !process.stdin.isTTY) {
+    content = fs.readFileSync(0, "utf-8").trim();
+  }
+  if (!content && !msgs) {
+    printError("No content provided. Pass text, --messages, --file, or pipe via stdin.");
+    process.exit(1);
+  }
+  let meta;
+  if (opts.metadata) {
+    try {
+      meta = JSON.parse(opts.metadata);
+    } catch {
+      printError("Invalid JSON in --metadata.");
+      process.exit(1);
+    }
+  }
+  let cats;
+  if (opts.categories) {
+    try {
+      cats = JSON.parse(opts.categories);
+    } catch {
+      cats = opts.categories.split(",").map((c) => c.trim());
+    }
+  }
+  let result;
+  try {
+    result = await timedStatus("Adding memory...", async () => {
+      return backend.add(content ?? void 0, msgs, {
+        userId: opts.userId,
+        agentId: opts.agentId,
+        appId: opts.appId,
+        runId: opts.runId,
+        metadata: meta,
+        immutable: opts.immutable,
+        infer: !opts.noInfer,
+        expires: opts.expires,
+        categories: cats,
+        enableGraph: opts.enableGraph
+      });
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  if (opts.output === "quiet") return;
+  if (opts.output === "json") {
+    formatAddResult(result, opts.output);
+    return;
+  }
+  console.log();
+  printScope({ user_id: opts.userId, agent_id: opts.agentId, app_id: opts.appId, run_id: opts.runId });
+  const results = Array.isArray(result) ? result : result.results ?? [result];
+  const count = results.length;
+  printSuccess(`Memory processed \u2014 ${count} memor${count === 1 ? "y" : "ies"} extracted`);
+  formatAddResult(result, opts.output);
+}
+async function cmdSearch(backend, query, opts) {
+  if (!query) {
+    printError("No query provided. Pass a query argument or pipe via stdin.");
+    process.exit(1);
+  }
+  let filters;
+  if (opts.filterJson) {
+    try {
+      filters = JSON.parse(opts.filterJson);
+    } catch {
+      printError("Invalid JSON in --filter.");
+      process.exit(1);
+    }
+  }
+  const fieldList = opts.fields ? opts.fields.split(",").map((f) => f.trim()) : void 0;
+  const start = performance.now();
+  let results;
+  try {
+    results = await timedStatus("Searching memories...", async () => {
+      return backend.search(query, {
+        userId: opts.userId,
+        agentId: opts.agentId,
+        appId: opts.appId,
+        runId: opts.runId,
+        topK: opts.topK,
+        threshold: opts.threshold,
+        rerank: opts.rerank,
+        keyword: opts.keyword,
+        filters,
+        fields: fieldList,
+        enableGraph: opts.enableGraph
+      });
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJson(results);
+  } else if (opts.output === "table") {
+    if (results.length > 0) {
+      formatMemoriesTable(results);
+      printResultSummary({ count: results.length, durationSecs: elapsed, scopeIds: { user_id: opts.userId, agent_id: opts.agentId } });
+    } else {
+      console.log();
+      printInfo("No memories found matching your query.");
+      console.log();
+    }
+  } else {
+    if (results.length > 0) {
+      formatMemoriesText(results);
+      printResultSummary({ count: results.length, durationSecs: elapsed, scopeIds: { user_id: opts.userId, agent_id: opts.agentId } });
+    } else {
+      console.log();
+      printInfo("No memories found matching your query.");
+      console.log();
+    }
+  }
+}
+async function cmdGet(backend, memoryId, opts) {
+  let result;
+  try {
+    result = await timedStatus("Fetching memory...", async () => {
+      return backend.get(memoryId);
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  formatSingleMemory(result, opts.output);
+}
+async function cmdList(backend, opts) {
+  const start = performance.now();
+  let results;
+  try {
+    results = await timedStatus("Listing memories...", async () => {
+      return backend.listMemories({
+        userId: opts.userId,
+        agentId: opts.agentId,
+        appId: opts.appId,
+        runId: opts.runId,
+        page: opts.page,
+        pageSize: opts.pageSize,
+        category: opts.category,
+        after: opts.after,
+        before: opts.before,
+        enableGraph: opts.enableGraph
+      });
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJson(results);
+  } else if (opts.output === "table") {
+    if (results.length > 0) {
+      formatMemoriesTable(results);
+      printResultSummary({ count: results.length, durationSecs: elapsed, page: opts.page, scopeIds: { user_id: opts.userId, agent_id: opts.agentId } });
+    } else {
+      console.log();
+      printInfo("No memories found.");
+      console.log();
+    }
+  } else {
+    if (results.length > 0) {
+      formatMemoriesText(results, "memories");
+      printResultSummary({ count: results.length, durationSecs: elapsed, page: opts.page, scopeIds: { user_id: opts.userId, agent_id: opts.agentId } });
+    } else {
+      console.log();
+      printInfo("No memories found.");
+      console.log();
+    }
+  }
+}
+async function cmdUpdate(backend, memoryId, text, opts) {
+  let meta;
+  if (opts.metadata) {
+    try {
+      meta = JSON.parse(opts.metadata);
+    } catch {
+      printError("Invalid JSON in --metadata.");
+      process.exit(1);
+    }
+  }
+  const start = performance.now();
+  let result;
+  try {
+    result = await timedStatus("Updating memory...", async () => {
+      return backend.update(memoryId, text, meta);
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJson(result);
+  } else if (opts.output !== "quiet") {
+    printSuccess(`Memory ${memoryId.slice(0, 8)} updated (${elapsed.toFixed(2)}s)`);
+  }
+}
+async function cmdDelete(backend, memoryId, opts) {
+  if (opts.dryRun) {
+    let mem;
+    try {
+      mem = await backend.get(memoryId);
+    } catch (e) {
+      printError(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+    const text = mem.memory ?? mem.text ?? "";
+    printInfo(`Would delete memory ${memoryId.slice(0, 8)}: ${text}`);
+    printInfo("No changes made.");
+    return;
+  }
+  const start = performance.now();
+  let result;
+  try {
+    result = await timedStatus("Deleting...", async () => {
+      return backend.delete(memoryId);
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJson(result);
+  } else if (opts.output !== "quiet") {
+    printSuccess(`Memory ${memoryId.slice(0, 8)} deleted (${elapsed.toFixed(2)}s)`);
+  }
+}
+async function cmdDeleteAll(backend, opts) {
+  if (opts.all) {
+    if (opts.dryRun) {
+      printInfo("Would delete ALL memories project-wide.");
+      printInfo("No changes made.");
+      return;
+    }
+    if (!opts.force) {
+      const readline = await import("readline");
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question(`
+  \u26A0  Delete ALL memories across the ENTIRE project? This cannot be undone. [y/N] `, resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        printInfo("Cancelled.");
+        process.exit(0);
+      }
+    }
+    const start2 = performance.now();
+    let result2;
+    try {
+      result2 = await timedStatus("Deleting all memories project-wide...", async () => {
+        return backend.delete(void 0, {
+          all: true,
+          userId: "*",
+          agentId: "*",
+          appId: "*",
+          runId: "*"
+        });
+      });
+    } catch (e) {
+      printError(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+    const elapsed2 = (performance.now() - start2) / 1e3;
+    if (opts.output === "json") {
+      formatJson(result2);
+    } else if (opts.output !== "quiet") {
+      if (result2.message) {
+        printInfo("Deletion started. Memories will be removed in the background.");
+      } else {
+        printSuccess(`All project memories deleted (${elapsed2.toFixed(2)}s)`);
+      }
+    }
+    return;
+  }
+  if (opts.dryRun) {
+    let memories;
+    try {
+      memories = await backend.listMemories({
+        userId: opts.userId,
+        agentId: opts.agentId,
+        appId: opts.appId,
+        runId: opts.runId
+      });
+    } catch (e) {
+      printError(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+    printInfo(`Would delete ${memories.length} memories.`);
+    printInfo("No changes made.");
+    return;
+  }
+  if (!opts.force) {
+    const scopeParts = [];
+    if (opts.userId) scopeParts.push(`user=${opts.userId}`);
+    if (opts.agentId) scopeParts.push(`agent=${opts.agentId}`);
+    if (opts.appId) scopeParts.push(`app=${opts.appId}`);
+    if (opts.runId) scopeParts.push(`run=${opts.runId}`);
+    const scope = scopeParts.length > 0 ? scopeParts.join(", ") : "ALL entities";
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question(`
+  \u26A0  Delete ALL memories for ${scope}? This cannot be undone. [y/N] `, resolve);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      printInfo("Cancelled.");
+      process.exit(0);
+    }
+  }
+  const start = performance.now();
+  let result;
+  try {
+    result = await timedStatus("Deleting all memories...", async () => {
+      return backend.delete(void 0, {
+        all: true,
+        userId: opts.userId,
+        agentId: opts.agentId,
+        appId: opts.appId,
+        runId: opts.runId
+      });
+    });
+  } catch (e) {
+    printError(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJson(result);
+  } else if (opts.output !== "quiet") {
+    if (result.message) {
+      printInfo("Deletion started. Memories will be removed in the background.");
+    } else {
+      printSuccess(`All matching memories deleted (${elapsed.toFixed(2)}s)`);
+    }
+  }
+}
+export {
+  cmdAdd,
+  cmdDelete,
+  cmdDeleteAll,
+  cmdGet,
+  cmdList,
+  cmdSearch,
+  cmdUpdate
+};

package/dist/utils-BAMFZ5H5.js

@@ -0,0 +1,124 @@
+import {
+  formatJsonEnvelope
+} from "./chunk-J7DYZDMM.js";
+import {
+  colors,
+  printError,
+  printSuccess,
+  timedStatus
+} from "./chunk-I7ABQZUR.js";
+
+// src/commands/utils.ts
+import fs from "fs";
+import { createRequire } from "module";
+import boxen from "boxen";
+var { brand, dim, success, error: errorColor } = colors;
+var _require = createRequire(import.meta.url);
+var VERSION = _require("../../package.json").version;
+async function cmdStatus(backend, opts = {}) {
+  const start = performance.now();
+  let result;
+  try {
+    result = await timedStatus("Checking connection...", async () => {
+      return backend.status({ userId: opts.userId, agentId: opts.agentId });
+    });
+  } catch (e) {
+    result = { connected: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJsonEnvelope({
+      command: "status",
+      data: {
+        connected: result.connected,
+        backend: result.backend ?? null,
+        base_url: result.base_url ?? null,
+        latency_ms: Math.round(elapsed * 1e3)
+      },
+      durationMs: Math.round(elapsed * 1e3)
+    });
+    return;
+  }
+  const lines = [];
+  if (result.connected) {
+    lines.push(`  ${success("\u25CF")} Connected`);
+  } else {
+    lines.push(`  ${errorColor("\u25CF")} Disconnected`);
+  }
+  lines.push(`  ${dim("Backend:")}  ${result.backend ?? "?"}`);
+  if (result.base_url) {
+    lines.push(`  ${dim("API URL:")}  ${result.base_url}`);
+  }
+  if (result.error) {
+    lines.push(`  ${errorColor("Error:")}    ${result.error}`);
+  }
+  lines.push(`  ${dim("Latency:")}  ${elapsed.toFixed(2)}s`);
+  const content = lines.join("\n");
+  console.log();
+  console.log(
+    boxen(content, {
+      title: brand("Connection Status"),
+      titleAlignment: "left",
+      borderColor: "magenta",
+      padding: 1
+    })
+  );
+  console.log();
+}
+function cmdVersion() {
+  console.log(`  ${brand("\u25C6 Mem0")} CLI v${VERSION}`);
+}
+async function cmdImport(backend, filePath, opts) {
+  let data;
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    data = Array.isArray(parsed) ? parsed : [parsed];
+  } catch (e) {
+    printError(`Failed to read file: ${e instanceof Error ? e.message : e}`);
+    process.exit(1);
+  }
+  let added = 0;
+  let failed = 0;
+  const start = performance.now();
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+    const content = item.memory ?? item.text ?? item.content ?? "";
+    if (!content) {
+      failed++;
+      continue;
+    }
+    try {
+      await backend.add(content, void 0, {
+        userId: opts.userId ?? item.user_id,
+        agentId: opts.agentId ?? item.agent_id,
+        metadata: item.metadata
+      });
+      added++;
+    } catch {
+      failed++;
+    }
+    if ((i + 1) % 10 === 0 || i === data.length - 1) {
+      process.stdout.write(`\r  ${dim(`Importing memories... ${i + 1}/${data.length}`)}`);
+    }
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  console.log();
+  if (opts.output === "json") {
+    formatJsonEnvelope({
+      command: "import",
+      data: { added, failed, duration_s: parseFloat(elapsed.toFixed(2)) },
+      durationMs: Math.round(elapsed * 1e3)
+    });
+    return;
+  }
+  printSuccess(`Imported ${added} memories (${elapsed.toFixed(2)}s)`);
+  if (failed > 0) {
+    printError(`${failed} memories failed to import.`);
+  }
+}
+export {
+  cmdImport,
+  cmdStatus,
+  cmdVersion
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@mem0/cli",
+  "version": "0.1.0",
+  "description": "The official CLI for mem0 — the memory layer for AI agents",
+  "type": "module",
+  "bin": {
+    "mem0": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "Apache-2.0",
+  "author": "mem0.ai <founders@mem0.ai>",
+  "keywords": ["mem0", "memory", "ai", "agents", "cli"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.4",
+    "ora": "^8.0.0",
+    "boxen": "^7.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.7.0",
+    "vitest": "^1.5.0",
+    "@biomejs/biome": "^1.7.0",
+    "@types/node": "^20.0.0"
+  }
+}