claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.70

package/.claude/cache/agent-pool.json

@@ -0,0 +1,33 @@
+{
+  "agents": {
+    "coordinator": {
+      "min": 1,
+      "max": 3
+    },
+    "coder": {
+      "min": 2,
+      "max": 5
+    },
+    "researcher": {
+      "min": 1,
+      "max": 3
+    },
+    "analyst": {
+      "min": 1,
+      "max": 2
+    },
+    "tester": {
+      "min": 1,
+      "max": 2
+    }
+  },
+  "lifecycle": {
+    "idleTimeout": 300000,
+    "healthCheck": 30000,
+    "recycleAfter": 100
+  },
+  "resources": {
+    "maxMemoryPerAgent": 134217728,
+    "maxCpuPercent": 10
+  }
+}

package/.claude/cache/memory-optimization.json

@@ -0,0 +1,19 @@
+{
+  "connectionPool": {
+    "min": 2,
+    "max": 10,
+    "idleTimeout": 30000
+  },
+  "writeBatch": {
+    "size": 50,
+    "flushInterval": 1000
+  },
+  "readCache": {
+    "maxSize": 1000,
+    "ttl": 60000
+  },
+  "compression": {
+    "enabled": true,
+    "threshold": 1024
+  }
+}

package/.claude/cache/neural-optimization.json

@@ -0,0 +1,25 @@
+{
+  "predictionCache": {
+    "enabled": true,
+    "maxEntries": 10000,
+    "ttl": 300000
+  },
+  "preload": {
+    "models": [
+      "task_predictor",
+      "error_preventer",
+      "performance_optimizer"
+    ],
+    "warmup": true
+  },
+  "batching": {
+    "enabled": true,
+    "maxBatchSize": 100,
+    "maxWaitTime": 50
+  },
+  "wasm": {
+    "simd": true,
+    "threads": 4,
+    "memoryPages": 256
+  }
+}

package/.claude/cache/optimized-hooks.json

@@ -0,0 +1,19 @@
+{
+  "PreToolUse": [
+    {
+      "matcher": "Bash",
+      "hooks": [
+        {
+          "type": "batch",
+          "parallel": true,
+          "cache": true,
+          "commands": [
+            "npx claude-flow@alpha hooks pre-command --batch true",
+            "npx claude-flow@alpha memory store --batch true",
+            "npx claude-flow@alpha neural predict --cache true"
+          ]
+        }
+      ]
+    }
+  ]
+}

package/.claude/cache/parallel-processing.json

@@ -0,0 +1,26 @@
+{
+  "tasks": {
+    "maxConcurrent": 10,
+    "queueSize": 100,
+    "priorityLevels": 4
+  },
+  "fileOps": {
+    "readConcurrency": 20,
+    "writeConcurrency": 10,
+    "usePipelining": true
+  },
+  "network": {
+    "maxSockets": 50,
+    "keepAlive": true,
+    "timeout": 30000
+  },
+  "workers": {
+    "enabled": true,
+    "count": 4,
+    "taskTypes": [
+      "neural_training",
+      "data_processing",
+      "analysis"
+    ]
+  }
+}

package/.claude/commands/analysis/COMMAND_COMPLIANCE_REPORT.md

@@ -0,0 +1,54 @@
+# Analysis Commands Compliance Report
+
+## Overview
+Reviewed all command files in `.claude/commands/analysis/` directory to ensure proper usage of:
+- `mcp__claude-flow__*` tools (preferred)
+- `npx claude-flow` commands (as fallback)
+- No direct implementation calls
+
+## Files Reviewed
+
+### 1. token-efficiency.md
+**Status**: ✅ Updated
+**Changes Made**:
+- Replaced `npx ruv-swarm hook session-end --export-metrics` with proper MCP tool call
+- Updated to: `Tool: mcp__claude-flow__token_usage` with appropriate parameters
+- Maintained result format and context
+
+**Before**:
+```bash
+npx ruv-swarm hook session-end --export-metrics
+```
+
+**After**:
+```
+Tool: mcp__claude-flow__token_usage
+Parameters: {"operation": "session", "timeframe": "24h"}
+```
+
+### 2. performance-bottlenecks.md
+**Status**: ✅ Compliant (No changes needed)
+**Reason**: Already uses proper `mcp__claude-flow__task_results` tool format
+
+## Summary
+
+- **Total files reviewed**: 2
+- **Files updated**: 1
+- **Files already compliant**: 1
+- **Compliance rate after updates**: 100%
+
+## Compliance Patterns Enforced
+
+1. **MCP Tool Usage**: All direct tool calls now use `mcp__claude-flow__*` format
+2. **Parameter Format**: JSON parameters properly structured
+3. **Command Context**: Preserved original functionality and expected results
+4. **Documentation**: Maintained clarity and examples
+
+## Recommendations
+
+1. All analysis commands now follow the proper pattern
+2. No direct bash commands or implementation calls remain
+3. Token usage analysis properly integrated with MCP tools
+4. Performance analysis already using correct tool format
+
+The analysis directory is now fully compliant with the Claude Flow command standards.

package/.claude/commands/analysis/README.md

@@ -0,0 +1,9 @@
+# Analysis Commands
+
+Commands for analysis operations in Claude Flow.
+
+## Available Commands
+
+- [bottleneck-detect](./bottleneck-detect.md)
+- [token-usage](./token-usage.md)
+- [performance-report](./performance-report.md)

package/.claude/commands/analysis/bottleneck-detect.md

@@ -0,0 +1,162 @@
+# bottleneck detect
+
+Analyze performance bottlenecks in swarm operations and suggest optimizations.
+
+## Usage
+
+```bash
+npx claude-flow bottleneck detect [options]
+```
+
+## Options
+
+- `--swarm-id, -s <id>` - Analyze specific swarm (default: current)
+- `--time-range, -t <range>` - Analysis period: 1h, 24h, 7d, all (default: 1h)
+- `--threshold <percent>` - Bottleneck threshold percentage (default: 20)
+- `--export, -e <file>` - Export analysis to file
+- `--fix` - Apply automatic optimizations
+
+## Examples
+
+### Basic bottleneck detection
+
+```bash
+npx claude-flow bottleneck detect
+```
+
+### Analyze specific swarm
+
+```bash
+npx claude-flow bottleneck detect --swarm-id swarm-123
+```
+
+### Last 24 hours with export
+
+```bash
+npx claude-flow bottleneck detect -t 24h -e bottlenecks.json
+```
+
+### Auto-fix detected issues
+
+```bash
+npx claude-flow bottleneck detect --fix --threshold 15
+```
+
+## Metrics Analyzed
+
+### Communication Bottlenecks
+
+- Message queue delays
+- Agent response times
+- Coordination overhead
+- Memory access patterns
+
+### Processing Bottlenecks
+
+- Task completion times
+- Agent utilization rates
+- Parallel execution efficiency
+- Resource contention
+
+### Memory Bottlenecks
+
+- Cache hit rates
+- Memory access patterns
+- Storage I/O performance
+- Neural pattern loading
+
+### Network Bottlenecks
+
+- API call latency
+- MCP communication delays
+- External service timeouts
+- Concurrent request limits
+
+## Output Format
+
+```
+🔍 Bottleneck Analysis Report
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 Summary
+├── Time Range: Last 1 hour
+├── Agents Analyzed: 6
+├── Tasks Processed: 42
+└── Critical Issues: 2
+
+🚨 Critical Bottlenecks
+1. Agent Communication (35% impact)
+   └── coordinator → coder-1 messages delayed by 2.3s avg
+
+2. Memory Access (28% impact)
+   └── Neural pattern loading taking 1.8s per access
+
+⚠️ Warning Bottlenecks
+1. Task Queue (18% impact)
+   └── 5 tasks waiting > 10s for assignment
+
+💡 Recommendations
+1. Switch to hierarchical topology (est. 40% improvement)
+2. Enable memory caching (est. 25% improvement)
+3. Increase agent concurrency to 8 (est. 20% improvement)
+
+✅ Quick Fixes Available
+Run with --fix to apply:
+- Enable smart caching
+- Optimize message routing
+- Adjust agent priorities
+```
+
+## Automatic Fixes
+
+When using `--fix`, the following optimizations may be applied:
+
+1. **Topology Optimization**
+
+   - Switch to more efficient topology
+   - Adjust communication patterns
+   - Reduce coordination overhead
+
+2. **Caching Enhancement**
+
+   - Enable memory caching
+   - Optimize cache strategies
+   - Preload common patterns
+
+3. **Concurrency Tuning**
+
+   - Adjust agent counts
+   - Optimize parallel execution
+   - Balance workload distribution
+
+4. **Priority Adjustment**
+   - Reorder task queues
+   - Prioritize critical paths
+   - Reduce wait times
+
+## Performance Impact
+
+Typical improvements after bottleneck resolution:
+
+- **Communication**: 30-50% faster message delivery
+- **Processing**: 20-40% reduced task completion time
+- **Memory**: 40-60% fewer cache misses
+- **Overall**: 25-45% performance improvement
+
+## Integration with Claude Code
+
+```javascript
+// Check for bottlenecks in Claude Code
+mcp__claude-flow__bottleneck_detect {
+  timeRange: "1h",
+  threshold: 20,
+  autoFix: false
+}
+```
+
+## See Also
+
+- `performance report` - Detailed performance analysis
+- `token usage` - Token optimization analysis
+- `swarm monitor` - Real-time monitoring
+- `cache manage` - Cache optimization

package/.claude/commands/analysis/performance-bottlenecks.md

@@ -32,7 +32,7 @@ The post-task hook automatically analyzes:
 ### 3. Improvement Suggestions
 
 ```
-Tool: mcp__ruv-swarm__task_results
+Tool: mcp__claude-flow__task_results
 Parameters: {"taskId": "task-123", "format": "detailed"}
 
 Result includes:

package/.claude/commands/analysis/performance-report.md

@@ -0,0 +1,25 @@
+# performance-report
+
+Generate comprehensive performance reports for swarm operations.
+
+## Usage
+```bash
+npx claude-flow analysis performance-report [options]
+```
+
+## Options
+- `--format <type>` - Report format (json, html, markdown)
+- `--include-metrics` - Include detailed metrics
+- `--compare <id>` - Compare with previous swarm
+
+## Examples
+```bash
+# Generate HTML report
+npx claude-flow analysis performance-report --format html
+
+# Compare swarms
+npx claude-flow analysis performance-report --compare swarm-123
+
+# Full metrics report
+npx claude-flow analysis performance-report --include-metrics --format markdown
+```

package/.claude/commands/analysis/token-efficiency.md

@@ -19,7 +19,8 @@ Reduce token consumption while maintaining quality through intelligent coordinat
 
 ```bash
 # Check token savings after session
-npx ruv-swarm hook session-end --export-metrics
+Tool: mcp__claude-flow__token_usage
+Parameters: {"operation": "session", "timeframe": "24h"}
 
 # Result shows:
 {

package/.claude/commands/analysis/token-usage.md

@@ -0,0 +1,25 @@
+# token-usage
+
+Analyze token usage patterns and optimize for efficiency.
+
+## Usage
+```bash
+npx claude-flow analysis token-usage [options]
+```
+
+## Options
+- `--period <time>` - Analysis period (1h, 24h, 7d, 30d)
+- `--by-agent` - Break down by agent
+- `--by-operation` - Break down by operation type
+
+## Examples
+```bash
+# Last 24 hours token usage
+npx claude-flow analysis token-usage --period 24h
+
+# By agent breakdown
+npx claude-flow analysis token-usage --by-agent
+
+# Export detailed report
+npx claude-flow analysis token-usage --period 7d --export tokens.csv
+```

package/.claude/commands/automation/README.md

@@ -0,0 +1,9 @@
+# Automation Commands
+
+Commands for automation operations in Claude Flow.
+
+## Available Commands
+
+- [auto-agent](./auto-agent.md)
+- [smart-spawn](./smart-spawn.md)
+- [workflow-select](./workflow-select.md)

package/.claude/commands/automation/auto-agent.md

@@ -0,0 +1,122 @@
+# auto agent
+
+Automatically spawn and manage agents based on task requirements.
+
+## Usage
+
+```bash
+npx claude-flow auto agent [options]
+```
+
+## Options
+
+- `--task, -t <description>` - Task description for agent analysis
+- `--max-agents, -m <number>` - Maximum agents to spawn (default: auto)
+- `--min-agents <number>` - Minimum agents required (default: 1)
+- `--strategy, -s <type>` - Selection strategy: optimal, minimal, balanced
+- `--no-spawn` - Analyze only, don't spawn agents
+
+## Examples
+
+### Basic auto-spawning
+
+```bash
+npx claude-flow auto agent --task "Build a REST API with authentication"
+```
+
+### Constrained spawning
+
+```bash
+npx claude-flow auto agent -t "Debug performance issue" --max-agents 3
+```
+
+### Analysis only
+
+```bash
+npx claude-flow auto agent -t "Refactor codebase" --no-spawn
+```
+
+### Minimal strategy
+
+```bash
+npx claude-flow auto agent -t "Fix bug in login" -s minimal
+```
+
+## How It Works
+
+1. **Task Analysis**
+
+   - Parses task description
+   - Identifies required skills
+   - Estimates complexity
+   - Determines parallelization opportunities
+
+2. **Agent Selection**
+
+   - Matches skills to agent types
+   - Considers task dependencies
+   - Optimizes for efficiency
+   - Respects constraints
+
+3. **Topology Selection**
+
+   - Chooses optimal swarm structure
+   - Configures communication patterns
+   - Sets up coordination rules
+   - Enables monitoring
+
+4. **Automatic Spawning**
+   - Creates selected agents
+   - Assigns specific roles
+   - Distributes subtasks
+   - Initiates coordination
+
+## Agent Types Selected
+
+- **Architect**: System design, architecture decisions
+- **Coder**: Implementation, code generation
+- **Tester**: Test creation, quality assurance
+- **Analyst**: Performance, optimization
+- **Researcher**: Documentation, best practices
+- **Coordinator**: Task management, progress tracking
+
+## Strategies
+
+### Optimal
+
+- Maximum efficiency
+- May spawn more agents
+- Best for complex tasks
+- Highest resource usage
+
+### Minimal
+
+- Minimum viable agents
+- Conservative approach
+- Good for simple tasks
+- Lowest resource usage
+
+### Balanced
+
+- Middle ground
+- Adaptive to complexity
+- Default strategy
+- Good performance/resource ratio
+
+## Integration with Claude Code
+
+```javascript
+// In Claude Code after auto-spawning
+mcp__claude-flow__auto_agent {
+  task: "Build authentication system",
+  strategy: "balanced",
+  maxAgents: 6
+}
+```
+
+## See Also
+
+- `agent spawn` - Manual agent creation
+- `swarm init` - Initialize swarm manually
+- `smart spawn` - Intelligent agent spawning
+- `workflow select` - Choose predefined workflows

package/.claude/commands/automation/self-healing.md

@@ -44,12 +44,57 @@ Each recovery improves future prevention:
 - Similar errors prevented proactively
 - Recovery strategies optimized
 
-## Hook Integration
+**Pattern Storage:**
+```javascript
+// Store error patterns
+mcp__claude-flow__memory_usage({
+  "action": "store",
+  "key": "error-pattern-" + Date.now(),
+  "value": JSON.stringify(errorData),
+  "namespace": "error-patterns",
+  "ttl": 2592000 // 30 days
+})
+
+// Analyze patterns
+mcp__claude-flow__neural_patterns({
+  "action": "analyze",
+  "operation": "error-recovery",
+  "outcome": "success"
+})
+```
+
+## Self-Healing Integration
+
+### MCP Tool Coordination
+```javascript
+// Initialize self-healing swarm
+mcp__claude-flow__swarm_init({
+  "topology": "star",
+  "maxAgents": 4,
+  "strategy": "adaptive"
+})
+
+// Spawn recovery agents
+mcp__claude-flow__agent_spawn({
+  "type": "monitor",
+  "name": "Error Monitor",
+  "capabilities": ["error-detection", "recovery"]
+})
+
+// Orchestrate recovery
+mcp__claude-flow__task_orchestrate({
+  "task": "recover from error",
+  "strategy": "sequential",
+  "priority": "critical"
+})
+```
+
+### Fallback Hook Configuration
 ```json
 {
   "PostToolUse": [{
     "matcher": "^Bash$",
-    "command": "npx ruv-swarm hook post-bash --exit-code '${tool.result.exitCode}' --auto-recover"
+    "command": "npx claude-flow hook post-bash --exit-code '${tool.result.exitCode}' --auto-recover"
   }]
 }
 ```

package/.claude/commands/automation/session-memory.md

@@ -14,12 +14,23 @@ At session end, automatically saves:
 - Knowledge base updates
 
 ### 2. Session Restoration
-```bash
-# New session automatically loads previous state
-claude "Continue where we left off"
+```javascript
+// Using MCP tools for memory operations
+mcp__claude-flow__memory_usage({
+  "action": "retrieve",
+  "key": "session-state",
+  "namespace": "sessions"
+})
 
-# Or manually restore specific session
-npx ruv-swarm hook session-restore --session-id "sess-123"
+// Restore swarm state
+mcp__claude-flow__context_restore({
+  "snapshotId": "sess-123"
+})
+```
+
+**Fallback with npx:**
+```bash
+npx claude-flow hook session-restore --session-id "sess-123"
 ```
 
 ### 3. Memory Types
@@ -43,15 +54,33 @@ npx ruv-swarm hook session-restore --session-id "sess-123"
 - Efficiency trends
 
 ### 4. Privacy & Control
+```javascript
+// List memory contents
+mcp__claude-flow__memory_usage({
+  "action": "list",
+  "namespace": "sessions"
+})
+
+// Delete specific memory
+mcp__claude-flow__memory_usage({
+  "action": "delete",
+  "key": "session-123",
+  "namespace": "sessions"
+})
+
+// Backup memory
+mcp__claude-flow__memory_backup({
+  "path": "./backups/memory-backup.json"
+})
+```
+
+**Manual control:**
 ```bash
 # View stored memory
-ls .ruv-swarm/
-
-# Clear specific memory
-rm .ruv-swarm/session-*.json
+ls .claude-flow/memory/
 
 # Disable memory
-export RUV_SWARM_MEMORY_PERSIST=false
+export CLAUDE_FLOW_MEMORY_PERSIST=false
 ```
 
 ## Benefits