workflow-composer skill

---
name: workflow-composer
description: >
  Chain Vibery commands, skills, and agents into repeatable automated workflows.
  Outputs: Executable workflow files, hook configurations, CI/CD integration.
  Use when user has repetitive multi-step processes to automate.
  Triggers: create workflow, automate this process, chain these commands, /workflow
---

# Workflow Composer

Transform repetitive multi-step processes into one-command automations.

## Purpose

Users manually run the same sequence of commands repeatedly. This skill captures those patterns and outputs executable workflows using Vibery hooks, custom commands, or CI/CD configurations.

## Available Workflow Types

```
1. Hooks (event-triggered):
   - PostToolUse: After Claude edits files
   - PreToolUse: Before Claude runs commands
   - Stop: When conversation ends

2. Custom Commands (.claude/commands/*.md):
   - User-triggered via /command-name
   - Can include $ARGUMENTS

3. GitHub Actions (.github/workflows/*.yml):
   - Triggered by git events
   - Full CI/CD capabilities

4. Shell Scripts:
   - Direct automation
   - Can combine multiple tools
```

---

## Process

### Phase 1: Workflow Discovery

#### Entry Check
```
IF user described: repetitive process + trigger condition
    → Proceed to Phase 2
ELSE
    → Discover workflow first
```

#### Discovery Questions
| Question | Purpose |
|----------|---------|
| "Walk me through what you do repeatedly" | Capture full sequence |
| "What triggers this process?" | Determines workflow type |
| "Any variations or conditions?" | Identifies branching logic |
| "How often do you do this?" | Prioritizes automation value |

#### Workflow Trigger → Type Mapping
```
IF trigger = "after I edit code"
    → Hook (PostToolUse)

IF trigger = "before running a command"
    → Hook (PreToolUse)

IF trigger = "when I finish a session"
    → Hook (Stop)

IF trigger = "when I type a command"
    → Custom Command

IF trigger = "on git push/PR"
    → GitHub Action

IF trigger = "manually, but want one command"
    → Shell Script or Custom Command
```

---

### Phase 2: Workflow Analysis

#### Entry Check
```
IF workflow discovered:
    → Analyze and structure
ELSE
    → Return to Phase 1
```

#### Step Extraction
```
FOR each step in user's process:
    Identify:
    - Action: What happens
    - Tool: Which Vibery component
    - Input: What it needs
    - Output: What it produces
    - Condition: When to skip/branch
```

#### Workflow Structure
```markdown
## Workflow: [Name]

### Trigger
[When this runs]

### Steps
| # | Action | Tool | Condition |
|---|--------|------|-----------|
| 1 | [action] | [vibery component] | [if any] |
| 2 | [action] | [vibery component] | [if any] |

### Variables
- [var1]: [source]
- [var2]: [source]

### Error Handling
- If [step] fails: [action]
```

---

### Phase 3: Workflow Generation

#### Entry Check
```
IF workflow analyzed:
    → Generate appropriate format
ELSE
    → Return to Phase 2
```

#### Hook Generation
```yaml
# hooks/[workflow-name].yaml
name: [workflow-name]
description: [what it does]

triggers:
  - type: PostToolUse    # or PreToolUse, Stop
    tools: [Write, Edit]  # which tools trigger

actions:
  - name: [step-1-name]
    command: [command to run]
    condition: [optional condition]

  - name: [step-2-name]
    command: [command to run]
```

**Install command:**
```bash
npx vibery install hook:[workflow-name]
# Or copy to .claude/hooks/
```

#### Custom Command Generation
```markdown
# .claude/commands/[workflow-name].md

[Description of what this workflow does]

## Steps

1. First, I'll [action 1]
2. Then, [action 2]
3. Finally, [action 3]

## Input
$ARGUMENTS

## Execution

[Detailed instructions for Claude to follow]

### Step 1: [Name]
[Instructions]

### Step 2: [Name]
[Instructions]

### Confirmation
Before completing, verify:
- [ ] [check 1]
- [ ] [check 2]
```

#### GitHub Action Generation
```yaml
# .github/workflows/[workflow-name].yml
name: [Workflow Name]

on:
  [trigger]:
    [conditions]

jobs:
  [job-name]:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: [Step 1]
        run: [command]

      - name: [Step 2]
        run: [command]
```

#### Shell Script Generation
```bash
#!/bin/bash
# [workflow-name].sh
# [Description]

set -e  # Exit on error

# Step 1: [Name]
echo "→ [Description]"
[command]

# Step 2: [Name]
echo "→ [Description]"
[command]

echo "✓ Workflow complete"
```

---

### Phase 4: Integration & Testing

#### Entry Check
```
IF workflow generated:
    → Add integration and test instructions
ELSE
    → Return to Phase 3
```

#### Integration Instructions
```markdown
## Installation

### Option 1: Vibery Install (if published)
```bash
npx vibery install [workflow-name]
```

### Option 2: Manual Install
```bash
# Copy to appropriate location:
cp [file] [destination]

# Make executable (if script):
chmod +x [file]
```

## Testing

### Dry Run
[Commands to test without side effects]

### Verification
After running, check:
- [ ] [expected outcome 1]
- [ ] [expected outcome 2]

## Troubleshooting

### Common Issues
| Issue | Cause | Fix |
|-------|-------|-----|
| [issue] | [cause] | [fix] |
```

---

### Phase 5: Output Delivery

#### Output Format
```markdown
# Workflow: [Name]

## Overview
[One sentence description]

## Trigger
[When this runs]

## Installation
[Copy-paste commands]

## Configuration
[File content to create]

## Usage
[How to run/trigger]

## Customization
[What can be modified]

## Related Workflows
[Suggest complementary automations]
```

---

## Common Workflow Templates

### Feature Development Workflow
```
Trigger: /feature [name]
Steps:
1. Create branch: git checkout -b feature/[name]
2. Generate spec: /spec-writer
3. Plan architecture: architect-planner
4. Create files: Based on plan
5. Generate tests: /generate-tests
6. Create PR: /create-pr
```

### Code Review Workflow
```
Trigger: PostToolUse on Edit
Steps:
1. Lint: Run project linter
2. Type check: Run tsc/mypy
3. Test affected: Run related tests
4. Format: Auto-format on save
```

### Release Workflow
```
Trigger: /release [version]
Steps:
1. Run full test suite
2. Update version in package.json
3. Generate changelog
4. Create git tag
5. Push with tags
6. Create GitHub release
```

### Documentation Workflow
```
Trigger: /docs
Steps:
1. Scan for undocumented functions
2. Generate JSDoc/docstrings
3. Update README if needed
4. Generate API docs
```

---

## Self-Check (Read before every response)

□ Is the trigger clear and specific?
  → Vague triggers = unexpected executions

□ Are steps atomic and ordered?
  → Each step should do one thing

□ Did I include error handling?
  → Workflows fail; handle gracefully

□ Is output copy-paste ready?
  → User shouldn't need to modify

□ Did I include testing instructions?
  → Untested workflows = broken workflows

□ Is the workflow actually saving time?
  → Automation overhead vs manual time

□ Can it be undone if something goes wrong?
  → Include rollback instructions for risky steps

---

## Integration with Vibery

```
SUGGEST after workflow created:
    - "Publish to Vibery: npx vibery publish"
    - "Share with team: Add to project .claude/"
    - "Combine with: [related workflows]"
```