@hasna/mementos 0.14.18 → 0.14.19

package/dist/mcp/index.js

@@ -11557,6 +11557,7 @@ CREATE TABLE IF NOT EXISTS machines (
   name TEXT NOT NULL UNIQUE,
   hostname TEXT NOT NULL,
   platform TEXT NOT NULL DEFAULT 'unknown',
+  is_primary INTEGER NOT NULL DEFAULT 0,
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
@@ -11936,33 +11937,44 @@ CREATE INDEX IF NOT EXISTS idx_memories_sequence_group ON memories(sequence_grou
 INSERT OR IGNORE INTO _migrations (id) VALUES (32);
 `,
     `
-ALTER TABLE machines ADD COLUMN is_primary INTEGER NOT NULL DEFAULT 0;
-CREATE INDEX IF NOT EXISTS idx_machines_primary ON machines(is_primary);
-CREATE TRIGGER IF NOT EXISTS machines_single_primary_insert
-AFTER INSERT ON machines
-WHEN NEW.is_primary = 1
-BEGIN
-  UPDATE machines
-  SET is_primary = 0,
-      last_seen_at = COALESCE(NEW.last_seen_at, datetime('now'))
-  WHERE id != NEW.id AND is_primary = 1;
-END;
-CREATE TRIGGER IF NOT EXISTS machines_single_primary_update
-AFTER UPDATE OF is_primary ON machines
-WHEN NEW.is_primary = 1
-BEGIN
-  UPDATE machines
-  SET is_primary = 0,
-      last_seen_at = COALESCE(NEW.last_seen_at, datetime('now'))
-  WHERE id != NEW.id AND is_primary = 1;
-END;
-CREATE TRIGGER IF NOT EXISTS machines_prevent_delete_primary
-BEFORE DELETE ON machines
-WHEN OLD.is_primary = 1
-BEGIN
-  SELECT RAISE(ABORT, 'Primary machine cannot be deleted');
-END;
-INSERT OR IGNORE INTO _migrations (id) VALUES (33);
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  subject TEXT NOT NULL,
+  description TEXT DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+  priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('critical', 'high', 'medium', 'low')),
+  tags TEXT NOT NULL DEFAULT '[]',
+  assigned_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  parent_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  progress REAL NOT NULL DEFAULT 0 CHECK(progress >= 0 AND progress <= 1),
+  due_at TEXT,
+  started_at TEXT,
+  completed_at TEXT,
+  failed_at TEXT,
+  error TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(assigned_agent_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_task_id);
+
+CREATE TABLE IF NOT EXISTS task_comments (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  body TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_comments_agent ON task_comments(agent_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (34);
 `
   ];
 });
@@ -12617,7 +12629,7 @@ function createMemory(input, dedupeMode = "merge", db) {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 1, ?, ?, ?, ?, ?, ?)`, [
     id,
     input.key,
-    input.value,
+    safeValue,
     input.category || "knowledge",
     input.scope || "private",
     input.summary || null,
@@ -13091,8 +13103,12 @@ function parseMachine(row) {
     is_primary: Boolean(row.is_primary)
   };
 }
+function normalizeHostname(host) {
+  return host.replace(/\.(local|lan|home|internal)$/i, "");
+}
 function registerMachine(name, db = getDatabase()) {
-  const host = hostname2();
+  const rawHost = hostname2();
+  const host = normalizeHostname(rawHost);
   const plat = platform2();
   const machineName = name?.trim() || host;
   const existing = parseMachine(db.query("SELECT * FROM machines WHERE hostname = ?").get(host));
@@ -13156,7 +13172,7 @@ function touchMachine(id, db = getDatabase()) {
   db.run("UPDATE machines SET last_seen_at = ? WHERE id = ?", [now(), id]);
 }
 function getCurrentMachineId(db = getDatabase()) {
-  const host = hostname2();
+  const host = normalizeHostname(hostname2());
   const m = db.query("SELECT id FROM machines WHERE hostname = ?").get(host);
   if (m) {
     touchMachine(m.id, db);
@@ -13879,6 +13895,10 @@ function buildFilterConditions(filter) {
       params.push(tag);
     }
   }
+  if (filter.namespace) {
+    conditions.push("m.namespace = ?");
+    params.push(filter.namespace);
+  }
   return { conditions, params };
 }
 function searchWithFts5(d, query, queryLower, filter, graphBoostedIds) {
@@ -23126,6 +23146,7 @@ function resolveProjectId(agentId, explicitProjectId) {
 
 // src/mcp/tools/memory-crud.ts
 init_database();
+init_machines();
 init_search();
 
 // src/lib/duration.ts
@@ -23314,6 +23335,11 @@ function registerMemoryCrudTools(server) {
       }
       const dedupeMode = conflict ?? "merge";
       const conflictStrategy = args.conflict_strategy ?? "last_writer_wins";
+      if (!input.machine_id) {
+        try {
+          input.machine_id = getCurrentMachineId();
+        } catch {}
+      }
       if (conflictStrategy === "reject" && input.agent_id) {
         const db = getDatabase();
         try {
@@ -26783,7 +26809,14 @@ Created: ${project.created_at}`
       const machines = listMachines();
       return { content: [{ type: "text", text: JSON.stringify(machines) }] };
     } catch (e) {
-      return { content: [{ type: "text", text: formatError3(e) }], isError: true };
+      try {
+        const machines = listMachines();
+        return { content: [{ type: "text", text: JSON.stringify(machines) + `
+
+(Note: Cloud pull failed, showing local data only)` }] };
+      } catch {
+        return { content: [{ type: "text", text: formatError3(e) }], isError: true };
+      }
     }
   });
   server.tool("rename_machine", "Rename a machine by its ID or current name.", { id: exports_external2.string().describe("Machine ID or name"), new_name: exports_external2.string() }, async (args) => {

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
+};