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

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/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/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/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

package/.claude/commands/automation/smart-agents.md

@@ -27,15 +27,43 @@ The system monitors workload and spawns additional agents when:
 - Complexity increases
 - Parallel opportunities exist
 
+**Status Monitoring:**
+```javascript
+// Check swarm health
+mcp__claude-flow__swarm_status({
+  "swarmId": "current"
+})
+
+// Monitor agent performance
+mcp__claude-flow__agent_metrics({
+  "agentId": "agent-123"
+})
+```
+
 ## Configuration
-Already enabled in settings.json:
-```json
-{
-  "hooks": [{
-    "matcher": "^Task$",
-    "command": "npx ruv-swarm hook pre-task --auto-spawn-agents"
-  }]
-}
+
+### MCP Tool Integration
+Uses Claude Flow MCP tools for agent coordination:
+```javascript
+// Initialize swarm with appropriate topology
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 8,
+  "strategy": "auto"
+})
+
+// Spawn agents based on file type
+mcp__claude-flow__agent_spawn({
+  "type": "coder",
+  "name": "JavaScript Handler",
+  "capabilities": ["javascript", "typescript"]
+})
+```
+
+### Fallback Configuration
+If MCP tools are unavailable:
+```bash
+npx claude-flow hook pre-task --auto-spawn-agents
 ```
 
 ## Benefits

package/.claude/commands/coordination/init.md

@@ -5,7 +5,7 @@
 
 ## MCP Tool Usage in Claude Code
 
-**Tool:** `mcp__ruv-swarm__swarm_init`
+**Tool:** `mcp__claude-flow__swarm_init`
 
 ## Parameters
 ```json
@@ -27,7 +27,7 @@ Remember: This does NOT create actual coding agents. It creates a coordination p
 ## Example Usage
 
 **In Claude Code:**
-1. Use the tool: `mcp__ruv-swarm__swarm_init`
+1. Use the tool: `mcp__claude-flow__swarm_init`
 2. With parameters: `{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}`
 3. Claude Code then executes the coordinated plan using its native tools
 

package/.claude/commands/coordination/orchestrate.md

@@ -5,7 +5,7 @@
 
 ## MCP Tool Usage in Claude Code
 
-**Tool:** `mcp__ruv-swarm__task_orchestrate`
+**Tool:** `mcp__claude-flow__task_orchestrate`
 
 ## Parameters
 ```json
@@ -26,7 +26,7 @@ The orchestrator creates a plan that Claude Code follows using its native tools.
 ## Example Usage
 
 **In Claude Code:**
-1. Use the tool: `mcp__ruv-swarm__task_orchestrate`
+1. Use the tool: `mcp__claude-flow__task_orchestrate`
 2. With parameters: `{"task": "Implement authentication system", "strategy": "parallel", "priority": "high"}`
 3. Claude Code then executes the coordinated plan using its native tools
 

package/.claude/commands/coordination/spawn.md

@@ -5,7 +5,7 @@
 
 ## MCP Tool Usage in Claude Code
 
-**Tool:** `mcp__ruv-swarm__agent_spawn`
+**Tool:** `mcp__claude-flow__agent_spawn`
 
 ## Parameters
 ```json
@@ -28,7 +28,7 @@ These patterns guide how Claude Code approaches different aspects of your task.
 ## Example Usage
 
 **In Claude Code:**
-1. Use the tool: `mcp__ruv-swarm__agent_spawn`
+1. Use the tool: `mcp__claude-flow__agent_spawn`
 2. With parameters: `{"type": "researcher", "name": "Literature Analysis", "capabilities": ["deep-analysis"]}`
 3. Claude Code then executes the coordinated plan using its native tools
 

package/.claude/commands/github/code-review-swarm.md

@@ -7,24 +7,48 @@ Deploy specialized AI agents to perform comprehensive, intelligent code reviews
 
 ### 1. Multi-Agent Review System
 ```bash
-# Initialize code review swarm
+# Initialize code review swarm with gh CLI
+# Get PR details
+PR_DATA=$(gh pr view 123 --json files,additions,deletions,title,body)
+PR_DIFF=$(gh pr diff 123)
+
+# Initialize swarm with PR context
 npx ruv-swarm github review-init \
   --pr 123 \
+  --pr-data "$PR_DATA" \
+  --diff "$PR_DIFF" \
   --agents "security,performance,style,architecture,accessibility" \
-  --depth comprehensive \
-  --post-comments
+  --depth comprehensive
+
+# Post initial review status
+gh pr comment 123 --body "🔍 Multi-agent code review initiated"
 ```
 
 ### 2. Specialized Review Agents
 
 #### Security Agent
 ```bash
-# Security-focused review
-npx ruv-swarm github review-security \
+# Security-focused review with gh CLI
+# Get changed files
+CHANGED_FILES=$(gh pr view 123 --json files --jq '.files[].path')
+
+# Run security review
+SECURITY_RESULTS=$(npx ruv-swarm github review-security \
   --pr 123 \
+  --files "$CHANGED_FILES" \
   --check "owasp,cve,secrets,permissions" \
-  --suggest-fixes \
-  --block-if-critical
+  --suggest-fixes)
+
+# Post security findings
+if echo "$SECURITY_RESULTS" | grep -q "critical"; then
+  # Request changes for critical issues
+  gh pr review 123 --request-changes --body "$SECURITY_RESULTS"
+  # Add security label
+  gh pr edit 123 --add-label "security-review-required"
+else
+  # Post as comment for non-critical issues
+  gh pr comment 123 --body "$SECURITY_RESULTS"
+fi
 ```
 
 #### Performance Agent
@@ -223,12 +247,30 @@ jobs:
         with:
           fetch-depth: 0
           
+      - name: Setup GitHub CLI
+        run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
+          
       - name: Run Review Swarm
-        uses: ruvnet/review-swarm-action@v1
-        with:
-          agents: all
-          post-comments: true
-          update-status: true
+        run: |
+          # Get PR context with gh CLI
+          PR_NUM=${{ github.event.pull_request.number }}
+          PR_DATA=$(gh pr view $PR_NUM --json files,title,body,labels)
+          
+          # Run swarm review
+          REVIEW_OUTPUT=$(npx ruv-swarm github review-all \
+            --pr $PR_NUM \
+            --pr-data "$PR_DATA" \
+            --agents "security,performance,style,architecture")
+          
+          # Post review results
+          echo "$REVIEW_OUTPUT" | gh pr review $PR_NUM --comment -F -
+          
+          # Update PR status
+          if echo "$REVIEW_OUTPUT" | grep -q "approved"; then
+            gh pr review $PR_NUM --approve
+          elif echo "$REVIEW_OUTPUT" | grep -q "changes-requested"; then
+            gh pr review $PR_NUM --request-changes -b "See review comments above"
+          fi
 ```
 
 ### Review Triggers
@@ -259,12 +301,35 @@ jobs:
 
 ### Intelligent Comment Generation
 ```bash
-# Generate contextual review comments
-npx ruv-swarm github review-comment \
+# Generate contextual review comments with gh CLI
+# Get PR diff with context
+PR_DIFF=$(gh pr diff 123 --color never)
+PR_FILES=$(gh pr view 123 --json files)
+
+# Generate review comments
+COMMENTS=$(npx ruv-swarm github review-comment \
   --pr 123 \
+  --diff "$PR_DIFF" \
+  --files "$PR_FILES" \
   --style "constructive" \
   --include-examples \
-  --suggest-fixes
+  --suggest-fixes)
+
+# Post comments using gh CLI
+echo "$COMMENTS" | jq -c '.[]' | while read -r comment; do
+  FILE=$(echo "$comment" | jq -r '.path')
+  LINE=$(echo "$comment" | jq -r '.line')
+  BODY=$(echo "$comment" | jq -r '.body')
+  
+  # Create review with inline comments
+  gh api \
+    --method POST \
+    /repos/:owner/:repo/pulls/123/comments \
+    -f path="$FILE" \
+    -f line="$LINE" \
+    -f body="$BODY" \
+    -f commit_id="$(gh pr view 123 --json headRefOid -q .headRefOid)"
+done
 ```
 
 ### Comment Templates