jules-orchestrator-kit 0.2.9 → 0.5.1

package/scripts/lock-manager.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+/**
+ * lock-manager.mjs
+ * 
+ * Manages multi-agent file locks to prevent concurrent modification collisions.
+ * Uses .agent/sync-manifest.json as the lock registry.
+ * 
+ * Usage:
+ *   node scripts/lock-manager.mjs acquire <agent_name> <task_id> <file_path1> <file_path2> [--unattended]
+ *   node scripts/lock-manager.mjs release <task_id>
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const MANIFEST_PATH = path.join(process.cwd(), '.agent', 'sync-manifest.json');
+const TTL_MS = 20 * 60 * 1000; // 20 minutes
+
+async function readManifest() {
+  try {
+    const data = await fs.readFile(MANIFEST_PATH, 'utf-8');
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return {};
+    }
+    throw err;
+  }
+}
+
+async function writeManifest(manifest) {
+  await fs.mkdir(path.dirname(MANIFEST_PATH), { recursive: true });
+  await fs.writeFile(MANIFEST_PATH, JSON.stringify(manifest, null, 2), 'utf-8');
+}
+
+function cleanExpiredLocks(manifest) {
+  const now = Date.now();
+  let changed = false;
+  for (const [file, lock] of Object.entries(manifest)) {
+    if (lock.expiresAt < now) {
+      delete manifest[file];
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+async function acquireLocks(agentName, taskId, files) {
+  const manifest = await readManifest();
+  cleanExpiredLocks(manifest);
+  
+  const now = Date.now();
+  const expiresAt = now + TTL_MS;
+
+  const conflicts = [];
+  for (const file of files) {
+    const normalizedFile = path.normalize(file);
+    if (manifest[normalizedFile] && manifest[normalizedFile].taskId !== taskId) {
+      conflicts.push({
+        file: normalizedFile,
+        lockedBy: manifest[normalizedFile].agentName,
+        task: manifest[normalizedFile].taskId
+      });
+    }
+  }
+
+  if (conflicts.length > 0) {
+    console.error(`ERROR: Cannot acquire locks for task ${taskId}. Conflicts detected:`);
+    for (const conflict of conflicts) {
+      console.error(`  - ${conflict.file} is locked by ${conflict.lockedBy} (Task: ${conflict.task})`);
+    }
+    process.exit(1);
+  }
+
+  for (const file of files) {
+    const normalizedFile = path.normalize(file);
+    manifest[normalizedFile] = {
+      agentName,
+      taskId,
+      acquiredAt: now,
+      expiresAt
+    };
+  }
+
+  await writeManifest(manifest);
+  console.log(`SUCCESS: Acquired locks for task ${taskId} on ${files.length} files.`);
+}
+
+async function releaseLocks(taskId) {
+  const manifest = await readManifest();
+  let releasedCount = 0;
+  
+  for (const [file, lock] of Object.entries(manifest)) {
+    if (lock.taskId === taskId) {
+      delete manifest[file];
+      releasedCount++;
+    }
+  }
+
+  if (releasedCount > 0) {
+    await writeManifest(manifest);
+    console.log(`SUCCESS: Released ${releasedCount} locks for task ${taskId}.`);
+  } else {
+    console.log(`INFO: No locks found for task ${taskId}.`);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (command === 'acquire') {
+    const agentName = args[1];
+    const taskId = args[2];
+    const unattendedIndex = args.indexOf('--unattended');
+    
+    let files = [];
+    if (unattendedIndex !== -1) {
+       files = args.slice(3, unattendedIndex).concat(args.slice(unattendedIndex + 1));
+    } else {
+       files = args.slice(3);
+    }
+    
+    if (!agentName || !taskId || files.length === 0) {
+      console.error('Usage: acquire <agent_name> <task_id> <file_paths...>');
+      process.exit(1);
+    }
+    
+    await acquireLocks(agentName, taskId, files);
+  } else if (command === 'release') {
+    const taskId = args[1];
+    if (!taskId) {
+      console.error('Usage: release <task_id>');
+      process.exit(1);
+    }
+    await releaseLocks(taskId);
+  } else {
+    console.error('Unknown command. Use "acquire" or "release".');
+    process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('Unhandled error:', err);
+  process.exit(1);
+});

package/scripts/utils.mjs

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+
+// ANSI colors for standardizing CLI DX
+const isCI = !!process.env.CI;
+const noColor = (!process.stdout.isTTY && !isCI) || process.env.NO_COLOR;
+const c = (color, text) => noColor ? text : `\x1b[${color}m${text}\x1b[0m`;
+
+export const log = {
+  info: (msg) => console.log(c(36, `ℹ️  ${msg}`)),
+  success: (msg) => console.log(c(32, `✅ ${msg}`)),
+  warn: (msg) => console.warn(c(33, `⚠️  ${msg}`)),
+  error: (msg) => {
+    if (isCI) console.log(`::error::${msg}`);
+    console.error(c(31, `❌ ${msg}`));
+  },
+  step: (stepStr, msg) => console.log(`${c(90, stepStr)} ${msg}`),
+  dim: (msg) => console.log(c(90, msg)),
+  header: (msg) => {
+    if (isCI) console.log(`::group::${msg}`);
+    console.log(`\n${c("1;35", `=== ${msg} ===`)}\n`);
+  },
+  groupEnd: () => {
+    if (isCI) console.log("::endgroup::");
+  }
+};
+
+export const sleep = promisify(setTimeout);
+
+export function ensureDir(dirPath) {
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  } catch (error) {
+    log.error(`EACCES: Insufficient permissions or failed to create directory: ${dirPath}`);
+    log.error(error.message);
+    process.exit(1);
+  }
+}
+
+export function logToHistory(filename, content, type = "audit") {
+  const dateStr = new Date().toISOString().split("T")[0];
+  const historyDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/history");
+  ensureDir(historyDir);
+  const filePath = path.join(historyDir, `${dateStr}-${filename}`);
+  fs.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+
+export function resolveMarkdownConflict(content) {
+  if (!content || typeof content !== "string") return "";
+  if (!content.includes("<<<<<<<")) return content;
+
+  const lines = content.split("\n");
+  const result = [];
+  let inConflict = false;
+  let headBuffer = [];
+  let devBuffer = [];
+  let section = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("<<<<<<<")) {
+      inConflict = true;
+      section = "head";
+      continue;
+    }
+    if (line.startsWith("=======")) {
+      section = "dev";
+      continue;
+    }
+    if (line.startsWith(">>>>>>>")) {
+      result.push(...headBuffer);
+      result.push(...devBuffer);
+      headBuffer = [];
+      devBuffer = [];
+      inConflict = false;
+      section = null;
+      continue;
+    }
+
+    if (inConflict) {
+      if (section === "head") headBuffer.push(line);
+      else if (section === "dev") devBuffer.push(line);
+    } else {
+      result.push(line);
+    }
+  }
+
+  return result.join("\n");
+}

package/.agent/history/2026-07-27-dispatch-test-swarm-task.md

@@ -1,9 +0,0 @@
----
-type: jules_dispatch
-title: "Test Swarm Task"
-timestamp: "2026-07-27T09:38:12.728Z"
----
-# Jules Task Dispatch: Test Swarm Task
-
-## Prompt
-Test Prompt Description