claude-flow-novice 2.18.5 → 2.18.6

package/.claude/commands/workflow.md

@@ -0,0 +1,295 @@
+---
+description: "Advanced workflow automation with event-driven triggers and AI coordination"
+argument-hint: "<action> [workflow-name] [options]"
+allowed-tools: ["Bash", "Read", "Write", "Edit", "Grep", "mcp__claude-flow__workflow_create", "mcp__claude-flow__workflow_execute", "mcp__claude-flow__automation_setup", "mcp__claude-flow__pipeline_create", "mcp__claude-flow__scheduler_manage", "mcp__claude-flow__trigger_setup", "mcp__claude-flow__agent_spawn", "mcp__claude-flow__task_orchestrate", "mcp__claude-flow__memory_usage"]
+---
+
+# Workflow Automation & Orchestration
+
+Create, manage, and execute sophisticated automated workflows with AI-powered orchestration and event-driven triggers.
+
+**Action**: $ARGUMENTS
+
+## Workflow Actions
+
+### Workflow Management
+- `create <name>` - Create new workflow with AI assistance
+- `list` - Show all available workflows
+- `execute <name>` - Run workflow with real-time monitoring
+- `status [name]` - Check workflow execution status
+- `stop <name>` - Gracefully stop running workflow
+
+### Automation Setup
+- `triggers setup` - Configure event-driven triggers
+- `schedule <name> <cron>` - Schedule workflow execution
+- `pipeline create <name>` - Create CI/CD pipeline
+- `hooks enable` - Enable automation hooks
+- `monitor <name>` - Real-time workflow monitoring
+
+### Template Management
+- `template list` - Show workflow templates
+- `template create <name>` - Create reusable template
+- `template apply <name>` - Apply template to project
+- `export <name>` - Export workflow definition
+- `import <file>` - Import workflow from file
+
+## Workflow Types
+
+### 🚀 Development Workflows
+
+#### Full-Stack Feature Development
+```yaml
+name: "feature-development"
+trigger: "branch-created"
+steps:
+  - name: "analyze-requirements"
+    agent: "researcher"
+    action: "analyze-feature-requirements"
+  
+  - name: "design-architecture"
+    agent: "system-architect"
+    depends: ["analyze-requirements"]
+    action: "design-system-architecture"
+  
+  - name: "backend-implementation"
+    agent: "backend-dev"
+    depends: ["design-architecture"]
+    parallel: true
+    action: "implement-backend-services"
+  
+  - name: "frontend-implementation"
+    agent: "coder"
+    depends: ["design-architecture"]
+    parallel: true
+    action: "implement-frontend-components"
+  
+  - name: "integration-testing"
+    agent: "tester"
+    depends: ["backend-implementation", "frontend-implementation"]
+    action: "run-integration-tests"
+```
+
+#### Code Quality Pipeline
+```yaml
+name: "code-quality"
+trigger: "pull-request"
+steps:
+  - name: "static-analysis"
+    tools: ["eslint", "typescript", "rust-clippy"]
+    parallel: true
+  
+  - name: "security-scan"
+    tools: ["npm-audit", "cargo-audit", "snyk"]
+    parallel: true
+  
+  - name: "test-execution"
+    agents: ["tester"]
+    coverage_threshold: 85
+  
+  - name: "performance-test"
+    agents: ["perf-analyzer"]
+    benchmarks: ["load", "stress", "memory"]
+```
+
+### 🔄 CI/CD Workflows
+
+#### Deployment Pipeline
+```yaml
+name: "deployment-pipeline"
+trigger: "tag-created"
+environments: ["staging", "production"]
+steps:
+  - name: "build"
+    parallel_matrix:
+      - target: "linux-x64"
+      - target: "darwin-arm64"
+      - target: "windows-x64"
+  
+  - name: "test-suite"
+    depends: ["build"]
+    types: ["unit", "integration", "e2e"]
+  
+  - name: "security-audit"
+    depends: ["build"]
+    scans: ["dependencies", "containers", "infrastructure"]
+  
+  - name: "deploy-staging"
+    depends: ["test-suite", "security-audit"]
+    environment: "staging"
+    approval: false
+  
+  - name: "deploy-production"
+    depends: ["deploy-staging"]
+    environment: "production"
+    approval: true
+    rollback_strategy: "blue-green"
+```
+
+### 📅 Scheduled Workflows
+
+#### Maintenance Tasks
+```yaml
+name: "weekly-maintenance"
+schedule: "0 2 * * 1"  # Every Monday at 2 AM
+steps:
+  - name: "dependency-updates"
+    agent: "dependency-analyzer"
+    action: "check-updates"
+    auto_pr: true
+  
+  - name: "security-scan"
+    agent: "security-specialist"
+    action: "vulnerability-scan"
+    report: "weekly-security-report"
+  
+  - name: "performance-analysis"
+    agent: "perf-analyzer"
+    action: "benchmark-comparison"
+    retention: "6-months"
+  
+  - name: "cleanup-artifacts"
+    action: "cleanup-old-builds"
+    retention: "30-days"
+```
+
+## Event-Driven Triggers
+
+### Git Triggers
+- **Push Events**: Branch pushes, tag creation, force pushes
+- **PR Events**: Created, updated, merged, closed
+- **Issue Events**: Opened, commented, labeled, closed
+- **Release Events**: Published, edited, deleted
+
+### File System Triggers
+- **File Changes**: Specific file/directory modifications
+- **Pattern Matching**: Glob patterns for selective triggering
+- **Dependency Changes**: package.json, Cargo.toml, requirements.txt
+- **Configuration Changes**: Environment files, CI configs
+
+### External Triggers
+- **Webhooks**: External service notifications
+- **API Calls**: RESTful trigger endpoints
+- **Scheduled**: Cron-based scheduling
+- **Manual**: User-initiated execution
+
+## Workflow Features
+
+### 🦾 AI-Powered Orchestration
+
+#### Intelligent Task Distribution
+- **Agent Selection**: Choose optimal agents based on task requirements
+- **Load Balancing**: Distribute work across available agents
+- **Failure Recovery**: Automatic retry with different agents
+- **Resource Management**: Monitor and allocate system resources
+
+#### Dynamic Workflow Adaptation
+- **Context Awareness**: Adapt based on project type and complexity
+- **Performance Learning**: Optimize workflows based on execution history
+- **Error Patterns**: Learn from failures to prevent future issues
+- **Team Preferences**: Adapt to team coding styles and preferences
+
+### 📊 Real-Time Monitoring
+
+#### Execution Tracking
+- **Step Progress**: Real-time step execution status
+- **Agent Activity**: Monitor agent resource usage and performance
+- **Bottleneck Detection**: Identify and resolve workflow bottlenecks
+- **Performance Metrics**: Track execution times and success rates
+
+#### Notifications & Alerts
+- **Slack Integration**: Send notifications to team channels
+- **Email Alerts**: Critical failure and success notifications
+- **Dashboard Updates**: Real-time web dashboard updates
+- **Mobile Notifications**: Push notifications for mobile apps
+
+### 🔒 Security & Compliance
+
+#### Access Control
+- **Role-Based Permissions**: Workflow execution permissions
+- **Secret Management**: Secure handling of API keys and credentials
+- **Audit Logging**: Complete audit trail of workflow executions
+- **Compliance Checks**: Ensure workflows meet security standards
+
+#### Safe Execution
+- **Sandbox Isolation**: Isolate workflow execution environments
+- **Resource Limits**: Prevent resource exhaustion
+- **Rollback Capabilities**: Quick rollback for failed deployments
+- **Validation Gates**: Pre-execution validation and safety checks
+
+## Usage Examples
+
+### Create Development Workflow
+```bash
+# Create new feature development workflow
+/workflow create feature-pipeline
+
+# AI will prompt for:
+# - Project type (detected automatically)
+# - Testing requirements
+# - Deployment targets
+# - Team preferences
+
+# Generated workflow includes:
+# - Appropriate agents for detected tech stack
+# - Testing strategy based on project type
+# - Security scans relevant to framework
+# - Deployment steps for target platform
+```
+
+### Execute Workflow with Monitoring
+```bash
+# Execute workflow with real-time monitoring
+/workflow execute feature-pipeline --monitor
+
+# Output:
+# 🚀 Starting workflow: feature-pipeline
+# ✅ [1/5] Requirements Analysis (researcher) - 2.3s
+# 🔄 [2/5] Architecture Design (system-architect) - Running...
+# ⏸️ [3/5] Backend Implementation (backend-dev) - Waiting
+# ⏸️ [4/5] Frontend Implementation (coder) - Waiting
+# ⏸️ [5/5] Integration Testing (tester) - Waiting
+```
+
+### Schedule Maintenance Workflow
+```bash
+# Schedule weekly maintenance
+/workflow schedule maintenance-pipeline "0 2 * * 1"
+
+# Output:
+# 📋 Scheduled: maintenance-pipeline
+# ⏰ Next run: Monday, 2:00 AM UTC
+# 🔄 Tasks: dependency-updates, security-scan, cleanup
+# 📊 Estimated duration: 15-20 minutes
+```
+
+## Template Library
+
+### Pre-Built Workflows
+- **Feature Development**: Full-stack feature implementation
+- **Bug Fix Pipeline**: Issue triage, fix, test, deploy
+- **Security Audit**: Comprehensive security scanning
+- **Performance Testing**: Load testing and optimization
+- **Documentation**: Auto-generate and update docs
+- **Dependency Management**: Regular updates and security patches
+
+### Custom Templates
+- **Team-Specific**: Workflows tailored to team processes
+- **Project-Specific**: Workflows adapted to project requirements
+- **Industry-Specific**: Workflows for specific domains (fintech, healthcare)
+- **Compliance**: Workflows ensuring regulatory compliance
+
+## Integration Capabilities
+
+### Development Tools
+- **GitHub/GitLab**: Git workflow integration
+- **Jira/Linear**: Issue tracking integration
+- **Slack/Teams**: Communication integration
+- **Docker/Kubernetes**: Container orchestration
+
+### Cloud Platforms
+- **AWS/Azure/GCP**: Cloud deployment integration
+- **Terraform**: Infrastructure as code
+- **Monitoring**: Datadog, New Relic, Prometheus
+- **Security**: Snyk, Veracode, SonarQube
+
+Create powerful, intelligent workflows that adapt to your team's needs and automate your entire development lifecycle.

package/.claude/commands/write-plan.md

@@ -0,0 +1,275 @@
+---
+description: "CFN Loop pre-planning: Generate structured implementation plans with TDD approach"
+argument-hint: "<task description> [--mode=mvp|standard|enterprise]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Bash"]
+---
+
+# Write Plan - CFN Loop Pre-Planning
+
+Generate structured implementation plan BEFORE executing CFN Loop. Outputs plan document for review.
+
+🎯 **Use this BEFORE /cfn-loop-cli or /cfn-loop-task**
+
+**Task**: $ARGUMENTS
+
+## What This Does
+
+**Pre-planning phase for CFN Loop:**
+1. Analyzes task complexity
+2. Selects appropriate agents
+3. Defines test cases and success criteria
+4. Creates implementation roadmap
+5. Outputs plan document for approval
+
+**Then run:**
+```bash
+# After reviewing plan
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+# OR
+/cfn-loop-task "Implement JWT authentication" --mode=standard
+```
+
+## Command Options
+
+```bash
+# Standard planning
+/write-plan "Implement JWT authentication"
+
+# MVP planning (faster, simpler)
+/write-plan "Build prototype feature" --mode=mvp
+
+# Enterprise planning (comprehensive)
+/write-plan "Production security system" --mode=enterprise
+```
+
+**Options:**
+- `--mode=<mvp|standard|enterprise>`: Planning depth (default: standard)
+
+## Execution Pattern
+
+### Step 1: Analyze Task
+
+```javascript
+Task("planner", `
+  ANALYZE TASK FOR CFN LOOP PLANNING
+
+  Task: $ARGUMENTS
+  Mode: ${mode}
+
+  ANALYSIS REQUIRED:
+  1. Complexity Assessment:
+     - Estimated files: 1-2 (simple) | 3-5 (standard) | >5 (complex)
+     - Estimated LOC: <200 (simple) | 200-500 (standard) | >500 (complex)
+     - Keywords: security, performance, frontend, mobile, etc.
+
+  2. Agent Selection:
+     - Loop 3 (Implementation): Based on task type
+       * Backend: backend-dev, researcher, devops
+       * Full-stack: backend-dev, react-frontend-engineer, devops
+       * Mobile: mobile-dev, backend-dev
+       * Security: security-specialist, backend-dev
+     - Loop 2 (Validation): Scale by complexity
+       * Simple: reviewer, tester
+       * Standard: +architect, +security-specialist
+       * Complex: +code-analyzer, +performance-benchmarker
+
+  3. Test Cases (TDD Approach):
+     - Red Phase: Failure scenarios
+     - Green Phase: Minimal passing implementation
+     - Refactor Phase: Quality improvements
+
+  4. Success Criteria:
+     - Test coverage target (≥80%)
+     - Performance benchmarks (if applicable)
+     - Security requirements (if applicable)
+     - Deliverables list
+
+  OUTPUT: planning/PLAN_${sanitize($ARGUMENTS)}.md
+`)
+```
+
+### Step 2: Generate Plan Document
+
+**Plan Structure:**
+```markdown
+# Implementation Plan: [Task Name]
+
+## Task Analysis
+- **Complexity**: Simple | Standard | Complex
+- **Estimated Files**: N
+- **Estimated LOC**: N
+- **Mode**: ${mode}
+
+## Agent Configuration
+
+### Loop 3 (Implementation)
+- agent-1 (role)
+- agent-2 (role)
+- agent-3 (role)
+
+### Loop 2 (Validation)
+- reviewer (code review)
+- tester (quality assurance)
+[+ architect, security-specialist for standard/enterprise]
+
+### Product Owner
+- product-owner (PROCEED/ITERATE/ABORT decision)
+
+## Test-Driven Development Plan
+
+### Phase 1: Red (Failure Scenarios)
+**Deliverables:**
+- [ ] Test script: tests/test-[feature].sh
+- [ ] Failure test cases defined
+
+**Test Cases:**
+1. [Test case 1 - expected failure]
+2. [Test case 2 - edge case]
+3. [Test case 3 - performance requirement]
+
+### Phase 2: Green (Minimal Implementation)
+**Deliverables:**
+- [ ] Minimal working implementation
+- [ ] All test cases passing
+
+**Implementation Steps:**
+1. [Core functionality]
+2. [Basic validation]
+3. [Minimal error handling]
+
+### Phase 3: Refactor (Quality Improvement)
+**Deliverables:**
+- [ ] Code quality improvements
+- [ ] Enhanced test coverage (≥80%)
+- [ ] Documentation
+
+**Refactoring Goals:**
+1. [Code organization]
+2. [Performance optimization]
+3. [Security hardening]
+
+## Success Criteria
+
+### Quality Gates
+- Loop 3 Gate: ≥${mode === 'enterprise' ? 0.85 : mode === 'standard' ? 0.75 : 0.70}
+- Loop 2 Consensus: ≥${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+
+### Deliverables
+- [ ] All test cases passing
+- [ ] Test coverage ≥80%
+- [ ] Code complexity <15 per function
+- [ ] Security review complete
+- [ ] Documentation updated
+
+### Performance Benchmarks (if applicable)
+- [Benchmark 1]
+- [Benchmark 2]
+
+## Potential Blockers
+
+**Technical:**
+- [Potential blocker 1]
+- [Mitigation strategy]
+
+**Dependencies:**
+- [External dependency 1]
+- [Fallback plan]
+
+## Iteration Strategy
+- Max iterations: ${mode === 'enterprise' ? 15 : mode === 'standard' ? 10 : 5}
+- Confidence threshold: ${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+- Adaptive agent spawning: YES
+
+## Next Steps
+
+1. Review this plan
+2. Execute CFN Loop:
+   \`\`\`bash
+   /cfn-loop-cli "$ARGUMENTS" --mode=${mode}
+   # OR for debugging:
+   /cfn-loop-task "$ARGUMENTS" --mode=${mode}
+   \`\`\`
+```
+
+### Step 3: Output Plan
+
+```javascript
+const planPath = `planning/PLAN_${sanitize($ARGUMENTS)}.md`;
+Write(planPath, planContent);
+
+console.log(`✅ Implementation plan generated: ${planPath}`);
+console.log('');
+console.log('📋 Plan Summary:');
+console.log(`- Complexity: ${complexity}`);
+console.log(`- Loop 3 Agents: ${loop3Agents.length}`);
+console.log(`- Loop 2 Validators: ${loop2Agents.length}`);
+console.log(`- Test Cases: ${testCases.length}`);
+console.log(`- Success Criteria: ${successCriteria.length}`);
+console.log('');
+console.log('Next: Review plan, then execute CFN Loop');
+console.log(`/cfn-loop-cli "$ARGUMENTS" --mode=${mode}`);
+```
+
+## Integration with CFN Loop
+
+**Workflow:**
+```
+1. /write-plan "Task description" --mode=standard
+   ↓ Generates planning/PLAN_task.md
+
+2. Human reviews plan (optional)
+   ↓ Approve or request changes
+
+3. /cfn-loop-cli "Task description" --mode=standard
+   ↓ Executes implementation following plan
+
+4. CFN Loop autonomously implements following TDD phases
+```
+
+## Mode Comparison
+
+| Mode | Complexity | Agents | Test Coverage | Use Case |
+|------|------------|--------|---------------|----------|
+| MVP | Low | 3-4 total | ≥70% | Prototypes, proof-of-concept |
+| Standard | Medium | 5-7 total | ≥80% | Production features |
+| Enterprise | High | 8-10 total | ≥90% | Critical systems, compliance |
+
+## Example Output
+
+```
+Analyzing task...
+
+✅ Implementation plan generated: planning/PLAN_jwt_authentication.md
+
+📋 Plan Summary:
+- Complexity: Standard
+- Loop 3 Agents: 3 (backend-dev, researcher, devops)
+- Loop 2 Validators: 4 (reviewer, tester, architect, security-specialist)
+- Test Cases: 8
+- Success Criteria: 6
+
+Next: Review plan, then execute CFN Loop
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+```
+
+## Best Practices
+
+**When to Use:**
+- ✅ Complex tasks (>3 steps)
+- ✅ Security-critical features
+- ✅ Team collaboration (plan review needed)
+- ✅ Learning CFN Loop workflow
+
+**When to Skip:**
+- Simple bug fixes (go straight to /cfn-loop-cli)
+- Urgent hotfixes (no time for planning)
+- Well-understood patterns (agent knows what to do)
+
+## Related Commands
+
+- **Execute Plan**: `/cfn-loop-cli` (production) or `/cfn-loop-task` (debugging)
+- **Document Results**: `/cfn-loop-document` (after completion)
+
+---
+
+**Version:** 2.0.0 (2025-10-31) - Integrated with CFN Loop v3 architecture