@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-7EY5DCRO.js

@@ -0,0 +1,434 @@
+import {
+  kanbanTool
+} from "./chunk-JNNVRHMV.js";
+import {
+  applyManagedKanbanBoardToTodos,
+  blockingTitles,
+  mirrorSessionTodosToKanban,
+  takeSessionMirrorFailure
+} from "./chunk-PY2IOS7C.js";
+
+// src/todo.ts
+import {
+  loadPlan,
+  loadTasks,
+  savePlan,
+  saveTasks,
+  setPlanItemStatus
+} from "@wrongstack/core/storage";
+import { addTask, getBoard } from "@wrongstack/kanban";
+function normalizedTitle(value) {
+  return value.trim().toLocaleLowerCase().replace(/\s+/g, " ");
+}
+function activeBoardId(items, ctx) {
+  const metaKanban = ctx.meta?.["kanban"];
+  const metaBoardId = metaKanban && typeof metaKanban === "object" ? metaKanban["boardId"] : void 0;
+  return ctx.currentKanbanBoardId ?? (typeof metaBoardId === "string" ? metaBoardId : void 0) ?? items.find((item) => item.kanbanBoardId)?.kanbanBoardId ?? "";
+}
+function bindTodosToBoard(items, previous, board) {
+  const previousById = new Map(previous.map((item) => [item.id, item]));
+  const available = board.tasks.filter(
+    (task) => task.status !== "archived" && task.mergedIntoTaskId === void 0 && (!task.childTaskIds || task.childTaskIds.length === 0)
+  ).sort(
+    (left, right) => left.createdAt.localeCompare(right.createdAt) || left.order - right.order
+  );
+  const used = /* @__PURE__ */ new Set();
+  return items.map((item) => {
+    const previousItem = previousById.get(item.id);
+    const requestedTaskId = item.kanbanBoardId === board.id ? item.kanbanTaskId : previousItem?.kanbanBoardId === board.id ? previousItem.kanbanTaskId : void 0;
+    const title = normalizedTitle(item.content);
+    const candidates = [
+      requestedTaskId ? board.tasks.find((task2) => task2.id === requestedTaskId) : void 0,
+      board.tasks.find((task2) => task2.id === item.id),
+      board.tasks.find((task2) => task2.origin?.taskId === item.id),
+      available.find((task2) => !used.has(task2.id) && normalizedTitle(task2.title) === title)
+    ];
+    const task = candidates.find((candidate) => candidate && !used.has(candidate.id));
+    if (!task) {
+      const { blockedBy: _discarded, ...rest } = item;
+      return { ...rest };
+    }
+    used.add(task.id);
+    const blockedBy = blockingTitles(board, task);
+    return {
+      ...item,
+      kanbanBoardId: board.id,
+      kanbanTaskId: task.id,
+      ...blockedBy.length ? { blockedBy } : { blockedBy: void 0 }
+    };
+  });
+}
+function demoteBlockedInProgress(items, warnings) {
+  return items.map((item) => {
+    if (item.status !== "in_progress" || !item.blockedBy?.length) return item;
+    warnings.push(
+      `"${item.content}" cannot start yet \u2014 it waits on: ${item.blockedBy.join("; ")}. Kept as pending; complete the blocking work first.`
+    );
+    return { ...item, status: "pending" };
+  });
+}
+async function createMissingManagedCards(items, board, ctx, warnings) {
+  const created = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kanbanBoardId === board.id && item.kanbanTaskId) continue;
+    try {
+      const result = await addTask(
+        ctx.projectRoot,
+        board.id,
+        {
+          title: item.content,
+          description: item.activeForm?.trim() || `Added from the session todo list: ${item.content}`
+        },
+        // The card mirrors this session's todo row, so the session owns it.
+        { sessionId: ctx.eventSessionId(), actor: "todo" }
+      );
+      if (!result) {
+        warnings.push(`Could not open a Kanban card for "${item.content}": board not found.`);
+        continue;
+      }
+      created.set(item.id, result.task.id);
+    } catch (error) {
+      warnings.push(
+        `Could not open a Kanban card for "${item.content}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return created;
+}
+async function synchronizeManagedKanban(items, board, ctx, signal) {
+  let synced = 0;
+  const warnings = [];
+  const actor = ctx.agentId?.trim() || ctx.agentName?.trim() || "kanban-agent";
+  const execute = async (input) => {
+    const result = await kanbanTool.execute(input, ctx, { signal });
+    if (!result.ok) warnings.push(result.message);
+    else {
+      synced++;
+      if (result.message.includes("Warning:")) warnings.push(result.message);
+    }
+    return result;
+  };
+  for (const item of items) {
+    if (item.status !== "pending" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (task?.lifecycle?.currentStage !== "running") continue;
+    const released = await execute({
+      action: "mark_assignment",
+      boardId: board.id,
+      taskId: task.id,
+      assignmentStatus: "assigned",
+      agentId: actor,
+      lastResult: `Todo returned to queue: ${item.content}`
+    });
+    if (!released.ok) continue;
+    await execute({
+      action: "transition_task",
+      boardId: board.id,
+      taskId: task.id,
+      lifecycleStage: "todo",
+      author: actor,
+      transitionComment: `Todo returned to queue: ${item.content}`
+    });
+  }
+  for (const item of items) {
+    if (item.status === "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (task?.status !== "completed") continue;
+    warnings.push(
+      `"${item.content}" is already Done on the Kanban board and a completed card cannot be reopened; the row stays completed. Create a follow-up card for any remaining work.`
+    );
+  }
+  for (const item of items) {
+    if (item.status !== "completed" || item.kanbanBoardId !== board.id || !item.kanbanTaskId) {
+      continue;
+    }
+    const task = board.tasks.find((candidate) => candidate.id === item.kanbanTaskId);
+    if (!task || task.status === "completed") continue;
+    const stage = task.lifecycle?.currentStage;
+    if (stage === "backlog" || stage === "todo") {
+      const started = await execute({
+        action: "start_task",
+        boardId: board.id,
+        taskId: task.id,
+        author: actor,
+        agentId: actor,
+        transitionComment: `Auto-started for completion: ${item.content}`
+      });
+      if (!started.ok) {
+        continue;
+      }
+    }
+    await execute({
+      action: "mark_assignment",
+      boardId: board.id,
+      taskId: task.id,
+      assignmentStatus: "completed",
+      agentId: actor,
+      lastResult: `Todo completed: ${item.content}`
+    });
+  }
+  const attemptedParents = /* @__PURE__ */ new Set();
+  let afterCompletions = await getBoard(ctx.projectRoot, board.id);
+  while (afterCompletions) {
+    const parent = afterCompletions.tasks.find(
+      (task) => task.atomic === true && task.status !== "completed" && Boolean(task.childTaskIds?.length) && !attemptedParents.has(task.id) && task.childTaskIds?.every(
+        (childId) => afterCompletions?.tasks.find((candidate) => candidate.id === childId)?.status === "completed"
+      )
+    );
+    if (!parent) break;
+    attemptedParents.add(parent.id);
+    const started = await execute({
+      action: "start_task",
+      boardId: board.id,
+      taskId: parent.id,
+      author: actor,
+      agentId: actor,
+      transitionComment: "All child tasks completed; validating composite parent."
+    });
+    if (started.ok) {
+      await execute({
+        action: "mark_assignment",
+        boardId: board.id,
+        taskId: parent.id,
+        assignmentStatus: "completed",
+        agentId: actor,
+        lastResult: "All child tasks completed; composite result ready for verification."
+      });
+    }
+    afterCompletions = await getBoard(ctx.projectRoot, board.id);
+  }
+  const completionPending = items.some(
+    (item) => item.status === "completed" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId) && afterCompletions?.tasks.find((task) => task.id === item.kanbanTaskId)?.status !== "completed"
+  );
+  const active = items.find(
+    (item) => item.status === "in_progress" && item.kanbanBoardId === board.id && Boolean(item.kanbanTaskId)
+  );
+  const activeStage = active?.kanbanTaskId ? afterCompletions?.tasks.find((task) => task.id === active.kanbanTaskId)?.lifecycle?.currentStage : void 0;
+  if (active?.kanbanTaskId) {
+    if (activeStage === "review" || activeStage === "done") {
+      warnings.push(
+        `"${active.content}" is in ${activeStage === "review" ? "Review" : "Done"} awaiting acceptance; not re-activating it from the todo list. ` + (activeStage === "review" ? "Call kanban start_task explicitly to reopen it as a repair." : "Done is terminal; reopen only by creating a follow-up card.")
+      );
+    } else {
+      await execute({
+        action: "start_task",
+        boardId: board.id,
+        taskId: active.kanbanTaskId,
+        author: actor,
+        agentId: actor,
+        transitionComment: `Todo activated: ${active.content}`
+      });
+    }
+  }
+  if (active?.kanbanTaskId && activeStage === "review") {
+  } else if (active?.kanbanTaskId && completionPending) {
+    warnings.push(
+      "A completed todo is still awaiting acceptance; the next independent Kanban task was started."
+    );
+  } else if (!active && ctx.currentKanbanBoardId === board.id) {
+    ctx.setCurrentKanbanTask(void 0, board.id);
+  }
+  return { synced, warnings };
+}
+var todoTool = {
+  name: "todo",
+  category: "Session",
+  description: "Manage the compact active-work list. With a managed Kanban binding, every row resolves to a real card and status changes advance that card; without Kanban it remains session-only state. Each call replaces ordering and supplied fields, but unfinished omitted rows are retained until completed.",
+  usageHint: "BEST PRACTICE for complex tasks:\n- At the beginning of a non-trivial task, create a clear todo list with specific, actionable items.\n- Only **one** item should be `in_progress` at any time.\n- Update the list frequently as work progresses (mark items done, add new ones, change status).\n- **Re-order items** to reflect current priorities. Omission is not cancellation: unfinished rows are retained until completed.\n- When all items are completed the board auto-clears \u2014 you do NOT need to send an empty list.\n- The system and user can see this list, so keep it honest and up-to-date.\nThis tool is extremely valuable for maintaining focus and giving the user visibility into your plan.",
+  permission: "confirm",
+  mutating: true,
+  timeoutMs: 3e4,
+  capabilities: ["session.todo", "fs.write"],
+  subjectKey: "todos",
+  icon: "todo",
+  inputSchema: {
+    type: "object",
+    properties: {
+      todos: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: 'Unique identifier for the todo item (e.g. "1", "auth-flow").'
+            },
+            content: {
+              type: "string",
+              description: "Clear, actionable description of the task."
+            },
+            status: {
+              type: "string",
+              enum: ["pending", "in_progress", "completed"],
+              description: 'Current status. Only one item should be "in_progress" at a time.'
+            },
+            activeForm: {
+              type: "string",
+              description: 'Optional present-tense form shown while the task is active (e.g. "Fixing auth bug").'
+            },
+            kanbanBoardId: {
+              type: "string",
+              description: "Kanban board that owns this UI row when Kanban is active."
+            },
+            kanbanTaskId: {
+              type: "string",
+              description: "Real Kanban task represented by this UI row."
+            }
+          },
+          required: ["id", "content", "status"]
+        },
+        description: "The desired todo list. Supplied rows are replaced/reordered; unfinished omitted rows are retained."
+      }
+    },
+    required: ["todos"]
+  },
+  async execute(input, ctx, call) {
+    if (!Array.isArray(input?.todos)) {
+      throw new Error("todo: todos must be an array");
+    }
+    const items = input.todos.filter((t) => Boolean(t?.id && t.content));
+    const todoIdentity = (item) => item.kanbanBoardId && item.kanbanTaskId ? `kanban:${item.kanbanBoardId}:${item.kanbanTaskId}` : item.promotedFromTask ? `task:${item.promotedFromTask}` : item.promotedFromPlan ? `plan:${item.promotedFromPlan}` : `todo:${item.id}`;
+    const requestedIdentities = new Set(items.map(todoIdentity));
+    for (const previous of ctx.todos ?? []) {
+      const identity = todoIdentity(previous);
+      if (previous.status === "completed" || requestedIdentities.has(identity)) {
+        continue;
+      }
+      items.push({ ...previous });
+      requestedIdentities.add(identity);
+    }
+    const inProgress = items.filter((t) => t.status === "in_progress");
+    if (inProgress.length > 1) {
+      let seenInProgress = false;
+      for (const item of items) {
+        if (item.status === "in_progress") {
+          if (seenInProgress) item.status = "pending";
+          seenInProgress = true;
+        }
+      }
+    }
+    const boardId = activeBoardId(items, ctx);
+    let board = boardId ? await getBoard(ctx.projectRoot, boardId) : null;
+    const managed = board?.lifecycle?.mode === "managed";
+    let boundItems = managed && board ? bindTodosToBoard(items, ctx.todos ?? [], board) : items;
+    const creationWarnings = [];
+    if (managed && board) {
+      const managedBoardId = board.id;
+      const created = await createMissingManagedCards(boundItems, board, ctx, creationWarnings);
+      if (created.size > 0) {
+        boundItems = boundItems.map((item) => {
+          const taskId = created.get(item.id);
+          return taskId ? { ...item, kanbanBoardId: managedBoardId, kanbanTaskId: taskId } : item;
+        });
+        board = await getBoard(ctx.projectRoot, managedBoardId) ?? board;
+        boundItems = bindTodosToBoard(boundItems, ctx.todos ?? [], board);
+      }
+      boundItems = demoteBlockedInProgress(boundItems, creationWarnings);
+    }
+    ctx.state.replaceTodos(boundItems);
+    const kanbanSync = managed && board ? await synchronizeManagedKanban(boundItems, board, ctx, call.signal) : { synced: 0, warnings: [] };
+    kanbanSync.warnings.unshift(...creationWarnings);
+    if (managed && board) {
+      const unresolved = boundItems.filter(
+        (item) => item.kanbanBoardId !== board.id || !item.kanbanTaskId
+      );
+      if (unresolved.length > 0) {
+        kanbanSync.warnings.push(
+          `${unresolved.length} Todo row(s) could not be bound to a Kanban task and were not applied. Preserve kanbanBoardId/kanbanTaskId when updating the projection.`
+        );
+      }
+    }
+    const mirrorFailure = takeSessionMirrorFailure(ctx.projectRoot, ctx.session?.id ?? "");
+    if (mirrorFailure) kanbanSync.warnings.push(mirrorFailure);
+    let projectedBoard = board;
+    if (managed && board) {
+      const refreshed = await getBoard(ctx.projectRoot, board.id);
+      if (refreshed) {
+        projectedBoard = refreshed;
+        applyManagedKanbanBoardToTodos(ctx, refreshed);
+      }
+    }
+    if (!managed) {
+      mirrorSessionTodosToKanban(ctx.projectRoot, items, ctx.session?.id ?? "session");
+    }
+    const completedPlanIds = /* @__PURE__ */ new Set();
+    const completedTaskIds = /* @__PURE__ */ new Set();
+    const pendingPlanIds = /* @__PURE__ */ new Set();
+    const pendingTaskIds = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      if (item.promotedFromPlan) {
+        (item.status === "completed" ? completedPlanIds : pendingPlanIds).add(
+          item.promotedFromPlan
+        );
+      }
+      if (item.promotedFromTask) {
+        (item.status === "completed" ? completedTaskIds : pendingTaskIds).add(
+          item.promotedFromTask
+        );
+      }
+    }
+    for (const planId of completedPlanIds) {
+      if (pendingPlanIds.has(planId)) continue;
+      const meta = ctx.meta;
+      const planPath = meta["plan.path.resolved"] ?? meta["plan.path"];
+      if (typeof planPath !== "string" || !planPath) continue;
+      try {
+        const plan = await loadPlan(planPath);
+        if (plan) {
+          const updated = setPlanItemStatus(plan, planId, "done");
+          await savePlan(planPath, updated);
+        }
+      } catch {
+      }
+    }
+    for (const taskId of completedTaskIds) {
+      if (pendingTaskIds.has(taskId)) continue;
+      const meta = ctx.meta;
+      const taskPath = meta["task.path.resolved"] ?? meta["task.path"];
+      if (typeof taskPath !== "string" || !taskPath) continue;
+      try {
+        const file = await loadTasks(taskPath);
+        if (file) {
+          const task = file.tasks.find((t) => t.id === taskId);
+          if (task && task.status !== "completed") {
+            task.status = "completed";
+            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            await saveTasks(taskPath, file);
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      count: items.length,
+      in_progress: (ctx.todos ?? boundItems).filter((t) => t.status === "in_progress").length,
+      ...kanbanSync.synced > 0 ? { kanban_synced: kanbanSync.synced } : {},
+      ...kanbanSync.warnings.length > 0 ? { kanban_warnings: kanbanSync.warnings } : {},
+      ...projectedBoard?.lifecycle?.mode === "managed" ? {
+        kanban_bindings: boundItems.flatMap((item) => {
+          if (item.kanbanBoardId !== projectedBoard.id || !item.kanbanTaskId) return [];
+          const task = projectedBoard.tasks.find(
+            (candidate) => candidate.id === item.kanbanTaskId
+          );
+          return task ? [
+            {
+              todoId: item.id,
+              boardId: projectedBoard.id,
+              taskId: task.id,
+              taskStatus: task.status
+            }
+          ] : [];
+        })
+      } : {}
+    };
+  }
+};
+
+export {
+  todoTool
+};
+//# sourceMappingURL=chunk-7EY5DCRO.js.map