@mem0/cli 0.1.0

package/dist/chunk-O3XZVUUX.js

@@ -0,0 +1,252 @@
+// src/backend/base.ts
+var AuthError = class extends Error {
+  constructor(message = "Authentication failed. Your API key may be invalid or expired.") {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(path) {
+    super(`Resource not found: ${path}`);
+    this.name = "NotFoundError";
+  }
+};
+var APIError = class extends Error {
+  constructor(path, detail) {
+    super(`Bad request to ${path}: ${detail}`);
+    this.name = "APIError";
+  }
+};
+function getBackend(config) {
+  return new PlatformBackend(config.platform);
+}
+
+// src/backend/platform.ts
+var PlatformBackend = class {
+  baseUrl;
+  headers;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `Token ${config.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async _request(method, path, opts) {
+    let url = `${this.baseUrl}${path}`;
+    if (opts?.params) {
+      const qs = new URLSearchParams(opts.params).toString();
+      url += `?${qs}`;
+    }
+    const fetchOpts = {
+      method,
+      headers: this.headers,
+      signal: AbortSignal.timeout(3e4)
+    };
+    if (opts?.json) {
+      fetchOpts.body = JSON.stringify(opts.json);
+    }
+    const resp = await fetch(url, fetchOpts);
+    if (resp.status === 401) {
+      throw new AuthError();
+    }
+    if (resp.status === 404) {
+      throw new NotFoundError(path);
+    }
+    if (resp.status === 400) {
+      let detail;
+      try {
+        const body = await resp.json();
+        detail = body.detail ?? resp.statusText;
+      } catch {
+        detail = resp.statusText;
+      }
+      throw new APIError(path, detail);
+    }
+    if (!resp.ok) {
+      throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+    }
+    if (resp.status === 204) {
+      return {};
+    }
+    return resp.json();
+  }
+  async add(content, messages, opts = {}) {
+    const payload = {};
+    if (messages) {
+      payload.messages = messages;
+    } else if (content) {
+      payload.messages = [{ role: "user", content }];
+    }
+    if (opts.userId) payload.user_id = opts.userId;
+    if (opts.agentId) payload.agent_id = opts.agentId;
+    if (opts.appId) payload.app_id = opts.appId;
+    if (opts.runId) payload.run_id = opts.runId;
+    if (opts.metadata) payload.metadata = opts.metadata;
+    if (opts.immutable) payload.immutable = true;
+    if (opts.infer === false) payload.infer = false;
+    if (opts.expires) payload.expiration_date = opts.expires;
+    if (opts.categories) payload.categories = opts.categories;
+    if (opts.enableGraph) payload.enable_graph = true;
+    return await this._request("POST", "/v1/memories/", { json: payload });
+  }
+  _buildFilters(opts) {
+    if (opts.extraFilters && ("AND" in opts.extraFilters || "OR" in opts.extraFilters)) {
+      return opts.extraFilters;
+    }
+    const andConditions = [];
+    if (opts.userId) andConditions.push({ user_id: opts.userId });
+    if (opts.agentId) andConditions.push({ agent_id: opts.agentId });
+    if (opts.appId) andConditions.push({ app_id: opts.appId });
+    if (opts.runId) andConditions.push({ run_id: opts.runId });
+    if (opts.extraFilters) {
+      for (const [k, v] of Object.entries(opts.extraFilters)) {
+        andConditions.push({ [k]: v });
+      }
+    }
+    if (andConditions.length === 1) return andConditions[0];
+    if (andConditions.length > 1) return { AND: andConditions };
+    return void 0;
+  }
+  async search(query, opts = {}) {
+    const payload = {
+      query,
+      top_k: opts.topK ?? 10,
+      threshold: opts.threshold ?? 0.3
+    };
+    const apiFilters = this._buildFilters({
+      userId: opts.userId,
+      agentId: opts.agentId,
+      appId: opts.appId,
+      runId: opts.runId,
+      extraFilters: opts.filters
+    });
+    if (apiFilters) payload.filters = apiFilters;
+    if (opts.rerank) payload.rerank = true;
+    if (opts.keyword) payload.keyword_search = true;
+    if (opts.fields) payload.fields = opts.fields;
+    if (opts.enableGraph) payload.enable_graph = true;
+    const result = await this._request("POST", "/v2/memories/search/", {
+      json: payload
+    });
+    if (Array.isArray(result)) return result;
+    const obj = result;
+    return obj.results ?? obj.memories ?? [];
+  }
+  async get(memoryId) {
+    return await this._request("GET", `/v1/memories/${memoryId}/`);
+  }
+  async listMemories(opts = {}) {
+    const payload = {};
+    const params = {
+      page: String(opts.page ?? 1),
+      page_size: String(opts.pageSize ?? 100)
+    };
+    const extra = {};
+    if (opts.category) {
+      extra.categories = { contains: opts.category };
+    }
+    if (opts.after) {
+      extra.created_at = { ...extra.created_at, gte: opts.after };
+    }
+    if (opts.before) {
+      extra.created_at = { ...extra.created_at, lte: opts.before };
+    }
+    const apiFilters = this._buildFilters({
+      userId: opts.userId,
+      agentId: opts.agentId,
+      appId: opts.appId,
+      runId: opts.runId,
+      extraFilters: Object.keys(extra).length > 0 ? extra : void 0
+    });
+    if (apiFilters) payload.filters = apiFilters;
+    if (opts.enableGraph) payload.enable_graph = true;
+    const result = await this._request("POST", "/v2/memories/", { json: payload, params });
+    if (Array.isArray(result)) return result;
+    const obj = result;
+    return obj.results ?? obj.memories ?? [];
+  }
+  async update(memoryId, content, metadata) {
+    const payload = {};
+    if (content) payload.text = content;
+    if (metadata) payload.metadata = metadata;
+    return await this._request("PUT", `/v1/memories/${memoryId}/`, {
+      json: payload
+    });
+  }
+  async delete(memoryId, opts = {}) {
+    if (opts.all) {
+      const params = {};
+      if (opts.userId) params.user_id = opts.userId;
+      if (opts.agentId) params.agent_id = opts.agentId;
+      if (opts.appId) params.app_id = opts.appId;
+      if (opts.runId) params.run_id = opts.runId;
+      return await this._request("DELETE", "/v1/memories/", { params });
+    }
+    if (memoryId) {
+      return await this._request("DELETE", `/v1/memories/${memoryId}/`);
+    }
+    throw new Error("Either memoryId or --all is required");
+  }
+  async deleteEntities(opts) {
+    const params = {};
+    if (opts.userId) params.user_id = opts.userId;
+    if (opts.agentId) params.agent_id = opts.agentId;
+    if (opts.appId) params.app_id = opts.appId;
+    if (opts.runId) params.run_id = opts.runId;
+    if (Object.keys(params).length === 0) {
+      throw new Error("At least one entity ID is required for deleteEntities.");
+    }
+    return await this._request("DELETE", "/v1/entities/", { params });
+  }
+  async status(opts = {}) {
+    try {
+      if (opts.userId || opts.agentId) {
+        const payload = {};
+        const statusParams = { page: "1", page_size: "1" };
+        const apiFilters = this._buildFilters({
+          userId: opts.userId,
+          agentId: opts.agentId
+        });
+        if (apiFilters) payload.filters = apiFilters;
+        await this._request("POST", "/v2/memories/", { json: payload, params: statusParams });
+      } else {
+        await this._request("GET", "/v1/entities/");
+      }
+      return { connected: true, backend: "platform", base_url: this.baseUrl };
+    } catch (e) {
+      return {
+        connected: false,
+        backend: "platform",
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  async entities(entityType) {
+    const result = await this._request("GET", "/v1/entities/");
+    let items;
+    if (Array.isArray(result)) {
+      items = result;
+    } else {
+      items = result.results ?? [];
+    }
+    const typeMap = {
+      users: "user",
+      agents: "agent",
+      apps: "app",
+      runs: "run"
+    };
+    const targetType = typeMap[entityType];
+    if (targetType) {
+      items = items.filter(
+        (e) => e.type?.toLowerCase() === targetType
+      );
+    }
+    return items;
+  }
+};
+
+export {
+  PlatformBackend,
+  getBackend
+};

package/dist/config-WKOCXNAS.js

@@ -0,0 +1,86 @@
+import {
+  getNestedValue,
+  loadConfig,
+  redactKey,
+  saveConfig,
+  setNestedValue
+} from "./chunk-EJ5AQPMT.js";
+import {
+  formatJsonEnvelope
+} from "./chunk-J7DYZDMM.js";
+import {
+  colors,
+  printError,
+  printSuccess
+} from "./chunk-I7ABQZUR.js";
+
+// src/commands/config.ts
+import Table from "cli-table3";
+var { brand, accent, dim } = colors;
+function cmdConfigShow(opts = {}) {
+  const config = loadConfig();
+  if (opts.output === "json") {
+    formatJsonEnvelope({
+      command: "config show",
+      data: {
+        defaults: {
+          user_id: config.defaults.userId || null,
+          agent_id: config.defaults.agentId || null,
+          app_id: config.defaults.appId || null,
+          run_id: config.defaults.runId || null,
+          enable_graph: config.defaults.enableGraph
+        },
+        platform: {
+          api_key: redactKey(config.platform.apiKey),
+          base_url: config.platform.baseUrl
+        }
+      }
+    });
+    return;
+  }
+  console.log();
+  console.log(`  ${brand("\u25C6 mem0 Configuration")}
+`);
+  const table = new Table({
+    head: [accent("Key"), accent("Value")],
+    style: { head: [], border: [] }
+  });
+  table.push(["defaults.user_id", config.defaults.userId || dim("(not set)")]);
+  table.push(["defaults.agent_id", config.defaults.agentId || dim("(not set)")]);
+  table.push(["defaults.app_id", config.defaults.appId || dim("(not set)")]);
+  table.push(["defaults.run_id", config.defaults.runId || dim("(not set)")]);
+  table.push(["defaults.enable_graph", String(config.defaults.enableGraph)]);
+  table.push(["", ""]);
+  table.push(["platform.api_key", redactKey(config.platform.apiKey)]);
+  table.push(["platform.base_url", config.platform.baseUrl]);
+  console.log(table.toString());
+  console.log();
+}
+function cmdConfigGet(key) {
+  const config = loadConfig();
+  const value = getNestedValue(config, key);
+  if (value === void 0) {
+    printError(`Unknown config key: ${key}`);
+  } else {
+    if (key.includes("api_key") || key.split(".").pop() === "key") {
+      console.log(redactKey(String(value)));
+    } else {
+      console.log(String(value));
+    }
+  }
+}
+function cmdConfigSet(key, value) {
+  const config = loadConfig();
+  if (setNestedValue(config, key, value)) {
+    saveConfig(config);
+    const display = key.includes("key") ? redactKey(value) : value;
+    printSuccess(`${key} = ${display}`);
+  } else {
+    printError(`Unknown config key: ${key}`);
+  }
+}
+export {
+  cmdConfigGet,
+  cmdConfigSet,
+  cmdConfigShow
+};

package/dist/entities-XPRXH4X4.js

@@ -0,0 +1,119 @@
+import {
+  formatJson
+} from "./chunk-J7DYZDMM.js";
+import {
+  colors,
+  printError,
+  printInfo,
+  printSuccess,
+  timedStatus
+} from "./chunk-I7ABQZUR.js";
+
+// src/commands/entities.ts
+import readline from "readline";
+import Table from "cli-table3";
+var { brand, accent, dim } = colors;
+var VALID_TYPES = /* @__PURE__ */ new Set(["users", "agents", "apps", "runs"]);
+async function cmdEntitiesList(backend, entityType, opts) {
+  if (!VALID_TYPES.has(entityType)) {
+    printError(`Invalid entity type: ${entityType}. Use: ${[...VALID_TYPES].join(", ")}`);
+    process.exit(1);
+  }
+  const start = performance.now();
+  let results;
+  try {
+    results = await timedStatus(`Fetching ${entityType}...`, async () => {
+      return backend.entities(entityType);
+    });
+  } catch (e) {
+    printError(
+      e instanceof Error ? e.message : String(e),
+      "This feature may require the mem0 Platform."
+    );
+    process.exit(1);
+  }
+  const elapsed = (performance.now() - start) / 1e3;
+  if (opts.output === "json") {
+    formatJson(results);
+    return;
+  }
+  if (!results.length) {
+    printInfo(`No ${entityType} found.`);
+    return;
+  }
+  const table = new Table({
+    head: [accent("Name / ID"), accent("Created")],
+    style: { head: [], border: [] }
+  });
+  for (const entity of results) {
+    const name = String(entity.name ?? entity.id ?? "\u2014");
+    const created = String(entity.created_at ?? "\u2014").slice(0, 10);
+    table.push([name, created]);
+  }
+  console.log();
+  console.log(table.toString());
+  console.log(`  ${dim(`${results.length} ${entityType} (${elapsed.toFixed(2)}s)`)}`);
+  console.log();
+}
+async function cmdEntitiesDelete(backend, opts) {
+  if (!opts.userId && !opts.agentId && !opts.appId && !opts.runId) {
+    printError("Provide at least one of --user-id, --agent-id, --app-id, --run-id.");
+    process.exit(1);
+  }
+  if (opts.dryRun) {
+    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}`);
+    printInfo(`Would delete entity ${scopeParts.join(", ")} and all its 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.join(", ");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question(
+        `
+  \u26A0  Delete entity ${scope} AND all its memories? 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 entity...", async () => {
+      return backend.deleteEntities({
+        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") {
+    printSuccess(`Entity deleted with all memories (${elapsed.toFixed(2)}s)`);
+  }
+}
+export {
+  cmdEntitiesDelete,
+  cmdEntitiesList
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node