@hasna/todos 0.11.82 → 0.11.84

package/dist/storage.js

@@ -11907,7 +11907,19 @@ function createPostgresTodosStorageAdapter(options) {
       claimNext: (agentId, filters) => claimNextTask2(agentId, filters, store),
       getNext: (_agentId, filters) => getNextTask2(filters, store),
       getActiveWork: (filters) => getActiveWork2(filters, store),
-      getChangedSince: (since, filters) => getChangedSince(since, filters, store)
+      getChangedSince: (since, filters) => getChangedSince(since, filters, store),
+      lock: (id, agentId) => lockTask2(id, agentId, store),
+      unlock: (id, agentId) => unlockTask2(id, agentId, store)
+    },
+    dependencies: {
+      add: (taskId, dependsOn, context) => addDependency2(taskId, dependsOn, store, context),
+      remove: (taskId, dependsOn) => removeDependency2(taskId, dependsOn, store),
+      list: (taskId) => listDependencies(taskId, store),
+      listAll: () => store.list("dependencies")
+    },
+    verifications: {
+      add: (input, context) => addVerification(input, store, context),
+      list: (taskId) => listVerifications(taskId, store)
     },
     projects: {
       create: (input, context) => createProject2(input, store, context),
@@ -12362,6 +12374,104 @@ async function patchTask(task, patch, store) {
   await store.upsert("tasks", updated);
   return updated;
 }
+var CLOUD_LOCK_EXPIRY_MINUTES = 30;
+function cloudLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  return new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000 < Date.now();
+}
+function cloudLockExpiresAt(lockedAt) {
+  return new Date(new Date(lockedAt).getTime() + CLOUD_LOCK_EXPIRY_MINUTES * 60 * 1000).toISOString();
+}
+async function lockTask2(id, agentId, store) {
+  const task = await requireRecord("tasks", id, store);
+  if (task.status === "completed" || task.status === "cancelled") {
+    return { success: false, error: `Task is ${task.status} and cannot be locked` };
+  }
+  if (task.locked_by && task.locked_by !== agentId && !cloudLockExpired(task.locked_at)) {
+    return { success: false, locked_by: task.locked_by, locked_at: task.locked_at ?? undefined, error: `Task is locked by ${task.locked_by}` };
+  }
+  const timestamp = new Date().toISOString();
+  await patchTask(task, { locked_by: agentId, locked_at: timestamp }, store);
+  return { success: true, locked_by: agentId, locked_at: timestamp, expires_at: cloudLockExpiresAt(timestamp) };
+}
+async function unlockTask2(id, agentId, store) {
+  const task = await requireRecord("tasks", id, store);
+  if (agentId && task.locked_by && task.locked_by !== agentId) {
+    throw new Error(`Task ${id} is locked by ${task.locked_by}, not ${agentId}`);
+  }
+  await patchTask(task, { locked_by: null, locked_at: null }, store);
+  return true;
+}
+function dependencyId(taskId, dependsOn) {
+  return `${taskId}::${dependsOn}`;
+}
+async function addDependency2(taskId, dependsOn, store, context) {
+  if (taskId === dependsOn)
+    throw new Error("A task cannot depend on itself");
+  if (!await store.get("tasks", taskId))
+    throw new Error(`Task not found: ${taskId}`);
+  if (!await store.get("tasks", dependsOn))
+    throw new Error(`Task not found: ${dependsOn}`);
+  const edges = await store.list("dependencies");
+  const adjacency = new Map;
+  for (const edge of edges) {
+    if (!adjacency.has(edge.task_id))
+      adjacency.set(edge.task_id, []);
+    adjacency.get(edge.task_id).push(edge.depends_on);
+  }
+  const queue = [dependsOn];
+  const seen = new Set;
+  while (queue.length) {
+    const node = queue.shift();
+    if (node === taskId)
+      throw new Error(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+    if (seen.has(node))
+      continue;
+    seen.add(node);
+    for (const next of adjacency.get(node) ?? [])
+      queue.push(next);
+  }
+  const timestamp = new Date().toISOString();
+  const record = { id: dependencyId(taskId, dependsOn), task_id: taskId, depends_on: dependsOn, created_at: timestamp, updated_at: timestamp };
+  await store.upsert("dependencies", record, context);
+  return { task_id: taskId, depends_on: dependsOn };
+}
+async function removeDependency2(taskId, dependsOn, store) {
+  const existing = await store.get("dependencies", dependencyId(taskId, dependsOn));
+  if (!existing)
+    return false;
+  await store.delete("dependencies", dependencyId(taskId, dependsOn));
+  return true;
+}
+async function listDependencies(taskId, store) {
+  const edges = await store.list("dependencies");
+  return {
+    dependencies: edges.filter((edge) => edge.task_id === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on })),
+    blocked_by: edges.filter((edge) => edge.depends_on === taskId).map((edge) => ({ task_id: edge.task_id, depends_on: edge.depends_on }))
+  };
+}
+async function addVerification(input, store, context) {
+  if (!await store.get("tasks", input.task_id))
+    throw new Error(`Task not found: ${input.task_id}`);
+  const timestamp = new Date().toISOString();
+  const verification = {
+    id: randomUUID3(),
+    task_id: input.task_id,
+    command: input.command,
+    status: input.status ?? "unknown",
+    output_summary: input.output_summary ?? null,
+    artifact_path: input.artifact_path ?? null,
+    agent_id: input.agent_id ?? context?.agentId ?? null,
+    run_at: timestamp,
+    created_at: timestamp
+  };
+  await store.upsert("verifications", { ...verification, updated_at: timestamp }, context);
+  return verification;
+}
+async function listVerifications(taskId, store) {
+  return (await store.list("verifications")).filter((verification) => verification.task_id === taskId).sort((a, b) => b.run_at.localeCompare(a.run_at));
+}
 var TASK_ORDER_BY = "ORDER BY CASE payload->>'priority' WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END ASC, payload->>'created_at' ASC, payload->>'id' ASC";
 function toFilterArray(value) {
   return Array.isArray(value) ? value : [value];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/todos",
-  "version": "0.11.82",
+  "version": "0.11.84",
   "description": "Universal task management for AI coding agents - CLI + MCP server + interactive TUI",
   "type": "module",
   "main": "dist/index.js",