claude-flow-novice 2.13.0 → 2.14.1

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

@@ -0,0 +1,41 @@
+---
+description: "Performance monitoring and optimization"
+argument-hint: "<action> [component]"
+allowed-tools: ["mcp__claude-flow-novice__performance_report", "mcp__claude-flow-novice__bottleneck_analyze", "mcp__claude-flow-novice__health_check"]
+---
+
+# Performance Monitoring & Optimization
+
+Monitor system performance, identify bottlenecks, and optimize operations.
+
+**Action**: $ARGUMENTS
+
+**Available Performance Actions**:
+- `report` - Generate comprehensive performance report
+- `benchmark [type]` - Run performance benchmarks
+- `bottleneck [component]` - Identify performance bottlenecks
+- `tokens` - Analyze token consumption patterns
+- `trends` - Show performance trends over time
+- `optimize` - Auto-optimize system performance
+
+**Performance Metrics**:
+
+## System Performance
+- **Memory Usage**: RAM and cache utilization
+- **CPU Performance**: Processing efficiency
+- **I/O Operations**: File and network operations
+- **Agent Coordination**: Swarm performance metrics
+
+## Optimization Areas
+- **Token Efficiency**: Reduce token consumption
+- **Parallel Execution**: Multi-agent coordination
+- **Cache Management**: Memory optimization
+- **Resource Allocation**: Dynamic scaling
+
+## Monitoring Features
+- **Real-time Metrics**: Live performance data
+- **Trend Analysis**: Historical performance patterns
+- **Bottleneck Detection**: Automated issue identification
+- **SLA Monitoring**: Service level tracking
+
+Execute performance analysis and provide actionable optimization recommendations.

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.