claude-flow 2.0.0-alpha.88 → 2.0.0-alpha.89

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

@@ -0,0 +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)
+- [Configuration](./config.md)