jules-orchestrator-kit 0.2.9 → 0.5.1

package/scripts/jules-nightly.mjs

@@ -6,7 +6,11 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { execFileSync } from "node:child_process";
+import { execFileSync, execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { log, logToHistory } from "./utils.mjs";
+
+const execFileAsync = promisify(execFile);
 
 const isDryRun = process.argv.includes("--dry-run");
 
@@ -50,67 +54,77 @@ const UNIVERSAL_NIGHTLY_TASKS = [
 ];
 
 function logNightlyHistory(taskResults, dryRun = false) {
-  const dateStr = new Date().toISOString().split("T")[0];
-  const historyDir = path.resolve(process.cwd(), ".agent/history");
-  if (!fs.existsSync(historyDir)) {
-    fs.mkdirSync(historyDir, { recursive: true });
-  }
-  const historyFile = path.join(historyDir, `${dateStr}-nightly-audit.md`);
-
   const modeLabel = dryRun ? "[DRY RUN]" : "[DISPATCHED]";
+  const dateStr = new Date().toISOString().split("T")[0];
   let content = `---\ntype: nightly_jules_audit\ntimestamp: "${new Date().toISOString()}"\nstatus: "${modeLabel}"\n---\n# Nightly Jules Maintenance Suite Audit - ${dateStr}\n\nSummary of automated audit dispatches:\n\n`;
 
   for (const res of taskResults) {
     content += `- **${res.title}** (\`${res.id}\`): ${res.status}\n`;
   }
 
-  fs.writeFileSync(historyFile, content, "utf-8");
-  console.log(`📝 Logged nightly audit summary to: ${path.relative(process.cwd(), historyFile)}`);
+  const historyFile = logToHistory(`nightly-audit.md`, content, "nightly");
+  log.success(`Logged nightly audit summary to: ${path.relative(process.cwd(), historyFile)}`);
+
+  if (process.env.GITHUB_STEP_SUMMARY) {
+    try {
+      fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, `\n${content}\n`, "utf-8");
+      log.success("Appended nightly audit summary to GitHub Step Summary.");
+    } catch (err) {
+      log.warn(`Failed to write to GITHUB_STEP_SUMMARY: ${err.message}`);
+    }
+  }
 }
 
-function dispatchTask(task, dryRun = false) {
+async function dispatchTask(task, dryRun = false) {
   const title = task.title;
   const fullPrompt = task.prompt;
 
-  console.log(`\n🌙 [${task.id}] Preparing task: '${title}'...`);
+  log.step("🌙", `[${task.id}] Preparing task: '${title}'...`);
 
   if (dryRun) {
-    console.log(`   [DRY RUN] Would dispatch task '${title}' to target repository`);
+    log.dim(`   [DRY RUN] Would dispatch task '${title}' to target repository`);
     return { id: task.id, title, status: "Dry Run OK" };
   }
 
   const dispatchScript = path.resolve(process.cwd(), "scripts/jules-dispatch.mjs");
   if (fs.existsSync(dispatchScript)) {
     try {
-      execFileSync("node", [dispatchScript, title, fullPrompt], { stdio: "inherit" });
+      await execFileAsync("node", [dispatchScript, title, fullPrompt]);
       return { id: task.id, title, status: "Dispatched successfully" };
     } catch (error) {
-      console.error(`❌ Failed to dispatch via jules-dispatch.mjs: ${error.message}`);
+      log.error(`Failed to dispatch via jules-dispatch.mjs: ${error.message}`);
       return { id: task.id, title, status: `Failed: ${error.message}` };
     }
   } else {
-    console.error(`❌ Dispatch script not found at ${dispatchScript}`);
+    log.error(`Dispatch script not found at ${dispatchScript}`);
     return { id: task.id, title, status: "Failed (Script missing)" };
   }
 }
 
-function main() {
-  console.log("==================================================");
-  console.log("🌙 Nightly Jules Maintenance & Audit Suite");
-  console.log("==================================================");
+async function main() {
+  log.header("Nightly Jules Maintenance & Audit Suite");
 
   if (isDryRun) {
-    console.log("🔍 Running in DRY RUN mode. No tasks will be dispatched.");
+    log.info("Running in DRY RUN mode. No tasks will be dispatched.");
   }
 
-  const results = [];
-  for (const task of UNIVERSAL_NIGHTLY_TASKS) {
-    const res = dispatchTask(task, isDryRun);
-    results.push(res);
-  }
+  const taskPromises = UNIVERSAL_NIGHTLY_TASKS.map((task) => dispatchTask(task, isDryRun));
+  const settled = await Promise.allSettled(taskPromises);
+  const results = settled.map((s, idx) =>
+    s.status === "fulfilled" ? s.value : { id: UNIVERSAL_NIGHTLY_TASKS[idx].id, title: UNIVERSAL_NIGHTLY_TASKS[idx].title, status: `Failed: ${s.reason}` }
+  );
 
   logNightlyHistory(results, isDryRun);
-  console.log("\n✅ Nightly Jules audit suite execution completed cleanly.");
+  const hasFailures = results.some((r) => r.status && (r.status.includes("Failed") || r.status.includes("error")));
+  if (hasFailures) {
+    log.error("Nightly Jules audit suite completed with task errors.");
+    process.exitCode = 1;
+  } else {
+    log.success("Nightly Jules audit suite execution completed cleanly.");
+  }
 }
 
-main();
+main().catch((err) => {
+  log.error(`Unhandled error in nightly suite: ${err.message}`);
+  process.exit(1);
+});

package/scripts/jules-queue-runner.mjs

@@ -1,7 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { log, ensureDir, sleep } from "./utils.mjs";
+
+const execFileAsync = promisify(execFile);
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -11,14 +15,15 @@ const queueDir = path.resolve(process.cwd(), ".agent/jules-queue");
 const completedDir = path.resolve(process.cwd(), ".agent/jules-queue/completed");
 const queueLogFile = path.join(queueDir, "queue.jsonl");
 
+const processingDir = path.resolve(process.cwd(), ".agent/jules-queue/.processing");
+
 if (!fs.existsSync(queueDir)) {
   console.error(`❌ Queue directory not found: ${queueDir}`);
   process.exit(1);
 }
 
-if (!fs.existsSync(completedDir)) {
-  fs.mkdirSync(completedDir, { recursive: true });
-}
+ensureDir(completedDir);
+ensureDir(processingDir);
 
 function logQueueState(file, status, error = null) {
   const entry = JSON.stringify({
@@ -35,35 +40,100 @@ const files = fs.readdirSync(queueDir).filter(
 );
 
 if (files.length === 0) {
-  console.log("ℹ️ No tasks found in the queue.");
+  log.info("No tasks found in the queue.");
   process.exit(0);
 }
 
-console.log(`🐝 Found ${files.length} tasks in the queue. Processing...`);
-
-files.forEach((file, index) => {
-  const filePath = path.join(queueDir, file);
-  // Generate title from filename (e.g. "TASK-001-auth-spec.md" -> "TASK 001 auth spec")
-  const title = file.replace(/\.md$/, "").replace(/-/g, " ");
-  
-  console.log(`\n----------------------------------------`);
-  console.log(`[${index + 1}/${files.length}] Dispatching queued task: ${title}`);
-  logQueueState(file, "RUNNING");
-  
+log.info(`🚀 Found ${files.length} tasks in the queue. Sending to Jules...`);
+
+const MAX_CONCURRENT = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10) || 3;
+
+const args = process.argv.slice(2);
+let paceMs = parseInt(process.env.JULES_PACE_MS || "500", 10);
+const paceIdx = args.indexOf("--pace-ms");
+if (paceIdx !== -1 && args[paceIdx + 1]) {
+  const parsed = parseInt(args[paceIdx + 1], 10);
+  if (Number.isFinite(parsed) && parsed >= 0) paceMs = parsed;
+}
+
+function safeMoveSync(src, dest) {
   try {
-    execFileSync("node", [dispatchScript, title, filePath], {
-      stdio: "inherit",
-    });
-    
-    // Move to completed
-    const destPath = path.join(completedDir, file);
-    fs.renameSync(filePath, destPath);
-    logQueueState(file, "COMPLETED");
-    console.log(`✅ Moved ${file} to completed/`);
-  } catch (error) {
-    logQueueState(file, "FAILED", error);
-    console.error(`⚠️ Failed to dispatch task [${title}]:`, error.message);
+    fs.renameSync(src, dest);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      fs.copyFileSync(src, dest);
+      fs.unlinkSync(src);
+    } else {
+      throw err;
+    }
   }
-});
+}
+
+async function safeMoveAsync(src, dest) {
+  try {
+    await fs.promises.rename(src, dest);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      await fs.promises.copyFile(src, dest);
+      await fs.promises.unlink(src);
+    } else {
+      throw err;
+    }
+  }
+}
+
+async function runQueue() {
+  for (let i = 0; i < files.length; i += MAX_CONCURRENT) {
+    const batch = files.slice(i, i + MAX_CONCURRENT);
+    await Promise.allSettled(
+      batch.map(async (file, bIdx) => {
+        if (bIdx > 0 && paceMs > 0) {
+          await sleep(bIdx * paceMs);
+        }
+        const index = i + bIdx;
+        const filePath = path.join(queueDir, file);
+        const processingPath = path.join(processingDir, file);
+        
+        // Atomic claim: move from queueDir to processingDir before dispatching
+        try {
+          safeMoveSync(filePath, processingPath);
+        } catch (claimErr) {
+          // Another runner already claimed this task file or file missing
+          return;
+        }
+
+        const title = file.replace(/\.md$/, "").replace(/-/g, " ");
+        
+        const content = fs.readFileSync(processingPath, "utf-8").trim();
+        if (!content || content.length < 10) {
+          log.warn(`Task file ${file} is empty or invalid. Skipping dispatch.`);
+          const destPath = path.join(completedDir, file);
+          await safeMoveAsync(processingPath, destPath);
+          logQueueState(file, "SKIPPED_INVALID");
+          return;
+        }
 
-console.log(`\n🎉 Queue processing complete!`);
+        log.step(`[${index + 1}/${files.length}]`, `🚀 Sending task to Jules: ${title}`);
+        logQueueState(file, "RUNNING");
+        
+        try {
+          await execFileAsync("node", [dispatchScript, title, processingPath]);
+          
+          const destPath = path.join(completedDir, file);
+          await safeMoveAsync(processingPath, destPath);
+          logQueueState(file, "DISPATCHED");
+          log.success(`Task dispatched successfully (Moved ${file} to completed/)`);
+        } catch (error) {
+          logQueueState(file, "FAILED", error);
+          log.error(`Failed to dispatch task [${title}]: ${error.message}`);
+        }
+      })
+    );
+  }
+  log.header("Queue processing complete!");
+}
+
+runQueue().catch(err => {
+  log.error(`Fatal queue error: ${err.message}`);
+  process.exit(1);
+});

package/scripts/jules-scan-todos.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Suggested Tasks Scanner for Google Jules
+ * Scans codebase for TODO, FIXME, HACK, and OPTIMIZE comments, ranks them by priority,
+ * and generates a tasks JSON file formatted for jules-swarm or jules-dispatch.
+ * Zero external dependencies.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { log, ensureDir } from "./utils.mjs";
+
+const IGNORE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".agent/history",
+  ".agent/worktrees",
+  ".agent/jules-queue/.processing",
+  ".agent/jules-queue/completed",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  "tmp_repos",
+  "tmp_repos2",
+  "tmp_repos3"
+]);
+
+const IGNORE_EXTS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".pdf",
+  ".zip", ".tar", ".gz", ".7z", ".mp4", ".webm", ".mp3", ".wav",
+  ".lock", ".map", ".bin", ".exe"
+]);
+
+const TAG_REGEX = /(?:(?:\/\/|\/\*|\*|#|<!--)\s*|\b)(FIXME|HACK|TODO|OPTIMIZE):?\s*(.+)$/;
+
+export function scanCodebaseForTodos(rootDir = process.cwd(), options = {}) {
+  const tasks = [];
+  const maxTasks = options.maxTasks || 100;
+
+  function walk(currentDir) {
+    if (tasks.length >= maxTasks) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (_) {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (tasks.length >= maxTasks) break;
+      const fullPath = path.join(currentDir, entry.name);
+      const relPath = path.relative(rootDir, fullPath).replace(/\\/g, "/");
+
+      if (entry.isDirectory()) {
+        const baseName = entry.name;
+        if (IGNORE_DIRS.has(baseName) || IGNORE_DIRS.has(relPath) || baseName.startsWith(".")) {
+          continue;
+        }
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (IGNORE_EXTS.has(ext)) 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)) {
+              continue;
+            }
+            const match = line.match(TAG_REGEX);
+            if (match) {
+              const tag = match[1].toUpperCase();
+              const text = match[2].trim();
+              const priority = (tag === "FIXME" || tag === "HACK") ? "HIGH" : "MEDIUM";
+              const taskId = `task-${tag.toLowerCase()}-${tasks.length + 1}`;
+
+              tasks.push({
+                id: taskId,
+                title: `${tag} in ${path.basename(relPath)}: ${text.slice(0, 50)}`,
+                priority,
+                prompt: `Resolve ${tag} comment in \`${relPath}\` at line ${lineIdx + 1}.\n\nComment: ${text}\n\nFile Context:\n\`\`\`\nLine ${lineIdx + 1}: ${line.trim()}\n\`\`\``,
+                file: relPath,
+                line: lineIdx + 1,
+                tag
+              });
+
+              if (tasks.length >= maxTasks) break;
+            }
+          }
+        } catch (_) {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  walk(rootDir);
+  return tasks;
+}
+
+export function runScanner() {
+  const args = process.argv.slice(2);
+  const isJson = args.includes("--json");
+
+  let outputPath = path.resolve(process.cwd(), ".agent/jules-queue/suggested-tasks.json");
+  const outIdx = args.indexOf("--output");
+  if (outIdx !== -1 && args[outIdx + 1]) {
+    outputPath = path.resolve(process.cwd(), args[outIdx + 1]);
+  }
+
+  log.header("Suggested Tasks Scanner");
+  log.info(`Scanning codebase for TODO, FIXME, HACK, and OPTIMIZE comments...`);
+
+  const tasks = scanCodebaseForTodos(process.cwd());
+
+  if (isJson) {
+    console.log(JSON.stringify(tasks, null, 2));
+    return;
+  }
+
+  log.success(`Scanned and found ${tasks.length} suggested task(s).`);
+
+  if (tasks.length === 0) {
+    log.info("Zero TODO/FIXME comments found in codebase!");
+    return;
+  }
+
+  ensureDir(path.dirname(outputPath));
+  fs.writeFileSync(outputPath, JSON.stringify(tasks, null, 2), "utf-8");
+
+  log.success(`Generated suggested tasks file: ${path.relative(process.cwd(), outputPath)}`);
+  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))) {
+  runScanner();
+}