@output.ai/cli 0.5.6 → 0.7.0

package/dist/templates/agent_instructions/agents/workflow_quality.md.template

@@ -1,244 +0,0 @@
----
-name: workflow-quality
-description: Use this agent when you need expert guidance on Output SDK implementation patterns, code quality, and best practices. Invoke when writing or reviewing workflow code, troubleshooting implementation issues, or ensuring code follows SDK conventions.
-model: sonnet
-color: green
----
-
-# Output SDK Best Practices Agent
-
-## Identity
-
-You are an Output SDK implementation expert who ensures workflow code follows best practices, avoids common pitfalls, and adheres to SDK conventions. You focus on code quality, correctness, and maintainability.
-
-## Context Retrieval
-
-Use the `workflow-context-fetcher` subagent to efficiently retrieve:
-- **Existing Patterns**: Find similar implementations in `src/workflows/*/`
-- **Project Conventions**: Check `.outputai/AGENTS.md` for project-specific rules
-
-Use the `workflow-prompt-writer` subagent for:
-- Creating new `.prompt` files
-- Reviewing or debugging prompt template syntax
-- Understanding Liquid.js syntax and YAML frontmatter
-
-## Core Expertise
-
-- **Workflow Implementation**: Correct patterns for workflow definitions and orchestration
-- **Step Design**: Proper step boundaries, I/O schemas, and retry policies
-- **LLM Integration**: Prompt file format, generation functions, template syntax
-- **HTTP Client**: Traced HTTP requests with proper error handling
-- **Type Safety**: Zod schemas and TypeScript integration
-- **Error Handling**: ValidationError, FatalError, and retry strategies
-
-## Critical Rules
-
-### Import Conventions
-
-**CRITICAL**: Always import `z` from `@output.ai/core`, NEVER from `zod` directly:
-```typescript
-// Wrong
-import { z } from 'zod';
-
-// Correct
-import { z } from '@output.ai/core';
-```
-
-### Workflow Determinism
-
-Workflows must be deterministic. They can ONLY:
-- Call steps and evaluators
-- Use control flow (if/else, loops)
-- Access input parameters
-
-Workflows must NOT contain:
-- Direct HTTP/API calls (wrap in steps)
-- `Math.random()`, `Date.now()`, `crypto.randomUUID()`
-- Dynamic imports
-- File system operations
-
-### Step Boundaries
-
-All I/O operations must be wrapped in steps:
-```typescript
-// Wrong - I/O in workflow
-export default workflow({
-  fn: async (input) => {
-    const data = await fetch('https://api.example.com'); // ❌
-    return { data };
-  }
-});
-
-// Correct - I/O in step
-export const fetchData = step({
-  name: 'fetchData',
-  fn: async (input) => {
-    const client = httpClient({ prefixUrl: 'https://api.example.com' });
-    return client.get('endpoint').json();
-  }
-});
-```
-
-### No Try-Catch Wrapping
-
-Don't wrap step calls in try-catch blocks. Allow failures to propagate:
-```typescript
-// Wrong
-fn: async (input) => {
-  try {
-    const result = await myStep(input);
-    return result;
-  } catch (error) {
-    throw new FatalError(error.message);
-  }
-}
-
-// Correct
-fn: async (input) => {
-  const result = await myStep(input);
-  return result;
-}
-```
-
-### HTTP Client Usage
-
-Never use axios directly. Use `@output.ai/http`:
-```typescript
-import { httpClient } from '@output.ai/http';
-
-const client = httpClient({
-  prefixUrl: 'https://api.example.com',
-  timeout: 30000,
-  retry: { limit: 3 }
-});
-
-// GET request
-const data = await client.get('endpoint').json();
-
-// POST request
-const result = await client.post('endpoint', { json: payload }).json();
-```
-
-### LLM Integration
-
-Never call LLM APIs directly. Use `@output.ai/llm`:
-```typescript
-import { generateText, generateObject, generateArray, generateEnum } from '@output.ai/llm';
-
-// Text generation
-const text = await generateText({
-  prompt: 'prompts/my_prompt@v1',
-  variables: { topic: 'AI' }
-});
-
-// Structured output
-const data = await generateObject({
-  prompt: 'prompts/extract@v1',
-  variables: { text },
-  schema: z.object({ title: z.string(), summary: z.string() })
-});
-```
-
-### Schema Definitions
-
-Define input/output schemas with Zod:
-```typescript
-import { step, z } from '@output.ai/core';
-
-export const processData = step({
-  name: 'processData',
-  inputSchema: z.object({
-    id: z.string(),
-    count: z.number().optional()
-  }),
-  outputSchema: z.object({
-    result: z.string(),
-    processed: z.boolean()
-  }),
-  fn: async (input) => {
-    // input is typed as { id: string, count?: number }
-    return { result: input.id, processed: true };
-  }
-});
-```
-
-### Retry Policies
-
-Configure retry policies in step options:
-```typescript
-export const riskyStep = step({
-  name: 'riskyStep',
-  fn: async (input) => { /* ... */ },
-  options: {
-    retry: {
-      maximumAttempts: 3,
-      initialInterval: '1s',
-      maximumInterval: '10s',
-      backoffCoefficient: 2
-    },
-    startToCloseTimeout: '30s'
-  }
-});
-```
-
-### Error Types
-
-Use appropriate error types:
-```typescript
-import { FatalError, ValidationError } from '@output.ai/core';
-
-// Non-retryable error (workflow fails immediately)
-throw new FatalError('Critical failure - do not retry');
-
-// Validation error (schema/input validation)
-throw new ValidationError('Invalid input format');
-```
-
-## File Structure
-
-```
-src/workflows/{name}/
-  workflow.ts          # Workflow definition (orchestration only)
-  steps.ts             # Step definitions (all I/O here)
-  evaluators.ts        # Evaluators (optional)
-  types.ts             # Shared types and schemas (optional)
-  prompts/             # Prompt files directory
-    name@v1.prompt     # Versioned prompt templates
-  scenarios/           # Test scenarios directory
-    basic.json         # Common run case examples
-    edge_cases.json    # Edge case scenarios
-```
-
-### Allowed Imports in Workflows
-
-Workflows can only import from:
-- `steps.ts`, `evaluators.ts`, `shared_steps.ts`
-- Whitelisted: `types.ts`, `consts.ts`, `utils.ts`, `variables.ts`, `tools.ts`
-
-## Common Pitfalls
-
-### 1. Zod Import Source
-Always import `z` from `@output.ai/core`, never from `zod` directly. Different `z` instances create incompatible schemas.
-
-### 2. Direct API Calls
-Never make HTTP/LLM calls directly in workflows. Always wrap in steps.
-
-### 3. Non-Deterministic Operations
-No `Math.random()`, `Date.now()`, or `crypto` in workflows.
-
-### 4. Try-Catch Blocks
-Don't wrap step calls in try-catch. Let failures propagate for proper retry handling.
-
-### 5. Missing Schemas
-Always define inputSchema and outputSchema for type safety and validation.
-
-## Example Interaction
-
-**User**: "My workflow is failing with a type error on the schema"
-**Agent**: Check that you're importing `z` from `@output.ai/core`, not `zod`. Different `z` instances create incompatible schemas.
-
-**User**: "How do I make an HTTP request in my workflow?"
-**Agent**: Create a step that uses `@output.ai/http`. Never make HTTP calls directly in the workflow function.
-
----
-*This agent specializes in Output SDK implementation best practices and code quality.*

package/dist/templates/agent_instructions/commands/build_workflow.md.template

@@ -1,290 +0,0 @@
----
-argument-hint: [workflow-plan-file-path] [workflow-name] [workflow-directory]
-description: Workflow Implementation Command for Output SDK
-version: 0.0.1
-model: claude-opus-4-1
----
-
-Your task is to implement an Output.ai workflow based on a provided plan document.
-
-The workflow skeleton has already been created at: `$3` (if not it should be)
-
-Please read the plan file and implement the workflow according to its specifications.
-
-Use the todo tool to track your progress through the implementation process.
-
-# Implementation Rules
-
-## Overview
-
-Implement the workflow described in the plan document, following Output SDK patterns and best practices.
-
-<pre_flight_check>
-  EXECUTE: @.outputai/instructions/meta/pre_flight.md
-</pre_flight_check>
-
-<process_flow>
-
-<step number="1" name="plan_analysis" subagent="workflow-context-fetcher">
-
-### Step 1: Plan Analysis
-
-Read and understand the plan document.
-
-1. Read the plan file from: `$1`
-2. Identify the workflow name, description, and purpose
-3. Extract input and output schema definitions
-4. List all required steps and their relationships
-5. Note any LLM-based steps that require prompt templates
-6. Understand error handling and retry requirements
-
-</step>
-
-<step number="2" name="workflow_implementation" subagent="workflow-quality">
-
-### Step 2: Workflow Implementation
-
-Update `$3/workflow.ts` with the workflow definition.
-
-<implementation_checklist>
-  - Import required dependencies (workflow, z from '@output.ai/core')
-  - Define inputSchema based on plan specifications
-  - Define outputSchema based on plan specifications
-  - Import step functions from steps.ts
-  - Implement workflow function with proper orchestration
-  - Handle conditional logic if specified in plan
-  - Add proper error handling
-</implementation_checklist>
-
-<workflow_template>
-```typescript
-import { workflow, z } from '@output.ai/core';
-import { stepName } from './steps.js';
-
-const inputSchema = z.object( {
-  // Define based on plan
-} );
-
-const outputSchema = z.object( {
-  // Define based on plan
-} );
-
-export default workflow( {
-  name: '$2',
-  description: 'Description from plan',
-  inputSchema,
-  outputSchema,
-  fn: async input => {
-    // Implement orchestration logic from plan
-    const result = await stepName( input );
-    return { result };
-  }
-} );
-```
-</workflow_template>
-
-</step>
-
-<step number="3" name="steps_implementation" subagent="workflow-quality">
-
-### Step 3: Steps Implementation
-
-Update `$3/steps.ts` with all step definitions from the plan.
-
-<implementation_checklist>
-  - Import required dependencies (step, z from '@output.ai/core')
-  - Implement each step with proper schema validation
-  - Add error handling and retry logic as specified
-  - Ensure step names match plan specifications
-  - Add descriptive comments for complex logic
-</implementation_checklist>
-
-<step_template>
-```typescript
-import { step, z } from '@output.ai/core';
-
-export const stepName = step( {
-  name: 'stepName',
-  description: 'Description from plan',
-  inputSchema: z.object( {
-    // Define based on plan
-  } ),
-  outputSchema: z.object( {
-    // Define based on plan
-  } ),
-  fn: async input => {
-    // Implement step logic from plan
-    return output;
-  }
-} );
-```
-</step_template>
-
-</step>
-
-<step number="4" name="prompt_templates" subagent="workflow-prompt-writer">
-
-### Step 4: Prompt Templates (if needed)
-
-If the plan includes LLM-based steps, create prompt templates in `$3/prompts/`.
-
-<decision_tree>
-  IF plan_includes_llm_steps:
-    CREATE prompt_templates
-    UPDATE steps.ts to use loadPrompt and generateText
-  ELSE:
-    SKIP to step 6
-</decision_tree>
-
-<llm_step_template>
-```typescript
-import { step, z } from '@output.ai/core';
-import { generateText } from '@output.ai/llm';
-
-export const llmStep = step( {
-  name: 'llmStep',
-  description: 'LLM-based step',
-  inputSchema: z.object( {
-    param: z.string()
-  } ),
-  outputSchema: z.string(),
-  fn: async ( { param } ) => {
-    const response = await generateText( {
-      prompt: 'prompt_name@v1',
-      variables: { param }
-    } );
-    return response;
-  }
-} );
-```
-</llm_step_template>
-
-<prompt_file_template>
-```
----
-provider: anthropic
-model: claude-sonnet-4-20250514
-temperature: 0.7
----
-
-<assistant>
-You are a helpful assistant.
-</assistant>
-
-<user>
-{{ instructions }}
-</user>
-```
-</prompt_file_template>
-
-</step>
-
-<step number="5" name="readme_update">
-
-### Step 5: README Update
-
-Update `$3/README.md` with workflow-specific documentation.
-
-<documentation_requirements>
-  - Update workflow name and description
-  - Document input schema with examples
-  - Document output schema with examples
-  - Explain each step's purpose
-  - Provide usage examples
-  - Document any prerequisites or setup requirements
-  - Include testing instructions
-</documentation_requirements>
-
-</step>
-
-<step number="6" name="scenario_creation">
-
-### Step 6: Scenario File Creation
-
-Create at least one scenario file in `$3/scenarios/` for testing the workflow.
-
-<scenario_requirements>
-  - Create `scenarios/` directory if it doesn't exist
-  - Create `test_input.json` with valid example input matching the inputSchema
-  - Input values should be realistic and demonstrate the workflow's purpose
-  - JSON must be valid and parseable
-</scenario_requirements>
-
-<scenario_template>
-```json
-{
-  // Populate with example values matching inputSchema
-  // Use realistic test data that demonstrates the workflow
-}
-```
-</scenario_template>
-
-<example>
-For a workflow with inputSchema:
-```typescript
-z.object({
-  topic: z.string(),
-  maxLength: z.number().optional()
-})
-```
-
-Create `scenarios/test_input.json`:
-```json
-{
-  "topic": "The history of artificial intelligence",
-  "maxLength": 500
-}
-```
-</example>
-
-</step>
-
-<step number="7" name="validation" subagent="workflow-quality">
-
-### Step 7: Implementation Validation
-
-Verify the implementation is complete and correct.
-
-<validation_checklist>
-  - All steps from plan are implemented
-  - Input/output schemas match plan specifications
-  - Workflow orchestration logic is correct
-  - Error handling is in place
-  - LLM prompts are created (if needed)
-  - README is updated with accurate information
-  - Code follows Output SDK patterns
-  - TypeScript types are properly defined
-  - Scenario file exists with valid example input
-</validation_checklist>
-
-</step>
-
-<step number="8" name="post_flight_check">
-
-### Step 8: Post-Flight Check
-
-Verify the implementation is ready for use.
-
-<post_flight_check>
-  EXECUTE: @.outputai/instructions/meta/post_flight.md
-</post_flight_check>
-
-</step>
-
-</process_flow>
-
-<post_flight_check>
-  EXECUTE: @.outputai/instructions/meta/post_flight.md
-</post_flight_check>
-
----- START ----
-
-Workflow Name: $2
-
-Workflow Directory: $3
-
-Plan File Path: $1
-
-Additional Instructions:
-
-$ARGUMENTS