@hdwebsoft/hdcode-agent-team 0.1.2 → 0.1.3

package/dist/index.js

@@ -117,6 +117,37 @@ function hasCycle(taskId, blockedBy, allTasks) {
   }
   return false;
 }
+function hasCycleViaBlocks(taskId, blockTargets, blockedBySources, allTasks) {
+  const upstream = new Set;
+  const queue = [...blockedBySources];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (upstream.has(current))
+      continue;
+    upstream.add(current);
+    const task = allTasks.get(current);
+    if (task)
+      queue.push(...task.blockedBy);
+  }
+  for (const targetId of blockTargets) {
+    if (upstream.has(targetId))
+      return true;
+    const targetQueue = [targetId];
+    const visited = new Set;
+    while (targetQueue.length > 0) {
+      const cur = targetQueue.shift();
+      if (visited.has(cur))
+        continue;
+      visited.add(cur);
+      if (upstream.has(cur))
+        return true;
+      const t = allTasks.get(cur);
+      if (t)
+        targetQueue.push(...t.blockedBy);
+    }
+  }
+  return false;
+}
 async function unblockDependents(base, teamName, completedTaskId) {
   const unblocked = [];
   const allTasks = await loadAllTasks(base, teamName);
@@ -312,6 +343,7 @@ function createTeamTools(directory) {
 
 // src/tools/task-tools.ts
 import { join as join5 } from "node:path";
+import { unlink as unlink2 } from "node:fs/promises";
 import { tool as tool2 } from "@opencode-ai/plugin";
 function parseStringArray(raw, label) {
   if (!raw.trimStart().startsWith("[")) {
@@ -386,6 +418,9 @@ function createTaskTools(directory) {
           if (addBlockedBy.length > 0 && hasCycle(id, addBlockedBy, taskMap)) {
             return `Error: Circular dependency detected for task ${id}`;
           }
+          if (addBlocks.length > 0 && hasCycleViaBlocks(id, addBlocks, addBlockedBy, taskMap)) {
+            return `Error: Circular dependency detected for task ${id}`;
+          }
           const task = {
             id,
             subject: args.subject,
@@ -492,6 +527,11 @@ function createTaskTools(directory) {
             const result = parseStringArray(args.addBlocks, "addBlocks");
             if (typeof result === "string")
               return result;
+            const allTasks = await loadAllTasks(directory, args.teamName);
+            const taskMap = new Map(allTasks.map((t) => [t.id, t]));
+            if (hasCycleViaBlocks(task.id, result, task.blockedBy, taskMap)) {
+              return `Error: Circular dependency detected — cannot add blocks`;
+            }
             for (const targetId of result) {
               if (!task.blocks.includes(targetId)) {
                 task.blocks.push(targetId);
@@ -510,6 +550,11 @@ function createTaskTools(directory) {
             const result = parseStringArray(args.addBlockedBy, "addBlockedBy");
             if (typeof result === "string")
               return result;
+            const allTasks = await loadAllTasks(directory, args.teamName);
+            const taskMap = new Map(allTasks.map((t) => [t.id, t]));
+            if (hasCycle(task.id, result, taskMap)) {
+              return `Error: Circular dependency detected — cannot add blockedBy`;
+            }
             for (const targetId of result) {
               if (!task.blockedBy.includes(targetId)) {
                 task.blockedBy.push(targetId);
@@ -533,6 +578,46 @@ function createTaskTools(directory) {
         });
       }
     }),
+    task_delete: tool2({
+      description: "Delete a task and clean up all bidirectional dependency links. Removes this task from blocks[] and blockedBy[] of all related tasks.",
+      args: {
+        teamName: tool2.schema.string().describe("Team name"),
+        taskId: tool2.schema.string().describe("Task ID to delete")
+      },
+      async execute(args) {
+        const dir = teamDir(directory, args.teamName);
+        if (!await exists(join5(dir, "config.json"))) {
+          return `Error: Team "${args.teamName}" not found`;
+        }
+        const tasksDir = join5(dir, "tasks");
+        const tasksLockPath = join5(tasksDir, ".lock");
+        return withLock(tasksLockPath, async () => {
+          const tPath = taskFilePath(directory, args.teamName, args.taskId);
+          if (!await exists(tPath)) {
+            return `Error: Task "${args.taskId}" not found in team "${args.teamName}"`;
+          }
+          const task = await readJson(tPath);
+          for (const blockerId of task.blockedBy) {
+            const blockerPath = taskFilePath(directory, args.teamName, blockerId);
+            if (await exists(blockerPath)) {
+              const blocker = await readJson(blockerPath);
+              blocker.blocks = blocker.blocks.filter((id) => id !== args.taskId);
+              await writeJsonAtomic(blockerPath, blocker);
+            }
+          }
+          for (const blockedId of task.blocks) {
+            const blockedPath = taskFilePath(directory, args.teamName, blockedId);
+            if (await exists(blockedPath)) {
+              const blocked = await readJson(blockedPath);
+              blocked.blockedBy = blocked.blockedBy.filter((id) => id !== args.taskId);
+              await writeJsonAtomic(blockedPath, blocked);
+            }
+          }
+          await unlink2(tPath);
+          return `Task "${args.taskId}" deleted and all dependency links cleaned up`;
+        });
+      }
+    }),
     task_get: tool2({
       description: "Get a single task by ID.",
       args: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hdwebsoft/hdcode-agent-team",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "OpenCode plugin for multi-agent team coordination — per-agent inboxes, task management with dependency tracking, and file locking.",
   "type": "module",
   "main": "./dist/index.js",