@auto-engineer/pipeline 1.65.0 → 1.67.0

package/src/engine/workflows/phased-workflow.ts

@@ -0,0 +1,153 @@
+export type PhasedItem = {
+  key: string;
+  phase: string;
+  status: 'pending' | 'dispatched' | 'completed' | 'failed';
+};
+
+export type PhasedInput =
+  | {
+      type: 'StartPhased';
+      data: {
+        correlationId: string;
+        items: Array<{ key: string; phase: string }>;
+        phases: string[];
+        stopOnFailure: boolean;
+      };
+    }
+  | { type: 'ItemCompleted'; data: { itemKey: string; result: Record<string, unknown> } }
+  | { type: 'ItemFailed'; data: { itemKey: string; error: Record<string, unknown> } };
+
+export type PhasedOutput =
+  | { type: 'DispatchItem'; kind: 'Command'; data: { itemKey: string; phase: string } }
+  | { type: 'PhasedCompleted'; data: { completedItems: string[] } }
+  | { type: 'PhasedFailed'; data: { failedItems: string[]; completedItems: string[] } };
+
+export type PhasedState = {
+  status: 'idle' | 'running' | 'completed' | 'failed';
+  items: PhasedItem[];
+  phases: string[];
+  currentPhaseIndex: number;
+  stopOnFailure: boolean;
+};
+
+export function initialState(): PhasedState {
+  return {
+    status: 'idle',
+    items: [],
+    phases: [],
+    currentPhaseIndex: 0,
+    stopOnFailure: false,
+  };
+}
+
+export function decide(input: PhasedInput, state: PhasedState): PhasedOutput | PhasedOutput[] {
+  switch (input.type) {
+    case 'StartPhased': {
+      const currentPhase = state.phases[state.currentPhaseIndex];
+      return state.items
+        .filter((item) => item.phase === currentPhase)
+        .map((item) => ({
+          type: 'DispatchItem' as const,
+          kind: 'Command' as const,
+          data: { itemKey: item.key, phase: item.phase },
+        }));
+    }
+    case 'ItemCompleted': {
+      const currentPhase = state.phases[state.currentPhaseIndex];
+      const currentPhaseItems = state.items.filter((item) => item.phase === currentPhase);
+      const allCompleted = currentPhaseItems.every((item) => item.status === 'completed');
+      if (allCompleted) {
+        const allItems = state.items;
+        const allDone = allItems.every((item) => item.status === 'completed');
+        if (allDone) {
+          return {
+            type: 'PhasedCompleted',
+            data: { completedItems: allItems.map((item) => item.key) },
+          };
+        }
+        const nextPhaseIndex = state.currentPhaseIndex + 1;
+        if (nextPhaseIndex < state.phases.length) {
+          const nextPhase = state.phases[nextPhaseIndex];
+          return state.items
+            .filter((item) => item.phase === nextPhase)
+            .map((item) => ({
+              type: 'DispatchItem' as const,
+              kind: 'Command' as const,
+              data: { itemKey: item.key, phase: item.phase },
+            }));
+        }
+      }
+      return [];
+    }
+    case 'ItemFailed': {
+      if (state.stopOnFailure) {
+        const failedItems = state.items.filter((item) => item.status === 'failed').map((item) => item.key);
+        const completedItems = state.items.filter((item) => item.status === 'completed').map((item) => item.key);
+        return {
+          type: 'PhasedFailed',
+          data: { failedItems, completedItems },
+        };
+      }
+      return [];
+    }
+    default:
+      return [];
+  }
+}
+
+export function evolve(state: PhasedState, event: PhasedInput | PhasedOutput): PhasedState {
+  switch (event.type) {
+    case 'StartPhased':
+      return {
+        status: 'running',
+        items: event.data.items.map((item) => ({ ...item, status: 'pending' as const })),
+        phases: event.data.phases,
+        currentPhaseIndex: 0,
+        stopOnFailure: event.data.stopOnFailure,
+      };
+
+    case 'DispatchItem': {
+      const phaseIndex = state.phases.indexOf(event.data.phase);
+      return {
+        ...state,
+        items: state.items.map((item) =>
+          item.key === event.data.itemKey ? { ...item, status: 'dispatched' as const } : item,
+        ),
+        currentPhaseIndex: phaseIndex > state.currentPhaseIndex ? phaseIndex : state.currentPhaseIndex,
+      };
+    }
+
+    case 'ItemCompleted':
+      return {
+        ...state,
+        items: state.items.map((item) =>
+          item.key === event.data.itemKey ? { ...item, status: 'completed' as const } : item,
+        ),
+      };
+
+    case 'ItemFailed':
+      return {
+        ...state,
+        items: state.items.map((item) =>
+          item.key === event.data.itemKey ? { ...item, status: 'failed' as const } : item,
+        ),
+      };
+
+    case 'PhasedCompleted':
+      return { ...state, status: 'completed' };
+
+    case 'PhasedFailed':
+      return { ...state, status: 'failed' };
+
+    default:
+      return state;
+  }
+}
+
+export function createPhasedWorkflow(): {
+  decide: typeof decide;
+  evolve: typeof evolve;
+  initialState: typeof initialState;
+} {
+  return { decide, evolve, initialState };
+}

package/src/engine/workflows/settled-workflow.specs.ts

@@ -0,0 +1,364 @@
+import type { SettledInput, SettledState } from './settled-workflow';
+import { createSettledWorkflow, decide, evolve, initialState } from './settled-workflow';
+
+describe('settled workflow', () => {
+  describe('initialState', () => {
+    it('returns idle state with empty tracking', () => {
+      expect(initialState()).toEqual({
+        status: 'idle',
+        commandTypes: [],
+        completions: {},
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+  });
+
+  describe('evolve', () => {
+    it('transitions from idle to waiting on StartSettled', () => {
+      const state = initialState();
+      const event = {
+        type: 'StartSettled' as const,
+        data: { correlationId: 'corr-1', commandTypes: ['CheckTests', 'CheckTypes'] },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        completions: {},
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+
+    it('records command completion', () => {
+      const state = {
+        status: 'waiting' as const,
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        completions: {},
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const event = {
+        type: 'CommandCompleted' as const,
+        data: {
+          commandType: 'CheckTests',
+          result: 'success' as const,
+          event: { passed: true },
+        },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        completions: {
+          CheckTests: { result: 'success', event: { passed: true } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+
+    it('preserves existing completions when recording another', () => {
+      const state = {
+        status: 'waiting' as const,
+        commandTypes: ['CheckTests', 'CheckTypes', 'CheckLint'],
+        completions: {
+          CheckTests: { result: 'success' as const, event: { passed: true } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const event = {
+        type: 'CommandCompleted' as const,
+        data: {
+          commandType: 'CheckTypes',
+          result: 'failure' as const,
+          event: { errors: 3 },
+        },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes', 'CheckLint'],
+        completions: {
+          CheckTests: { result: 'success', event: { passed: true } },
+          CheckTypes: { result: 'failure', event: { errors: 3 } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+
+    it('does not mutate the original state', () => {
+      const state = {
+        status: 'waiting' as const,
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        completions: {},
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const event = {
+        type: 'CommandCompleted' as const,
+        data: {
+          commandType: 'CheckTests',
+          result: 'success' as const,
+          event: { passed: true },
+        },
+      };
+
+      evolve(state, event);
+
+      expect(state.completions).toEqual({});
+    });
+
+    it('returns state unchanged for unknown event types', () => {
+      const state = initialState();
+      const event = { type: 'UnknownEvent' as string, data: {} };
+
+      const result = evolve(state, event as any);
+
+      expect(result).toEqual(state);
+    });
+
+    it('handles output events by returning state unchanged', () => {
+      const state = {
+        status: 'waiting' as const,
+        commandTypes: ['CheckTests'],
+        completions: {
+          CheckTests: { result: 'success' as const, event: { passed: true } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const event = {
+        type: 'AllSettled' as const,
+        data: {
+          results: {
+            CheckTests: { result: 'success' as const, event: { passed: true } },
+          },
+        },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'done',
+        commandTypes: ['CheckTests'],
+        completions: {
+          CheckTests: { result: 'success', event: { passed: true } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+
+    it('transitions to done on SettledFailed', () => {
+      const state = {
+        status: 'waiting' as const,
+        commandTypes: ['CheckTests'],
+        completions: {
+          CheckTests: { result: 'failure' as const, event: { errors: 1 } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const event = {
+        type: 'SettledFailed' as const,
+        data: {
+          results: {
+            CheckTests: { result: 'failure' as const, event: { errors: 1 } },
+          },
+          failures: ['CheckTests'],
+        },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'done',
+        commandTypes: ['CheckTests'],
+        completions: {
+          CheckTests: { result: 'failure', event: { errors: 1 } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+
+    it('increments retryCount on RetryCommands', () => {
+      const state = {
+        status: 'waiting' as const,
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        completions: {
+          CheckTests: { result: 'failure' as const, event: { errors: 1 } },
+          CheckTypes: { result: 'success' as const, event: {} },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const event = {
+        type: 'RetryCommands' as const,
+        kind: 'Command' as const,
+        data: { commandTypes: ['CheckTests'] },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        completions: {
+          CheckTypes: { result: 'success', event: {} },
+        },
+        retryCount: 1,
+        maxRetries: 3,
+      });
+    });
+  });
+
+  describe('decide', () => {
+    it('returns empty array when not all commands completed', () => {
+      const state: SettledState = {
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes', 'CheckLint'],
+        completions: {
+          CheckTests: { result: 'success', event: { duration: 100 } },
+        },
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const input: SettledInput = {
+        type: 'CommandCompleted',
+        data: { commandType: 'CheckTests', result: 'success', event: { duration: 100 } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when status is idle', () => {
+      const state = initialState();
+      const input: SettledInput = {
+        type: 'StartSettled',
+        data: { correlationId: 'c1', commandTypes: ['A'] },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([]);
+    });
+
+    it('returns AllSettled when all commands completed successfully', () => {
+      const completions = {
+        CheckTests: { result: 'success' as const, event: { duration: 100 } },
+        CheckTypes: { result: 'success' as const, event: { duration: 50 } },
+        CheckLint: { result: 'success' as const, event: { duration: 30 } },
+      };
+      const state: SettledState = {
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes', 'CheckLint'],
+        completions,
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const input: SettledInput = {
+        type: 'CommandCompleted',
+        data: { commandType: 'CheckLint', result: 'success', event: { duration: 30 } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual({
+        type: 'AllSettled',
+        data: { results: completions },
+      });
+    });
+
+    it('returns RetryCommands when failures exist and retries available', () => {
+      const completions = {
+        CheckTests: { result: 'failure' as const, event: { error: 'test failed' } },
+        CheckTypes: { result: 'success' as const, event: { duration: 50 } },
+        CheckLint: { result: 'success' as const, event: { duration: 30 } },
+      };
+      const state: SettledState = {
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes', 'CheckLint'],
+        completions,
+        retryCount: 0,
+        maxRetries: 3,
+      };
+      const input: SettledInput = {
+        type: 'CommandCompleted',
+        data: { commandType: 'CheckLint', result: 'success', event: { duration: 30 } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual({
+        type: 'RetryCommands',
+        kind: 'Command',
+        data: { commandTypes: ['CheckTests'] },
+      });
+    });
+
+    it('returns SettledFailed when failures exist and no retries left', () => {
+      const completions = {
+        CheckTests: { result: 'failure' as const, event: { error: 'test failed' } },
+        CheckTypes: { result: 'success' as const, event: { duration: 50 } },
+        CheckLint: { result: 'success' as const, event: { duration: 30 } },
+      };
+      const state: SettledState = {
+        status: 'waiting',
+        commandTypes: ['CheckTests', 'CheckTypes', 'CheckLint'],
+        completions,
+        retryCount: 3,
+        maxRetries: 3,
+      };
+      const input: SettledInput = {
+        type: 'CommandCompleted',
+        data: { commandType: 'CheckLint', result: 'success', event: { duration: 30 } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual({
+        type: 'SettledFailed',
+        data: {
+          results: completions,
+          failures: ['CheckTests'],
+        },
+      });
+    });
+  });
+
+  describe('createSettledWorkflow', () => {
+    it('factory produces workflow with configured command types and max retries', () => {
+      const workflow = createSettledWorkflow({
+        commandTypes: ['A', 'B'],
+        maxRetries: 5,
+      });
+      const state = workflow.initialState();
+      expect(state).toEqual({
+        status: 'idle',
+        commandTypes: [],
+        completions: {},
+        retryCount: 0,
+        maxRetries: 5,
+      });
+      expect(workflow.decide).toBe(decide);
+      expect(workflow.evolve).toBe(evolve);
+    });
+
+    it('defaults maxRetries to 3 when not provided', () => {
+      const workflow = createSettledWorkflow({
+        commandTypes: ['X'],
+      });
+      const state = workflow.initialState();
+      expect(state).toEqual({
+        status: 'idle',
+        commandTypes: [],
+        completions: {},
+        retryCount: 0,
+        maxRetries: 3,
+      });
+    });
+  });
+});

package/src/engine/workflows/settled-workflow.ts

@@ -0,0 +1,139 @@
+export type SettledInput =
+  | { type: 'StartSettled'; data: { correlationId: string; commandTypes: string[] } }
+  | {
+      type: 'CommandCompleted';
+      data: { commandType: string; result: 'success' | 'failure'; event: Record<string, unknown> };
+    };
+
+export type SettledOutput =
+  | {
+      type: 'AllSettled';
+      data: { results: Record<string, { result: 'success' | 'failure'; event: Record<string, unknown> }> };
+    }
+  | {
+      type: 'SettledFailed';
+      data: {
+        results: Record<string, { result: 'success' | 'failure'; event: Record<string, unknown> }>;
+        failures: string[];
+      };
+    }
+  | { type: 'RetryCommands'; kind: 'Command'; data: { commandTypes: string[] } };
+
+export type SettledState = {
+  status: 'idle' | 'waiting' | 'done';
+  commandTypes: string[];
+  completions: Record<string, { result: 'success' | 'failure'; event: Record<string, unknown> }>;
+  retryCount: number;
+  maxRetries: number;
+};
+
+type SettledEvent = SettledInput | SettledOutput;
+
+export function initialState(): SettledState {
+  return {
+    status: 'idle',
+    commandTypes: [],
+    completions: {},
+    retryCount: 0,
+    maxRetries: 3,
+  };
+}
+
+export function evolve(state: SettledState, event: SettledEvent): SettledState {
+  switch (event.type) {
+    case 'StartSettled':
+      return {
+        ...state,
+        status: 'waiting',
+        commandTypes: event.data.commandTypes,
+      };
+
+    case 'CommandCompleted':
+      return {
+        ...state,
+        completions: {
+          ...state.completions,
+          [event.data.commandType]: {
+            result: event.data.result,
+            event: event.data.event,
+          },
+        },
+      };
+
+    case 'AllSettled':
+      return { ...state, status: 'done' };
+
+    case 'SettledFailed':
+      return { ...state, status: 'done' };
+
+    case 'RetryCommands': {
+      const retried = new Set(event.data.commandTypes);
+      const completions = { ...state.completions };
+      for (const ct of retried) {
+        delete completions[ct];
+      }
+      return {
+        ...state,
+        completions,
+        retryCount: state.retryCount + 1,
+      };
+    }
+
+    default:
+      return state;
+  }
+}
+
+export function decide(input: SettledInput, state: SettledState): SettledOutput | SettledOutput[] {
+  if (state.status !== 'waiting') {
+    return [];
+  }
+
+  const allCompleted = state.commandTypes.every((ct) => ct in state.completions);
+  if (!allCompleted) {
+    return [];
+  }
+
+  const failures = state.commandTypes.filter((ct) => state.completions[ct].result === 'failure');
+
+  if (failures.length === 0) {
+    return {
+      type: 'AllSettled',
+      data: { results: state.completions },
+    };
+  }
+
+  if (state.retryCount < state.maxRetries) {
+    return {
+      type: 'RetryCommands',
+      kind: 'Command',
+      data: { commandTypes: failures },
+    };
+  }
+
+  return {
+    type: 'SettledFailed',
+    data: {
+      results: state.completions,
+      failures,
+    },
+  };
+}
+
+export function createSettledWorkflow(config: { commandTypes: string[]; maxRetries?: number }): {
+  decide: typeof decide;
+  evolve: typeof evolve;
+  initialState: () => SettledState;
+} {
+  return {
+    decide,
+    evolve,
+    initialState: () => ({
+      status: 'idle',
+      commandTypes: [],
+      completions: {},
+      retryCount: 0,
+      maxRetries: config.maxRetries ?? 3,
+    }),
+  };
+}

package/src/graph/types.ts

@@ -1,4 +1,4 @@
-export type NodeType = 'event' | 'command' | 'settled';
+export type NodeType = 'event' | 'command' | 'settled' | 'phased' | 'await';
 
 export type NodeStatus = 'idle' | 'running' | 'success' | 'error';
 

package/src/index.ts

@@ -17,6 +17,7 @@ export type {
   TriggerBuilder,
 } from './builder/define';
 export { define } from './builder/define';
+export { defineV2, type PipelineV2, toGraph as toGraphV2 } from './builder/define-v2';
 export type {
   AcceptsDescriptor,
   CustomHandlerDescriptor,
@@ -33,6 +34,7 @@ export type {
 } from './core/descriptors';
 export type { Command, CommandDispatch, Event, HandlerFailedEvent } from './core/types';
 export { dispatch } from './core/types';
+export * from './engine/index';
 export type { GraphEdge, GraphIR, GraphNode, NodeType } from './graph/types';
 export type { EventLoggerOptions, LogEntry } from './logging/event-logger';
 export { EventLogger } from './logging/event-logger';