Output Dev Create Skeleton

npx output workflow generate --skeleton

src/workflows/{workflow-name}/
├── workflow.ts      # Main workflow definition
├── steps.ts         # Step function definitions
├── types.ts         # Zod schemas and types
├── prompts/         # Empty folder for prompt files
└── scenarios/       # Empty folder for test scenarios

src/
├── shared/                      # Shared code (create if needed)
│   ├── clients/                 # API clients
│   ├── utils/                   # Utility functions
│   ├── services/                # Business logic services
│   ├── steps/                   # Shared steps (optional)
│   └── evaluators/              # Shared evaluators (optional)
└── workflows/
    └── {workflow-name}/         # Your new workflow
        ├── workflow.ts
        ├── steps.ts
        ├── types.ts
        ├── prompts/
        └── scenarios/

import { workflow, z } from '@outputai/core';
import { exampleStep } from './steps.js';
import { WorkflowInputSchema } from './types.js';

export default workflow( {
  name: 'workflowName',
  description: 'Workflow description',
  inputSchema: WorkflowInputSchema,
  outputSchema: z.object( { result: z.string() } ),
  fn: async input => {
    const result = await exampleStep( input );
    return { result };
  }
} );

import { step, z } from '@outputai/core';
import { ExampleStepInputSchema } from './types.js';

export const exampleStep = step( {
  name: 'exampleStep',
  description: 'Example step description',
  inputSchema: ExampleStepInputSchema,
  outputSchema: z.object( { result: z.string() } ),
  fn: async input => {
    // Implement step logic here
    return { result: 'example' };
  }
} );

import { z } from '@outputai/core';

export const WorkflowInputSchema = z.object( {
  // Define input fields
} );

export type WorkflowInput = z.infer<typeof WorkflowInputSchema>;

import { z } from '@outputai/core';

export const WorkflowInputSchema = z.object( {
  content: z.string().describe( 'Content to process' ),
  options: z.object( {
    format: z.enum( [ 'json', 'text' ] ).default( 'json' )
  } ).optional()
} );

export type WorkflowInput = z.infer<typeof WorkflowInputSchema>;
export type WorkflowOutput = { processed: string };

import { step, z, FatalError, ValidationError } from '@outputai/core';
import { ProcessContentInputSchema } from './types.js';

export const processContent = step( {
  name: 'processContent',
  description: 'Process the input content',
  inputSchema: ProcessContentInputSchema,
  outputSchema: z.object( { processed: z.string() } ),
  fn: async ( { content } ) => {
    // Implement your logic
    return { processed: content.toUpperCase() };
  }
} );

import { workflow, z } from '@outputai/core';
import { processContent } from './steps.js';
import { WorkflowInputSchema } from './types.js';

export default workflow( {
  name: 'contentProcessor',
  description: 'Process content with custom logic',
  inputSchema: WorkflowInputSchema,
  outputSchema: z.object( { processed: z.string() } ),
  fn: async input => {
    const result = await processContent( { content: input.content } );
    return result;
  }
} );

prompts/
└── analyzeContent@v1.prompt

scenarios/
├── basic_input.json
└── complex_input.json

# Create shared directories if they don't exist
mkdir -p src/shared/clients
mkdir -p src/shared/utils
mkdir -p src/shared/services

import { GeminiService } from '../../shared/clients/gemini_client.js';
import { formatDate } from '../../shared/utils/date_helpers.js';