jules-orchestrator-kit 0.8.0 → 0.8.5

package/scripts/jules-swarm.mjs

@@ -2,46 +2,75 @@ import { execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { log, sleep } from "./utils.mjs";
 
 const execFileAsync = promisify(execFile);
 
-const tasksFile = process.argv[2];
+const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
 
-if (!tasksFile) {
-  log.error("Usage: node scripts/jules-swarm.mjs <path-to-tasks.json>");
-  log.error('Format of tasks.json: [ { "id": "t1", "title": "Task 1", "prompt": "Description 1", "scope": ["src/moduleA/**"] } ]');
-  process.exit(1);
-}
+let tasks = [];
+let MAX_CONCURRENT = 3;
+let STAGGER_MS = 1500;
+let USE_WORKTREES = false;
 
-const resolvedPath = path.resolve(process.cwd(), tasksFile);
-if (!fs.existsSync(resolvedPath)) {
-  log.error(`Tasks file not found: ${resolvedPath}`);
-  process.exit(1);
-}
+const activeChildProcesses = new Set();
 
-const tasks = JSON.parse(fs.readFileSync(resolvedPath, "utf-8"));
-if (!Array.isArray(tasks)) {
-  log.error("tasks.json must contain a JSON array of task objects.");
-  process.exit(1);
-}
+if (isMainModule) {
+  process.on("SIGINT", () => {
+    log.dim("SIGINT received. Cleaning up active processes and Git worktrees...");
+    cleanupAllWorktreesSync();
+    process.exit(130);
+  });
+
+  process.on("SIGTERM", () => {
+    log.dim("SIGTERM received. Cleaning up active processes and Git worktrees...");
+    cleanupAllWorktreesSync();
+    process.exit(143);
+  });
+
+  const tasksFile = process.argv[2];
+
+  if (!tasksFile) {
+    log.error("Usage: node scripts/jules-swarm.mjs <path-to-tasks.json>");
+    log.error('Format of tasks.json: [ { "id": "t1", "title": "Task 1", "prompt": "Description 1", "scope": ["src/moduleA/**"] } ]');
+    process.exit(1);
+  }
+
+  const resolvedPath = path.resolve(process.cwd(), tasksFile);
+  if (!fs.existsSync(resolvedPath)) {
+    log.error(`Tasks file not found: ${resolvedPath}`);
+    process.exit(1);
+  }
 
-const parsedConcurrent = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10);
-const MAX_CONCURRENT = Number.isFinite(parsedConcurrent) && parsedConcurrent > 0 ? parsedConcurrent : 3;
+  tasks = JSON.parse(fs.readFileSync(resolvedPath, "utf-8"));
+  if (!Array.isArray(tasks)) {
+    log.error("tasks.json must contain a JSON array of task objects.");
+    process.exit(1);
+  }
 
-const parsedStagger = parseInt(process.env.JULES_SWARM_STAGGER_MS || "1500", 10);
-const STAGGER_MS = Number.isFinite(parsedStagger) && parsedStagger >= 0 ? parsedStagger : 1500;
+  const parsedConcurrent = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10);
+  MAX_CONCURRENT = Number.isFinite(parsedConcurrent) && parsedConcurrent > 0 ? parsedConcurrent : 3;
 
-const USE_WORKTREES = process.env.JULES_USE_WORKTREES === "true";
+  const parsedStagger = parseInt(process.env.JULES_SWARM_STAGGER_MS || "1500", 10);
+  STAGGER_MS = Number.isFinite(parsedStagger) && parsedStagger >= 0 ? parsedStagger : 1500;
 
-// Ensure root project path is preserved for history logs even when running in worktrees
-process.env.JULES_PROJECT_ROOT = process.cwd();
+  USE_WORKTREES = process.env.JULES_USE_WORKTREES === "true";
 
-log.info(`Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT}, Worktrees: ${USE_WORKTREES ? "ENABLED" : "DISABLED"})...`);
+  process.env.JULES_PROJECT_ROOT = process.cwd();
+  log.info(`Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT}, Worktrees: ${USE_WORKTREES ? "ENABLED" : "DISABLED"})...`);
+}
 
 const activeWorktrees = new Set();
 
 function cleanupAllWorktreesSync() {
+  for (const child of Array.from(activeChildProcesses)) {
+    try {
+      child.kill("SIGTERM");
+    } catch (_) {}
+  }
+  activeChildProcesses.clear();
+
   for (const item of Array.from(activeWorktrees)) {
     if (item.wtDir && fs.existsSync(item.wtDir)) {
       try {
@@ -84,17 +113,7 @@ function reapOrphanedWorktrees() {
   } catch (_) {}
 }
 
-process.on("SIGINT", () => {
-  log.dim("SIGINT received. Cleaning up active Git worktrees...");
-  cleanupAllWorktreesSync();
-  process.exit(130);
-});
 
-process.on("SIGTERM", () => {
-  log.dim("SIGTERM received. Cleaning up active Git worktrees...");
-  cleanupAllWorktreesSync();
-  process.exit(143);
-});
 
 async function createWorktree(taskId) {
   const slug = taskId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
@@ -149,7 +168,73 @@ async function removeWorktree(wtDir, branchName) {
   }
 }
 
+export function buildSyncManifest(tasksList = []) {
+  const reservations = tasksList.map((t, idx) => ({
+    id: t.id || `task-${idx + 1}`,
+    title: t.title || "",
+    scope: t.scope || null,
+    reservedAt: new Date().toISOString()
+  }));
+
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    totalTasks: tasksList.length,
+    reservations
+  };
+}
+
+export async function pushReservationManifest(manifest, projectRoot = process.cwd()) {
+  const agentDir = path.resolve(projectRoot, ".agent");
+  const manifestPath = path.join(agentDir, "sync-manifest.json");
+
+  try {
+    await fs.promises.mkdir(agentDir, { recursive: true });
+    await fs.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+
+    const allowRemotePush = process.env.JULES_SWARM_REMOTE_PUSH === "true" || process.env.JULES_SWARM_REMOTE_PUSH === "1";
+    const isDryRun = process.env.JULES_DRY_RUN === "true" || process.env.JULES_DRY_RUN === "1";
+
+    if (isDryRun) {
+      log.dim("[DRY RUN] Generated .agent/sync-manifest.json reservation manifest (git push skipped).");
+      return { status: "DRY_RUN", path: manifestPath };
+    }
+
+    if (!allowRemotePush) {
+      log.info(`Generated local swarm reservation manifest: ${manifestPath}`);
+      return { status: "SAVED_LOCAL", path: manifestPath };
+    }
+
+    try {
+      await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: projectRoot });
+    } catch {
+      log.dim("Not in a git repository. Skipped git push for sync manifest.");
+      return { status: "SKIPPED_NOT_GIT", path: manifestPath };
+    }
+
+    try {
+      const manifestBranch = `jules/swarm-manifest-${Date.now()}`;
+      await execFileAsync("git", ["add", manifestPath], { cwd: projectRoot });
+      await execFileAsync("git", ["commit", "-m", "chore(jules): reservation sync manifest [skip ci]"], { cwd: projectRoot });
+      log.info(`Committed reservation manifest to Git. Pushing to origin/${manifestBranch}...`);
+
+      await execFileAsync("git", ["push", "origin", `HEAD:${manifestBranch}`], { cwd: projectRoot });
+      log.success(`Pushed reservation manifest to origin/${manifestBranch}.`);
+      return { status: "PUSHED", branch: manifestBranch, path: manifestPath };
+    } catch (gitErr) {
+      log.warn(`⚠️ Git push reservation manifest failed (${gitErr.message}). Continuing local dispatch...`);
+      return { status: "FAILED_GIT", error: gitErr.message, path: manifestPath };
+    }
+  } catch (err) {
+    log.warn(`⚠️ Failed to build or save sync manifest: ${err.message}`);
+    return { status: "ERROR", error: err.message };
+  }
+}
+
 async function runSwarm() {
+  const manifest = buildSyncManifest(tasks);
+  await pushReservationManifest(manifest);
+
   if (USE_WORKTREES) {
     reapOrphanedWorktrees();
   }
@@ -188,7 +273,7 @@ async function runSwarm() {
 
         try {
           const dispatchScript = path.resolve(process.cwd(), "scripts/jules-dispatch.mjs");
-          const { stdout } = await execFileAsync("node", [dispatchScript, task.title, effectivePrompt], {
+          const child = execFile("node", [dispatchScript, task.title, effectivePrompt], {
             cwd: execCwd,
             timeout: 15 * 60 * 1000,
             env: {
@@ -198,6 +283,18 @@ async function runSwarm() {
               JULES_SLOT_TOTAL: String(tasks.length)
             },
           });
+          activeChildProcesses.add(child);
+
+          const { stdout } = await new Promise((resolve, reject) => {
+            let out = "";
+            child.stdout?.on("data", (data) => { out += data; });
+            child.on("error", reject);
+            child.on("close", (code) => {
+              activeChildProcesses.delete(child);
+              if (code === 0) resolve({ stdout: out });
+              else reject(new Error(`Process exited with code ${code}`));
+            });
+          });
           if (stdout) log.dim(stdout.trim());
           return { taskId, title: task.title, status: "SUCCESS" };
         } catch (error) {
@@ -237,7 +334,9 @@ async function runSwarm() {
   }
 }
 
-runSwarm().catch((err) => {
-  log.error(`Unhandled swarm rejection: ${err.message}`);
-  process.exit(1);
-});
+if (isMainModule) {
+  runSwarm().catch((err) => {
+    log.error(`Unhandled swarm rejection: ${err.message}`);
+    process.exit(1);
+  });
+}

package/scripts/lock-manager.mjs

@@ -13,9 +13,11 @@
 
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const MANIFEST_PATH = path.join(process.cwd(), '.agent', 'sync-manifest.json');
+const MANIFEST_PATH = path.join(process.cwd(), '.agent', 'file-locks.json');
 const TTL_MS = 20 * 60 * 1000; // 20 minutes
+const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
 
 async function readManifest() {
   try {
@@ -76,8 +78,11 @@ function cleanExpiredLocks(manifest) {
   return changed;
 }
 
-async function acquireLocks(agentName, taskId, files) {
+async function acquireLocks(agentName, taskId, files, isUnattended = false) {
   await withManifestLock(async () => {
+    if (isUnattended) {
+      console.log(`[lock-manager] Operating in unattended mode for task ${taskId}`);
+    }
     const manifest = await readManifest();
   cleanExpiredLocks(manifest);
   
@@ -148,20 +153,20 @@ async function main() {
     const agentName = args[1];
     const taskId = args[2];
     const unattendedIndex = args.indexOf('--unattended');
-    
+    const isUnattended = unattendedIndex !== -1;
     let files = [];
-    if (unattendedIndex !== -1) {
+    if (isUnattended) {
        files = args.slice(3, unattendedIndex).concat(args.slice(unattendedIndex + 1));
     } else {
        files = args.slice(3);
     }
     
     if (!agentName || !taskId || files.length === 0) {
-      console.error('Usage: acquire <agent_name> <task_id> <file_paths...>');
+      console.error('Usage: acquire <agent_name> <task_id> <file_paths...> [--unattended]');
       process.exit(1);
     }
     
-    await acquireLocks(agentName, taskId, files);
+    await acquireLocks(agentName, taskId, files, isUnattended);
   } else if (command === 'release') {
     const taskId = args[1];
     if (!taskId) {
@@ -175,7 +180,9 @@ async function main() {
   }
 }
 
-main().catch(err => {
-  console.error('Unhandled error:', err);
-  process.exit(1);
-});
+if (isMainModule) {
+  main().catch(err => {
+    console.error('Unhandled error:', err);
+    process.exit(1);
+  });
+}

package/scripts/utils.mjs

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { execFileSync } from "node:child_process";
+import os from "node:os";
+
 import { promisify } from "node:util";
 
 // ANSI colors for standardizing CLI DX
@@ -29,6 +30,28 @@ export const log = {
 
 export const sleep = promisify(setTimeout);
 
+export function loadEnv(customCwd = process.cwd()) {
+  const envPath = path.resolve(customCwd, ".env");
+  if (fs.existsSync(envPath)) {
+    const lines = fs.readFileSync(envPath, "utf-8").split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx > 0) {
+        const key = trimmed.slice(0, eqIdx).trim().replace(/^export\s+/, "");
+        let val = trimmed.slice(eqIdx + 1).trim();
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+          val = val.slice(1, -1);
+        }
+        if (!process.env[key]) {
+          process.env[key] = val;
+        }
+      }
+    }
+  }
+}
+
 export function ensureDir(dirPath) {
   try {
     if (!fs.existsSync(dirPath)) {
@@ -37,11 +60,13 @@ export function ensureDir(dirPath) {
   } catch (error) {
     log.error(`EACCES: Insufficient permissions or failed to create directory: ${dirPath}`);
     log.error(error.message);
-    process.exit(1);
+    const err = new Error(`Failed to create directory ${dirPath}: ${error.message}`);
+    err.code = "EACCES";
+    throw err;
   }
 }
 
-export function logToHistory(filename, content, type = "audit") {
+export function logToHistory(filename, content) {
   const dateStr = new Date().toISOString().split("T")[0];
   const historyDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/history");
   ensureDir(historyDir);
@@ -110,9 +135,19 @@ export const HIGH_CONFIDENCE_PATTERNS = [
   /\bgh[pousr]_[a-zA-Z0-9]{36,}\b/g,
   /\bgithub_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}\b/g,
   /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bASIA[0-9A-Z]{16}\b/g,
   /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\bPuTTY-User-Key-File-\d+:/g,
   /\bnpm_[a-zA-Z0-9]{36}\b/g,
   /\bsk_live_[0-9a-zA-Z]{24,}\b/g,
+  /\bsbp_[a-zA-Z0-9]{40,}\b/g,
+  /\bhf_[a-zA-Z0-9]{34,}\b/g,
+  /\bGOCSPX-[a-zA-Z0-9_-]{28}\b/g,
+  /\bglpat-[a-zA-Z0-9_-]{20,}\b/g,
+  /\bdop_v1_[a-f0-9]{64}\b/g,
+  /\bSG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}\b/g,
+  /\bwhsec_[a-zA-Z0-9]{24,}\b/g,
+  /\bshpat_[a-f0-9]{32}\b/g,
 ];
 
 export const LOW_CONFIDENCE_PATTERNS = [
@@ -121,16 +156,23 @@ export const LOW_CONFIDENCE_PATTERNS = [
   /\bBearer\s+[a-zA-Z0-9\-\._~+\/]+=*/g,
   /\bsk-(?:ant-api03-|proj-|svcacct-)[a-zA-Z0-9\-\_]{32,}\b/g,
   /\bxox[baprs]-[a-zA-Z0-9\-]{10,}\b/g,
+  /\bxapp-\d+-[a-zA-Z0-9_]+-\d+-[a-zA-Z0-9_]+\b/g,
   /\beyJ[a-zA-Z0-9_\-]{10,}\.[a-zA-Z0-9_\-]{10,}\.[a-zA-Z0-9_\-]{10,}\b/g,
   /\b(?:rk|pk)_(?:live|test)_[0-9a-zA-Z]{24,}\b/g,
   /\bsk_test_[0-9a-zA-Z]{24,}\b/g,
+  /https:\/\/hooks\.slack\.com\/services\/T[a-zA-Z0-9_]+\/B[a-zA-Z0-9_]+\/[a-zA-Z0-9_]+/g,
+  /\b[a-z][a-z0-9+.-]*:\/\/[^:\s]+:[^@\s]+@[^:\s\/]+/gi,
+  /\bAuthorization:\s*Basic\s+[A-Za-z0-9+/=]{16,}/gi,
+  /[?&]sig=[A-Za-z0-9%+/=]{20,}/g,
 ];
 
 export function hasHighConfidenceSecret(text) {
   if (!text) return false;
   return HIGH_CONFIDENCE_PATTERNS.some((pat) => {
     pat.lastIndex = 0;
-    return pat.test(text);
+    const res = pat.test(text);
+    pat.lastIndex = 0;
+    return res;
   });
 }
 
@@ -138,7 +180,9 @@ export function hasLowConfidenceSecret(text) {
   if (!text) return false;
   return LOW_CONFIDENCE_PATTERNS.some((pat) => {
     pat.lastIndex = 0;
-    return pat.test(text);
+    const res = pat.test(text);
+    pat.lastIndex = 0;
+    return res;
   });
 }
 
@@ -150,7 +194,7 @@ export function redactSecrets(text) {
     if (
       envVal &&
       (envVal.length >= 20 || calculateShannonEntropy(envVal) > 3.6) &&
-      /KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL|AUTH/i.test(envKey)
+      /KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL|AUTH|PASSPHRASE|URL|URI|DSN|CONNECTION|ACCOUNT/i.test(envKey)
     ) {
       if (sanitized.includes(envVal)) {
         sanitized = sanitized.split(envVal).join("[REDACTED_ENV_SECRET]");
@@ -160,15 +204,103 @@ export function redactSecrets(text) {
 
   const allPatterns = [...HIGH_CONFIDENCE_PATTERNS, ...LOW_CONFIDENCE_PATTERNS];
   for (const pat of allPatterns) {
+    pat.lastIndex = 0;
     sanitized = sanitized.replace(pat, "[REDACTED_BY_SECURITY_GATE]");
+    pat.lastIndex = 0;
   }
   return sanitized;
 }
 
+export function anonymizePii(text) {
+  if (!text) return "";
+  let sanitized = text;
+
+  // Mask email addresses
+  sanitized = sanitized.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[REDACTED_EMAIL]");
+
+  // Mask IPv4 addresses (excluding 0.0.0.0, 127.0.0.1, 10.x, 192.168.x if needed, or mask all)
+  sanitized = sanitized.replace(/\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g, (ip) => {
+    if (ip === "127.0.0.1" || ip === "0.0.0.0") return ip;
+    return "[REDACTED_IP]";
+  });
+
+  // Mask phone numbers (formatted with international prefix or standard delimiters)
+  sanitized = sanitized.replace(/(?:(?:\+\d{1,3}[\s-]?)|\b)\(?\d{2,4}\)?(?:[\s-]?\d{2,4}){2,4}\b/g, (phone) => {
+    const digitsOnly = phone.replace(/\D/g, "");
+    if (digitsOnly.length >= 7 && digitsOnly.length <= 15) {
+      return "[REDACTED_PHONE]";
+    }
+    return phone;
+  });
+
+  return sanitized;
+}
+
+export function verifyLedgerIntegrity(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { ok: false, count: 0, reason: "File not found" };
+  }
+  try {
+    const rawContent = fs.readFileSync(filePath, "utf-8");
+    const content = rawContent.replace(/\r\n/g, "\n").trim();
+    if (!content) return { ok: true, count: 0 };
+
+    const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+    let previousHash = "";
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch (jsonErr) {
+        return { ok: false, count: i, reason: `Corrupted JSON record at line ${i + 1}: ${jsonErr.message}` };
+      }
+
+      if (!record.event || !record.timestamp) {
+        return { ok: false, count: i, reason: `Missing mandatory event/timestamp fields at line ${i + 1}` };
+      }
+
+      const lineHash = crypto.createHash("sha256").update(previousHash + line).digest("hex");
+      previousHash = lineHash;
+    }
+
+    return { ok: true, count: lines.length, lastHash: previousHash };
+  } catch (err) {
+    return { ok: false, count: 0, reason: err.message };
+  }
+}
+
+export function pruneOldLedgers(stateDir, retentionDays = 30) {
+  try {
+    if (!fs.existsSync(stateDir)) return;
+    const now = Date.now();
+    const maxAgeMs = retentionDays * 24 * 60 * 60 * 1000;
+    const files = fs.readdirSync(stateDir);
+    files.forEach((file) => {
+      if (file.endsWith(".jsonl")) {
+        const filePath = path.join(stateDir, file);
+        const stat = fs.statSync(filePath);
+        if (now - stat.mtimeMs > maxAgeMs) {
+          try { fs.unlinkSync(filePath); } catch (_) {}
+        }
+      }
+    });
+  } catch (_) {}
+}
+
+export function getLocalDateString(date = new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
 export function getDailyLedgerPath(ledgerName = "sessions") {
-  const dateStr = new Date().toISOString().split("T")[0];
+  const dateStr = getLocalDateString();
   const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state", ledgerName);
   ensureDir(stateDir);
+  pruneOldLedgers(stateDir, 30);
   return path.join(stateDir, `${dateStr}.jsonl`);
 }
 
@@ -183,7 +315,6 @@ export function appendLedger(ledgerName, payload) {
 }
 
 export function checkDailyBudget(maxSessions = 300) {
-  const dateStr = new Date().toISOString().split("T")[0];
   const ledgerPath = getDailyLedgerPath("sessions");
   
   if (!fs.existsSync(ledgerPath)) {
@@ -275,3 +406,18 @@ export function reserveDailyBudget(maxSessions = 300, taskKey = "") {
     }
   }
 }
+
+export function getIsolatedCacheDir() {
+  const customCache = process.env.JULES_CACHE_DIR;
+  if (customCache) {
+    return path.resolve(customCache);
+  }
+  return path.join(os.homedir(), ".cache", "jules-orchestrator-kit");
+}
+
+export function ensureSdkCacheIsolation() {
+  const cacheDir = getIsolatedCacheDir();
+  ensureDir(cacheDir);
+  process.env.JULES_CACHE_DIR = cacheDir;
+  return cacheDir;
+}

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,63 +0,0 @@
-name: Bug Report
-description: Create a report to help us improve Jules Orchestrator Kit
-title: "[BUG] "
-labels: ["bug"]
-assignees: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this bug report!
-  - type: input
-    id: version
-    attributes:
-      label: "Node.js Version"
-      description: "What version of Node.js are you using? (e.g. v20.11.0)"
-      placeholder: "v20.x"
-    validations:
-      required: true
-  - type: dropdown
-    id: package_manager
-    attributes:
-      label: "Package Manager"
-      description: "Which package manager are you using?"
-      options:
-        - npm
-        - pnpm
-        - yarn
-        - bun
-    validations:
-      required: true
-  - type: dropdown
-    id: execution_mode
-    attributes:
-      label: "Execution Mode"
-      description: "How are you running Jules?"
-      options:
-        - API Mode (JULES_API_KEY set)
-        - CLI Mode (Local jules binary)
-    validations:
-      required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: "Bug Description"
-      description: "A clear and concise description of what the bug is."
-      placeholder: "When I run npm run jules:queue..."
-    validations:
-      required: true
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: "Steps to Reproduce"
-      description: "Steps to reproduce the behavior."
-      placeholder: "1. Go to...\n2. Click on...\n3. See error"
-    validations:
-      required: true
-  - type: textarea
-    id: expected
-    attributes:
-      label: "Expected Behavior"
-      description: "A clear and concise description of what you expected to happen."
-    validations:
-      required: true

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,34 +0,0 @@
-name: Feature Request
-description: Suggest an idea for Jules Orchestrator Kit
-title: "[FEATURE] "
-labels: ["enhancement"]
-assignees: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for suggesting a new feature!
-  - type: textarea
-    id: description
-    attributes:
-      label: "Is your feature request related to a problem? Please describe."
-      description: "A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]"
-      placeholder: "..."
-    validations:
-      required: true
-  - type: textarea
-    id: solution
-    attributes:
-      label: "Describe the solution you'd like"
-      description: "A clear and concise description of what you want to happen."
-      placeholder: "..."
-    validations:
-      required: true
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: "Describe alternatives you've considered"
-      description: "A clear and concise description of any alternative solutions or features you've considered."
-      placeholder: "..."
-    validations:
-      required: false