claude-flow-novice 2.10.5 → 2.10.6

package/claude-assets/commands/cfn/sparc.md

@@ -0,0 +1,46 @@
+---
+description: "Execute SPARC methodology phases"
+argument-hint: "<phase> <task description>"
+allowed-tools: ["mcp__claude-flow-novice__task_orchestrate", "mcp__claude-flow-novice__agent_spawn"]
+---
+
+# SPARC Methodology Execution
+
+Execute systematic development phases using SPARC methodology.
+
+**Phase**: $1
+**Task**: $2
+
+**SPARC Phases**:
+
+## Specification (spec)
+- Define clear requirements and acceptance criteria
+- Create user stories and use cases
+- Identify constraints and assumptions
+- Specify input/output requirements
+
+## Pseudocode (pseudo)
+- Break down problem into logical steps
+- Write high-level algorithm pseudocode
+- Define data structures and flow
+- Plan error handling and edge cases
+
+## Architecture (arch)
+- Design system architecture and components
+- Define interfaces and APIs
+- Choose appropriate patterns and technologies
+- Plan data flow and storage
+
+## Refinement (refine)
+- Review and improve the design
+- Optimize algorithms and data structures
+- Add comprehensive error handling
+- Enhance documentation
+
+## Completion (complete)
+- Implement the final solution
+- Write comprehensive tests
+- Perform integration testing
+- Prepare for production deployment
+
+**Execute the specified SPARC phase for the given task with detailed analysis and recommendations.**

package/claude-assets/commands/cfn/suggest-improvements.md

@@ -0,0 +1,95 @@
+---
+description: "AI-powered project analysis with prioritized improvement recommendations"
+argument-hint: "[--focus=<area>|--quick|--detailed|--security]"
+allowed-tools: ["Read", "Bash", "Glob", "Grep", "mcp__claude-flow__language_detect", "mcp__claude-flow__framework_detect", "mcp__claude-flow__dependency_analyze", "mcp__claude-flow__rust_quality_analyze", "mcp__claude-flow__typescript_validate", "mcp__claude-flow__memory_usage", "mcp__claude-flow__agent_spawn"]
+---
+
+# AI Project Analysis & Improvement Suggestions
+
+Provide intelligent, prioritized recommendations for improving your codebase based on AI analysis.
+
+**Focus Area**: $ARGUMENTS
+
+## Analysis Options
+
+- `--focus=security` - Focus on security vulnerabilities and best practices
+- `--focus=performance` - Analyze performance bottlenecks and optimizations
+- `--focus=maintainability` - Code quality, readability, and maintainability
+- `--focus=testing` - Test coverage, quality, and missing test scenarios
+- `--quick` - Fast analysis with top 3-5 recommendations
+- `--detailed` - Comprehensive analysis with implementation guides
+- `--security` - Security-focused analysis with CVE scanning
+
+## What This Command Does
+
+### 🔍 Intelligent Codebase Analysis
+- **Framework-Aware**: Leverages 98.5% accurate framework detection
+- **Language-Specific**: Tailored recommendations for detected languages
+- **Context-Aware**: Understands project structure and patterns
+- **Risk Assessment**: Prioritizes improvements by impact and effort
+
+### 🎦 Analysis Categories
+
+#### Security Analysis
+- Dependency vulnerability scanning
+- Code security pattern detection
+- Authentication/authorization review
+- Input validation and sanitization
+
+#### Performance Analysis
+- Bundle size optimization opportunities
+- Database query optimization
+- Caching strategy improvements
+- Resource usage patterns
+
+#### Code Quality Analysis
+- Design pattern recommendations
+- Refactoring opportunities
+- Documentation gaps
+- Type safety improvements
+
+#### Testing Analysis
+- Coverage gap identification
+- Missing test scenarios
+- Test quality assessment
+- E2E testing opportunities
+
+## Sample Output
+
+```markdown
+## 🚨 High Priority (Security)
+1. **Update lodash dependency** - CVE-2021-23337 (Risk: High)
+   Command: `npm update lodash@^4.17.21`
+   
+2. **Add input validation** - Missing sanitization in user routes
+   Files: `src/routes/user.js`
+
+## 🚀 Medium Priority (Performance)
+1. **Implement code splitting** - Bundle size: 2.3MB
+   Framework: React with dynamic imports
+   
+2. **Add Redis caching** - Database queries: 150ms avg
+   Impact: 60% performance improvement
+
+## 🛠️ Low Priority (Maintenance)
+1. **Add TypeScript** - 89% of codebase would benefit
+2. **Update documentation** - API docs outdated
+```
+
+## Educational Focus
+
+Every recommendation includes:
+- **Why**: Explanation of the problem/opportunity
+- **Impact**: Expected improvement metrics
+- **How**: Specific implementation steps
+- **Resources**: Links to best practices and tutorials
+
+## Framework-Specific Recommendations
+
+- **Rust**: Clippy suggestions, unsafe code review, performance optimization
+- **JavaScript/Node.js**: NPM audit, bundle analysis, async/await patterns
+- **TypeScript**: Type coverage, strict mode opportunities
+- **Python**: Virtual environment setup, type hints, security scanning
+- **React**: Component optimization, state management, accessibility
+
+Get actionable, prioritized recommendations to improve your project's security, performance, and maintainability.

package/claude-assets/commands/cfn/suggest-templates.md

@@ -0,0 +1,147 @@
+---
+description: "Contextual code templates based on detected project patterns and frameworks"
+argument-hint: "[<component-type>|--list|--search=<pattern>|--category=<type>]"
+allowed-tools: ["Read", "Write", "Bash", "Glob", "Grep", "mcp__claude-flow__language_detect", "mcp__claude-flow__framework_detect", "mcp__claude-flow__memory_usage", "mcp__shadcn_mcp__generate_component"]
+---
+
+# Contextual Code Templates
+
+Generate relevant code templates based on your project's detected frameworks, patterns, and current context.
+
+**Template Type**: $ARGUMENTS
+
+## Template Options
+
+- `--list` - Show all available templates for detected framework
+- `--search=<pattern>` - Search templates by keyword or pattern
+- `--category=<type>` - Filter by category (component, service, test, config)
+- `<component-type>` - Generate specific component (e.g., "api-route", "react-component")
+
+## What This Command Does
+
+### 🎯 Smart Template Selection
+- **Framework Detection**: Automatically detects React, Express, FastAPI, Axum, etc.
+- **Pattern Recognition**: Analyzes existing code patterns and conventions
+- **Context-Aware**: Suggests templates relevant to current file/directory
+- **Best Practices**: Templates follow industry standards and conventions
+
+### 📋 Template Categories
+
+#### Frontend Templates
+- **React Components**: Functional components, hooks, context providers
+- **Vue Components**: Composition API, reactive patterns
+- **Angular Components**: Services, modules, guards
+- **Styling**: CSS modules, styled-components, Tailwind patterns
+
+#### Backend Templates
+- **REST APIs**: Express routes, FastAPI endpoints, Axum handlers
+- **Database**: Models, migrations, queries, repositories
+- **Authentication**: JWT middleware, OAuth flows, session management
+- **Testing**: Unit tests, integration tests, mocks
+
+#### Configuration Templates
+- **Build Tools**: Webpack, Vite, Rollup configurations
+- **CI/CD**: GitHub Actions, Docker, deployment scripts
+- **Environment**: .env templates, config management
+- **Documentation**: README patterns, API docs, changelogs
+
+## Framework-Specific Examples
+
+### React Project Detected
+```bash
+# Available templates:
+/suggest-templates --list
+# Output: react-component, react-hook, context-provider, test-component
+
+# Generate a React component
+/suggest-templates react-component
+# Creates: functional component with TypeScript, props interface, styling
+```
+
+### Express.js Project Detected
+```bash
+# Generate API route template
+/suggest-templates api-route
+# Creates: Express route with validation, error handling, documentation
+
+# Generate middleware template
+/suggest-templates middleware
+# Creates: Express middleware with proper error handling and logging
+```
+
+### Rust Project Detected
+```bash
+# Generate Axum handler
+/suggest-templates axum-handler
+# Creates: Async handler with proper error handling and serialization
+
+# Generate test module
+/suggest-templates rust-test
+# Creates: Test module with common test patterns and mocks
+```
+
+## Template Features
+
+### 🛠️ Smart Generation
+- **Project Conventions**: Follows your existing naming and structure patterns
+- **Dependency Integration**: Uses libraries already in your project
+- **Type Safety**: Generates TypeScript/Rust types when applicable
+- **Error Handling**: Includes proper error handling patterns
+
+### 📚 Educational Comments
+- **Best Practice Explanations**: Comments explain why patterns are used
+- **Common Pitfalls**: Warnings about potential issues
+- **Extension Points**: Suggestions for how to extend the template
+- **Performance Tips**: Optimization recommendations
+
+### 🔄 Template Customization
+- **Variable Substitution**: Replaces placeholders with project-specific values
+- **Conditional Sections**: Includes/excludes code based on project setup
+- **Style Matching**: Matches your existing code style (spaces/tabs, naming)
+
+## Sample Template Output
+
+```typescript
+// React Functional Component Template
+import React, { useState, useEffect } from 'react';
+import styles from './MyComponent.module.css';
+
+interface MyComponentProps {
+  // TODO: Define your props here
+  title?: string;
+}
+
+/**
+ * MyComponent - Brief description
+ * 
+ * Best Practices:
+ * - Use functional components with hooks
+ * - Keep components small and focused
+ * - Extract custom hooks for complex logic
+ */
+const MyComponent: React.FC<MyComponentProps> = ({ title = 'Default Title' }) => {
+  const [isLoading, setIsLoading] = useState(false);
+
+  useEffect(() => {
+    // TODO: Add your effect logic here
+  }, []);
+
+  return (
+    <div className={styles.container}>
+      <h2>{title}</h2>
+      {/* TODO: Add your component content */}
+    </div>
+  );
+};
+
+export default MyComponent;
+```
+
+## Integration with Tools
+
+- **shadcn/ui Integration**: Generate beautiful UI components when shadcn is detected
+- **Testing Framework**: Include appropriate test templates (Jest, Vitest, pytest)
+- **Documentation**: Generate component documentation and usage examples
+- **Storybook**: Include Storybook stories when detected
+
+Get contextual, educational code templates that follow your project's patterns and best practices.

package/claude-assets/commands/cfn/swarm.md

@@ -0,0 +1,24 @@
+---
+description: "AI swarm management and coordination"
+argument-hint: "<action> [parameters]"
+allowed-tools: ["mcp__claude-flow-novice__swarm_init", "mcp__claude-flow-novice__agent_spawn", "mcp__claude-flow-novice__task_orchestrate"]
+---
+
+# AI Swarm Management
+
+Execute AI swarm coordination and management tasks.
+
+**Command**: $ARGUMENTS
+
+**Available Actions**:
+- `init <topology> <count>` - Initialize swarm (mesh, hierarchical, ring, star)
+- `status` - Show swarm status and health
+- `spawn <type>` - Create specialized agent (researcher, coder, analyst, etc.)
+- `orchestrate "<task>"` - Coordinate task across swarm
+- `scale <count>` - Scale swarm to specified agent count
+- `destroy` - Gracefully shutdown swarm
+
+**Swarm Coordination**:
+Use the claude-flow-novice MCP tools to coordinate AI agent swarms for complex task execution. The swarm system supports multiple topologies and can auto-scale based on workload.
+
+Execute the requested swarm action and provide status updates on coordination progress.

package/claude-assets/commands/cfn/switch-api.md

@@ -0,0 +1,53 @@
+---
+description: Switch Main Chat and Task tool between Z.ai and Anthropic providers
+tags: [config, api, cost-optimization]
+---
+
+Switch Main Chat and Task() tool API provider between Z.ai (cost-optimized) and Anthropic (high-quality).
+
+**Important:** CLI agents always use Z.ai (from `.env`). This command only affects Main Chat and Task() spawned agents.
+
+**Usage:**
+- `/switch-api` - Show current status
+- `/switch-api zai` - Main Chat/Task tool use Z.ai ($0.50/1M tokens)
+- `/switch-api max` - Main Chat/Task tool use Anthropic ($15/1M tokens, requires re-login)
+
+**Arguments:**
+- `status` - Show current routing configuration (default)
+- `zai` - Route Main Chat + Task tool to Z.ai for cost savings
+- `max` or `claude` - Route Main Chat + Task tool to Anthropic for quality
+
+**What This Does:**
+
+`/switch-api zai`:
+- Adds env vars to `.claude/settings.json`
+- Main Chat + Task() agents use Z.ai
+- Cost: $0.50/1M tokens (97% savings)
+- No login required
+
+`/switch-api max`:
+- Removes env vars from `.claude/settings.json`
+- Main Chat + Task() agents use Anthropic
+- Cost: $15/1M tokens (or $0 with unlimited plan)
+- **Requires** running `claude login`
+
+**Combined Architecture:**
+```
+Main Chat (Anthropic or Z.ai - your choice)
+  ↓
+Task() → Coordinator (uses Main Chat provider)
+  ↓
+CLI spawn → Workers (always Z.ai from .env)
+```
+
+**Execute:**
+```bash
+bash scripts/switch-api.sh {{args}}
+```
+
+**Examples:**
+```bash
+/switch-api          # Show current routing
+/switch-api zai      # Cost-optimize Main Chat
+/switch-api max      # Quality-optimize Main Chat (requires re-login)
+```

package/claude-assets/commands/cfn/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.