@yemi33/minions 0.1.58 → 0.1.60

package/engine/routing.js

@@ -0,0 +1,163 @@
+/**
+ * engine/routing.js — Agent routing, budget checks, and routing table parsing.
+ * Extracted from engine.js.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const shared = require('./shared');
+const queries = require('./queries');
+
+const { safeJson, safeRead } = shared;
+const { ENGINE_DIR, DISPATCH_PATH } = queries;
+
+const MINIONS_DIR = path.resolve(__dirname, '..');
+const ROUTING_PATH = path.join(MINIONS_DIR, 'routing.md');
+
+// Lazy require to avoid circular dependency with engine.js
+let _engine = null;
+function engine() { if (!_engine) _engine = require('../engine'); return _engine; }
+
+// ─── Temp Agents ─────────────────────────────────────────────────────────────
+
+const tempAgents = new Map(); // tempAgentId → { name, role, createdAt }
+
+// ─── Routing Parser ─────────────────────────────────────────────────────────
+
+function getRouting() {
+  return safeRead(ROUTING_PATH);
+}
+
+let _routingCache = null;
+let _routingCacheMtime = 0;
+
+function parseRoutingTable() {
+  const content = getRouting();
+  const routes = {};
+  const lines = content.split('\n');
+  let inTable = false;
+
+  for (const line of lines) {
+    if (line.startsWith('| Work Type')) { inTable = true; continue; }
+    if (line.startsWith('|---')) continue;
+    if (!inTable || !line.startsWith('|')) {
+      if (inTable && !line.startsWith('|')) inTable = false;
+      continue;
+    }
+    const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+    if (cells.length >= 3) {
+      routes[cells[0].toLowerCase()] = {
+        preferred: cells[1].toLowerCase(),
+        fallback: cells[2].toLowerCase()
+      };
+    }
+  }
+  return routes;
+}
+
+function getRoutingTableCached() {
+  let mtime = 0;
+  try { mtime = fs.statSync(ROUTING_PATH).mtimeMs; } catch { /* optional */ }
+  if (_routingCache && _routingCacheMtime === mtime) return _routingCache;
+  _routingCache = parseRoutingTable();
+  _routingCacheMtime = mtime;
+  return _routingCache;
+}
+
+// ─── Budget ──────────────────────────────────────────────────────────────────
+
+function getMonthlySpend(agentId) {
+  const metrics = safeJson(path.join(ENGINE_DIR, 'metrics.json')) || {};
+  const daily = metrics._daily || {};
+  const now = new Date();
+  const monthPrefix = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+  let total = 0;
+  for (const [date, data] of Object.entries(daily)) {
+    if (date.startsWith(monthPrefix)) {
+      total += (data.perAgent?.[agentId]?.costUsd || 0);
+    }
+  }
+  // Fallback: if no per-agent daily data, use cumulative (less accurate for monthly)
+  if (total === 0 && metrics[agentId]?.totalCostUsd) {
+    // Can't distinguish monthly from cumulative — treat as monthly estimate
+    // This path is for backward compat before per-agent daily tracking was added
+  }
+  return total;
+}
+
+function getAgentErrorRate(agentId) {
+  const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
+  const metrics = safeJson(metricsPath) || {};
+  const m = metrics[agentId];
+  if (!m) return 0;
+  const total = m.tasksCompleted + m.tasksErrored;
+  return total > 0 ? m.tasksErrored / total : 0;
+}
+
+function isAgentIdle(agentId) {
+  // Dispatch queue is the single source of truth for agent availability
+  const dispatch = safeJson(DISPATCH_PATH) || {};
+  return !(dispatch.active || []).some(d => d.agent === agentId);
+}
+
+// ─── Agent Resolution ────────────────────────────────────────────────────────
+
+// Track agents claimed during a single discovery pass to distribute work
+const _claimedAgents = new Set();
+function resetClaimedAgents() { _claimedAgents.clear(); }
+
+function resolveAgent(workType, config, authorAgent = null) {
+  const routes = getRoutingTableCached();
+  const route = routes[workType] || routes['implement'];
+  const agents = config.agents || {};
+
+  // Resolve _author_ token
+  let preferred = route.preferred === '_author_' ? authorAgent : route.preferred;
+  let fallback = route.fallback === '_author_' ? authorAgent : route.fallback;
+
+  const isAvailable = (id) => {
+    if (!agents[id] || !isAgentIdle(id) || _claimedAgents.has(id)) return false;
+    // Budget check — no budget means infinite (no limit)
+    const budget = agents[id].monthlyBudgetUsd;
+    if (budget && budget > 0) {
+      if (getMonthlySpend(id) >= budget) return false;
+    }
+    return true;
+  };
+
+  // Check preferred and fallback first (routing table order)
+  if (preferred && isAvailable(preferred)) { _claimedAgents.add(preferred); return preferred; }
+  if (fallback && isAvailable(fallback)) { _claimedAgents.add(fallback); return fallback; }
+
+  // Fall back to any idle agent, preferring lower error rates
+  const idle = Object.keys(agents)
+    .filter(id => id !== preferred && id !== fallback && isAvailable(id))
+    .sort((a, b) => getAgentErrorRate(a) - getAgentErrorRate(b));
+
+  if (idle[0]) { _claimedAgents.add(idle[0]); return idle[0]; }
+
+  // No idle configured agent — try temp agent if enabled
+  if (config.engine?.allowTempAgents) {
+    const tempId = `temp-${shared.uid()}`;
+    _claimedAgents.add(tempId);
+    tempAgents.set(tempId, { name: `Temp-${tempId.slice(5, 9)}`, role: 'Temporary Agent', createdAt: engine().ts() });
+    engine().log('info', `Spawning temp agent ${tempId} — all permanent agents busy`);
+    return tempId;
+  }
+
+  // No idle agent available — return null, item stays pending until next tick
+  return null;
+}
+
+module.exports = {
+  tempAgents,
+  getRouting,
+  parseRoutingTable,
+  getRoutingTableCached,
+  getMonthlySpend,
+  getAgentErrorRate,
+  isAgentIdle,
+  _claimedAgents,
+  resetClaimedAgents,
+  resolveAgent,
+};

package/engine/shared.js

@@ -38,24 +38,24 @@ function safeWrite(p, data) {
       } catch (e) {
         if (e.code === 'EPERM' && attempt < 4) {
           const delay = 50 * (attempt + 1); // 50, 100, 150, 200ms
-          try { const ab = new SharedArrayBuffer(4); Atomics.wait(new Int32Array(ab), 0, 0, delay); } catch { const start = Date.now(); while (Date.now() - start < delay) {} }
+          try { const ab = new SharedArrayBuffer(4); Atomics.wait(new Int32Array(ab), 0, 0, delay); } catch { /* fallback busy-wait */ const start = Date.now(); while (Date.now() - start < delay) {} }
           continue;
         }
         // Final attempt failed — fall through to direct write
       }
     }
     // All rename attempts failed — direct write as fallback (not atomic but won't lose data)
-    try { fs.unlinkSync(tmp); } catch {}
+    try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
     fs.writeFileSync(p, content);
   } catch (err) {
     // Even direct write failed — log and clean up tmp
     console.error(`[safeWrite] FAILED to write ${p}: ${err.message}`);
-    try { fs.unlinkSync(tmp); } catch {}
+    try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
   }
 }
 
 function safeUnlink(p) {
-  try { fs.unlinkSync(p); } catch {}
+  try { fs.unlinkSync(p); } catch { /* cleanup */ }
 }
 
 function sleepMs(ms) {
@@ -90,8 +90,8 @@ function withFileLock(lockPath, fn, {
   try {
     return fn();
   } finally {
-    try { fs.closeSync(fd); } catch {}
-    try { fs.unlinkSync(lockPath); } catch {}
+    try { fs.closeSync(fd); } catch { /* cleanup */ }
+    try { fs.unlinkSync(lockPath); } catch { /* cleanup */ }
   }
 }
 

package/engine/spawn-agent.js

@@ -45,7 +45,7 @@ if (!claudeBin) {
       const basedir = path.dirname(which.replace(/^\/c\//, 'C:/').replace(/\//g, path.sep));
       claudeBin = path.join(basedir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
     }
-  } catch {}
+  } catch { /* optional */ }
 }
 
 // Debug log
@@ -86,7 +86,7 @@ if (_sysPromptFileSupported === null) {
     const { spawnSync } = require('child_process');
     const testResult = spawnSync(process.execPath, [claudeBin, '--help'], { encoding: 'utf8', timeout: 10000, windowsHide: true });
     _sysPromptFileSupported = (testResult.stdout || '').includes('system-prompt-file');
-    try { fs.writeFileSync(capsCachePath, JSON.stringify({ claudeBin, sysPromptFile: _sysPromptFileSupported, checkedAt: new Date().toISOString() })); } catch {}
+    try { fs.writeFileSync(capsCachePath, JSON.stringify({ claudeBin, sysPromptFile: _sysPromptFileSupported, checkedAt: new Date().toISOString() })); } catch { /* optional */ }
   } catch { _sysPromptFileSupported = true; /* assume supported */ }
 }
 if (!isResume) try {
@@ -131,7 +131,7 @@ if (!isResume && Buffer.byteLength(sysPrompt) >= 30000) {
 proc.stdin.end();
 
 // Clean up temp file (only created for non-resume sessions)
-if (!isResume) setTimeout(() => { try { fs.unlinkSync(sysTmpPath); } catch {} }, 5000);
+if (!isResume) setTimeout(() => { try { fs.unlinkSync(sysTmpPath); } catch { /* cleanup */ } }, 5000);
 
 // Capture stderr separately for debugging
 let stderrBuf = '';