@renseiai/agentfactory 0.8.7 → 0.8.9

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

@@ -0,0 +1,71 @@
+/**
+ * Expression Parser & Evaluator — Public API
+ *
+ * Parses Handlebars-style condition strings from WorkflowDefinition
+ * transitions into a typed AST, and evaluates them within a sandboxed
+ * context.
+ *
+ * @example
+ * ```ts
+ * import { parseExpression, evaluateCondition, buildEvaluationContext } from './expression/index.js'
+ *
+ * const ast = parseExpression("{{ hasLabel('bug') and priority gt 3 }}")
+ * // => BinaryOp(AND, FunctionCall("hasLabel", [StringLiteral("bug")]), BinaryOp(GT, ...))
+ *
+ * const ctx = buildEvaluationContext(issue, phaseState)
+ * const result = evaluateCondition("{{ hasLabel('bug') }}", ctx)
+ * // => true or false
+ * ```
+ */
+import { tokenize } from './lexer.js';
+import { parse } from './parser.js';
+import { evaluate } from './evaluator.js';
+export { ParseError, tokenize } from './lexer.js';
+// ---------------------------------------------------------------------------
+// Re-exports — Parser
+// ---------------------------------------------------------------------------
+export { parse } from './parser.js';
+// ---------------------------------------------------------------------------
+// Re-exports — Evaluator
+// ---------------------------------------------------------------------------
+export { evaluate, EvaluationError } from './evaluator.js';
+export { buildEvaluationContext } from './context.js';
+// ---------------------------------------------------------------------------
+// Re-exports — Helpers
+// ---------------------------------------------------------------------------
+export { createBuiltinHelpers } from './helpers.js';
+// ---------------------------------------------------------------------------
+// Convenience entry points
+// ---------------------------------------------------------------------------
+/**
+ * Parse a condition string into an AST in a single call.
+ *
+ * Combines tokenization and parsing. Accepts strings with or without
+ * `{{ }}` delimiters.
+ *
+ * @param condition - The condition string to parse.
+ * @returns The root AST node.
+ * @throws {ParseError} on invalid input with position information.
+ */
+export function parseExpression(condition) {
+    const tokens = tokenize(condition);
+    return parse(tokens);
+}
+/**
+ * Parse and evaluate a condition string, returning a boolean result.
+ *
+ * This is the primary entry point for workflow transition evaluation.
+ * It combines parsing and evaluation in one call, and coerces the
+ * result to a boolean.
+ *
+ * @param condition - The condition string (with or without `{{ }}`).
+ * @param context   - The sandboxed evaluation context.
+ * @returns `true` if the condition is satisfied, `false` otherwise.
+ * @throws {ParseError} on syntax errors.
+ * @throws {EvaluationError} on runtime errors (unknown functions, type mismatches).
+ */
+export function evaluateCondition(condition, context) {
+    const ast = parseExpression(condition);
+    const result = evaluate(ast, context);
+    return Boolean(result);
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Expression Lexer (Tokenizer)
+ *
+ * Converts a condition string (with optional `{{ }}` delimiters) into a
+ * flat token stream. Each token carries source-position info for error
+ * reporting downstream.
+ */
+export type TokenType = 'Identifier' | 'BooleanLiteral' | 'StringLiteral' | 'NumberLiteral' | 'Operator' | 'LeftParen' | 'RightParen' | 'Comma' | 'EOF';
+/** Source position within the *inner* expression (after delimiter stripping). */
+export interface SourcePosition {
+    /** 0-based character offset */
+    readonly offset: number;
+    /** 1-based column (same as offset + 1 since expressions are single-line) */
+    readonly column: number;
+}
+export interface Token {
+    readonly type: TokenType;
+    readonly value: string;
+    readonly position: SourcePosition;
+}
+/**
+ * Error thrown when the lexer or parser encounters invalid input.
+ * Carries source-position information for precise error messages.
+ */
+export declare class ParseError extends Error {
+    readonly position: SourcePosition;
+    constructor(message: string, position: SourcePosition);
+}
+/**
+ * Tokenize a condition string into a flat token array.
+ *
+ * @param input - The condition string, optionally wrapped in `{{ }}`.
+ * @returns An array of tokens ending with an `EOF` token.
+ * @throws {ParseError} on unexpected characters or unterminated strings.
+ */
+export declare function tokenize(input: string): Token[];
+//# sourceMappingURL=lexer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,166 @@
+/**
+ * Expression Lexer (Tokenizer)
+ *
+ * Converts a condition string (with optional `{{ }}` delimiters) into a
+ * flat token stream. Each token carries source-position info for error
+ * reporting downstream.
+ */
+// ---------------------------------------------------------------------------
+// ParseError
+// ---------------------------------------------------------------------------
+/**
+ * Error thrown when the lexer or parser encounters invalid input.
+ * Carries source-position information for precise error messages.
+ */
+export class ParseError extends Error {
+    position;
+    constructor(message, position) {
+        super(`${message} at column ${position.column}`);
+        this.name = 'ParseError';
+        this.position = position;
+    }
+}
+// ---------------------------------------------------------------------------
+// Keyword sets
+// ---------------------------------------------------------------------------
+const OPERATORS = new Set([
+    'and', 'or', 'not',
+    'eq', 'neq', 'gt', 'lt', 'gte', 'lte',
+]);
+const BOOLEAN_LITERALS = new Set(['true', 'false']);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function isWhitespace(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+}
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+function isIdentStart(ch) {
+    return (ch >= 'a' && ch <= 'z') ||
+        (ch >= 'A' && ch <= 'Z') ||
+        ch === '_';
+}
+function isIdentChar(ch) {
+    return isIdentStart(ch) || isDigit(ch);
+}
+function pos(offset) {
+    return { offset, column: offset + 1 };
+}
+// ---------------------------------------------------------------------------
+// Strip delimiters
+// ---------------------------------------------------------------------------
+/**
+ * Remove the `{{ }}` Handlebars-style delimiters from a condition string.
+ * Returns the inner content and the offset of the inner content within
+ * the original string (so positions map back correctly).
+ */
+function stripDelimiters(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('{{') && trimmed.endsWith('}}')) {
+        const openIdx = input.indexOf('{{');
+        // +2 to skip past the opening {{
+        const innerStart = openIdx + 2;
+        const closeIdx = input.lastIndexOf('}}');
+        return {
+            inner: input.slice(innerStart, closeIdx),
+            offset: innerStart,
+        };
+    }
+    // No delimiters — treat as raw expression
+    return { inner: input, offset: 0 };
+}
+// ---------------------------------------------------------------------------
+// Tokenize
+// ---------------------------------------------------------------------------
+/**
+ * Tokenize a condition string into a flat token array.
+ *
+ * @param input - The condition string, optionally wrapped in `{{ }}`.
+ * @returns An array of tokens ending with an `EOF` token.
+ * @throws {ParseError} on unexpected characters or unterminated strings.
+ */
+export function tokenize(input) {
+    const { inner } = stripDelimiters(input);
+    const tokens = [];
+    let i = 0;
+    while (i < inner.length) {
+        const ch = inner[i];
+        // Skip whitespace
+        if (isWhitespace(ch)) {
+            i++;
+            continue;
+        }
+        // Single-quoted string literal
+        if (ch === "'") {
+            const start = i;
+            i++; // skip opening quote
+            let value = '';
+            while (i < inner.length && inner[i] !== "'") {
+                value += inner[i];
+                i++;
+            }
+            if (i >= inner.length) {
+                throw new ParseError('Unterminated string literal', pos(start));
+            }
+            i++; // skip closing quote
+            tokens.push({ type: 'StringLiteral', value, position: pos(start) });
+            continue;
+        }
+        // Number literal
+        if (isDigit(ch) || (ch === '-' && i + 1 < inner.length && isDigit(inner[i + 1]))) {
+            const start = i;
+            if (ch === '-')
+                i++; // consume negative sign
+            while (i < inner.length && isDigit(inner[i]))
+                i++;
+            // Decimal part
+            if (i < inner.length && inner[i] === '.' && i + 1 < inner.length && isDigit(inner[i + 1])) {
+                i++; // skip dot
+                while (i < inner.length && isDigit(inner[i]))
+                    i++;
+            }
+            tokens.push({ type: 'NumberLiteral', value: inner.slice(start, i), position: pos(start) });
+            continue;
+        }
+        // Identifiers, keywords, operators, boolean literals
+        if (isIdentStart(ch)) {
+            const start = i;
+            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) });
+            }
+            else if (OPERATORS.has(word)) {
+                tokens.push({ type: 'Operator', value: word, position: pos(start) });
+            }
+            else {
+                tokens.push({ type: 'Identifier', value: word, position: pos(start) });
+            }
+            continue;
+        }
+        // Parentheses
+        if (ch === '(') {
+            tokens.push({ type: 'LeftParen', value: '(', position: pos(i) });
+            i++;
+            continue;
+        }
+        if (ch === ')') {
+            tokens.push({ type: 'RightParen', value: ')', position: pos(i) });
+            i++;
+            continue;
+        }
+        // Comma
+        if (ch === ',') {
+            tokens.push({ type: 'Comma', value: ',', position: pos(i) });
+            i++;
+            continue;
+        }
+        // Unknown character
+        throw new ParseError(`Unexpected character '${ch}'`, pos(i));
+    }
+    tokens.push({ type: 'EOF', value: '', position: pos(i) });
+    return tokens;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Expression Parser (Recursive Descent)
+ *
+ * Parses a token stream (produced by the lexer) into a typed AST.
+ *
+ * Operator precedence (lowest to highest):
+ *   1. `or`
+ *   2. `and`
+ *   3. comparisons: `eq`, `neq`, `gt`, `lt`, `gte`, `lte`
+ *   4. `not` (unary prefix)
+ *   5. primary: literals, variable refs, function calls, parenthesized exprs
+ */
+import type { ASTNode } from './ast.js';
+import type { Token } from './lexer.js';
+/**
+ * Parse a token stream into an AST.
+ *
+ * @param tokens - Token array produced by `tokenize()`.
+ * @returns The root AST node.
+ * @throws {ParseError} on syntax errors.
+ */
+export declare function parse(tokens: Token[]): ASTNode;
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/workflow/expression/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAyLvC;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAkB9C"}

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

@@ -0,0 +1,181 @@
+/**
+ * Expression Parser (Recursive Descent)
+ *
+ * Parses a token stream (produced by the lexer) into a typed AST.
+ *
+ * Operator precedence (lowest to highest):
+ *   1. `or`
+ *   2. `and`
+ *   3. comparisons: `eq`, `neq`, `gt`, `lt`, `gte`, `lte`
+ *   4. `not` (unary prefix)
+ *   5. primary: literals, variable refs, function calls, parenthesized exprs
+ */
+import { ParseError } from './lexer.js';
+// ---------------------------------------------------------------------------
+// Operator sets
+// ---------------------------------------------------------------------------
+const COMPARISON_OPERATORS = new Set(['eq', 'neq', 'gt', 'lt', 'gte', 'lte']);
+function peek(state) {
+    return state.tokens[state.pos];
+}
+function advance(state) {
+    const token = state.tokens[state.pos];
+    state.pos++;
+    return token;
+}
+function expect(state, type, value) {
+    const token = peek(state);
+    if (token.type !== type || (value !== undefined && token.value !== value)) {
+        const expected = value ? `'${value}'` : type;
+        const got = token.type === 'EOF' ? 'end of expression' : `'${token.value}'`;
+        throw new ParseError(`Expected ${expected} but got ${got}`, token.position);
+    }
+    return advance(state);
+}
+// ---------------------------------------------------------------------------
+// Grammar rules
+// ---------------------------------------------------------------------------
+/**
+ * expression := orExpr
+ */
+function parseExpression(state) {
+    return parseOr(state);
+}
+/**
+ * orExpr := andExpr ( 'or' andExpr )*
+ */
+function parseOr(state) {
+    let left = parseAnd(state);
+    while (peek(state).type === 'Operator' && peek(state).value === 'or') {
+        advance(state); // consume 'or'
+        const right = parseAnd(state);
+        left = { type: 'BinaryOp', operator: 'or', left, right };
+    }
+    return left;
+}
+/**
+ * andExpr := comparisonExpr ( 'and' comparisonExpr )*
+ */
+function parseAnd(state) {
+    let left = parseComparison(state);
+    while (peek(state).type === 'Operator' && peek(state).value === 'and') {
+        advance(state); // consume 'and'
+        const right = parseComparison(state);
+        left = { type: 'BinaryOp', operator: 'and', left, right };
+    }
+    return left;
+}
+/**
+ * comparisonExpr := unaryExpr ( ('eq'|'neq'|'gt'|'lt'|'gte'|'lte') unaryExpr )?
+ *
+ * Comparisons are non-associative (no chaining).
+ */
+function parseComparison(state) {
+    let left = parseUnary(state);
+    const token = peek(state);
+    if (token.type === 'Operator' && COMPARISON_OPERATORS.has(token.value)) {
+        const operator = advance(state).value;
+        const right = parseUnary(state);
+        left = { type: 'BinaryOp', operator, left, right };
+    }
+    return left;
+}
+/**
+ * unaryExpr := 'not' unaryExpr | primaryExpr
+ */
+function parseUnary(state) {
+    const token = peek(state);
+    if (token.type === 'Operator' && token.value === 'not') {
+        advance(state); // consume 'not'
+        const operand = parseUnary(state);
+        return { type: 'UnaryOp', operator: 'not', operand };
+    }
+    return parsePrimary(state);
+}
+/**
+ * primaryExpr := BooleanLiteral
+ *              | StringLiteral
+ *              | NumberLiteral
+ *              | Identifier '(' argList? ')'   -- function call
+ *              | Identifier                     -- variable ref
+ *              | '(' expression ')'             -- grouped sub-expression
+ */
+function parsePrimary(state) {
+    const token = peek(state);
+    // Boolean literal
+    if (token.type === 'BooleanLiteral') {
+        advance(state);
+        return { type: 'BooleanLiteral', value: token.value === 'true' };
+    }
+    // String literal
+    if (token.type === 'StringLiteral') {
+        advance(state);
+        return { type: 'StringLiteral', value: token.value };
+    }
+    // Number literal
+    if (token.type === 'NumberLiteral') {
+        advance(state);
+        return { type: 'NumberLiteral', value: Number(token.value) };
+    }
+    // Identifier — could be variable ref or function call
+    if (token.type === 'Identifier') {
+        advance(state);
+        // Check for function call: Identifier '(' ...
+        if (peek(state).type === 'LeftParen') {
+            advance(state); // consume '('
+            const args = parseArgList(state);
+            expect(state, 'RightParen');
+            return { type: 'FunctionCall', name: token.value, args };
+        }
+        return { type: 'VariableRef', name: token.value };
+    }
+    // Parenthesized sub-expression
+    if (token.type === 'LeftParen') {
+        advance(state); // consume '('
+        const expr = parseExpression(state);
+        expect(state, 'RightParen');
+        return expr;
+    }
+    // Error: unexpected token
+    const got = token.type === 'EOF' ? 'end of expression' : `'${token.value}'`;
+    throw new ParseError(`Unexpected ${got}`, token.position);
+}
+/**
+ * argList := expression ( ',' expression )*
+ *          | (empty)
+ */
+function parseArgList(state) {
+    const args = [];
+    if (peek(state).type === 'RightParen') {
+        return args;
+    }
+    args.push(parseExpression(state));
+    while (peek(state).type === 'Comma') {
+        advance(state); // consume ','
+        args.push(parseExpression(state));
+    }
+    return args;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Parse a token stream into an AST.
+ *
+ * @param tokens - Token array produced by `tokenize()`.
+ * @returns The root AST node.
+ * @throws {ParseError} on syntax errors.
+ */
+export function parse(tokens) {
+    if (tokens.length === 0 || (tokens.length === 1 && tokens[0].type === 'EOF')) {
+        throw new ParseError('Empty expression', { offset: 0, column: 1 });
+    }
+    const state = { tokens, pos: 0 };
+    const ast = parseExpression(state);
+    // Ensure all tokens were consumed (except EOF)
+    const remaining = peek(state);
+    if (remaining.type !== 'EOF') {
+        throw new ParseError(`Unexpected '${remaining.value}' after expression`, remaining.position);
+    }
+    return ast;
+}

package/dist/src/workflow/gate-state.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Gate State Persistence Layer
+ *
+ * Manages gate lifecycle state for workflow execution gates (signal, timer, webhook).
+ * Uses a storage adapter pattern so that packages/core does not depend on
+ * packages/server (Redis) directly.
+ *
+ * Gates are external conditions that can pause workflow phase transitions until
+ * a condition is met (e.g., human approval signal, timer expiration, webhook callback).
+ */
+import type { GateDefinition } from './workflow-types.js';
+/**
+ * Persisted state for a single gate instance tied to an issue
+ */
+export interface GateState {
+    /** The issue this gate is associated with */
+    issueId: string;
+    /** Unique gate name (from GateDefinition) */
+    gateName: string;
+    /** Gate type: signal (external event), timer (time-based), webhook (HTTP callback) */
+    gateType: 'signal' | 'timer' | 'webhook';
+    /** Current gate status */
+    status: 'pending' | 'active' | 'satisfied' | 'timed-out';
+    /** When the gate was triggered (phase entered), epoch ms */
+    activatedAt: number;
+    /** When the gate condition was met, epoch ms */
+    satisfiedAt?: number;
+    /** When the timeout fired, epoch ms */
+    timedOutAt?: number;
+    /** Action to take when gate times out */
+    timeoutAction?: 'escalate' | 'skip' | 'fail';
+    /** What satisfied the gate (comment ID, webhook payload hash, timer ID) */
+    signalSource?: string;
+    /** Authentication token for webhook gates (used to validate incoming callbacks) */
+    webhookToken?: string;
+    /** Duration string from gate definition (e.g., "4h") */
+    timeoutDuration?: string;
+    /** Computed absolute timestamp for timeout deadline, epoch ms */
+    timeoutDeadline?: number;
+}
+/**
+ * Storage adapter for gate state persistence.
+ * Implementations can back this with Redis, in-memory maps, etc.
+ */
+export interface GateStorage {
+    /** Get the state of a specific gate for an issue */
+    getGateState(issueId: string, gateName: string): Promise<GateState | null>;
+    /** Set the state of a specific gate for an issue */
+    setGateState(issueId: string, gateName: string, state: GateState): Promise<void>;
+    /** Get all active (status === 'active') gates for an issue */
+    getActiveGates(issueId: string): Promise<GateState[]>;
+    /** Clear all gate states for an issue */
+    clearGateStates(issueId: string): Promise<void>;
+}
+/**
+ * In-memory gate storage for testing and local development
+ */
+export declare class InMemoryGateStorage implements GateStorage {
+    private store;
+    /** Build a composite key from issueId and gateName */
+    private key;
+    getGateState(issueId: string, gateName: string): Promise<GateState | null>;
+    setGateState(issueId: string, gateName: string, state: GateState): Promise<void>;
+    getActiveGates(issueId: string): Promise<GateState[]>;
+    clearGateStates(issueId: string): Promise<void>;
+}
+/**
+ * Initialize the gate state manager with a storage adapter.
+ * Must be called before using gate state management functions.
+ */
+export declare function initGateStorage(storage: GateStorage): void;
+/**
+ * Parse a duration string into milliseconds.
+ *
+ * Supported formats:
+ * - "15s" - seconds
+ * - "30m" - minutes
+ * - "4h"  - hours
+ * - "2d"  - days
+ *
+ * @param duration - Duration string (e.g., "4h", "30m", "2d", "15s")
+ * @returns Duration in milliseconds
+ * @throws Error if the duration format is invalid
+ */
+export declare function parseDuration(duration: string): number;
+/**
+ * Activate a gate for an issue, creating an active gate state with a computed
+ * timeout deadline (if the gate definition includes a timeout).
+ *
+ * @param issueId - The issue identifier
+ * @param gateDef - The gate definition from the workflow
+ * @param storage - The gate storage adapter to use
+ * @returns The created GateState
+ */
+export declare function activateGate(issueId: string, gateDef: GateDefinition, storage: GateStorage): Promise<GateState>;
+/**
+ * Mark a gate as satisfied, recording what source satisfied it.
+ *
+ * @param issueId - The issue identifier
+ * @param gateName - The gate name to satisfy
+ * @param source - What satisfied the gate (e.g., comment ID, webhook payload hash, timer ID)
+ * @param storage - The gate storage adapter to use
+ * @returns The updated GateState, or null if the gate was not found
+ */
+export declare function satisfyGate(issueId: string, gateName: string, source: string, storage: GateStorage): Promise<GateState | null>;
+/**
+ * Mark a gate as timed-out.
+ *
+ * @param issueId - The issue identifier
+ * @param gateName - The gate name to time out
+ * @param storage - The gate storage adapter to use
+ * @returns The updated GateState, or null if the gate was not found
+ */
+export declare function timeoutGate(issueId: string, gateName: string, storage: GateStorage): Promise<GateState | null>;
+//# sourceMappingURL=gate-state.d.ts.map

package/dist/src/workflow/gate-state.d.ts.map

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