claude-flow-novice 1.2.1 → 1.3.1

package/src/cli/simple-commands/sparc-modes/architect.js

@@ -0,0 +1,125 @@
+// architect.js - Architect mode orchestration template
+export function getArchitectOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Requirements Analysis** (10 mins)
+   - Analyze the user's request: "${taskDescription}"
+   - Query existing project context: \`npx claude-flow memory query ${memoryNamespace}\`
+   - Identify core components, services, and modular boundaries
+   - List external dependencies and integration points
+   - Document scalability and security requirements
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_requirements "Core components: X, Y, Z. External deps: API-A, Service-B. Security: OAuth2, RLS policies needed."\`
+
+2. **System Architecture Design** (20 mins)
+   - Create modular architecture diagram using Mermaid syntax
+   - Define clear service boundaries and responsibilities
+   - Design API contracts between components
+   - Plan data flow and state management patterns
+   - Ensure NO hardcoded secrets or env values in design
+   - Create extensible integration points
+   - Store architecture: \`npx claude-flow memory store ${memoryNamespace}_architecture "Microservices: auth-service, user-service, data-processor. APIs: REST for external, gRPC for internal. State: Event-sourced with CQRS."\`
+
+3. **Technical Specifications** (15 mins)
+   - Define detailed interface contracts (OpenAPI/AsyncAPI)
+   - Specify data models and database schemas
+   - Plan security boundaries and authentication flows
+   - Document performance and scaling considerations
+   - Define configuration management strategy
+   - Store specs: \`npx claude-flow memory store ${memoryNamespace}_tech_specs "Auth: JWT with refresh tokens. DB: PostgreSQL with read replicas. Cache: Redis. Config: Environment-based with secrets manager."\`
+
+4. **Modular Implementation Plan** (10 mins)
+   - Break system into modules < 500 lines each
+   - Create development phases with clear milestones
+   - Define testing strategy (unit, integration, e2e)
+   - Plan deployment and rollback procedures
+   - Identify tasks for other SPARC modes
+   - Store plan: \`npx claude-flow memory store ${memoryNamespace}_implementation_plan "Phase 1: Core auth (tdd mode). Phase 2: User management (code mode). Phase 3: Integration (integration mode)."\`
+
+5. **Directory Safety**
+   - **IMPORTANT**: All files should be created in the current working directory
+   - **DO NOT** create files in system directories or node_modules
+   - For named projects, create a subdirectory: \\\`mkdir project-name && cd project-name\\\`
+   - Use relative paths from your working directory
+   - Example structure:
+     \\\`\\\`\\\`
+     ./ (current directory)
+     ├── architecture/
+     │   ├── system-overview.md
+     │   └── api-specifications.md
+     └── implementation-plan.md
+     \\\`\\\`\\\`
+
+6. **Deliverables**
+   - architecture/
+     - system-overview.md (with Mermaid diagrams)
+     - api-specifications.md (OpenAPI/AsyncAPI specs)
+     - data-models.md (schemas with relationships)
+     - security-architecture.md (auth flows, boundaries)
+     - deployment-architecture.md (infrastructure design)
+   - implementation-plan.md (phased approach with SPARC mode assignments)
+
+## Next Steps - Sequential and Background Execution
+After completing architecture, delegate to appropriate modes:
+
+### Sequential Mode (for simple tasks):
+- \`npx claude-flow sparc run spec-pseudocode "Create detailed pseudocode for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Review architecture for vulnerabilities" --non-interactive\`
+
+### Background Swarm Mode (for complex implementation):
+- \`npx claude-flow swarm "Implement complete ${taskDescription} based on architecture" --strategy development --background --monitor\`
+- \`npx claude-flow swarm "Create comprehensive test suite for ${taskDescription}" --strategy testing --background --parallel\`
+- \`npx claude-flow swarm "Generate complete documentation for ${taskDescription}" --strategy research --background\`
+
+## 🐝 Enhanced Architecture with Background Swarms
+Leverage background swarm processing for complex architecture tasks:
+
+\`\`\`bash
+# Background research swarm for comprehensive analysis
+npx claude-flow swarm "Research and analyze all architectural patterns for ${taskDescription}" \\
+  --strategy research --background --parallel --monitor \\
+  --output ./architecture-research
+
+# Background development swarm for proof of concepts
+npx claude-flow swarm "Create architectural proof of concepts and prototypes for ${taskDescription}" \\
+  --strategy development --background --testing --monitor \\
+  --output ./architecture-prototypes
+
+# Background documentation swarm for comprehensive specs
+npx claude-flow swarm "Generate complete technical specifications and API documentation for ${taskDescription}" \\
+  --strategy research --background --parallel \\
+  --output ./architecture-docs
+
+# Monitor all background swarms
+npx claude-flow status
+npx claude-flow monitor
+
+# Sequential architecture refinement with background support
+npx claude-flow sparc run architect "Initial system design for ${taskDescription}" --non-interactive
+npx claude-flow swarm "Refine architecture based on security and performance analysis" \\
+  --strategy optimization --background --review --testing \\
+  --output ./architecture-refined
+\`\`\`
+
+## 🔄 Hybrid SPARC-Swarm Workflow
+Combine SPARC modes with background swarms for optimal efficiency:
+
+\`\`\`bash
+# Phase 1: Quick architecture analysis (SPARC)
+npx claude-flow sparc run architect "Core system design" --non-interactive
+
+# Phase 2: Parallel background research (Swarm)
+npx claude-flow swarm "Deep dive research into scalability patterns" --strategy research --background &
+npx claude-flow swarm "Security analysis and threat modeling" --strategy analysis --background &
+npx claude-flow swarm "Performance benchmarking and optimization research" --strategy optimization --background &
+
+# Phase 3: Implementation swarm (Background)
+npx claude-flow swarm "Full implementation of ${taskDescription} architecture" \\
+  --strategy development --background --parallel --monitor --testing \\
+  --max-agents 8 --output ./implementation
+
+# Monitor progress
+npx claude-flow status
+tail -f ./swarm-runs/*/swarm.log
+\`\`\``;
+}

package/src/cli/simple-commands/sparc-modes/ask.js

@@ -0,0 +1,126 @@
+// ask.js - Ask mode orchestration template
+export function getAskOrchestration(taskDescription, memoryNamespace) {
+  return `
+## ❓ Ask Mode - SPARC Navigation Guide
+
+I'll help you navigate the SPARC methodology and determine the best approach for: "${taskDescription}"
+
+## Understanding Your Request
+
+Let me analyze your needs and guide you to the right SPARC mode:
+
+### 1. **Project Phase Analysis** (5 mins)
+   - What stage is your project in?
+   - What type of help do you need?
+   - What's your end goal?
+
+### 2. **SPARC Mode Recommendations**
+
+Based on your request, here are the relevant SPARC modes:
+
+#### 📋 Planning & Design Modes:
+- **\`spec-pseudocode\`** - For creating detailed specifications, requirements, and high-level logic
+  - Use when: Starting a new feature, defining requirements, planning algorithms
+  - Example: \`npx claude-flow sparc run spec-pseudocode "Create user authentication flow" --non-interactive\`
+
+- **\`architect\`** - For system design, API boundaries, and service architecture
+  - Use when: Designing system structure, defining APIs, planning microservices
+  - Example: \`npx claude-flow sparc run architect "Design e-commerce platform architecture" --non-interactive\`
+
+#### 🧠 Implementation Modes:
+- **\`code\`** - For implementing features with clean architecture
+  - Use when: Building new features, writing production code
+  - Example: \`npx claude-flow sparc run code "Implement payment processing service" --non-interactive\`
+
+- **\`tdd\`** - For test-first development with comprehensive coverage
+  - Use when: Want high quality code, need test coverage, following TDD practices
+  - Example: \`npx claude-flow sparc run tdd "Build shopping cart with TDD" --non-interactive\`
+
+#### 🔧 Quality & Maintenance Modes:
+- **\`debug\`** - For troubleshooting issues and fixing bugs
+  - Use when: Something's broken, need to trace errors, fix runtime issues
+  - Example: \`npx claude-flow sparc run debug "Fix memory leak in data processor" --non-interactive\`
+
+- **\`security-review\`** - For security audits and vulnerability checks
+  - Use when: Need security audit, checking for exposed secrets, compliance review
+  - Example: \`npx claude-flow sparc run security-review "Audit user data handling" --non-interactive\`
+
+- **\`refinement-optimization-mode\`** - For performance optimization and refactoring
+  - Use when: Code needs optimization, files too large, performance issues
+  - Example: \`npx claude-flow sparc run refinement-optimization-mode "Optimize database queries" --non-interactive\`
+
+#### 📚 Documentation & Integration:
+- **\`docs-writer\`** - For creating documentation and guides
+  - Use when: Need README, API docs, user guides
+  - Example: \`npx claude-flow sparc run docs-writer "Create API documentation" --non-interactive\`
+
+- **\`integration\`** - For connecting services and ensuring system cohesion
+  - Use when: Integrating components, connecting APIs, system integration
+  - Example: \`npx claude-flow sparc run integration "Connect auth service to user service" --non-interactive\`
+
+#### 🚀 Deployment & Operations:
+- **\`devops\`** - For deployment, CI/CD, and infrastructure
+  - Use when: Setting up deployment, configuring CI/CD, provisioning infrastructure
+  - Example: \`npx claude-flow sparc run devops "Deploy to AWS with auto-scaling" --non-interactive\`
+
+- **\`post-deployment-monitoring-mode\`** - For production monitoring
+  - Use when: Setting up monitoring, configuring alerts, tracking metrics
+  - Example: \`npx claude-flow sparc run post-deployment-monitoring-mode "Setup DataDog monitoring" --non-interactive\`
+
+#### 🔐 Specialized Modes:
+- **\`supabase-admin\`** - For Supabase database and auth management
+  - Use when: Working with Supabase, setting up database, configuring auth
+  - Example: \`npx claude-flow sparc run supabase-admin "Setup user authentication database" --non-interactive\`
+
+- **\`mcp\`** - For MCP (Model Context Protocol) integrations
+  - Use when: Integrating external tools via MCP, API connections
+  - Example: \`npx claude-flow sparc run mcp "Integrate Stripe payment API" --non-interactive\`
+
+### 3. **Workflow Recommendations**
+
+For "${taskDescription}", I recommend this workflow:
+
+\`\`\`bash
+# Step 1: Define requirements
+npx claude-flow sparc run spec-pseudocode "${taskDescription} - requirements and pseudocode" --non-interactive
+
+# Step 2: Design architecture (if needed)
+npx claude-flow sparc run architect "${taskDescription} - system design" --non-interactive
+
+# Step 3: Implement with TDD
+npx claude-flow sparc run tdd "${taskDescription} - implementation" --non-interactive
+
+# Step 4: Security review
+npx claude-flow sparc run security-review "${taskDescription} - security audit" --non-interactive
+
+# Step 5: Documentation
+npx claude-flow sparc run docs-writer "${taskDescription} - documentation" --non-interactive
+\`\`\`
+
+### 4. **Best Practices Reminder**
+When using any SPARC mode, remember:
+✅ Keep files modular (< 500 lines)
+✅ Never hardcode environment variables
+✅ Use configuration files for env-specific values
+✅ Write tests for critical functionality
+✅ Document your decisions in memory
+
+### 5. **Memory Management**
+Track your progress across modes:
+\`\`\`bash
+# Store project context
+npx claude-flow memory store ${memoryNamespace}_context "Working on: ${taskDescription}"
+
+# Query previous work
+npx claude-flow memory query ${memoryNamespace}
+
+# List all memory entries
+npx claude-flow memory list
+\`\`\`
+
+## Next Steps
+
+Based on your request "${taskDescription}", which SPARC mode would you like to use? Or would you like me to help you break down your task into smaller, mode-specific subtasks?
+
+Remember: The SPARC methodology ensures systematic, high-quality development. Each mode has a specific purpose - use them in combination for best results!`;
+}

package/src/cli/simple-commands/sparc-modes/code.js

@@ -0,0 +1,148 @@
+// code.js - Auto-Coder mode orchestration template
+export function getCodeOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Project Directory Setup & Context Review** (5 mins)
+   - Verify current working directory and create project structure
+   - For named projects (e.g., "hello-world"), create as subdirectory
+   - Review implementation task: "${taskDescription}"
+   - Query architecture and pseudocode: 
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_pseudocode
+     npx claude-flow memory query ${memoryNamespace}_tech_specs
+     \`\`\`
+   - Identify modules to implement and their boundaries
+   - Review configuration requirements
+   - Check for any blocking dependencies
+
+2. **Project Setup & Configuration** (10 mins)
+   - Initialize project structure in current directory or subdirectory
+   - IMPORTANT: Use pwd to verify you're NOT in node_modules/
+   - Set up environment configuration (NO hardcoded values):
+     - Create .env.example with all required variables
+     - Set up config/ directory with environment loaders
+     - Implement secrets management abstraction
+   - Install dependencies based on tech specs
+   - Create module structure (each file < 500 lines)
+   - Store setup: \`npx claude-flow memory store ${memoryNamespace}_setup "Project structure: src/{domain,application,infrastructure}. Config: dotenv + vault integration. Dependencies: express, joi, winston."\`
+
+3. **Modular Implementation** (30 mins)
+   - Implement features using clean architecture principles:
+     - Domain layer: Business entities and rules
+     - Application layer: Use cases and workflows
+     - Infrastructure layer: External integrations
+   - Follow SOLID principles and dependency injection
+   - Keep each module/file under 500 lines
+   - Use configuration for ALL environment-specific values
+   - Implement comprehensive error handling
+   - Add structured logging with context
+   - Store progress: \`npx claude-flow memory store ${memoryNamespace}_implementation "Completed: auth-service (3 modules), user-repository (2 modules). Remaining: notification-service."\`
+
+4. **Integration & Basic Testing** (15 mins)
+   - Wire up dependency injection container
+   - Connect modules following architecture design
+   - Implement health checks and monitoring endpoints
+   - Add input validation and sanitization
+   - Create smoke tests for critical paths
+   - Verify configuration loading works correctly
+   - Test error scenarios and graceful degradation
+   - Store results: \`npx claude-flow memory store ${memoryNamespace}_tests "Smoke tests passing. Health checks operational. Error handling verified. Ready for TDD mode deep testing."\`
+
+5. **Code Quality & Documentation** (10 mins)
+   - Run linters and formatters
+   - Add inline documentation for complex logic
+   - Create API documentation (if applicable)
+   - Generate dependency graphs
+   - Update README with setup instructions
+   - Store completion: \`npx claude-flow memory store ${memoryNamespace}_code_complete "Implementation complete. All modules < 500 lines. No hardcoded secrets. Ready for testing and integration."\`
+
+## Directory Safety Check
+Before creating any files:
+1. Run \`pwd\` to verify current directory
+2. Ensure you're NOT in /node_modules/ or any system directory
+3. If creating a named project, create it as a subdirectory
+4. Example: For "hello-world", create ./hello-world/ in current directory
+
+## Deliverables
+All files should be created relative to the current working directory:
+- src/
+  - domain/ (business logic, < 500 lines per file)
+  - application/ (use cases, < 500 lines per file)
+  - infrastructure/ (external integrations)
+  - config/ (environment management)
+- tests/
+  - smoke/ (basic functionality tests)
+  - fixtures/ (test data)
+- config/
+  - .env.example (all required variables)
+  - config.js (environment loader)
+- docs/
+  - API.md (if applicable)
+  - SETUP.md (detailed setup guide)
+
+## Tool Usage Reminders
+- Use \`insert_content\` for new files or empty targets
+- Use \`apply_diff\` for modifying existing code with complete search/replace blocks
+- Avoid \`search_and_replace\` unless absolutely necessary
+- Always verify all tool parameters before execution
+
+## Next Steps - Sequential and Background Options
+After implementation, choose appropriate execution mode:
+
+### Sequential Mode (for simple follow-up tasks):
+- \`npx claude-flow sparc run tdd "Write comprehensive tests for ${taskDescription}" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Security audit for ${taskDescription}" --non-interactive\`
+
+### Background Swarm Mode (for complex comprehensive tasks):
+- \`npx claude-flow swarm "Create comprehensive test suite with unit, integration, and e2e tests for ${taskDescription}" --strategy testing --background --parallel\`
+- \`npx claude-flow swarm "Perform full security audit and penetration testing for ${taskDescription}" --strategy analysis --background --review\`
+- \`npx claude-flow swarm "Generate complete documentation, API specs, and deployment guides for ${taskDescription}" --strategy research --background\`
+
+## 🐝 Enhanced Development with Background Swarms
+Leverage background swarm processing for large-scale development:
+
+\`\`\`bash
+# Background comprehensive implementation swarm
+npx claude-flow swarm "Implement complete ${taskDescription} with all modules, testing, and documentation" \\
+  --strategy development --background --parallel --monitor --testing \\
+  --max-agents 6 --output ./implementation
+
+# Background quality assurance swarm
+npx claude-flow swarm "Comprehensive QA including testing, security review, and performance optimization for ${taskDescription}" \\
+  --strategy testing --background --review --monitor \\
+  --output ./qa-results
+
+# Background documentation and deployment swarm
+npx claude-flow swarm "Create production-ready documentation, deployment scripts, and monitoring for ${taskDescription}" \\
+  --strategy research --background --parallel \\
+  --output ./deployment-ready
+
+# Monitor all background development
+npx claude-flow status
+npx claude-flow monitor
+\`\`\`
+
+## 🔄 Hybrid SPARC-Swarm Development Workflow
+Combine SPARC modes with background swarms for optimal development velocity:
+
+\`\`\`bash
+# Phase 1: Quick prototyping (SPARC)
+npx claude-flow sparc run code "Core ${taskDescription} prototype" --non-interactive
+
+# Phase 2: Parallel background development (Swarm)
+npx claude-flow swarm "Full implementation of ${taskDescription} with advanced features" --strategy development --background --parallel &
+npx claude-flow swarm "Comprehensive testing strategy for ${taskDescription}" --strategy testing --background &
+npx claude-flow swarm "Security hardening and performance optimization" --strategy optimization --background &
+
+# Phase 3: Integration and deployment (Background)
+npx claude-flow swarm "Integration testing and production deployment preparation for ${taskDescription}" \\
+  --strategy integration --background --monitor --testing \\
+  --output ./production-ready
+
+# Monitor all development streams
+npx claude-flow status
+tail -f ./swarm-runs/*/swarm.log
+\`\`\``;
+}

package/src/cli/simple-commands/sparc-modes/debug.js

@@ -0,0 +1,112 @@
+// debug.js - Debugger mode orchestration template
+export function getDebugOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Issue Analysis & Reproduction** (10 mins)
+   - Understand the reported issue: "${taskDescription}"
+   - Query relevant context and previous issues:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_bugs
+     npx claude-flow memory query ${memoryNamespace}_implementation
+     npx claude-flow memory query ${memoryNamespace}_tests
+     \`\`\`
+   - Set up debugging environment:
+     - Enable verbose logging
+     - Configure debugging tools
+     - Prepare monitoring setup
+   - Reproduce the issue consistently
+   - Collect error messages, stack traces, and logs
+   - Identify affected components and dependencies
+   - Store findings: \`npx claude-flow memory store ${memoryNamespace}_issue_analysis "Issue: ${taskDescription}. Reproduction: Steps 1-3. Error: Stack trace at line X. Affected: auth-service, user-repository."\`
+
+2. **Root Cause Investigation** (20 mins)
+   - Add strategic debug logging:
+     - Entry/exit points of suspect functions
+     - State before/after transformations
+     - External service call results
+   - Use debugging tools:
+     - Debugger breakpoints
+     - Memory profilers (if memory issue)
+     - Network analyzers (if API issue)
+   - Trace execution flow systematically:
+     - Follow data through the system
+     - Check assumptions at each step
+     - Verify external dependencies
+   - Analyze patterns:
+     - When does it fail? (timing, load, specific data)
+     - What changed recently? (code, config, dependencies)
+   - Avoid changing env configuration directly
+   - Store investigation: \`npx claude-flow memory store ${memoryNamespace}_root_cause "Root cause: Race condition in auth token refresh. Occurs under high load when token expires during request processing. Fix approach: Implement token refresh mutex."\`
+
+3. **Solution Development** (15 mins)
+   - Develop targeted fix approach:
+     - Minimal change to resolve issue
+     - Maintain backward compatibility
+     - Consider edge cases
+   - Implement the solution:
+     - Keep changes modular
+     - Don't exceed 500 lines per file
+     - Add inline comments explaining the fix
+   - Add regression tests:
+     - Test the specific failure scenario
+     - Test related edge cases
+     - Ensure fix doesn't break existing tests
+   - Implement defensive coding:
+     - Add validation where missing
+     - Improve error messages
+     - Add circuit breakers if needed
+   - Store solution: \`npx claude-flow memory store ${memoryNamespace}_solution "Fix: Added mutex lock for token refresh. Tests: 3 regression tests added. Validation: Added token expiry check. No breaking changes."\`
+
+4. **Validation & Performance Check** (10 mins)
+   - Run comprehensive test suite:
+     \`\`\`bash
+     npm test
+     npm run test:integration
+     npm run test:e2e
+     \`\`\`
+   - Verify original issue is resolved
+   - Check performance impact:
+     - Run performance benchmarks
+     - Monitor memory usage
+     - Check response times
+   - Test in conditions that triggered the bug
+   - Verify no new issues introduced
+   - Document the fix with context
+   - Store validation: \`npx claude-flow memory store ${memoryNamespace}_debug_validation "All tests passing. Performance impact: <5ms latency increase. Memory usage unchanged. Original issue resolved."\`
+
+5. **Documentation & Cleanup** (5 mins)
+   - Create detailed fix documentation
+   - Remove debug logging (keep useful ones)
+   - Update error handling guides
+   - Create runbook for similar issues
+   - Submit for code review
+
+## Deliverables
+- Fixed code with:
+  - Inline comments explaining the fix
+  - Improved error messages
+  - Defensive coding additions
+- tests/regression/
+  - Test cases for the specific bug
+  - Edge case coverage
+- docs/
+  - DEBUG_REPORT.md (root cause analysis)
+  - FIX_DOCUMENTATION.md (what was changed and why)
+  - RUNBOOK.md (guide for similar issues)
+- Performance comparison report
+
+## Debugging Best Practices
+- Use structured logging with correlation IDs
+- Avoid changing production env during debugging
+- Keep debug changes isolated and reversible
+- Test fixes under same conditions as bug
+- Document investigation process for future reference
+- Consider using feature flags for gradual rollout
+
+## Next Steps
+After debugging completes:
+- \`npx claude-flow sparc run security-review "Review security impact of ${taskDescription} fix" --non-interactive\`
+- \`npx claude-flow sparc run refinement-optimization-mode "Refactor affected modules for better maintainability" --non-interactive\`
+- \`npx claude-flow sparc run post-deployment-monitoring-mode "Monitor ${taskDescription} fix in production" --non-interactive\``;
+}

package/src/cli/simple-commands/sparc-modes/devops.js

@@ -0,0 +1,137 @@
+// devops.js - DevOps mode orchestration template
+export function getDevOpsOrchestration(taskDescription, memoryNamespace) {
+  return `
+## Task Orchestration Steps
+
+1. **Environment Analysis** (10 mins)
+   - Run system analysis: \`uname -a\`
+   - Understand deployment requirements: "${taskDescription}"
+   - Query architecture and configuration:
+     \`\`\`bash
+     npx claude-flow memory query ${memoryNamespace}_architecture
+     npx claude-flow memory query ${memoryNamespace}_deployment
+     npx claude-flow memory query ${memoryNamespace}_infrastructure
+     \`\`\`
+   - Identify target environments:
+     - Development, staging, production
+     - Cloud providers (AWS, GCP, Azure)
+     - Edge platforms (Vercel, Cloudflare)
+     - Container orchestration (K8s, ECS)
+   - Review current infrastructure state
+   - Store analysis: \`npx claude-flow memory store ${memoryNamespace}_devops_analysis "Task: ${taskDescription}. Target: AWS ECS + CloudFront. Current: Local dev only. Requirements: Auto-scaling, blue-green deployment, monitoring."\`
+
+2. **Infrastructure Provisioning** (20 mins)
+   - Set up infrastructure as code:
+     - Create Terraform/CloudFormation templates
+     - Define resource configurations
+     - Set up networking (VPC, subnets, security groups)
+   - Provision compute resources:
+     - Cloud functions (Lambda, Cloud Functions)
+     - Container services (ECS, GKE)
+     - Edge runtimes (Workers, Functions)
+   - Configure managed services:
+     - Databases (RDS, DynamoDB, Firestore)
+     - Caching (ElastiCache, Memorystore)
+     - Message queues (SQS, Pub/Sub)
+   - Set up secrets management:
+     - AWS Secrets Manager / GCP Secret Manager
+     - Vault integration
+     - Environment injection layers
+   - NEVER hardcode credentials or tokens
+   - Store provisioning: \`npx claude-flow memory store ${memoryNamespace}_infrastructure "Provisioned: ECS cluster (2 AZs), RDS PostgreSQL, ElastiCache Redis, ALB. Secrets: AWS Secrets Manager configured. Terraform state: S3 backend."\`
+
+3. **CI/CD Pipeline Setup** (15 mins)
+   - Create pipeline configuration:
+     - GitHub Actions / GitLab CI / Jenkins
+     - Multi-stage pipeline (build, test, deploy)
+     - Environment-specific deployments
+   - Implement build stages:
+     \`\`\`yaml
+     - Build: Compile, bundle, optimize
+     - Test: Unit, integration, e2e
+     - Security: SAST, dependency scanning
+     - Package: Docker images, artifacts
+     \`\`\`
+   - Configure deployment strategies:
+     - Blue-green deployments
+     - Canary releases
+     - Rollback procedures
+   - Set up quality gates:
+     - Code coverage thresholds
+     - Performance benchmarks
+     - Security scan results
+   - Store pipeline config: \`npx claude-flow memory store ${memoryNamespace}_cicd "Pipeline: GitHub Actions. Stages: build->test->security->deploy. Environments: dev (auto), staging (manual), prod (approved). Rollback: Automated on failure."\`
+
+4. **Monitoring & Observability** (15 mins)
+   - Set up application monitoring:
+     - APM tools (DataDog, New Relic, AppDynamics)
+     - Custom metrics and dashboards
+     - Real-time alerting
+   - Configure infrastructure monitoring:
+     - CloudWatch / Stackdriver metrics
+     - Resource utilization alerts
+     - Cost optimization tracking
+   - Implement logging strategy:
+     - Centralized logging (ELK, CloudWatch Logs)
+     - Structured logging format
+     - Log retention policies
+   - Set up distributed tracing:
+     - Request flow tracking
+     - Performance bottleneck identification
+     - Error correlation
+   - Configure alerting rules:
+     - SLA/SLO monitoring
+     - Anomaly detection
+     - Escalation procedures
+   - Store monitoring setup: \`npx claude-flow memory store ${memoryNamespace}_monitoring "APM: DataDog configured. Logs: CloudWatch Logs with 30-day retention. Alerts: CPU >80%, Memory >85%, Error rate >1%. Dashboards: App performance, infra health, cost tracking."\`
+
+5. **Security & Compliance** (10 mins)
+   - Implement security best practices:
+     - TLS/SSL certificates (Let's Encrypt, ACM)
+     - WAF rules and DDoS protection
+     - Network segmentation
+     - IAM roles and policies
+   - Configure compliance controls:
+     - Audit logging
+     - Data encryption at rest/transit
+     - Backup and disaster recovery
+   - Set up security scanning:
+     - Container image scanning
+     - Infrastructure vulnerability scanning
+     - Compliance policy validation
+   - Document security procedures
+   - Store security config: \`npx claude-flow memory store ${memoryNamespace}_devops_security "TLS: ACM certificates on ALB. WAF: OWASP rules enabled. IAM: Least privilege roles. Backups: Daily snapshots, 30-day retention. Compliance: SOC2 controls implemented."\`
+
+## Deliverables
+- infrastructure/
+  - terraform/ (IaC templates, < 500 lines per file)
+  - scripts/ (deployment scripts)
+  - configs/ (environment configurations)
+- .github/workflows/ or .gitlab-ci.yml
+  - ci.yml (build and test pipeline)
+  - deploy.yml (deployment pipeline)
+- monitoring/
+  - dashboards/ (monitoring dashboards)
+  - alerts/ (alerting rules)
+- docs/
+  - DEPLOYMENT.md (deployment procedures)
+  - RUNBOOK.md (operational runbook)
+  - DISASTER_RECOVERY.md (DR procedures)
+  - ROLLBACK.md (rollback instructions)
+
+## DevOps Best Practices
+- Immutable infrastructure deployments
+- Blue-green deployment strategy
+- Automated rollback on failures
+- Never hardcode credentials - use secrets managers
+- Infrastructure as Code for everything
+- Comprehensive monitoring and alerting
+- Regular disaster recovery testing
+- Cost optimization reviews
+
+## Next Steps
+After DevOps setup:
+- \`npx claude-flow sparc run post-deployment-monitoring-mode "Verify production deployment health" --non-interactive\`
+- \`npx claude-flow sparc run security-review "Audit infrastructure security" --non-interactive\`
+- \`npx claude-flow sparc run refinement-optimization-mode "Optimize deployment performance" --non-interactive\``;
+}