jules-orchestrator-kit 0.5.1 → 0.6.0

package/scripts/jules-create.mjs

@@ -19,8 +19,28 @@ const queueDir = path.resolve(process.cwd(), ".agent/jules-queue");
 ensureDir(queueDir);
 
 const safeTitle = taskTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
-const filesInQueue = fs.readdirSync(queueDir).filter(f => f.endsWith(".md") && f !== "README.md");
-const nextId = (filesInQueue.length + 1).toString().padStart(3, "0");
+
+let maxId = 0;
+const dirsToCheck = [queueDir, path.join(queueDir, ".processing"), path.join(queueDir, "completed")];
+
+for (const dir of dirsToCheck) {
+  try {
+    const files = fs.readdirSync(dir);
+    for (const f of files) {
+      if (f.startsWith("TASK-") && f.endsWith(".md")) {
+        const match = f.match(/^TASK-(\d+)-/);
+        if (match) {
+          const id = parseInt(match[1], 10);
+          if (id > maxId) maxId = id;
+        }
+      }
+    }
+  } catch (e) {
+    // Directory might not exist yet, that's fine
+  }
+}
+
+const nextId = (maxId + 1).toString().padStart(3, "0");
 const filename = `TASK-${nextId}-${safeTitle}.md`;
 const filepath = path.join(queueDir, filename);
 

package/scripts/jules-dispatch.mjs

@@ -5,7 +5,7 @@ import crypto from "node:crypto";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { resolveProjectCommands } from "./command-resolver.mjs";
-import { log, logToHistory } from "./utils.mjs";
+import { log, logToHistory, redactSecrets, appendLedger, checkDailyBudget, reserveDailyBudget } from "./utils.mjs";
 
 const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
 
@@ -41,42 +41,18 @@ function loadEnv() {
     }
   }
 }
-loadEnv();
-
-// 0.2 Pre-Flight Secret Redaction Gate (RegEx + Env Denylist)
-export function redactSecrets(text) {
-  if (!text) return "";
-  let sanitized = text;
-
-  // Redact active env secrets from denylist keys (*_KEY, *_SECRET, *_TOKEN, etc.)
-  for (const [envKey, envVal] of Object.entries(process.env)) {
-    if (
-      envVal &&
-      envVal.length >= 6 &&
-      /KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL|AUTH/i.test(envKey)
-    ) {
-      if (sanitized.includes(envVal)) {
-        sanitized = sanitized.split(envVal).join("[REDACTED_ENV_SECRET]");
-      }
-    }
-  }
+if (isMainModule) {
+  loadEnv();
+}
 
-  const patterns = [
-    /gh[pusr]_[a-zA-Z0-9]{36}/g,
-    /github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}/g,
-    /AKIA[0-9A-Z]{16}/g,
-    /AIzaSy[a-zA-Z0-9_\-]{33}/g,
-    /ya29\.[a-zA-Z0-9_\-]{20,}/g,
-    /Bearer\s+[a-zA-Z0-9\-\._~+\/]+=*/g,
-    /sk-(?:ant-api03-|proj-|svcacct-)[a-zA-Z0-9\-\_]{32,}/g,
-    /xox[baprs]-[a-zA-Z0-9\-]{10,}/g,
-    /eyJ[a-zA-Z0-9_\-]{10,}\.[a-zA-Z0-9_\-]{10,}\.[a-zA-Z0-9_\-]{10,}/g,
-    /-----BEGIN (?:RSA|OPENSSH|EC|PRIVATE) KEY-----[\s\S]*?-----END (?:RSA|OPENSSH|EC|PRIVATE) KEY-----/g,
-  ];
-  for (const pat of patterns) {
-    sanitized = sanitized.replace(pat, "[REDACTED_BY_SECURITY_GATE]");
+function parseRetryAfter(res) {
+  const raw = res.headers.get("Retry-After");
+  let waitSec = Number.parseInt(raw ?? "", 10);
+  if (!Number.isFinite(waitSec)) {
+    const asDate = raw ? Date.parse(raw) : NaN;
+    waitSec = Number.isFinite(asDate) ? Math.ceil((asDate - Date.now()) / 1000) : 5;
   }
-  return sanitized;
+  return Math.min(Math.max(waitSec, 0), 60);
 }
 
 const ASTRO_TRIGGER_RE = /\b(?:astro|components|pages|src\/.*\.astro)\b/i;
@@ -127,6 +103,7 @@ let fullPrompt = "";
 let historyFile = "";
 let tmpPayloadFile = "";
 let tmpDir = "";
+let taskKey = "";
 
 const ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 export function getAlphaRange(index, total) {
@@ -155,7 +132,7 @@ if (isMainModule) {
   if (fs.existsSync(possiblePath)) {
     try {
       const verifiedPath = path.resolve(process.cwd(), possiblePath);
-      if (verifiedPath.startsWith(process.cwd())) {
+      if (!path.relative(process.cwd(), verifiedPath).startsWith('..')) {
         const fd = fs.openSync(verifiedPath, "r");
         try {
           const stat = fs.fstatSync(fd);
@@ -212,10 +189,13 @@ if (isMainModule) {
   log.info(`Dispatching task to Google Jules: "${taskTitle}"...`);
   log.success(`Logged dispatch history to: ${path.relative(process.cwd(), historyFile)}`);
 
-  const payloadHash = crypto.createHash("sha256").update(taskTitle + Date.now()).digest("hex").slice(0, 12);
+  const hashInput = [repo || "repoless", taskTitle, rawPrompt, process.env.BASE_BRANCH || "main", dateStr].join("\u0000");
+  taskKey = crypto.createHash("sha256").update(hashInput).digest("hex").slice(0, 12);
+  
   tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "jules-payload-"));
-  tmpPayloadFile = path.join(tmpDir, `payload_${payloadHash}.json`);
+  tmpPayloadFile = path.join(tmpDir, `payload_${taskKey}.json`);
   fs.writeFileSync(tmpPayloadFile, JSON.stringify({ repo, title: taskTitle, prompt: fullPrompt }), { mode: 0o600 });
+
 }
 
 function cleanupTmp() {
@@ -237,6 +217,14 @@ async function executeDispatch() {
       return;
     }
 
+    const budgetLimit = process.env.JULES_DAILY_BUDGET ? parseInt(process.env.JULES_DAILY_BUDGET, 10) : 300;
+    const budgetCheck = reserveDailyBudget(budgetLimit, taskKey);
+    
+    if (!budgetCheck.ok) {
+      log.warn(`Daily budget exhausted or locked (${budgetCheck.used}/${budgetCheck.budget} sessions). Aborting dispatch.`);
+      process.exit(7); // Budget exhausted exit code
+    }
+
     if (apiKey && (repo || isRepoless)) {
       const payload = {
         title: taskTitle,
@@ -269,10 +257,20 @@ async function executeDispatch() {
               "X-Goog-Api-Key": apiKey,
               "Content-Type": "application/json"
             },
-            body: JSON.stringify(payload)
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(30000)
           });
 
-          if (res.ok || res.status === 429) {
+          if (res.status === 429) {
+            const waitSec = parseRetryAfter(res);
+            if (attempts < maxAttempts) {
+              log.warn(`⚠️ REST API Rate Limit Exceeded (HTTP 429). Retrying after ${waitSec}s...`);
+              await new Promise((r) => setTimeout(r, waitSec * 1000));
+              continue;
+            }
+          }
+
+          if (res.ok || res.status === 429 || res.status === 400 || res.status === 401) {
             break;
           }
 
@@ -300,8 +298,17 @@ async function executeDispatch() {
       }
 
       if (res.status === 429) {
-        log.error(`❌ Jules REST API Rate Limit Exceeded (HTTP 429). Will NOT fallback to CLI.`);
-        process.exit(1);
+        const waitSec = parseRetryAfter(res);
+        const err = new Error(`❌ Jules REST API Rate Limit Exceeded (HTTP 429). Retry after: ${waitSec}s`);
+        err.code = 1;
+        throw err;
+      }
+
+      if (res.status === 400 || res.status === 401) {
+        const errText = await res.text().catch(() => "");
+        const err = new Error(`❌ Jules REST API returned HTTP ${res.status}: ${errText}`);
+        err.code = 1;
+        throw err;
       }
 
       if (!res.ok) {
@@ -318,6 +325,7 @@ async function executeDispatch() {
         sessionId = sId || data.name || data.id || sessionId;
         log.success(`REST API Dispatch response: Session ${sessionId} created successfully.`);
         fs.appendFileSync(historyFile, `\n## Session\n- ID: \`${sessionId}\`\n`);
+        appendLedger("sessions", { event: "session_dispatched", task_key: taskKey, session_id: sessionId, status: "dispatched", task_title: taskTitle, mode: "api" });
       } catch (jsonErr) {
         log.warn("⚠️ Failed to parse REST API JSON response:", jsonErr.message);
       }
@@ -349,15 +357,17 @@ function dispatchViaCli(targetRepo, payloadFile, title) {
     log.step("💻", `Executing: jules ${args.join(" ")} (prompt passed via stdin)...`);
     execFileSync("jules", args, { input: promptToSend, stdio: ["pipe", "inherit", "inherit"] });
     log.success(`Successfully dispatched task "${title}" to Jules CLI.`);
+    appendLedger("sessions", { event: "session_dispatched", task_key: taskKey, session_id: "CLI", status: "dispatched", task_title: title, mode: "cli" });
   } catch (error) {
-    log.error(`Failed to dispatch task to Jules CLI: ${error.message}`);
-    process.exit(1);
+    const err = new Error(`Failed to dispatch task to Jules CLI: ${error.message}`);
+    err.code = 1;
+    throw err;
   }
 }
 
 if (isMainModule) {
   executeDispatch().catch((err) => {
     log.error(`❌ Fatal unhandled rejection in dispatch: ${err.message}`);
-    process.exit(1);
+    process.exit(err.code || 1);
   });
 }

package/scripts/jules-queue-runner.mjs

@@ -13,6 +13,7 @@ const dispatchScript = path.resolve(__dirname, "jules-dispatch.mjs");
 
 const queueDir = path.resolve(process.cwd(), ".agent/jules-queue");
 const completedDir = path.resolve(process.cwd(), ".agent/jules-queue/completed");
+const failedDir = path.resolve(process.cwd(), ".agent/jules-queue/failed");
 const queueLogFile = path.join(queueDir, "queue.jsonl");
 
 const processingDir = path.resolve(process.cwd(), ".agent/jules-queue/.processing");
@@ -23,8 +24,22 @@ if (!fs.existsSync(queueDir)) {
 }
 
 ensureDir(completedDir);
+ensureDir(failedDir);
 ensureDir(processingDir);
 
+// Recover any tasks left in .processing from a previous run or crash
+const STALE_MS = 15 * 60 * 1000;
+const processingFiles = fs.readdirSync(processingDir).filter(f => f.endsWith(".md"));
+for (const f of processingFiles) {
+  const procPath = path.join(processingDir, f);
+  try {
+    if (Date.now() - fs.statSync(procPath).mtimeMs < STALE_MS) continue;
+    const backToQueue = path.join(queueDir, f);
+    fs.renameSync(procPath, backToQueue);
+    log.info(`Recovered stale task ${f} from .processing/`);
+  } catch (_) {}
+}
+
 function logQueueState(file, status, error = null) {
   const entry = JSON.stringify({
     timestamp: new Date().toISOString(),
@@ -97,14 +112,21 @@ async function runQueue() {
         // Atomic claim: move from queueDir to processingDir before dispatching
         try {
           safeMoveSync(filePath, processingPath);
+          const now = new Date();
+          fs.utimesSync(processingPath, now, now);
         } catch (claimErr) {
           // Another runner already claimed this task file or file missing
           return;
         }
 
-        const title = file.replace(/\.md$/, "").replace(/-/g, " ");
+        let title = file.replace(/\.md$/, "").replace(/-/g, " ");
         
         const content = fs.readFileSync(processingPath, "utf-8").trim();
+        const h1Match = content.match(/^#\s+(.+)$/m);
+        if (h1Match && h1Match[1].trim()) {
+          title = h1Match[1].trim();
+        }
+        
         if (!content || content.length < 10) {
           log.warn(`Task file ${file} is empty or invalid. Skipping dispatch.`);
           const destPath = path.join(completedDir, file);
@@ -117,7 +139,7 @@ async function runQueue() {
         logQueueState(file, "RUNNING");
         
         try {
-          await execFileAsync("node", [dispatchScript, title, processingPath]);
+          await execFileAsync("node", [dispatchScript, title, processingPath], { timeout: 10 * 60 * 1000 });
           
           const destPath = path.join(completedDir, file);
           await safeMoveAsync(processingPath, destPath);
@@ -125,7 +147,30 @@ async function runQueue() {
           log.success(`Task dispatched successfully (Moved ${file} to completed/)`);
         } catch (error) {
           logQueueState(file, "FAILED", error);
-          log.error(`Failed to dispatch task [${title}]: ${error.message}`);
+          
+          let attempts = 0;
+          const attemptMatch = content.match(/^attempts:\s*(\d+)/m);
+          if (attemptMatch) attempts = parseInt(attemptMatch[1], 10);
+
+          if (attempts >= 2) {
+             const destPath = path.join(failedDir, file);
+             try { await safeMoveAsync(processingPath, destPath); } catch (_) {}
+             log.error(`Task [${title}] failed 3 times. Moved to failed/. Error: ${error.message}`);
+          } else {
+             let newContent = content;
+             if (attemptMatch) {
+                newContent = content.replace(/^attempts:\s*\d+/m, `attempts: ${attempts + 1}`);
+             } else if (content.startsWith("---\n")) {
+                newContent = content.replace(/^---\n/, `---\nattempts: 1\n`);
+             } else {
+                newContent = `---\nattempts: 1\n---\n\n` + content;
+             }
+             try {
+               fs.writeFileSync(processingPath, newContent);
+               await safeMoveAsync(processingPath, filePath);
+             } catch (_) {}
+             log.warn(`Task [${title}] failed. Re-queued (Attempt ${attempts + 1}). Error: ${error.message}`);
+          }
         }
       })
     );

package/scripts/jules-scan-todos.mjs

@@ -8,6 +8,7 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { log, ensureDir } from "./utils.mjs";
 
 const IGNORE_DIRS = new Set([
@@ -22,9 +23,8 @@ const IGNORE_DIRS = new Set([
   "coverage",
   ".next",
   ".turbo",
-  "tmp_repos",
-  "tmp_repos2",
-  "tmp_repos3"
+  "test",
+  "scripts/jules-scan-todos.mjs"
 ]);
 
 const IGNORE_EXTS = new Set([
@@ -61,15 +61,15 @@ export function scanCodebaseForTodos(rootDir = process.cwd(), options = {}) {
         walk(fullPath);
       } else if (entry.isFile()) {
         const ext = path.extname(entry.name).toLowerCase();
-        if (IGNORE_EXTS.has(ext)) continue;
+        if (IGNORE_EXTS.has(ext) || IGNORE_DIRS.has(relPath)) continue;
 
         try {
           const content = fs.readFileSync(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
             const line = lines[lineIdx];
-            // Ignore false positives from regex definitions, test assertions, or scanner string literals
-            if (/TAG_REGEX|assert\.|tasks\.some|log\.info\("Zero TODO|\/FIXME comments/i.test(line)) {
+            // Ignore false positives from regex definitions or scanner string literals
+            if (/TAG_REGEX|tasks\.some|log\.info\("Zero TODO|\/FIXME comments/i.test(line)) {
               continue;
             }
             const match = line.match(TAG_REGEX);
@@ -137,6 +137,6 @@ export function runScanner() {
   log.info(`Run \`npx jules-swarm ${path.relative(process.cwd(), outputPath)}\` to execute all tasks in parallel.`);
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.url.slice(7))) {
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
   runScanner();
 }