@hasna/mementos 0.14.18 → 0.14.20

package/dist/index.js

@@ -9765,6 +9765,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'))
 );
@@ -10144,33 +10145,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);
 `
   ];
 });
@@ -10892,7 +10904,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,
@@ -11688,8 +11700,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 = hostname();
+  const rawHost = hostname();
+  const host = normalizeHostname(rawHost);
   const plat = platform2();
   const machineName = name?.trim() || host;
   const existing = parseMachine(db.query("SELECT * FROM machines WHERE hostname = ?").get(host));
@@ -11765,7 +11781,7 @@ function touchMachine(id, db = getDatabase()) {
   db.run("UPDATE machines SET last_seen_at = ? WHERE id = ?", [now(), id]);
 }
 function getCurrentMachineId(db = getDatabase()) {
-  const host = hostname();
+  const host = normalizeHostname(hostname());
   const m = db.query("SELECT id FROM machines WHERE hostname = ?").get(host);
   if (m) {
     touchMachine(m.id, db);
@@ -12306,6 +12322,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) {
@@ -14161,9 +14181,423 @@ function clearActiveModel() {
   delete config.activeModel;
   writeConfig(config);
 }
+// src/db/tasks.ts
+init_database();
+function parseTask(row) {
+  return {
+    id: row.id,
+    subject: row.subject,
+    description: row.description ?? "",
+    status: row.status,
+    priority: row.priority,
+    tags: JSON.parse(row.tags ?? "[]"),
+    assigned_agent_id: row.assigned_agent_id ?? null,
+    project_id: row.project_id ?? null,
+    session_id: row.session_id ?? null,
+    parent_task_id: row.parent_task_id ?? null,
+    metadata: JSON.parse(row.metadata ?? "{}"),
+    progress: row.progress,
+    due_at: row.due_at ?? null,
+    started_at: row.started_at ?? null,
+    completed_at: row.completed_at ?? null,
+    failed_at: row.failed_at ?? null,
+    error: row.error ?? null,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function createTask(db, input) {
+  const id = uuid();
+  const ts = now();
+  db.run(`INSERT INTO tasks (id, subject, description, status, priority, tags, assigned_agent_id, project_id, session_id, parent_task_id, metadata, due_at, created_at, updated_at)
+     VALUES (?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.subject,
+    input.description ?? "",
+    input.priority ?? "medium",
+    JSON.stringify(input.tags ?? []),
+    input.assigned_agent_id ?? null,
+    input.project_id ?? null,
+    input.session_id ?? null,
+    input.parent_task_id ?? null,
+    JSON.stringify(input.metadata ?? {}),
+    input.due_at ?? null,
+    ts,
+    ts
+  ]);
+  const row = db.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  if (!row) {
+    throw new Error(`Failed to load task after create: ${id}`);
+  }
+  return parseTask(row);
+}
+function getTask(db, id) {
+  const row = db.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  return row ? parseTask(row) : null;
+}
+function listTasks(db, filter) {
+  let sql = "SELECT * FROM tasks WHERE 1=1";
+  let countSql = "SELECT COUNT(*) as c FROM tasks WHERE 1=1";
+  const params = [];
+  const countParams = [];
+  if (filter?.status) {
+    sql += " AND status = ?";
+    countSql += " AND status = ?";
+    params.push(filter.status);
+    countParams.push(filter.status);
+  }
+  if (filter?.priority) {
+    sql += " AND priority = ?";
+    countSql += " AND priority = ?";
+    params.push(filter.priority);
+    countParams.push(filter.priority);
+  }
+  if (filter?.assigned_agent_id) {
+    sql += " AND assigned_agent_id = ?";
+    countSql += " AND assigned_agent_id = ?";
+    params.push(filter.assigned_agent_id);
+    countParams.push(filter.assigned_agent_id);
+  }
+  if (filter?.project_id) {
+    sql += " AND project_id = ?";
+    countSql += " AND project_id = ?";
+    params.push(filter.project_id);
+    countParams.push(filter.project_id);
+  }
+  if (filter?.session_id) {
+    sql += " AND session_id = ?";
+    countSql += " AND session_id = ?";
+    params.push(filter.session_id);
+    countParams.push(filter.session_id);
+  }
+  if (filter?.parent_task_id !== undefined) {
+    if (filter.parent_task_id === null) {
+      sql += " AND parent_task_id IS NULL";
+      countSql += " AND parent_task_id IS NULL";
+    } else {
+      sql += " AND parent_task_id = ?";
+      countSql += " AND parent_task_id = ?";
+      params.push(filter.parent_task_id);
+      countParams.push(filter.parent_task_id);
+    }
+  }
+  if (filter?.tags?.length) {
+    const placeholders = filter.tags.map(() => "?").join(", ");
+    sql += ` AND EXISTS (SELECT 1 FROM json_each(tags) WHERE value IN (${placeholders}))`;
+    countSql += ` AND EXISTS (SELECT 1 FROM json_each(tags) WHERE value IN (${placeholders}))`;
+    params.push(...filter.tags);
+    countParams.push(...filter.tags);
+  }
+  sql += " ORDER BY CASE priority WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 WHEN 'low' THEN 4 END, created_at ASC";
+  if (filter?.limit !== undefined) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter?.offset !== undefined) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = db.query(sql).all(...params);
+  const countRow = db.query(countSql).get(...countParams);
+  return { tasks: rows.map(parseTask), count: countRow.c };
+}
+function updateTask(db, id, input) {
+  const existing = getTask(db, id);
+  if (!existing)
+    return null;
+  const updates = [];
+  const params = [];
+  const ts = now();
+  if (input.subject !== undefined) {
+    updates.push("subject = ?");
+    params.push(input.subject);
+  }
+  if (input.description !== undefined) {
+    updates.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    updates.push("status = ?");
+    params.push(input.status);
+    if (input.status === "in_progress" && !existing.started_at) {
+      updates.push("started_at = ?");
+      params.push(ts);
+    }
+    if (input.status === "completed") {
+      updates.push("completed_at = ?");
+      params.push(ts);
+      updates.push("progress = ?");
+      params.push(1);
+    }
+    if (input.status === "failed") {
+      updates.push("failed_at = ?");
+      params.push(ts);
+    }
+  }
+  if (input.priority !== undefined) {
+    updates.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.tags !== undefined) {
+    updates.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.assigned_agent_id !== undefined) {
+    updates.push("assigned_agent_id = ?");
+    params.push(input.assigned_agent_id);
+  }
+  if (input.metadata !== undefined) {
+    updates.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.progress !== undefined) {
+    updates.push("progress = ?");
+    params.push(input.progress);
+  }
+  if (input.due_at !== undefined) {
+    updates.push("due_at = ?");
+    params.push(input.due_at);
+  }
+  if (input.error !== undefined) {
+    updates.push("error = ?");
+    params.push(input.error);
+  }
+  if (updates.length === 0)
+    return existing;
+  updates.push("updated_at = ?");
+  params.push(ts);
+  params.push(id);
+  db.run(`UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`, ...params);
+  return getTask(db, id);
+}
+function deleteTask(db, id) {
+  const result = db.run("DELETE FROM tasks WHERE id = ?", id);
+  return result.changes > 0;
+}
+function addTaskComment(db, taskId, body, agentId) {
+  const id = uuid();
+  db.run("INSERT INTO task_comments (id, task_id, agent_id, body) VALUES (?, ?, ?, ?)", [id, taskId, agentId ?? null, body]);
+  const row = db.query("SELECT * FROM task_comments WHERE id = ?").get(id);
+  return parseTaskComment(row);
+}
+function parseTaskComment(row) {
+  return {
+    id: row.id,
+    task_id: row.task_id,
+    agent_id: row.agent_id ?? null,
+    body: row.body,
+    created_at: row.created_at
+  };
+}
+function listTaskComments(db, taskId) {
+  const rows = db.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at ASC").all(taskId);
+  return { comments: rows.map(parseTaskComment), count: rows.length };
+}
+function deleteTaskComment(db, id) {
+  const result = db.run("DELETE FROM task_comments WHERE id = ?", id);
+  return result.changes > 0;
+}
+function getTaskStats(db, filter) {
+  let where = "WHERE 1=1";
+  const params = [];
+  if (filter?.project_id) {
+    where += " AND project_id = ?";
+    params.push(filter.project_id);
+  }
+  if (filter?.agent_id) {
+    where += " AND assigned_agent_id = ?";
+    params.push(filter.agent_id);
+  }
+  const total = db.query(`SELECT COUNT(*) as c FROM tasks ${where}`).get(...params).c;
+  const byStatus = {};
+  const statusRows = db.query(`SELECT status, COUNT(*) as c FROM tasks ${where} GROUP BY status`).all(...params);
+  for (const row of statusRows)
+    byStatus[row.status] = row.c;
+  const byPriority = {};
+  const priorityRows = db.query(`SELECT priority, COUNT(*) as c FROM tasks ${where} GROUP BY priority`).all(...params);
+  for (const row of priorityRows)
+    byPriority[row.priority] = row.c;
+  const overdue = db.query(`SELECT COUNT(*) as c FROM tasks ${where} AND status != 'completed' AND status != 'cancelled' AND due_at IS NOT NULL AND due_at < datetime('now')`).get(...params).c;
+  return {
+    total,
+    by_status: {
+      pending: byStatus["pending"] ?? 0,
+      in_progress: byStatus["in_progress"] ?? 0,
+      completed: byStatus["completed"] ?? 0,
+      failed: byStatus["failed"] ?? 0,
+      cancelled: byStatus["cancelled"] ?? 0
+    },
+    by_priority: {
+      critical: byPriority["critical"] ?? 0,
+      high: byPriority["high"] ?? 0,
+      medium: byPriority["medium"] ?? 0,
+      low: byPriority["low"] ?? 0
+    },
+    overdue
+  };
+}
+// src/lib/task-runner.ts
+init_database();
+var _handlers = new Map;
+var _defaultHandler = null;
+function registerTaskHandler(type, handler) {
+  _handlers.set(type, handler);
+}
+function setDefaultTaskHandler(handler) {
+  _defaultHandler = handler;
+}
+function resolveHandler(task) {
+  for (const tag of task.tags) {
+    const h = _handlers.get(tag);
+    if (h)
+      return h;
+  }
+  const metaType = task.metadata?.["type"];
+  if (metaType) {
+    const h = _handlers.get(metaType);
+    if (h)
+      return h;
+  }
+  return _defaultHandler;
+}
+var _workerStarted = false;
+var _processing = false;
+var _totalProcessed = 0;
+var _pollIntervalMs = 60000;
+function startTaskRunner(intervalMs) {
+  if (_workerStarted)
+    return;
+  _workerStarted = true;
+  if (intervalMs)
+    _pollIntervalMs = intervalMs;
+  console.log(`[task-runner] Started, polling every ${_pollIntervalMs / 1000}s`);
+  _tick();
+  setInterval(() => {
+    _tick();
+  }, _pollIntervalMs);
+}
+async function _tick() {
+  if (_processing)
+    return;
+  let task = null;
+  try {
+    const db = getDatabase();
+    const result = listTasks(db, { status: "pending", limit: 1 });
+    if (result.tasks.length === 0)
+      return;
+    task = result.tasks[0] ?? null;
+  } catch (e) {
+    console.error("[task-runner] Failed to list pending tasks:", e);
+    return;
+  }
+  if (!task)
+    return;
+  _processing = true;
+  try {
+    const db = getDatabase();
+    updateTask(db, task.id, { status: "in_progress" });
+    task = getTask(db, task.id);
+  } catch (e) {
+    console.error("[task-runner] Failed to claim task:", e);
+    _processing = false;
+    return;
+  }
+  const handler = resolveHandler(task);
+  if (!handler) {
+    console.warn(`[task-runner] No handler for task: ${task.subject} (tags: ${JSON.stringify(task.tags)}, meta.type: ${task.metadata?.["type"]})`);
+    try {
+      const db = getDatabase();
+      updateTask(db, task.id, {
+        status: "failed",
+        error: "No handler registered for this task type"
+      });
+    } catch {}
+    _processing = false;
+    _totalProcessed++;
+    return;
+  }
+  const taskId = task.id;
+  let progress = 0;
+  const ctx = {
+    task,
+    updateProgress: (p) => {
+      progress = Math.min(1, Math.max(0, p));
+      try {
+        const db = getDatabase();
+        updateTask(db, taskId, { progress });
+      } catch {}
+    },
+    addComment: (body, agentId) => {
+      try {
+        const db = getDatabase();
+        addTaskComment(db, taskId, body, agentId);
+      } catch {}
+    }
+  };
+  try {
+    await handler(ctx);
+    const db = getDatabase();
+    updateTask(db, taskId, { status: "completed", progress: 1 });
+    console.log(`[task-runner] Completed: ${task.subject}`);
+  } catch (e) {
+    const errorMsg = e instanceof Error ? e.message : String(e);
+    try {
+      const db = getDatabase();
+      updateTask(db, taskId, { status: "failed", error: errorMsg });
+    } catch {}
+    console.error(`[task-runner] Failed: ${task.subject} \u2014 ${errorMsg}`);
+  } finally {
+    _processing = false;
+    _totalProcessed++;
+  }
+}
+function getTaskRunnerStats() {
+  try {
+    const db = getDatabase();
+    const rows = db.query("SELECT status, COUNT(*) as c FROM tasks GROUP BY status").all();
+    const stats = {
+      pending: 0,
+      inProgress: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0,
+      totalProcessed: _totalProcessed
+    };
+    for (const row of rows) {
+      switch (row.status) {
+        case "pending":
+          stats.pending = row.c;
+          break;
+        case "in_progress":
+          stats.inProgress = row.c;
+          break;
+        case "completed":
+          stats.completed = row.c;
+          break;
+        case "failed":
+          stats.failed = row.c;
+          break;
+        case "cancelled":
+          stats.cancelled = row.c;
+          break;
+      }
+    }
+    return stats;
+  } catch {
+    return {
+      pending: 0,
+      inProgress: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0,
+      totalProcessed: _totalProcessed
+    };
+  }
+}
 export {
   withMemoryLock,
   uuid,
+  updateTask,
   updateMemory,
   updateEntity,
   updateAgent,
@@ -14173,9 +14607,11 @@ export {
   touchMachine,
   touchAgent,
   syncMemories,
+  startTaskRunner,
   shortUuid,
   setPrimaryMachine,
   setFocus,
+  setDefaultTaskHandler,
   setActiveProfile,
   setActiveModel,
   searchMemories,
@@ -14188,6 +14624,7 @@ export {
   releaseMemoryWriteLock,
   releaseLock,
   releaseAllAgentLocks,
+  registerTaskHandler,
   registerProject,
   registerMachine,
   registerAgent,
@@ -14200,6 +14637,8 @@ export {
   mergeEntities,
   memoryLockId,
   loadConfig,
+  listTasks,
+  listTaskComments,
   listRelations,
   listProjects,
   listProfiles,
@@ -14211,6 +14650,9 @@ export {
   listAgentLocks,
   linkEntityToMemory,
   incrementRecallCount,
+  getTaskStats,
+  getTaskRunnerStats,
+  getTask,
   getRelation,
   getRelatedEntities,
   getProject,
@@ -14243,6 +14685,8 @@ export {
   findPath,
   enforceQuotas,
   deprioritizeStale,
+  deleteTaskComment,
+  deleteTask,
   deleteRelation,
   deleteProfile,
   deleteMemory,
@@ -14250,6 +14694,7 @@ export {
   deleteEntity,
   defaultSyncAgents,
   dedup,
+  createTask,
   createRelation,
   createMemory,
   createEntity,
@@ -14267,6 +14712,7 @@ export {
   archiveUnused,
   archiveStale,
   agentHoldsLock,
+  addTaskComment,
   acquireMemoryWriteLock,
   acquireLock,
   VersionConflictError,