@claude-flow/cli 3.7.0-alpha.1 → 3.7.0-alpha.10

package/.claude/commands/pair/examples.md

@@ -1,512 +1,512 @@
-# Pair Programming Examples
-
-Real-world examples and scenarios for pair programming sessions.
-
-## Example 1: Feature Implementation
-
-### Scenario
-Implementing a user authentication feature with JWT tokens.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode switch \
-  --agent senior-dev \
-  --focus implement \
-  --verify \
-  --test
-```
-
-### Session Flow
-```
-👥 Starting pair programming for authentication feature...
-
-[DRIVER: You - 10 minutes]
-/explain JWT authentication flow
-> AI explains JWT concepts and best practices
-
-/suggest implementation approach
-> AI suggests using middleware pattern with refresh tokens
-
-# You write the basic auth middleware structure
-
-[SWITCH TO NAVIGATOR]
-
-[NAVIGATOR: AI - 10 minutes]
-/implement JWT token generation with refresh tokens
-> AI generates secure token implementation
-
-/test-gen
-> AI creates comprehensive test suite
-
-[SWITCH TO DRIVER]
-
-[DRIVER: You - 10 minutes]
-# You refine the implementation
-/review --security
-> AI performs security review, suggests improvements
-
-/commit --message "feat: JWT authentication with refresh tokens"
-✅ Truth Score: 0.98 - Committed successfully
-```
-
-## Example 2: Bug Fixing Session
-
-### Scenario
-Debugging a memory leak in a Node.js application.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode navigator \
-  --agent debugger-expert \
-  --focus debug \
-  --trace
-```
-
-### Session Flow
-```
-👥 Starting debugging session...
-
-/status
-> Analyzing application for memory issues...
-
-/perf --profile
-> Memory usage growing: 150MB → 450MB over 10 minutes
-
-/find "new EventEmitter" --regex
-> Found 3 instances of EventEmitter creation
-
-/inspect eventEmitters --deep
-> Discovering listeners not being removed
-
-/suggest fix for memory leak
-> AI suggests: "Add removeListener in cleanup functions"
-
-/implement cleanup functions for all event emitters
-> AI generates proper cleanup code
-
-/test
-> Memory stable at 150MB ✅
-
-/commit --message "fix: memory leak in event emitters"
-```
-
-## Example 3: Test-Driven Development
-
-### Scenario
-Building a shopping cart feature using TDD.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode tdd \
-  --agent tdd-specialist \
-  --test-first
-```
-
-### Session Flow
-```
-👥 TDD Session: Shopping Cart Feature
-
-[RED PHASE]
-/test-gen "add item to cart"
-> AI writes failing test:
-  ✗ should add item to cart
-  ✗ should update quantity for existing item
-  ✗ should calculate total price
-
-[GREEN PHASE]
-/implement minimal cart functionality
-> You write just enough code to pass tests
-
-/test
-> Tests passing: 3/3 ✅
-
-[REFACTOR PHASE]
-/refactor --pattern repository
-> AI refactors to repository pattern
-
-/test
-> Tests still passing: 3/3 ✅
-
-[NEXT CYCLE]
-/test-gen "remove item from cart"
-> AI writes new failing tests...
-```
-
-## Example 4: Code Refactoring
-
-### Scenario
-Refactoring legacy code to modern patterns.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode driver \
-  --focus refactor \
-  --verify \
-  --threshold 0.98
-```
-
-### Session Flow
-```
-👥 Refactoring Session: Modernizing UserService
-
-/analyze UserService.js
-> AI identifies:
-  - Callback hell (5 levels deep)
-  - No error handling
-  - Tight coupling
-  - No tests
-
-/suggest refactoring plan
-> AI suggests:
-  1. Convert callbacks to async/await
-  2. Add error boundaries
-  3. Extract dependencies
-  4. Add unit tests
-
-/test-gen --before-refactor
-> AI generates tests for current behavior
-
-/refactor callbacks to async/await
-# You refactor with AI guidance
-
-/test
-> All tests passing ✅
-
-/review --compare
-> AI shows before/after comparison
-> Code complexity: 35 → 12
-> Truth score: 0.99 ✅
-
-/commit --message "refactor: modernize UserService with async/await"
-```
-
-## Example 5: Learning Session
-
-### Scenario
-Learning React hooks with AI mentorship.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode mentor \
-  --agent react-expert \
-  --pace slow \
-  --examples
-```
-
-### Session Flow
-```
-👥 Learning Session: React Hooks
-
-/learn useState hook
-> AI explains with interactive examples
-
-/example custom hook for API calls
-> AI shows best practice implementation:
-```javascript
-function useApi(url) {
-  const [data, setData] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  
-  useEffect(() => {
-    // Implementation explained step by step
-  }, [url]);
-  
-  return { data, loading, error };
-}
-```
-
-/implement my own custom hook
-# You write with AI guidance
-
-/review --educational
-> AI provides detailed feedback with learning points
-
-/quiz react hooks
-> AI tests your understanding
-> Score: 8/10 - Good progress!
-```
-
-## Example 6: Performance Optimization
-
-### Scenario
-Optimizing a slow React application.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode switch \
-  --agent performance-expert \
-  --focus optimize \
-  --profile
-```
-
-### Session Flow
-```
-👥 Performance Optimization Session
-
-/perf --profile
-> React DevTools Profiler Results:
-  - ProductList: 450ms render
-  - CartSummary: 200ms render
-  - Unnecessary re-renders: 15
-
-/suggest optimizations for ProductList
-> AI suggests:
-  1. Add React.memo
-  2. Use useMemo for expensive calculations
-  3. Implement virtualization for long lists
-
-/implement React.memo and useMemo
-# You implement with AI guidance
-
-/perf --profile
-> ProductList: 45ms render (90% improvement!) ✅
-
-/implement virtualization with react-window
-> AI implements virtual scrolling
-
-/perf --profile
-> ProductList: 12ms render (97% improvement!) ✅
-> FPS: 60 stable ✅
-
-/commit --message "perf: optimize ProductList with memoization and virtualization"
-```
-
-## Example 7: API Development
-
-### Scenario
-Building a RESTful API with Express.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode navigator \
-  --agent backend-expert \
-  --focus implement \
-  --test
-```
-
-### Session Flow
-```
-👥 API Development Session
-
-/design REST API for blog platform
-> AI designs endpoints:
-  POST   /api/posts
-  GET    /api/posts
-  GET    /api/posts/:id
-  PUT    /api/posts/:id
-  DELETE /api/posts/:id
-
-/implement CRUD endpoints with validation
-> AI implements with Express + Joi validation
-
-/test-gen --integration
-> AI generates integration tests
-
-/security --api
-> AI adds:
-  - Rate limiting
-  - Input sanitization
-  - JWT authentication
-  - CORS configuration
-
-/document --openapi
-> AI generates OpenAPI documentation
-
-/test --integration
-> All endpoints tested: 15/15 ✅
-
-/deploy --staging
-> API deployed to staging environment
-```
-
-## Example 8: Database Migration
-
-### Scenario
-Migrating from MongoDB to PostgreSQL.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode switch \
-  --agent database-expert \
-  --verify \
-  --test
-```
-
-### Session Flow
-```
-👥 Database Migration Session
-
-/analyze MongoDB schema
-> AI maps current structure:
-  - users collection → users table
-  - posts collection → posts table
-  - Embedded comments → comments table with FK
-
-/design PostgreSQL schema
-> AI creates normalized schema with relations
-
-/implement migration script
-# You write migration with AI assistance
-
-/test --migration --sample-data
-> Migration successful for 10,000 records ✅
-
-/implement data access layer
-> AI creates repository pattern implementation
-
-/test --integration
-> All queries working correctly ✅
-
-/verify data integrity
-> Truth score: 0.995 ✅
-> No data loss detected
-```
-
-## Example 9: CI/CD Pipeline
-
-### Scenario
-Setting up GitHub Actions CI/CD pipeline.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode navigator \
-  --agent devops-expert \
-  --focus implement
-```
-
-### Session Flow
-```
-👥 CI/CD Pipeline Setup
-
-/implement GitHub Actions workflow
-> AI creates .github/workflows/ci.yml:
-  - Build on push/PR
-  - Run tests
-  - Check coverage
-  - Deploy to staging
-
-/test --ci --dry-run
-> Pipeline simulation successful ✅
-
-/implement deployment to production
-> AI adds:
-  - Manual approval step
-  - Rollback capability
-  - Health checks
-  - Notifications
-
-/security --scan-pipeline
-> AI adds security scanning:
-  - Dependency scanning
-  - Container scanning
-  - Secret scanning
-
-/commit --message "ci: complete CI/CD pipeline with security scanning"
-```
-
-## Example 10: Mobile App Development
-
-### Scenario
-Building a React Native mobile feature.
-
-### Session Setup
-```bash
-claude-flow pair --start \
-  --mode switch \
-  --agent mobile-expert \
-  --language react-native \
-  --test
-```
-
-### Session Flow
-```
-👥 Mobile Development Session
-
-/implement offline-first data sync
-> AI implements:
-  - Local SQLite storage
-  - Queue for pending changes
-  - Sync on connection restore
-  - Conflict resolution
-
-/test --device ios simulator
-> Feature working on iOS ✅
-
-/test --device android emulator
-> Feature working on Android ✅
-
-/optimize --mobile
-> AI optimizes:
-  - Reduces bundle size by 30%
-  - Implements lazy loading
-  - Adds image caching
-
-/review --accessibility
-> AI ensures:
-  - Screen reader support
-  - Proper contrast ratios
-  - Touch target sizes
-
-/commit --message "feat: offline-first sync with optimizations"
-```
-
-## Common Patterns
-
-### Starting Patterns
-```bash
-# Quick start for common scenarios
-claude-flow pair --template <template>
-```
-
-Available templates:
-- `feature` - New feature development
-- `bugfix` - Bug fixing session
-- `refactor` - Code refactoring
-- `optimize` - Performance optimization
-- `test` - Test writing
-- `review` - Code review
-- `learn` - Learning session
-
-### Session Commands Flow
-
-#### Typical Feature Development
-```
-/start → /explain → /design → /implement → /test → /review → /commit → /end
-```
-
-#### Typical Bug Fix
-```
-/start → /reproduce → /debug → /trace → /fix → /test → /verify → /commit → /end
-```
-
-#### Typical Refactoring
-```
-/start → /analyze → /plan → /test-gen → /refactor → /test → /review → /commit → /end
-```
-
-## Best Practices from Examples
-
-1. **Always Start with Context** - Use `/explain` or `/analyze`
-2. **Test Early and Often** - Run tests after each change
-3. **Verify Before Commit** - Check truth scores
-4. **Document Decisions** - Use `/note` for important choices
-5. **Review Security** - Always run `/security` for sensitive code
-6. **Profile Performance** - Use `/perf` for optimization
-7. **Save Sessions** - Use `/save` for complex work
-
-## Related Documentation
-
-- [Getting Started](./README.md)
-- [Session Management](./session.md)
-- [Commands Reference](./commands.md)
+# Pair Programming Examples
+
+Real-world examples and scenarios for pair programming sessions.
+
+## Example 1: Feature Implementation
+
+### Scenario
+Implementing a user authentication feature with JWT tokens.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode switch \
+  --agent senior-dev \
+  --focus implement \
+  --verify \
+  --test
+```
+
+### Session Flow
+```
+👥 Starting pair programming for authentication feature...
+
+[DRIVER: You - 10 minutes]
+/explain JWT authentication flow
+> AI explains JWT concepts and best practices
+
+/suggest implementation approach
+> AI suggests using middleware pattern with refresh tokens
+
+# You write the basic auth middleware structure
+
+[SWITCH TO NAVIGATOR]
+
+[NAVIGATOR: AI - 10 minutes]
+/implement JWT token generation with refresh tokens
+> AI generates secure token implementation
+
+/test-gen
+> AI creates comprehensive test suite
+
+[SWITCH TO DRIVER]
+
+[DRIVER: You - 10 minutes]
+# You refine the implementation
+/review --security
+> AI performs security review, suggests improvements
+
+/commit --message "feat: JWT authentication with refresh tokens"
+✅ Truth Score: 0.98 - Committed successfully
+```
+
+## Example 2: Bug Fixing Session
+
+### Scenario
+Debugging a memory leak in a Node.js application.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode navigator \
+  --agent debugger-expert \
+  --focus debug \
+  --trace
+```
+
+### Session Flow
+```
+👥 Starting debugging session...
+
+/status
+> Analyzing application for memory issues...
+
+/perf --profile
+> Memory usage growing: 150MB → 450MB over 10 minutes
+
+/find "new EventEmitter" --regex
+> Found 3 instances of EventEmitter creation
+
+/inspect eventEmitters --deep
+> Discovering listeners not being removed
+
+/suggest fix for memory leak
+> AI suggests: "Add removeListener in cleanup functions"
+
+/implement cleanup functions for all event emitters
+> AI generates proper cleanup code
+
+/test
+> Memory stable at 150MB ✅
+
+/commit --message "fix: memory leak in event emitters"
+```
+
+## Example 3: Test-Driven Development
+
+### Scenario
+Building a shopping cart feature using TDD.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode tdd \
+  --agent tdd-specialist \
+  --test-first
+```
+
+### Session Flow
+```
+👥 TDD Session: Shopping Cart Feature
+
+[RED PHASE]
+/test-gen "add item to cart"
+> AI writes failing test:
+  ✗ should add item to cart
+  ✗ should update quantity for existing item
+  ✗ should calculate total price
+
+[GREEN PHASE]
+/implement minimal cart functionality
+> You write just enough code to pass tests
+
+/test
+> Tests passing: 3/3 ✅
+
+[REFACTOR PHASE]
+/refactor --pattern repository
+> AI refactors to repository pattern
+
+/test
+> Tests still passing: 3/3 ✅
+
+[NEXT CYCLE]
+/test-gen "remove item from cart"
+> AI writes new failing tests...
+```
+
+## Example 4: Code Refactoring
+
+### Scenario
+Refactoring legacy code to modern patterns.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode driver \
+  --focus refactor \
+  --verify \
+  --threshold 0.98
+```
+
+### Session Flow
+```
+👥 Refactoring Session: Modernizing UserService
+
+/analyze UserService.js
+> AI identifies:
+  - Callback hell (5 levels deep)
+  - No error handling
+  - Tight coupling
+  - No tests
+
+/suggest refactoring plan
+> AI suggests:
+  1. Convert callbacks to async/await
+  2. Add error boundaries
+  3. Extract dependencies
+  4. Add unit tests
+
+/test-gen --before-refactor
+> AI generates tests for current behavior
+
+/refactor callbacks to async/await
+# You refactor with AI guidance
+
+/test
+> All tests passing ✅
+
+/review --compare
+> AI shows before/after comparison
+> Code complexity: 35 → 12
+> Truth score: 0.99 ✅
+
+/commit --message "refactor: modernize UserService with async/await"
+```
+
+## Example 5: Learning Session
+
+### Scenario
+Learning React hooks with AI mentorship.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode mentor \
+  --agent react-expert \
+  --pace slow \
+  --examples
+```
+
+### Session Flow
+```
+👥 Learning Session: React Hooks
+
+/learn useState hook
+> AI explains with interactive examples
+
+/example custom hook for API calls
+> AI shows best practice implementation:
+```javascript
+function useApi(url) {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  
+  useEffect(() => {
+    // Implementation explained step by step
+  }, [url]);
+  
+  return { data, loading, error };
+}
+```
+
+/implement my own custom hook
+# You write with AI guidance
+
+/review --educational
+> AI provides detailed feedback with learning points
+
+/quiz react hooks
+> AI tests your understanding
+> Score: 8/10 - Good progress!
+```
+
+## Example 6: Performance Optimization
+
+### Scenario
+Optimizing a slow React application.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode switch \
+  --agent performance-expert \
+  --focus optimize \
+  --profile
+```
+
+### Session Flow
+```
+👥 Performance Optimization Session
+
+/perf --profile
+> React DevTools Profiler Results:
+  - ProductList: 450ms render
+  - CartSummary: 200ms render
+  - Unnecessary re-renders: 15
+
+/suggest optimizations for ProductList
+> AI suggests:
+  1. Add React.memo
+  2. Use useMemo for expensive calculations
+  3. Implement virtualization for long lists
+
+/implement React.memo and useMemo
+# You implement with AI guidance
+
+/perf --profile
+> ProductList: 45ms render (90% improvement!) ✅
+
+/implement virtualization with react-window
+> AI implements virtual scrolling
+
+/perf --profile
+> ProductList: 12ms render (97% improvement!) ✅
+> FPS: 60 stable ✅
+
+/commit --message "perf: optimize ProductList with memoization and virtualization"
+```
+
+## Example 7: API Development
+
+### Scenario
+Building a RESTful API with Express.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode navigator \
+  --agent backend-expert \
+  --focus implement \
+  --test
+```
+
+### Session Flow
+```
+👥 API Development Session
+
+/design REST API for blog platform
+> AI designs endpoints:
+  POST   /api/posts
+  GET    /api/posts
+  GET    /api/posts/:id
+  PUT    /api/posts/:id
+  DELETE /api/posts/:id
+
+/implement CRUD endpoints with validation
+> AI implements with Express + Joi validation
+
+/test-gen --integration
+> AI generates integration tests
+
+/security --api
+> AI adds:
+  - Rate limiting
+  - Input sanitization
+  - JWT authentication
+  - CORS configuration
+
+/document --openapi
+> AI generates OpenAPI documentation
+
+/test --integration
+> All endpoints tested: 15/15 ✅
+
+/deploy --staging
+> API deployed to staging environment
+```
+
+## Example 8: Database Migration
+
+### Scenario
+Migrating from MongoDB to PostgreSQL.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode switch \
+  --agent database-expert \
+  --verify \
+  --test
+```
+
+### Session Flow
+```
+👥 Database Migration Session
+
+/analyze MongoDB schema
+> AI maps current structure:
+  - users collection → users table
+  - posts collection → posts table
+  - Embedded comments → comments table with FK
+
+/design PostgreSQL schema
+> AI creates normalized schema with relations
+
+/implement migration script
+# You write migration with AI assistance
+
+/test --migration --sample-data
+> Migration successful for 10,000 records ✅
+
+/implement data access layer
+> AI creates repository pattern implementation
+
+/test --integration
+> All queries working correctly ✅
+
+/verify data integrity
+> Truth score: 0.995 ✅
+> No data loss detected
+```
+
+## Example 9: CI/CD Pipeline
+
+### Scenario
+Setting up GitHub Actions CI/CD pipeline.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode navigator \
+  --agent devops-expert \
+  --focus implement
+```
+
+### Session Flow
+```
+👥 CI/CD Pipeline Setup
+
+/implement GitHub Actions workflow
+> AI creates .github/workflows/ci.yml:
+  - Build on push/PR
+  - Run tests
+  - Check coverage
+  - Deploy to staging
+
+/test --ci --dry-run
+> Pipeline simulation successful ✅
+
+/implement deployment to production
+> AI adds:
+  - Manual approval step
+  - Rollback capability
+  - Health checks
+  - Notifications
+
+/security --scan-pipeline
+> AI adds security scanning:
+  - Dependency scanning
+  - Container scanning
+  - Secret scanning
+
+/commit --message "ci: complete CI/CD pipeline with security scanning"
+```
+
+## Example 10: Mobile App Development
+
+### Scenario
+Building a React Native mobile feature.
+
+### Session Setup
+```bash
+claude-flow pair --start \
+  --mode switch \
+  --agent mobile-expert \
+  --language react-native \
+  --test
+```
+
+### Session Flow
+```
+👥 Mobile Development Session
+
+/implement offline-first data sync
+> AI implements:
+  - Local SQLite storage
+  - Queue for pending changes
+  - Sync on connection restore
+  - Conflict resolution
+
+/test --device ios simulator
+> Feature working on iOS ✅
+
+/test --device android emulator
+> Feature working on Android ✅
+
+/optimize --mobile
+> AI optimizes:
+  - Reduces bundle size by 30%
+  - Implements lazy loading
+  - Adds image caching
+
+/review --accessibility
+> AI ensures:
+  - Screen reader support
+  - Proper contrast ratios
+  - Touch target sizes
+
+/commit --message "feat: offline-first sync with optimizations"
+```
+
+## Common Patterns
+
+### Starting Patterns
+```bash
+# Quick start for common scenarios
+claude-flow pair --template <template>
+```
+
+Available templates:
+- `feature` - New feature development
+- `bugfix` - Bug fixing session
+- `refactor` - Code refactoring
+- `optimize` - Performance optimization
+- `test` - Test writing
+- `review` - Code review
+- `learn` - Learning session
+
+### Session Commands Flow
+
+#### Typical Feature Development
+```
+/start → /explain → /design → /implement → /test → /review → /commit → /end
+```
+
+#### Typical Bug Fix
+```
+/start → /reproduce → /debug → /trace → /fix → /test → /verify → /commit → /end
+```
+
+#### Typical Refactoring
+```
+/start → /analyze → /plan → /test-gen → /refactor → /test → /review → /commit → /end
+```
+
+## Best Practices from Examples
+
+1. **Always Start with Context** - Use `/explain` or `/analyze`
+2. **Test Early and Often** - Run tests after each change
+3. **Verify Before Commit** - Check truth scores
+4. **Document Decisions** - Use `/note` for important choices
+5. **Review Security** - Always run `/security` for sensitive code
+6. **Profile Performance** - Use `/perf` for optimization
+7. **Save Sessions** - Use `/save` for complex work
+
+## Related Documentation
+
+- [Getting Started](./README.md)
+- [Session Management](./session.md)
+- [Commands Reference](./commands.md)
 - [Configuration](./config.md)