@algosuite/vo-mcp 0.2.0-beta.59 → 0.2.0-beta.61

package/dist/ci/check-local-pr-overlap.js

@@ -106643,6 +106643,81 @@ if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.ar
   process.exitCode = exitCode;
 }
 
+// ../../scripts/virtual-office/code-runner/self-claim-identity.mjs
+var CODE_TASK_BRANCH_RE = /^(?:refs\/heads\/)?vo\/code-task-([0-9a-z]{8,})-/iu;
+var CODE_TASK_MARKER_RE = /(?:^|[\s[(])code-task:([0-9a-z][0-9a-z-]{7,63})/iu;
+var MIN_TASK_ID_TOKEN_LENGTH = 8;
+var MAX_TASK_ID_LENGTH = 36;
+var TASK_ID_CHARS_RE = /^[0-9a-z][0-9a-z-]*$/u;
+function normalizeTaskId(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function taskIdFromCodeTaskBranch(branch) {
+  const match = CODE_TASK_BRANCH_RE.exec(String(branch ?? "").trim());
+  return match ? match[1].toLowerCase() : "";
+}
+function taskIdFromClaimMarker(currentTask) {
+  const match = CODE_TASK_MARKER_RE.exec(String(currentTask ?? ""));
+  return match ? match[1].toLowerCase() : "";
+}
+function resolvePublishingTaskId({ taskId = "", branch = "", env = {} } = {}) {
+  const none = { taskId: "", token: "", source: "none", exact: false };
+  const fromBranch = taskIdFromCodeTaskBranch(branch);
+  const branchToken = fromBranch.length >= MIN_TASK_ID_TOKEN_LENGTH ? fromBranch : "";
+  const explicit = normalizeTaskId(taskId);
+  if (explicit.length >= MIN_TASK_ID_TOKEN_LENGTH && TASK_ID_CHARS_RE.test(explicit)) {
+    return { taskId: explicit, token: explicit.slice(0, MIN_TASK_ID_TOKEN_LENGTH), source: "explicit", exact: true };
+  }
+  const fromEnv = normalizeTaskId(env?.VO_CODE_TASK_ID);
+  if (fromEnv.length >= MIN_TASK_ID_TOKEN_LENGTH && TASK_ID_CHARS_RE.test(fromEnv)) {
+    if (branchToken && !fromEnv.startsWith(branchToken)) {
+      return { ...none, source: "conflict" };
+    }
+    return { taskId: fromEnv, token: fromEnv.slice(0, MIN_TASK_ID_TOKEN_LENGTH), source: "env", exact: true };
+  }
+  if (branchToken) return { taskId: branchToken, token: branchToken, source: "branch", exact: false };
+  return none;
+}
+function matchesPublishingTask(candidate, publishing) {
+  const value = normalizeTaskId(candidate);
+  if (!publishing?.token) return false;
+  if (value.length < MIN_TASK_ID_TOKEN_LENGTH || value.length > MAX_TASK_ID_LENGTH) return false;
+  if (!TASK_ID_CHARS_RE.test(value)) return false;
+  if (!value.startsWith(publishing.token)) return false;
+  if (publishing.exact) return publishing.taskId.startsWith(value) || value.startsWith(publishing.taskId);
+  return true;
+}
+function claimTaskId(conflict, publishing) {
+  if (!publishing?.token) return "";
+  const marked = taskIdFromClaimMarker(conflict?.currentTask);
+  if (marked && matchesPublishingTask(marked, publishing)) return marked;
+  const agentId = String(conflict?.agentId ?? "").trim().toLowerCase();
+  if (!agentId) return "";
+  const index = agentId.lastIndexOf(`-${publishing.token}`);
+  if (index < 0) return "";
+  const tail = agentId.slice(index + 1);
+  return matchesPublishingTask(tail, publishing) ? tail : "";
+}
+function claimBelongsToTask(conflict, publishing) {
+  return claimTaskId(conflict, publishing) !== "";
+}
+function partitionSelfClaims(conflicts = [], publishing = { token: "" }) {
+  const self2 = [];
+  const foreign = [];
+  for (const conflict of conflicts) {
+    (claimBelongsToTask(conflict, publishing) ? self2 : foreign).push(conflict);
+  }
+  return { self: self2, foreign };
+}
+function describeSelfClaimExclusion(self2 = [], publishing = { token: "" }) {
+  if (self2.length === 0) return "";
+  const files = [...new Set(self2.map((conflict) => conflict?.matchedFile || conflict?.file || "?"))];
+  return [
+    `Self-claims ignored: ${self2.length} live whiteboard claim(s) held by this publishing task (task ${publishing.taskId || publishing.token}, matched via ${publishing.source}).`,
+    ...files.map((file) => `- ${file}`)
+  ].join("\n");
+}
+
 // ../../scripts/ci/check-local-pr-overlap.mjs
 function normalizeFileList(files = []) {
   return [...new Set(files.flatMap((file) => String(file || "").split(/\r?\n/)).map((file) => file.trim().replaceAll("\\", "/")).filter(Boolean))];
@@ -106728,7 +106803,10 @@ function evaluateOverlapGate({
   whiteboardReason = "",
   requireWhiteboard = true,
   allowOverlap = false,
-  prLabel = "local branch"
+  prLabel = "local branch",
+  // Never silent: when the publishing task's OWN claims were dropped, say so and
+  // name them. A gate that quietly ignores claims cannot be told from a broken one.
+  selfClaimNote = ""
 } = {}) {
   const files = normalizeFileList(changedFiles);
   const overlaps = classifyOverlaps(files, otherPrs || []);
@@ -106740,6 +106818,7 @@ function evaluateOverlapGate({
   lines.push(`Local overlap gate for ${prLabel}`);
   lines.push(`Changed files: ${files.length}`);
   if (otherPrs?.length) lines.push(`Compared against open PRs: ${otherPrs.length}`);
+  if (selfClaimNote) lines.push(selfClaimNote);
   if (directOverlap || overlaps.packageOverlaps.length || overlaps.sharedDepOverlaps.length) {
     lines.push("");
     lines.push(buildOverlapReport(overlaps, 0));
@@ -106780,6 +106859,32 @@ function evaluateOverlapGate({
     report: lines.join("\n")
   };
 }
+function decideOverlapGate({
+  changedFiles,
+  otherPrs = [],
+  busResult = { available: true, conflicts: [] },
+  taskId = "",
+  branch = "",
+  env = process.env,
+  requireWhiteboard = true,
+  allowOverlap = false,
+  prLabel = branch || "local branch"
+} = {}) {
+  const publishing = resolvePublishingTaskId({ taskId, branch, env });
+  const { self: self2, foreign } = partitionSelfClaims(busResult?.conflicts || [], publishing);
+  const evaluated = evaluateOverlapGate({
+    changedFiles,
+    otherPrs,
+    busConflicts: foreign,
+    whiteboardAvailable: busResult?.available !== false,
+    whiteboardReason: busResult?.reason || "",
+    requireWhiteboard,
+    allowOverlap,
+    prLabel,
+    selfClaimNote: describeSelfClaimExclusion(self2, publishing)
+  });
+  return { ...evaluated, publishing, selfClaims: self2 };
+}
 async function main() {
   const { values: args } = parseArgs({
     options: {
@@ -106788,7 +106893,10 @@ async function main() {
       branch: { type: "string", default: "" },
       stdin: { type: "boolean", default: false },
       "exclude-pr": { type: "string", default: "" },
-      "agent-id": { type: "string", default: process.env.AGENT_ID || "" }
+      "agent-id": { type: "string", default: process.env.AGENT_ID || "" },
+      // The publishing code task. Explicit beats VO_CODE_TASK_ID beats the
+      // `vo/code-task-<id8>-…` branch; absent everywhere ⇒ nothing is excluded.
+      "task-id": { type: "string", default: "" }
     }
   });
   const changedFiles = args.stdin ? readFilesFromStdin() : readChangedFiles({ base: args.base, head: args.head });
@@ -106815,12 +106923,12 @@ async function main() {
     return 2;
   }
   const busResult = await checkForConflicts(changedFiles, { excludeAgentId: args["agent-id"] });
-  const result = evaluateOverlapGate({
+  const result = decideOverlapGate({
     changedFiles,
     otherPrs,
-    busConflicts: busResult.conflicts || [],
-    whiteboardAvailable: busResult.available !== false,
-    whiteboardReason: busResult.reason || "",
+    busResult,
+    taskId: args["task-id"],
+    branch: args.branch,
     requireWhiteboard: process.env.VO_ALLOW_WHITEBOARD_UNAVAILABLE !== "1",
     allowOverlap: process.env.VO_ALLOW_PR_OVERLAP === "1",
     prLabel: args.branch || "local branch"
@@ -106831,6 +106939,7 @@ async function main() {
 var __test3 = {
   HOSTILE_WORKTREE_GIT_GUARDS,
   gitText,
+  decideOverlapGate,
   evaluateOverlapGate,
   isPrDiffTooLargeError,
   normalizeFileList,
@@ -106842,7 +106951,8 @@ if (process.argv[1] && import.meta.url === pathToFileURL2(path2.resolve(process.
   process.exit(await main());
 }
 export {
-  __test3 as __test
+  __test3 as __test,
+  decideOverlapGate
 };
 /*! Bundled license information: