@hexabot-ai/agentic 3.0.1-alpha.0

package/dist/cjs/utils/workflow-definition.js

@@ -0,0 +1,102 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeRenameTaskInDefinition = void 0;
+const dsl_types_1 = require("../dsl.types");
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const replaceOutputTaskReferences = (source, currentTaskName, nextTaskName) => {
+    if (!source.includes('$output')) {
+        return source;
+    }
+    const escapedTaskName = escapeRegExp(currentTaskName);
+    const dotNotationPattern = new RegExp(`(\\$output\\.)${escapedTaskName}(?=[^a-zA-Z0-9_]|$)`, 'g');
+    const singleQuotePattern = new RegExp(`(\\$output\\s*\\[\\s*')${escapedTaskName}('\\s*\\])`, 'g');
+    const doubleQuotePattern = new RegExp(`(\\$output\\s*\\[\\s*")${escapedTaskName}("\\s*\\])`, 'g');
+    return source
+        .replace(dotNotationPattern, `$1${nextTaskName}`)
+        .replace(singleQuotePattern, `$1${nextTaskName}$2`)
+        .replace(doubleQuotePattern, `$1${nextTaskName}$2`);
+};
+const renameTaskInFlow = (steps, currentTaskName, nextTaskName) => {
+    return steps.map((step) => {
+        if ('do' in step) {
+            return {
+                ...step,
+                do: step.do === currentTaskName ? nextTaskName : step.do,
+            };
+        }
+        if ('parallel' in step) {
+            return {
+                ...step,
+                parallel: {
+                    ...step.parallel,
+                    steps: renameTaskInFlow(step.parallel.steps, currentTaskName, nextTaskName),
+                },
+            };
+        }
+        if ('conditional' in step) {
+            return {
+                ...step,
+                conditional: {
+                    ...step.conditional,
+                    when: step.conditional.when.map((branch) => ({
+                        ...branch,
+                        steps: renameTaskInFlow(branch.steps, currentTaskName, nextTaskName),
+                    })),
+                },
+            };
+        }
+        if ('loop' in step) {
+            return {
+                ...step,
+                loop: {
+                    ...step.loop,
+                    steps: renameTaskInFlow(step.loop.steps, currentTaskName, nextTaskName),
+                },
+            };
+        }
+        return step;
+    });
+};
+const renameOutputTaskReferencesInValue = (value, currentTaskName, nextTaskName) => {
+    if (typeof value === 'string') {
+        return replaceOutputTaskReferences(value, currentTaskName, nextTaskName);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => renameOutputTaskReferencesInValue(item, currentTaskName, nextTaskName));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    return Object.entries(value).reduce((acc, [key, nestedValue]) => {
+        acc[key] = renameOutputTaskReferencesInValue(nestedValue, currentTaskName, nextTaskName);
+        return acc;
+    }, {});
+};
+const safeRenameTaskInDefinition = (definition, currentTaskName, nextTaskName) => {
+    if (currentTaskName === nextTaskName) {
+        return definition;
+    }
+    if (!Object.prototype.hasOwnProperty.call(definition.defs, currentTaskName)) {
+        return definition;
+    }
+    const currentDefinition = definition.defs[currentTaskName];
+    if (!currentDefinition || currentDefinition.kind !== dsl_types_1.TASK_KIND) {
+        return definition;
+    }
+    const renamedDefs = Object.entries(definition.defs).reduce((acc, [defName, def]) => {
+        acc[defName === currentTaskName ? nextTaskName : defName] = def;
+        return acc;
+    }, {});
+    const definitionWithRenamedFlow = {
+        ...definition,
+        defs: renamedDefs,
+        flow: renameTaskInFlow(definition.flow, currentTaskName, nextTaskName),
+    };
+    return renameOutputTaskReferencesInValue(definitionWithRenamedFlow, currentTaskName, nextTaskName);
+};
+exports.safeRenameTaskInDefinition = safeRenameTaskInDefinition;

package/dist/cjs/workflow-compiler.js

@@ -0,0 +1,212 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileWorkflow = void 0;
+const zod_1 = require("zod");
+const base_binding_1 = require("./bindings/base-binding");
+const dsl_types_1 = require("./dsl.types");
+const naming_1 = require("./utils/naming");
+const workflow_event_emitter_1 = require("./workflow-event-emitter");
+const workflow_values_1 = require("./workflow-values");
+/** Build a stable identifier for a step using its path and label. */
+const buildStepId = (path, label) => {
+    const pathPart = path.length > 0 ? path.join('.') : 'root';
+    return `${pathPart}:${label}`;
+};
+/** Convert workflow input field metadata to a zod schema. */
+const inputFieldToZod = (field) => {
+    let schema;
+    switch (field.type) {
+        case 'string':
+            schema = zod_1.z.string();
+            break;
+        case 'number':
+            schema = zod_1.z.number();
+            break;
+        case 'integer':
+            schema = zod_1.z.int();
+            break;
+        case 'boolean':
+            schema = zod_1.z.boolean();
+            break;
+        case 'array':
+            schema = zod_1.z.array(field.items ? inputFieldToZod(field.items) : zod_1.z.any());
+            break;
+        case 'object': {
+            const properties = {};
+            if (field.properties) {
+                for (const [name, child] of Object.entries(field.properties)) {
+                    properties[name] = inputFieldToZod(child).optional();
+                }
+            }
+            schema =
+                Object.keys(properties).length > 0
+                    ? zod_1.z.strictObject(properties).partial()
+                    : zod_1.z.record(zod_1.z.string(), zod_1.z.any());
+            break;
+        }
+        default:
+            schema = zod_1.z.any();
+    }
+    if (field.enum) {
+        schema = schema.refine((value) => field.enum?.some((allowed) => allowed === value), {
+            message: `Value must be one of: ${field.enum.join(', ')}`,
+        });
+    }
+    return schema;
+};
+/** Assemble a parser for the workflow top-level input payload. */
+const buildInputParser = (schema) => {
+    if (!schema || Object.keys(schema).length === 0) {
+        return zod_1.z.looseObject({});
+    }
+    const shape = {};
+    for (const [name, field] of Object.entries(schema)) {
+        shape[name] = inputFieldToZod(field).optional();
+    }
+    return zod_1.z.strictObject(shape).partial();
+};
+/** Compile a raw mapping object into expression-aware value mappings. */
+const compileMapping = (values, options) => {
+    if (!values) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+        key,
+        (0, workflow_values_1.compileValue)(value, options),
+    ]));
+};
+/** Ensure every task references a provided action implementation. */
+const assertActionsBound = (tasks, actions) => {
+    const missing = Object.values(tasks)
+        .map((task) => task.action)
+        .filter((actionName) => !Object.prototype.hasOwnProperty.call(actions, actionName));
+    if (missing.length > 0) {
+        throw new Error(`No action implementations provided for: ${missing.join(', ')}`);
+    }
+};
+/** Parse settings, compile inputs, and bind actions for each task. */
+const compileTasks = (definition, options) => {
+    const compiled = {};
+    const defaultSettings = definition.defaults?.settings;
+    const taskDefinitions = (0, dsl_types_1.extractTaskDefinitions)(definition.defs);
+    const bindingValidation = (0, base_binding_1.validateAndResolveBindings)(definition, {
+        bindingKinds: options.bindingKinds,
+        actions: options.actions,
+    });
+    if (bindingValidation.errors.length > 0) {
+        throw new Error(`Workflow bindings validation failed: ${bindingValidation.errors.join('; ')}`);
+    }
+    assertActionsBound(taskDefinitions, options.actions);
+    for (const [taskName, task] of Object.entries(taskDefinitions)) {
+        (0, naming_1.assertSnakeCaseName)(taskName, 'action');
+        const action = options.actions[task.action];
+        const settingsPayload = (0, workflow_values_1.mergeSettings)(defaultSettings, task.settings);
+        const parsedSettings = action.parseSettings(settingsPayload);
+        compiled[taskName] = {
+            name: taskName,
+            actionName: task.action,
+            definition: task,
+            action,
+            inputs: compileMapping(task.inputs, options) ?? {},
+            settings: parsedSettings,
+            bindings: (0, base_binding_1.mountTaskBindings)(task.bindings, bindingValidation.resolvedDefs, options.bindingKinds),
+        };
+    }
+    return compiled;
+};
+/** Recursively compile flow steps into executable nodes with generated ids. */
+const compileFlowSteps = (steps, path = [], options) => steps.map((step, index) => {
+    const stepPath = [...path, index];
+    if ('do' in step) {
+        const label = step.do;
+        return {
+            type: workflow_event_emitter_1.StepType.Task,
+            id: buildStepId(stepPath, step.do),
+            label,
+            taskName: step.do,
+        };
+    }
+    if ('parallel' in step) {
+        const label = step.parallel.description ?? 'parallel';
+        return {
+            type: workflow_event_emitter_1.StepType.Parallel,
+            id: buildStepId(stepPath, 'parallel'),
+            label,
+            description: step.parallel.description,
+            strategy: step.parallel.strategy ?? 'wait_all',
+            steps: compileFlowSteps(step.parallel.steps, [...stepPath, 'parallel'], options),
+        };
+    }
+    if ('conditional' in step) {
+        const label = step.conditional.description ?? 'conditional';
+        const branches = step.conditional.when.map((branch, branchIdx) => ({
+            id: buildStepId([...stepPath, 'branch', branchIdx], 'conditional'),
+            condition: 'condition' in branch
+                ? (0, workflow_values_1.compileValue)(branch.condition, options)
+                : undefined,
+            steps: compileFlowSteps(branch.steps, [...stepPath, 'branch', branchIdx], options),
+        }));
+        return {
+            type: workflow_event_emitter_1.StepType.Conditional,
+            id: buildStepId(stepPath, 'conditional'),
+            label,
+            description: step.conditional.description,
+            branches,
+        };
+    }
+    const loop = step.loop;
+    const label = loop.name ?? 'loop';
+    const commonLoop = {
+        type: workflow_event_emitter_1.StepType.Loop,
+        id: buildStepId(stepPath, label),
+        label,
+        name: loop.name,
+        description: loop.description,
+        accumulate: loop.accumulate
+            ? {
+                as: loop.accumulate.as,
+                initial: loop.accumulate.initial,
+                merge: (0, workflow_values_1.compileValue)(loop.accumulate.merge, options),
+            }
+            : undefined,
+        steps: compileFlowSteps(loop.steps, [...stepPath, loop.name ?? 'loop'], options),
+    };
+    if (loop.type === 'for_each') {
+        return {
+            ...commonLoop,
+            loopType: 'for_each',
+            forEach: {
+                item: loop.for_each.item,
+                in: (0, workflow_values_1.compileValue)(loop.for_each.in, options),
+            },
+            maxConcurrency: loop.max_concurrency,
+            until: loop.until ? (0, workflow_values_1.compileValue)(loop.until, options) : undefined,
+        };
+    }
+    return {
+        ...commonLoop,
+        loopType: 'while',
+        while: (0, workflow_values_1.compileValue)(loop.while, options),
+    };
+});
+/** Compile a workflow definition into structures consumable by the runtime. */
+const compileWorkflow = (definition, options) => {
+    const inputParser = buildInputParser(definition.inputs?.schema);
+    const tasks = compileTasks(definition, options);
+    const flow = compileFlowSteps(definition.flow, [], options);
+    const outputMapping = compileMapping(definition.outputs, options) ?? {};
+    return {
+        definition,
+        tasks,
+        flow,
+        outputMapping,
+        inputParser,
+        defaultSettings: definition.defaults?.settings,
+    };
+};
+exports.compileWorkflow = compileWorkflow;

package/dist/cjs/workflow-event-emitter.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowEventEmitter = exports.StepType = void 0;
+var StepType;
+(function (StepType) {
+    StepType["Task"] = "task";
+    StepType["Parallel"] = "parallel";
+    StepType["Conditional"] = "conditional";
+    StepType["Loop"] = "loop";
+})(StepType || (exports.StepType = StepType = {}));
+/**
+ * Minimal, browser-friendly event emitter that preserves the typed payloads
+ * exposed by {@link WorkflowEventMap}. It supports the subset of the Node.js
+ * EventEmitter API that the runtime relies on (`emit` and `on`).
+ */
+class WorkflowEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    emit(event, payload) {
+        const eventListeners = this.listeners.get(event);
+        if (!eventListeners || eventListeners.size === 0) {
+            return false;
+        }
+        eventListeners.forEach((listener) => listener(payload));
+        return true;
+    }
+    on(event, listener) {
+        const listeners = this.listeners.get(event) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(event, listeners);
+        return this;
+    }
+}
+exports.WorkflowEventEmitter = WorkflowEventEmitter;