@positronic/core 0.0.1 → 0.0.2

package/src/dsl/workflow-runner.test.ts

@@ -1,203 +0,0 @@
-import { WorkflowRunner } from './workflow-runner';
-import { workflow } from './workflow';
-import { WORKFLOW_EVENTS, STATUS } from './constants';
-import type { FileStore } from '../file-stores/types';
-
-class TestFileStore implements FileStore {
-  async readFile(path: string) {
-    return Promise.resolve('');
-  }
-}
-
-describe('WorkflowRunner', () => {
-  const mockClient = {
-    execute: jest.fn()
-  };
-
-  const mockLogger = {
-    log: jest.fn()
-  };
-
-  const mockAdapter = {
-    dispatch: jest.fn()
-  };
-
-  const fileStore = new TestFileStore();
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should run a workflow and dispatch events to adapters', async () => {
-    const runner = new WorkflowRunner({
-      adapters: [mockAdapter],
-      fileStore,
-      logger: mockLogger,
-      verbose: false,
-      client: mockClient
-    });
-
-    const testWorkflow = workflow('Test Workflow')
-      .step('First Step', () => ({ value: 42 }))
-      .step('Async Step', async ({ state}) => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        return { ...state, asyncValue: 'completed' };
-      })
-      .step('Final Step', ({ state }) => ({
-        ...state,
-        finalValue: state.value * 2
-      }));
-
-    await runner.run(testWorkflow);
-
-    // Verify adapter received all events in correct order
-    expect(mockAdapter.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: WORKFLOW_EVENTS.START,
-        workflowTitle: 'Test Workflow'
-      })
-    );
-
-    expect(mockAdapter.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: WORKFLOW_EVENTS.STEP_COMPLETE,
-        stepTitle: 'First Step'
-      })
-    );
-
-    expect(mockAdapter.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: WORKFLOW_EVENTS.STEP_COMPLETE,
-        stepTitle: 'Async Step'
-      })
-    );
-
-    expect(mockAdapter.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: WORKFLOW_EVENTS.STEP_COMPLETE,
-        stepTitle: 'Final Step'
-      })
-    );
-
-    expect(mockAdapter.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: WORKFLOW_EVENTS.COMPLETE,
-        status: STATUS.COMPLETE
-      })
-    );
-
-    // Verify the order of events
-    const stepCompletions = mockAdapter.dispatch.mock.calls
-      .filter(call => call[0].type === WORKFLOW_EVENTS.STEP_COMPLETE)
-      .map(call => call[0].stepTitle);
-
-    expect(stepCompletions).toEqual([
-      'First Step',
-      'Async Step',
-      'Final Step'
-    ]);
-  });
-
-  it('should log final state when verbose is true', async () => {
-    const runner = new WorkflowRunner({
-      adapters: [],
-      fileStore,
-      logger: mockLogger,
-      verbose: true,
-      client: mockClient
-    });
-
-    const testWorkflow = workflow('Test Workflow')
-      .step('Test Step', () => ({ value: 42 }));
-
-    await runner.run(testWorkflow);
-
-    expect(mockLogger.log).toHaveBeenCalledWith(
-      expect.stringContaining('Workflow completed:')
-    );
-    expect(mockLogger.log).toHaveBeenCalledWith(
-      expect.stringContaining('"value": 42')
-    );
-  });
-
-  it('should handle workflow errors', async () => {
-    const runner = new WorkflowRunner({
-      adapters: [mockAdapter],
-      fileStore,
-      logger: mockLogger,
-      verbose: true,
-      client: mockClient
-    });
-
-    const errorWorkflow = workflow('Error Workflow')
-      .step('Error Step', () => {
-        throw new Error('Test error');
-      });
-
-    try {
-      await runner.run(errorWorkflow);
-    } catch (error) {
-      // Expected error
-    }
-
-    // Verify error event was dispatched
-    expect(mockAdapter.dispatch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: WORKFLOW_EVENTS.ERROR,
-        error: expect.objectContaining({
-          message: 'Test error'
-        })
-      })
-    );
-  });
-
-  it('should truncate long values in verbose output', async () => {
-    const runner = new WorkflowRunner({
-      adapters: [],
-      fileStore,
-      logger: mockLogger,
-      verbose: true,
-      client: mockClient
-    });
-
-    const longString = 'a'.repeat(1000); // Make string much longer
-    const testWorkflow = workflow('Test Workflow')
-      .step('Test Step', () => ({
-        longString,
-        nested: { longString }
-      }));
-
-    await runner.run(testWorkflow);
-
-    const logCall = mockLogger.log.mock.calls.find(call =>
-      call[0].includes('Workflow completed:')
-    );
-
-    expect(logCall[0]).toContain('...');
-    expect(logCall[0].length).toBeLessThan(longString.length);
-  });
-
-  it('should maintain state between steps', async () => {
-    const runner = new WorkflowRunner({
-      adapters: [],
-      fileStore,
-      logger: mockLogger,
-      verbose: true,
-      client: mockClient
-    });
-
-    const testWorkflow = workflow('Test Workflow')
-      .step('First Step', () => ({ count: 1 }))
-      .step('Second Step', ({ state }) => ({
-        count: state.count + 1
-      }));
-
-    await runner.run(testWorkflow);
-
-    const finalLog = mockLogger.log.mock.calls.find(call =>
-      call[0].includes('Workflow completed:')
-    );
-
-    expect(finalLog[0]).toContain('"count": 2');
-  });
-});

package/src/dsl/workflow-runner.ts

@@ -1,146 +0,0 @@
-import { WORKFLOW_EVENTS } from './constants';
-import { applyPatches } from './json-patch';
-import type { Adapter } from "../adapters/types";
-import type { FileStore } from "../file-stores/types";
-import type { SerializedStep, Workflow } from './workflow';
-import type { State } from './types';
-import type { PromptClient } from '../clients/types';
-
-interface Logger {
-  log(...args: any[]): void;
-}
-
-export class WorkflowRunner {
-  constructor(
-    private options: {
-      adapters: Adapter[],
-      fileStore: FileStore,
-      logger: Logger,
-      verbose: boolean,
-      client: PromptClient
-    }
-  ) {}
-
-  async run<
-    TOptions extends object = {},
-    TState extends State = {}
-  >(
-    workflow: Workflow<TOptions, TState>,
-    {
-      initialState = {} as TState,
-      options,
-      initialCompletedSteps,
-      workflowRunId,
-      endAfter
-    }: {
-      initialState?: TState,
-      options?: TOptions,
-      initialCompletedSteps?: SerializedStep[] | never,
-      workflowRunId?: string | never,
-      endAfter?: number
-    } = {}
-  ) {
-    const {
-      adapters,
-      logger: { log },
-      verbose,
-      fileStore,
-      client,
-    } = this.options;
-
-    let currentState = initialState ?? ({} as TState);
-    let stepNumber = 1;
-
-    // Apply any patches from completed steps
-    // to the initial state so that the workflow
-    // starts with a state that reflects all of the completed steps.
-    // Need to do this when a workflow is restarted with completed steps.
-    initialCompletedSteps?.forEach(step => {
-      if (step.patch) {
-        currentState = applyPatches(currentState, [step.patch]) as TState;
-        stepNumber++;
-      }
-    });
-
-    const workflowRun = workflowRunId && initialCompletedSteps
-      ? workflow.run({ initialState, initialCompletedSteps, workflowRunId, options, client, fileStore })
-      : workflow.run({ initialState, options, client, fileStore });
-
-    for await (const event of workflowRun) {
-      // Dispatch event to all adapters
-      await Promise.all(
-        adapters.map(adapter => adapter.dispatch(event))
-      );
-
-      // Update current state when steps complete
-      if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
-        if (event.patch) {
-          currentState = applyPatches(currentState, [event.patch]) as TState;
-        }
-
-        // Check if we should stop after this step
-        if (endAfter && stepNumber >= endAfter) {
-          // Log final state if verbose
-          if (verbose) {
-            log(`\nWorkflow stopped after step ${endAfter} as requested: \n\n ${JSON.stringify(
-              this.truncateDeep(structuredClone(currentState)), null, 2
-            )}`);
-          }
-          return;
-        }
-
-        stepNumber++;
-      }
-
-      // Log final state on workflow completion/error if verbose
-      if ((
-        event.type === WORKFLOW_EVENTS.COMPLETE ||
-        event.type === WORKFLOW_EVENTS.ERROR
-      ) && verbose) {
-        log(`\nWorkflow completed: \n\n ${JSON.stringify(
-          this.truncateDeep(structuredClone(currentState)), null, 2
-        )}`);
-      }
-    }
-  }
-
-  private truncateDeep(obj: any, maxLength: number = 100): any {
-    if (obj === null || obj === undefined) return obj;
-
-    if (typeof obj === 'string') {
-      return obj.length > maxLength ? obj.slice(0, maxLength) + '...' : obj;
-    }
-
-    if (Array.isArray(obj)) {
-      if (obj.length === 0) return obj;
-
-      let truncatedArray = [];
-      let currentLength = 2; // Account for [] brackets
-
-      for (let i = 0; i < obj.length; i++) {
-        const processedItem = this.truncateDeep(obj[i], maxLength);
-        const itemStr = JSON.stringify(processedItem);
-
-        if (currentLength + itemStr.length + (i > 0 ? 1 : 0) > maxLength) {
-          truncatedArray.push(`... (${obj.length})`);
-          break;
-        }
-
-        truncatedArray.push(processedItem);
-        currentLength += itemStr.length + (i > 0 ? 1 : 0); // Add 1 for comma
-      }
-
-      return truncatedArray;
-    }
-
-    if (typeof obj === 'object') {
-      const truncated: Record<string, any> = {};
-      for (const [key, value] of Object.entries(obj)) {
-        truncated[key] = this.truncateDeep(value, maxLength);
-      }
-      return truncated;
-    }
-
-    return obj;
-  }
-}