claude-flow-novice 1.1.9 → 1.2.0

package/.claude/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/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/commands/swarm.js

@@ -0,0 +1,423 @@
+#!/usr/bin/env node
+
+/**
+ * Swarm Management Slash Command
+ * Usage: /swarm <action> [options]
+ */
+
+import { SlashCommand } from '../core/slash-command.js';
+
+export class SwarmCommand extends SlashCommand {
+  constructor() {
+    super('swarm', 'Manage AI agent swarms with various topologies and coordination patterns');
+  }
+
+  getUsage() {
+    return '/swarm <action> [options]';
+  }
+
+  getExamples() {
+    return [
+      '/swarm init mesh 8 - Initialize mesh topology with 8 agents',
+      '/swarm status - Get current swarm status',
+      '/swarm spawn researcher - Spawn a researcher agent',
+      '/swarm orchestrate "Build REST API" - Orchestrate a task',
+      '/swarm monitor - Monitor swarm activity',
+      '/swarm scale 12 - Scale swarm to 12 agents',
+      '/swarm destroy - Gracefully shutdown swarm'
+    ];
+  }
+
+  async execute(args, context) {
+    const [action, ...params] = args;
+
+    if (!action) {
+      return this.formatResponse({
+        success: false,
+        error: 'Action required',
+        usage: this.getUsage(),
+        availableActions: [
+          'init', 'status', 'spawn', 'orchestrate', 'monitor', 'scale', 'destroy'
+        ]
+      });
+    }
+
+    try {
+      let result;
+
+      switch (action.toLowerCase()) {
+        case 'init':
+          result = await this.initSwarm(params);
+          break;
+        
+        case 'status':
+          result = await this.getStatus(params);
+          break;
+        
+        case 'spawn':
+          result = await this.spawnAgent(params);
+          break;
+        
+        case 'orchestrate':
+          result = await this.orchestrateTask(params);
+          break;
+        
+        case 'monitor':
+          result = await this.monitorSwarm(params);
+          break;
+        
+        case 'scale':
+          result = await this.scaleSwarm(params);
+          break;
+        
+        case 'destroy':
+          result = await this.destroySwarm(params);
+          break;
+        
+        default:
+          result = {
+            success: false,
+            error: `Unknown action: ${action}`,
+            availableActions: [
+              'init', 'status', 'spawn', 'orchestrate', 'monitor', 'scale', 'destroy'
+            ]
+          };
+      }
+
+      return this.formatResponse(result);
+    } catch (error) {
+      return this.formatResponse({
+        success: false,
+        error: error.message,
+        action: action
+      });
+    }
+  }
+
+  async initSwarm(params) {
+    const [topology = 'mesh', maxAgents = '8', strategy = 'balanced'] = params;
+
+    const validTopologies = ['mesh', 'hierarchical', 'ring', 'star'];
+    if (!validTopologies.includes(topology)) {
+      return {
+        success: false,
+        error: `Invalid topology. Valid options: ${validTopologies.join(', ')}`
+      };
+    }
+
+    const agentCount = parseInt(maxAgents);
+    if (isNaN(agentCount) || agentCount < 1 || agentCount > 100) {
+      return {
+        success: false,
+        error: 'Agent count must be between 1 and 100'
+      };
+    }
+
+    console.log(`🚀 Initializing ${topology} swarm with ${agentCount} agents...`);
+
+    const prompt = `
+🚀 **SWARM INITIALIZATION**
+
+**Configuration:**
+- Topology: ${topology}
+- Max Agents: ${agentCount}
+- Strategy: ${strategy}
+
+**Initialize the swarm with MCP tools:**
+
+\`\`\`javascript
+// Step 1: Initialize swarm coordination
+mcp__claude-flow__swarm_init({
+  topology: "${topology}",
+  maxAgents: ${agentCount},
+  strategy: "${strategy}"
+});
+
+// Step 2: Set up agent coordination patterns
+mcp__claude-flow__coordination_sync({ swarmId: "swarm-${Date.now()}" });
+\`\`\`
+
+**Then use Claude Code's Task tool to spawn actual working agents:**
+\`\`\`javascript
+Task("Coordinator Agent", "Coordinate swarm activities and task distribution", "coordinator")
+Task("Research Agent", "Analyze requirements and gather information", "researcher")
+Task("Coder Agent", "Implement code and solutions", "coder")
+Task("Tester Agent", "Create and run comprehensive tests", "tester")
+\`\`\`
+
+**Execute this swarm initialization now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      topology: topology,
+      maxAgents: agentCount,
+      strategy: strategy,
+      swarmId: `swarm-${Date.now()}`
+    };
+  }
+
+  async getStatus(params) {
+    const [verbose = 'false'] = params;
+    const isVerbose = verbose.toLowerCase() === 'true';
+
+    console.log('📊 Getting swarm status...');
+
+    const prompt = `
+📊 **SWARM STATUS CHECK**
+
+**Get current swarm information:**
+
+\`\`\`javascript
+// Check swarm status with MCP tools
+mcp__claude-flow__swarm_status({ verbose: ${isVerbose} });
+
+// Get agent metrics
+mcp__claude-flow__agent_metrics({ metric: "all" });
+
+// Check active tasks
+mcp__claude-flow__task_status({ detailed: ${isVerbose} });
+\`\`\`
+
+**Execute this status check now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      verbose: isVerbose
+    };
+  }
+
+  async spawnAgent(params) {
+    const [type, ...nameParams] = params;
+    const name = nameParams.join(' ');
+
+    if (!type) {
+      return {
+        success: false,
+        error: 'Agent type required',
+        availableTypes: [
+          'researcher', 'coder', 'analyst', 'optimizer', 'coordinator',
+          'tester', 'reviewer', 'architect', 'documenter'
+        ]
+      };
+    }
+
+    console.log(`🤖 Spawning ${type} agent${name ? ` named "${name}"` : ''}...`);
+
+    const prompt = `
+🤖 **SPAWN AGENT**
+
+**Agent Configuration:**
+- Type: ${type}
+- Name: ${name || `${type}-${Date.now()}`}
+
+**Use both MCP coordination and Claude Code execution:**
+
+\`\`\`javascript
+// Step 1: Register agent with MCP coordination
+mcp__claude-flow__agent_spawn({
+  type: "${type}",
+  name: "${name || `${type}-${Date.now()}`}",
+  capabilities: ["${type}-specific-capabilities"]
+});
+
+// Step 2: Spawn actual working agent with Claude Code's Task tool
+Task("${name || `${type} Agent`}", "Execute ${type} tasks with coordination hooks", "${type}")
+\`\`\`
+
+**Agent Instructions:**
+The agent should use hooks for coordination:
+- Pre-task: \`npx claude-flow@alpha hooks pre-task\`
+- Post-edit: \`npx claude-flow@alpha hooks post-edit\`
+- Post-task: \`npx claude-flow@alpha hooks post-task\`
+
+**Execute this agent spawn now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      agentType: type,
+      agentName: name || `${type}-${Date.now()}`
+    };
+  }
+
+  async orchestrateTask(params) {
+    const task = params.join(' ');
+
+    if (!task) {
+      return {
+        success: false,
+        error: 'Task description required'
+      };
+    }
+
+    console.log(`🎯 Orchestrating task: ${task}`);
+
+    const prompt = `
+🎯 **TASK ORCHESTRATION**
+
+**Task:** ${task}
+
+**Orchestrate with coordinated agents:**
+
+\`\`\`javascript
+// Step 1: Set up task orchestration
+mcp__claude-flow__task_orchestrate({
+  task: "${task}",
+  strategy: "adaptive",
+  priority: "high"
+});
+
+// Step 2: Spawn coordinated agents with Claude Code's Task tool
+Task("Task Coordinator", "Break down and coordinate: ${task}", "coordinator")
+Task("Implementation Agent", "Execute main implementation for: ${task}", "coder")
+Task("Quality Agent", "Ensure quality and testing for: ${task}", "tester")
+Task("Review Agent", "Review and validate: ${task}", "reviewer")
+\`\`\`
+
+**Coordination Protocol:**
+1. Each agent uses hooks for coordination
+2. Shared memory for context and progress
+3. Automatic load balancing and optimization
+
+**Execute this task orchestration now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      task: task,
+      taskId: `task-${Date.now()}`
+    };
+  }
+
+  async monitorSwarm(params) {
+    const [duration = '30'] = params;
+    const monitorDuration = parseInt(duration);
+
+    console.log(`👁️ Monitoring swarm for ${monitorDuration} seconds...`);
+
+    const prompt = `
+👁️ **SWARM MONITORING**
+
+**Monitor swarm activity:**
+
+\`\`\`javascript
+// Real-time swarm monitoring
+mcp__claude-flow__swarm_monitor({
+  interval: 5,
+  duration: ${monitorDuration}
+});
+
+// Performance metrics
+mcp__claude-flow__performance_report({ format: "detailed" });
+
+// Agent performance
+mcp__claude-flow__agent_metrics({ metric: "performance" });
+\`\`\`
+
+**Monitoring Dashboard:**
+- Agent status and performance
+- Task progress and completion
+- Resource utilization
+- Coordination efficiency
+
+**Execute this monitoring now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      duration: monitorDuration
+    };
+  }
+
+  async scaleSwarm(params) {
+    const [targetSize] = params;
+    const newSize = parseInt(targetSize);
+
+    if (isNaN(newSize) || newSize < 1 || newSize > 100) {
+      return {
+        success: false,
+        error: 'Target size must be between 1 and 100'
+      };
+    }
+
+    console.log(`📈 Scaling swarm to ${newSize} agents...`);
+
+    const prompt = `
+📈 **SWARM SCALING**
+
+**Scale to ${newSize} agents:**
+
+\`\`\`javascript
+// Auto-scale swarm
+mcp__claude-flow__swarm_scale({
+  targetSize: ${newSize}
+});
+
+// Optimize topology for new size
+mcp__claude-flow__topology_optimize();
+
+// Rebalance tasks
+mcp__claude-flow__load_balance({ tasks: ["current-tasks"] });
+\`\`\`
+
+**Scaling Strategy:**
+- Graceful addition/removal of agents
+- Automatic task redistribution
+- Topology optimization
+- Performance monitoring
+
+**Execute this scaling now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      targetSize: newSize
+    };
+  }
+
+  async destroySwarm(params) {
+    console.log('🛑 Destroying swarm...');
+
+    const prompt = `
+🛑 **SWARM DESTRUCTION**
+
+**Gracefully shutdown swarm:**
+
+\`\`\`javascript
+// Step 1: Complete current tasks
+mcp__claude-flow__task_status({ detailed: true });
+
+// Step 2: Save state and metrics
+mcp__claude-flow__state_snapshot({ name: "final-state" });
+
+// Step 3: Destroy swarm
+mcp__claude-flow__swarm_destroy();
+\`\`\`
+
+**Shutdown Checklist:**
+- ✅ Complete active tasks
+- ✅ Save coordination state
+- ✅ Export performance metrics
+- ✅ Clean up resources
+- ✅ Graceful agent termination
+
+**Execute this shutdown now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      action: 'destroy'
+    };
+  }
+}
+
+export default SwarmCommand;

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