ai-workflows 1.0.0 → 1.1.0

package/dist/scripts/generate-types.js

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,5 @@
+/**
+ * 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

@@ -0,0 +1,94 @@
+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/{index.d.ts → src/index.d.ts}

@@ -1,3 +1,5 @@
+import { ai } from './ai-proxy.js';
+export { ai };
 /**
  * A placeholder function that adds two numbers
  * @param a First number

package/dist/{index.js → src/index.js}

@@ -1,3 +1,5 @@
+import { ai } from './ai-proxy.js';
+export { ai };
 /**
  * A placeholder function that adds two numbers
  * @param a First number

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

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

package/dist/src/index.test.js

@@ -0,0 +1,35 @@
+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'
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-workflows",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Composable AI Workflows & Durable Execution Framework",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -14,12 +14,13 @@
     "bin"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && NODE_OPTIONS=\"--experimental-specifier-resolution=node --loader ts-node/esm\" ts-node scripts/generate-types.ts",
     "test": "jest",
     "test:watch": "jest --watch",
     "lint": "eslint src",
     "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx}\" \"*.{md,mdx}\"",
-    "prepublishOnly": "pnpm run build"
+    "prepublishOnly": "pnpm run build",
+    "generate-types": "NODE_OPTIONS=\"--experimental-specifier-resolution=node --loader ts-node/esm\" ts-node scripts/generate-types.ts"
   },
   "keywords": [
     "ai",
@@ -46,6 +47,7 @@
     "@semantic-release/github": "^11.0.1",
     "@semantic-release/npm": "^12.0.1",
     "@semantic-release/release-notes-generator": "^14.0.1",
+    "@swc/core": "^1.10.1",
     "@testing-library/jest-dom": "^6.4.2",
     "@testing-library/react": "^16.1.0",
     "@types/jest": "^29.5.14",
@@ -63,6 +65,7 @@
     "prettier": "^3.4.2",
     "semantic-release": "^24.2.0",
     "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
     "typescript": "^5.7.2"
   },
   "dependencies": {
@@ -71,6 +74,7 @@
     "ai-functions": "^0.2.19",
     "gray-matter": "^4.0.3",
     "mdxld": "^0.1.1",
+    "openai": "^4.77.0",
     "react": "^18.3.1",
     "react-dom": "^18.2.0",
     "yaml": "^2.6.1",

package/dist/index.test.js

@@ -1,9 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { add } from './index.js';
-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);
-    });
-});