@hdwebsoft/hdcode-agent-team 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/index.ts
+import { relative, isAbsolute } from "node:path";
+
 // src/teams.ts
 import { readdir as readdir2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
@@ -233,36 +236,38 @@ function createTeamTools(directory) {
         description: tool.schema.string().describe("Team description")
       },
       async execute(args) {
-        const dir = teamDir(directory, args.teamName);
-        if (await exists(join4(dir, "config.json"))) {
-          return `Error: Team "${args.teamName}" already exists`;
-        }
-        await ensureDir(join4(dir, "tasks"));
-        await ensureDir(join4(dir, "inboxes"));
-        await ensureDir(join4(dir, "reports"));
-        const now = Date.now();
-        const leadId = `team-lead@${args.teamName}`;
-        const config = {
-          name: args.teamName,
-          description: args.description,
-          createdAt: now,
-          leadAgentId: leadId,
-          members: [
-            {
-              agentId: leadId,
-              name: "team-lead",
-              agentType: "team-lead",
-              model: "unknown",
-              planModeRequired: false,
-              joinedAt: now,
-              cwd: directory,
-              isActive: true
-            }
-          ]
-        };
-        await writeJsonAtomic(join4(dir, "config.json"), config);
-        await writeJsonAtomic(join4(dir, "inboxes", "team-lead.json"), []);
-        return JSON.stringify(config, null, 2);
+        return withTeamLock(directory, args.teamName, async () => {
+          const dir = teamDir(directory, args.teamName);
+          if (await exists(join4(dir, "config.json"))) {
+            return `Error: Team "${args.teamName}" already exists`;
+          }
+          await ensureDir(join4(dir, "tasks"));
+          await ensureDir(join4(dir, "inboxes"));
+          await ensureDir(join4(dir, "reports"));
+          const now = Date.now();
+          const leadId = `team-lead@${args.teamName}`;
+          const config = {
+            name: args.teamName,
+            description: args.description,
+            createdAt: now,
+            leadAgentId: leadId,
+            members: [
+              {
+                agentId: leadId,
+                name: "team-lead",
+                agentType: "team-lead",
+                model: "unknown",
+                planModeRequired: false,
+                joinedAt: now,
+                cwd: directory,
+                isActive: true
+              }
+            ]
+          };
+          await writeJsonAtomic(join4(dir, "config.json"), config);
+          await writeJsonAtomic(join4(dir, "inboxes", "team-lead.json"), []);
+          return JSON.stringify(config, null, 2);
+        });
       }
     }),
     team_delete: tool({
@@ -271,12 +276,14 @@ function createTeamTools(directory) {
         teamName: tool.schema.string().describe("Team name to delete")
       },
       async execute(args) {
-        const dir = teamDir(directory, args.teamName);
-        if (!await exists(join4(dir, "config.json"))) {
-          return `Error: Team "${args.teamName}" not found`;
-        }
-        await rm2(dir, { recursive: true, force: true });
-        return `Team "${args.teamName}" deleted successfully`;
+        return withTeamLock(directory, args.teamName, async () => {
+          const dir = teamDir(directory, args.teamName);
+          if (!await exists(join4(dir, "config.json"))) {
+            return `Error: Team "${args.teamName}" not found`;
+          }
+          await rm2(dir, { recursive: true, force: true });
+          return `Team "${args.teamName}" deleted successfully`;
+        });
       }
     }),
     team_status: tool({
@@ -360,6 +367,7 @@ import { tool as tool2 } from "@opencode-ai/plugin";
 
 // src/reservations.ts
 import { join as join5 } from "node:path";
+import { readdir as readdir4 } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 var DEFAULT_TTL_SECONDS = 1800;
 var MAX_TTL_SECONDS = 14400;
@@ -590,6 +598,70 @@ async function checkFile(base, teamName, path, agentId) {
   const canEdit = !reserved || !!agentId && holders.every((h) => h.agentId === agentId);
   return { reserved, canEdit, holders };
 }
+async function checkFileAcrossTeams(base, filePath, sessionId) {
+  const root = join5(base, TEAM_ROOT);
+  if (!await exists(root))
+    return null;
+  let normalized;
+  try {
+    normalized = normalizeRepoPath(filePath);
+  } catch {
+    return null;
+  }
+  let entries;
+  try {
+    entries = await readdir4(root, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith("."))
+      continue;
+    const storePath = reservationStorePath(base, entry.name);
+    if (!await exists(storePath))
+      continue;
+    let store;
+    try {
+      store = await readJson(storePath);
+    } catch {
+      continue;
+    }
+    pruneExpired(store);
+    for (const r of store.reservations) {
+      if (r.files.includes(normalized)) {
+        return {
+          teamName: entry.name,
+          holder: {
+            reservationId: r.id,
+            agentId: r.agentId,
+            taskId: r.taskId,
+            reason: r.reason,
+            expiresAt: r.expiresAt,
+            matchedBy: "file",
+            value: normalized
+          }
+        };
+      }
+      for (const p of r.prefixes) {
+        if (isPathInsidePrefix(normalized, p)) {
+          return {
+            teamName: entry.name,
+            holder: {
+              reservationId: r.id,
+              agentId: r.agentId,
+              taskId: r.taskId,
+              reason: r.reason,
+              expiresAt: r.expiresAt,
+              matchedBy: "prefix",
+              value: p
+            }
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
 
 // src/tools/task-tools.ts
 function parseStringArray(raw, label) {
@@ -723,6 +795,24 @@ function createTaskTools(directory) {
             return `Error: Task "${args.taskId}" not found in team "${args.teamName}"`;
           }
           const task = await readJson(tPath);
+          const originalOwner = task.owner;
+          if (args.subject !== undefined)
+            task.subject = args.subject;
+          if (args.description !== undefined)
+            task.description = args.description;
+          if (args.activeForm !== undefined)
+            task.activeForm = args.activeForm;
+          if (args.owner !== undefined)
+            task.owner = args.owner;
+          if (args.metadata) {
+            let newMeta;
+            try {
+              newMeta = JSON.parse(args.metadata);
+            } catch {
+              return "Error: Invalid metadata JSON";
+            }
+            task.metadata = { ...task.metadata, ...newMeta };
+          }
           if (args.status) {
             const validTransitions = {
               pending: ["in_progress"],
@@ -751,7 +841,7 @@ function createTaskTools(directory) {
             if (args.status === "in_progress") {
               const fileScope = task.metadata?.fileScope;
               if (fileScope) {
-                const agentId = args.owner || task.owner || "unknown";
+                const agentId = task.owner || "unknown";
                 const reserveResult = await reserveFiles(directory, args.teamName, {
                   agentId,
                   taskId: task.id,
@@ -764,36 +854,22 @@ function createTaskTools(directory) {
               }
             }
             if (args.status === "completed") {
-              const agentId = args.owner || task.owner;
-              if (agentId) {
-                await releaseByTask(directory, args.teamName, agentId, task.id);
+              if (originalOwner) {
+                await releaseByTask(directory, args.teamName, originalOwner, task.id);
               }
             }
             task.status = args.status;
           }
-          if (args.subject !== undefined)
-            task.subject = args.subject;
-          if (args.description !== undefined)
-            task.description = args.description;
-          if (args.activeForm !== undefined)
-            task.activeForm = args.activeForm;
-          if (args.owner !== undefined)
-            task.owner = args.owner;
-          if (args.metadata) {
-            let newMeta;
-            try {
-              newMeta = JSON.parse(args.metadata);
-            } catch {
-              return "Error: Invalid metadata JSON";
-            }
-            task.metadata = { ...task.metadata, ...newMeta };
-          }
           if (args.addBlocks) {
             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]));
+            for (const targetId of result) {
+              if (!taskMap.has(targetId))
+                return `Error: Task "${targetId}" not found — cannot add to blocks`;
+            }
             if (hasCycleViaBlocks(task.id, result, task.blockedBy, taskMap)) {
               return `Error: Circular dependency detected — cannot add blocks`;
             }
@@ -802,12 +878,10 @@ function createTaskTools(directory) {
                 task.blocks.push(targetId);
               }
               const targetPath = taskFilePath(directory, args.teamName, targetId);
-              if (await exists(targetPath)) {
-                const target = await readJson(targetPath);
-                if (!target.blockedBy.includes(task.id)) {
-                  target.blockedBy.push(task.id);
-                  await writeJsonAtomic(targetPath, target);
-                }
+              const target = await readJson(targetPath);
+              if (!target.blockedBy.includes(task.id)) {
+                target.blockedBy.push(task.id);
+                await writeJsonAtomic(targetPath, target);
               }
             }
           }
@@ -817,6 +891,10 @@ function createTaskTools(directory) {
               return result;
             const allTasks = await loadAllTasks(directory, args.teamName);
             const taskMap = new Map(allTasks.map((t) => [t.id, t]));
+            for (const targetId of result) {
+              if (!taskMap.has(targetId))
+                return `Error: Task "${targetId}" not found — cannot add to blockedBy`;
+            }
             if (hasCycle(task.id, result, taskMap)) {
               return `Error: Circular dependency detected — cannot add blockedBy`;
             }
@@ -825,12 +903,10 @@ function createTaskTools(directory) {
                 task.blockedBy.push(targetId);
               }
               const targetPath = taskFilePath(directory, args.teamName, targetId);
-              if (await exists(targetPath)) {
-                const target = await readJson(targetPath);
-                if (!target.blocks.includes(task.id)) {
-                  target.blocks.push(task.id);
-                  await writeJsonAtomic(targetPath, target);
-                }
+              const target = await readJson(targetPath);
+              if (!target.blocks.includes(task.id)) {
+                target.blocks.push(task.id);
+                await writeJsonAtomic(targetPath, target);
               }
             }
           }
@@ -947,6 +1023,7 @@ function createMessageTools(directory) {
         const inboxesDir = join7(dir, "inboxes");
         await ensureDir(inboxesDir);
         const message = {
+          type: args.type,
           from: sender,
           text: args.content,
           ...args.summary && { summary: args.summary },
@@ -993,11 +1070,17 @@ function createMessageTools(directory) {
       },
       async execute(args) {
         const dir = teamDir(directory, args.teamName);
-        if (!await exists(join7(dir, "config.json"))) {
+        const configPath = join7(dir, "config.json");
+        if (!await exists(configPath)) {
           return `Error: Team "${args.teamName}" not found`;
         }
         const agentName = args.agent.includes("@") ? args.agent.split("@")[0] : args.agent;
-        const inboxPath = join7(dir, "inboxes", `${agentName}.json`);
+        const config = await readJson(configPath);
+        const member = config.members.find((m) => m.name === agentName || m.agentId === args.agent);
+        if (!member) {
+          return `Error: Agent "${args.agent}" not found in team "${args.teamName}"`;
+        }
+        const inboxPath = join7(dir, "inboxes", `${member.name}.json`);
         if (args.markRead) {
           return withTeamLock(directory, args.teamName, async () => {
             const allMessages = await readInbox(inboxPath);
@@ -1143,6 +1226,7 @@ function createReservationTools(directory) {
 }
 
 // src/index.ts
+var WRITE_TOOLS = new Set(["edit", "write", "create"]);
 var HDTeamPlugin = async ({ directory }) => {
   return {
     "experimental.session.compacting": async (_input, output) => {
@@ -1159,6 +1243,26 @@ Use team_status(teamName) to get full details. Continue any in-progress tasks.
 `);
       }
     },
+    "tool.execute.before": async (input, output) => {
+      if (!WRITE_TOOLS.has(input.tool))
+        return;
+      const filePath = output.args.filePath;
+      if (!filePath)
+        return;
+      let repoPath = filePath;
+      if (isAbsolute(filePath)) {
+        repoPath = relative(directory, filePath);
+        if (repoPath.startsWith(".."))
+          return;
+      }
+      const match = await checkFileAcrossTeams(directory, repoPath);
+      if (match) {
+        const h = match.holder;
+        const who = h.taskId ? `${h.agentId} (task ${h.taskId})` : h.agentId;
+        const reason = h.reason ? ` — ${h.reason}` : "";
+        throw new Error(`\uD83D\uDD12 File "${repoPath}" is reserved by ${who} in team "${match.teamName}"${reason}. ` + `Use file_check to see details or wait for the reservation to expire (${h.expiresAt}).`);
+      }
+    },
     tool: {
       ...createTeamTools(directory),
       ...createTaskTools(directory),

package/package.json

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