claude-flow-novice 2.14.0 → 2.14.2

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