@output.ai/cli 0.0.3 → 0.0.5

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

@@ -1,466 +1,260 @@
 ---
+argument-hint: [workflow-description-and-additional-instructions]
 description: Workflow Planning Command for Output SDK
-version: 2.0
-encoding: UTF-8
+version: 0.0.1
+model: claude-opus-4-1
 ---
 
-# Plan Workflow Command
+Your task is to generate a comprehensive Output.ai workflow implementation plan in markdown format.
+
+The plan will be displayed to the user who can then decide what to do with it.
+
+Please respond with only the final version of the plan.
+
+Use the todo tool to track your progress through the plan creation process.
+
+# Plan Creation Rules
 
 ## Overview
 
-Generate comprehensive workflow implementation plans following Output SDK patterns and best practices.
+Generate detailed specifications for implementation of a new workflow.
 
 <pre_flight_check>
-  EXECUTE: @{{projectPath}}/.outputai/instructions/meta/pre_flight.md
+  EXECUTE: @.outputai/instructions/meta/pre_flight.md
 </pre_flight_check>
 
 <process_flow>
 
-<step number="1" subagent="workflow_planner" name="requirements_analysis">
-
-### Step 1: Requirements Analysis
-
-Use the workflow_planner subagent to analyze the workflow requirements and infer smart defaults.
-
-<smart_inference>
-  <approach>Infer requirements from description and apply defaults</approach>
-  <defaults>
-    - retry_policy: 3 attempts with exponential backoff
-    - timeout: 30s for activities, 5m for workflows
-    - openai_model: gpt-4o unless specified
-    - error_handling: ApplicationFailure patterns
-    - performance: clarity over speed optimization
-  </defaults>
-</smart_inference>
-
-<critical_questions>
-  ASK ONLY if cannot be inferred:
-  - Ambiguous input/output structures
-  - Non-standard API integrations
-  - Complex orchestration patterns
-  - Unusual error handling requirements
-</critical_questions>
-
-<requirements_template>
-  ## Requirements Analysis
-
-  **Goal**: {{workflowGoal}}
-  **Input**: {{inputDescription}}
-  **Output**: {{outputDescription}}
-  **External Services**: {{servicesList}}
-  **Constraints**: {{constraintsList}}
-</requirements_template>
+<step number="1" name="context_gathering">
+
+### Step 1: Context Gathering
+
+Take the time to gather all the context you need to create a comprehensive plan.
+1. Read any given files or links
+2. Find any related workflows in the project
+3. Read the projects documentation files
 
 </step>
 
-<step number="2" name="pattern_analysis">
+<step number="2" name="requirements_clarification">
 
-### Step 2: Pattern Analysis
+### Step 2: Requirements Clarification
 
-<analysis_targets>
-  - Check the repository for similar implementations
-  - Identify reusable activities
-  - Find applicable prompt templates in workflow directories
-  - Locate relevant schemas and types
-</analysis_targets>
+Clarify scope boundaries and technical considerations by asking numbered questions as needed to ensure clear requirements before proceeding.
 
-<pattern_collection>
-  <existing_workflows>workflows with similar purpose or structure</existing_workflows>
-  <reusable_activities>activities that can be leveraged</reusable_activities>
-  <error_patterns>established error handling patterns</error_patterns>
-  <retry_policies>common retry configurations</retry_policies>
-</pattern_collection>
+<clarification_areas>
+  <scope>
+    - in_scope: what is included
+    - out_of_scope: what is excluded (optional)
+  </scope>
+  <technical>
+    - functionality specifics
+    - UI/UX requirements
+    - integration points
+  </technical>
+</clarification_areas>
 
+<decision_tree>
+  IF clarification_needed:
+    ASK numbered_questions
+    WAIT for_user_response
+  ELSE:
+    PROCEED schema_definition
+</decision_tree>
 </step>
 
-<step number="3" subagent="workflow_planner" name="schema_definition">
+<step number="3" name="workflow_design">
 
-### Step 3: Schema Definition
+### Step 3: Workflow Design
 
-Use the workflow_planner subagent to define input/output schemas with Zod validation.
+Design the workflow with clear single purpose steps and sound orchestration logic.
 
-<schema_requirements>
-  - Use simple TypeScript interfaces for basic types
-  - Use Zod schemas when validation is needed
-  - Keep field types simple: string, number, boolean, object
-  - Mark optional fields with ? in interfaces or .optional() in Zod
-  - Export types for reuse across workflow files
-</schema_requirements>
+<thought_process>
 
-<input_schema_template>
-  ```typescript
-  // For simple types (types.ts)
-  export interface {{WorkflowName}}Input {
-    {{requiredField}}: string;
-    {{optionalField}}?: string;
-  }
+  1. Define the workflow name and description
+  2. What is a valid output schema for the workflow?
+  3. What is a valid input schema for the workflow?
+  4. What needs to happen to transform the input into the output?
+  5. What are the atomic steps that need to happen to transform the input into the output?
+  6. How do these steps relate to each other?
+  7. Are any of these steps conditional?
+  8. Are any of these steps already defined in the project?
+  9. How could these steps fail, and how should we handle them? (retry, backoff, etc.)
 
-  // Or for validation with Zod
-  import { z } from 'zod';
+</thought_process>
 
-  export const {{WorkflowName}}InputSchema = z.object({
-    {{requiredField}}: z.string(),
-    {{optionalField}}: z.string().optional()
-  });
+<workflow_template>
+```typescript
+import { workflow, z } from 'output.ai/core';
+import { sumValues } from './steps.js';
 
-  export type {{WorkflowName}}Input = z.infer<typeof {{WorkflowName}}InputSchema>;
-  ```
-</input_schema_template>
+const inputSchema = z.object( {
+  values: z.array( z.number() )
+} );
 
-<output_schema_template>
-  ```typescript
-  export interface {{WorkflowName}}Output {
-    result: string;
-    // Additional fields as needed
-    {{additionalFields}}
+const outputSchema = z.object( {
+  result: z.number()
+} );
+
+export default workflow( {
+  name: 'simple',
+  description: 'A simple workflow',
+  inputSchema,
+  outputSchema,
+  fn: async input => {
+    const result = await sumValues( input.values );
+    return { result };
   }
-  ```
-</output_schema_template>
+} );
+```
+</workflow_template>
 
-</step>
+<step number="4" name="step_design">
+### Step 4: Step Design
 
-<step number="4" subagent="workflow_planner" name="activity_design">
-
-### Step 4: Activity Design
-
-Use the workflow_planner subagent to design workflow activities with clear boundaries.
-
-<activity_template>
-  ### Step: `{{stepName}}`
-
-  **Purpose**: {{stepPurpose}}
-
-  **Implementation (steps.ts)**:
-  ```typescript
-  import { step } from '@output.ai/core';
-  import { generateText, generateObject } from '@output.ai/llm';
-  import { loadPrompt } from '@output.ai/prompt';
-  import type { Prompt } from '@output.ai/llm';
-
-  export const {{stepName}} = step({
-    name: '{{stepName}}',
-    description: '{{stepDescription}}',
-    inputSchema: {
-      type: 'object',
-      required: [{{requiredFields}}],
-      properties: {
-        {{fieldName}}: { type: '{{fieldType}}' }
-        // Add more fields as needed
-      }
-    },
-    outputSchema: {
-      type: '{{outputType}}'
-    },
-    fn: async (input) => {
-      // Implementation logic
-      {{implementationLogic}}
-
-      // For LLM operations:
-      // const prompt = loadPrompt('{{promptName}}', input);
-      // const response = await generateText(prompt as Prompt);
-
-      return {{returnValue}};
-    }
-  });
-  ```
-
-  **Error Handling**:
-  - Use `FatalError` from '@output.ai/core' for non-retryable errors
-  - Standard errors will be retried based on workflow configuration
-</activity_template>
+Design the steps with clear boundaries.
 
-<decision_tree>
-  IF step_uses_llm:
-    USE generateText or generateObject from @output.ai/llm
-    LOAD prompts with loadPrompt from @output.ai/prompt
-    DEFINE error handling with FatalError
-  ELSE IF step_uses_external_service:
-    IMPORT required service libraries
-    HANDLE errors appropriately
-  ELSE:
-    IMPLEMENT pure logic
-    VALIDATE inputs/outputs
-</decision_tree>
+<step_template>
+```typescript
+import { step, z } from 'output.ai/core';
+
+export const sumValues = step( {
+  name: 'sumValues',
+  description: 'Sum all values',
+  inputSchema: z.array( z.number() ),
+  outputSchema: z.number(),
+  fn: async numbers => numbers.reduce( ( v, n ) => v + n, 0 )
+} );
+```
+</step_template>
 
 </step>
 
-<step number="5" subagent="workflow_planner" name="prompt_engineering">
+<step number="5" name="prompt_engineering">
 
-### Step 5: Prompt Engineering (Conditional)
+### Step 5: Prompt Engineering
 
-Use the workflow_planner subagent to design LLM prompts if the workflow uses AI services.
+If any of the steps use an LLM, design the prompts for the steps.
 
 <decision_tree>
-  IF workflow_uses_llm:
-    EXECUTE prompt_design
+  IF step_uses_llm:
+    USE prompt_step_template
   ELSE:
     SKIP to step 6
 </decision_tree>
 
-<prompt_template>
-  **Prompt File ({{promptName}}@v1.prompt)**:
-  ```yaml
-  ---
-  provider: {{provider}}  # anthropic, openai, etc.
-  model: {{model}}  # e.g., claude-sonnet-4-20250514, gpt-4o
-  temperature: {{temperature}}  # e.g., 0.7
-  ---
-
-  <assistant>
-  {{systemPrompt}}
-  </assistant>
-
-  <user>
-  {{userPrompt}}
-
-  Variables to include:
-  {{ "{{ " }}{{variableName}}{{ " }}" }}
-  </user>
-  ```
-</prompt_template>
-
-<template_variables>
-  **Template Variables**:
-  - `{{ "{{ " }}{{variableName1}}{{ " }}" }}` - {{description1}}
-  - `{{ "{{ " }}{{variableName2}}{{ " }}" }}` - {{description2}}
-
-  **Loading in Step**:
-  ```typescript
-  const prompt = loadPrompt('{{promptName}}@v1', {
-    {{variableName1}}: input.{{field1}},
-    {{variableName2}}: input.{{field2}}
-  });
-  ```
-</template_variables>
-
-</step>
-
-<step number="6" subagent="workflow_planner" name="orchestration_planning">
-
-### Step 6: Workflow Orchestration
-
-Use the workflow_planner subagent to define the workflow execution logic.
-
-<orchestration_template>
-  ## Workflow Logic
-
-  1. **Input Validation**: `validateWorkflowInput(rawInput, {{WorkflowName}}InputSchema)`
-  2. **{{Step2Name}}**: {{step2Description}}
-  3. **{{Step3Name}}**: Call `{{activityName}}({{parameters}})`
-  4. **{{Step4Name}}**: {{step4Description}}
-  5. **Result Assembly**: Structure final output with metadata
-  6. **Return**: Complete {{WorkflowName}}Output object
-
-  **Conditional Logic**:
-  {{conditionalRules}}
-</orchestration_template>
-
-<workflow_code_template>
-  **Workflow File (workflow.ts)**:
-  ```typescript
-  import { workflow } from '@output.ai/core';
-  import { {{stepImports}} } from './steps.js';
-  import type { {{WorkflowName}}Input, {{WorkflowName}}Output } from './types.js';
-
-  export default workflow({
-    name: '{{workflowName}}',
-    description: '{{workflowDescription}}',
-    inputSchema: {
-      type: 'object',
-      required: [{{requiredFields}}],
-      properties: {
-        {{fieldName}}: { type: '{{fieldType}}' }
-        // Define all input fields
-      }
-    },
-    outputSchema: {
-      type: 'object',
-      required: [{{outputRequiredFields}}],
-      properties: {
-        result: { type: 'string' }
-        // Define output structure
-      }
-    },
-    fn: async (input: {{WorkflowName}}Input): Promise<{{WorkflowName}}Output> => {
-      // Workflow orchestration logic
-      {{orchestrationSteps}}
-
-      // Example step invocation:
-      // const result = await {{stepName}}({ {{stepParams}} });
-
-      return {
-        result: {{resultValue}}
-      };
-    }
-  });
-  ```
-</workflow_code_template>
-
-</step>
-
-<step number="7" name="plan_document_creation">
-
-### Step 7: Create Plan Document
-
-<plan_structure>
-  # Workflow Plan: {{WorkflowName}}
+<prompt_step_template>
+```typescript
+import { step, z } from 'output.ai/core';
+import { loadPrompt } from 'output.ai/prompt';
+import { generateText } from 'output.ai/llm';
+
+export const aiSdkPrompt = step( {
+  name: 'aiSdkPrompt',
+  description: 'Generates a prompt',
+  inputSchema: z.object( {
+    topic: z.string()
+  } ),
+  outputSchema: z.string(),
+  fn: async ( { topic } ) => {
+    const prompt = loadPrompt( 'prompt@v1', { topic } );
+    const response = await generateText( { prompt } );
+    return response;
+  }
+} );
 
-  ## Overview
-  - **Purpose**: {{purpose}}
-  - **Use Case**: {{useCase}}
-  - **Key Features**: {{features}}
+export const finalStep = step( {
+  name: 'finalStep',
+  outputSchema: z.boolean(),
+  fn: async () => true
+} );
 
-  ## Technical Specifications
-  {{schemaDefinitions}}
+```
+</prompt_step_template>
 
-  ## Activity Specifications
-  {{activityDefinitions}}
+<prompt_template>
+```
+---
+provider: anthropic
+model: claude-sonnet-4-20250514
+temperature: 0.7
+---
 
-  ## Prompt Specifications (if applicable)
-  {{promptDefinitions}}
+<assistant>
+You are a concise assistant.
+</assistant>
 
-  ## Workflow Orchestration
-  {{orchestrationLogic}}
+<user>
+Explain about "{{ topic }}"
+</user>
 
-  ## Implementation Checklist
-  - [ ] Create workflow directory structure
-  - [ ] Implement input/output schemas
-  - [ ] Create activity functions
-  - [ ] Design prompt templates (if needed)
-  - [ ] Implement workflow logic
-  - [ ] Add to entrypoint.ts
-  - [ ] Write unit tests
-  - [ ] Test with flow-cli
-  - [ ] Run integration tests
-  - [ ] Update documentation
-</plan_structure>
+```
 
-<file_location>
-  workflow_plans/{{workflowName}}-plan.md
-</file_location>
+</prompt_template>
 
 </step>
 
-<step number="8" subagent="workflow_planner" name="testing_strategy">
-
-### Step 8: Define Testing Strategy
-
-Use the workflow_planner subagent to create comprehensive testing requirements.
-
-<test_scenarios>
-  ## Testing Plan
+<step number="6" name="testing_strategy">
 
-  ### Happy Path Tests
-  1. **Complete Input**: All fields provided, successful execution
-  2. **Minimal Input**: Required fields only
-  3. **Variations**: Different input combinations
+### Step 6: Testing Strategy
 
-  ### Edge Cases
-  1. **Boundary Values**: Min/max values, empty strings
-  2. **Special Characters**: Unicode, punctuation
-  3. **Optional Fields**: With/without optional data
+Design the testing strategy for the workflow.
+<thought_process>
+  1. What unit tests do we need to write?
+  2. How can I run the workflow?
+  3. What cases do we need to validate?
+</thought_process>
 
-  ### Error Scenarios
-  1. **Invalid Input**: Malformed data, wrong types
-  2. **Service Failures**: API errors, timeouts
-  3. **Schema Violations**: Invalid responses
-
-  ### Performance Tests
-  1. **Response Time**: Must complete within {{timeout}}
-  2. **Concurrent Execution**: Multiple workflow instances
-  3. **Resource Usage**: Monitor memory and CPU
-</test_scenarios>
+</step>
 
-<test_commands>
-  ```bash
-  # Build the workflow
-  npm run build
+<step number="7" name="generate_plan">
+### Step 7: Generate Plan
 
-  # Start the worker (in one terminal)
-  npm run start  # or flow-worker
+Generate the complete plan in markdown format.
 
-  # Execute workflow (in another terminal or via API)
-  # Via API endpoint if configured
-  curl -X POST http://localhost:3000/workflows/{{workflowName}} \
-    -H "Content-Type: application/json" \
-    -d '{{testPayload}}'
+Note that every implementation should start with running the cli command `output workflow generate --skeleton` to create the workflow directory structure.
 
-  # Run validation
-  ./run.sh validate
+<file_template>
+  <header>
+    # Workflow Requirements Document
 
-  # Development mode with Docker
-  ./run.sh dev
-  ```
-</test_commands>
+    > Workflow: [WORKFLOW_NAME]
+    > Created: [CURRENT_DATE]
+  </header>
+  <required_sections>
+    - Overview
+    - Spec Scope
+    - Out of Scope
+    - Workflow Design
+    - Step Design
+    - Testing Strategy
+    - Implementation Phases
+  </required_sections>
+</file_template>
 
 </step>
 
-<step number="9" name="review_checkpoint">
-
-### Step 9: Review and Approval
-
-Request user review of the workflow plan before proceeding to implementation.
+<step_number="8" name="post_flight_check">
 
-<review_template>
-  I've completed the workflow plan for {{workflowName}}:
 
-  📋 **Plan Document**: `workflow_plans/{{workflowName}}-plan.md`
+### Step 8: Post-Flight Check
 
-  The plan includes:
-  - Complete input/output schemas with Zod validation
-  - {{activityCount}} activity specifications with error handling
-  - Workflow orchestration logic
-  - Comprehensive testing strategy
-  - Implementation checklist
+Verify the plan is complete and ready for implementation.
 
-  Please review the plan and let me know if any modifications are needed.
-</review_template>
+<post_flight_check>
+  EXECUTE: @.outputai/instructions/meta/post_flight.md
+</post_flight_check>
 
 </step>
 
 </process_flow>
 
 <post_flight_check>
-  EXECUTE: @{{projectPath}}/.outputai/instructions/meta/post_flight.md
+  EXECUTE: @.outputai/instructions/meta/post_flight.md
 </post_flight_check>
 
-## Command Usage
-
-### Basic Planning
-```
-/plan-workflow "Process customer support tickets using AI categorization"
-```
+---- START ----
 
-### With Complexity Hints
-```
-/plan-workflow "Multi-step data pipeline with validation" --complexity=complex --integrations=apis,llm
-```
-
-### Integration-Heavy Workflow
-```
-/plan-workflow "E-commerce order fulfillment" --integrations=payment,inventory,shipping
-```
+Workflow Description and Additional Instructions:
 
-## Quality Standards
-
-### Plan Completeness
-- All schemas defined with exact types
-- Every activity specified with I/O and processing logic
-- External services identified with SDK references
-- Error handling complete for all scenarios
-- Testing scenarios documented with commands
-
-### Output SDK Compliance
-- ES module imports with .js extensions
-- Use @output.ai/core for workflow and step functions
-- Use @output.ai/llm for AI operations
-- Use @output.ai/prompt for prompt loading
-- Use FatalError from @output.ai/core for non-retryable errors
-- Follow established workflow file structure (workflow.ts, steps.ts, types.ts, *.prompt)
-
-### Implementation Readiness
-- Developer can implement without clarification
-- All code examples compile without modification
-- Testing approach is comprehensive
-- Performance requirements are measurable
-- Documentation is clear and actionable
+$ARGUMENTS

package/dist/test_helpers/mocks.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Mock for @anthropic-ai/claude-agent-sdk
+ */
+export declare const mockClaudeAgentSDK: {
+    Agent: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock for @output.ai/llm
+ */
+export declare const mockLLM: {
+    generateText: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock for child_process spawn (for agents init)
+ */
+export declare const mockSpawn: import("vitest").Mock<(...args: any[]) => any>;
+/**
+ * Mock for fs/promises
+ */
+export declare const mockFS: {
+    access: import("vitest").Mock<(...args: any[]) => any>;
+    mkdir: import("vitest").Mock<(...args: any[]) => any>;
+    writeFile: import("vitest").Mock<(...args: any[]) => any>;
+    readFile: import("vitest").Mock<(...args: any[]) => any>;
+    stat: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Mock for @inquirer/prompts
+ */
+export declare const mockInquirer: {
+    input: import("vitest").Mock<(...args: any[]) => any>;
+    confirm: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Reset all mocks
+ */
+export declare function resetAllMocks(): void;