@renseiai/agentfactory 0.8.12 → 0.8.13

package/dist/src/workflow/expression/evaluator.test.js

@@ -88,6 +88,22 @@ describe('evaluate — variable lookup', () => {
         const ast = { type: 'VariableRef', name: 'data' };
         expect(evaluate(ast, ctx({ data: null }))).toBe(null);
     });
+    it('resolves dotted variable path from nested context', () => {
+        const ast = { type: 'VariableRef', name: 'trigger.data.issueId' };
+        expect(evaluate(ast, ctx({ trigger: { data: { issueId: 'SUP-123' } } }))).toBe('SUP-123');
+    });
+    it('resolves two-level dotted path', () => {
+        const ast = { type: 'VariableRef', name: 'steps.route.result' };
+        expect(evaluate(ast, ctx({ steps: { route: { result: 'development' } } }))).toBe('development');
+    });
+    it('returns false for dotted path when intermediate is missing', () => {
+        const ast = { type: 'VariableRef', name: 'trigger.data.issueId' };
+        expect(evaluate(ast, ctx({}))).toBe(false);
+    });
+    it('returns false for dotted path when intermediate is null', () => {
+        const ast = { type: 'VariableRef', name: 'trigger.data.issueId' };
+        expect(evaluate(ast, ctx({ trigger: null }))).toBe(false);
+    });
 });
 // ---------------------------------------------------------------------------
 // 3. Boolean operators
@@ -437,6 +453,30 @@ describe('evaluate — comparisons', () => {
     });
 });
 // ---------------------------------------------------------------------------
+// 4b. in operator
+// ---------------------------------------------------------------------------
+describe('evaluate — in operator', () => {
+    it('returns true when value is in array', () => {
+        const result = evaluateCondition("{{ 'bug' in labels }}", ctx({ labels: ['bug', 'enhancement'] }));
+        expect(result).toBe(true);
+    });
+    it('returns false when value is not in array', () => {
+        const result = evaluateCondition("{{ 'feature' in labels }}", ctx({ labels: ['bug', 'enhancement'] }));
+        expect(result).toBe(false);
+    });
+    it('returns true for substring in string', () => {
+        const result = evaluateCondition("{{ 'fix' in title }}", ctx({ title: 'Quick fix for bug' }));
+        expect(result).toBe(true);
+    });
+    it('returns false when substring not in string', () => {
+        const result = evaluateCondition("{{ 'hotfix' in title }}", ctx({ title: 'Quick fix for bug' }));
+        expect(result).toBe(false);
+    });
+    it('throws for invalid right operand type', () => {
+        expect(() => evaluateCondition("{{ 'x' in count }}", ctx({ count: 42 }))).toThrow(EvaluationError);
+    });
+});
+// ---------------------------------------------------------------------------
 // 5. Function calls
 // ---------------------------------------------------------------------------
 describe('evaluate — function calls', () => {
@@ -561,6 +601,91 @@ describe('built-in helpers', () => {
             expect(helpers.isParentIssue()).toBe(false);
         });
     });
+    describe('hasSubIssues', () => {
+        it('returns true when hasSubIssues is true', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue, { hasSubIssues: true });
+            expect(helpers.hasSubIssues()).toBe(true);
+        });
+        it('returns false when hasSubIssues is false', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue, { hasSubIssues: false });
+            expect(helpers.hasSubIssues()).toBe(false);
+        });
+        it('returns false when hasSubIssues is not specified', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.hasSubIssues()).toBe(false);
+        });
+    });
+    describe('isAssignedToHuman', () => {
+        it('returns true when isAssignedToHuman is true', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue, { isAssignedToHuman: true });
+            expect(helpers.isAssignedToHuman()).toBe(true);
+        });
+        it('returns false when isAssignedToHuman is false', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue, { isAssignedToHuman: false });
+            expect(helpers.isAssignedToHuman()).toBe(false);
+        });
+        it('returns false when isAssignedToHuman is not specified', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.isAssignedToHuman()).toBe(false);
+        });
+    });
+    describe('hasBlockingIncomplete', () => {
+        it('returns true when hasBlockingIncomplete is true', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue, { hasBlockingIncomplete: true });
+            expect(helpers.hasBlockingIncomplete()).toBe(true);
+        });
+        it('returns false when hasBlockingIncomplete is false', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue, { hasBlockingIncomplete: false });
+            expect(helpers.hasBlockingIncomplete()).toBe(false);
+        });
+        it('returns false when hasBlockingIncomplete is not specified', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.hasBlockingIncomplete()).toBe(false);
+        });
+    });
+    describe('startsWith', () => {
+        it('returns true when string starts with prefix', () => {
+            const issue = makeIssue({ title: 'fix: resolve bug' });
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.startsWith('fix: resolve bug', 'fix')).toBe(true);
+        });
+        it('returns false when string does not start with prefix', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.startsWith('hello world', 'world')).toBe(false);
+        });
+        it('returns false for non-string arguments', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.startsWith(123, 'fix')).toBe(false);
+        });
+    });
+    describe('contains', () => {
+        it('returns true when string contains substring', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.contains('hello world', 'world')).toBe(true);
+        });
+        it('returns false when string does not contain substring', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.contains('hello world', 'foo')).toBe(false);
+        });
+        it('returns false for non-string arguments', () => {
+            const issue = makeIssue();
+            const helpers = createBuiltinHelpers(issue);
+            expect(helpers.contains(42, 'test')).toBe(false);
+        });
+    });
 });
 // ---------------------------------------------------------------------------
 // 7. Complex expressions (end-to-end with evaluateCondition)
@@ -635,6 +760,37 @@ describe('evaluateCondition — end-to-end', () => {
         const context = buildEvaluationContext(issue, { researchCompleted: true }, { hasSubIssues: false });
         expect(evaluateCondition("{{ hasLabel('bug') and researchCompleted }}", context)).toBe(true);
     });
+    it('evaluates hasSubIssues() in condition', () => {
+        const issue = makeIssue();
+        const context = buildEvaluationContext(issue, undefined, { hasSubIssues: true });
+        expect(evaluateCondition('{{ hasSubIssues() }}', context)).toBe(true);
+    });
+    it('evaluates isAssignedToHuman() in condition', () => {
+        const issue = makeIssue();
+        const context = buildEvaluationContext(issue, undefined, { isAssignedToHuman: true });
+        expect(evaluateCondition('{{ isAssignedToHuman() }}', context)).toBe(true);
+    });
+    it('evaluates hasBlockingIncomplete() in condition', () => {
+        const issue = makeIssue();
+        const context = buildEvaluationContext(issue, undefined, { hasBlockingIncomplete: true });
+        expect(evaluateCondition('{{ hasBlockingIncomplete() }}', context)).toBe(true);
+    });
+    it('evaluates dotted path expression end-to-end', () => {
+        const context = ctx({ trigger: { data: { issueId: 'SUP-123' } } });
+        expect(evaluateCondition("{{ trigger.data.issueId == 'SUP-123' }}", context)).toBe(true);
+    });
+    it('evaluates symbolic operators end-to-end', () => {
+        const context = ctx({ priority: 5 });
+        expect(evaluateCondition('{{ priority > 3 }}', context)).toBe(true);
+    });
+    it('evaluates startsWith() function in condition', () => {
+        const context = ctx({ title: 'fix: resolve memory leak' }, { startsWith: (...args) => typeof args[0] === 'string' && typeof args[1] === 'string' && args[0].startsWith(args[1]) });
+        expect(evaluateCondition("{{ startsWith(title, 'fix') }}", context)).toBe(true);
+    });
+    it('evaluates contains() function in condition', () => {
+        const context = ctx({ description: 'This is a hotfix release' }, { contains: (...args) => typeof args[0] === 'string' && typeof args[1] === 'string' && args[0].includes(args[1]) });
+        expect(evaluateCondition("{{ contains(description, 'hotfix') }}", context)).toBe(true);
+    });
 });
 // ---------------------------------------------------------------------------
 // 8. Error cases
@@ -774,6 +930,24 @@ describe('buildEvaluationContext', () => {
         expect(context.functions.isParentIssue).toBeDefined();
         expect(context.functions.isParentIssue()).toBe(true);
     });
+    it('registers hasSubIssues function', () => {
+        const issue = makeIssue();
+        const context = buildEvaluationContext(issue, undefined, { hasSubIssues: true });
+        expect(context.functions.hasSubIssues).toBeDefined();
+        expect(context.functions.hasSubIssues()).toBe(true);
+    });
+    it('registers isAssignedToHuman function', () => {
+        const issue = makeIssue();
+        const context = buildEvaluationContext(issue, undefined, { isAssignedToHuman: true });
+        expect(context.functions.isAssignedToHuman).toBeDefined();
+        expect(context.functions.isAssignedToHuman()).toBe(true);
+    });
+    it('registers hasBlockingIncomplete function', () => {
+        const issue = makeIssue();
+        const context = buildEvaluationContext(issue, undefined, { hasBlockingIncomplete: true });
+        expect(context.functions.hasBlockingIncomplete).toBeDefined();
+        expect(context.functions.hasBlockingIncomplete()).toBe(true);
+    });
     it('works end-to-end with evaluateCondition', () => {
         const issue = makeIssue({
             labels: ['bug', 'priority-high'],

package/dist/src/workflow/expression/expression.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseExpression, tokenize, parse, ParseError } from './index.js';
+import { parseExpression, tokenize, parse, ParseError, interpolateTemplate } from './index.js';
 // ---------------------------------------------------------------------------
 // Lexer tests
 // ---------------------------------------------------------------------------
@@ -67,6 +67,43 @@ describe('tokenize', () => {
         const tokens = tokenize('{{ x }}');
         expect(tokens[tokens.length - 1].type).toBe('EOF');
     });
+    it('tokenizes dotted variable path as single Identifier', () => {
+        const tokens = tokenize('{{ trigger.data.issueId }}');
+        const nonEof = tokens.filter((t) => t.type !== 'EOF');
+        expect(nonEof).toHaveLength(1);
+        expect(nonEof[0].type).toBe('Identifier');
+        expect(nonEof[0].value).toBe('trigger.data.issueId');
+    });
+    it('tokenizes symbolic operators == != > < >= <=', () => {
+        const cases = [
+            { input: '{{ x == y }}', expected: 'eq' },
+            { input: '{{ x != y }}', expected: 'neq' },
+            { input: '{{ x > y }}', expected: 'gt' },
+            { input: '{{ x < y }}', expected: 'lt' },
+            { input: '{{ x >= y }}', expected: 'gte' },
+            { input: '{{ x <= y }}', expected: 'lte' },
+        ];
+        for (const { input, expected } of cases) {
+            const tokens = tokenize(input);
+            const ops = tokens.filter((t) => t.type === 'Operator');
+            expect(ops).toHaveLength(1);
+            expect(ops[0].value).toBe(expected);
+        }
+    });
+    it('tokenizes mixed symbolic and keyword operators', () => {
+        const tokens = tokenize('{{ x == 5 and y > 3 }}');
+        const types = tokens.map((t) => `${t.type}:${t.value}`);
+        expect(types).toEqual([
+            'Identifier:x',
+            'Operator:eq',
+            'NumberLiteral:5',
+            'Operator:and',
+            'Identifier:y',
+            'Operator:gt',
+            'NumberLiteral:3',
+            'EOF:',
+        ]);
+    });
 });
 // ---------------------------------------------------------------------------
 // Parser tests — simple expressions
@@ -224,6 +261,59 @@ describe('parseExpression', () => {
                 right: { type: 'NumberLiteral', value: 5 },
             });
         });
+        it('parses in', () => {
+            const ast = parseExpression("{{ 'bug' in labels }}");
+            expect(ast).toEqual({
+                type: 'BinaryOp',
+                operator: 'in',
+                left: { type: 'StringLiteral', value: 'bug' },
+                right: { type: 'VariableRef', name: 'labels' },
+            });
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Dotted variable paths
+    // -------------------------------------------------------------------------
+    describe('dotted variable paths', () => {
+        it('parses dotted variable reference', () => {
+            const ast = parseExpression('{{ trigger.data.issueId }}');
+            expect(ast).toEqual({
+                type: 'VariableRef',
+                name: 'trigger.data.issueId',
+            });
+        });
+        it('parses dotted path with symbolic comparison', () => {
+            const ast = parseExpression('{{ trigger.data.priority > 3 }}');
+            expect(ast).toEqual({
+                type: 'BinaryOp',
+                operator: 'gt',
+                left: { type: 'VariableRef', name: 'trigger.data.priority' },
+                right: { type: 'NumberLiteral', value: 3 },
+            });
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Symbolic operators
+    // -------------------------------------------------------------------------
+    describe('symbolic operators', () => {
+        it('parses expression with symbolic == operator', () => {
+            const ast = parseExpression("{{ status == 'active' }}");
+            expect(ast).toEqual({
+                type: 'BinaryOp',
+                operator: 'eq',
+                left: { type: 'VariableRef', name: 'status' },
+                right: { type: 'StringLiteral', value: 'active' },
+            });
+        });
+        it('parses expression with symbolic != operator', () => {
+            const ast = parseExpression("{{ status != 'closed' }}");
+            expect(ast).toEqual({
+                type: 'BinaryOp',
+                operator: 'neq',
+                left: { type: 'VariableRef', name: 'status' },
+                right: { type: 'StringLiteral', value: 'closed' },
+            });
+        });
     });
     // -------------------------------------------------------------------------
     // Function calls
@@ -514,3 +604,52 @@ describe('parseExpression', () => {
         });
     });
 });
+// ---------------------------------------------------------------------------
+// Template interpolation tests
+// ---------------------------------------------------------------------------
+describe('interpolateTemplate', () => {
+    /** Create a context with the given variables and optional functions. */
+    function ctx(variables, functions = {}) {
+        return { variables, functions };
+    }
+    it('resolves a single expression', () => {
+        const result = interpolateTemplate('Issue {{ issueId }} is ready', ctx({ issueId: 'SUP-123' }));
+        expect(result).toBe('Issue SUP-123 is ready');
+    });
+    it('resolves multiple expressions', () => {
+        const result = interpolateTemplate('{{ name }} has {{ count }} items', ctx({ name: 'Alice', count: 5 }));
+        expect(result).toBe('Alice has 5 items');
+    });
+    it('resolves dotted path expressions', () => {
+        const result = interpolateTemplate('Issue {{ trigger.data.issueId }} is ready', ctx({ trigger: { data: { issueId: 'SUP-123' } } }));
+        expect(result).toBe('Issue SUP-123 is ready');
+    });
+    it('coerces boolean to string', () => {
+        const result = interpolateTemplate('Result: {{ active }}', ctx({ active: true }));
+        expect(result).toBe('Result: true');
+    });
+    it('coerces number to string', () => {
+        const result = interpolateTemplate('Count: {{ count }}', ctx({ count: 42 }));
+        expect(result).toBe('Count: 42');
+    });
+    it('passes through static string without expressions', () => {
+        const result = interpolateTemplate('No expressions here', ctx({}));
+        expect(result).toBe('No expressions here');
+    });
+    it('resolves expression-only template', () => {
+        const result = interpolateTemplate('{{ status }}', ctx({ status: 'In Progress' }));
+        expect(result).toBe('In Progress');
+    });
+    it('resolves function calls in template', () => {
+        const result = interpolateTemplate('Has bug: {{ hasLabel(\'bug\') }}', ctx({}, { hasLabel: (...args) => args[0] === 'bug' }));
+        expect(result).toBe('Has bug: true');
+    });
+    it('throws ParseError on empty expression', () => {
+        expect(() => interpolateTemplate('Hello {{  }}', ctx({}))).toThrow(ParseError);
+        expect(() => interpolateTemplate('Hello {{  }}', ctx({}))).toThrow(/Empty expression/);
+    });
+    it('resolves false for undefined variables', () => {
+        const result = interpolateTemplate('Value: {{ missing }}', ctx({}));
+        expect(result).toBe('Value: false');
+    });
+});

package/dist/src/workflow/expression/helpers.d.ts

@@ -9,6 +9,10 @@ import type { GovernorIssue } from '../../governor/governor-types.js';
 export interface BuiltinHelperOptions {
     /** Whether the issue has sub-issues (i.e., it is a parent issue) */
     hasSubIssues?: boolean;
+    /** Whether the issue is assigned to a human user (vs unassigned or bot) */
+    isAssignedToHuman?: boolean;
+    /** Whether the issue has incomplete blocking relations */
+    hasBlockingIncomplete?: boolean;
 }
 /**
  * Create the set of built-in helper functions bound to the given issue.

package/dist/src/workflow/expression/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAMrE,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,IAAI,GAAE,oBAAyB,GAC9B,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAwCjD"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAMrE,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,0DAA0D;IAC1D,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,IAAI,GAAE,oBAAyB,GAC9B,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAgGjD"}

package/dist/src/workflow/expression/helpers.js

@@ -52,5 +52,56 @@ export function createBuiltinHelpers(issue, opts = {}) {
         isParentIssue() {
             return opts.hasSubIssues === true;
         },
+        /**
+         * Check whether the issue has sub-issues.
+         * Alias for `isParentIssue()`.
+         *
+         * Usage in expressions: `hasSubIssues()`
+         */
+        hasSubIssues() {
+            return opts.hasSubIssues === true;
+        },
+        /**
+         * Check whether the issue is assigned to a human user (vs unassigned or bot).
+         *
+         * Usage in expressions: `isAssignedToHuman()`
+         */
+        isAssignedToHuman() {
+            return opts.isAssignedToHuman === true;
+        },
+        /**
+         * Check whether the issue has incomplete blocking relations.
+         *
+         * Usage in expressions: `hasBlockingIncomplete()`
+         */
+        hasBlockingIncomplete() {
+            return opts.hasBlockingIncomplete === true;
+        },
+        /**
+         * Check whether a string starts with a given prefix.
+         *
+         * Usage in expressions: `startsWith(title, 'fix')`
+         */
+        startsWith(...args) {
+            const str = args[0];
+            const prefix = args[1];
+            if (typeof str !== 'string' || typeof prefix !== 'string') {
+                return false;
+            }
+            return str.startsWith(prefix);
+        },
+        /**
+         * Check whether a string contains a given substring.
+         *
+         * Usage in expressions: `contains(title, 'hotfix')`
+         */
+        contains(...args) {
+            const str = args[0];
+            const substring = args[1];
+            if (typeof str !== 'string' || typeof substring !== 'string') {
+                return false;
+            }
+            return str.includes(substring);
+        },
     };
 }

package/dist/src/workflow/expression/index.d.ts

@@ -52,4 +52,18 @@ export declare function parseExpression(condition: string): ASTNode;
  * @throws {EvaluationError} on runtime errors (unknown functions, type mismatches).
  */
 export declare function evaluateCondition(condition: string, context: EvaluationContext): boolean;
+/**
+ * Interpolate template expressions within a string.
+ *
+ * Finds all `{{ ... }}` expressions in the input string, evaluates each
+ * against the context, and replaces the placeholder with the string
+ * representation of the result.
+ *
+ * @param template - The template string containing `{{ }}` expressions.
+ * @param context  - The sandboxed evaluation context.
+ * @returns The fully resolved string.
+ * @throws {ParseError} on syntax errors in expressions.
+ * @throws {EvaluationError} on runtime errors in expressions.
+ */
+export declare function interpolateTemplate(template: string, context: EvaluationContext): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/workflow/expression/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AASrD,YAAY,EACV,OAAO,EACP,WAAW,EACX,cAAc,EACd,aAAa,EACb,aAAa,EACb,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,UAAU,CAAA;AAMjB,YAAY,EACV,KAAK,EACL,SAAS,EACT,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAMjD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAMnC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAM1D,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAMrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAMnD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAG1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAIxF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AASrD,YAAY,EACV,OAAO,EACP,WAAW,EACX,cAAc,EACd,aAAa,EACb,aAAa,EACb,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,UAAU,CAAA;AAMjB,YAAY,EACV,KAAK,EACL,SAAS,EACT,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAMjD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAMnC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAM1D,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAMrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAMnD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAG1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAIxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAcxF"}

package/dist/src/workflow/expression/index.js

@@ -17,7 +17,7 @@
  * // => true or false
  * ```
  */
-import { tokenize } from './lexer.js';
+import { tokenize, ParseError } from './lexer.js';
 import { parse } from './parser.js';
 import { evaluate } from './evaluator.js';
 export { ParseError, tokenize } from './lexer.js';
@@ -69,3 +69,30 @@ export function evaluateCondition(condition, context) {
     const result = evaluate(ast, context);
     return Boolean(result);
 }
+/**
+ * Interpolate template expressions within a string.
+ *
+ * Finds all `{{ ... }}` expressions in the input string, evaluates each
+ * against the context, and replaces the placeholder with the string
+ * representation of the result.
+ *
+ * @param template - The template string containing `{{ }}` expressions.
+ * @param context  - The sandboxed evaluation context.
+ * @returns The fully resolved string.
+ * @throws {ParseError} on syntax errors in expressions.
+ * @throws {EvaluationError} on runtime errors in expressions.
+ */
+export function interpolateTemplate(template, context) {
+    // Regex to match {{ ... }} expressions (non-greedy)
+    const EXPR_PATTERN = /\{\{(.*?)\}\}/g;
+    return template.replace(EXPR_PATTERN, (_match, expr) => {
+        const trimmed = expr.trim();
+        if (trimmed.length === 0) {
+            throw new ParseError('Empty expression in template', { offset: 0, column: 1 });
+        }
+        const tokens = tokenize(trimmed);
+        const ast = parse(tokens);
+        const result = evaluate(ast, context);
+        return String(result);
+    });
+}

package/dist/src/workflow/expression/lexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/lexer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,gBAAgB,GAChB,eAAe,GACf,eAAe,GACf,UAAU,GACV,WAAW,GACX,YAAY,GACZ,OAAO,GACP,KAAK,CAAA;AAET,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC;AAMD;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;gBAErB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc;CAKtD;AAsED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAsF/C"}
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/lexer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,gBAAgB,GAChB,eAAe,GACf,eAAe,GACf,UAAU,GACV,WAAW,GACX,YAAY,GACZ,OAAO,GACP,KAAK,CAAA;AAET,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC;AAMD;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;gBAErB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc;CAKtD;AAuED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAkI/C"}

package/dist/src/workflow/expression/lexer.js

@@ -26,6 +26,7 @@ export class ParseError extends Error {
 const OPERATORS = new Set([
     'and', 'or', 'not',
     'eq', 'neq', 'gt', 'lt', 'gte', 'lte',
+    'in',
 ]);
 const BOOLEAN_LITERALS = new Set(['true', 'false']);
 // ---------------------------------------------------------------------------
@@ -129,6 +130,15 @@ export function tokenize(input) {
             const start = i;
             while (i < inner.length && isIdentChar(inner[i]))
                 i++;
+            // Dotted variable paths: consume `.` followed by another identifier segment
+            while (i < inner.length &&
+                inner[i] === '.' &&
+                i + 1 < inner.length &&
+                isIdentStart(inner[i + 1])) {
+                i++; // skip the dot
+                while (i < inner.length && isIdentChar(inner[i]))
+                    i++;
+            }
             const word = inner.slice(start, i);
             if (BOOLEAN_LITERALS.has(word)) {
                 tokens.push({ type: 'BooleanLiteral', value: word, position: pos(start) });
@@ -158,6 +168,39 @@ export function tokenize(input) {
             i++;
             continue;
         }
+        // Symbolic comparison operators
+        if (ch === '=' && i + 1 < inner.length && inner[i + 1] === '=') {
+            tokens.push({ type: 'Operator', value: 'eq', position: pos(i) });
+            i += 2;
+            continue;
+        }
+        if (ch === '!' && i + 1 < inner.length && inner[i + 1] === '=') {
+            tokens.push({ type: 'Operator', value: 'neq', position: pos(i) });
+            i += 2;
+            continue;
+        }
+        if (ch === '>') {
+            if (i + 1 < inner.length && inner[i + 1] === '=') {
+                tokens.push({ type: 'Operator', value: 'gte', position: pos(i) });
+                i += 2;
+            }
+            else {
+                tokens.push({ type: 'Operator', value: 'gt', position: pos(i) });
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === '<') {
+            if (i + 1 < inner.length && inner[i + 1] === '=') {
+                tokens.push({ type: 'Operator', value: 'lte', position: pos(i) });
+                i += 2;
+            }
+            else {
+                tokens.push({ type: 'Operator', value: 'lt', position: pos(i) });
+                i += 1;
+            }
+            continue;
+        }
         // Unknown character
         throw new ParseError(`Unexpected character '${ch}'`, pos(i));
     }

package/dist/src/workflow/expression/parser.js

@@ -14,7 +14,7 @@ import { ParseError } from './lexer.js';
 // ---------------------------------------------------------------------------
 // Operator sets
 // ---------------------------------------------------------------------------
-const COMPARISON_OPERATORS = new Set(['eq', 'neq', 'gt', 'lt', 'gte', 'lte']);
+const COMPARISON_OPERATORS = new Set(['eq', 'neq', 'gt', 'lt', 'gte', 'lte', 'in']);
 function peek(state) {
     return state.tokens[state.pos];
 }

package/dist/src/workflow/index.d.ts

@@ -4,9 +4,9 @@
  * Declarative workflow graph definitions using YAML (v1.1 schema extension).
  * Defines phases, transitions, escalation ladder, gates, and parallelism.
  */
-export type { EscalationStrategy, PhaseDefinition, PhaseOutputDeclaration, PhaseInputDeclaration, TransitionDefinition, EscalationLadderRung, EscalationConfig, GateDefinition, ParallelismGroupDefinition, WorkflowDefinition, BranchingDefinition, TemplateRetryConfig, TemplateTimeoutConfig, } from './workflow-types.js';
-export { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
-export { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
+export type { EscalationStrategy, PhaseDefinition, PhaseOutputDeclaration, PhaseInputDeclaration, TransitionDefinition, EscalationLadderRung, EscalationConfig, GateDefinition, ParallelismGroupDefinition, WorkflowDefinition, BranchingDefinition, TemplateRetryConfig, TemplateTimeoutConfig, WorkflowTriggerDefinition, ProviderRequirement, WorkflowConfig, StepDefinition, NodeDefinition, WorkflowDefinitionV2, AnyWorkflowDefinition, } from './workflow-types.js';
+export { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, WorkflowTriggerDefinitionSchema, ProviderRequirementSchema, WorkflowConfigSchema, StepDefinitionSchema, NodeDefinitionSchema, WorkflowDefinitionV2Schema, AnyWorkflowDefinitionSchema, validateAnyWorkflowDefinition, crossValidateWorkflowV2, } from './workflow-types.js';
+export { loadWorkflowDefinitionFile, loadAnyWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
 export type { WorkflowRegistryConfig, WorkflowStoreSource } from './workflow-registry.js';
 export { WorkflowRegistry } from './workflow-registry.js';
 export type { TransitionContext, TransitionResult } from './transition-engine.js';

package/dist/src/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/workflow/index.ts"],"names":[],"mappings":"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"}

package/dist/src/workflow/index.js

@@ -4,8 +4,10 @@
  * Declarative workflow graph definitions using YAML (v1.1 schema extension).
  * Defines phases, transitions, escalation ladder, gates, and parallelism.
  */
-export { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, } from './workflow-types.js';
-export { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
+export { PhaseDefinitionSchema, PhaseOutputDeclarationSchema, PhaseInputDeclarationSchema, TransitionDefinitionSchema, EscalationLadderRungSchema, EscalationConfigSchema, GateDefinitionSchema, ParallelismGroupDefinitionSchema, WorkflowDefinitionSchema, BranchingDefinitionSchema, TemplateRetryConfigSchema, TemplateTimeoutConfigSchema, validateWorkflowDefinition, 
+// v2 schemas & validation
+WorkflowTriggerDefinitionSchema, ProviderRequirementSchema, WorkflowConfigSchema, StepDefinitionSchema, NodeDefinitionSchema, WorkflowDefinitionV2Schema, AnyWorkflowDefinitionSchema, validateAnyWorkflowDefinition, crossValidateWorkflowV2, } from './workflow-types.js';
+export { loadWorkflowDefinitionFile, loadAnyWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
 export { WorkflowRegistry } from './workflow-registry.js';
 export { evaluateTransitions } from './transition-engine.js';
 export { evaluateBranching } from './branching-router.js';