jules-orchestrator-kit 0.1.9 → 0.2.8

package/scripts/jules-self-audit.mjs

@@ -43,6 +43,14 @@ export function matchGlob(filepath, globPattern) {
 }
 
 
+/**
+ * Lightweight Zero-Dependency YAML Pattern Extractor
+ * Extracts forbidden_paths and allow_paths arrays from jules.yml.
+ * Supported subset:
+ *  - Flow style arrays: forbidden_paths: ["path1", "path2"]
+ *  - Block style arrays: forbidden_paths:\n  - path1\n  - path2
+ * Limitations: Does not support multiline strings (|/>), nested dicts, or inline comments.
+ */
 export function loadForbiddenPatterns(configContent = "") {
   const defaultForbidden = [
     ".github/**",
@@ -112,10 +120,35 @@ export function loadAllowedPatterns(configContent = "") {
   return blockParsed;
 }
 
+export function parseAndCleanStderr(stderrStr) {
+  if (!stderrStr) return "";
+  const clean = stderrStr.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+  const lines = clean.split("\n").filter(Boolean);
+  return lines.slice(-100).join("\n");
+}
+
+export function logAuditMetrics(metrics) {
+  const historyDir = path.resolve(process.cwd(), ".agent/history");
+  if (!fs.existsSync(historyDir)) {
+    fs.mkdirSync(historyDir, { recursive: true });
+  }
+  const metricsFile = path.join(historyDir, "metrics.jsonl");
+  const logLine = JSON.stringify({
+    timestamp: new Date().toISOString(),
+    ...metrics,
+  }) + "\n";
+  fs.appendFileSync(metricsFile, logLine, "utf-8");
+}
+
 export function runSelfAudit() {
   console.log("🔍 Running Jules PR Self-Audit Gatekeeper...\n");
 
   const targetBranch = process.env.BASE_BRANCH || "main";
+  const SAFE_BRANCH = /^[a-zA-Z0-9._\/-]+$/;
+  if (!SAFE_BRANCH.test(targetBranch)) {
+    console.error(`❌ FATAL: Invalid BASE_BRANCH "${targetBranch}". Must match ^[a-zA-Z0-9._\\/-]+$`);
+    process.exit(1);
+  }
   console.log(`🎯 Target Branch: ${targetBranch}`);
 
   if (process.env.CI) {
@@ -150,7 +183,6 @@ export function runSelfAudit() {
   const forbiddenPatterns = loadForbiddenPatterns(trustedConfig);
   const allowedPatterns = loadAllowedPatterns(trustedConfig);
 
-
   const violations = rawDiffFiles.filter((file) => {
     const isForbidden = forbiddenPatterns.some((pattern) => matchGlob(file, pattern));
     if (!isForbidden) return false;
@@ -166,18 +198,38 @@ export function runSelfAudit() {
   }
   console.log("\n✅ Restricted File Boundary Check: PASSED");
 
-
   console.log("\n🛠️ Resolving Dynamic Verification Suite...");
   const resolvedCmds = resolveWorkspaceExecutionBoundary(changedCodeFiles, process.cwd());
   console.log(`📋 Discovered Execution Scope: ${resolvedCmds.source}`);
 
+  const startTime = Date.now();
+  let testPassed = true;
+  let failureLog = "";
+
+  const runVerification = (cmd) => {
+    try {
+      execSync(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+      return true;
+    } catch (err) {
+      failureLog = parseAndCleanStderr((err.stderr || "") + "\n" + (err.stdout || "") + "\n" + (err.message || ""));
+      return false;
+    }
+  };
+
   if (resolvedCmds.testCmd) {
     console.log(`▶ Running Test Verification: ${resolvedCmds.testCmd}`);
-    runCommand(resolvedCmds.testCmd);
+    if (!runVerification(resolvedCmds.testCmd)) {
+      testPassed = false;
+      console.error(`❌ Test verification failed: ${resolvedCmds.testCmd}`);
+    }
   }
-  if (resolvedCmds.buildCmd) {
+
+  if (testPassed && resolvedCmds.buildCmd) {
     console.log(`▶ Running Build Verification: ${resolvedCmds.buildCmd}`);
-    runCommand(resolvedCmds.buildCmd);
+    if (!runVerification(resolvedCmds.buildCmd)) {
+      testPassed = false;
+      console.error(`❌ Build verification failed: ${resolvedCmds.buildCmd}`);
+    }
   }
 
   if (!resolvedCmds.testCmd && !resolvedCmds.buildCmd) {
@@ -185,6 +237,21 @@ export function runSelfAudit() {
     runCommand("git status");
   }
 
+  const durationMs = Date.now() - startTime;
+  logAuditMetrics({
+    targetBranch,
+    changedFilesCount: changedCodeFiles.length,
+    testPassed,
+    durationMs,
+    scope: resolvedCmds.source,
+  });
+
+  if (!testPassed) {
+    console.error("\n🔄 OODA SELF-HEALING FEEDBACK LOG:");
+    console.error(failureLog.slice(-1500));
+    process.exit(1);
+  }
+
   console.log("\n🎉 JULES PR SELF-AUDIT PASSED SUCCESSFULLY!");
 }
 

package/scripts/jules-swarm.mjs

@@ -9,7 +9,7 @@ const tasksFile = process.argv[2];
 
 if (!tasksFile) {
   console.error("Usage: node scripts/jules-swarm.mjs <path-to-tasks.json>");
-  console.error('Format of tasks.json: [ { "id": "t1", "title": "Task 1", "prompt": "Description 1" } ]');
+  console.error('Format of tasks.json: [ { "id": "t1", "title": "Task 1", "prompt": "Description 1", "scope": ["src/moduleA/**"] } ]');
   process.exit(1);
 }
 
@@ -25,15 +25,61 @@ if (!Array.isArray(tasks)) {
   process.exit(1);
 }
 
-const MAX_CONCURRENT = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10);
-const STAGGER_MS = parseInt(process.env.JULES_SWARM_STAGGER_MS || "1500", 10);
+const parsedConcurrent = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10);
+const MAX_CONCURRENT = Number.isFinite(parsedConcurrent) && parsedConcurrent > 0 ? parsedConcurrent : 3;
 
-console.log(`🐝 Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT})...`);
+const parsedStagger = parseInt(process.env.JULES_SWARM_STAGGER_MS || "1500", 10);
+const STAGGER_MS = Number.isFinite(parsedStagger) && parsedStagger >= 0 ? parsedStagger : 1500;
+
+const USE_WORKTREES = process.env.JULES_USE_WORKTREES === "true";
+
+// Ensure root project path is preserved for history logs even when running in worktrees
+process.env.JULES_PROJECT_ROOT = process.cwd();
+
+console.log(`🐝 Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT}, Worktrees: ${USE_WORKTREES ? "ENABLED" : "DISABLED"})...`);
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+async function createWorktree(taskId) {
+  const slug = taskId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const wtDir = path.resolve(process.cwd(), `.agent/worktrees/${slug}`);
+  const branchName = `jules/${slug}`;
+  try {
+    if (!fs.existsSync(path.dirname(wtDir))) {
+      fs.mkdirSync(path.dirname(wtDir), { recursive: true });
+    }
+    await execFileAsync("git", ["worktree", "add", "-b", branchName, wtDir, "HEAD"]);
+    return { wtDir, branchName };
+  } catch (err) {
+    try {
+      await execFileAsync("git", ["worktree", "add", "--force", wtDir, "HEAD"]);
+      return { wtDir, branchName: null };
+    } catch (fallbackErr) {
+      console.warn(`⚠️ Failed to create worktree for ${taskId}:`, fallbackErr.message);
+      return null;
+    }
+  }
+}
+
+async function removeWorktree(wtDir, branchName) {
+  if (!wtDir) return;
+  try {
+    await execFileAsync("git", ["worktree", "remove", "--force", wtDir]);
+  } catch (err) {
+    console.warn(`⚠️ Failed to remove worktree at ${wtDir}:`, err.message);
+  }
+  if (branchName) {
+    try {
+      await execFileAsync("git", ["branch", "-D", branchName]);
+    } catch (err) {
+      console.warn(`⚠️ Failed to delete swarm branch ${branchName}:`, err.message);
+    }
+  }
+}
+
 async function runSwarm() {
   const results = [];
+  let hasFailure = false;
 
   for (let i = 0; i < tasks.length; i += MAX_CONCURRENT) {
     const batch = tasks.slice(i, i + MAX_CONCURRENT);
@@ -49,15 +95,39 @@ async function runSwarm() {
         console.log(`\n----------------------------------------`);
         console.log(`[${taskNum}/${tasks.length}] Dispatching Swarm Task: ${task.title} (${taskId})`);
 
+        let wtInfo = null;
+        let execCwd = process.cwd();
+
+        if (USE_WORKTREES) {
+          wtInfo = await createWorktree(taskId);
+          if (wtInfo?.wtDir) {
+            execCwd = wtInfo.wtDir;
+            console.log(`🌲 Isolated Task ${taskId} in Git Worktree: ${wtInfo.wtDir}`);
+          }
+        }
+
+        let effectivePrompt = task.prompt || "";
+        if (task.scope) {
+          const scopeStr = typeof task.scope === "string" ? task.scope : JSON.stringify(task.scope);
+          effectivePrompt += `\n\n[SCOPE LOCK]\nStrictly limit changes to designated bounds: ${scopeStr}`;
+        }
+
         try {
-          const { stdout } = await execFileAsync("node", ["scripts/jules-dispatch.mjs", task.title, task.prompt], {
+          const dispatchScript = path.resolve(process.cwd(), "scripts/jules-dispatch.mjs");
+          const { stdout } = await execFileAsync("node", [dispatchScript, task.title, effectivePrompt], {
+            cwd: execCwd,
             timeout: 15 * 60 * 1000,
+            env: { ...process.env, JULES_PROJECT_ROOT: process.env.JULES_PROJECT_ROOT },
           });
           if (stdout) console.log(stdout.trim());
           return { taskId, title: task.title, status: "SUCCESS" };
         } catch (error) {
           console.error(`⚠️ Failed task [${task.title}]:`, error.message);
           return { taskId, title: task.title, status: "FAILED", error: error.message };
+        } finally {
+          if (wtInfo?.wtDir) {
+            await removeWorktree(wtInfo.wtDir, wtInfo.branchName);
+          }
         }
       })
     );
@@ -65,8 +135,10 @@ async function runSwarm() {
     for (const r of batchResults) {
       if (r.status === "fulfilled") {
         results.push(r.value);
+        if (r.value.status === "FAILED") hasFailure = true;
       } else {
         results.push({ title: "Unknown Task", status: "FAILED", error: r.reason });
+        hasFailure = true;
       }
     }
 
@@ -81,7 +153,13 @@ async function runSwarm() {
   results.forEach((res) => {
     console.log(`  - [${res.status}] ${res.title}`);
   });
-}
 
-runSwarm();
+  if (hasFailure) {
+    process.exitCode = 1;
+  }
+}
 
+runSwarm().catch((err) => {
+  console.error("❌ Unhandled swarm rejection:", err);
+  process.exit(1);
+});