amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/workflows/compiler.js

@@ -0,0 +1,222 @@
+'use strict';
+
+const vm = require('vm');
+
+const COMPILE_TIMEOUT_MS = 1000;
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function splitEventRef(ref) {
+  const value = String(ref || '').trim();
+  if (!value) return { source: '*', event: '*', ref: '*.*' };
+  const dot = value.indexOf('.');
+  if (dot === -1) return { source: value, event: '*', ref: `${value}.*` };
+  const source = value.slice(0, dot).trim() || '*';
+  const event = value.slice(dot + 1).trim() || '*';
+  return { source, event, ref: `${source}.${event}` };
+}
+
+function serializeValue(value) {
+  if (typeof value === 'function') {
+    return { $fn: value.toString() };
+  }
+  if (Array.isArray(value)) return value.map(serializeValue);
+  if (isObject(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (child !== undefined) out[key] = serializeValue(child);
+    }
+    return out;
+  }
+  return value;
+}
+
+function splitToolActionRef(ref) {
+  const value = String(ref || '').trim();
+  let index = -1;
+  for (const separator of ['.', ':', '/']) {
+    index = Math.max(index, value.lastIndexOf(separator));
+  }
+  if (index === -1) return { toolId: value, actionName: '' };
+  return {
+    toolId: value.slice(0, index).trim(),
+    actionName: value.slice(index + 1).trim(),
+  };
+}
+
+function normalizeSource(sourceText) {
+  let source = String(sourceText || '').trim();
+  if (!source) throw new Error('Workflow script is empty.');
+
+  if (/^\s*export\s+default\s+workflow\s*\(/.test(source)) {
+    source = source.replace(/^\s*export\s+default\s+workflow\s*\(/, '__workflow = workflow(');
+  } else if (/^\s*module\.exports\s*=\s*workflow\s*\(/.test(source)) {
+    source = source.replace(/^\s*module\.exports\s*=\s*workflow\s*\(/, '__workflow = workflow(');
+  } else if (/^\s*workflow\s*\(/.test(source)) {
+    source = `__workflow = ${source}`;
+  }
+
+  return source;
+}
+
+function makeBuilders() {
+  const builders = {};
+
+  builders.event = (ref, options = {}) => ({
+    ...splitEventRef(ref),
+    ...(isObject(options) ? serializeValue(options) : {}),
+  });
+
+  builders.code = (name, fn, options = {}) => {
+    if (typeof name !== 'string' || !name.trim()) throw new Error('code() needs a cell name.');
+    if (typeof fn !== 'function') throw new Error(`code("${name}") needs a function.`);
+    return {
+      kind: 'code',
+      name: name.trim(),
+      code: fn.toString(),
+      ...(isObject(options) ? serializeValue(options) : {}),
+    };
+  };
+
+  builders.cli = (name, config = {}) => {
+    if (typeof name !== 'string' || !name.trim()) throw new Error('cli() needs a cell name.');
+    return {
+      kind: 'cli',
+      name: name.trim(),
+      config: serializeValue(config || {}),
+    };
+  };
+
+  builders.tool = (name, toolRef, actionOrArgs = {}, argsOrOptions = {}, maybeOptions = {}) => {
+    if (typeof name !== 'string' || !name.trim()) throw new Error('tool() needs a cell name.');
+    let toolId = '';
+    let actionName = '';
+    let args = {};
+    let options = {};
+
+    if (isObject(toolRef)) {
+      const ref = toolRef.ref || toolRef.action || toolRef.tool || toolRef.call;
+      const parsed = ref ? splitToolActionRef(ref) : {};
+      toolId = String(toolRef.toolId || toolRef.tool_id || parsed.toolId || '').trim();
+      actionName = String(toolRef.actionName || toolRef.action_name || parsed.actionName || '').trim();
+      args = toolRef.args || toolRef.input || {};
+      options = toolRef.options || {};
+    } else if (typeof actionOrArgs === 'string') {
+      toolId = String(toolRef || '').trim();
+      actionName = actionOrArgs.trim();
+      args = argsOrOptions || {};
+      options = maybeOptions || {};
+    } else {
+      const parsed = splitToolActionRef(toolRef);
+      toolId = parsed.toolId;
+      actionName = parsed.actionName;
+      args = actionOrArgs || {};
+      options = argsOrOptions || {};
+    }
+
+    if (typeof toolId !== 'string' || !toolId.trim()) throw new Error(`tool("${name}") needs a tool id.`);
+    if (typeof actionName !== 'string' || !actionName.trim()) {
+      throw new Error(`tool("${name}") needs an action name.`);
+    }
+    return {
+      kind: 'tool',
+      name: name.trim(),
+      toolId: toolId.trim(),
+      actionName: actionName.trim(),
+      args: serializeValue(args || {}),
+      ...(isObject(options) ? serializeValue(options) : {}),
+    };
+  };
+
+  builders.http = (name, config = {}) => builders.tool(name, 'http', 'fetch', config);
+
+  builders.agent = (name, agent, promptOrArgs = {}, options = {}) => {
+    const args = isObject(promptOrArgs)
+      ? { agent, ...promptOrArgs }
+      : { agent, prompt: String(promptOrArgs || '') };
+    return builders.tool(name, 'amalgm.talk_to_agent', args, options);
+  };
+
+  builders.workflow = (definition) => definition;
+
+  return builders;
+}
+
+function normalizeCell(cell, index, names) {
+  if (!isObject(cell)) throw new Error(`Cell ${index + 1} is not a valid workflow cell.`);
+  if (!['code', 'cli', 'tool'].includes(cell.kind)) {
+    throw new Error(`Cell "${cell.name || index + 1}" has unsupported kind "${cell.kind}".`);
+  }
+  if (typeof cell.name !== 'string' || !cell.name.trim()) {
+    throw new Error(`Cell ${index + 1} is missing a name.`);
+  }
+  const name = cell.name.trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(name)) {
+    throw new Error(`Cell "${name}" must start with a letter or underscore and only use letters, numbers, "_" or "-".`);
+  }
+  if (names.has(name)) throw new Error(`Duplicate workflow cell name "${name}".`);
+  names.add(name);
+
+  return {
+    id: cell.id || name,
+    ...cell,
+    name,
+  };
+}
+
+function normalizeWorkflow(definition) {
+  if (!isObject(definition)) throw new Error('workflow() needs an object.');
+  const trigger = isObject(definition.trigger)
+    ? definition.trigger
+    : splitEventRef(definition.trigger || '*.*');
+  const names = new Set();
+  const cells = Array.isArray(definition.cells)
+    ? definition.cells.map((cell, index) => normalizeCell(cell, index, names))
+    : [];
+  if (cells.length === 0) throw new Error('Workflow needs at least one cell.');
+
+  return {
+    version: 1,
+    trigger: {
+      ...splitEventRef(trigger.ref || `${trigger.source || '*'}.${trigger.event || '*'}`),
+      ...serializeValue(trigger),
+    },
+    cells,
+    allowlist: isObject(definition.allowlist) ? serializeValue(definition.allowlist) : {},
+    limits: isObject(definition.limits) ? serializeValue(definition.limits) : {},
+  };
+}
+
+function compileWorkflowText(workflowText) {
+  const source = normalizeSource(workflowText);
+  const builders = makeBuilders();
+  const sandbox = {
+    ...builders,
+    __workflow: null,
+  };
+  const context = vm.createContext(sandbox, {
+    name: 'amalgm-workflow-compile',
+    codeGeneration: { strings: true, wasm: false },
+  });
+
+  try {
+    const script = new vm.Script(source, { filename: 'workflow.dsl.js' });
+    script.runInContext(context, { timeout: COMPILE_TIMEOUT_MS });
+  } catch (error) {
+    throw new Error(`Workflow compile failed: ${error.message}`);
+  }
+
+  if (!sandbox.__workflow) {
+    throw new Error('Workflow script must export or return workflow({...}).');
+  }
+
+  return normalizeWorkflow(sandbox.__workflow);
+}
+
+module.exports = {
+  compileWorkflowText,
+  splitEventRef,
+  splitToolActionRef,
+};