ai-workflows 1.1.0 → 2.0.0

package/test/workflow.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import { Workflow, createTestContext, parseEvent } from '../src/workflow.js'
+import { clearEventHandlers } from '../src/on.js'
+import { clearScheduleHandlers } from '../src/every.js'
+
+describe('Workflow - unified $ API', () => {
+  beforeEach(() => {
+    clearEventHandlers()
+    clearScheduleHandlers()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  describe('Workflow()', () => {
+    it('should create a workflow with $ context', () => {
+      const workflow = Workflow($ => {
+        // Just accessing $ to verify it works
+        expect($).toBeDefined()
+        expect($.on).toBeDefined()
+        expect($.every).toBeDefined()
+        expect($.send).toBeDefined()
+        expect($.log).toBeDefined()
+        expect($.get).toBeDefined()
+        expect($.set).toBeDefined()
+        expect($.getState).toBeDefined()
+      })
+
+      expect(workflow).toBeDefined()
+      expect(workflow.$).toBeDefined()
+      expect(workflow.send).toBeDefined()
+      expect(workflow.start).toBeDefined()
+      expect(workflow.stop).toBeDefined()
+    })
+
+    it('should capture event handlers registered via $.on', () => {
+      const workflow = Workflow($ => {
+        $.on.Customer.created(() => {})
+        $.on.Order.completed(() => {})
+      })
+
+      expect(workflow.definition.events).toHaveLength(2)
+      expect(workflow.definition.events[0]?.noun).toBe('Customer')
+      expect(workflow.definition.events[0]?.event).toBe('created')
+      expect(workflow.definition.events[1]?.noun).toBe('Order')
+      expect(workflow.definition.events[1]?.event).toBe('completed')
+    })
+
+    it('should capture schedule handlers registered via $.every', () => {
+      const workflow = Workflow($ => {
+        $.every.hour(() => {})
+        $.every.Monday.at9am(() => {})
+      })
+
+      expect(workflow.definition.schedules).toHaveLength(2)
+    })
+
+    it('should capture function source code', () => {
+      const workflow = Workflow($ => {
+        $.on.Test.event(async (data, ctx) => {
+          ctx.log('Test event', data)
+        })
+      })
+
+      // Source code is captured (variable names may be minified)
+      expect(workflow.definition.events[0]?.source).toBeDefined()
+      expect(workflow.definition.events[0]?.source.length).toBeGreaterThan(0)
+      expect(workflow.definition.events[0]?.source).toContain('Test event')
+    })
+
+    it('should deliver events to registered handlers', async () => {
+      const handler = vi.fn()
+
+      const workflow = Workflow($ => {
+        $.on.Customer.created(handler)
+      })
+
+      await workflow.start()
+      await workflow.send('Customer.created', { id: '123', name: 'John' })
+
+      expect(handler).toHaveBeenCalledTimes(1)
+      expect(handler).toHaveBeenCalledWith(
+        { id: '123', name: 'John' },
+        expect.objectContaining({
+          send: expect.any(Function),
+          log: expect.any(Function),
+        })
+      )
+    })
+
+    it('should allow chained event sending from handlers', async () => {
+      const welcomeHandler = vi.fn()
+
+      const workflow = Workflow($ => {
+        $.on.Customer.created(async (customer, $) => {
+          await $.send('Email.welcome', { to: customer.email })
+        })
+
+        $.on.Email.welcome(welcomeHandler)
+      })
+
+      await workflow.start()
+      await workflow.send('Customer.created', { name: 'John', email: 'john@example.com' })
+
+      expect(welcomeHandler).toHaveBeenCalledWith(
+        { to: 'john@example.com' },
+        expect.anything()
+      )
+    })
+
+    it('should track events in state history', async () => {
+      const workflow = Workflow($ => {
+        $.on.Test.event(() => {})
+      })
+
+      await workflow.start()
+      await workflow.send('Test.event', { data: 'test' })
+
+      expect(workflow.state.history).toHaveLength(1)
+      expect(workflow.state.history[0]).toMatchObject({
+        type: 'event',
+        name: 'Test.event',
+        data: { data: 'test' },
+      })
+    })
+
+    it('should trigger schedule handlers', async () => {
+      const handler = vi.fn()
+
+      const workflow = Workflow($ => {
+        $.every.seconds(1)(handler)
+      })
+
+      await workflow.start()
+      await vi.advanceTimersByTimeAsync(1000)
+
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      await vi.advanceTimersByTimeAsync(1000)
+      expect(handler).toHaveBeenCalledTimes(2)
+
+      await workflow.stop()
+    })
+
+    it('should stop schedule handlers on stop', async () => {
+      const handler = vi.fn()
+
+      const workflow = Workflow($ => {
+        $.every.seconds(1)(handler)
+      })
+
+      await workflow.start()
+      await vi.advanceTimersByTimeAsync(1000)
+      expect(handler).toHaveBeenCalledTimes(1)
+
+      await workflow.stop()
+      await vi.advanceTimersByTimeAsync(5000)
+      expect(handler).toHaveBeenCalledTimes(1)
+    })
+
+    it('should support $.set and $.get for context data', async () => {
+      const workflow = Workflow($ => {
+        $.on.Test.set(async (data, $) => {
+          $.set('value', data.value)
+        })
+
+        $.on.Test.get(async (_, $) => {
+          const value = $.get<number>('value')
+          $.log('Got value', value)
+        })
+      })
+
+      await workflow.start()
+      await workflow.send('Test.set', { value: 42 })
+
+      expect(workflow.state.context.value).toBe(42)
+      expect(workflow.$.get('value')).toBe(42)
+    })
+
+    it('should use initial context from options', () => {
+      const workflow = Workflow(
+        $ => {},
+        { context: { counter: 100 } }
+      )
+
+      expect(workflow.state.context.counter).toBe(100)
+    })
+  })
+
+  describe('parseEvent', () => {
+    it('should parse valid event strings', () => {
+      expect(parseEvent('Customer.created')).toEqual({
+        noun: 'Customer',
+        event: 'created',
+      })
+    })
+
+    it('should return null for invalid event strings', () => {
+      expect(parseEvent('invalid')).toBeNull()
+      expect(parseEvent('too.many.parts')).toBeNull()
+      expect(parseEvent('')).toBeNull()
+    })
+  })
+
+  describe('createTestContext', () => {
+    it('should create a $ context for testing', () => {
+      const $ = createTestContext()
+
+      expect($.send).toBeDefined()
+      expect($.on).toBeDefined()
+      expect($.every).toBeDefined()
+      expect($.log).toBeDefined()
+      expect($.get).toBeDefined()
+      expect($.set).toBeDefined()
+      expect($.getState).toBeDefined()
+      expect($.emittedEvents).toBeDefined()
+    })
+
+    it('should track emitted events', async () => {
+      const $ = createTestContext()
+
+      await $.send('Test.event1', { a: 1 })
+      await $.send('Test.event2', { b: 2 })
+
+      expect($.emittedEvents).toHaveLength(2)
+      expect($.emittedEvents[0]).toEqual({ event: 'Test.event1', data: { a: 1 } })
+      expect($.emittedEvents[1]).toEqual({ event: 'Test.event2', data: { b: 2 } })
+    })
+
+    it('should support get/set', () => {
+      const $ = createTestContext()
+
+      $.set('key', 'value')
+      expect($.get('key')).toBe('value')
+    })
+  })
+
+  describe('$.every patterns', () => {
+    it('should support $.every.hour', () => {
+      const workflow = Workflow($ => {
+        $.every.hour(() => {})
+      })
+
+      expect(workflow.definition.schedules[0]?.interval).toEqual({
+        type: 'cron',
+        expression: '0 * * * *',
+        natural: 'hour',
+      })
+    })
+
+    it('should support $.every.Monday.at9am', () => {
+      const workflow = Workflow($ => {
+        $.every.Monday.at9am(() => {})
+      })
+
+      expect(workflow.definition.schedules[0]?.interval).toEqual({
+        type: 'cron',
+        expression: '0 9 * * 1',
+        natural: 'Monday.at9am',
+      })
+    })
+
+    it('should support $.every.minutes(30)', () => {
+      const workflow = Workflow($ => {
+        $.every.minutes(30)(() => {})
+      })
+
+      expect(workflow.definition.schedules[0]?.interval).toEqual({
+        type: 'minute',
+        value: 30,
+        natural: '30 minutes',
+      })
+    })
+
+    it('should support $.every("natural language")', () => {
+      const workflow = Workflow($ => {
+        $.every('first Monday of the month', () => {})
+      })
+
+      expect(workflow.definition.schedules[0]?.interval).toEqual({
+        type: 'natural',
+        description: 'first Monday of the month',
+      })
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['test/**/*.test.ts'],
+  },
+})

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 AI Primitives
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/scripts/generate-types.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/scripts/generate-types.js

@@ -1,57 +0,0 @@
-import { readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import matter from 'gray-matter';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const aiDir = resolve(process.cwd(), 'ai');
-const outputFile = resolve(process.cwd(), 'src/ai-types.d.ts');
-/**
- * Converts an MDX output type definition to a TypeScript type
- * Handles enum types (separated by |) and string types
- */
-function convertOutputTypeToTS(type) {
-    if (type.includes('|')) {
-        // Handle enum types (e.g., "Article | BlogPosting | Thing")
-        return type.split('|').map(t => `'${t.trim()}'`).join(' | ');
-    }
-    return 'string';
-}
-/**
- * Generates TypeScript type definitions from MDX files
- */
-function generateTypes() {
-    const mdxFiles = readdirSync(aiDir).filter(file => file.endsWith('.mdx'));
-    let typeDefinitions = `// Generated TypeScript definitions for AI methods
-// DO NOT EDIT DIRECTLY - Generated from MDX files in ai/
-
-declare const ai: {
-`;
-    for (const file of mdxFiles) {
-        const methodName = file.replace('.mdx', '');
-        const content = readFileSync(resolve(aiDir, file), 'utf-8');
-        const { data: frontmatter } = matter(content);
-        if (!frontmatter.output?.type) {
-            console.warn(`Warning: ${file} is missing output type definition`);
-            continue;
-        }
-        const tsType = convertOutputTypeToTS(frontmatter.output.type);
-        const description = frontmatter.output.description || 'No description provided';
-        typeDefinitions += `  /**
-   * ${description}
-   * @param input The input data for the AI operation
-   * @returns A promise that resolves to the generated output
-   */
-  ${methodName}(input: unknown): Promise<${tsType}>;
-
-`;
-    }
-    typeDefinitions += `}
-
-export { ai }
-`;
-    writeFileSync(outputFile, typeDefinitions);
-    console.log(`Generated type definitions at ${outputFile}`);
-}
-// Run the generator
-generateTypes();

package/dist/src/ai-proxy.d.ts

@@ -1,5 +0,0 @@
-/**
- * The ai object is a Proxy that dynamically loads MDX files for each method call
- * Example: ai.summarize(ticket) will load ai/summarize.mdx and use its configuration
- */
-export declare const ai: {};

package/dist/src/ai-proxy.js

@@ -1,94 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-import path from 'path';
-import matter from 'gray-matter';
-import { z } from 'zod';
-import { OpenAI } from 'openai';
-const aiBasePath = path.resolve(process.cwd(), 'ai');
-const openai = new OpenAI({
-    apiKey: process.env.OPENAI_API_KEY
-});
-// Schema for required MDX frontmatter
-const frontmatterSchema = z.object({
-    model: z.string(),
-    system: z.string(),
-    output: z.object({
-        type: z.string(),
-        description: z.string()
-    })
-});
-/**
- * Creates a Zod schema from an output definition in MDX frontmatter
- * Handles enum types (separated by |) and string types with descriptions
- * @param outputDef - The output definition from MDX frontmatter
- * @returns A Zod schema for validating the output
- */
-function createZodSchemaFromOutput(outputDef) {
-    const { type, description } = outputDef;
-    // Create schema based on output type
-    const schema = type.includes('|')
-        ? z.object({
-            type: z.enum(type.split('|').map(t => t.trim())),
-            description: z.string()
-        })
-        : z.object({
-            type: z.string(),
-            description: z.string()
-        });
-    return schema.describe(description);
-}
-/**
- * The ai object is a Proxy that dynamically loads MDX files for each method call
- * Example: ai.summarize(ticket) will load ai/summarize.mdx and use its configuration
- */
-export const ai = new Proxy({}, {
-    get(_target, methodName) {
-        return async (input) => {
-            try {
-                // Check if MDX file exists
-                const mdxFile = path.join(aiBasePath, `${methodName}.mdx`);
-                if (!existsSync(mdxFile)) {
-                    throw new Error(`No MDX file found for ai.${methodName}(). Create ${methodName}.mdx in the ai/ directory.`);
-                }
-                // Load and parse the MDX file
-                const fileContent = readFileSync(mdxFile, 'utf-8');
-                const { data: rawFrontmatter, content } = matter(fileContent);
-                // Validate frontmatter against schema
-                const frontmatter = frontmatterSchema.parse(rawFrontmatter);
-                // Create Zod schema from output definition
-                const outputSchema = createZodSchemaFromOutput(frontmatter.output);
-                // Generate response using OpenAI
-                const completion = await openai.chat.completions.create({
-                    model: frontmatter.model,
-                    messages: [
-                        { role: 'system', content: frontmatter.system },
-                        { role: 'user', content: `${content}\n\nInput: ${JSON.stringify(input, null, 2)}` }
-                    ],
-                    response_format: { type: 'json_object' },
-                    temperature: 0.7, // Add some creativity while maintaining structure
-                });
-                // Parse and validate the response
-                let result;
-                try {
-                    result = JSON.parse(completion.choices[0].message.content || '{}');
-                }
-                catch (error) {
-                    // Narrow error type for proper handling
-                    const parseError = error;
-                    throw new Error(`Failed to parse OpenAI response as JSON: ${parseError.message}`);
-                }
-                // Validate against our schema and return
-                return outputSchema.parse(result);
-            }
-            catch (error) {
-                // Enhance error messages for different types of failures
-                if (error instanceof z.ZodError) {
-                    throw new Error(`Schema validation failed in ai.${methodName}(): ${error.errors.map(e => e.message).join(', ')}`);
-                }
-                else if (error instanceof Error) {
-                    throw new Error(`Error in ai.${methodName}(): ${error.message}`);
-                }
-                throw error;
-            }
-        };
-    }
-});

package/dist/src/index.d.ts

@@ -1,9 +0,0 @@
-import { ai } from './ai-proxy.js';
-export { ai };
-/**
- * A placeholder function that adds two numbers
- * @param a First number
- * @param b Second number
- * @returns The sum of a and b
- */
-export declare function add(a: number, b: number): number;

package/dist/src/index.js

@@ -1,11 +0,0 @@
-import { ai } from './ai-proxy.js';
-export { ai };
-/**
- * A placeholder function that adds two numbers
- * @param a First number
- * @param b Second number
- * @returns The sum of a and b
- */
-export function add(a, b) {
-    return a + b;
-}

package/dist/src/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/index.test.js

@@ -1,35 +0,0 @@
-import { describe, it, expect, beforeAll } from '@jest/globals';
-import { add, ai } from './index.js';
-import { mkdir, writeFile } from 'fs/promises';
-import path from 'path';
-describe('add', () => {
-    it('should add two numbers correctly', () => {
-        expect(add(2, 3)).toBe(5);
-        expect(add(-1, 1)).toBe(0);
-        expect(add(0, 0)).toBe(0);
-    });
-});
-describe('ai', () => {
-    beforeAll(async () => {
-        // Create ai directory and test MDX file
-        await mkdir(path.resolve(process.cwd(), 'ai'), { recursive: true });
-        await writeFile(path.resolve(process.cwd(), 'ai/test.mdx'), `---
-model: gpt-3.5-turbo
-system: Test system prompt
-output:
-  type: Article | BlogPosting
-  description: Test description
----
-
-# Test MDX
-
-Test content`);
-    });
-    it('should handle AI method calls correctly', async () => {
-        const result = await ai.test({ input: 'test' });
-        expect(result).toEqual({
-            type: 'Article',
-            description: 'Test description'
-        });
-    });
-});