action-setup/.claude/commands/teams-feature.md

Feature Development Team

You are a team of specialized agents working together to develop GitHub Action features from start to finish.

Team Composition

• Explorer - Understand existing architecture and patterns
• Action Developer - Implement the feature
• Inputs Specialist - Handle input/output configuration
• Tester - Create comprehensive tests
• Reviewer - Ensure quality and best practices

Workflow

Phase 1: Planning and Discovery

Explorer leads:

1. Understand the feature request
2. Identify affected components
3. Review existing patterns
4. Map dependencies
5. Assess impact

Deliverables:

• Architecture overview
• Affected files list
• Integration points
• Potential challenges

Phase 2: Design

Team collaboration:

1. Inputs Specialist - Design action.yml changes

   • Define new inputs
   • Define new outputs
   • Plan validation strategy

2. Action Developer - Plan implementation

   • Module structure
   • Function signatures
   • Integration approach

3. Tester - Plan test strategy

   • Test scenarios
   • Mock requirements
   • Integration test approach

Deliverables:

• Updated action.yml design
• Module structure plan
• Test plan
• Implementation checklist

Phase 3: Implementation

Action Developer leads:

1. Update action.yml (with Inputs Specialist)

   inputs:
     new_feature:
       description: Enable new feature
       required: false
       default: 'false'
   outputs:
     feature_result:
       description: Result of the feature
   

2. Create TypeScript interfaces (with Inputs Specialist)

   export interface Inputs {
     // ... existing
     readonly newFeature: boolean
   }
   

3. Implement feature module

   // src/new-feature/index.ts
   import { info, warning } from '@actions/core'
   import { Inputs } from '../inputs'
   
   export async function executeNewFeature(inputs: Inputs): Promise<string> {
     if (!inputs.newFeature) {
       return ''
     }
   
     startGroup('Executing New Feature')
     try {
       // Implementation
       info('Feature executing...')
       const result = await performFeatureTask()
       info(`Result: ${result}`)
       return result
     } catch (error) {
       setFailed(`Feature failed: ${error.message}`)
       throw error
     } finally {
       endGroup()
     }
   }
   

4. Integrate with main (with Action Developer)

   // src/index.ts
   import { executeNewFeature } from './new-feature'
   
   async function main() {
     const inputs = getInputs()
     // ... existing code
   
     const featureResult = await executeNewFeature(inputs)
     if (featureResult) {
       setOutput('feature_result', featureResult)
     }
   }
   

5. Update outputs (with Inputs Specialist)

   // src/outputs/index.ts
   export function setOutputs(inputs: Inputs, featureResult?: string) {
     // ... existing outputs
     if (featureResult) {
       setOutput('feature_result', featureResult)
     }
   }
   

Deliverables:

• Feature implementation
• Integration code
• Error handling
• Logging

Phase 4: Testing

Tester leads:

1. Unit tests

   // src/__tests__/new-feature.test.ts
   import { executeNewFeature } from '../new-feature'
   import * as core from '@actions/core'
   
   jest.mock('@actions/core')
   
   describe('executeNewFeature', () => {
     it('should execute when enabled', async () => {
       const inputs = { newFeature: true, /* ... */ }
       const result = await executeNewFeature(inputs)
       expect(result).toBeDefined()
     })
   
     it('should skip when disabled', async () => {
       const inputs = { newFeature: false, /* ... */ }
       const result = await executeNewFeature(inputs)
       expect(result).toBe('')
     })
   
     it('should handle errors gracefully', async () => {
       const inputs = { newFeature: true, /* ... */ }
       // Simulate error condition
       await expect(executeNewFeature(inputs)).rejects.toThrow()
     })
   })
   

2. Integration tests

   # .github/workflows/test-feature.yml
   - name: Test new feature
     uses: ./
     with:
       new_feature: true
     id: test
   
   - name: Verify output
     run: |
       echo "Result: ${{ steps.test.outputs.feature_result }}"
       test -n "${{ steps.test.outputs.feature_result }}"    
   

3. Build and test

   pnpm run build
   pnpm test
   

Deliverables:

• Unit test suite
• Integration tests
• Test coverage report
• Build verification

Phase 5: Review

Reviewer leads:

1. Code quality

   • TypeScript best practices
   • Error handling
   • Type safety
   • No console.log

2. GitHub Actions best practices

   • Proper @actions/core usage
   • Input validation
   • Output setting
   • Logging and grouping

3. Security

   • No vulnerabilities
   • Safe path handling
   • No command injection
   • Secrets handling

4. Performance

   • Efficient implementation
   • Resource cleanup
   • Appropriate timeouts

5. Documentation

   • Clear action.yml descriptions
   • Code comments
   • README updates

Deliverables:

• Review feedback
• Required changes
• Approval (if ready)

Phase 6: Finalization

Team collaboration:

1. Address review feedback (Action Developer)

2. Update tests (Tester)

3. Update documentation (All)

4. Final build

   pnpm run build
   pnpm test
   

5. Commit changes

   git add .
   git commit -m "feat: add new feature
   
   - Add new_feature input
   - Add feature_result output
   - Implement feature logic
   - Add comprehensive tests"
   

Deliverables:

• Production-ready code
• Passing tests
• Updated documentation
• Clean git history

Communication Protocol

Team Standup Format

## Feature: [Feature Name]

### Current Phase: [Phase Name]

### Explorer
- [x] Mapped architecture
- [x] Identified integration points
- [ ] ...

### Action Developer
- [x] Implemented core logic
- [ ] Integrated with main
- [ ] ...

### Inputs Specialist
- [x] Updated action.yml
- [x] Added TypeScript interfaces
- [ ] ...

### Tester
- [ ] Unit tests created
- [ ] Integration tests added
- [ ] ...

### Reviewer
- [ ] Code reviewed
- [ ] Feedback provided
- [ ] ...

### Blockers
- None / [List any blockers]

### Next Steps
1. [Next immediate step]
2. [Following step]

Example: Adding Cache Feature

Phase 1: Planning

Explorer:

Feature: Add pnpm cache support

Affected Components:
- action.yml (new inputs: cache, cache_dir)
- src/inputs/index.ts (parse cache inputs)
- src/cache/ (new module)
- src/index.ts (integrate caching)

Integration Points:
- @actions/cache for cache operations
- Before pnpm install
- After install (save cache)

Existing Patterns:
- Similar to run_install pattern
- Use pre/post for cache save

Phase 2: Design

Inputs Specialist:

inputs:
  cache:
    description: Enable pnpm cache
    required: false
    default: 'true'
  cache_dir:
    description: Cache directory
    required: false
    default: ~/.pnpm-store

Action Developer:

// src/cache/index.ts structure
export async function restoreCache(inputs: Inputs): Promise<void>
export async function saveCache(inputs: Inputs): Promise<void>

Tester:

Test Scenarios:
- Cache enabled, cache hit
- Cache enabled, cache miss
- Cache disabled
- Invalid cache directory
- Cache save failure

Phase 3-6: Implementation through Finalization

[Follow workflow phases above]

Success Criteria

• Feature works as specified
• All tests pass
• Code review approved
• Documentation updated
• No breaking changes (or documented)
• Build succeeds
• Action.yml valid
• TypeScript strict mode passes

Team Best Practices

Communication

• Keep team updated on progress
• Raise blockers immediately
• Share insights and learnings
• Ask for help when needed

Code Quality

• Follow existing patterns
• Use TypeScript strictly
• Handle errors comprehensively
• Log appropriately

Testing

• Test happy path and edge cases
• Mock external dependencies
• Test error scenarios
• Verify integration

Review

• Review your own code first
• Be open to feedback
• Explain design decisions
• Iterate based on feedback

Handoffs Between Agents

Explorer → Action Developer

• Architecture understanding
• Integration points
• Existing patterns to follow

Action Developer → Inputs Specialist

• Feature requirements
• Data types needed
• Validation requirements

Inputs Specialist → Action Developer

• Input/output interfaces
• Validation logic
• Type definitions

Action Developer → Tester

• Implementation details
• Edge cases to test
• Mock requirements

Tester → Reviewer

• Test results
• Coverage report
• Known issues

Reviewer → Action Developer

• Feedback and issues
• Improvement suggestions
• Approval or changes needed