@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-FW65TP4G.js

@@ -0,0 +1,520 @@
+import {
+  todoTool
+} from "./chunk-J4SRJKBW.js";
+import {
+  mirrorSessionTasksToKanban
+} from "./chunk-QNJ7AQ4B.js";
+
+// src/task.ts
+import { randomUUID } from "node:crypto";
+import { addPlanItem, formatPlan, mutatePlan, mutateTasks } from "@wrongstack/core/storage";
+import { computeTaskItemProgress, formatTaskList } from "@wrongstack/core/utils";
+function findTaskIndex(tasks, query) {
+  const asNum = Number.parseInt(query, 10);
+  if (!Number.isNaN(asNum)) {
+    const idx = asNum - 1;
+    if (tasks[idx]) return idx;
+  }
+  const byId = tasks.findIndex((t) => t.id === query);
+  if (byId >= 0) return byId;
+  const lower = query.toLowerCase();
+  return tasks.findIndex((t) => t.title.toLowerCase().includes(lower));
+}
+var taskTool = {
+  name: "task",
+  category: "Session",
+  description: 'Manage session-persistent structured work items with dependencies, types, and priorities. Unlike `todo` (flat, tactical), `task` supports typed work (feature/bugfix/refactor/etc.), dependencies between items, priority ranking, and agent assignment. Tasks are written to disk and survive session resumes. By default they are isolated to this session; use `scope: "project"` to store tasks in a shared project-level file visible to all sessions.',
+  usageHint: 'USE FOR STRUCTURED WORK:\n- `action: "replace"` \u2014 replace task details/order without omitting unfinished persisted tasks\n- `action: "add"` \u2014 append a single task\n- `action: "status"` \u2014 update a task\'s status (e.g. pending\u2192in_progress, in_progress\u2192completed)\n- `action: "show"` \u2014 view current tasks without changing them\n- `action: "promote"` \u2014 convert a task into actionable todo items via `target` (id|index|substring)\n- `action: "planify"` \u2014 promote a task to a plan item (strategic level) via `target` (id|index|substring)\n\nTask fields:\n- `dependsOn`: list of task IDs this one waits for\n- `type`: "feature" | "bugfix" | "refactor" | "docs" | "test" | "chore"\n- `priority`: "critical" | "high" | "medium" | "low"\n- `assignee`: agent/subagent name (e.g. "bug-hunter", "refactor-planner")\n- `estimateHours`: rough time estimate\n- `scope`: "session" (default, isolated) or "project" (shared across sessions)',
+  permission: "confirm",
+  mutating: true,
+  subjectKey: "action",
+  capabilities: ["fs.write"],
+  icon: "task",
+  timeoutMs: 5e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["replace", "add", "status", "show", "promote", "planify"],
+        description: "replace = set full list, add = append, status = update task status, show = view only, promote = convert task to todos, planify = convert task to plan item."
+      },
+      tasks: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: 'Unique id (e.g. "t1", "auth-flow").' },
+            title: { type: "string", description: "Short title." },
+            description: { type: "string", description: "Optional details." },
+            type: {
+              type: "string",
+              enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
+            },
+            priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+            status: {
+              type: "string",
+              enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"]
+            },
+            dependsOn: {
+              type: "array",
+              items: { type: "string" },
+              description: "IDs of tasks this one depends on."
+            },
+            assignee: { type: "string", description: "Agent/subagent assigned." },
+            estimateHours: { type: "number", description: "Estimated hours." },
+            tags: { type: "array", items: { type: "string" }, description: "Optional tags." },
+            createdAt: { type: "string" },
+            updatedAt: { type: "string" }
+          },
+          required: ["id", "title", "type", "priority", "status"]
+        },
+        description: "Complete desired task list. Existing unfinished tasks may not be omitted; complete them first."
+      },
+      task: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          type: {
+            type: "string",
+            enum: ["feature", "bugfix", "refactor", "docs", "test", "chore"]
+          },
+          priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+          status: {
+            type: "string",
+            enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"]
+          },
+          dependsOn: { type: "array", items: { type: "string" } },
+          assignee: { type: "string" },
+          estimateHours: { type: "number" },
+          tags: { type: "array", items: { type: "string" } }
+        },
+        required: ["title", "type", "priority"],
+        description: "Single task to append (id/createdAt/updatedAt auto-generated)."
+      },
+      id: {
+        type: "string",
+        description: "Task id for action=status or target for action=promote."
+      },
+      status: {
+        type: "string",
+        enum: ["pending", "in_progress", "blocked", "failed", "review", "completed"],
+        description: "New status for action=status."
+      },
+      target: {
+        type: "string",
+        description: "Target task identifier (id, 1-based index, or title substring) for action=promote."
+      },
+      subtasks: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional subtask titles for action=promote. Each becomes a pending todo."
+      },
+      scope: {
+        type: "string",
+        enum: ["session", "project"],
+        description: 'Storage scope: "session" (default, isolated to this session) or "project" (shared across all sessions for this project).'
+      }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const sessionTaskPath = ctx.meta["task.path"];
+    let taskPath;
+    if (input.scope === "project") {
+      if (typeof sessionTaskPath === "string") {
+        const lastSep = Math.max(
+          sessionTaskPath.lastIndexOf("/"),
+          sessionTaskPath.lastIndexOf("\\")
+        );
+        taskPath = lastSep >= 0 ? sessionTaskPath.slice(0, lastSep + 1) + "backlog.tasks.json" : "backlog.tasks.json";
+      }
+    } else {
+      taskPath = sessionTaskPath;
+    }
+    if (typeof taskPath !== "string" || !taskPath) {
+      return {
+        ok: false,
+        message: "Task storage path not configured.",
+        count: 0,
+        completed: 0,
+        inProgress: 0
+      };
+    }
+    const sessionId = ctx.session?.id ?? "unknown";
+    let early = null;
+    const promoteMeta = { count: 0, title: "" };
+    const planifyMeta = { title: "", details: "" };
+    let didPlanify = false;
+    let todosToReplace = null;
+    let file;
+    try {
+      file = await mutateTasks(taskPath, sessionId, async (f) => {
+        switch (input.action) {
+          case "show":
+            break;
+          case "replace": {
+            if (!Array.isArray(input.tasks)) {
+              early = {
+                ok: false,
+                message: "action=replace requires `tasks` array.",
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const newIds = new Set(input.tasks.map((t) => t.id));
+            if (newIds.size !== input.tasks.length) {
+              const seen = /* @__PURE__ */ new Set();
+              const dupes = [
+                ...new Set(
+                  input.tasks.map((t) => t.id).filter((id) => {
+                    if (seen.has(id)) return true;
+                    seen.add(id);
+                    return false;
+                  })
+                )
+              ];
+              early = {
+                ok: false,
+                message: `action=replace has duplicate task IDs: ${dupes.join(", ")}. Each task id must be unique.`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const omittedUnfinished = f.tasks.filter(
+              (task) => task.status !== "completed" && !newIds.has(task.id)
+            );
+            if (omittedUnfinished.length > 0) {
+              early = {
+                ok: false,
+                message: `action=replace cannot omit unfinished tasks: ${omittedUnfinished.map((task) => task.id).join(", ")}. Complete them first.`,
+                count: f.tasks.length,
+                ...computeTaskItemProgress(f.tasks)
+              };
+              return f;
+            }
+            for (const t of input.tasks) {
+              if (t.dependsOn && t.dependsOn.length > 0) {
+                const missing = t.dependsOn.filter((d) => !newIds.has(d));
+                if (missing.length > 0) {
+                  early = {
+                    ok: false,
+                    message: `dependsOn validation failed: task "${t.id}" references unknown IDs: ${missing.join(", ")}`,
+                    count: 0,
+                    completed: 0,
+                    inProgress: 0
+                  };
+                  return f;
+                }
+              }
+              if (t.status === "in_progress" || t.status === "completed") {
+                const unmet = (t.dependsOn ?? []).filter(
+                  (dependencyId) => input.tasks?.find((candidate) => candidate.id === dependencyId)?.status !== "completed"
+                );
+                if (unmet.length > 0) {
+                  early = {
+                    ok: false,
+                    message: `dependency status validation failed: task "${t.id}" cannot be ${t.status} before completion of ${unmet.join(", ")}.`,
+                    count: f.tasks.length,
+                    ...computeTaskItemProgress(f.tasks)
+                  };
+                  return f;
+                }
+              }
+            }
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            f.tasks = input.tasks.map((t) => ({
+              ...t,
+              createdAt: t.createdAt || now,
+              updatedAt: now
+            }));
+            break;
+          }
+          case "add": {
+            const t = input.task;
+            if (!t?.title) {
+              early = {
+                ok: false,
+                message: "action=add requires `task` with at least `title`.",
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            if (t.dependsOn && t.dependsOn.length > 0) {
+              const existingIds = new Set(f.tasks.map((e) => e.id));
+              const missing = t.dependsOn.filter((d) => !existingIds.has(d));
+              if (missing.length > 0) {
+                early = {
+                  ok: false,
+                  message: `dependsOn validation failed: unknown task IDs: ${missing.join(", ")}`,
+                  count: 0,
+                  completed: 0,
+                  inProgress: 0
+                };
+                return f;
+              }
+            }
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            const newTask = {
+              id: `task_${Date.now()}_${randomUUID().slice(0, 8)}`,
+              title: t.title,
+              description: t.description,
+              type: t.type || "feature",
+              priority: t.priority || "medium",
+              status: t.status || "pending",
+              dependsOn: t.dependsOn,
+              assignee: t.assignee,
+              estimateHours: t.estimateHours,
+              tags: t.tags,
+              createdAt: now,
+              updatedAt: now
+            };
+            f.tasks.push(newTask);
+            break;
+          }
+          case "status": {
+            if (!input.id || !input.status) {
+              early = {
+                ok: false,
+                message: "action=status requires `id` and `status`.",
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const task = f.tasks.find((t) => t.id === input.id);
+            if (!task) {
+              early = {
+                ok: false,
+                message: `Task "${input.id}" not found.`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            if (input.status === "in_progress" || input.status === "completed") {
+              const unmet = (task.dependsOn ?? []).filter(
+                (dependencyId) => f.tasks.find((candidate) => candidate.id === dependencyId)?.status !== "completed"
+              );
+              if (unmet.length > 0) {
+                early = {
+                  ok: false,
+                  message: `Task "${task.id}" cannot be ${input.status} before dependencies complete: ${unmet.join(", ")}.`,
+                  count: f.tasks.length,
+                  ...computeTaskItemProgress(f.tasks)
+                };
+                return f;
+              }
+            }
+            task.status = input.status;
+            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            break;
+          }
+          case "promote": {
+            const target = input.target?.trim();
+            if (!target) {
+              early = {
+                ok: false,
+                message: "action=promote requires `target` (task id, index, or title substring).",
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const idx = findTaskIndex(f.tasks, target);
+            if (idx === -1) {
+              early = {
+                ok: false,
+                message: `No task matched "${target}".`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const match = f.tasks[idx];
+            if (!match) {
+              early = {
+                ok: false,
+                message: `No task matched "${target}".`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            if (match.status !== "completed" && match.status !== "failed") {
+              match.status = "in_progress";
+              match.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            }
+            const todos = [];
+            const ts = Date.now();
+            todos.push({
+              id: `todo_${ts}_task`,
+              content: match.title,
+              status: "in_progress",
+              activeForm: match.title,
+              promotedFromTask: match.id
+            });
+            if (match.description) {
+              todos.push({
+                id: `todo_${ts}_${randomUUID().slice(0, 6)}`,
+                content: match.description.slice(0, 200),
+                status: "pending",
+                promotedFromTask: match.id
+              });
+            }
+            if (input.subtasks && input.subtasks.length > 0) {
+              for (const st of input.subtasks) {
+                todos.push({
+                  id: `todo_${ts}_${randomUUID().slice(0, 6)}`,
+                  content: st,
+                  status: "pending",
+                  promotedFromTask: match.id
+                });
+              }
+            }
+            todosToReplace = todos;
+            promoteMeta.count = todos.length;
+            promoteMeta.title = match.title;
+            break;
+          }
+          case "planify": {
+            const target = input.target?.trim();
+            if (!target) {
+              early = {
+                ok: false,
+                message: "action=planify requires `target` (task id, index, or title substring).",
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const idx = findTaskIndex(f.tasks, target);
+            if (idx === -1) {
+              early = {
+                ok: false,
+                message: `No task matched "${target}".`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            const match = f.tasks[idx];
+            if (!match) {
+              early = {
+                ok: false,
+                message: `No task matched "${target}".`,
+                count: 0,
+                completed: 0,
+                inProgress: 0
+              };
+              return f;
+            }
+            planifyMeta.title = match.title;
+            planifyMeta.details = match.description ?? "";
+            didPlanify = true;
+            break;
+          }
+          default:
+            early = {
+              ok: false,
+              message: `Unknown action "${input.action}". Use replace | add | status | show | promote | planify.`,
+              count: 0,
+              completed: 0,
+              inProgress: 0
+            };
+            return f;
+        }
+        return f;
+      });
+    } catch (err) {
+      return {
+        ok: false,
+        message: `Task change not saved \u2014 ${err instanceof Error ? err.message : String(err)}`,
+        count: 0,
+        completed: 0,
+        inProgress: 0
+      };
+    }
+    ctx.meta["task.path.resolved"] = taskPath;
+    if (todosToReplace) {
+      await todoTool.execute({ todos: todosToReplace }, ctx, {
+        signal: AbortSignal.timeout(3e4)
+      });
+    }
+    mirrorSessionTasksToKanban(ctx.projectRoot, file.tasks, sessionId);
+    if (early) return early;
+    if (didPlanify) {
+      const { title, details } = planifyMeta;
+      const planPathRaw = ctx.meta["plan.path"];
+      const prog = computeTaskItemProgress(file.tasks);
+      if (typeof planPathRaw === "string" && planPathRaw) {
+        let planPath = planPathRaw;
+        if (input.scope === "project") {
+          const lastSep = Math.max(planPath.lastIndexOf("/"), planPath.lastIndexOf("\\"));
+          planPath = lastSep >= 0 ? planPath.slice(0, lastSep + 1) + "backlog.plan.json" : "backlog.plan.json";
+        }
+        let formatted = "";
+        try {
+          await mutatePlan(planPath, sessionId, (pf) => {
+            const { plan: updated } = addPlanItem(pf, title, details || void 0);
+            formatted = formatPlan(updated);
+            return updated;
+          });
+          ctx.meta["plan.path.resolved"] = planPath;
+        } catch (err) {
+          return {
+            ok: false,
+            message: `planify: plan not saved \u2014 ${err instanceof Error ? err.message : String(err)}`,
+            count: file.tasks.length,
+            completed: prog.completed,
+            inProgress: prog.inProgress
+          };
+        }
+        return {
+          ok: true,
+          message: `planify ok \u2014 added "${title}" to plan.
+${formatted}`,
+          count: file.tasks.length,
+          completed: prog.completed,
+          inProgress: prog.inProgress
+        };
+      }
+      return {
+        ok: false,
+        message: "Plan storage path not configured \u2014 cannot planify.",
+        count: file.tasks.length,
+        completed: prog.completed,
+        inProgress: prog.inProgress
+      };
+    }
+    const p = computeTaskItemProgress(file.tasks);
+    const summary = promoteMeta.count > 0 ? `promote ok \u2014 ${promoteMeta.count} todo(s) created from "${promoteMeta.title}".
+${formatTaskList(file.tasks)}` : file.tasks.length > 0 ? formatTaskList(file.tasks) : "No tasks.";
+    return {
+      ok: true,
+      message: summary,
+      count: file.tasks.length,
+      completed: p.completed,
+      inProgress: p.inProgress
+    };
+  }
+};
+
+export {
+  taskTool
+};
+//# sourceMappingURL=chunk-FW65TP4G.js.map