@output.ai/cli 0.0.0

package/dist/templates/workflow/steps.ts.template

@@ -0,0 +1,77 @@
+import { step } from '@output.ai/core';
+import { loadPrompt } from '@output.ai/prompt';
+import { generateText } from '@output.ai/llm';
+import type { Prompt } from '@output.ai/llm';
+
+// Define input/output schemas for the LLM step
+const llmInputSchema = {
+  type: 'object',
+  properties: {
+    userInput: { type: 'string' }
+  },
+  required: ['userInput']
+};
+
+const llmOutputSchema = {
+  type: 'string'
+};
+
+// Example step using LLM
+export const exampleLLMStep = step( {
+  name: 'exampleLLMStep',
+  description: 'Example step that uses LLM',
+  inputSchema: llmInputSchema,
+  outputSchema: llmOutputSchema,
+  fn: async ( input: { userInput: string } ): Promise<string> => {
+    // Load the prompt template
+    const prompt = loadPrompt( 'prompt@v1', {
+      userInput: input.userInput
+    } );
+
+    // Generate text using LLM
+    const response = await generateText( prompt as Prompt );
+
+    return response;
+  }
+} );
+
+// Define schemas for data processing step
+const processDataInputSchema = {
+  type: 'object',
+  properties: {
+    value: { type: 'number' },
+    type: { type: 'string' }
+  },
+  required: ['value', 'type']
+};
+
+const processDataOutputSchema = {
+  type: 'object',
+  properties: {
+    processed: { type: 'boolean' },
+    timestamp: { type: 'string' },
+    data: { type: 'object' }
+  },
+  required: ['processed', 'timestamp', 'data']
+};
+
+// Example data processing step
+export const processDataStep = step( {
+  name: 'processDataStep',
+  description: 'Process input data',
+  inputSchema: processDataInputSchema,
+  outputSchema: processDataOutputSchema,
+  fn: async ( input: { value: number; type: string } ) => {
+    // TODO: Implement your step logic here
+    console.log( 'Processing data:', input );
+
+    // Example processing
+    return {
+      processed: true,
+      timestamp: new Date().toISOString(),
+      data: input
+    };
+  }
+} );
+
+// Add more steps as needed

package/dist/templates/workflow/workflow.ts.template

@@ -0,0 +1,73 @@
+import { workflow } from '@output.ai/core';
+import { exampleLLMStep, processDataStep } from './steps.js';
+
+// Define the input schema for the workflow
+const inputSchema = {
+  type: 'object',
+  properties: {
+    prompt: { 
+      type: 'string',
+      description: 'The prompt to send to the LLM'
+    },
+    data: {
+      type: 'object',
+      properties: {
+        value: { type: 'number' },
+        type: { type: 'string' }
+      },
+      required: ['value', 'type']
+    }
+  },
+  required: ['prompt']
+};
+
+// Define the output schema for the workflow
+const outputSchema = {
+  type: 'object',
+  properties: {
+    llmResponse: { type: 'string' },
+    processedData: {
+      type: 'object',
+      properties: {
+        processed: { type: 'boolean' },
+        timestamp: { type: 'string' },
+        data: { type: 'object' }
+      }
+    },
+    message: { type: 'string' }
+  },
+  required: ['llmResponse', 'processedData', 'message']
+};
+
+// Define the input type based on the schema
+interface WorkflowInput {
+  prompt: string;
+  data?: {
+    value: number;
+    type: string;
+  };
+}
+
+export default workflow( {
+  name: '{{workflowName}}',
+  description: '{{description}}',
+  inputSchema,
+  outputSchema,
+  fn: async ( input: WorkflowInput ) => {
+    // Call the LLM step with input from workflow
+    const llmResponse = await exampleLLMStep( {
+      userInput: input.prompt
+    } );
+
+    // Process data if provided, otherwise use defaults
+    const processedData = await processDataStep( 
+      input.data || { value: 42, type: 'default' }
+    );
+
+    return {
+      llmResponse,
+      processedData,
+      message: 'Workflow {{workflowName}} executed successfully'
+    };
+  }
+} );

package/dist/types/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Error thrown when a workflow already exists
+ */
+export declare class WorkflowExistsError extends Error {
+    constructor(workflowName: string, targetPath: string);
+}
+/**
+ * Error thrown when workflow name is invalid
+ */
+export declare class InvalidNameError extends Error {
+    constructor(name: string);
+}
+/**
+ * Error thrown when template file is not found
+ */
+export declare class TemplateNotFoundError extends Error {
+    constructor(templateFile: string);
+}
+/**
+ * Error thrown when output directory is invalid or inaccessible
+ */
+export declare class InvalidOutputDirectoryError extends Error {
+    constructor(outputDir: string, reason?: string);
+}

package/dist/types/errors.js

@@ -0,0 +1,35 @@
+/**
+ * Error thrown when a workflow already exists
+ */
+export class WorkflowExistsError extends Error {
+    constructor(workflowName, targetPath) {
+        super(`Workflow "${workflowName}" already exists at ${targetPath}. Use --force to overwrite.`);
+    }
+}
+/**
+ * Error thrown when workflow name is invalid
+ */
+export class InvalidNameError extends Error {
+    constructor(name) {
+        super(`Invalid workflow name "${name}". Name must contain only letters, numbers, hyphens, and underscores.`);
+    }
+}
+/**
+ * Error thrown when template file is not found
+ */
+export class TemplateNotFoundError extends Error {
+    constructor(templateFile) {
+        super(`Template file "${templateFile}" not found. Please ensure CLI is properly installed.`);
+    }
+}
+/**
+ * Error thrown when output directory is invalid or inaccessible
+ */
+export class InvalidOutputDirectoryError extends Error {
+    constructor(outputDir, reason) {
+        const message = reason ?
+            `Invalid output directory "${outputDir}": ${reason}` :
+            `Invalid output directory "${outputDir}"`;
+        super(message);
+    }
+}

package/dist/types/generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Configuration for workflow generation
+ */
+export interface WorkflowGenerationConfig {
+    name: string;
+    description?: string;
+    outputDir: string;
+    skeleton: boolean;
+    force: boolean;
+}
+/**
+ * Result of workflow generation
+ */
+export interface WorkflowGenerationResult {
+    workflowName: string;
+    targetDir: string;
+    filesCreated: string[];
+}
+/**
+ * Template file information
+ */
+export interface TemplateFile {
+    name: string;
+    path: string;
+    outputName: string;
+}

package/dist/types/generator.js

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

package/dist/utils/paths.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Template directory paths
+ */
+export declare const TEMPLATE_DIRS: {
+    readonly workflow: string;
+};
+/**
+ * Default output directories
+ */
+export declare const DEFAULT_OUTPUT_DIRS: {
+    readonly workflows: "output-workflows/src";
+};
+/**
+ * Resolve the output directory path
+ */
+export declare function resolveOutputDir(outputDir: string): string;
+/**
+ * Create target directory path for a workflow
+ */
+export declare function createTargetDir(outputDir: string, workflowName: string): string;
+/**
+ * Get the template directory for a specific template type
+ */
+export declare function getTemplateDir(templateType: keyof typeof TEMPLATE_DIRS): string;

package/dist/utils/paths.js

@@ -0,0 +1,35 @@
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Template directory paths
+ */
+export const TEMPLATE_DIRS = {
+    workflow: path.join(__dirname, '..', 'templates', 'workflow')
+};
+/**
+ * Default output directories
+ */
+export const DEFAULT_OUTPUT_DIRS = {
+    workflows: 'output-workflows/src'
+};
+/**
+ * Resolve the output directory path
+ */
+export function resolveOutputDir(outputDir) {
+    return path.resolve(process.cwd(), outputDir);
+}
+/**
+ * Create target directory path for a workflow
+ */
+export function createTargetDir(outputDir, workflowName) {
+    const resolvedOutputDir = resolveOutputDir(outputDir);
+    return path.join(resolvedOutputDir, workflowName);
+}
+/**
+ * Get the template directory for a specific template type
+ */
+export function getTemplateDir(templateType) {
+    return TEMPLATE_DIRS[templateType];
+}

package/dist/utils/template.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Process a template string with variables
+ */
+export declare function processTemplate(templateContent: string, variables: Record<string, string>): string;
+/**
+ * Prepare template variables from workflow name and description
+ */
+export declare function prepareTemplateVariables(workflowName: string, description: string): Record<string, string>;
+export { camelCase, pascalCase } from 'change-case';

package/dist/utils/template.js

@@ -0,0 +1,30 @@
+import Handlebars from 'handlebars';
+import { camelCase, pascalCase } from 'change-case';
+/**
+ * Create a Handlebars compiler with custom helpers
+ */
+function createCompiler() {
+    const compiler = Handlebars.create();
+    compiler.registerHelper('camelCase', (str) => camelCase(str));
+    compiler.registerHelper('pascalCase', (str) => pascalCase(str));
+    return compiler;
+}
+/**
+ * Process a template string with variables
+ */
+export function processTemplate(templateContent, variables) {
+    const compiler = createCompiler();
+    const template = compiler.compile(templateContent);
+    return template(variables);
+}
+/**
+ * Prepare template variables from workflow name and description
+ */
+export function prepareTemplateVariables(workflowName, description) {
+    return {
+        workflowName: camelCase(workflowName),
+        WorkflowName: pascalCase(workflowName),
+        description: description || `A ${workflowName} workflow`
+    };
+}
+export { camelCase, pascalCase } from 'change-case';

package/dist/utils/template.spec.d.ts

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

package/dist/utils/template.spec.js

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import { camelCase, pascalCase, processTemplate, prepareTemplateVariables } from './template';
+describe('Template Utilities', () => {
+    describe('pascalCase', () => {
+        it('should convert kebab-case to PascalCase', () => {
+            expect(pascalCase('my-workflow-name')).toBe('MyWorkflowName');
+        });
+        it('should convert snake_case to PascalCase', () => {
+            expect(pascalCase('my_workflow_name')).toBe('MyWorkflowName');
+        });
+        it('should handle single word', () => {
+            expect(pascalCase('workflow')).toBe('Workflow');
+        });
+        it('should handle mixed separators', () => {
+            expect(pascalCase('my-workflow_name')).toBe('MyWorkflowName');
+        });
+    });
+    describe('camelCase', () => {
+        it('should convert kebab-case to camelCase', () => {
+            expect(camelCase('my-workflow-name')).toBe('myWorkflowName');
+        });
+        it('should convert snake_case to camelCase', () => {
+            expect(camelCase('my_workflow_name')).toBe('myWorkflowName');
+        });
+        it('should handle single word', () => {
+            expect(camelCase('workflow')).toBe('workflow');
+        });
+    });
+    describe('processTemplate', () => {
+        it('should replace single variable', () => {
+            const template = 'Hello {{name}}!';
+            const variables = { name: 'World' };
+            expect(processTemplate(template, variables)).toBe('Hello World!');
+        });
+        it('should replace multiple variables', () => {
+            const template = 'Workflow {{workflowName}} - {{description}}';
+            const variables = {
+                workflowName: 'myWorkflow',
+                description: 'A test workflow'
+            };
+            expect(processTemplate(template, variables))
+                .toBe('Workflow myWorkflow - A test workflow');
+        });
+        it('should replace multiple occurrences of same variable', () => {
+            const template = '{{name}} says hello to {{name}}';
+            const variables = { name: 'Alice' };
+            expect(processTemplate(template, variables))
+                .toBe('Alice says hello to Alice');
+        });
+        it('should use Handlebars helpers for case transformations', () => {
+            const template = '{{camelCase name}} and {{pascalCase name}}';
+            const variables = { name: 'my-workflow-name' };
+            expect(processTemplate(template, variables))
+                .toBe('myWorkflowName and MyWorkflowName');
+        });
+    });
+    describe('prepareTemplateVariables', () => {
+        it('should prepare variables from workflow name and description', () => {
+            const variables = prepareTemplateVariables('my-test-workflow', 'A test workflow for testing');
+            expect(variables).toEqual({
+                workflowName: 'myTestWorkflow',
+                WorkflowName: 'MyTestWorkflow',
+                description: 'A test workflow for testing'
+            });
+        });
+        it('should provide default description if not provided', () => {
+            const variables = prepareTemplateVariables('test-workflow', '');
+            expect(variables.description).toBe('A test-workflow workflow');
+        });
+    });
+});

package/dist/utils/validation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Validate workflow name format
+ * Must contain only letters, numbers, hyphens, and underscores
+ */
+export declare function isValidWorkflowName(name: string): boolean;
+/**
+ * Validate workflow name and throw descriptive error if invalid
+ */
+export declare function validateWorkflowName(name: string): void;
+/**
+ * Validate that a directory path is safe to create
+ */
+export declare function validateOutputDirectory(outputDir: string): void;

package/dist/utils/validation.js

@@ -0,0 +1,25 @@
+import { InvalidNameError, InvalidOutputDirectoryError } from '../types/errors.js';
+/**
+ * Validate workflow name format
+ * Must contain only letters, numbers, hyphens, and underscores
+ */
+export function isValidWorkflowName(name) {
+    // Must start with a letter or underscore, followed by any number of letters, numbers, or underscores
+    return /^[a-z_][a-z0-9_]*$/i.test(name);
+}
+/**
+ * Validate workflow name and throw descriptive error if invalid
+ */
+export function validateWorkflowName(name) {
+    if (!isValidWorkflowName(name)) {
+        throw new InvalidNameError(name);
+    }
+}
+/**
+ * Validate that a directory path is safe to create
+ */
+export function validateOutputDirectory(outputDir) {
+    if (!outputDir || outputDir.trim() === '') {
+        throw new InvalidOutputDirectoryError(outputDir, 'Output directory cannot be empty');
+    }
+}

package/dist/utils/validation.spec.d.ts

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

package/dist/utils/validation.spec.js

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest';
+import { isValidWorkflowName } from './validation.js';
+describe('isValidWorkflowName', () => {
+    describe('valid workflow names', () => {
+        it('should accept single letter', () => {
+            expect(isValidWorkflowName('a')).toBe(true);
+            expect(isValidWorkflowName('Z')).toBe(true);
+        });
+        it('should accept single underscore', () => {
+            expect(isValidWorkflowName('_')).toBe(true);
+        });
+        it('should accept names starting with letter', () => {
+            expect(isValidWorkflowName('workflow')).toBe(true);
+            expect(isValidWorkflowName('MyWorkflow')).toBe(true);
+            expect(isValidWorkflowName('simpleWorkflow123')).toBe(true);
+        });
+        it('should accept names starting with underscore', () => {
+            expect(isValidWorkflowName('_workflow')).toBe(true);
+            expect(isValidWorkflowName('_private_workflow')).toBe(true);
+            expect(isValidWorkflowName('__double_underscore')).toBe(true);
+        });
+        it('should accept names with numbers after first character', () => {
+            expect(isValidWorkflowName('workflow1')).toBe(true);
+            expect(isValidWorkflowName('workflow_123')).toBe(true);
+            expect(isValidWorkflowName('a123456789')).toBe(true);
+            expect(isValidWorkflowName('_123')).toBe(true);
+        });
+        it('should accept names with underscores in any position', () => {
+            expect(isValidWorkflowName('my_workflow')).toBe(true);
+            expect(isValidWorkflowName('workflow_name_here')).toBe(true);
+            expect(isValidWorkflowName('a_b_c_d')).toBe(true);
+            expect(isValidWorkflowName('workflow__double')).toBe(true);
+        });
+        it('should accept mixed case names', () => {
+            expect(isValidWorkflowName('WorkFlow')).toBe(true);
+            expect(isValidWorkflowName('myWorkFlow')).toBe(true);
+            expect(isValidWorkflowName('MY_WORKFLOW')).toBe(true);
+            expect(isValidWorkflowName('CamelCaseWorkflow')).toBe(true);
+        });
+        it('should accept long valid names', () => {
+            const longName = 'a'.repeat(100) + '_' + '1'.repeat(100);
+            expect(isValidWorkflowName(longName)).toBe(true);
+        });
+    });
+    describe('invalid workflow names', () => {
+        it('should reject empty string', () => {
+            expect(isValidWorkflowName('')).toBe(false);
+        });
+        it('should reject names starting with numbers', () => {
+            expect(isValidWorkflowName('1workflow')).toBe(false);
+            expect(isValidWorkflowName('123')).toBe(false);
+            expect(isValidWorkflowName('0_workflow')).toBe(false);
+            expect(isValidWorkflowName('9abc')).toBe(false);
+        });
+        it('should reject names with hyphens', () => {
+            expect(isValidWorkflowName('my-workflow')).toBe(false);
+            expect(isValidWorkflowName('workflow-name')).toBe(false);
+            expect(isValidWorkflowName('-workflow')).toBe(false);
+            expect(isValidWorkflowName('workflow-')).toBe(false);
+        });
+        it('should reject names with spaces', () => {
+            expect(isValidWorkflowName('my workflow')).toBe(false);
+            expect(isValidWorkflowName(' workflow')).toBe(false);
+            expect(isValidWorkflowName('workflow ')).toBe(false);
+            expect(isValidWorkflowName('work flow')).toBe(false);
+        });
+        it('should reject names with special characters', () => {
+            expect(isValidWorkflowName('workflow!')).toBe(false);
+            expect(isValidWorkflowName('work@flow')).toBe(false);
+            expect(isValidWorkflowName('workflow#123')).toBe(false);
+            expect(isValidWorkflowName('work$flow')).toBe(false);
+            expect(isValidWorkflowName('workflow%')).toBe(false);
+            expect(isValidWorkflowName('work^flow')).toBe(false);
+            expect(isValidWorkflowName('workflow&')).toBe(false);
+            expect(isValidWorkflowName('work*flow')).toBe(false);
+            expect(isValidWorkflowName('workflow(')).toBe(false);
+            expect(isValidWorkflowName('work)flow')).toBe(false);
+            expect(isValidWorkflowName('work+flow')).toBe(false);
+            expect(isValidWorkflowName('work=flow')).toBe(false);
+            expect(isValidWorkflowName('work[flow')).toBe(false);
+            expect(isValidWorkflowName('work]flow')).toBe(false);
+            expect(isValidWorkflowName('work{flow')).toBe(false);
+            expect(isValidWorkflowName('work}flow')).toBe(false);
+            expect(isValidWorkflowName('work|flow')).toBe(false);
+            expect(isValidWorkflowName('work\\flow')).toBe(false);
+            expect(isValidWorkflowName('work/flow')).toBe(false);
+            expect(isValidWorkflowName('work:flow')).toBe(false);
+            expect(isValidWorkflowName('work;flow')).toBe(false);
+            expect(isValidWorkflowName('work"flow')).toBe(false);
+            expect(isValidWorkflowName('work\'flow')).toBe(false);
+            expect(isValidWorkflowName('work<flow')).toBe(false);
+            expect(isValidWorkflowName('work>flow')).toBe(false);
+            expect(isValidWorkflowName('work,flow')).toBe(false);
+            expect(isValidWorkflowName('work.flow')).toBe(false);
+            expect(isValidWorkflowName('work?flow')).toBe(false);
+            expect(isValidWorkflowName('work`flow')).toBe(false);
+            expect(isValidWorkflowName('work~flow')).toBe(false);
+        });
+        it('should reject names with unicode characters', () => {
+            expect(isValidWorkflowName('wørkflow')).toBe(false);
+            expect(isValidWorkflowName('работа')).toBe(false);
+            expect(isValidWorkflowName('工作流')).toBe(false);
+            expect(isValidWorkflowName('workflow™')).toBe(false);
+            expect(isValidWorkflowName('work✓flow')).toBe(false);
+            expect(isValidWorkflowName('😀workflow')).toBe(false);
+        });
+        it('should reject names with tabs and newlines', () => {
+            expect(isValidWorkflowName('work\tflow')).toBe(false);
+            expect(isValidWorkflowName('work\nflow')).toBe(false);
+            expect(isValidWorkflowName('work\rflow')).toBe(false);
+        });
+        it('should handle string versions of null and undefined', () => {
+            // String(null) returns "null" which is actually a valid workflow name
+            expect(isValidWorkflowName(String(null))).toBe(true);
+            // String(undefined) returns "undefined" which is also a valid workflow name
+            expect(isValidWorkflowName(String(undefined))).toBe(true);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle boundary conditions', () => {
+            expect(isValidWorkflowName('a0')).toBe(true);
+            expect(isValidWorkflowName('_0')).toBe(true);
+            expect(isValidWorkflowName('Z9')).toBe(true);
+            expect(isValidWorkflowName('_9')).toBe(true);
+        });
+        it('should be case-insensitive for letters', () => {
+            expect(isValidWorkflowName('abc')).toBe(true);
+            expect(isValidWorkflowName('ABC')).toBe(true);
+            expect(isValidWorkflowName('AbC')).toBe(true);
+        });
+        it('should handle only underscores and numbers after initial character', () => {
+            expect(isValidWorkflowName('a_________')).toBe(true);
+            expect(isValidWorkflowName('_000000000')).toBe(true);
+            expect(isValidWorkflowName('a_0_1_2_3')).toBe(true);
+        });
+    });
+});

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@output.ai/cli",
+  "description": "CLI for Output.ai workflow generation",
+  "version": "0.0.0",
+  "author": "Ben Church",
+  "bin": {
+    "output-cli": "./bin/run.js"
+  },
+  "bugs": "https://github.com/growthxai/flow-sdk/issues",
+  "dependencies": {
+    "@oclif/core": "^4",
+    "@oclif/plugin-help": "^6",
+    "@oclif/plugin-plugins": "^5",
+    "change-case": "^5.4.4",
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@oclif/test": "^4",
+    "@types/handlebars": "^4.0.40",
+    "@types/node": "^18",
+    "copyfiles": "^2.4.1",
+    "oclif": "^4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "./bin",
+    "./dist",
+    "./oclif.manifest.json"
+  ],
+  "homepage": "https://github.com/growthxai/flow-sdk",
+  "keywords": [
+    "oclif"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "type": "module",
+  "oclif": {
+    "bin": "output-cli",
+    "dirname": "output-cli",
+    "commands": "./dist/commands",
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-plugins"
+    ],
+    "topicSeparator": " ",
+    "topics": {
+      "workflow": {
+        "description": "Manage Output.ai workflows"
+      }
+    }
+  },
+  "repository": "sdk/cli",
+  "scripts": {
+    "build": "rm -rf ./dist && tsc && copyfiles -u 1 './src/templates/**/*.template' './src/templates/**/.env.template' './src/templates/**/*.prompt.template' dist",
+    "test": "vitest run"
+  },
+  "types": "dist/index.d.ts"
+}