@sparkleideas/claude-flow 3.5.2-patch.1

package/.claude/commands/hooks/setup.md

@@ -0,0 +1,103 @@
+# Setting Up ruv-swarm Hooks
+
+## Quick Start
+
+### 1. Initialize with Hooks
+```bash
+npx claude-flow init --hooks
+```
+
+This automatically creates:
+- `.claude/settings.json` with hook configurations
+- Hook command documentation
+- Default hook handlers
+
+### 2. Test Hook Functionality
+```bash
+# Test pre-edit hook
+npx claude-flow hook pre-edit --file test.js
+
+# Test session summary
+npx claude-flow hook session-end --summary
+```
+
+### 3. Customize Hooks
+
+Edit `.claude/settings.json` to customize:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "^Write$",
+        "hooks": [{
+          "type": "command",
+          "command": "npx claude-flow hook pre-write --file '${tool.params.file_path}'"
+        }]
+      }
+    ]
+  }
+}
+```
+
+## Hook Response Format
+
+Hooks return JSON with:
+- `continue`: Whether to proceed (true/false)
+- `reason`: Explanation for decision
+- `metadata`: Additional context
+
+Example blocking response:
+```json
+{
+  "continue": false,
+  "reason": "Protected file - manual review required",
+  "metadata": {
+    "file": ".env.production",
+    "protection_level": "high"
+  }
+}
+```
+
+## Performance Tips
+- Keep hooks lightweight (< 100ms)
+- Use caching for repeated operations
+- Batch related operations
+- Run non-critical hooks asynchronously
+
+## Debugging Hooks
+```bash
+# Enable debug output
+export CLAUDE_FLOW_DEBUG=true
+
+# Test specific hook
+npx claude-flow hook pre-edit --file app.js --debug
+```
+
+## Common Patterns
+
+### Auto-Format on Save
+Already configured by default for common file types.
+
+### Protected File Detection
+```json
+{
+  "matcher": "^(Write|Edit)$",
+  "hooks": [{
+    "type": "command",
+    "command": "npx claude-flow hook check-protected --file '${tool.params.file_path}'"
+  }]
+}
+```
+
+### Automatic Testing
+```json
+{
+  "matcher": "^Write$",
+  "hooks": [{
+    "type": "command",
+    "command": "test -f '${tool.params.file_path%.js}.test.js' && npm test '${tool.params.file_path%.js}.test.js'"
+  }]
+}
+```

package/.claude/commands/improved-workflows.js

@@ -0,0 +1,76 @@
+
+/**
+ * Improved Workflow Commands
+ * Generated by Training Pipeline
+ * Best Strategy: balanced
+ */
+
+export const improvedWorkflows = {
+  strategy: 'balanced',
+  
+  execute: async (task) => {
+    // Use learned optimal configuration
+    const config = {
+  "successRate": 0.8548781869890831,
+  "avgScore": 89.5490481124677,
+  "avgExecutionTime": 27.931191563699983,
+  "uses": 12,
+  "trend": [
+    {
+      "score": 77.72222222222221,
+      "timestamp": "2025-08-12T16:41:35.236Z"
+    },
+    {
+      "score": 77.72222222222221,
+      "timestamp": "2025-08-12T16:41:35.241Z"
+    },
+    {
+      "score": 91.05455555555557,
+      "timestamp": "2025-08-12T16:41:35.246Z"
+    },
+    {
+      "score": 91.05455555555555,
+      "timestamp": "2025-08-12T16:41:37.860Z"
+    },
+    {
+      "score": 88.83333333333333,
+      "timestamp": "2025-08-12T16:41:37.865Z"
+    },
+    {
+      "score": 88.83333333333333,
+      "timestamp": "2025-08-12T16:41:37.870Z"
+    },
+    {
+      "score": 88.83233333333334,
+      "timestamp": "2025-08-12T16:41:39.923Z"
+    },
+    {
+      "score": 88.83233333333334,
+      "timestamp": "2025-08-12T16:41:39.929Z"
+    },
+    {
+      "score": 84.38888888888889,
+      "timestamp": "2025-08-12T16:41:39.934Z"
+    },
+    {
+      "score": 91.05355555555555,
+      "timestamp": "2025-08-12T16:43:01.248Z"
+    },
+    {
+      "score": 91.05555555555554,
+      "timestamp": "2025-08-12T16:43:01.253Z"
+    },
+    {
+      "score": 91.05455555555555,
+      "timestamp": "2025-08-12T16:43:01.258Z"
+    }
+  ]
+};
+    
+    // Apply learned optimizations
+    console.log('Using optimized strategy: balanced');
+    
+    // Execute with improved parameters
+    return await executeWithConfig(task, config);
+  }
+};

package/.claude/commands/monitoring/README.md

@@ -0,0 +1,9 @@
+# Monitoring Commands
+
+Commands for monitoring operations in Claude Flow.
+
+## Available Commands
+
+- [swarm-monitor](./swarm-monitor.md)
+- [agent-metrics](./agent-metrics.md)
+- [real-time-view](./real-time-view.md)

package/.claude/commands/monitoring/agent-metrics.md

@@ -0,0 +1,25 @@
+# agent-metrics
+
+View agent performance metrics.
+
+## Usage
+```bash
+npx claude-flow agent metrics [options]
+```
+
+## Options
+- `--agent-id <id>` - Specific agent
+- `--period <time>` - Time period
+- `--format <type>` - Output format
+
+## Examples
+```bash
+# All agents metrics
+npx claude-flow agent metrics
+
+# Specific agent
+npx claude-flow agent metrics --agent-id agent-001
+
+# Last hour
+npx claude-flow agent metrics --period 1h
+```

package/.claude/commands/monitoring/agents.md

@@ -0,0 +1,44 @@
+# List Active Patterns
+
+## 🎯 Key Principle
+**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
+
+## MCP Tool Usage in Claude Code
+
+**Tool:** `mcp__claude-flow__agent_list`
+
+## Parameters
+```json
+{
+  "swarmId": "current"
+}
+```
+
+## Description
+View all active cognitive patterns and their current focus areas
+
+## Details
+Filters:
+- **all**: Show all defined patterns
+- **active**: Currently engaged patterns
+- **idle**: Available but unused patterns
+- **busy**: Patterns actively coordinating tasks
+
+## Example Usage
+
+**In Claude Code:**
+1. List all agents: Use tool `mcp__claude-flow__agent_list`
+2. Get specific agent metrics: Use tool `mcp__claude-flow__agent_metrics` with parameters `{"agentId": "coder-123"}`
+3. Monitor agent performance: Use tool `mcp__claude-flow__swarm_monitor` with parameters `{"interval": 2000}`
+
+## Important Reminders
+- ✅ This tool provides coordination and structure
+- ✅ Claude Code performs all actual implementation
+- ❌ The tool does NOT write code
+- ❌ The tool does NOT access files directly
+- ❌ The tool does NOT execute commands
+
+## See Also
+- Main documentation: /CLAUDE.md
+- Other commands in this category
+- Workflow examples in /workflows/

package/.claude/commands/monitoring/real-time-view.md

@@ -0,0 +1,25 @@
+# real-time-view
+
+Real-time view of swarm activity.
+
+## Usage
+```bash
+npx claude-flow monitoring real-time-view [options]
+```
+
+## Options
+- `--filter <type>` - Filter view
+- `--highlight <pattern>` - Highlight pattern
+- `--tail <n>` - Show last N events
+
+## Examples
+```bash
+# Start real-time view
+npx claude-flow monitoring real-time-view
+
+# Filter errors
+npx claude-flow monitoring real-time-view --filter errors
+
+# Highlight pattern
+npx claude-flow monitoring real-time-view --highlight "API"
+```

package/.claude/commands/monitoring/status.md

@@ -0,0 +1,46 @@
+# Check Coordination Status
+
+## 🎯 Key Principle
+**This tool coordinates Claude Code's actions. It does NOT write code or create content.**
+
+## MCP Tool Usage in Claude Code
+
+**Tool:** `mcp__claude-flow__swarm_status`
+
+## Parameters
+```json
+{
+  "swarmId": "current"
+}
+```
+
+## Description
+Monitor the effectiveness of current coordination patterns
+
+## Details
+Shows:
+- Active coordination topologies
+- Current cognitive patterns in use
+- Task breakdown and progress
+- Resource utilization for coordination
+- Overall system health
+
+## Example Usage
+
+**In Claude Code:**
+1. Check swarm status: Use tool `mcp__claude-flow__swarm_status`
+2. Monitor in real-time: Use tool `mcp__claude-flow__swarm_monitor` with parameters `{"interval": 1000}`
+3. Get agent metrics: Use tool `mcp__claude-flow__agent_metrics` with parameters `{"agentId": "agent-123"}`
+4. Health check: Use tool `mcp__claude-flow__health_check` with parameters `{"components": ["swarm", "memory", "neural"]}`
+
+## Important Reminders
+- ✅ This tool provides coordination and structure
+- ✅ Claude Code performs all actual implementation
+- ❌ The tool does NOT write code
+- ❌ The tool does NOT access files directly
+- ❌ The tool does NOT execute commands
+
+## See Also
+- Main documentation: /CLAUDE.md
+- Other commands in this category
+- Workflow examples in /workflows/

package/.claude/commands/monitoring/swarm-monitor.md

@@ -0,0 +1,25 @@
+# swarm-monitor
+
+Real-time swarm monitoring.
+
+## Usage
+```bash
+npx claude-flow swarm monitor [options]
+```
+
+## Options
+- `--interval <ms>` - Update interval
+- `--metrics` - Show detailed metrics
+- `--export` - Export monitoring data
+
+## Examples
+```bash
+# Start monitoring
+npx claude-flow swarm monitor
+
+# Custom interval
+npx claude-flow swarm monitor --interval 5000
+
+# With metrics
+npx claude-flow swarm monitor --metrics
+```

package/.claude/commands/optimization/README.md

@@ -0,0 +1,9 @@
+# Optimization Commands
+
+Commands for optimization operations in Claude Flow.
+
+## Available Commands
+
+- [topology-optimize](./topology-optimize.md)
+- [parallel-execute](./parallel-execute.md)
+- [cache-manage](./cache-manage.md)

package/.claude/commands/optimization/auto-topology.md

@@ -0,0 +1,62 @@
+# Automatic Topology Selection
+
+## Purpose
+Automatically select the optimal swarm topology based on task complexity analysis.
+
+## How It Works
+
+### 1. Task Analysis
+The system analyzes your task description to determine:
+- Complexity level (simple/medium/complex)
+- Required agent types
+- Estimated duration
+- Resource requirements
+
+### 2. Topology Selection
+Based on analysis, it selects:
+- **Star**: For simple, centralized tasks
+- **Mesh**: For medium complexity with flexibility needs
+- **Hierarchical**: For complex tasks requiring structure
+- **Ring**: For sequential processing workflows
+
+### 3. Example Usage
+
+**Simple Task:**
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {"task": "Fix typo in README.md"}
+Result: Automatically uses star topology with single agent
+```
+
+**Complex Task:**
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {"task": "Refactor authentication system with JWT, add tests, update documentation"}
+Result: Automatically uses hierarchical topology with architect, coder, and tester agents
+```
+
+## Benefits
+- 🎯 Optimal performance for each task type
+- 🤖 Automatic agent assignment
+- ⚡ Reduced setup time
+- 📊 Better resource utilization
+
+## Hook Configuration
+The pre-task hook automatically handles topology selection:
+```json
+{
+  "command": "npx claude-flow hook pre-task --optimize-topology"
+}
+```
+
+## Direct Optimization
+```
+Tool: mcp__claude-flow__topology_optimize
+Parameters: {"swarmId": "current"}
+```
+
+## CLI Usage
+```bash
+# Auto-optimize topology via CLI
+npx claude-flow optimize topology
+```

package/.claude/commands/optimization/cache-manage.md

@@ -0,0 +1,25 @@
+# cache-manage
+
+Manage operation cache for performance.
+
+## Usage
+```bash
+npx claude-flow optimization cache-manage [options]
+```
+
+## Options
+- `--action <type>` - Action (view, clear, optimize)
+- `--max-size <mb>` - Maximum cache size
+- `--ttl <seconds>` - Time to live
+
+## Examples
+```bash
+# View cache stats
+npx claude-flow optimization cache-manage --action view
+
+# Clear cache
+npx claude-flow optimization cache-manage --action clear
+
+# Set limits
+npx claude-flow optimization cache-manage --max-size 100 --ttl 3600
+```

package/.claude/commands/optimization/parallel-execute.md

@@ -0,0 +1,25 @@
+# parallel-execute
+
+Execute tasks in parallel for maximum efficiency.
+
+## Usage
+```bash
+npx claude-flow optimization parallel-execute [options]
+```
+
+## Options
+- `--tasks <file>` - Task list file
+- `--max-parallel <n>` - Maximum parallel tasks
+- `--strategy <type>` - Execution strategy
+
+## Examples
+```bash
+# Execute task list
+npx claude-flow optimization parallel-execute --tasks tasks.json
+
+# Limit parallelism
+npx claude-flow optimization parallel-execute --tasks tasks.json --max-parallel 5
+
+# Custom strategy
+npx claude-flow optimization parallel-execute --strategy adaptive
+```

package/.claude/commands/optimization/parallel-execution.md

@@ -0,0 +1,50 @@
+# Parallel Task Execution
+
+## Purpose
+Execute independent subtasks in parallel for maximum efficiency.
+
+## Coordination Strategy
+
+### 1. Task Decomposition
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {
+  "task": "Build complete REST API with auth, CRUD operations, and tests",
+  "strategy": "parallel",
+  "maxAgents": 8
+}
+```
+
+### 2. Parallel Workflows
+The system automatically:
+- Identifies independent components
+- Assigns specialized agents
+- Executes in parallel where possible
+- Synchronizes at dependency points
+
+### 3. Example Breakdown
+For the REST API task:
+- **Agent 1 (Architect)**: Design API structure
+- **Agent 2-3 (Coders)**: Implement auth & CRUD in parallel
+- **Agent 4 (Tester)**: Write tests as features complete
+- **Agent 5 (Documenter)**: Update docs continuously
+
+## CLI Usage
+```bash
+# Execute parallel tasks via CLI
+npx claude-flow parallel "Build REST API" --max-agents 8
+```
+
+## Performance Gains
+- 🚀 2.8-4.4x faster execution
+- 💪 Optimal CPU utilization
+- 🔄 Automatic load balancing
+- 📈 Linear scalability with agents
+
+## Monitoring
+```
+Tool: mcp__claude-flow__swarm_monitor
+Parameters: {"interval": 1000, "swarmId": "current"}
+```
+
+Watch real-time parallel execution progress!

package/.claude/commands/optimization/topology-optimize.md

@@ -0,0 +1,25 @@
+# topology-optimize
+
+Optimize swarm topology for current workload.
+
+## Usage
+```bash
+npx claude-flow optimization topology-optimize [options]
+```
+
+## Options
+- `--analyze-first` - Analyze before optimizing
+- `--target <metric>` - Optimization target
+- `--apply` - Apply optimizations
+
+## Examples
+```bash
+# Analyze and suggest
+npx claude-flow optimization topology-optimize --analyze-first
+
+# Optimize for speed
+npx claude-flow optimization topology-optimize --target speed
+
+# Apply changes
+npx claude-flow optimization topology-optimize --target efficiency --apply
+```

package/.claude/commands/sparc/analyzer.md

@@ -0,0 +1,52 @@
+# SPARC Analyzer Mode
+
+## Purpose
+Deep code and data analysis with batch processing capabilities.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "analyzer",
+  task_description: "analyze codebase performance",
+  options: {
+    parallel: true,
+    detailed: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow sparc run analyzer "analyze codebase performance"
+
+# For alpha features
+npx claude-flow@alpha sparc run analyzer "analyze codebase performance"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow is installed locally
+./claude-flow sparc run analyzer "analyze codebase performance"
+```
+
+## Core Capabilities
+- Code analysis with parallel file processing
+- Data pattern recognition
+- Performance profiling
+- Memory usage analysis
+- Dependency mapping
+
+## Batch Operations
+- Parallel file analysis using concurrent Read operations
+- Batch pattern matching with Grep tool
+- Simultaneous metric collection
+- Aggregated reporting
+
+## Output Format
+- Detailed analysis reports
+- Performance metrics
+- Improvement recommendations
+- Visualizations when applicable

package/.claude/commands/sparc/architect.md

@@ -0,0 +1,53 @@
+# SPARC Architect Mode
+
+## Purpose
+System design with Memory-based coordination for scalable architectures.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "architect",
+  task_description: "design microservices architecture",
+  options: {
+    detailed: true,
+    memory_enabled: true
+  }
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow sparc run architect "design microservices architecture"
+
+# For alpha features
+npx claude-flow@alpha sparc run architect "design microservices architecture"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow is installed locally
+./claude-flow sparc run architect "design microservices architecture"
+```
+
+## Core Capabilities
+- System architecture design
+- Component interface definition
+- Database schema design
+- API contract specification
+- Infrastructure planning
+
+## Memory Integration
+- Store architecture decisions in Memory
+- Share component specifications across agents
+- Maintain design consistency
+- Track architectural evolution
+
+## Design Patterns
+- Microservices
+- Event-driven architecture
+- Domain-driven design
+- Hexagonal architecture
+- CQRS and Event Sourcing