@output.ai/cli 0.5.6 → 0.7.0

package/dist/templates/agent_instructions/skills/output-workflow-result/SKILL.md.template

@@ -1,199 +0,0 @@
----
-name: output-workflow-result
-description: Get the result of an Output SDK workflow execution. Use when retrieving the output of a completed workflow, getting the return value, or checking what a workflow produced after async execution.
-allowed-tools: [Bash]
----
-
-# Get Workflow Execution Result
-
-## Overview
-
-This skill retrieves the result (return value) of a completed workflow execution. Use it after a workflow started with `npx output workflow start` has completed, or to retrieve results from historical runs.
-
-## When to Use This Skill
-
-- Getting output from an asynchronously started workflow
-- Retrieving results from a completed workflow
-- Checking what a workflow produced
-- Processing workflow output in scripts
-- Comparing results between runs
-
-## Prerequisites
-
-- The workflow must have completed (status: COMPLETED)
-- You need the workflow ID
-- For FAILED workflows, use `npx output workflow debug` instead
-
-## Instructions
-
-### Get Result
-
-```bash
-npx output workflow result <workflowId>
-```
-
-The result is the return value of the workflow function, typically JSON.
-
-### Check Status First
-
-Before getting results, verify the workflow completed:
-
-```bash
-npx output workflow status <workflowId>
-# Should show: COMPLETED
-
-npx output workflow result <workflowId>
-```
-
-## Understanding Results
-
-### Success Results
-
-A successful workflow returns the value from its `fn` function:
-
-```typescript
-// Workflow code
-export default workflow({
-  fn: async (input) => {
-    return { processed: true, count: 42 };
-  }
-});
-```
-
-```bash
-# Result output
-npx output workflow result abc123
-# { "processed": true, "count": 42 }
-```
-
-### Error Results
-
-If you try to get the result of a failed workflow:
-- You'll get an error message
-- Use `npx output workflow debug` instead to see what went wrong
-
-### No Result (void workflows)
-
-Some workflows don't return a value:
-```bash
-npx output workflow result abc123
-# null
-```
-
-## Examples
-
-**Scenario**: Get result after async start
-
-```bash
-# Start workflow
-npx output workflow start calculate '{"values": [1, 2, 3]}'
-# Output: Workflow ID: calc-abc123
-
-# Wait for completion
-npx output workflow status calc-abc123
-# Status: COMPLETED
-
-# Get the result
-npx output workflow result calc-abc123
-# { "sum": 6, "average": 2 }
-```
-
-**Scenario**: Process result with jq
-
-```bash
-# Extract specific field
-npx output workflow result abc123 | jq '.total'
-
-# Format for display
-npx output workflow result abc123 | jq '.'
-
-# Save to file
-npx output workflow result abc123 > result.json
-```
-
-**Scenario**: Compare results between runs
-
-```bash
-# Get results from two runs
-npx output workflow result run-1-abc > result1.json
-npx output workflow result run-2-xyz > result2.json
-
-# Compare
-diff result1.json result2.json
-```
-
-**Scenario**: Use in a script
-
-```bash
-WORKFLOW_ID="abc123"
-
-# Wait for completion
-while [[ $(npx output workflow status $WORKFLOW_ID) == *"RUNNING"* ]]; do
-  sleep 5
-done
-
-# Check if completed successfully
-if [[ $(npx output workflow status $WORKFLOW_ID) == *"COMPLETED"* ]]; then
-  RESULT=$(npx output workflow result $WORKFLOW_ID)
-  echo "Workflow result: $RESULT"
-else
-  echo "Workflow did not complete successfully"
-  npx output workflow debug $WORKFLOW_ID
-fi
-```
-
-## Handling Different Result Types
-
-### JSON Objects
-```bash
-npx output workflow result abc123
-# { "key": "value", "nested": { "data": true } }
-```
-
-### Arrays
-```bash
-npx output workflow result abc123
-# [1, 2, 3, 4, 5]
-```
-
-### Primitive Values
-```bash
-npx output workflow result abc123
-# 42
-
-npx output workflow result abc123
-# "success"
-
-npx output workflow result abc123
-# true
-```
-
-### Large Results
-
-For large results, redirect to a file:
-```bash
-npx output workflow result abc123 > large-result.json
-```
-
-## Error Handling
-
-### "Workflow not found"
-- Check the workflow ID is correct
-- Use `npx output workflow runs list` to find valid IDs
-
-### "Workflow not completed"
-- Check status: `npx output workflow status <id>`
-- Wait for COMPLETED status before getting result
-- If RUNNING, wait and try again
-- If FAILED, use `npx output workflow debug`
-
-### "No result available"
-- The workflow may return void/undefined
-- Check the workflow code to see what it returns
-
-## Related Commands
-
-- `npx output workflow status <id>` - Check if workflow completed
-- `npx output workflow debug <id>` - Debug failed workflows
-- `npx output workflow run <name>` - Run and get result in one step
-- `npx output workflow runs list` - Find workflow IDs

package/dist/templates/agent_instructions/skills/output-workflow-run/SKILL.md.template

@@ -1,228 +0,0 @@
----
-name: output-workflow-run
-description: Execute an Output SDK workflow synchronously and wait for the result. Use when running a workflow and needing immediate results, testing workflow execution, or getting the output directly in the terminal.
-allowed-tools: [Bash, Read, Write]
----
-
-# Run Workflow Synchronously
-
-## Overview
-
-This skill executes a workflow synchronously, meaning the command waits for the workflow to complete and returns the result directly. This is ideal for testing, quick executions, and when you need immediate feedback.
-
-## When to Use This Skill
-
-- Testing a workflow during development
-- Running a workflow and needing the result immediately
-- Quick one-off workflow executions
-- Debugging by re-running a workflow with different inputs
-- When you don't need to monitor the workflow separately
-
-## When to Use Async Instead
-
-Consider using `npx output workflow start` (async) when:
-- The workflow takes a long time (minutes to hours)
-- You need to run multiple workflows in parallel
-- You want to disconnect and check results later
-- You need to monitor progress separately
-
-## Instructions
-
-### Basic Syntax
-
-```bash
-npx output workflow run <workflowName> --input '<json-input>'
-npx output workflow run <workflowName> --input <path-to-json-file>
-```
-
-The `--input` flag is required when the workflow expects input data.
-
-### Input Methods
-
-#### 1. Inline JSON
-
-Pass JSON directly on the command line:
-
-```bash
-npx output workflow run example --input '{"question": "who really is ada lovelace?"}'
-```
-
-#### 2. File Path (Recommended)
-
-Reference a JSON file containing the input:
-
-```bash
-npx output workflow run simple --input src/simple/scenarios/question_ada_lovelace.json
-```
-
-This is the recommended approach because:
-- Input is version controlled and reproducible
-- Complex inputs are easier to read and edit
-- Scenarios can be shared and reused
-
-### Scenario Folder Pattern (Best Practice)
-
-Workflows typically have a `scenarios/` folder containing test inputs:
-
-```
-src/
-  my_workflow/
-    workflow.ts
-    steps.ts
-    scenarios/
-      basic_test.json
-      edge_case_empty.json
-      large_payload.json
-```
-
-**Best practice workflow:**
-
-1. Create a scenario file with your input:
-   ```bash
-   # Create scenarios folder if it doesn't exist
-   mkdir -p src/my_workflow/scenarios
-   ```
-
-2. Write your input to a scenario file:
-   ```json
-   // src/my_workflow/scenarios/test_user.json
-   {
-     "userId": "123",
-     "options": {
-       "verbose": true
-     }
-   }
-   ```
-
-3. Run the workflow referencing the scenario:
-   ```bash
-   npx output workflow run my_workflow --input src/my_workflow/scenarios/test_user.json
-   ```
-
-### Input Examples
-
-```bash
-# Inline JSON - simple object
-npx output workflow run my-workflow --input '{"userId": "123"}'
-
-# Inline JSON - complex nested input
-npx output workflow run data-pipeline --input '{"source": "api", "options": {"limit": 100}}'
-
-# File path - reference a scenario file
-npx output workflow run simple --input src/simple/scenarios/basic.json
-
-# File path - relative to current directory
-npx output workflow run batch-processor --input ./test_inputs/batch1.json
-
-# No input (only if workflow doesn't require it)
-npx output workflow run health-check
-```
-
-## Understanding the Output
-
-The command returns the workflow result directly to stdout.
-
-### Success Output
-The workflow's return value is displayed, typically as JSON.
-
-### Error Output
-If the workflow fails, you'll see:
-- Error message
-- The workflow ID (for further debugging)
-- Suggestion to use `npx output workflow debug` for details
-
-## Examples
-
-**Scenario**: Test a workflow with a scenario file
-
-```bash
-# First, look for existing scenarios
-ls src/simple/scenarios/
-
-# Run using a scenario file
-npx output workflow run simple --input src/simple/scenarios/basic_sum.json
-
-# Output:
-# { "sum": 6, "count": 3 }
-```
-
-**Scenario**: Create and run a new test scenario
-
-```bash
-# Create a scenario file
-cat > src/my_workflow/scenarios/test_case_1.json << 'EOF'
-{
-  "question": "What is the capital of France?",
-  "context": "geography"
-}
-EOF
-
-# Run the workflow
-npx output workflow run my_workflow --input src/my_workflow/scenarios/test_case_1.json
-```
-
-**Scenario**: Quick inline test during development
-
-```bash
-npx output workflow run example --input '{"question": "explain quantum computing"}'
-```
-
-**Scenario**: Re-run a workflow with different input for debugging
-
-```bash
-# First attempt with scenario file
-npx output workflow run process-data --input src/process_data/scenarios/user_abc.json
-# Error occurs
-
-# Create a new scenario to isolate the issue
-cat > src/process_data/scenarios/debug_minimal.json << 'EOF'
-{"id": "test", "debug": true}
-EOF
-
-npx output workflow run process-data --input src/process_data/scenarios/debug_minimal.json
-```
-
-**Scenario**: Capture output for further processing
-
-```bash
-# Save result to a file
-npx output workflow run generate-report --input src/generate_report/scenarios/jan_2024.json > report.json
-
-# Pipe to jq for processing
-npx output workflow run get-users --input src/get_users/scenarios/active.json | jq '.users[].name'
-```
-
-## Error Handling
-
-### Common Errors
-
-| Error | Cause | Solution |
-|-------|-------|----------|
-| "Workflow not found" | Workflow name is incorrect | Check with `npx output workflow list` |
-| "Invalid input" | JSON doesn't match schema | Verify input matches workflow's inputSchema |
-| "Parse error" | Malformed JSON or file not found | Check JSON syntax or file path |
-| "Timeout" | Workflow took too long | Use async execution for long workflows |
-
-### Getting More Details on Failures
-
-When a workflow fails, the output includes the workflow ID. Use it to get the full trace:
-
-```bash
-npx output workflow run my-workflow --input src/my_workflow/scenarios/test.json
-# Output: Workflow failed. ID: abc123xyz
-
-npx output workflow debug abc123xyz --format json
-```
-
-## Input Schema Tips
-
-1. **Check the schema first**: Look at the workflow's `inputSchema` in the code
-2. **Use scenario files**: Create reusable test inputs in the workflow's `scenarios/` folder
-3. **Use proper types**: Strings in quotes, numbers without quotes, booleans as true/false
-4. **Include required fields**: All non-optional schema fields must be provided
-
-## Related Commands
-
-- `npx output workflow start <name> --input` - Start asynchronously
-- `npx output workflow list` - See available workflows
-- `npx output workflow debug <id>` - Debug a failed run

package/dist/templates/agent_instructions/skills/output-workflow-runs-list/SKILL.md.template

@@ -1,141 +0,0 @@
----
-name: output-workflow-runs-list
-description: List Output SDK workflow execution history. Use when finding failed runs, reviewing past executions, identifying workflow IDs for debugging, filtering runs by workflow type, or investigating recent workflow activity.
-allowed-tools: [Bash]
----
-
-# List Workflow Execution History
-
-## Overview
-
-This skill helps you view the execution history of workflows. Use it to find failed runs, identify workflow IDs for debugging, and review past executions.
-
-## When to Use This Skill
-
-- Finding recent failed workflow runs
-- Getting a workflow ID for debugging
-- Reviewing execution history for a specific workflow
-- Investigating when a problem started occurring
-- Checking the status of recent executions
-
-## Instructions
-
-### List All Recent Runs
-
-```bash
-npx output workflow runs list
-```
-
-By default, this shows the 100 most recent workflow executions across all workflow types.
-
-### Available Flags
-
-| Flag | Description | Default |
-|------|-------------|---------|
-| `--limit <n>` | Number of runs to display | 100 |
-| `--format <type>` | Output format: table, json, text | table |
-
-### Filter by Workflow Name
-
-```bash
-npx output workflow runs list <workflowName>
-```
-
-This shows only runs for the specified workflow type.
-
-### Get Detailed JSON Output
-
-```bash
-npx output workflow runs list --format json
-```
-
-Use JSON format for programmatic analysis or when you need full details.
-
-## Understanding the Output
-
-### Status Values
-
-| Status | Meaning | Action |
-|--------|---------|--------|
-| RUNNING | Workflow is currently executing | Wait or monitor |
-| COMPLETED | Workflow finished successfully | No action needed |
-| FAILED | Workflow encountered an error | Debug with trace |
-| TERMINATED | Workflow was manually stopped | Review if expected |
-| TIMED_OUT | Workflow exceeded time limit | Check for long operations |
-
-### Key Fields
-
-When viewing runs, pay attention to:
-
-- **Workflow ID**: Unique identifier needed for debugging commands
-- **Status**: Current execution state
-- **Start Time**: When the execution began
-- **End Time**: When the execution completed (if finished)
-- **Workflow Name**: The type of workflow that ran
-
-## Examples
-
-**Scenario**: Find failed workflow runs
-
-```bash
-# List recent runs and look for FAILED status
-npx output workflow runs list --limit 20
-
-# Or use JSON format with jq to filter
-npx output workflow runs list --format json | jq '.[] | select(.status == "FAILED")'
-```
-
-**Scenario**: Get workflow ID for debugging
-
-```bash
-# List runs for a specific workflow
-npx output workflow runs list my-workflow --limit 5
-
-# Note the workflow ID from the output (e.g., "abc123xyz")
-# Then debug it
-npx output workflow debug abc123xyz --format json
-```
-
-**Scenario**: Review recent activity for a specific workflow
-
-```bash
-# See the last 10 runs of the data-pipeline workflow
-npx output workflow runs list data-pipeline --limit 10
-```
-
-**Scenario**: Export run history for analysis
-
-```bash
-# Get all recent runs as JSON for external analysis
-npx output workflow runs list --format json > workflow-runs.json
-```
-
-**Scenario**: Find when failures started
-
-```bash
-# Look at more history to find patterns
-npx output workflow runs list --limit 50 --format json | jq 'group_by(.status) | map({status: .[0].status, count: length})'
-```
-
-## Identifying Problems
-
-### Signs of Issues
-
-1. **Multiple FAILED runs**: Indicates a persistent bug
-2. **Mix of COMPLETED and FAILED**: Could be input-dependent issues
-3. **All recent runs TERMINATED**: Someone may be stopping workflows
-4. **Long RUNNING times**: Possible hang or performance issue
-
-### Next Steps After Finding a Failed Run
-
-1. Copy the workflow ID from the run
-2. Get the execution trace: `npx output workflow debug <workflowId> --format json`
-3. Analyze the trace to identify the failure
-4. Apply the appropriate fix based on the error pattern
-
-## Related Commands
-
-- `npx output workflow debug <id>` - Analyze execution trace
-- `npx output workflow status <id>` - Check current status
-- `npx output workflow result <id>` - Get execution result
-- `npx output workflow list` - List available workflows