@hasna/todos 0.10.21 → 0.11.1

package/dist/index.js

@@ -754,6 +754,58 @@ var MIGRATIONS = [
   `
   ALTER TABLE tasks ADD COLUMN task_type TEXT;
   CREATE INDEX IF NOT EXISTS idx_tasks_task_type ON tasks(task_type);
+  ALTER TABLE tasks ADD COLUMN cost_tokens INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN cost_usd REAL DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN delegated_from TEXT;
+  ALTER TABLE tasks ADD COLUMN delegation_depth INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN retry_count INTEGER DEFAULT 0;
+  ALTER TABLE tasks ADD COLUMN max_retries INTEGER DEFAULT 3;
+  ALTER TABLE tasks ADD COLUMN retry_after TEXT;
+  ALTER TABLE tasks ADD COLUMN sla_minutes INTEGER;
+
+  CREATE TABLE IF NOT EXISTS task_traces (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    trace_type TEXT NOT NULL CHECK(trace_type IN ('tool_call','llm_call','error','handoff','custom')),
+    name TEXT,
+    input_summary TEXT,
+    output_summary TEXT,
+    duration_ms INTEGER,
+    tokens INTEGER,
+    cost_usd REAL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_traces_task ON task_traces(task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_traces_agent ON task_traces(agent_id);
+
+  CREATE TABLE IF NOT EXISTS context_snapshots (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    snapshot_type TEXT NOT NULL CHECK(snapshot_type IN ('interrupt','complete','handoff','checkpoint')),
+    plan_summary TEXT,
+    files_open TEXT DEFAULT '[]',
+    attempts TEXT DEFAULT '[]',
+    blockers TEXT DEFAULT '[]',
+    next_steps TEXT,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_snapshots_agent ON context_snapshots(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_snapshots_task ON context_snapshots(task_id);
+
+  CREATE TABLE IF NOT EXISTS agent_budgets (
+    agent_id TEXT PRIMARY KEY,
+    max_concurrent INTEGER DEFAULT 5,
+    max_cost_usd REAL,
+    max_task_minutes INTEGER,
+    period_hours INTEGER DEFAULT 24,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
   INSERT OR IGNORE INTO _migrations (id) VALUES (35);
   `
 ];
@@ -936,6 +988,15 @@ function ensureSchema(db) {
   ensureColumn("tasks", "assigned_by", "TEXT");
   ensureColumn("tasks", "assigned_from_project", "TEXT");
   ensureColumn("tasks", "started_at", "TEXT");
+  ensureColumn("tasks", "task_type", "TEXT");
+  ensureColumn("tasks", "cost_tokens", "INTEGER DEFAULT 0");
+  ensureColumn("tasks", "cost_usd", "REAL DEFAULT 0");
+  ensureColumn("tasks", "delegated_from", "TEXT");
+  ensureColumn("tasks", "delegation_depth", "INTEGER DEFAULT 0");
+  ensureColumn("tasks", "retry_count", "INTEGER DEFAULT 0");
+  ensureColumn("tasks", "max_retries", "INTEGER DEFAULT 3");
+  ensureColumn("tasks", "retry_after", "TEXT");
+  ensureColumn("tasks", "sla_minutes", "INTEGER");
   ensureColumn("agents", "role", "TEXT DEFAULT 'agent'");
   ensureColumn("agents", "permissions", `TEXT DEFAULT '["*"]'`);
   ensureColumn("agents", "reports_to", "TEXT");
@@ -2252,6 +2313,20 @@ function completeTask(id, agentId, db, options) {
   if (spawnedFromTemplate) {
     meta._spawned_task = { id: spawnedFromTemplate.id, short_id: spawnedFromTemplate.short_id, title: spawnedFromTemplate.title };
   }
+  const unblockedDeps = d.query(`SELECT DISTINCT t.id, t.short_id, t.title FROM tasks t
+     JOIN task_dependencies td ON td.task_id = t.id
+     WHERE td.depends_on = ? AND t.status = 'pending'
+     AND NOT EXISTS (
+       SELECT 1 FROM task_dependencies td2
+       JOIN tasks dep2 ON dep2.id = td2.depends_on
+       WHERE td2.task_id = t.id AND dep2.status NOT IN ('completed', 'cancelled') AND dep2.id != ?
+     )`).all(id, id);
+  if (unblockedDeps.length > 0) {
+    meta._unblocked = unblockedDeps.map((d2) => ({ id: d2.id, short_id: d2.short_id, title: d2.title }));
+    for (const dep of unblockedDeps) {
+      dispatchWebhook("task.unblocked", { id: dep.id, unblocked_by: id, title: dep.title }, d).catch(() => {});
+    }
+  }
   return { ...task, status: "completed", locked_by: null, locked_at: null, completed_at: timestamp, confidence, version: task.version + 1, updated_at: timestamp, metadata: meta };
 }
 function lockTask(id, agentId, db) {
@@ -2548,24 +2623,36 @@ function failTask(id, agentId, reason, options, db) {
   };
   let retryTask;
   if (options?.retry) {
-    let title = task.title;
-    if (task.short_id && title.startsWith(task.short_id + ": ")) {
-      title = title.slice(task.short_id.length + 2);
+    const retryCount = (task.retry_count || 0) + 1;
+    const maxRetries = task.max_retries || 3;
+    if (retryCount > maxRetries) {
+      d.run("UPDATE tasks SET metadata = ? WHERE id = ?", [
+        JSON.stringify({ ...meta, _retry_exhausted: { retry_count: retryCount - 1, max_retries: maxRetries } }),
+        id
+      ]);
+    } else {
+      const backoffMinutes = Math.pow(5, retryCount - 1);
+      const retryAfter = options.retry_after || new Date(Date.now() + backoffMinutes * 60 * 1000).toISOString();
+      let title = task.title;
+      if (task.short_id && title.startsWith(task.short_id + ": ")) {
+        title = title.slice(task.short_id.length + 2);
+      }
+      retryTask = createTask({
+        title,
+        description: task.description ?? undefined,
+        priority: task.priority,
+        project_id: task.project_id ?? undefined,
+        task_list_id: task.task_list_id ?? undefined,
+        plan_id: task.plan_id ?? undefined,
+        assigned_to: task.assigned_to ?? undefined,
+        tags: task.tags,
+        metadata: { ...task.metadata, _retry: { original_id: task.id, retry_count: retryCount, max_retries: maxRetries, retry_after: retryAfter, failure_reason: reason } },
+        estimated_minutes: task.estimated_minutes ?? undefined,
+        recurrence_rule: task.recurrence_rule ?? undefined,
+        due_at: retryAfter
+      }, d);
+      d.run("UPDATE tasks SET retry_count = ?, max_retries = ?, retry_after = ? WHERE id = ?", [retryCount, maxRetries, retryAfter, retryTask.id]);
     }
-    retryTask = createTask({
-      title,
-      description: task.description ?? undefined,
-      priority: task.priority,
-      project_id: task.project_id ?? undefined,
-      task_list_id: task.task_list_id ?? undefined,
-      plan_id: task.plan_id ?? undefined,
-      assigned_to: task.assigned_to ?? undefined,
-      tags: task.tags,
-      metadata: { ...task.metadata, _retry: { original_id: task.id, retry_after: options.retry_after || null, failure_reason: reason } },
-      estimated_minutes: task.estimated_minutes ?? undefined,
-      recurrence_rule: task.recurrence_rule ?? undefined,
-      due_at: options.retry_after || task.due_at || undefined
-    }, d);
   }
   return { task: failedTask, retryTask };
 }
@@ -2589,6 +2676,40 @@ function getStaleTasks(staleMinutes = 30, filters, db) {
   const rows = d.query(`SELECT * FROM tasks WHERE ${where} ORDER BY updated_at ASC`).all(...params);
   return rows.map(rowToTask);
 }
+function logCost(taskId, tokens, usd, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE tasks SET cost_tokens = cost_tokens + ?, cost_usd = cost_usd + ?, updated_at = ? WHERE id = ?", [tokens, usd, now(), taskId]);
+}
+function stealTask(agentId, opts, db) {
+  const d = db || getDatabase();
+  const staleMinutes = opts?.stale_minutes ?? 30;
+  const staleTasks = getStaleTasks(staleMinutes, { project_id: opts?.project_id, task_list_id: opts?.task_list_id }, d);
+  if (staleTasks.length === 0)
+    return null;
+  const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  staleTasks.sort((a, b) => (priorityOrder[a.priority] ?? 9) - (priorityOrder[b.priority] ?? 9));
+  const target = staleTasks[0];
+  const timestamp = now();
+  d.run(`UPDATE tasks SET assigned_to = ?, locked_by = ?, locked_at = ?, updated_at = ?, version = version + 1 WHERE id = ?`, [agentId, agentId, timestamp, timestamp, target.id]);
+  logTaskChange(target.id, "steal", "assigned_to", target.assigned_to, agentId, agentId, d);
+  dispatchWebhook("task.assigned", { id: target.id, agent_id: agentId, title: target.title, stolen_from: target.assigned_to }, d).catch(() => {});
+  return { ...target, assigned_to: agentId, locked_by: agentId, locked_at: timestamp, updated_at: timestamp, version: target.version + 1 };
+}
+function claimOrSteal(agentId, filters, db) {
+  const d = db || getDatabase();
+  const tx = d.transaction(() => {
+    const next = getNextTask(agentId, filters, d);
+    if (next) {
+      const started = startTask(next.id, agentId, d);
+      return { task: started, stolen: false };
+    }
+    const stolen = stealTask(agentId, { stale_minutes: filters?.stale_minutes, project_id: filters?.project_id, task_list_id: filters?.task_list_id }, d);
+    if (stolen)
+      return { task: stolen, stolen: true };
+    return null;
+  });
+  return tx();
+}
 function getStatus(filters, agentId, options, db) {
   const d = db || getDatabase();
   const pending = countTasks({ ...filters, status: "pending" }, d);
@@ -4998,6 +5119,188 @@ function issueToTask(issue, opts) {
     agent_id: opts?.agent_id
   };
 }
+// src/db/traces.ts
+function logTrace(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO task_traces (id, task_id, agent_id, trace_type, name, input_summary, output_summary, duration_ms, tokens, cost_usd, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.task_id,
+    input.agent_id || null,
+    input.trace_type,
+    input.name || null,
+    input.input_summary || null,
+    input.output_summary || null,
+    input.duration_ms ?? null,
+    input.tokens ?? null,
+    input.cost_usd ?? null,
+    timestamp
+  ]);
+  return {
+    id,
+    task_id: input.task_id,
+    agent_id: input.agent_id || null,
+    trace_type: input.trace_type,
+    name: input.name || null,
+    input_summary: input.input_summary || null,
+    output_summary: input.output_summary || null,
+    duration_ms: input.duration_ms ?? null,
+    tokens: input.tokens ?? null,
+    cost_usd: input.cost_usd ?? null,
+    created_at: timestamp
+  };
+}
+function getTaskTraces(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_traces WHERE task_id = ? ORDER BY created_at DESC").all(taskId);
+}
+function getTraceStats(taskId, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT COUNT(*) as total,
+       SUM(CASE WHEN trace_type = 'tool_call' THEN 1 ELSE 0 END) as tool_calls,
+       SUM(CASE WHEN trace_type = 'llm_call' THEN 1 ELSE 0 END) as llm_calls,
+       SUM(CASE WHEN trace_type = 'error' THEN 1 ELSE 0 END) as errors,
+       COALESCE(SUM(tokens), 0) as total_tokens,
+       COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+       COALESCE(SUM(duration_ms), 0) as total_duration_ms
+     FROM task_traces WHERE task_id = ?`).get(taskId);
+  return row;
+}
+// src/db/snapshots.ts
+function rowToSnapshot(row) {
+  return {
+    ...row,
+    snapshot_type: row.snapshot_type,
+    files_open: JSON.parse(row.files_open || "[]"),
+    attempts: JSON.parse(row.attempts || "[]"),
+    blockers: JSON.parse(row.blockers || "[]"),
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function saveSnapshot(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO context_snapshots (id, agent_id, task_id, project_id, snapshot_type, plan_summary, files_open, attempts, blockers, next_steps, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.agent_id || null,
+    input.task_id || null,
+    input.project_id || null,
+    input.snapshot_type,
+    input.plan_summary || null,
+    JSON.stringify(input.files_open || []),
+    JSON.stringify(input.attempts || []),
+    JSON.stringify(input.blockers || []),
+    input.next_steps || null,
+    JSON.stringify(input.metadata || {}),
+    timestamp
+  ]);
+  return {
+    id,
+    agent_id: input.agent_id || null,
+    task_id: input.task_id || null,
+    project_id: input.project_id || null,
+    snapshot_type: input.snapshot_type,
+    plan_summary: input.plan_summary || null,
+    files_open: input.files_open || [],
+    attempts: input.attempts || [],
+    blockers: input.blockers || [],
+    next_steps: input.next_steps || null,
+    metadata: input.metadata || {},
+    created_at: timestamp
+  };
+}
+function getLatestSnapshot(agentId, taskId, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (agentId) {
+    conditions.push("agent_id = ?");
+    params.push(agentId);
+  }
+  if (taskId) {
+    conditions.push("task_id = ?");
+    params.push(taskId);
+  }
+  if (conditions.length === 0)
+    return null;
+  const where = conditions.join(" AND ");
+  const row = d.query(`SELECT * FROM context_snapshots WHERE ${where} ORDER BY created_at DESC LIMIT 1`).get(...params);
+  return row ? rowToSnapshot(row) : null;
+}
+function listSnapshots(opts, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (opts.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(opts.agent_id);
+  }
+  if (opts.task_id) {
+    conditions.push("task_id = ?");
+    params.push(opts.task_id);
+  }
+  if (opts.project_id) {
+    conditions.push("project_id = ?");
+    params.push(opts.project_id);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = opts.limit || 20;
+  params.push(limit);
+  return d.query(`SELECT * FROM context_snapshots ${where} ORDER BY created_at DESC LIMIT ?`).all(...params).map(rowToSnapshot);
+}
+// src/db/budgets.ts
+function setBudget(agentId, opts, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run(`INSERT INTO agent_budgets (agent_id, max_concurrent, max_cost_usd, max_task_minutes, period_hours, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(agent_id) DO UPDATE SET
+       max_concurrent = COALESCE(?, max_concurrent),
+       max_cost_usd = COALESCE(?, max_cost_usd),
+       max_task_minutes = COALESCE(?, max_task_minutes),
+       period_hours = COALESCE(?, period_hours),
+       updated_at = ?`, [
+    agentId,
+    opts.max_concurrent ?? 5,
+    opts.max_cost_usd ?? null,
+    opts.max_task_minutes ?? null,
+    opts.period_hours ?? 24,
+    timestamp,
+    timestamp,
+    opts.max_concurrent ?? null,
+    opts.max_cost_usd ?? null,
+    opts.max_task_minutes ?? null,
+    opts.period_hours ?? null,
+    timestamp
+  ]);
+  return getBudget(agentId, d);
+}
+function getBudget(agentId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM agent_budgets WHERE agent_id = ?").get(agentId);
+}
+function checkBudget(agentId, db) {
+  const d = db || getDatabase();
+  const budget = getBudget(agentId, d);
+  if (!budget)
+    return { allowed: true, current_concurrent: 0, max_concurrent: 999 };
+  const concurrent = countTasks({ status: "in_progress", assigned_to: agentId }, d);
+  if (concurrent >= budget.max_concurrent) {
+    return { allowed: false, reason: `Concurrent limit reached (${concurrent}/${budget.max_concurrent})`, current_concurrent: concurrent, max_concurrent: budget.max_concurrent };
+  }
+  if (budget.max_cost_usd != null) {
+    const periodStart = new Date(Date.now() - budget.period_hours * 60 * 60 * 1000).toISOString();
+    const costRow = d.query("SELECT COALESCE(SUM(cost_usd), 0) as total FROM tasks WHERE (assigned_to = ? OR agent_id = ?) AND updated_at > ?").get(agentId, agentId, periodStart);
+    if (costRow.total >= budget.max_cost_usd) {
+      return { allowed: false, reason: `Cost limit reached ($${costRow.total.toFixed(2)}/$${budget.max_cost_usd.toFixed(2)} in ${budget.period_hours}h)`, current_concurrent: concurrent, max_concurrent: budget.max_concurrent, current_cost_usd: costRow.total, max_cost_usd: budget.max_cost_usd };
+    }
+  }
+  return { allowed: true, current_concurrent: concurrent, max_concurrent: budget.max_concurrent };
+}
 export {
   uuid,
   updateTaskList,
@@ -5017,12 +5320,15 @@ export {
   syncWithAgents,
   syncWithAgent,
   syncKgEdges,
+  stealTask,
   startTask,
   slugify,
   setTaskStatus,
   setTaskPriority,
+  setBudget,
   searchTasks,
   scoreTask,
+  saveSnapshot,
   resolvePartialId,
   resetDatabase,
   removeTaskRelationshipByPair,
@@ -5044,8 +5350,10 @@ export {
   nextOccurrence,
   moveTask,
   matchCapabilities,
+  logTrace,
   logTaskChange,
   logProgress,
+  logCost,
   lockTask,
   loadConfig,
   listWebhooks,
@@ -5053,6 +5361,7 @@ export {
   listTasks,
   listTaskLists,
   listTaskFiles,
+  listSnapshots,
   listSessions,
   listProjects,
   listProjectSources,
@@ -5065,9 +5374,11 @@ export {
   isValidRecurrenceRule,
   isAgentConflict,
   getWebhook,
+  getTraceStats,
   getTemplate,
   getTasksChangedSince,
   getTaskWithRelations,
+  getTaskTraces,
   getTaskStats,
   getTaskRelationships,
   getTaskRelationship,
@@ -5096,6 +5407,7 @@ export {
   getOrg,
   getNextTask,
   getLeaderboard,
+  getLatestSnapshot,
   getLatestHandoff,
   getImpactAnalysis,
   getDirectReports,
@@ -5107,6 +5419,7 @@ export {
   getChecklist,
   getCapableAgents,
   getBurndown,
+  getBudget,
   getBlockingDeps,
   getAgentMetrics,
   getAgentByName,
@@ -5150,10 +5463,12 @@ export {
   cloneTask,
   clearChecklist,
   cleanExpiredLocks,
+  claimOrSteal,
   claimNextTask,
   checkLock,
   checkCompletionGuard,
   checkChecklistItem,
+  checkBudget,
   bulkUpdateTasks,
   bulkCreateTasks,
   bulkAddTaskFiles,

package/dist/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AA6IA,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAO9E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AA+IA,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAO9E"}