bus-agent 2.3.0

package/lib/orchestrator.js

@@ -0,0 +1,426 @@
+/**
+ * CoCo Orchestrator — Auto-Reply Rules + Agent Workflows
+ *
+ * Two systems in one:
+ *
+ * 1. Auto-Reply Rules: When message matches pattern → forward/reply
+ * 2. Agent Orchestrator: Pipeline of agents, each step feeds into next
+ */
+const fs = require('fs');
+const path = require('path');
+
+const RULES_FILE = path.join(__dirname, '..', '.bus', 'auto-reply-rules.json');
+const WORKFLOWS_FILE = path.join(__dirname, '..', '.bus', 'workflows.json');
+
+class Orchestrator {
+  constructor(bus) {
+    this.bus = bus;
+    this._rules = [];
+    this._workflows = [];
+    this._reload();
+  }
+
+  _reload() {
+    this._rules = this._loadJson(RULES_FILE, []);
+    this._workflows = this._loadJson(WORKFLOWS_FILE, []);
+    this._running = false;
+    this._timer = null;
+    this._lastCheck = {};
+  }
+
+  // ═══════════════════════════════════════════════════
+  //  PART 1: Auto-Reply Rules
+  // ═══════════════════════════════════════════════════
+
+  addRule(rule) {
+    /**
+     * rule = {
+     *   id: 'review-code',           // optional, auto-generated
+     *   description: 'Forward code reviews to agent-reviewer',
+     *   match: {
+     *     from: 'andul',             // sender filter (optional, * = any)
+     *     contains: 'code review',   // text in message (optional)
+     *     regex: 'PR #\\d+',         // regex pattern (optional)
+     *     metadata_match: {          // match against metadata fields
+     *       priority: 'high'
+     *     },
+     *   },
+     *   action: {
+     *     type: 'forward',           // 'forward' | 'reply' | 'broadcast'
+     *     to: 'reviewer',            // target agent or #channel
+     *     transform: 'Appended: {message}',  // optional message transform
+     *   },
+     *   enabled: true,
+     *   max_loops: 3,                // prevent infinite loops
+     * }
+     */
+    if (!rule.id) rule.id = `rule_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    if (!rule.match) return { ok: false, error: 'Rule needs "match" config' };
+    if (!rule.action) return { ok: false, error: 'Rule needs "action" config' };
+    rule.enabled = rule.enabled !== false;
+    rule.loop_count = 0;
+    rule.created_at = rule.created_at || new Date().toISOString();
+    this._rules.push(rule);
+    this._saveJson(RULES_FILE, this._rules);
+    return { ok: true, rule_id: rule.id };
+  }
+
+  removeRule(ruleId) {
+    const idx = this._rules.findIndex(r => r.id === ruleId);
+    if (idx === -1) return { ok: false, error: 'Rule not found' };
+    this._rules.splice(idx, 1);
+    this._saveJson(RULES_FILE, this._rules);
+    return { ok: true };
+  }
+
+  listRules() {
+    return this._rules.map(r => ({
+      id: r.id,
+      description: r.description || '',
+      match: r.match,
+      action: r.action,
+      enabled: r.enabled,
+      created_at: r.created_at,
+    }));
+  }
+
+  _checkRules(msg) {
+    // Skip system messages and broadcasts from ourselves
+    if (!msg || !msg.message) return;
+    if (['coco', 'webhook', 'hermes-fwd'].includes(msg.from)) return;
+
+    for (const rule of this._rules) {
+      if (!rule.enabled) continue;
+      if (rule.loop_count >= (rule.max_loops || 3)) continue;
+
+      const match = rule.match;
+      let matched = true;
+
+      // Check sender
+      if (match.from && match.from !== '*' && msg.from !== match.from) matched = false;
+
+      // Check message content
+      if (matched && match.contains && !msg.message.toLowerCase().includes(match.contains.toLowerCase())) matched = false;
+
+      // Check regex
+      if (matched && match.regex) {
+        try {
+          if (!new RegExp(match.regex, 'i').test(msg.message)) matched = false;
+        } catch { matched = false; }
+      }
+
+      // Check metadata
+      if (matched && match.metadata_match) {
+        for (const [k, v] of Object.entries(match.metadata_match)) {
+          if ((msg.metadata || {})[k] !== v) matched = false;
+        }
+      }
+
+      if (matched) {
+        rule.loop_count++;
+        this._executeAction(rule, msg);
+      }
+    }
+  }
+
+  _executeAction(rule, originalMsg) {
+    const action = rule.action;
+    let message = originalMsg.message;
+
+    // Apply transform
+    if (action.transform) {
+      message = action.transform
+        .replace('{message}', originalMsg.message)
+        .replace('{from}', originalMsg.from)
+        .replace('{channel}', originalMsg.metadata?.channel || '');
+    }
+
+    switch (action.type) {
+      case 'forward':
+        if (action.to?.startsWith('#')) {
+          this.bus.channelSend(action.to.slice(1), 'coco', message);
+          console.log(`[Orchestrator] Rule "${rule.id}": fwd from ${originalMsg.from} to ${action.to}`);
+        } else if (action.to) {
+          this.bus.sendMessage('coco', action.to, message, {
+            type: 'auto_forwarded',
+            original_from: originalMsg.from,
+            rule_id: rule.id,
+          });
+          console.log(`[Orchestrator] Rule "${rule.id}": fwd from ${originalMsg.from} to ${action.to}`);
+        }
+        break;
+
+      case 'reply':
+        this.bus.sendMessage('coco', originalMsg.from, message, {
+          type: 'auto_reply',
+          rule_id: rule.id,
+          in_reply_to: originalMsg.id,
+        });
+        console.log(`[Orchestrator] Rule "${rule.id}": auto-reply to ${originalMsg.from}`);
+        break;
+
+      case 'broadcast':
+        this.bus.broadcastMessage('coco', message);
+        console.log(`[Orchestrator] Rule "${rule.id}": broadcast from ${originalMsg.from}`);
+        break;
+    }
+  }
+
+  // ═══════════════════════════════════════════════════
+  //  PART 2: Agent Orchestrator Workflows
+  // ═══════════════════════════════════════════════════
+
+  createWorkflow(wf) {
+    /**
+     * workflow = {
+     *   id: 'review-and-deploy',
+     *   description: 'Review code, then deploy if approved',
+     *   steps: [
+     *     { agent: 'hermes', prompt: 'Review this: {input}', store: 'review_result' },
+     *     { agent: 'deploy-bot', prompt: 'Deploy: {review_result}', store: 'deploy_result' },
+     *   ],
+     *   input: '',                   // initial input (filled at run time)
+     *   enabled: true,
+     * }
+     */
+    if (!wf.id) wf.id = `wf_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    if (!wf.steps || wf.steps.length === 0) return { ok: false, error: 'Workflow needs steps' };
+    wf.enabled = wf.enabled !== false;
+    wf.created_at = wf.created_at || new Date().toISOString();
+    this._workflows.push(wf);
+    this._saveJson(WORKFLOWS_FILE, this._workflows);
+    return { ok: true, workflow_id: wf.id };
+  }
+
+  removeWorkflow(wfId) {
+    const idx = this._workflows.findIndex(w => w.id === wfId);
+    if (idx === -1) return { ok: false, error: 'Workflow not found' };
+    this._workflows.splice(idx, 1);
+    this._saveJson(WORKFLOWS_FILE, this._workflows);
+    return { ok: true };
+  }
+
+  listWorkflows() {
+    return this._workflows.map(w => ({
+      id: w.id,
+      description: w.description || '',
+      steps: w.steps.length,
+      enabled: w.enabled,
+      created_at: w.created_at,
+    }));
+  }
+
+  async runWorkflow(wfId, input, requester) {
+    const wf = this._workflows.find(w => w.id === wfId);
+    if (!wf) return { ok: false, error: 'Workflow not found' };
+    if (!wf.enabled) return { ok: false, error: 'Workflow is disabled' };
+
+    const context = { input };
+    const results = [];
+
+    for (const step of wf.steps) {
+      const prompt = step.prompt.replace(/\{(\w+)\}/g, (_, key) => context[key] || '');
+      const stepResult = await this._runStep(step, prompt, requester);
+      results.push({
+        step: step.agent,
+        result: stepResult,
+        store: step.store,
+      });
+
+      if (step.store && stepResult) {
+        context[step.store] = stepResult;
+      }
+    }
+
+    return { ok: true, workflow_id: wfId, steps: results.length, results };
+  }
+
+  async _runStep(step, prompt, requester) {
+    // Send message to agent, wait for reply (up to timeout)
+    return new Promise((resolve) => {
+      const timeoutMs = step.timeout || 120000;
+
+      // Send prompt to target agent
+      this.bus.sendMessage(requester || 'coco', step.agent, prompt, {
+        type: 'orchestrator_task',
+        step: step.agent,
+        expect_reply: true,
+      });
+
+      // Long-poll for reply
+      // We use a one-time waiter on the requester's inbox
+      const agentName = requester || 'coco';
+      const inboxDir = path.join(__dirname, '..', '.bus', 'messages', agentName);
+
+      const startCount = fs.existsSync(inboxDir)
+        ? fs.readdirSync(inboxDir).filter(f => f.endsWith('.json')).length
+        : 0;
+
+      const pollInterval = setInterval(() => {
+        if (!fs.existsSync(inboxDir)) return;
+
+        const files = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json'));
+        if (files.length > startCount) {
+          clearInterval(pollInterval);
+          clearTimeout(timeoutTimer);
+
+          // Get the last message (most recent)
+          const newestFile = files[files.length - 1];
+          try {
+            const msg = JSON.parse(fs.readFileSync(path.join(inboxDir, newestFile), 'utf-8'));
+            if (msg.from === step.agent) {
+              resolve(msg.message);
+              return;
+            }
+          } catch {}
+          resolve('[Error reading reply]');
+        }
+      }, 2000);
+
+      const timeoutTimer = setTimeout(() => {
+        clearInterval(pollInterval);
+        resolve(`[Timeout: ${step.agent} did not respond in ${timeoutMs / 1000}s]`);
+      }, timeoutMs);
+    });
+  }
+
+  start() {
+    if (this._running) return;
+    this._running = true;
+    console.log(`[Orchestrator] Started: ${this._rules.filter(r => r.enabled).length} rules, ${this._workflows.filter(w => w.enabled).length} workflows`);
+  }
+
+  stop() {
+    this._running = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  // ── Tools ──
+
+  getTools() {
+    return [
+      // Auto-Reply Rules
+      {
+        name: 'auto_reply_add',
+        description: 'Add an auto-reply rule: when a message matches criteria, auto-forward/reply/broadcast',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+            description: { type: 'string' },
+            match: {
+              type: 'object',
+              properties: {
+                from: { type: 'string', description: 'Sender filter (agent name or * for any)' },
+                contains: { type: 'string', description: 'Message must contain this text' },
+                regex: { type: 'string', description: 'Message must match this regex' },
+                metadata_match: { type: 'object', description: 'Match against metadata fields' },
+              },
+            },
+            action: {
+              type: 'object',
+              properties: {
+                type: { type: 'string', enum: ['forward', 'reply', 'broadcast'], description: 'Action type' },
+                to: { type: 'string', description: 'Target: agent name or #channel (for forward)' },
+                transform: { type: 'string', description: 'Transform message. Variables: {message}, {from}, {channel}' },
+              },
+              required: ['type'],
+            },
+            enabled: { type: 'boolean' },
+            max_loops: { type: 'number', description: 'Max times this rule can fire per message chain' },
+          },
+          required: ['match', 'action'],
+        },
+      },
+      {
+        name: 'auto_reply_remove',
+        description: 'Remove an auto-reply rule',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            rule_id: { type: 'string' },
+          },
+          required: ['rule_id'],
+        },
+      },
+      {
+        name: 'auto_reply_list',
+        description: 'List all auto-reply rules',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      // Workflows
+      {
+        name: 'workflow_create',
+        description: 'Create a multi-step agent workflow pipeline',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+            description: { type: 'string' },
+            steps: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  agent: { type: 'string', description: 'Target agent name' },
+                  prompt: { type: 'string', description: 'Prompt template. Use {input}, {prev_result}, etc.' },
+                  store: { type: 'string', description: 'Variable name to store result for next steps' },
+                  timeout: { type: 'number', description: 'Max wait per step in ms' },
+                },
+                required: ['agent', 'prompt'],
+              },
+            },
+          },
+          required: ['steps'],
+        },
+      },
+      {
+        name: 'workflow_run',
+        description: 'Run a workflow pipeline with initial input',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            workflow_id: { type: 'string' },
+            input: { type: 'string', description: 'Initial input text' },
+            requester: { type: 'string', description: 'Agent name to receive results' },
+          },
+          required: ['workflow_id', 'input'],
+        },
+      },
+      {
+        name: 'workflow_remove',
+        description: 'Remove a workflow',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            workflow_id: { type: 'string' },
+          },
+          required: ['workflow_id'],
+        },
+      },
+      {
+        name: 'workflow_list',
+        description: 'List all workflows',
+        inputSchema: { type: 'object', properties: {} },
+      },
+    ];
+  }
+
+  _loadJson(filePath, defaultVal) {
+    try {
+      if (fs.existsSync(filePath)) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      }
+    } catch {}
+    return defaultVal;
+  }
+
+  _saveJson(filePath, data) {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+}
+
+module.exports = { Orchestrator };

package/lib/scheduler.js

@@ -0,0 +1,259 @@
+/**
+ * CoCo Scheduler — Schedule messages to be sent on the bus at specified times
+ *
+ * Reads a schedule file (.bus/schedule.json) and fires messages on time.
+ * Supports cron-like intervals, one-shot, and recurring scheduled messages.
+ *
+ * Usage:
+ *   node index.js --scheduler        # Run alongside daemon
+ *
+ * Schedule format (.bus/schedule.json):
+ * [
+ *   {
+ *     "id": "daily-standup",
+ *     "cron": "0 9 * * 1-5",        // minute hour day month weekday
+ *     "from": "coco",
+ *     "to": "dev-team",              // agent name or channel (prefix with #)
+ *     "message": "Time for standup!",
+ *     "metadata": { "type": "reminder" },
+ *     "enabled": true,
+ *     "tz": "Asia/Bangkok"
+ *   }
+ * ]
+ */
+const fs = require('fs');
+const path = require('path');
+
+const SCHEDULE_FILE = path.join(__dirname, '..', '.bus', 'schedule.json');
+
+class Scheduler {
+  constructor(bus) {
+    this.bus = bus;
+    this._jobs = [];
+    this._timer = null;
+    this._running = false;
+    this.loadSchedule();
+  }
+
+  loadSchedule() {
+    try {
+      if (fs.existsSync(SCHEDULE_FILE)) {
+        this._jobs = JSON.parse(fs.readFileSync(SCHEDULE_FILE, 'utf-8'));
+        return this._jobs;
+      }
+    } catch (err) {
+      console.error(`[Scheduler] Error loading schedule: ${err.message}`);
+    }
+    this._jobs = [];
+    return [];
+  }
+
+  saveSchedule() {
+    fs.writeFileSync(SCHEDULE_FILE, JSON.stringify(this._jobs, null, 2), 'utf-8');
+  }
+
+  addJob(job) {
+    if (!job.id) job.id = `job_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    if (!job.cron && !job.at) {
+      return { ok: false, error: 'Must specify "cron" or "at"' };
+    }
+    job.enabled = job.enabled !== false;
+    job.created_at = job.created_at || new Date().toISOString();
+    this._jobs.push(job);
+    this.saveSchedule();
+    return { ok: true, job_id: job.id };
+  }
+
+  removeJob(jobId) {
+    const idx = this._jobs.findIndex(j => j.id === jobId);
+    if (idx === -1) return { ok: false, error: 'Job not found' };
+    this._jobs.splice(idx, 1);
+    this.saveSchedule();
+    return { ok: true };
+  }
+
+  listJobs() {
+    return this._jobs.map(j => ({
+      id: j.id,
+      description: j.message?.substring(0, 60),
+      schedule: j.cron || j.at,
+      to: j.to,
+      enabled: j.enabled,
+      created_at: j.created_at,
+    }));
+  }
+
+  start() {
+    if (this._running) return;
+    this._running = true;
+    this.loadSchedule();
+    this._tick();
+    this._timer = setInterval(() => this._tick(), 60000);
+    console.log(`[Scheduler] Started with ${this._jobs.filter(j => j.enabled).length} enabled jobs`);
+  }
+
+  stop() {
+    this._running = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  _tick() {
+    const now = new Date();
+    const minuteKey = this._minuteKey(now);
+
+    for (const job of this._jobs) {
+      if (!job.enabled) continue;
+
+      let shouldFire = false;
+
+      if (job.cron) {
+        shouldFire = this._matchCron(job.cron, now, job.tz);
+      } else if (job.at) {
+        const atTime = new Date(job.at).getTime();
+        if (atTime > 0 && Math.abs(now.getTime() - atTime) < 60000) {
+          shouldFire = true;
+          // One-shot: disable after firing
+          job.enabled = false;
+          this.saveSchedule();
+        }
+      }
+
+      if (shouldFire) {
+        this._fire(job);
+      }
+    }
+  }
+
+  _fire(job) {
+    const to = job.to || 'broadcast';
+    const from = job.from || 'coco';
+
+    console.log(`[Scheduler] Firing job "${job.id}" → ${to}: ${(job.message || '').substring(0, 60)}`);
+
+    if (to === 'broadcast') {
+      this.bus.broadcastMessage(from, job.message);
+    } else if (to.startsWith('#')) {
+      const channelId = to.slice(1);
+      this.bus.channelSend(channelId, from, job.message);
+    } else {
+      this.bus.sendMessage(from, to, job.message, job.metadata || {});
+    }
+  }
+
+  _minuteKey(date) {
+    return `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')} ${String(date.getHours()).padStart(2,'0')}:${String(date.getMinutes()).padStart(2,'0')}`;
+  }
+
+  _matchCron(expr, date, tz) {
+    // Simple cron: "minute hour day month weekday"
+    // * = any, numbers match
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length < 5) return false;
+
+    const d = date;
+
+    // Resolve components — timezone-aware if specified
+    let minute, hour, day, month, weekday;
+    if (tz) {
+      try {
+        const parts = new Intl.DateTimeFormat('en-CA', {
+          timeZone: tz,
+          hour12: false,
+          year: 'numeric', month: '2-digit', day: '2-digit',
+          hour: '2-digit', minute: '2-digit', weekday: 'short'
+        }).formatToParts(d);
+        const map = {};
+        for (const p of parts) map[p.type] = p.value;
+        minute = parseInt(map.minute, 10);
+        hour = parseInt(map.hour, 10);
+        day = parseInt(map.day, 10);
+        month = parseInt(map.month, 10);
+        const wdMap = { Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6, Sun: 0 };
+        // weekday type from formatToParts is 'weekday', value is short like 'Wed'
+        weekday = wdMap[map.weekday] !== undefined ? wdMap[map.weekday] : 0;
+      } catch { fallbackToLocal(); }
+    } else {
+      fallbackToLocal();
+    }
+
+    function fallbackToLocal() {
+      minute = d.getMinutes();
+      hour = d.getHours();
+      day = d.getDate();
+      month = d.getMonth() + 1;
+      weekday = d.getDay();
+    }
+
+    const checks = [
+      { field: minute, pattern: parts[0] },
+      { field: hour, pattern: parts[1] },
+      { field: day, pattern: parts[2] },
+      { field: month, pattern: parts[3] },
+      { field: weekday, pattern: parts[4] },
+    ];
+
+    // All fields must match (or be *)
+    return checks.every(c => this._matchField(c.field, c.pattern));
+  }
+
+  _matchField(value, pattern) {
+    if (pattern === '*') return true;
+    if (pattern.includes(',')) {
+      return pattern.split(',').some(p => this._matchField(value, p.trim()));
+    }
+    if (pattern.includes('*/')) {
+      const step = parseInt(pattern.split('/')[1], 10);
+      return step > 0 && value % step === 0;
+    }
+    if (pattern.includes('-')) {
+      const [lo, hi] = pattern.split('-').map(Number);
+      return value >= lo && value <= hi;
+    }
+    return parseInt(pattern, 10) === value;
+  }
+
+  getScheduleTools() {
+    return [
+      {
+        name: 'scheduler_add',
+        description: 'Add a scheduled message. Specify cron expression (minute hour day month weekday) or exact time (ISO).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Unique job ID (optional, auto-generated)' },
+            cron: { type: 'string', description: 'Cron expression: "minute hour day month weekday" (e.g. "0 9 * * 1-5" = weekdays 9am)' },
+            at: { type: 'string', description: 'ISO timestamp for one-shot scheduling (e.g. "2026-06-25T09:00:00+07:00")' },
+            from: { type: 'string', description: 'Sender agent name (default: coco)' },
+            to: { type: 'string', description: 'Target: agent name, "#channel", or "broadcast" (default: broadcast)' },
+            message: { type: 'string', description: 'Message content to send' },
+            metadata: { type: 'object', description: 'Optional metadata' },
+            enabled: { type: 'boolean', description: 'Enable the job (default: true)' },
+            tz: { type: 'string', description: 'Timezone for cron (e.g. "Asia/Bangkok")' },
+          },
+          required: ['message'],
+        },
+      },
+      {
+        name: 'scheduler_remove',
+        description: 'Remove a scheduled job by ID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            job_id: { type: 'string', description: 'Job ID to remove' },
+          },
+          required: ['job_id'],
+        },
+      },
+      {
+        name: 'scheduler_list',
+        description: 'List all scheduled messages',
+        inputSchema: { type: 'object', properties: {} },
+      },
+    ];
+  }
+}
+
+module.exports = { Scheduler };