@hasna/mementos 0.14.17 → 0.14.19

package/dist/sdk/index.js

@@ -0,0 +1,397 @@
+// @bun
+// src/sdk/index.ts
+class MementosError extends Error {
+  status;
+  details;
+  constructor(message, status, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+    this.name = "MementosError";
+  }
+}
+
+class MementosClient {
+  baseUrl;
+  _fetch;
+  constructor(config = {}) {
+    this.baseUrl = (config.baseUrl ?? "http://localhost:19428").replace(/\/$/, "");
+    this._fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  static fromEnv(overrides = {}) {
+    const envUrl = typeof process !== "undefined" ? process.env?.["MEMENTOS_URL"] : undefined;
+    const baseUrl = envUrl ?? "http://localhost:19428";
+    return new MementosClient({ baseUrl, ...overrides });
+  }
+  async request(method, path, body, query) {
+    let url = `${this.baseUrl}${path}`;
+    if (query) {
+      const params = new URLSearchParams;
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== undefined)
+          params.set(k, String(v));
+      }
+      const qs = params.toString();
+      if (qs)
+        url += `?${qs}`;
+    }
+    const res = await this._fetch(url, {
+      method,
+      headers: body !== undefined ? { "Content-Type": "application/json" } : {},
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    if (!res.ok) {
+      let errBody = {};
+      try {
+        errBody = await res.json();
+      } catch {}
+      throw new MementosError(errBody.error ?? `HTTP ${res.status}`, res.status, errBody.details);
+    }
+    if (res.status === 204)
+      return;
+    return res.json();
+  }
+  get(path, query) {
+    return this.request("GET", path, undefined, query);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  delete(path) {
+    return this.request("DELETE", path);
+  }
+  async listMemories(filter = {}) {
+    const q = {};
+    if (filter.scope)
+      q["scope"] = filter.scope;
+    if (filter.category)
+      q["category"] = filter.category;
+    if (filter.tags?.length)
+      q["tags"] = filter.tags.join(",");
+    if (filter.min_importance !== undefined)
+      q["min_importance"] = filter.min_importance;
+    if (filter.pinned !== undefined)
+      q["pinned"] = filter.pinned;
+    if (filter.agent_id)
+      q["agent_id"] = filter.agent_id;
+    if (filter.project_id)
+      q["project_id"] = filter.project_id;
+    if (filter.session_id)
+      q["session_id"] = filter.session_id;
+    if (filter.namespace)
+      q["namespace"] = filter.namespace;
+    if (filter.status)
+      q["status"] = filter.status;
+    if (filter.limit !== undefined)
+      q["limit"] = filter.limit;
+    if (filter.offset !== undefined)
+      q["offset"] = filter.offset;
+    if (filter.fields?.length)
+      q["fields"] = filter.fields.join(",");
+    return this.get("/api/memories", q);
+  }
+  getStats() {
+    return this.get("/api/memories/stats");
+  }
+  getHealth() {
+    return this.get("/api/health");
+  }
+  getReport(options) {
+    return this.get("/api/report", options);
+  }
+  getStaleMemories(options) {
+    return this.get("/api/memories/stale", options);
+  }
+  getActivity(options) {
+    return this.get("/api/activity", options);
+  }
+  searchMemories(input) {
+    const body = typeof input === "string" ? { query: input } : input;
+    return this.post("/api/memories/search", body);
+  }
+  exportMemories(input = {}) {
+    return this.post("/api/memories/export", input);
+  }
+  importMemories(input) {
+    return this.post("/api/memories/import", input);
+  }
+  cleanExpired() {
+    return this.post("/api/memories/clean");
+  }
+  extractFromSession(input) {
+    return this.post("/api/memories/extract", input);
+  }
+  saveMemory(input) {
+    return this.post("/api/memories", input);
+  }
+  getMemory(id) {
+    return this.get(`/api/memories/${id}`);
+  }
+  getMemoryVersions(id) {
+    return this.get(`/api/memories/${id}/versions`);
+  }
+  updateMemory(id, input) {
+    return this.patch(`/api/memories/${id}`, input);
+  }
+  deleteMemory(id) {
+    return this.delete(`/api/memories/${id}`);
+  }
+  listAgents() {
+    return this.get("/api/agents");
+  }
+  registerAgent(input) {
+    return this.post("/api/agents", input);
+  }
+  getAgent(idOrName) {
+    return this.get(`/api/agents/${idOrName}`);
+  }
+  updateAgent(idOrName, updates) {
+    return this.patch(`/api/agents/${idOrName}`, updates);
+  }
+  listAgentsByProject(projectId) {
+    return this.get(`/api/agents`, { project_id: projectId });
+  }
+  listProjects() {
+    return this.get("/api/projects");
+  }
+  registerProject(input) {
+    return this.post("/api/projects", input);
+  }
+  getProject(idOrName) {
+    return this.get(`/api/projects/${encodeURIComponent(idOrName)}`);
+  }
+  getProjectAgents(idOrName) {
+    return this.get(`/api/projects/${encodeURIComponent(idOrName)}/agents`);
+  }
+  listEntities(filter) {
+    return this.get("/api/entities", filter);
+  }
+  createEntity(input) {
+    return this.post("/api/entities", input);
+  }
+  mergeEntities(input) {
+    return this.post("/api/entities/merge", input);
+  }
+  getEntity(id) {
+    return this.get(`/api/entities/${id}`);
+  }
+  updateEntity(id, input) {
+    return this.patch(`/api/entities/${id}`, input);
+  }
+  deleteEntity(id) {
+    return this.delete(`/api/entities/${id}`);
+  }
+  getEntityMemories(entityId) {
+    return this.get(`/api/entities/${entityId}/memories`);
+  }
+  linkEntityMemory(entityId, input) {
+    return this.post(`/api/entities/${entityId}/memories`, input);
+  }
+  unlinkEntityMemory(entityId, memoryId) {
+    return this.delete(`/api/entities/${entityId}/memories/${memoryId}`);
+  }
+  getEntityRelations(entityId, filter) {
+    return this.get(`/api/entities/${entityId}/relations`, filter);
+  }
+  createRelation(input) {
+    return this.post("/api/relations", input);
+  }
+  getRelation(id) {
+    return this.get(`/api/relations/${id}`);
+  }
+  deleteRelation(id) {
+    return this.delete(`/api/relations/${id}`);
+  }
+  getGraph(entityId, options) {
+    const q = {};
+    if (options?.depth !== undefined)
+      q["depth"] = options.depth;
+    if (options?.relation_types?.length)
+      q["relation_types"] = options.relation_types.join(",");
+    return this.get(`/api/graph/${entityId}`, q);
+  }
+  findPath(fromId, toId) {
+    return this.get("/api/graph/path", { from: fromId, to: toId });
+  }
+  getGraphStats() {
+    return this.get("/api/graph/stats");
+  }
+  async acquireLock(input) {
+    try {
+      return await this.post("/api/locks", input);
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("409"))
+        return null;
+      throw e;
+    }
+  }
+  checkLock(resourceType, resourceId, lockType) {
+    const params = { resource_type: resourceType, resource_id: resourceId };
+    if (lockType)
+      params["lock_type"] = lockType;
+    return this.get("/api/locks", params);
+  }
+  releaseLock(lockId, agentId) {
+    return this.request("DELETE", `/api/locks/${lockId}`, { agent_id: agentId });
+  }
+  listAgentLocks(agentId) {
+    return this.get(`/api/agents/${agentId}/locks`);
+  }
+  releaseAllAgentLocks(agentId) {
+    return this.request("DELETE", `/api/agents/${agentId}/locks`);
+  }
+  cleanExpiredLocks() {
+    return this.post("/api/locks/clean", {});
+  }
+  createTask(input) {
+    return this.post("/api/tasks", input);
+  }
+  listTasks(filter = {}) {
+    const q = {};
+    if (filter.status)
+      q["status"] = filter.status;
+    if (filter.priority)
+      q["priority"] = filter.priority;
+    if (filter.assigned_agent_id)
+      q["assigned_agent_id"] = filter.assigned_agent_id;
+    if (filter.project_id)
+      q["project_id"] = filter.project_id;
+    if (filter.session_id)
+      q["session_id"] = filter.session_id;
+    if (filter.parent_task_id !== undefined) {
+      q["parent_task_id"] = filter.parent_task_id ?? "null";
+    }
+    if (filter.tags?.length)
+      q["tags"] = filter.tags.join(",");
+    if (filter.limit !== undefined)
+      q["limit"] = filter.limit;
+    if (filter.offset !== undefined)
+      q["offset"] = filter.offset;
+    return this.get("/api/tasks", q);
+  }
+  getTaskStats(options) {
+    return this.get("/api/tasks/stats", options);
+  }
+  getTask(id) {
+    return this.get(`/api/tasks/${id}`);
+  }
+  updateTask(id, input) {
+    return this.patch(`/api/tasks/${id}`, input);
+  }
+  deleteTask(id) {
+    return this.delete(`/api/tasks/${id}`);
+  }
+  listTaskComments(taskId) {
+    return this.get(`/api/tasks/${taskId}/comments`);
+  }
+  addTaskComment(taskId, body, agentId) {
+    return this.post(`/api/tasks/${taskId}/comments`, { body, agent_id: agentId });
+  }
+  deleteTaskComment(taskId, commentId) {
+    return this.delete(`/api/tasks/${taskId}/comments/${commentId}`);
+  }
+  getContext(options) {
+    return this.get("/api/inject", options);
+  }
+  processConversationTurn(turn, context) {
+    return this.post("/api/auto-memory/process", { turn, ...context });
+  }
+  getAutoMemoryStatus() {
+    return this.get("/api/auto-memory/status");
+  }
+  configureAutoMemory(config) {
+    return this.request("PATCH", "/api/auto-memory/config", config);
+  }
+  testExtraction(turn, options) {
+    return this.post("/api/auto-memory/test", { turn, ...options });
+  }
+  listHooks(type) {
+    const params = type ? `?type=${encodeURIComponent(type)}` : "";
+    return this.get(`/api/hooks${params}`);
+  }
+  getHookStats() {
+    return this.get("/api/hooks/stats");
+  }
+  listWebhooks(filter) {
+    const params = new URLSearchParams;
+    if (filter?.type)
+      params.set("type", filter.type);
+    if (filter?.enabled !== undefined)
+      params.set("enabled", String(filter.enabled));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.get(`/api/webhooks${qs}`);
+  }
+  createWebhook(input) {
+    return this.post("/api/webhooks", input);
+  }
+  getWebhook(id) {
+    return this.get(`/api/webhooks/${id}`);
+  }
+  updateWebhook(id, updates) {
+    return this.request("PATCH", `/api/webhooks/${id}`, updates);
+  }
+  deleteWebhook(id) {
+    return this.request("DELETE", `/api/webhooks/${id}`);
+  }
+  enableWebhook(id) {
+    return this.updateWebhook(id, { enabled: true });
+  }
+  disableWebhook(id) {
+    return this.updateWebhook(id, { enabled: false });
+  }
+  runSynthesis(options) {
+    return this.post("/api/synthesis/run", options ?? {});
+  }
+  listSynthesisRuns(filter) {
+    const params = new URLSearchParams;
+    if (filter?.project_id)
+      params.set("project_id", filter.project_id);
+    if (filter?.limit)
+      params.set("limit", String(filter.limit));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.get(`/api/synthesis/runs${qs}`);
+  }
+  getSynthesisStatus(options) {
+    const params = new URLSearchParams;
+    if (options?.project_id)
+      params.set("project_id", options.project_id);
+    if (options?.run_id)
+      params.set("run_id", options.run_id);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.get(`/api/synthesis/status${qs}`);
+  }
+  rollbackSynthesis(runId) {
+    return this.post(`/api/synthesis/rollback/${runId}`, {});
+  }
+  ingestSession(input) {
+    return this.post("/api/sessions/ingest", input);
+  }
+  getSessionJob(jobId) {
+    return this.get(`/api/sessions/jobs/${jobId}`);
+  }
+  listSessionJobs(filter) {
+    const params = new URLSearchParams;
+    if (filter?.agent_id)
+      params.set("agent_id", filter.agent_id);
+    if (filter?.project_id)
+      params.set("project_id", filter.project_id);
+    if (filter?.status)
+      params.set("status", filter.status);
+    if (filter?.limit)
+      params.set("limit", String(filter.limit));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.get(`/api/sessions/jobs${qs}`);
+  }
+  getSessionQueueStats() {
+    return this.get("/api/sessions/queue/stats");
+  }
+}
+var sdk_default = MementosClient;
+export {
+  sdk_default as default,
+  MementosError,
+  MementosClient
+};