@output.ai/cli 0.0.0

package/README.md

@@ -0,0 +1,55 @@
+# @output.ai/cli
+
+CLI tool for generating Output.ai workflows.
+
+## Installation
+
+```bash
+# Install globally from the CLI package
+cd sdk/cli && npm link
+
+# Or run directly from the monorepo
+npx @output.ai/cli
+```
+
+## Usage
+
+### Generate a Workflow
+
+```bash
+# Generate a complete workflow with example steps
+output-cli workflow generate my-workflow --description "My awesome workflow"
+
+# Generate a minimal skeleton workflow
+output-cli workflow generate my-workflow --skeleton
+
+# Generate in a specific directory
+output-cli workflow generate my-workflow --output-dir ./src/workflows
+
+# Force overwrite existing workflow
+output-cli workflow generate my-workflow --force
+```
+
+#### Command Options
+
+- `--description, -d` - Description of the workflow
+- `--skeleton, -s` - Generate minimal skeleton without example steps
+- `--output-dir, -o` - Output directory (default: `output-workflows/src`)
+- `--force, -f` - Overwrite existing directory
+
+#### Generated Structure
+
+The CLI creates a complete workflow structure:
+
+```
+my-workflow/
+├── index.ts          # Main workflow definition
+├── steps.ts          # Activity/step implementations  
+├── types.ts          # TypeScript interfaces
+├── prompt@v1.prompt  # LLM prompt template (if not skeleton)
+└── README.md         # Workflow documentation
+```
+
+## About
+
+Built with [OCLIF](https://oclif.io) - see their documentation for advanced CLI features, plugins, and configuration options.

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import { execute } from '@oclif/core';
+
+await execute( { development: true, dir: import.meta.url } );

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { execute } from '@oclif/core';
+
+await execute( { dir: import.meta.url } );

package/dist/commands/workflow/generate.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class Generate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        skeleton: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'output-dir': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displaySuccess;
+}

package/dist/commands/workflow/generate.js

@@ -0,0 +1,74 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { generateWorkflow } from '../../services/workflow_generator.js';
+import { DEFAULT_OUTPUT_DIRS } from '../../utils/paths.js';
+export default class Generate extends Command {
+    static description = 'Generate a new Flow SDK workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-workflow',
+        '<%= config.bin %> <%= command.id %> my-workflow --skeleton',
+        '<%= config.bin %> <%= command.id %> data-processing --description "Process and transform data"'
+    ];
+    static flags = {
+        skeleton: Flags.boolean({
+            char: 's',
+            description: 'Generate minimal skeleton workflow without example steps',
+            default: false
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Description of the workflow',
+            required: false
+        }),
+        'output-dir': Flags.string({
+            char: 'o',
+            description: 'Output directory for the workflow',
+            default: DEFAULT_OUTPUT_DIRS.workflows
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Overwrite existing directory',
+            default: false
+        })
+    };
+    static args = {
+        name: Args.string({
+            required: true,
+            description: 'Name of the workflow to generate'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Generate);
+        // Check if skeleton flag is required
+        if (!flags.skeleton) {
+            this.error('Full workflow generation not implemented yet. Please use --skeleton flag');
+        }
+        try {
+            const result = await generateWorkflow({
+                name: args.name,
+                description: flags.description,
+                outputDir: flags['output-dir'],
+                skeleton: flags.skeleton,
+                force: flags.force
+            });
+            this.displaySuccess(result);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            throw error;
+        }
+    }
+    displaySuccess(result) {
+        this.log(`\n[SUCCESS] Workflow "${result.workflowName}" created successfully!`);
+        this.log(`\nLocation: ${result.targetDir}`);
+        this.log('\n-- Next steps --');
+        this.log(`   1. cd ${result.targetDir}`);
+        this.log('   2. Edit the workflow files to customize your implementation');
+        this.log('   3. If using @output.ai/llm, configure your .env file with LLM provider credentials:');
+        this.log('      - ANTHROPIC_API_KEY for Claude');
+        this.log('      - OPENAI_API_KEY for OpenAI');
+        this.log('   4. Build and run with the worker');
+        this.log('\nCheck the README.md for workflow-specific documentation.');
+    }
+}

package/dist/commands/workflow/generate.spec.d.ts

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

package/dist/commands/workflow/generate.spec.js

@@ -0,0 +1,119 @@
+/* eslint-disable no-restricted-syntax, @typescript-eslint/no-explicit-any, init-declarations */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Generate from './generate.js';
+import { generateWorkflow } from '../../services/workflow_generator.js';
+import { InvalidNameError, WorkflowExistsError } from '../../types/errors.js';
+// Mock the generateWorkflow function
+vi.mock('../../services/workflow_generator.js');
+describe('Generate Command', () => {
+    let mockGenerateWorkflow;
+    let logSpy;
+    const createCommand = () => {
+        const cmd = new Generate([], {});
+        // Mock OCLIF methods
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((message) => {
+            throw new Error(message);
+        });
+        // Mock parse method
+        cmd.parse = vi.fn();
+        logSpy = cmd.log;
+        return cmd;
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock generateWorkflow function
+        mockGenerateWorkflow = vi.mocked(generateWorkflow);
+    });
+    describe('successful workflow generation', () => {
+        it('should generate workflow with skeleton flag', async () => {
+            const cmd = createCommand();
+            // Mock parse return
+            cmd.parse.mockResolvedValue({
+                args: { name: 'test-workflow' },
+                flags: {
+                    skeleton: true,
+                    description: 'Test description',
+                    'output-dir': '/tmp',
+                    force: false
+                }
+            });
+            // Mock successful generation
+            mockGenerateWorkflow.mockResolvedValue({
+                workflowName: 'test-workflow',
+                targetDir: '/tmp/test-workflow',
+                filesCreated: ['index.ts', 'steps.ts', 'types.ts']
+            });
+            await cmd.run();
+            expect(mockGenerateWorkflow).toHaveBeenCalledWith({
+                name: 'test-workflow',
+                description: 'Test description',
+                outputDir: '/tmp',
+                skeleton: true,
+                force: false
+            });
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('[SUCCESS] Workflow "test-workflow" created successfully!'));
+        });
+        it('should require skeleton flag and reject without it', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'test-workflow' },
+                flags: {
+                    skeleton: false,
+                    'output-dir': '/tmp',
+                    force: false
+                }
+            });
+            await expect(cmd.run()).rejects.toThrow('Full workflow generation not implemented yet. Please use --skeleton flag');
+            expect(mockGenerateWorkflow).not.toHaveBeenCalled();
+        });
+    });
+    describe('error handling', () => {
+        it('should handle invalid name error', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'invalid name' },
+                flags: { 'output-dir': '/tmp', skeleton: true, force: false }
+            });
+            mockGenerateWorkflow.mockRejectedValue(new InvalidNameError('invalid name'));
+            await expect(cmd.run()).rejects.toThrow(/Invalid workflow name/i);
+        });
+        it('should handle workflow exists error', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'existing-workflow' },
+                flags: { 'output-dir': '/tmp', skeleton: true, force: false }
+            });
+            mockGenerateWorkflow.mockRejectedValue(new WorkflowExistsError('existing-workflow', '/tmp/existing-workflow'));
+            await expect(cmd.run()).rejects.toThrow(/already exists/i);
+        });
+        it('should re-throw non-CLI errors', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'test-workflow' },
+                flags: { 'output-dir': '/tmp', skeleton: true, force: false }
+            });
+            const systemError = new Error('System error');
+            mockGenerateWorkflow.mockRejectedValue(systemError);
+            await expect(cmd.run()).rejects.toThrow(systemError);
+        });
+    });
+    describe('success display', () => {
+        it('should display correct success message and next steps', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'my-workflow' },
+                flags: { 'output-dir': '/custom/path', skeleton: true, force: false }
+            });
+            mockGenerateWorkflow.mockResolvedValue({
+                workflowName: 'my-workflow',
+                targetDir: '/custom/path/my-workflow',
+                filesCreated: ['index.ts', 'steps.ts', 'types.ts']
+            });
+            await cmd.run();
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('[SUCCESS] Workflow "my-workflow" created successfully!'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Location: /custom/path/my-workflow'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('-- Next steps --'));
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.spec.d.ts

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

package/dist/index.spec.js

@@ -0,0 +1,6 @@
+import { describe, it, expect } from 'vitest';
+describe('CLI', () => {
+    it('should be initialized', () => {
+        expect(true).toBe(true);
+    });
+});

package/dist/services/template_processor.d.ts

@@ -0,0 +1,14 @@
+import type { TemplateFile } from '../types/generator.js';
+/**
+ * Get list of template files from a directory
+ * Automatically discovers all .template files and derives output names
+ */
+export declare function getTemplateFiles(templatesDir: string): Promise<TemplateFile[]>;
+/**
+ * Process a single template file
+ */
+export declare function processTemplateFile(templateFile: TemplateFile, targetDir: string, variables: Record<string, string>): Promise<void>;
+/**
+ * Process all template files
+ */
+export declare function processAllTemplates(templateFiles: TemplateFile[], targetDir: string, variables: Record<string, string>): Promise<string[]>;

package/dist/services/template_processor.js

@@ -0,0 +1,42 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { processTemplate } from '../utils/template.js';
+const TEMPLATE_EXTENSION = '.template';
+function isTemplateFile(file) {
+    return file.endsWith(TEMPLATE_EXTENSION);
+}
+function fileToTemplateFile(file, templatesDir) {
+    return {
+        name: file,
+        path: path.join(templatesDir, file),
+        outputName: file.replace(TEMPLATE_EXTENSION, '')
+    };
+}
+/**
+ * Get list of template files from a directory
+ * Automatically discovers all .template files and derives output names
+ */
+export async function getTemplateFiles(templatesDir) {
+    const files = await fs.readdir(templatesDir);
+    return files
+        .filter(isTemplateFile)
+        .map(file => fileToTemplateFile(file, templatesDir));
+}
+/**
+ * Process a single template file
+ */
+export async function processTemplateFile(templateFile, targetDir, variables) {
+    const templateContent = await fs.readFile(templateFile.path, 'utf-8');
+    const processedContent = processTemplate(templateContent, variables);
+    const outputPath = path.join(targetDir, templateFile.outputName);
+    await fs.writeFile(outputPath, processedContent, 'utf-8');
+}
+/**
+ * Process all template files
+ */
+export async function processAllTemplates(templateFiles, targetDir, variables) {
+    return Promise.all(templateFiles.map(async (templateFile) => {
+        await processTemplateFile(templateFile, targetDir, variables);
+        return templateFile.outputName;
+    }));
+}

package/dist/services/workflow_generator.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowGenerationConfig, WorkflowGenerationResult } from '../types/generator.js';
+/**
+ * Generate a new workflow
+ */
+export declare function generateWorkflow(config: WorkflowGenerationConfig): Promise<WorkflowGenerationResult>;

package/dist/services/workflow_generator.js

@@ -0,0 +1,40 @@
+import * as fs from 'node:fs/promises';
+import { WorkflowExistsError } from '../types/errors.js';
+import { createTargetDir, getTemplateDir } from '../utils/paths.js';
+import { validateWorkflowName, validateOutputDirectory } from '../utils/validation.js';
+import { prepareTemplateVariables } from '../utils/template.js';
+import { getTemplateFiles, processAllTemplates } from './template_processor.js';
+/**
+ * Validate the generation configuration
+ */
+function validateConfig(config) {
+    validateWorkflowName(config.name);
+    validateOutputDirectory(config.outputDir);
+}
+/**
+ * Check if target directory exists and handle accordingly
+ */
+import * as fsSync from 'node:fs';
+async function checkTargetDirectory(targetDir, force) {
+    if (fsSync.existsSync(targetDir) && !force) {
+        throw new WorkflowExistsError('', targetDir);
+    }
+}
+/**
+ * Generate a new workflow
+ */
+export async function generateWorkflow(config) {
+    validateConfig(config);
+    const targetDir = createTargetDir(config.outputDir, config.name);
+    const templatesDir = getTemplateDir('workflow');
+    await checkTargetDirectory(targetDir, config.force);
+    await fs.mkdir(targetDir, { recursive: true });
+    const variables = prepareTemplateVariables(config.name, config.description || '');
+    const templateFiles = await getTemplateFiles(templatesDir);
+    const filesCreated = await processAllTemplates(templateFiles, targetDir, variables);
+    return {
+        workflowName: config.name,
+        targetDir,
+        filesCreated
+    };
+}

package/dist/templates/workflow/.env.template

@@ -0,0 +1,7 @@
+# API Keys for LLM providers
+OPENAI_API_KEY=your_openai_api_key_here
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: Additional configuration
+# NODE_ENV=development
+# LOG_LEVEL=info

package/dist/templates/workflow/README.md.template

@@ -0,0 +1,215 @@
+# {{WorkflowName}} Workflow
+
+{{description}}
+
+## Overview
+
+This workflow was generated using the Flow SDK CLI. It provides a starting point for building Temporal-based workflows with LLM integration.
+
+## Files
+
+- `workflow.ts` - Main workflow definition with input/output schemas
+- `steps.ts` - Activity/step definitions with input/output schemas
+- `prompt@v1.prompt` - Example LLM prompt template
+- `.env` - Environment variables for API keys and configuration
+
+## Setup
+
+### Environment Variables
+
+Before running the workflow, configure your API keys in the `.env` file:
+
+```bash
+# Required for LLM functionality
+OPENAI_API_KEY=your_openai_api_key_here
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+```
+
+## Usage
+
+### Workflow Input
+
+The workflow expects input matching the input schema defined in `workflow.ts`.
+
+Example:
+```typescript
+{
+  prompt: "Tell me about workflows",
+  data: {
+    value: 42,
+    type: "example"
+  }
+}
+```
+
+### Workflow Output
+
+The workflow returns output matching the output schema defined in `workflow.ts`.
+
+Example:
+```typescript
+{
+  llmResponse: "Generated text from LLM",
+  processedData: {
+    processed: true,
+    timestamp: "2024-01-01T00:00:00Z",
+    data: { value: 42, type: "example" }
+  },
+  message: "Workflow completed successfully"
+}
+```
+
+## Development
+
+### Workflow Structure
+
+The workflow follows the new Flow SDK conventions:
+
+```typescript
+import { workflow } from '@output.ai/core';
+import { myStep, anotherStep } from './steps.js';
+
+const inputSchema = {
+  type: 'object',
+  properties: {
+    // Define your input properties
+  }
+};
+
+const outputSchema = {
+  type: 'object',
+  properties: {
+    // Define your output properties
+  }
+};
+
+export default workflow( {
+  name: 'workflowName',
+  description: 'Workflow description',
+  inputSchema,
+  outputSchema,
+  fn: async ( input ) => {
+    // Call steps directly
+    const result = await myStep( input );
+    return result;
+  }
+} );
+```
+
+### Adding New Steps
+
+1. Define new steps in `steps.ts` with schemas:
+
+```typescript
+import { step } from '@output.ai/core';
+
+const inputSchema = {
+  type: 'object',
+  properties: {
+    value: { type: 'number' }
+  },
+  required: ['value']
+};
+
+const outputSchema = {
+  type: 'object',
+  properties: {
+    result: { type: 'string' }
+  }
+};
+
+export const myStep = step( {
+  name: 'myStep',
+  description: 'Description of what this step does',
+  inputSchema,
+  outputSchema,
+  fn: async ( input: { value: number } ) => {
+    // Step implementation
+    return { result: `Processed ${input.value}` };
+  }
+} );
+```
+
+2. Import and use the step in your workflow (`workflow.ts`):
+
+```typescript
+import { myStep } from './steps.js';
+
+// Inside workflow fn:
+const result = await myStep( { value: 42 } );
+```
+
+### Using LLM in Steps
+
+The template includes an example of using LLM with prompts:
+
+```typescript
+import { loadPrompt } from '@output.ai/prompt';
+import { generateText } from '@output.ai/llm';
+import type { Prompt } from '@output.ai/llm';
+
+export const llmStep = step( {
+  name: 'llmStep',
+  description: 'Generate text using LLM',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      userInput: { type: 'string' }
+    }
+  },
+  outputSchema: { type: 'string' },
+  fn: async ( input: { userInput: string } ) => {
+    const prompt = loadPrompt( 'prompt@v1', { 
+      userInput: input.userInput 
+    } );
+    const response = await generateText( prompt as Prompt );
+    return response;
+  }
+} );
+```
+
+### Creating Prompt Templates
+
+Create new prompt files following the pattern:
+- File naming: `promptName@v1.prompt`
+- Include YAML frontmatter with provider and model
+- Use LiquidJS syntax for variables: `{{ variableName }}`
+
+Example prompt file:
+```
+---
+provider: anthropic
+model: claude-3-5-sonnet-latest
+---
+
+{{ userInput }}
+
+Please provide a helpful response.
+```
+
+## Testing
+
+To test your workflow:
+
+1. Build the parent project containing this workflow
+2. Start the Flow worker
+3. Execute the workflow using the Flow SDK API
+
+Example execution:
+```bash
+curl -X POST http://localhost:3001/workflow \
+  -H "Content-Type: application/json" \
+  -d '{
+    "workflowName": "{{workflowName}}",
+    "input": {
+      "prompt": "Tell me about workflows",
+      "data": { "value": 42, "type": "example" }
+    }
+  }'
+```
+
+## Resources
+
+- [Flow SDK Documentation](https://github.com/growthxai/flow-sdk)
+- [Temporal Documentation](https://docs.temporal.io)
+- [AI SDK Documentation](https://sdk.vercel.ai/docs)

package/dist/templates/workflow/prompt@v1.prompt.template

@@ -0,0 +1,13 @@
+---
+provider: anthropic
+model: claude-sonnet-4-20250514
+temperature: 0.7
+---
+
+<assistant>
+You are a helpful assistant for the {{workflowName}} workflow.
+</assistant>
+
+<user>
+{{ userInput }}
+</user>