@multiplier-labs/stepflow 0.3.1 → 0.3.4

package/src/planning/registry.ts

@@ -3,17 +3,16 @@
  * Provides storage and retrieval of recipes and handlers.
  */
 
-import RE2 from "re2";
-import type { WorkflowStep } from "../core/types";
+import type { WorkflowStep } from '../core/types';
+import { evaluateCondition, getNestedValue } from './evaluate-condition';
 import type {
   Recipe,
-  RecipeCondition,
   RecipeRegistry,
   RecipeQueryOptions,
   RegisteredStepHandler,
   StepHandlerRegistry,
   WorkflowKind,
-} from "./types";
+} from './types';
 
 // ============================================================================
 // Step Handler Registry Implementation
@@ -28,7 +27,7 @@ export class MemoryStepHandlerRegistry implements StepHandlerRegistry {
 
   /** Register a step handler. Throws if a handler with the same ID is already registered. */
   register<TInput = Record<string, unknown>>(
-    handler: RegisteredStepHandler<TInput>,
+    handler: RegisteredStepHandler<TInput>
   ): void {
     if (this.handlers.has(handler.id)) {
       throw new Error(`Step handler '${handler.id}' is already registered`);
@@ -68,7 +67,7 @@ export class MemoryStepHandlerRegistry implements StepHandlerRegistry {
     if (!ids) return [];
 
     return Array.from(ids)
-      .map((id) => this.handlers.get(id))
+      .map(id => this.handlers.get(id))
       .filter((h): h is RegisteredStepHandler => h !== undefined);
   }
 
@@ -76,7 +75,7 @@ export class MemoryStepHandlerRegistry implements StepHandlerRegistry {
    * Resolve a handler reference to a WorkflowStep handler function.
    * Returns undefined if the handler is not found.
    */
-  resolve(handlerRef: string): WorkflowStep["handler"] | undefined {
+  resolve(handlerRef: string): WorkflowStep['handler'] | undefined {
     const registered = this.handlers.get(handlerRef);
     return registered?.handler;
   }
@@ -121,7 +120,7 @@ export class MemoryRecipeRegistry implements RecipeRegistry {
     const variantKey = `${recipe.workflowKind}:${recipe.variant}`;
     if (this.variantIndex.has(variantKey)) {
       throw new Error(
-        `Recipe variant '${recipe.variant}' for '${recipe.workflowKind}' is already registered`,
+        `Recipe variant '${recipe.variant}' for '${recipe.workflowKind}' is already registered`
       );
     }
     this.variantIndex.set(variantKey, recipe.id);
@@ -160,7 +159,7 @@ export class MemoryRecipeRegistry implements RecipeRegistry {
     if (!ids) return [];
 
     return Array.from(ids)
-      .map((id) => this.recipes.get(id))
+      .map(id => this.recipes.get(id))
       .filter((r): r is Recipe => r !== undefined);
   }
 
@@ -179,7 +178,7 @@ export class MemoryRecipeRegistry implements RecipeRegistry {
    */
   getDefault(workflowKind: WorkflowKind): Recipe | undefined {
     // First try to find a 'default' variant
-    const defaultRecipe = this.getVariant(workflowKind, "default");
+    const defaultRecipe = this.getVariant(workflowKind, 'default');
     if (defaultRecipe) return defaultRecipe;
 
     // Fall back to the recipe with the lowest numeric priority (highest precedence).
@@ -198,7 +197,7 @@ export class MemoryRecipeRegistry implements RecipeRegistry {
   /** List all variant names registered for a workflow kind. */
   listVariants(workflowKind: WorkflowKind): string[] {
     const recipes = this.getByKind(workflowKind);
-    return recipes.map((r) => r.variant);
+    return recipes.map(r => r.variant);
   }
 
   /** Query recipes with optional filters for kind, variant, tags, and input conditions. */
@@ -206,21 +205,21 @@ export class MemoryRecipeRegistry implements RecipeRegistry {
     let results = this.list();
 
     if (options.workflowKind) {
-      results = results.filter((r) => r.workflowKind === options.workflowKind);
+      results = results.filter(r => r.workflowKind === options.workflowKind);
     }
 
     if (options.variant) {
-      results = results.filter((r) => r.variant === options.variant);
+      results = results.filter(r => r.variant === options.variant);
     }
 
     if (options.tags && options.tags.length > 0) {
-      results = results.filter((r) =>
-        options.tags!.some((tag) => r.tags?.includes(tag)),
+      results = results.filter(r =>
+        options.tags!.some(tag => r.tags?.includes(tag))
       );
     }
 
     if (options.matchConditions) {
-      results = results.filter((r) => {
+      results = results.filter(r => {
         if (!r.conditions || r.conditions.length === 0) return true;
         return this.evaluateConditions(r.conditions, options.matchConditions!);
       });
@@ -247,103 +246,18 @@ export class MemoryRecipeRegistry implements RecipeRegistry {
   /**
    * Evaluate recipe conditions against an input.
    * Returns true if all conditions match.
-   *
-   * Note: This intentionally mirrors the condition evaluation in planner.ts
-   * to keep registry queries independent of the planner implementation.
    */
   private evaluateConditions(
-    conditions: Recipe["conditions"],
-    input: Record<string, unknown>,
+    conditions: Recipe['conditions'],
+    input: Record<string, unknown>
   ): boolean {
     if (!conditions || conditions.length === 0) return true;
 
-    return conditions.every((condition) => {
-      const fieldValue = this.getNestedValue(input, condition.field);
-      return this.evaluateCondition(condition, fieldValue);
+    return conditions.every(condition => {
+      const fieldValue = getNestedValue(input, condition.field);
+      return evaluateCondition(condition.operator, fieldValue, condition.value);
     });
   }
-
-  /**
-   * Get a nested value from an object using dot notation.
-   */
-  private getNestedValue(obj: Record<string, unknown>, path: string): unknown {
-    return path.split(".").reduce<unknown>((current, key) => {
-      if (current && typeof current === "object" && key in current) {
-        return (current as Record<string, unknown>)[key];
-      }
-      return undefined;
-    }, obj);
-  }
-
-  /**
-   * Evaluate a single condition.
-   */
-  private evaluateCondition(
-    condition: RecipeCondition,
-    fieldValue: unknown,
-  ): boolean {
-    const { operator, value } = condition;
-
-    switch (operator) {
-      case "eq":
-        return fieldValue === value;
-
-      case "neq":
-        return fieldValue !== value;
-
-      case "gt":
-        return typeof fieldValue === "number" && typeof value === "number"
-          ? fieldValue > value
-          : false;
-
-      case "gte":
-        return typeof fieldValue === "number" && typeof value === "number"
-          ? fieldValue >= value
-          : false;
-
-      case "lt":
-        return typeof fieldValue === "number" && typeof value === "number"
-          ? fieldValue < value
-          : false;
-
-      case "lte":
-        return typeof fieldValue === "number" && typeof value === "number"
-          ? fieldValue <= value
-          : false;
-
-      case "contains":
-        if (typeof fieldValue === "string" && typeof value === "string") {
-          return fieldValue.includes(value);
-        }
-        if (Array.isArray(fieldValue)) {
-          return fieldValue.includes(value);
-        }
-        return false;
-
-      case "matches":
-        if (typeof fieldValue === "string" && typeof value === "string") {
-          try {
-            return new RE2(value).test(fieldValue);
-          } catch {
-            return false;
-          }
-        }
-        return false;
-
-      case "exists":
-        return (
-          fieldValue !== undefined && fieldValue !== null && fieldValue !== ""
-        );
-
-      case "notExists":
-        return (
-          fieldValue === undefined || fieldValue === null || fieldValue === ""
-        );
-
-      default:
-        return false;
-    }
-  }
 }
 
 // ============================================================================

package/src/planning/types.ts

@@ -3,14 +3,10 @@
  * Enables dynamic workflow orchestration through recipes and plans.
  */
 
-import type {
-  WorkflowKind,
-  StepErrorStrategy,
-  WorkflowStep,
-} from "../core/types";
+import type { WorkflowKind, StepErrorStrategy, WorkflowStep } from '../core/types';
 
 // Re-export core types used in planning
-export type { WorkflowKind, StepErrorStrategy } from "../core/types";
+export type { WorkflowKind, StepErrorStrategy } from '../core/types';
 
 // ============================================================================
 // Recipe Types
@@ -20,16 +16,16 @@ export type { WorkflowKind, StepErrorStrategy } from "../core/types";
  * Comparison operators for recipe conditions.
  */
 export type ConditionOperator =
-  | "eq" // equals
-  | "neq" // not equals
-  | "gt" // greater than
-  | "gte" // greater than or equal
-  | "lt" // less than
-  | "lte" // less than or equal
-  | "contains" // string/array contains
-  | "matches" // regex match
-  | "exists" // field exists and is truthy
-  | "notExists"; // field does not exist or is falsy
+  | 'eq'       // equals
+  | 'neq'      // not equals
+  | 'gt'       // greater than
+  | 'gte'      // greater than or equal
+  | 'lt'       // less than
+  | 'lte'      // less than or equal
+  | 'contains' // string/array contains
+  | 'matches'  // regex match
+  | 'exists'   // field exists and is truthy
+  | 'notExists'; // field does not exist or is falsy
 
 /**
  * A condition that determines when a recipe should be selected.
@@ -169,11 +165,11 @@ export interface Recipe {
  * Types of modifications that can be made to a plan.
  */
 export type PlanModificationType =
-  | "add_step" // Add a new step
-  | "remove_step" // Remove an existing step
-  | "modify_step" // Modify step configuration
-  | "reorder_steps" // Change step order
-  | "set_default"; // Override a default parameter
+  | 'add_step'      // Add a new step
+  | 'remove_step'   // Remove an existing step
+  | 'modify_step'   // Modify step configuration
+  | 'reorder_steps' // Change step order
+  | 'set_default';  // Override a default parameter
 
 /**
  * A modification to apply to a recipe when generating a plan.
@@ -306,7 +302,7 @@ export interface Plan {
 /**
  * Priority modes for planning.
  */
-export type PlanningPriority = "speed" | "quality" | "cost" | "balanced";
+export type PlanningPriority = 'speed' | 'quality' | 'cost' | 'balanced';
 
 /**
  * Constraints that limit planning and execution.
@@ -407,7 +403,7 @@ export interface Planner {
   selectRecipe(
     workflowKind: WorkflowKind,
     input: Record<string, unknown>,
-    context?: PlanningContext,
+    context?: PlanningContext
   ): Promise<RecipeSelectionResult>;
 
   /**
@@ -416,7 +412,7 @@ export interface Planner {
   generatePlan(
     recipe: Recipe,
     input: Record<string, unknown>,
-    context?: PlanningContext,
+    context?: PlanningContext
   ): Promise<Plan>;
 
   /**
@@ -425,7 +421,7 @@ export interface Planner {
   plan(
     workflowKind: WorkflowKind,
     input: Record<string, unknown>,
-    context?: PlanningContext,
+    context?: PlanningContext
   ): Promise<Plan>;
 
   /**
@@ -454,7 +450,7 @@ export interface RegisteredStepHandler<TInput = Record<string, unknown>> {
   description?: string;
 
   /** The handler function */
-  handler: WorkflowStep<TInput>["handler"];
+  handler: WorkflowStep<TInput>['handler'];
 
   /** Tags for categorization */
   tags?: string[];
@@ -469,7 +465,7 @@ export interface StepHandlerRegistry {
    * Register a step handler.
    */
   register<TInput = Record<string, unknown>>(
-    handler: RegisteredStepHandler<TInput>,
+    handler: RegisteredStepHandler<TInput>
   ): void;
 
   /**