@volter/supercode-orchestrator 0.4.28 → 0.4.30

package/board/expr.mjs

@@ -0,0 +1,212 @@
+// The workflow's expressions (crates/interchange/src/orchestration/workflow.rs `Expr`): a small CEL-like language
+// evaluated over a context the board engine builds (`card`, `event`, `params`, `now`, `host`, `lane`, `run`, …).
+// Literals (numbers, 'strings' or "strings", true, false, null, [lists]); names and member access (`a.b`, `a[b]`);
+// calls of the context's functions (`matches(text, pattern)`); the macros `list.all(x, expr)`, `list.exists(x, expr)`,
+// `list.map(x, expr)`, `list.filter(x, expr)` and `.size()`; operators `!` `-` `*` `/` `%` `+` `-` `<` `<=` `>` `>=`
+// `==` `!=` `in` `&&` `||` `??` and `c ? a : b`. A template is a string with `{{expr}}` parts. Nothing reaches the
+// host: an expression reads only what its context holds.
+
+const TOKEN = /\s*(?:(\d+(?:\.\d+)?)|('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*")|([A-Za-z_][A-Za-z0-9_]*)|(\?\?|&&|\|\||==|!=|<=|>=|[-+*/%<>!?:.,()[\]]))/y;
+
+function tokenize(text) {
+  const out = [];
+  TOKEN.lastIndex = 0;
+  let at = 0;
+  while (at < text.length) {
+    if (/^\s*$/.test(text.slice(at))) break;
+    TOKEN.lastIndex = at;
+    const m = TOKEN.exec(text);
+    if (!m) throw new Error(`cannot read the expression at "${text.slice(at, at + 20)}"`);
+    at = TOKEN.lastIndex;
+    if (m[1] !== undefined) out.push({ t: 'num', v: Number(m[1]) });
+    else if (m[2] !== undefined) out.push({ t: 'str', v: m[2].slice(1, -1).replace(/\\(.)/g, '$1') });
+    else if (m[3] !== undefined) out.push({ t: 'id', v: m[3] });
+    else out.push({ t: 'op', v: m[4] });
+  }
+  return out;
+}
+
+// precedence climbing over the binary operators, lowest first
+const BINARY = [['??'], ['||'], ['&&'], ['==', '!=', 'in'], ['<', '<=', '>', '>='], ['+', '-'], ['*', '/', '%']];
+const MACROS = new Set(['all', 'exists', 'map', 'filter']);
+
+function parse(text) {
+  const tokens = tokenize(text);
+  let i = 0;
+  const peek = () => tokens[i];
+  const is = (v) => tokens[i]?.t === 'op' && tokens[i].v === v;
+  const take = (v) => { if (!is(v)) throw new Error(`expected "${v}" in ${text}`); i += 1; };
+  const ternary = () => {
+    const c = binary(0);
+    if (!is('?')) return c;
+    i += 1;
+    const a = ternary();
+    take(':');
+    return { k: 'if', c, a, b: ternary() };
+  };
+  const binary = (level) => {
+    if (level === BINARY.length) return unary();
+    let left = binary(level + 1);
+    for (;;) {
+      const tok = peek();
+      const op = tok && ((tok.t === 'op' || (tok.t === 'id' && tok.v === 'in')) ? tok.v : null);
+      if (!op || !BINARY[level].includes(op)) return left;
+      i += 1;
+      left = { k: 'bin', op, l: left, r: binary(level + 1) };
+    }
+  };
+  const unary = () => {
+    if (is('!')) { i += 1; return { k: 'not', e: unary() }; }
+    if (is('-')) { i += 1; return { k: 'neg', e: unary() }; }
+    return postfix(primary());
+  };
+  const args = () => {
+    take('(');
+    const out = [];
+    while (!is(')')) { out.push(ternary()); if (is(',')) i += 1; else break; }
+    take(')');
+    return out;
+  };
+  const postfix = (e) => {
+    for (;;) {
+      if (is('.')) {
+        i += 1;
+        const name = peek();
+        if (name?.t !== 'id') throw new Error(`expected a name after "." in ${text}`);
+        i += 1;
+        if (is('(')) {
+          if (MACROS.has(name.v)) {
+            take('(');
+            const v = peek();
+            if (v?.t !== 'id') throw new Error(`${name.v} takes a variable name first in ${text}`);
+            i += 1;
+            take(',');
+            const body = ternary();
+            take(')');
+            e = { k: 'macro', m: name.v, on: e, v: v.v, body };
+          } else e = { k: 'method', m: name.v, on: e, args: args() };
+        } else e = { k: 'get', on: e, key: { k: 'lit', v: name.v } };
+      } else if (is('[')) {
+        i += 1;
+        const key = ternary();
+        take(']');
+        e = { k: 'get', on: e, key };
+      } else return e;
+    }
+  };
+  const primary = () => {
+    const tok = peek();
+    if (!tok) throw new Error(`the expression ends early: ${text}`);
+    i += 1;
+    if (tok.t === 'num' || tok.t === 'str') return { k: 'lit', v: tok.v };
+    if (tok.t === 'op' && tok.v === '(') { const e = ternary(); take(')'); return e; }
+    if (tok.t === 'op' && tok.v === '[') {
+      const items = [];
+      while (!is(']')) { items.push(ternary()); if (is(',')) i += 1; else break; }
+      take(']');
+      return { k: 'list', items };
+    }
+    if (tok.t === 'id') {
+      if (tok.v === 'true') return { k: 'lit', v: true };
+      if (tok.v === 'false') return { k: 'lit', v: false };
+      if (tok.v === 'null') return { k: 'lit', v: null };
+      if (is('(')) return { k: 'call', f: tok.v, args: args() };
+      return { k: 'name', v: tok.v };
+    }
+    throw new Error(`unexpected "${tok.v}" in ${text}`);
+  };
+  const tree = ternary();
+  if (i < tokens.length) throw new Error(`unexpected "${tokens[i].v}" in ${text}`);
+  return tree;
+}
+
+const cache = new Map();
+function compiled(text) {
+  let tree = cache.get(text);
+  if (!tree) { tree = parse(text); cache.set(text, tree); }
+  return tree;
+}
+
+const own = (o, k) => o !== null && o !== undefined && (typeof o === 'object' || typeof o === 'function') && Object.prototype.hasOwnProperty.call(o, k);
+
+function run(e, scope) {
+  switch (e.k) {
+    case 'lit': return e.v;
+    case 'list': return e.items.map((x) => run(x, scope));
+    case 'name': return own(scope, e.v) ? scope[e.v] : undefined;
+    case 'get': {
+      const on = run(e.on, scope);
+      const key = run(e.key, scope);
+      return own(on, key) || (Array.isArray(on) && Number.isInteger(key)) ? on[key] : undefined;
+    }
+    case 'not': return !truthy(run(e.e, scope));
+    case 'neg': return -Number(run(e.e, scope));
+    case 'if': return truthy(run(e.c, scope)) ? run(e.a, scope) : run(e.b, scope);
+    case 'bin': {
+      if (e.op === '&&') return truthy(run(e.l, scope)) && truthy(run(e.r, scope));
+      if (e.op === '||') return truthy(run(e.l, scope)) || truthy(run(e.r, scope));
+      if (e.op === '??') { const l = run(e.l, scope); return l === null || l === undefined ? run(e.r, scope) : l; }
+      const l = run(e.l, scope);
+      const r = run(e.r, scope);
+      switch (e.op) {
+        case '==': return (l ?? null) === (r ?? null);
+        case '!=': return (l ?? null) !== (r ?? null);
+        case 'in': return Array.isArray(r) ? r.includes(l) : r && typeof r === 'object' ? own(r, l) : false;
+        case '<': return l < r;
+        case '<=': return l <= r;
+        case '>': return l > r;
+        case '>=': return l >= r;
+        case '+': return typeof l === 'string' || typeof r === 'string' ? `${l ?? ''}${r ?? ''}` : Number(l) + Number(r);
+        case '-': return Number(l) - Number(r);
+        case '*': return Number(l) * Number(r);
+        case '/': return Number(l) / Number(r);
+        case '%': return Number(l) % Number(r);
+        default: throw new Error(`no operator ${e.op}`);
+      }
+    }
+    case 'call': {
+      const f = own(scope, e.f) ? scope[e.f] : undefined;
+      if (typeof f !== 'function') throw new Error(`no function ${e.f}`);
+      return f(...e.args.map((a) => run(a, scope)));
+    }
+    case 'method': {
+      const on = run(e.on, scope);
+      if (e.m === 'size') return Array.isArray(on) || typeof on === 'string' ? on.length : on && typeof on === 'object' ? Object.keys(on).length : 0;
+      const f = on && typeof on[e.m] === 'function' && own(on, e.m) ? on[e.m] : undefined;
+      if (!f) throw new Error(`no method ${e.m}`);
+      return f(...e.args.map((a) => run(a, scope)));
+    }
+    case 'macro': {
+      const list = Array.isArray(run(e.on, scope)) ? run(e.on, scope) : [];
+      const each = (x) => run(e.body, { ...scope, [e.v]: x });
+      if (e.m === 'all') return list.every((x) => truthy(each(x)));
+      if (e.m === 'exists') return list.some((x) => truthy(each(x)));
+      if (e.m === 'map') return list.map(each);
+      return list.filter((x) => truthy(each(x)));
+    }
+    default: throw new Error(`cannot evaluate ${e.k}`);
+  }
+}
+
+const truthy = (v) => v !== null && v !== undefined && v !== false && v !== 0 && v !== '';
+
+/** The value of `text` in `scope`; null for an empty expression. */
+export function evaluate(text, scope) {
+  if (text === null || text === undefined || String(text).trim() === '') return null;
+  return run(compiled(String(text)), scope);
+}
+
+/** Whether `text` holds in `scope` (no expression holds). */
+export function holds(text, scope) {
+  return text === null || text === undefined ? true : truthy(evaluate(text, scope));
+}
+
+/** A template with `{{expr}}` parts, each replaced by its value (nothing for null). */
+export function render(template, scope) {
+  return String(template ?? '').replace(/\{\{([\s\S]+?)\}\}/g, (_, e) => { const v = evaluate(e, scope); return v === null || v === undefined ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v); });
+}
+
+/** Parse every expression up front: answers the first that does not parse, or null. */
+export function check(text) {
+  try { compiled(String(text)); return null; } catch (error) { return error.message; }
+}

package/board/store.mjs

@@ -65,8 +65,10 @@ CREATE INDEX IF NOT EXISTS idx_events_run ON task_events(run_id, id);
 
 // supercode's part of a card, beside Hermes's row: where its session runs, and the arc a subtask belongs to (a
 // subtask is worked by its arc's session and never started on its own).
-const OURS = `CREATE TABLE IF NOT EXISTS supercode_cards (task_id TEXT PRIMARY KEY, machine TEXT, subtask_of TEXT);`;
-const OURS_COLUMNS = { subtask_of: 'TEXT' };
+const OURS = `CREATE TABLE IF NOT EXISTS supercode_cards (task_id TEXT PRIMARY KEY, machine TEXT, subtask_of TEXT, stage TEXT);`;
+// `stage`: the card's workflow status where kanban.db stores another (a `reviewing` card is `running` to Hermes)
+// `since`: when the card entered its workflow status; `after_fired`: which of the status's `after` moves have run since
+const OURS_COLUMNS = { subtask_of: 'TEXT', stage: 'TEXT', since: 'INTEGER', after_fired: 'TEXT' };
 
 /** The database file of board `slug` in the home at `root`. */
 export function boardPath(root, slug = DEFAULT_BOARD) {

package/board/tools.mjs

@@ -7,6 +7,7 @@ import { mkdirSync, statSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { DEFAULT_BOARD, event, json, openBoard, tx } from './store.mjs';
 import * as engine from './engine.mjs';
+import { loadWorkflow } from './workflow.mjs';
 
 const ok = (fields = {}) => JSON.stringify({ ok: true, ...fields });
 const error = (message) => JSON.stringify({ error: message });
@@ -37,6 +38,14 @@ export async function boardTool(root, name, args = {}, env = {}) {
   if (!['kanban_list', 'kanban_create', 'kanban_link'].includes(name) && !tid) return error('task_id is required (or HERMES_KANBAN_TASK in the environment)');
   if (own && LIFECYCLE.has(name) && tid !== own) return error(`worker is scoped to task ${own}; refusing to change ${tid}. Use kanban_comment to hand off to other tasks, or kanban_create for follow-up work.`);
   const slug = args.board || env.HERMES_KANBAN_BOARD || DEFAULT_BOARD;
+  // the board's workflow decides what each tool's event does; the worker is its run's role on its own task, and
+  // nobody on another (Hermes's worker scoping)
+  try { await loadWorkflow(root); } catch (e) { return error(e.message); }
+  engine.setCaller((db, cardId) => {
+    if (!own || cardId !== own || !runId) return own ? [] : ['manager'];
+    const meta = json(db.prepare('SELECT metadata FROM task_runs WHERE id = ?').get(runId)?.metadata, {})?.supercode ?? {};
+    return [meta.role ?? 'implementer'];
+  });
   let board;
   try { board = openBoard(root, slug); } catch (e) { return error(e.message); }
   board.label = slug;
@@ -87,32 +96,32 @@ export async function boardTool(root, name, args = {}, env = {}) {
           }
         }
         if (env.HERMES_SESSION_ID && own === tid) metadata = { ...(metadata ?? {}), worker_session_id: env.HERMES_SESSION_ID };
-        engine.complete(board, tid, { summary, result, metadata });
+        await engine.complete(board, tid, { summary, result, metadata });
         return ok({ task_id: tid, status: 'done' });
       }
       case 'kanban_block': {
         const stale = ownRun(); if (stale) return error(stale);
-        const status = engine.block(board, tid, { reason: args.reason ? redact(String(args.reason)) : null, kind: args.kind ?? null });
+        const { to: status } = await engine.block(board, tid, { reason: args.reason ? redact(String(args.reason)) : null, kind: args.kind ?? null });
         return ok({ task_id: tid, status });
       }
       case 'kanban_request_review': {
         const stale = ownRun(); if (stale) return error(stale);
-        engine.requestReview(board, tid, { summary: args.summary ? redact(String(args.summary)) : null, metadata: args.metadata ? redact(args.metadata) : null, reviewer: args.reviewer ?? null, expectedRunId: own === tid && runId ? runId : null });
+        await engine.requestReview(board, tid, { summary: args.summary ? redact(String(args.summary)) : null, metadata: args.metadata ? redact(args.metadata) : null, reviewer: args.reviewer ?? null, expectedRunId: own === tid && runId ? runId : null });
         return ok({ task_id: tid, status: 'review' });
       }
       case 'kanban_request_changes': {
         const stale = ownRun(); if (stale) return error(stale);
-        engine.requestChanges(board, tid, { reason: args.reason ? redact(String(args.reason)) : null, reviewer: author });
+        await engine.requestChanges(board, tid, { reason: args.reason ? redact(String(args.reason)) : null, reviewer: author });
         return ok({ task_id: tid });
       }
       case 'kanban_heartbeat': {
         const stale = ownRun(); if (stale) return error(stale);
-        engine.heartbeat(board, tid, args.note ?? null);
+        await engine.heartbeat(board, tid, args.note ?? null);
         return ok({ task_id: tid });
       }
       case 'kanban_comment': {
         if (!String(args.body ?? '').trim()) return error('body is required');
-        const n = engine.comment(board, tid, author, redact(String(args.body)));
+        const n = await engine.comment(board, tid, author, redact(String(args.body)));
         return ok({ task_id: tid, comment_id: n });
       }
       case 'kanban_attach': case 'kanban_attach_url': {
@@ -151,10 +160,10 @@ export async function boardTool(root, name, args = {}, env = {}) {
         return ok({ task_id: made.id, existing: made.existing, status: tx(board, (db) => engine.getTask(db, made.id)).status });
       }
       case 'kanban_unblock':
-        return ok({ task_id: tid, status: engine.unblock(board, tid) });
+        return ok({ task_id: tid, status: (await engine.unblock(board, tid)).to });
       case 'kanban_link':
         if (!args.parent_id || !args.child_id) return error('parent_id and child_id are required');
-        engine.link(board, args.parent_id, args.child_id);
+        await engine.link(board, args.parent_id, args.child_id);
         return ok({ parent_id: args.parent_id, child_id: args.child_id });
       default:
         return error(`no board tool ${name}`);