jules-orchestrator-kit 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Orchestration kit for running Google Jules autonomous agents.",
   "repository": {
     "type": "git",

package/scripts/command-resolver.mjs

@@ -44,6 +44,23 @@ export function resolveProjectCommands(projectRoot = process.cwd()) {
     }
   }
 
+function detectPackageManager(root, pkg = {}) {
+  if (fs.existsSync(path.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(root, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(root, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path.join(root, "package-lock.json"))) return "npm";
+
+  const pm = pkg.packageManager;
+  if (typeof pm === "string") {
+    if (pm.startsWith("pnpm")) return "pnpm";
+    if (pm.startsWith("yarn")) return "yarn";
+    if (pm.startsWith("bun")) return "bun";
+    if (pm.startsWith("npm")) return "npm";
+  }
+
+  return "npm";
+}
+
   // 2. Dynamic Detector Strategy List
   const detectors = [
     {
@@ -59,20 +76,21 @@ export function resolveProjectCommands(projectRoot = process.cwd()) {
       resolve: (root) => {
         try {
           const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+          const pm = detectPackageManager(root, pkg);
           const scripts = pkg.scripts || {};
-          let verifyScript = scripts["check:all"] ? "npm run check:all" : "";
+          let verifyScript = scripts["check:all"] ? `${pm} run check:all` : "";
           if (!verifyScript) {
             const parts = [];
-            if (scripts.lint) parts.push("npm run lint");
-            else if (scripts.check) parts.push("npm run check");
-            if (scripts.test) parts.push("npm test");
+            if (scripts.lint) parts.push(`${pm} run lint`);
+            else if (scripts.check) parts.push(`${pm} run check`);
+            if (scripts.test) parts.push(`${pm} test`);
             verifyScript = parts.join(" && ");
           }
-          const buildScript = scripts.build ? "npm run build" : "";
+          const buildScript = scripts.build ? `${pm} run build` : "";
           return {
-            testCmd: verifyScript || "npm test",
+            testCmd: verifyScript || `${pm} test`,
             buildCmd: buildScript,
-            source: "package.json",
+            source: `package.json (${pm})`,
           };
         } catch (err) {
           console.warn("⚠️ Failed to parse package.json:", err.message);

package/scripts/jules-status.mjs

@@ -1,17 +1,18 @@
-#!/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";
+import { log, checkDailyBudget } from "./utils.mjs";
 
+const isJson = process.argv.includes("--json");
 const queueLogPath = path.resolve(process.cwd(), ".agent/jules-queue/queue.jsonl");
 
+const budgetInfo = checkDailyBudget();
+
 if (!fs.existsSync(queueLogPath)) {
-  log.info("Queue log is empty. No tasks have been dispatched yet.");
+  if (isJson) {
+    console.log(JSON.stringify({ queue: [], budget: budgetInfo }, null, 2));
+  } else {
+    log.info("Queue log is empty. No tasks have been dispatched yet.");
+  }
   process.exit(0);
 }
 
@@ -20,7 +21,11 @@ try {
   const lines = content.split("\n").filter(Boolean);
   
   if (lines.length === 0) {
-    log.info("Queue log is empty.");
+    if (isJson) {
+      console.log(JSON.stringify({ queue: [], budget: budgetInfo }, null, 2));
+    } else {
+      log.info("Queue log is empty.");
+    }
     process.exit(0);
   }
 
@@ -32,10 +37,11 @@ try {
       const entry = JSON.parse(line);
       if (entry.file) {
         statusMap.set(entry.file, {
+          file: entry.file,
           Task: entry.file.replace(/^TASK-\d+-/, "").replace(/\.md$/, ""),
           Status: entry.status,
-          Timestamp: new Date(entry.timestamp).toLocaleString(),
-          Error: entry.error || "-"
+          Timestamp: entry.timestamp,
+          Error: entry.error || null
         });
       }
     } catch (e) {
@@ -43,15 +49,26 @@ try {
     }
   }
 
-  if (statusMap.size === 0) {
+  const tasksList = Array.from(statusMap.values());
+
+  if (isJson) {
+    console.log(JSON.stringify({ queue: tasksList, budget: budgetInfo }, null, 2));
+    process.exit(0);
+  }
+
+  if (tasksList.length === 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()));
+  log.header(`JULES QUEUE STATUS (Budget: ${budgetInfo.used}/${budgetInfo.budget} sessions used)`);
+  console.table(tasksList.map(t => ({ Task: t.Task, Status: t.Status, Timestamp: new Date(t.Timestamp).toLocaleString(), Error: t.Error || "-" })));
 
 } catch (err) {
-  log.error(`Failed to read queue log: ${err.message}`);
+  if (isJson) {
+    console.log(JSON.stringify({ error: err.message }, null, 2));
+  } else {
+    log.error(`Failed to read queue log: ${err.message}`);
+  }
   process.exit(1);
 }

package/scripts/jules-swarm.mjs

@@ -194,8 +194,8 @@ async function runSwarm() {
             env: {
               ...process.env,
               JULES_PROJECT_ROOT: process.env.JULES_PROJECT_ROOT,
-              JULES_SLOT_INDEX: String(bIdx + 1),
-              JULES_SLOT_TOTAL: String(batch.length)
+              JULES_SLOT_INDEX: String(taskNum),
+              JULES_SLOT_TOTAL: String(tasks.length)
             },
           });
           if (stdout) log.dim(stdout.trim());

package/scripts/utils.mjs

@@ -165,10 +165,15 @@ export function redactSecrets(text) {
   return sanitized;
 }
 
-export function appendLedger(ledgerName, payload) {
-  const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state");
+export function getDailyLedgerPath(ledgerName = "sessions") {
+  const dateStr = new Date().toISOString().split("T")[0];
+  const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state", ledgerName);
   ensureDir(stateDir);
-  const ledgerPath = path.join(stateDir, `${ledgerName}.jsonl`);
+  return path.join(stateDir, `${dateStr}.jsonl`);
+}
+
+export function appendLedger(ledgerName, payload) {
+  const ledgerPath = getDailyLedgerPath(ledgerName);
   const entry = JSON.stringify({
     timestamp: new Date().toISOString(),
     ...payload
@@ -179,33 +184,30 @@ export function appendLedger(ledgerName, payload) {
 
 export function checkDailyBudget(maxSessions = 300) {
   const dateStr = new Date().toISOString().split("T")[0];
-  const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state");
-  const sessionsLedger = path.join(stateDir, "sessions.jsonl");
+  const ledgerPath = getDailyLedgerPath("sessions");
   
-  if (!fs.existsSync(sessionsLedger)) {
+  if (!fs.existsSync(ledgerPath)) {
     return { ok: true, used: 0, budget: maxSessions };
   }
 
-  const content = fs.readFileSync(sessionsLedger, "utf-8");
+  const content = fs.readFileSync(ledgerPath, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   
   let usedToday = 0;
   for (const line of lines) {
     try {
       const entry = JSON.parse(line);
-      if (
-        entry.timestamp &&
-        entry.timestamp.startsWith(dateStr) &&
-        (entry.event === "budget_reserved" || !entry.event)
-      ) {
+      if (entry.event === "budget_reserved" || !entry.event) {
         usedToday++;
       }
-    } catch (e) {
-      // Ignore
-    }
+    } catch (_) {}
   }
 
-  return { ok: usedToday < maxSessions, used: usedToday, budget: maxSessions };
+  return {
+    ok: usedToday < maxSessions,
+    used: usedToday,
+    budget: maxSessions
+  };
 }
 
 function sleepSync(ms) {