@hasna/todos 0.10.13 → 0.10.15

package/dist/cli/index.js

@@ -9817,6 +9817,161 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// src/lib/auto-assign.ts
+var exports_auto_assign = {};
+__export(exports_auto_assign, {
+  findBestAgent: () => findBestAgent,
+  autoAssignTask: () => autoAssignTask
+});
+function findBestAgent(_task, db) {
+  const d = db || getDatabase();
+  const agents = listAgents(d).filter((a) => (a.role || "agent") === "agent");
+  if (agents.length === 0)
+    return null;
+  const inProgressTasks = listTasks({ status: "in_progress" }, d);
+  const load = new Map;
+  for (const a of agents)
+    load.set(a.name, 0);
+  for (const t of inProgressTasks) {
+    const name = t.assigned_to || t.agent_id;
+    if (name && load.has(name)) {
+      load.set(name, (load.get(name) || 0) + 1);
+    }
+  }
+  let bestAgent = agents[0].name;
+  let bestLoad = load.get(bestAgent) ?? 0;
+  for (const a of agents) {
+    const l = load.get(a.name) ?? 0;
+    if (l < bestLoad) {
+      bestAgent = a.name;
+      bestLoad = l;
+    }
+  }
+  return bestAgent;
+}
+function getAgentWorkloads(d) {
+  const rows = d.query("SELECT assigned_to, COUNT(*) as count FROM tasks WHERE status = 'in_progress' AND assigned_to IS NOT NULL GROUP BY assigned_to").all();
+  return new Map(rows.map((r) => [r.assigned_to, r.count]));
+}
+function buildPrompt(task, agents) {
+  const agentList = agents.map((a) => `- ${a.name} (role: ${a.role}, caps: [${a.capabilities.join(", ")}], active_tasks: ${a.in_progress_tasks})`).join(`
+`);
+  return `You are a task routing assistant. Given a task and available agents, choose the SINGLE best agent.
+
+TASK:
+Title: ${task.title}
+Priority: ${task.priority}
+Tags: ${task.tags.join(", ") || "none"}
+Description: ${task.description?.slice(0, 300) || "none"}
+
+AVAILABLE AGENTS:
+${agentList}
+
+Rules:
+- Match task tags/content to agent capabilities
+- Prefer agents with fewer active tasks
+- Prefer agents whose role fits the task (lead for critical, developer for features, qa for testing)
+- If no clear match, pick the agent with fewest active tasks
+
+Respond with ONLY a JSON object: {"agent_name": "<name>", "reason": "<one sentence>"}`;
+}
+async function callCerebras(prompt, apiKey) {
+  try {
+    const resp = await fetch(CEREBRAS_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        model: CEREBRAS_MODEL,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: 150,
+        temperature: 0
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok)
+      return null;
+    const data = await resp.json();
+    const content = data?.choices?.[0]?.message?.content?.trim();
+    if (!content)
+      return null;
+    const match = content.match(/\{[^}]+\}/s);
+    if (!match)
+      return null;
+    return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+}
+async function autoAssignTask(taskId, db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new Error(`Task ${taskId} not found`);
+  const agents = listAgents(d).filter((a) => a.status === "active");
+  if (agents.length === 0) {
+    return { task_id: taskId, assigned_to: null, agent_name: null, method: "no_agents" };
+  }
+  const workloads = getAgentWorkloads(d);
+  const apiKey = process.env["CEREBRAS_API_KEY"];
+  let selectedAgent = null;
+  let method = "capability_match";
+  let reason;
+  if (apiKey) {
+    const agentData = agents.map((a) => ({
+      id: a.id,
+      name: a.name,
+      role: a.role || "agent",
+      capabilities: a.capabilities || [],
+      in_progress_tasks: workloads.get(a.id) ?? 0
+    }));
+    const result = await callCerebras(buildPrompt({
+      title: task.title,
+      description: task.description,
+      priority: task.priority,
+      tags: task.tags || []
+    }, agentData), apiKey);
+    if (result?.agent_name) {
+      selectedAgent = agents.find((a) => a.name === result.agent_name) ?? null;
+      if (selectedAgent) {
+        method = "cerebras";
+        reason = result.reason;
+      }
+    }
+  }
+  if (!selectedAgent) {
+    const taskTags = task.tags || [];
+    const capable = getCapableAgents(taskTags, { min_score: 0, limit: 10 }, d);
+    if (capable.length > 0) {
+      const sorted = capable.sort((a, b) => {
+        if (b.score !== a.score)
+          return b.score - a.score;
+        return (workloads.get(a.agent.id) ?? 0) - (workloads.get(b.agent.id) ?? 0);
+      });
+      selectedAgent = sorted[0].agent;
+      reason = `Capability match (score: ${sorted[0].score.toFixed(2)})`;
+    } else {
+      selectedAgent = agents.slice().sort((a, b) => (workloads.get(a.id) ?? 0) - (workloads.get(b.id) ?? 0))[0];
+      reason = `Least busy agent (${workloads.get(selectedAgent.id) ?? 0} active tasks)`;
+    }
+  }
+  if (selectedAgent) {
+    updateTask(taskId, { assigned_to: selectedAgent.id, version: task.version }, d);
+  }
+  return {
+    task_id: taskId,
+    assigned_to: selectedAgent?.id ?? null,
+    agent_name: selectedAgent?.name ?? null,
+    method,
+    reason
+  };
+}
+var CEREBRAS_API_URL = "https://api.cerebras.ai/v1/chat/completions", CEREBRAS_MODEL = "llama-3.3-70b";
+var init_auto_assign = __esm(() => {
+  init_database();
+  init_tasks();
+  init_agents();
+});
+
 // src/db/task-files.ts
 var exports_task_files = {};
 __export(exports_task_files, {
@@ -13083,6 +13238,108 @@ Claimed: ${formatTask(result.claimed)}`);
       }
     });
   }
+  if (shouldRegisterTool("create_failure_task")) {
+    server.tool("create_failure_task", "Create a task from a test/build/typecheck failure. Auto-assigns to the most likely agent based on file ownership and org chart.", {
+      failure_type: exports_external.enum(["test", "build", "typecheck", "runtime", "other"]).describe("Type of failure"),
+      title: exports_external.string().optional().describe("Task title (auto-generated from error if omitted)"),
+      error_message: exports_external.string().describe("The error message or summary"),
+      file_path: exports_external.string().optional().describe("File where the failure occurred"),
+      stack_trace: exports_external.string().optional().describe("Stack trace or detailed output (truncated to 2000 chars)"),
+      project_id: exports_external.string().optional().describe("Project to associate the task with"),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional().describe("Default: high for build/typecheck, medium for test")
+    }, async ({ failure_type, title, error_message, file_path, stack_trace, project_id, priority }) => {
+      try {
+        const { createTask: createTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { autoAssignTask: autoAssignTask2 } = await Promise.resolve().then(() => (init_auto_assign(), exports_auto_assign));
+        const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
+        const defaultPriority = failure_type === "build" || failure_type === "typecheck" ? "high" : "medium";
+        const taskPriority = priority ?? defaultPriority;
+        const autoTitle = title || `${failure_type.toUpperCase()} failure${file_path ? ` in ${file_path.split("/").pop()}` : ""}: ${error_message.slice(0, 60)}`;
+        const description = [
+          `**Failure type:** ${failure_type}`,
+          file_path ? `**File:** ${file_path}` : null,
+          `**Error:**
+\`\`\`
+${error_message.slice(0, 500)}
+\`\`\``,
+          stack_trace ? `**Stack trace:**
+\`\`\`
+${stack_trace.slice(0, 1500)}
+\`\`\`` : null
+        ].filter(Boolean).join(`
+
+`);
+        const task = createTask2({
+          title: autoTitle,
+          description,
+          priority: taskPriority,
+          project_id: resolvedProjectId,
+          tags: ["failure", failure_type, "auto-created"],
+          status: "pending"
+        });
+        const assignResult = await autoAssignTask2(task.id);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ task_id: task.id, short_id: task.short_id, title: task.title, assigned_to: assignResult.agent_name, assign_method: assignResult.method }, null, 2)
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("auto_assign_task")) {
+    server.tool("auto_assign_task", "Auto-assign a task to the best available agent. Uses Cerebras LLM (llama-3.3-70b) if CEREBRAS_API_KEY is set, otherwise falls back to capability-based matching.", {
+      task_id: exports_external.string().describe("Task to auto-assign")
+    }, async ({ task_id }) => {
+      try {
+        const { autoAssignTask: autoAssignTask2 } = await Promise.resolve().then(() => (init_auto_assign(), exports_auto_assign));
+        const resolvedId = resolveId(task_id);
+        const result = await autoAssignTask2(resolvedId);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("auto_assign_unassigned")) {
+    server.tool("auto_assign_unassigned", "Auto-assign all unassigned pending tasks in a project using Cerebras LLM routing. Returns summary of assignments made.", {
+      project_id: exports_external.string().optional().describe("Filter to a specific project"),
+      limit: exports_external.number().optional().describe("Max tasks to assign (default: 20)")
+    }, async ({ project_id, limit }) => {
+      try {
+        const { autoAssignTask: autoAssignTask2 } = await Promise.resolve().then(() => (init_auto_assign(), exports_auto_assign));
+        const { listTasks: listTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
+        const tasks = listTasks2({
+          status: "pending",
+          project_id: resolvedProjectId
+        }).tasks.filter((t) => !t.assigned_to).slice(0, limit ?? 20);
+        const results = [];
+        for (const task of tasks) {
+          try {
+            const r = await autoAssignTask2(task.id);
+            results.push(r);
+          } catch {}
+        }
+        const assigned = results.filter((r) => r.assigned_to);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              total_checked: tasks.length,
+              assigned: assigned.length,
+              skipped: tasks.length - assigned.length,
+              results
+            }, null, 2)
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
   if (shouldRegisterTool("search_tools")) {
     server.tool("search_tools", "List all tool names, optionally filtered by substring.", { query: exports_external.string().optional() }, async ({ query }) => {
       const all = [
@@ -18727,6 +18984,49 @@ program2.command("context").description("Session start context: status, latest h
   console.log(chalk.dim(`
   as_of: ${new Date().toISOString()}`));
 });
+program2.command("report-failure").description("Create a task from a test/build/typecheck failure and auto-assign it").requiredOption("--error <message>", "Error message or summary").option("--type <type>", "Failure type: test, build, typecheck, runtime, other", "test").option("--file <path>", "File where failure occurred").option("--stack <trace>", "Stack trace or detailed output").option("--title <title>", "Custom task title (auto-generated if omitted)").option("--priority <p>", "Priority: low, medium, high, critical").option("--json", "Output as JSON").action(async (opts) => {
+  const globalOpts = program2.opts();
+  const { createTask: createTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+  const { autoAssignTask: autoAssignTask2 } = await Promise.resolve().then(() => (init_auto_assign(), exports_auto_assign));
+  const projectId = autoProject(globalOpts);
+  const failureType = opts.type || "test";
+  const defaultPriority = failureType === "build" || failureType === "typecheck" ? "high" : "medium";
+  const taskPriority = opts.priority || defaultPriority;
+  const autoTitle = opts.title || `${failureType.toUpperCase()} failure${opts.file ? ` in ${opts.file.split("/").pop()}` : ""}: ${opts.error.slice(0, 60)}`;
+  const descParts = [
+    `**Failure type:** ${failureType}`,
+    opts.file ? `**File:** ${opts.file}` : null,
+    `**Error:**
+\`\`\`
+${opts.error.slice(0, 500)}
+\`\`\``,
+    opts.stack ? `**Stack trace:**
+\`\`\`
+${opts.stack.slice(0, 1500)}
+\`\`\`` : null
+  ].filter(Boolean).join(`
+
+`);
+  const task = createTask2({
+    title: autoTitle,
+    description: descParts,
+    priority: taskPriority,
+    project_id: projectId || undefined,
+    tags: ["failure", failureType, "auto-created"],
+    status: "pending"
+  });
+  const assignResult = await autoAssignTask2(task.id);
+  if (opts.json || globalOpts.json) {
+    console.log(JSON.stringify({ task_id: task.id, short_id: task.short_id, title: task.title, assigned_to: assignResult.agent_name, method: assignResult.method }));
+    return;
+  }
+  console.log(chalk.green(`\u2713 Created task ${task.short_id || task.id.slice(0, 8)}: ${task.title}`));
+  if (assignResult.agent_name) {
+    console.log(chalk.cyan(`  Assigned to: ${assignResult.agent_name} (via ${assignResult.method})`));
+    if (assignResult.reason)
+      console.log(chalk.dim(`  Reason: ${assignResult.reason}`));
+  }
+});
 program2.action(async () => {
   if (process.stdout.isTTY) {
     try {

package/dist/lib/auto-assign.d.ts

@@ -1,9 +1,25 @@
+/**
+ * Auto-assign tasks to agents using Cerebras LLM for intelligent routing.
+ * Falls back to capability-based matching when the API key is unavailable or the call fails.
+ */
 import type { Database } from "bun:sqlite";
 import type { Task } from "../types/index.js";
+export interface AutoAssignResult {
+    task_id: string;
+    assigned_to: string | null;
+    agent_name: string | null;
+    method: "cerebras" | "capability_match" | "no_agents";
+    reason?: string;
+}
 /**
- * Find the best agent to assign a task to.
+ * Find the best agent to assign a task to (legacy simple version, no I/O).
  * Strategy: least-loaded agent with role "agent" (not admin/observer).
- * Returns agent name or null if no agents available.
  */
 export declare function findBestAgent(_task: Task, db?: Database): string | null;
+/**
+ * Auto-assign a task to the best available agent.
+ * Uses Cerebras LLM (llama-3.3-70b) if CEREBRAS_API_KEY is set,
+ * otherwise falls back to capability-based matching.
+ */
+export declare function autoAssignTask(taskId: string, db?: Database): Promise<AutoAssignResult>;
 //# sourceMappingURL=auto-assign.d.ts.map

package/dist/lib/auto-assign.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-assign.d.ts","sourceRoot":"","sources":["../../src/lib/auto-assign.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CA6BvE"}
+{"version":3,"file":"auto-assign.d.ts","sourceRoot":"","sources":["../../src/lib/auto-assign.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAK9C,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,UAAU,GAAG,kBAAkB,GAAG,WAAW,CAAC;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAsBvE;AA8DD;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA8D7F"}