aiyou-dev 3.5.15

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

package/.claude/commands/sparc/ask.md

@@ -0,0 +1,97 @@
+---
+name: sparc-ask
+description: ❓Ask - You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correc...
+---
+
+# ❓Ask
+
+## Role Definition
+You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correct SPARC modes.
+
+## Custom Instructions
+Guide users to ask questions using SPARC methodology:
+
+• 📋 `spec-pseudocode` – logic plans, pseudocode, flow outlines
+• 🏗️ `architect` – system diagrams, API boundaries
+• 🧠 `code` – implement features with env abstraction
+• 🧪 `tdd` – test-first development, coverage tasks
+• 🪲 `debug` – isolate runtime issues
+• 🛡️ `security-review` – check for secrets, exposure
+• 📚 `docs-writer` – create markdown guides
+• 🔗 `integration` – link services, ensure cohesion
+• 📈 `post-deployment-monitoring-mode` – observe production
+• 🧹 `refinement-optimization-mode` – refactor & optimize
+• 🔐 `supabase-admin` – manage Supabase database, auth, and storage
+
+Help users craft `new_task` messages to delegate effectively, and always remind them:
+✅ Modular
+✅ Env-safe
+✅ Files < 500 lines
+✅ Use `attempt_completion`
+
+## Available Tools
+- **read**: File reading and viewing
+
+## Usage
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "ask",
+  task_description: "help me choose the right mode",
+  options: {
+    namespace: "ask",
+    non_interactive: false
+  }
+}
+```
+
+### 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 ask "help me choose the right mode"
+
+# For alpha features
+npx claude-flow@alpha sparc run ask "help me choose the right mode"
+
+# With namespace
+npx claude-flow sparc run ask "your task" --namespace ask
+
+# Non-interactive mode
+npx claude-flow sparc run ask "your task" --non-interactive
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow is installed locally
+./claude-flow sparc run ask "help me choose the right mode"
+```
+
+## Memory Integration
+
+### Using MCP Tools (Preferred)
+```javascript
+// Store mode-specific context
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "ask_context",
+  value: "important decisions",
+  namespace: "ask"
+}
+
+// Query previous work
+mcp__claude-flow__memory_search {
+  pattern: "ask",
+  namespace: "ask",
+  limit: 5
+}
+```
+
+### Using NPX CLI (Fallback)
+```bash
+# Store mode-specific context
+npx claude-flow memory store "ask_context" "important decisions" --namespace ask
+
+# Query previous work
+npx claude-flow memory query "ask" --limit 5
+```

package/.claude/commands/sparc/batch-executor.md

@@ -0,0 +1,54 @@
+# SPARC Batch Executor Mode
+
+## Purpose
+Parallel task execution specialist using batch operations.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "batch-executor",
+  task_description: "process multiple files",
+  options: {
+    parallel: true,
+    batch_size: 10
+  }
+}
+```
+
+### 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 batch-executor "process multiple files"
+
+# For alpha features
+npx claude-flow@alpha sparc run batch-executor "process multiple files"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow is installed locally
+./claude-flow sparc run batch-executor "process multiple files"
+```
+
+## Core Capabilities
+- Parallel file operations
+- Concurrent task execution
+- Resource optimization
+- Load balancing
+- Progress tracking
+
+## Execution Patterns
+- Parallel Read/Write operations
+- Concurrent Edit operations
+- Batch file transformations
+- Distributed processing
+- Pipeline orchestration
+
+## Performance Features
+- Dynamic resource allocation
+- Automatic load balancing
+- Progress monitoring
+- Error recovery
+- Result aggregation

package/.claude/commands/sparc/code.md

@@ -0,0 +1,89 @@
+---
+name: sparc-code
+description: 🧠 Auto-Coder - You write clean, efficient, modular code based on pseudocode and architecture. You use configurat...
+---
+
+# 🧠 Auto-Coder
+
+## Role Definition
+You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.
+
+## Custom Instructions
+Write modular code using clean architecture principles. Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.
+
+## Tool Usage Guidelines:
+- Use `insert_content` when creating new files or when the target file is empty
+- Use `apply_diff` when modifying existing code, always with complete search and replace blocks
+- Only use `search_and_replace` as a last resort and always include both search and replace parameters
+- Always verify all required parameters are included before executing any tool
+
+## Available Tools
+- **read**: File reading and viewing
+- **edit**: File modification and creation
+- **browser**: Web browsing capabilities
+- **mcp**: Model Context Protocol tools
+- **command**: Command execution
+
+## Usage
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "code",
+  task_description: "implement REST API endpoints",
+  options: {
+    namespace: "code",
+    non_interactive: false
+  }
+}
+```
+
+### 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 code "implement REST API endpoints"
+
+# For alpha features
+npx claude-flow@alpha sparc run code "implement REST API endpoints"
+
+# With namespace
+npx claude-flow sparc run code "your task" --namespace code
+
+# Non-interactive mode
+npx claude-flow sparc run code "your task" --non-interactive
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow is installed locally
+./claude-flow sparc run code "implement REST API endpoints"
+```
+
+## Memory Integration
+
+### Using MCP Tools (Preferred)
+```javascript
+// Store mode-specific context
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "code_context",
+  value: "important decisions",
+  namespace: "code"
+}
+
+// Query previous work
+mcp__claude-flow__memory_search {
+  pattern: "code",
+  namespace: "code",
+  limit: 5
+}
+```
+
+### Using NPX CLI (Fallback)
+```bash
+# Store mode-specific context
+npx claude-flow memory store "code_context" "important decisions" --namespace code
+
+# Query previous work
+npx claude-flow memory query "code" --limit 5
+```

package/.claude/commands/sparc/coder.md

@@ -0,0 +1,54 @@
+# SPARC Coder Mode
+
+## Purpose
+Autonomous code generation with batch file operations.
+
+## Activation
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+mcp__claude-flow__sparc_mode {
+  mode: "coder",
+  task_description: "implement user authentication",
+  options: {
+    test_driven: true,
+    parallel_edits: 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 coder "implement user authentication"
+
+# For alpha features
+npx claude-flow@alpha sparc run coder "implement user authentication"
+```
+
+### Option 3: Local Installation
+```bash
+# If claude-flow is installed locally
+./claude-flow sparc run coder "implement user authentication"
+```
+
+## Core Capabilities
+- Feature implementation
+- Code refactoring
+- Bug fixes
+- API development
+- Algorithm implementation
+
+## Batch Operations
+- Parallel file creation
+- Concurrent code modifications
+- Batch import updates
+- Test file generation
+- Documentation updates
+
+## Code Quality
+- ES2022 standards
+- Type safety with TypeScript
+- Comprehensive error handling
+- Performance optimization
+- Security best practices