jules-orchestrator-kit 0.3.0 → 0.5.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();
+}

package/scripts/jules-self-audit.mjs

@@ -1,16 +1,19 @@
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import crypto from "node:crypto";
+import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { resolveWorkspaceExecutionBoundary } from "./command-resolver.mjs";
+import { log, logToHistory } from "./utils.mjs";
 
-function runCommand(cmd, ignoreError = false) {
+function runGitCommand(args, ignoreError = false) {
   try {
-    return execSync(cmd, { encoding: "utf-8" }).trim();
+    return execFileSync("git", args, { encoding: "utf-8" }).trim();
   } catch (error) {
     if (ignoreError) return "";
-    console.error(`❌ Command failed: ${cmd}`);
-    console.error(error.message);
+    log.error(`Git command failed: git ${args.join(" ")}`);
+    log.error(error.message);
     process.exit(1);
   }
 }
@@ -145,32 +148,45 @@ export function logAuditMetrics(metrics) {
 }
 
 export function runSelfAudit() {
-  console.log("🔍 Running Jules PR Self-Audit Gatekeeper...\n");
+  log.header("Running Jules PR Self-Audit Gatekeeper...");
 
   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);
+    log.error(`FATAL: Invalid BASE_BRANCH "${targetBranch}". Must match ^[a-zA-Z0-9._\\/-]+$`);
+    process.exit(2);
+  }
+  log.info(`Target Branch: ${targetBranch}`);
+
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+  } catch {
+    log.error("FATAL: git is not installed or not in PATH.");
+    process.exit(2);
   }
-  console.log(`🎯 Target Branch: ${targetBranch}`);
 
   if (process.env.CI) {
-    console.log("☁️ CI environment detected. Fetching merge-base history...");
-    runCommand(`git fetch origin ${targetBranch} --depth=100 || git fetch origin ${targetBranch} --unshallow`, true);
+    log.info("☁️ CI environment detected. Fetching merge-base history...");
+    runGitCommand(["fetch", "origin", targetBranch, "--depth=100"], true);
+    const tmpRef = runGitCommand(["rev-parse", "--verify", `origin/${targetBranch}`], true) ? `origin/${targetBranch}` : targetBranch;
+    const tmpMerge = runGitCommand(["merge-base", "HEAD", tmpRef], true);
+    if (!tmpMerge) {
+      log.warn("Shallow fetch failed to find merge-base, executing full unshallow...");
+      runGitCommand(["fetch", "origin", targetBranch, "--unshallow"], true);
+    }
   }
 
-  const mainRef = runCommand(`git rev-parse --verify origin/${targetBranch}`, true) ? `origin/${targetBranch}` : targetBranch;
-  const mergeBase = runCommand(`git merge-base HEAD ${mainRef}`, true);
+  const mainRef = runGitCommand(["rev-parse", "--verify", `origin/${targetBranch}`], true) ? `origin/${targetBranch}` : targetBranch;
+  const mergeBase = runGitCommand(["merge-base", "HEAD", mainRef], true);
 
   if (!mergeBase) {
-    console.error(`❌ FATAL: Could not compute merge-base with ${mainRef}. Make sure git history is unshallowed.`);
-    process.exit(1);
+    log.error(`FATAL: Could not compute merge-base with ${mainRef}. Make sure git history is unshallowed.`);
+    process.exit(2);
   }
 
-  console.log(`🔗 Merge-Base Hash: ${mergeBase}`);
+  log.info(`Merge-Base Hash: ${mergeBase}`);
 
-  const rawDiffFiles = runCommand(`git diff -z --name-only ${mergeBase}...HEAD`)
+  const rawDiffFiles = runGitCommand(["diff", "-z", "--name-only", `${mergeBase}...HEAD`])
     .split("\0")
     .map((f) => f.trim().replace(/^["']|["']$/g, ""))
     .filter(Boolean);
@@ -178,12 +194,12 @@ export function runSelfAudit() {
   const isBloatFile = (file) => /(\.lock|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|\.png|\.jpg|\.jpeg|\.pdf|\.min\.js|\.map)$/i.test(file);
   const changedCodeFiles = rawDiffFiles.filter((f) => !isBloatFile(f));
 
-  console.log(`\n📄 Modified Code Files (${changedCodeFiles.length} of ${rawDiffFiles.length} total changes):`);
-  changedCodeFiles.forEach((file) => console.log(`   - ${file}`));
+  log.info(`Modified Code Files (${changedCodeFiles.length} of ${rawDiffFiles.length} total changes):`);
+  changedCodeFiles.forEach((file) => log.dim(`   - ${file}`));
 
   // Fail closed: Load security config exclusively from base branch (mainRef).
   // Never fall back to working-tree config which an untrusted PR could craft.
-  const trustedConfig = runCommand(`git show ${mainRef}:.agent/jules.yml`, true);
+  const trustedConfig = runGitCommand(["show", `${mainRef}:.agent/jules.yml`], true);
   const forbiddenPatterns = loadForbiddenPatterns(trustedConfig);
   const allowedPatterns = loadAllowedPatterns(trustedConfig);
 
@@ -195,16 +211,16 @@ export function runSelfAudit() {
   });
 
   if (violations.length > 0) {
-    console.error("\n❌ RESTRICTED FILE VIOLATION DETECTED!");
-    console.error("Jules PR attempted to modify forbidden system files:");
-    violations.forEach((v) => console.error(`   - ${v}`));
-    process.exit(1);
+    log.error("RESTRICTED FILE VIOLATION DETECTED!");
+    log.error("Jules PR attempted to modify forbidden system files:");
+    violations.forEach((v) => log.error(`   - ${v}`));
+    process.exit(3);
   }
-  console.log("\n✅ Restricted File Boundary Check: PASSED");
+  log.success("Restricted File Boundary Check: PASSED");
 
-  console.log("\n🛠️ Resolving Dynamic Verification Suite...");
+  log.info("Resolving Dynamic Verification Suite...");
   const resolvedCmds = resolveWorkspaceExecutionBoundary(changedCodeFiles, process.cwd());
-  console.log(`📋 Discovered Execution Scope: ${resolvedCmds.source}`);
+  log.info(`Discovered Execution Scope: ${resolvedCmds.source}`);
 
   const startTime = Date.now();
   let testPassed = true;
@@ -221,23 +237,23 @@ export function runSelfAudit() {
   };
 
   if (resolvedCmds.testCmd) {
-    console.log(`▶ Running Test Verification: ${resolvedCmds.testCmd}`);
+    log.step("▶", `Running Test Verification: ${resolvedCmds.testCmd}`);
     if (!runVerification(resolvedCmds.testCmd)) {
       testPassed = false;
-      console.error(`❌ Test verification failed: ${resolvedCmds.testCmd}`);
+      log.error(`Test verification failed: ${resolvedCmds.testCmd}`);
     }
   }
 
   if (testPassed && resolvedCmds.buildCmd) {
-    console.log(`▶ Running Build Verification: ${resolvedCmds.buildCmd}`);
+    log.step("▶", `Running Build Verification: ${resolvedCmds.buildCmd}`);
     if (!runVerification(resolvedCmds.buildCmd)) {
       testPassed = false;
-      console.error(`❌ Build verification failed: ${resolvedCmds.buildCmd}`);
+      log.error(`Build verification failed: ${resolvedCmds.buildCmd}`);
     }
   }
 
   if (!resolvedCmds.testCmd && !resolvedCmds.buildCmd) {
-    console.log("ℹ️ No build or test scripts found. Running git status check.");
+    log.info("No build or test scripts found. Running git status check.");
     runCommand("git status");
   }
 
@@ -251,17 +267,150 @@ export function runSelfAudit() {
   });
 
   if (!testPassed) {
-    console.error("\n🔄 OODA SELF-HEALING FEEDBACK LOG:");
-    console.error(failureLog.slice(-1500));
-    process.exit(1);
+    log.error("OODA SELF-HEALING FEEDBACK LOG:");
+    log.dim(failureLog.slice(-1500));
+
+    // OODA Circuit Breaker: Fingerprint failure trace using SHA-256
+    const normalizedError = failureLog
+      .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z/g, "TIMESTAMP")
+      .replace(/0x[0-9a-fA-F]+/g, "HEX")
+      .replace(/\d+/g, "NUM")
+      .trim();
+    const errorHash = crypto.createHash("sha256").update(normalizedError).digest("hex");
+
+    const circuitFile = path.resolve(process.cwd(), ".agent/history/ooda-circuit.json");
+    let prevCircuit = { hash: "", count: 0 };
+    if (fs.existsSync(circuitFile)) {
+      try {
+        prevCircuit = JSON.parse(fs.readFileSync(circuitFile, "utf-8"));
+      } catch (_) {}
+    }
+
+    if (prevCircuit.hash === errorHash && prevCircuit.count >= 1) {
+      log.error("❌ OODA CIRCUIT BREAKER TRIPPED: Consecutive identical failure detected.");
+      log.error("Agent generated code with identical error trace twice in a row. Aborting auto-repair.");
+      try {
+        fs.writeFileSync(circuitFile, JSON.stringify({ hash: "", count: 0 }));
+      } catch (_) {}
+      process.exit(4);
+    }
+
+    try {
+      fs.writeFileSync(
+        circuitFile,
+        JSON.stringify({
+          hash: errorHash,
+          count: prevCircuit.hash === errorHash ? prevCircuit.count + 1 : 1,
+          updatedAt: new Date().toISOString()
+        })
+      );
+    } catch (_) {}
+
+    if (process.env.CI && !process.env.ALLOW_AUTO_REPAIR) {
+      log.error("CI environment detected and ALLOW_AUTO_REPAIR is not set. Failing fast to save CI minutes.");
+      process.exit(4);
+    }
+
+    let oodaRetries = 0;
+    try {
+      const history = execSync("git log -n 5 --format=%B", { encoding: "utf-8" });
+      const matches = history.match(/OODA Auto-Repair/gi);
+      if (matches) {
+        oodaRetries = matches.length;
+      }
+    } catch (e) {
+      // Ignorera git-fel här
+    }
+
+    if (oodaRetries < 3) {
+      log.info(`🛠️ Initiating OODA Auto-Repair (Attempt ${oodaRetries + 1}/3)...`);
+      const prompt = `OODA Auto-Repair Attempt ${oodaRetries + 1}\n\nThe verification suite failed with the following errors after the previous patch:\n\n\`\`\`\n${failureLog.slice(-1500)}\n\`\`\`\n\nPlease fix the errors so the verification passes.`;
+      
+      const dispatchScript = path.resolve(process.cwd(), "scripts/jules-dispatch.mjs");
+      try {
+        const env = { 
+          ...process.env, 
+          BASE_BRANCH: process.env.GITHUB_HEAD_REF || targetBranch 
+        };
+        execFileSync("node", [dispatchScript, "OODA Auto-Repair", prompt], {
+          stdio: "inherit",
+          env
+        });
+      } catch (dispatchErr) {
+        log.error(`Failed to trigger OODA repair dispatch: ${dispatchErr.message}`);
+      }
+    } else {
+      log.error("❌ OODA Auto-Repair exhausted maximum retries (3). Giving up.");
+    }
+    
+    process.exit(4);
   }
 
-  console.log("\n🎉 JULES PR SELF-AUDIT PASSED SUCCESSFULLY!");
+  log.success("🎉 JULES PR SELF-AUDIT PASSED SUCCESSFULLY!");
+}
+
+export function runPreflightSandbox() {
+  log.header("Initializing Pre-Flight Sandbox (Steril Simulering)...");
+  
+  const runId = crypto.randomBytes(4).toString("hex");
+  const sandboxDir = path.join(os.tmpdir(), `jules-preflight-${runId}`);
+  const tempArchive = path.join(os.tmpdir(), `jules-archive-${runId}.tar`);
+  
+  try {
+    log.step("[1/4]", `Skapar isolerad miljö i ${sandboxDir}...`);
+    fs.mkdirSync(sandboxDir, { recursive: true });
+    
+    execSync(`git archive HEAD -o "${tempArchive}"`);
+    execSync(`tar -xf "${tempArchive}" -C "${sandboxDir}"`);
+    
+    log.step("[2/4]", "Steriliserar miljövariabler...");
+    const sterileEnv = { ...process.env };
+    const stripKeys = ["DATABASE_URL", "NPM_TOKEN", "GITHUB_TOKEN", "GH_TOKEN", "AWS_ACCESS_KEY_ID", "STRIPE_TEST_KEY"];
+    for (const key of stripKeys) {
+      if (sterileEnv[key]) {
+        sterileEnv[key] = `mock-${key.toLowerCase()}`;
+      }
+    }
+    
+    log.step("[3/4]", "Löser beroenden i sandlådan...");
+    const resolvedCmds = resolveWorkspaceExecutionBoundary([], sandboxDir);
+    
+    if (resolvedCmds.testCmd || resolvedCmds.buildCmd) {
+      log.step("[4/4]", `Kör verifiering: ${resolvedCmds.testCmd || resolvedCmds.buildCmd}`);
+      execSync(resolvedCmds.testCmd || resolvedCmds.buildCmd, {
+        cwd: sandboxDir,
+        env: sterileEnv,
+        stdio: "inherit"
+      });
+      log.success("Pre-Flight Passed. Zero epistemic drift detected.");
+    } else {
+      log.info("Inga test/bygg-kommandon hittades för verifiering.");
+      log.success("Pre-Flight Passed (No-Op).");
+    }
+  } catch (err) {
+    log.error("\nPRE-FLIGHT MISSLYCKADES!");
+    log.error("Agenten skulle förmodligen krascha (The 5-Minute Drop-off) i Web UI på grund av saknade beroenden.");
+    log.error(err.message);
+    process.exit(1);
+  } finally {
+    try {
+      fs.rmSync(sandboxDir, { recursive: true, force: true });
+      if (fs.existsSync(tempArchive)) {
+        fs.rmSync(tempArchive, { force: true });
+      }
+    } catch (e) {
+      // Ignorera fel vid cleanup
+    }
+  }
 }
 
 // Execute when invoked directly from CLI
 if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
-  runSelfAudit();
+  if (process.argv.includes("--preflight")) {
+    runPreflightSandbox();
+  } else {
+    runSelfAudit();
+  }
 }
 
 

package/scripts/jules-status.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Jules Task Status Utility
+ * Parses the queue.jsonl file and renders a clean console.table
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { log } from "./utils.mjs";
+
+const queueLogPath = path.resolve(process.cwd(), ".agent/jules-queue/queue.jsonl");
+
+if (!fs.existsSync(queueLogPath)) {
+  log.info("Queue log is empty. No tasks have been dispatched yet.");
+  process.exit(0);
+}
+
+try {
+  const content = fs.readFileSync(queueLogPath, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  
+  if (lines.length === 0) {
+    log.info("Queue log is empty.");
+    process.exit(0);
+  }
+
+  // We only want the latest status for each task file
+  const statusMap = new Map();
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.file) {
+        statusMap.set(entry.file, {
+          Task: entry.file.replace(/^TASK-\d+-/, "").replace(/\.md$/, ""),
+          Status: entry.status,
+          Timestamp: new Date(entry.timestamp).toLocaleString(),
+          Error: entry.error || "-"
+        });
+      }
+    } catch (e) {
+      // Ignore malformed lines
+    }
+  }
+
+  if (statusMap.size === 0) {
+    log.info("No parseable task events found in queue.jsonl");
+    process.exit(0);
+  }
+
+  log.header("Jules Queue Status");
+  console.table(Array.from(statusMap.values()));
+
+} catch (err) {
+  log.error(`Failed to read queue log: ${err.message}`);
+  process.exit(1);
+}