@renseiai/agentfactory 0.8.7 → 0.8.8

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

@@ -0,0 +1,28 @@
+/**
+ * Duration Parser
+ *
+ * Parses human-readable duration strings into milliseconds.
+ * Supported units: "m" (minutes), "h" (hours), "d" (days).
+ *
+ * Examples:
+ *   "30m" → 1_800_000  (30 minutes)
+ *   "2h"  → 7_200_000  (2 hours)
+ *   "1d"  → 86_400_000 (1 day)
+ */
+/**
+ * Error thrown for invalid duration strings.
+ */
+export declare class DurationParseError extends Error {
+    constructor(input: string, reason: string);
+}
+/**
+ * Parse a duration string into milliseconds.
+ * Supports: "Nm" (minutes), "Nh" (hours), "Nd" (days)
+ * Examples: "30m" → 1800000, "2h" → 7200000, "1d" → 86400000
+ *
+ * @param duration - Duration string (e.g., "30m", "2h", "1d")
+ * @returns Duration in milliseconds
+ * @throws DurationParseError for invalid input
+ */
+export declare function parseDuration(duration: string): number;
+//# sourceMappingURL=duration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../src/workflow/duration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAkBH;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI1C;AAMD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBtD"}

package/dist/src/workflow/duration.js

@@ -0,0 +1,57 @@
+/**
+ * Duration Parser
+ *
+ * Parses human-readable duration strings into milliseconds.
+ * Supported units: "m" (minutes), "h" (hours), "d" (days).
+ *
+ * Examples:
+ *   "30m" → 1_800_000  (30 minutes)
+ *   "2h"  → 7_200_000  (2 hours)
+ *   "1d"  → 86_400_000 (1 day)
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const UNIT_TO_MS = {
+    m: 60 * 1000, // minutes
+    h: 60 * 60 * 1000, // hours
+    d: 24 * 60 * 60 * 1000, // days
+};
+const DURATION_REGEX = /^(\d+)(m|h|d)$/;
+// ---------------------------------------------------------------------------
+// Error
+// ---------------------------------------------------------------------------
+/**
+ * Error thrown for invalid duration strings.
+ */
+export class DurationParseError extends Error {
+    constructor(input, reason) {
+        super(`Invalid duration "${input}": ${reason}`);
+        this.name = 'DurationParseError';
+    }
+}
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+/**
+ * Parse a duration string into milliseconds.
+ * Supports: "Nm" (minutes), "Nh" (hours), "Nd" (days)
+ * Examples: "30m" → 1800000, "2h" → 7200000, "1d" → 86400000
+ *
+ * @param duration - Duration string (e.g., "30m", "2h", "1d")
+ * @returns Duration in milliseconds
+ * @throws DurationParseError for invalid input
+ */
+export function parseDuration(duration) {
+    if (!duration || typeof duration !== 'string') {
+        throw new DurationParseError(String(duration), 'duration must be a non-empty string');
+    }
+    const trimmed = duration.trim();
+    const match = DURATION_REGEX.exec(trimmed);
+    if (!match) {
+        throw new DurationParseError(trimmed, 'expected format "<number><unit>" where unit is m (minutes), h (hours), or d (days)');
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    return value * UNIT_TO_MS[unit];
+}

package/dist/src/workflow/duration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=duration.test.d.ts.map

package/dist/src/workflow/duration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.test.d.ts","sourceRoot":"","sources":["../../../src/workflow/duration.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { parseDuration, DurationParseError } from './duration.js';
+describe('parseDuration', () => {
+    // -------------------------------------------------------------------------
+    // Valid inputs
+    // -------------------------------------------------------------------------
+    it('parses "30m" to 1800000 ms', () => {
+        expect(parseDuration('30m')).toBe(1_800_000);
+    });
+    it('parses "2h" to 7200000 ms', () => {
+        expect(parseDuration('2h')).toBe(7_200_000);
+    });
+    it('parses "1d" to 86400000 ms', () => {
+        expect(parseDuration('1d')).toBe(86_400_000);
+    });
+    it('parses "90m" to 5400000 ms', () => {
+        expect(parseDuration('90m')).toBe(5_400_000);
+    });
+    it('parses "0m" to 0', () => {
+        expect(parseDuration('0m')).toBe(0);
+    });
+    it('parses "0h" to 0', () => {
+        expect(parseDuration('0h')).toBe(0);
+    });
+    it('parses "0d" to 0', () => {
+        expect(parseDuration('0d')).toBe(0);
+    });
+    it('parses large values like "365d"', () => {
+        expect(parseDuration('365d')).toBe(365 * 24 * 60 * 60 * 1000);
+    });
+    // -------------------------------------------------------------------------
+    // Invalid inputs — missing unit
+    // -------------------------------------------------------------------------
+    it('throws DurationParseError for "30" (missing unit)', () => {
+        expect(() => parseDuration('30')).toThrow(DurationParseError);
+        expect(() => parseDuration('30')).toThrow(/Invalid duration/);
+    });
+    it('throws DurationParseError for "m" (missing number)', () => {
+        expect(() => parseDuration('m')).toThrow(DurationParseError);
+    });
+    it('throws DurationParseError for empty string', () => {
+        expect(() => parseDuration('')).toThrow(DurationParseError);
+    });
+    it('throws DurationParseError for "abc" (nonsense input)', () => {
+        expect(() => parseDuration('abc')).toThrow(DurationParseError);
+    });
+    it('throws DurationParseError for negative numbers like "-5m"', () => {
+        expect(() => parseDuration('-5m')).toThrow(DurationParseError);
+    });
+    // -------------------------------------------------------------------------
+    // Invalid inputs — unsupported units
+    // -------------------------------------------------------------------------
+    it('throws DurationParseError for "30s" (seconds not supported)', () => {
+        expect(() => parseDuration('30s')).toThrow(DurationParseError);
+    });
+    it('throws DurationParseError for "2w" (weeks not supported)', () => {
+        expect(() => parseDuration('2w')).toThrow(DurationParseError);
+    });
+    it('throws DurationParseError for "1y" (years not supported)', () => {
+        expect(() => parseDuration('1y')).toThrow(DurationParseError);
+    });
+    // -------------------------------------------------------------------------
+    // Edge cases
+    // -------------------------------------------------------------------------
+    it('throws DurationParseError for decimal values like "1.5h"', () => {
+        expect(() => parseDuration('1.5h')).toThrow(DurationParseError);
+    });
+    it('throws DurationParseError for multiple units like "1h30m"', () => {
+        expect(() => parseDuration('1h30m')).toThrow(DurationParseError);
+    });
+    it('handles whitespace around the value', () => {
+        expect(parseDuration(' 30m ')).toBe(1_800_000);
+    });
+});

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

@@ -0,0 +1,53 @@
+/**
+ * Expression AST Node Definitions
+ *
+ * Typed AST nodes for parsed condition expressions from WorkflowDefinition
+ * `branching[].condition` fields. Uses discriminated unions with a literal
+ * `type` field for exhaustive pattern matching.
+ */
+/** A reference to a named variable, e.g. `isParentIssue`, `priority` */
+export interface VariableRef {
+    readonly type: 'VariableRef';
+    readonly name: string;
+}
+/** A boolean literal: `true` or `false` */
+export interface BooleanLiteral {
+    readonly type: 'BooleanLiteral';
+    readonly value: boolean;
+}
+/** A single-quoted string literal, e.g. `'bug'` */
+export interface StringLiteral {
+    readonly type: 'StringLiteral';
+    readonly value: string;
+}
+/** A numeric literal, e.g. `3`, `2.5` */
+export interface NumberLiteral {
+    readonly type: 'NumberLiteral';
+    readonly value: number;
+}
+/** Unary operators */
+export type UnaryOperator = 'not';
+/** Binary logical/comparison operators */
+export type BinaryOperator = 'and' | 'or' | 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte';
+/** A unary operation, e.g. `not <expr>` */
+export interface UnaryOp {
+    readonly type: 'UnaryOp';
+    readonly operator: UnaryOperator;
+    readonly operand: ASTNode;
+}
+/** A binary operation, e.g. `<expr> and <expr>`, `<expr> gt <expr>` */
+export interface BinaryOp {
+    readonly type: 'BinaryOp';
+    readonly operator: BinaryOperator;
+    readonly left: ASTNode;
+    readonly right: ASTNode;
+}
+/** A function call, e.g. `hasLabel('bug')`, `hasDirective('hotfix')` */
+export interface FunctionCall {
+    readonly type: 'FunctionCall';
+    readonly name: string;
+    readonly args: ASTNode[];
+}
+/** Discriminated union of all AST node types */
+export type ASTNode = VariableRef | BooleanLiteral | StringLiteral | NumberLiteral | UnaryOp | BinaryOp | FunctionCall;
+//# sourceMappingURL=ast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/ast.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAED,mDAAmD;AACnD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,yCAAyC;AACzC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAMD,sBAAsB;AACtB,MAAM,MAAM,aAAa,GAAG,KAAK,CAAA;AAEjC,0CAA0C;AAC1C,MAAM,MAAM,cAAc,GACtB,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,KAAK,CAAA;AAET,2CAA2C;AAC3C,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,uEAAuE;AACvE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAMD,wEAAwE;AACxE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CACzB;AAMD,gDAAgD;AAChD,MAAM,MAAM,OAAO,GACf,WAAW,GACX,cAAc,GACd,aAAa,GACb,aAAa,GACb,OAAO,GACP,QAAQ,GACR,YAAY,CAAA"}

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

@@ -0,0 +1,8 @@
+/**
+ * Expression AST Node Definitions
+ *
+ * Typed AST nodes for parsed condition expressions from WorkflowDefinition
+ * `branching[].condition` fields. Uses discriminated unions with a literal
+ * `type` field for exhaustive pattern matching.
+ */
+export {};

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

@@ -0,0 +1,40 @@
+/**
+ * Evaluation Context
+ *
+ * Defines the sandboxed context in which expression ASTs are evaluated.
+ * The context provides variable bindings and registered helper functions,
+ * with no access to globals, prototypes, or dynamic code execution.
+ */
+import type { GovernorIssue } from '../../governor/governor-types.js';
+/**
+ * The sandboxed evaluation context passed to the expression evaluator.
+ *
+ * - `variables` holds named values that `VariableRef` nodes resolve against.
+ * - `functions` holds callable helpers that `FunctionCall` nodes invoke.
+ */
+export interface EvaluationContext {
+    /** Variable bindings — e.g., { isParentIssue: true, priority: 3 } */
+    readonly variables: Record<string, unknown>;
+    /** Registered helper functions */
+    readonly functions: Record<string, (...args: unknown[]) => unknown>;
+}
+export interface BuildContextOptions {
+    /** Whether the issue has sub-issues (i.e., it is a parent issue) */
+    hasSubIssues?: boolean;
+}
+/**
+ * Build an EvaluationContext from a GovernorIssue and optional phase state.
+ *
+ * This is the primary way to create contexts for condition evaluation
+ * during workflow transitions. It:
+ *   1. Extracts well-known variables from the issue (status, labels, etc.)
+ *   2. Merges in phase-state booleans (researchCompleted, etc.)
+ *   3. Registers all built-in helper functions
+ *
+ * @param issue      - The issue being evaluated.
+ * @param phaseState - Optional map of phase completion flags.
+ * @param opts       - Additional context not on the issue itself.
+ * @returns A fully populated EvaluationContext.
+ */
+export declare function buildEvaluationContext(issue: GovernorIssue, phaseState?: Record<string, boolean>, opts?: BuildContextOptions): EvaluationContext;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAOrE;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,kCAAkC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAA;CACpE;AAMD,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,IAAI,CAAC,EAAE,mBAAmB,GACzB,iBAAiB,CAkBnB"}

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

@@ -0,0 +1,37 @@
+/**
+ * Evaluation Context
+ *
+ * Defines the sandboxed context in which expression ASTs are evaluated.
+ * The context provides variable bindings and registered helper functions,
+ * with no access to globals, prototypes, or dynamic code execution.
+ */
+import { createBuiltinHelpers } from './helpers.js';
+/**
+ * Build an EvaluationContext from a GovernorIssue and optional phase state.
+ *
+ * This is the primary way to create contexts for condition evaluation
+ * during workflow transitions. It:
+ *   1. Extracts well-known variables from the issue (status, labels, etc.)
+ *   2. Merges in phase-state booleans (researchCompleted, etc.)
+ *   3. Registers all built-in helper functions
+ *
+ * @param issue      - The issue being evaluated.
+ * @param phaseState - Optional map of phase completion flags.
+ * @param opts       - Additional context not on the issue itself.
+ * @returns A fully populated EvaluationContext.
+ */
+export function buildEvaluationContext(issue, phaseState, opts) {
+    const hasSubIssues = opts?.hasSubIssues ?? false;
+    const variables = {
+        // Issue-derived variables
+        isParentIssue: hasSubIssues,
+        labels: issue.labels,
+        status: issue.status,
+        priority: 0, // GovernorIssue doesn't carry priority; default to 0
+        // Spread phase-state booleans so expressions like
+        // `researchCompleted and not backlogCreationCompleted` work directly.
+        ...phaseState,
+    };
+    const functions = createBuiltinHelpers(issue, { hasSubIssues });
+    return { variables, functions };
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Expression Evaluator (Tree-Walking)
+ *
+ * Walks a parsed AST and produces a result value within a sandboxed
+ * EvaluationContext. No `eval()`, `new Function()`, or dynamic code
+ * execution is used — evaluation is a pure recursive descent over the
+ * typed AST nodes.
+ */
+import type { ASTNode } from './ast.js';
+import type { EvaluationContext } from './context.js';
+/**
+ * Error thrown when expression evaluation fails at runtime.
+ *
+ * Examples: unknown function name, type mismatch in numeric comparison.
+ */
+export declare class EvaluationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Evaluate an AST node within the given context.
+ *
+ * @param ast     - The AST node to evaluate.
+ * @param context - The sandboxed evaluation context.
+ * @returns The result of evaluating the node.
+ * @throws {EvaluationError} on unknown functions or type mismatches.
+ */
+export declare function evaluate(ast: ASTNode, context: EvaluationContext): unknown;
+//# sourceMappingURL=evaluator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAMrD;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAiBD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CA6D1E"}

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

@@ -0,0 +1,165 @@
+/**
+ * Expression Evaluator (Tree-Walking)
+ *
+ * Walks a parsed AST and produces a result value within a sandboxed
+ * EvaluationContext. No `eval()`, `new Function()`, or dynamic code
+ * execution is used — evaluation is a pure recursive descent over the
+ * typed AST nodes.
+ */
+// ---------------------------------------------------------------------------
+// EvaluationError
+// ---------------------------------------------------------------------------
+/**
+ * Error thrown when expression evaluation fails at runtime.
+ *
+ * Examples: unknown function name, type mismatch in numeric comparison.
+ */
+export class EvaluationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EvaluationError';
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Coerce an arbitrary value to a boolean using JavaScript truthiness rules.
+ */
+function toBool(value) {
+    return Boolean(value);
+}
+// ---------------------------------------------------------------------------
+// Evaluator
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate an AST node within the given context.
+ *
+ * @param ast     - The AST node to evaluate.
+ * @param context - The sandboxed evaluation context.
+ * @returns The result of evaluating the node.
+ * @throws {EvaluationError} on unknown functions or type mismatches.
+ */
+export function evaluate(ast, context) {
+    switch (ast.type) {
+        // -------------------------------------------------------------------
+        // Literals — return value directly
+        // -------------------------------------------------------------------
+        case 'BooleanLiteral':
+            return ast.value;
+        case 'StringLiteral':
+            return ast.value;
+        case 'NumberLiteral':
+            return ast.value;
+        // -------------------------------------------------------------------
+        // Variable reference — look up in context, default to false
+        // -------------------------------------------------------------------
+        case 'VariableRef': {
+            const value = context.variables[ast.name];
+            // Undefined variables resolve to `false` (no crash)
+            if (value === undefined) {
+                return false;
+            }
+            return value;
+        }
+        // -------------------------------------------------------------------
+        // Unary operator
+        // -------------------------------------------------------------------
+        case 'UnaryOp': {
+            // Currently only 'not' is supported
+            const operand = evaluate(ast.operand, context);
+            return !toBool(operand);
+        }
+        // -------------------------------------------------------------------
+        // Binary operator
+        // -------------------------------------------------------------------
+        case 'BinaryOp':
+            return evaluateBinaryOp(ast.operator, ast.left, ast.right, context);
+        // -------------------------------------------------------------------
+        // Function call
+        // -------------------------------------------------------------------
+        case 'FunctionCall': {
+            const fn = context.functions[ast.name];
+            if (!fn) {
+                throw new EvaluationError(`Unknown function '${ast.name}'. Available functions: ${Object.keys(context.functions).join(', ') || '(none)'}`);
+            }
+            const args = ast.args.map((arg) => evaluate(arg, context));
+            return fn(...args);
+        }
+        default: {
+            // Exhaustive check — should never reach here with a well-typed AST
+            const _exhaustive = ast;
+            throw new EvaluationError(`Unknown AST node type: ${_exhaustive.type}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Binary operator evaluation
+// ---------------------------------------------------------------------------
+function evaluateBinaryOp(operator, left, right, context) {
+    switch (operator) {
+        // Short-circuit logical operators
+        case 'and': {
+            const leftVal = evaluate(left, context);
+            if (!toBool(leftVal))
+                return leftVal;
+            return evaluate(right, context);
+        }
+        case 'or': {
+            const leftVal = evaluate(left, context);
+            if (toBool(leftVal))
+                return leftVal;
+            return evaluate(right, context);
+        }
+        // Equality — works across all types
+        case 'eq': {
+            const leftVal = evaluate(left, context);
+            const rightVal = evaluate(right, context);
+            return leftVal === rightVal;
+        }
+        case 'neq': {
+            const leftVal = evaluate(left, context);
+            const rightVal = evaluate(right, context);
+            return leftVal !== rightVal;
+        }
+        // Ordering comparisons — require matching numeric types
+        case 'gt':
+        case 'lt':
+        case 'gte':
+        case 'lte': {
+            const leftVal = evaluate(left, context);
+            const rightVal = evaluate(right, context);
+            return evaluateOrdering(operator, leftVal, rightVal);
+        }
+        default:
+            throw new EvaluationError(`Unknown operator '${operator}'`);
+    }
+}
+function evaluateOrdering(operator, left, right) {
+    // Both must be numbers or both must be strings for ordering comparisons
+    if (typeof left === 'number' && typeof right === 'number') {
+        switch (operator) {
+            case 'gt': return left > right;
+            case 'lt': return left < right;
+            case 'gte': return left >= right;
+            case 'lte': return left <= right;
+        }
+    }
+    if (typeof left === 'string' && typeof right === 'string') {
+        switch (operator) {
+            case 'gt': return left > right;
+            case 'lt': return left < right;
+            case 'gte': return left >= right;
+            case 'lte': return left <= right;
+        }
+    }
+    throw new EvaluationError(`Cannot compare ${typeLabel(left)} and ${typeLabel(right)} with '${operator}'. ` +
+        `Both operands must be numbers or both must be strings.`);
+}
+function typeLabel(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}

package/dist/src/workflow/expression/evaluator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evaluator.test.d.ts.map

package/dist/src/workflow/expression/evaluator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.test.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/evaluator.test.ts"],"names":[],"mappings":""}