burhan-mop 0.1.0

package/.claude/commands/stream-chain/pipeline.md

@@ -0,0 +1,121 @@
+# stream-chain pipeline
+
+Execute predefined pipelines for common development workflows.
+
+## Usage
+
+```bash
+claude-flow stream-chain pipeline <type> [options]
+```
+
+## Available Pipelines
+
+### analysis
+Code analysis and improvement pipeline.
+
+```bash
+claude-flow stream-chain pipeline analysis
+```
+
+**Steps:**
+1. Analyze current directory structure and identify main components
+2. Based on analysis, identify potential improvements and issues
+3. Generate detailed report with actionable recommendations
+
+### refactor
+Automated refactoring workflow.
+
+```bash
+claude-flow stream-chain pipeline refactor
+```
+
+**Steps:**
+1. Identify code that could benefit from refactoring
+2. Create prioritized refactoring plan with specific changes
+3. Provide refactored code examples for top 3 priorities
+
+### test
+Comprehensive test generation.
+
+```bash
+claude-flow stream-chain pipeline test
+```
+
+**Steps:**
+1. Analyze codebase and identify areas lacking test coverage
+2. Design comprehensive test cases for critical functions
+3. Generate unit test implementations with assertions
+
+### optimize
+Performance optimization pipeline.
+
+```bash
+claude-flow stream-chain pipeline optimize
+```
+
+**Steps:**
+1. Profile codebase and identify performance bottlenecks
+2. Analyze bottlenecks and suggest optimization strategies
+3. Provide optimized implementations for main issues
+
+## Options
+
+- `--verbose` - Show detailed execution
+- `--timeout <seconds>` - Timeout per step (default: 30)
+- `--debug` - Enable debug mode
+
+## Examples
+
+### Run Analysis Pipeline
+```bash
+claude-flow stream-chain pipeline analysis
+```
+
+### Refactor with Extended Timeout
+```bash
+claude-flow stream-chain pipeline refactor --timeout 60
+```
+
+### Verbose Test Generation
+```bash
+claude-flow stream-chain pipeline test --verbose
+```
+
+### Performance Optimization
+```bash
+claude-flow stream-chain pipeline optimize --debug
+```
+
+## Output
+
+Each pipeline generates:
+- Step-by-step execution progress
+- Success/failure status per step
+- Total execution time
+- Summary of results
+
+## Custom Pipelines
+
+Define custom pipelines in `.claude-flow/config.json`:
+
+```json
+{
+  "streamChain": {
+    "pipelines": {
+      "security": {
+        "name": "Security Audit Pipeline",
+        "prompts": [
+          "Scan for security vulnerabilities",
+          "Prioritize by severity",
+          "Generate fixes"
+        ]
+      }
+    }
+  }
+}
+```
+
+Then run:
+```bash
+claude-flow stream-chain pipeline security
+```

package/.claude/commands/stream-chain/run.md

@@ -0,0 +1,70 @@
+# stream-chain run
+
+Execute a custom stream chain with your own prompts.
+
+## Usage
+
+```bash
+claude-flow stream-chain run <prompt1> <prompt2> [...] [options]
+```
+
+Minimum 2 prompts required for chaining.
+
+## Options
+
+- `--verbose` - Show detailed execution information
+- `--timeout <seconds>` - Timeout per step (default: 30)
+- `--debug` - Enable debug mode
+
+## How It Works
+
+Each prompt in the chain receives the complete output from the previous step as context, enabling complex multi-step workflows.
+
+## Examples
+
+### Basic Chain
+```bash
+claude-flow stream-chain run \
+  "Write a function" \
+  "Add tests for it"
+```
+
+### Complex Workflow
+```bash
+claude-flow stream-chain run \
+  "Analyze the authentication system" \
+  "Identify security vulnerabilities" \
+  "Propose fixes with priority levels" \
+  "Implement the critical fixes" \
+  "Generate tests for the fixes"
+```
+
+### With Options
+```bash
+claude-flow stream-chain run \
+  "Complex analysis task" \
+  "Detailed implementation" \
+  --timeout 60 \
+  --verbose
+```
+
+## Context Preservation
+
+The output from each step is injected into the next prompt:
+
+```
+Step 1: "Write a sorting function"
+Output: [function code]
+
+Step 2 receives: "Previous step output:
+[function code]
+
+Next step: Optimize for performance"
+```
+
+## Best Practices
+
+1. **Clear Instructions**: Make each prompt specific
+2. **Logical Flow**: Order prompts in logical sequence
+3. **Appropriate Timeouts**: Increase for complex tasks
+4. **Verification**: Add verification steps in chain

package/.claude/commands/swarm/README.md

@@ -0,0 +1,15 @@
+# Swarm Commands
+
+Commands for swarm operations in Claude Flow.
+
+## Available Commands
+
+- [swarm](./swarm.md)
+- [swarm-init](./swarm-init.md)
+- [swarm-spawn](./swarm-spawn.md)
+- [swarm-status](./swarm-status.md)
+- [swarm-monitor](./swarm-monitor.md)
+- [swarm-strategies](./swarm-strategies.md)
+- [swarm-modes](./swarm-modes.md)
+- [swarm-background](./swarm-background.md)
+- [swarm-analysis](./swarm-analysis.md)

package/.claude/commands/swarm/analysis.md

@@ -0,0 +1,95 @@
+# Analysis Swarm Strategy
+
+## Purpose
+Comprehensive analysis through distributed agent coordination.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize analysis swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Orchestrate analysis task
+mcp__claude-flow__task_orchestrate({
+  "task": "analyze system performance",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "analyze system performance" --strategy analysis`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn analysis agents
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Data Collector",
+  "capabilities": ["metrics", "logging", "monitoring"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Pattern Analyzer",
+  "capabilities": ["pattern-recognition", "anomaly-detection"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "documenter",
+  "name": "Report Generator",
+  "capabilities": ["reporting", "visualization"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "coordinator",
+  "name": "Insight Synthesizer",
+  "capabilities": ["synthesis", "correlation"]
+})
+```
+
+## Coordination Modes
+- Mesh: For exploratory analysis
+- Pipeline: For sequential processing
+- Hierarchical: For complex systems
+
+## Analysis Operations
+```javascript
+// Run performance analysis
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "24h"
+})
+
+// Identify bottlenecks
+mcp__claude-flow__bottleneck_analyze({
+  "component": "api",
+  "metrics": ["response-time", "throughput"]
+})
+
+// Pattern recognition
+mcp__claude-flow__pattern_recognize({
+  "data": performanceData,
+  "patterns": ["anomaly", "trend", "cycle"]
+})
+```
+
+## Status Monitoring
+```javascript
+// Monitor analysis progress
+mcp__claude-flow__task_status({
+  "taskId": "analysis-task-001"
+})
+
+// Get analysis results
+mcp__claude-flow__task_results({
+  "taskId": "analysis-task-001"
+})
+```

package/.claude/commands/swarm/development.md

@@ -0,0 +1,96 @@
+# Development Swarm Strategy
+
+## Purpose
+Coordinated development through specialized agent teams.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize development swarm
+mcp__claude-flow__swarm_init({
+  "topology": "hierarchical",
+  "maxAgents": 8,
+  "strategy": "balanced"
+})
+
+// Orchestrate development task
+mcp__claude-flow__task_orchestrate({
+  "task": "build feature X",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "build feature X" --strategy development`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn development agents
+mcp__claude-flow__agent_spawn({
+  "type": "architect",
+  "name": "System Designer",
+  "capabilities": ["system-design", "api-design"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "coder",
+  "name": "Frontend Developer",
+  "capabilities": ["react", "typescript", "ui"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "coder",
+  "name": "Backend Developer",
+  "capabilities": ["nodejs", "api", "database"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "specialist",
+  "name": "Database Expert",
+  "capabilities": ["sql", "nosql", "optimization"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Integration Tester",
+  "capabilities": ["integration", "e2e", "api-testing"]
+})
+```
+
+## Best Practices
+- Use hierarchical mode for large projects
+- Enable parallel execution
+- Implement continuous testing
+- Monitor swarm health regularly
+
+## Status Monitoring
+```javascript
+// Check swarm status
+mcp__claude-flow__swarm_status({
+  "swarmId": "development-swarm"
+})
+
+// Monitor agent performance
+mcp__claude-flow__agent_metrics({
+  "agentId": "architect-001"
+})
+
+// Real-time monitoring
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "development-swarm",
+  "interval": 5000
+})
+```
+
+## Error Handling
+```javascript
+// Enable fault tolerance
+mcp__claude-flow__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "auto-recovery"
+})
+```

package/.claude/commands/swarm/examples.md

@@ -0,0 +1,168 @@
+# Examples Swarm Strategy
+
+## Common Swarm Patterns
+
+### Research Swarm
+
+#### Using MCP Tools
+```javascript
+// Initialize research swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Spawn research agents
+mcp__claude-flow__agent_spawn({
+  "type": "researcher",
+  "name": "AI Trends Researcher",
+  "capabilities": ["web-search", "analysis", "synthesis"]
+})
+
+// Orchestrate research
+mcp__claude-flow__task_orchestrate({
+  "task": "research AI trends",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+
+// Monitor progress
+mcp__claude-flow__swarm_status({
+  "swarmId": "research-swarm"
+})
+```
+
+#### Using CLI (Fallback)
+```bash
+npx claude-flow swarm "research AI trends" \
+  --strategy research \
+  --mode distributed \
+  --max-agents 6 \
+  --parallel
+```
+
+### Development Swarm
+
+#### Using MCP Tools
+```javascript
+// Initialize development swarm
+mcp__claude-flow__swarm_init({
+  "topology": "hierarchical",
+  "maxAgents": 8,
+  "strategy": "balanced"
+})
+
+// Spawn development team
+const devAgents = [
+  { type: "architect", name: "API Designer" },
+  { type: "coder", name: "Backend Developer" },
+  { type: "tester", name: "API Tester" },
+  { type: "documenter", name: "API Documenter" }
+]
+
+devAgents.forEach(agent => {
+  mcp__claude-flow__agent_spawn({
+    "type": agent.type,
+    "name": agent.name,
+    "swarmId": "dev-swarm"
+  })
+})
+
+// Orchestrate development
+mcp__claude-flow__task_orchestrate({
+  "task": "build REST API",
+  "strategy": "sequential",
+  "dependencies": ["design", "implement", "test", "document"]
+})
+
+// Enable monitoring
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "dev-swarm",
+  "interval": 5000
+})
+```
+
+#### Using CLI (Fallback)
+```bash
+npx claude-flow swarm "build REST API" \
+  --strategy development \
+  --mode hierarchical \
+  --monitor \
+  --output sqlite
+```
+
+### Analysis Swarm
+
+#### Using MCP Tools
+```javascript
+// Initialize analysis swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 5,
+  "strategy": "adaptive"
+})
+
+// Spawn analysis agents
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Code Analyzer",
+  "capabilities": ["static-analysis", "complexity-analysis"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Security Analyzer",
+  "capabilities": ["security-scan", "vulnerability-detection"]
+})
+
+// Parallel analysis execution
+mcp__claude-flow__parallel_execute({
+  "tasks": [
+    { "id": "analyze-code", "command": "analyze codebase structure" },
+    { "id": "analyze-security", "command": "scan for vulnerabilities" },
+    { "id": "analyze-performance", "command": "identify bottlenecks" }
+  ]
+})
+
+// Generate comprehensive report
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "current"
+})
+```
+
+#### Using CLI (Fallback)
+```bash
+npx claude-flow swarm "analyze codebase" \
+  --strategy analysis \
+  --mode mesh \
+  --parallel \
+  --timeout 300
+```
+
+## Error Handling Examples
+
+```javascript
+// Setup fault tolerance
+mcp__claude-flow__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "auto-recovery"
+})
+
+// Handle errors gracefully
+try {
+  await mcp__claude-flow__task_orchestrate({
+    "task": "complex operation",
+    "strategy": "parallel"
+  })
+} catch (error) {
+  // Check swarm health
+  const status = await mcp__claude-flow__swarm_status({})
+  
+  // Log error patterns
+  await mcp__claude-flow__error_analysis({
+    "logs": [error.message]
+  })
+}
+```

package/.claude/commands/swarm/maintenance.md

@@ -0,0 +1,102 @@
+# Maintenance Swarm Strategy
+
+## Purpose
+System maintenance and updates through coordinated agents.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize maintenance swarm
+mcp__claude-flow__swarm_init({
+  "topology": "star",
+  "maxAgents": 5,
+  "strategy": "sequential"
+})
+
+// Orchestrate maintenance task
+mcp__claude-flow__task_orchestrate({
+  "task": "update dependencies",
+  "strategy": "sequential",
+  "priority": "medium",
+  "dependencies": ["backup", "test", "update", "verify"]
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "update dependencies" --strategy maintenance`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn maintenance agents
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Dependency Analyzer",
+  "capabilities": ["dependency-analysis", "version-management"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "monitor",
+  "name": "Security Scanner",
+  "capabilities": ["security", "vulnerability-scan"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Test Runner",
+  "capabilities": ["testing", "validation"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "documenter",
+  "name": "Documentation Updater",
+  "capabilities": ["documentation", "changelog"]
+})
+```
+
+## Safety Features
+
+### Backup and Recovery
+```javascript
+// Create system backup
+mcp__claude-flow__backup_create({
+  "components": ["code", "config", "dependencies"],
+  "destination": "./backups/maintenance-" + Date.now()
+})
+
+// Create state snapshot
+mcp__claude-flow__state_snapshot({
+  "name": "pre-maintenance-" + Date.now()
+})
+
+// Enable fault tolerance
+mcp__claude-flow__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "checkpoint-recovery"
+})
+```
+
+### Security Scanning
+```javascript
+// Run security scan
+mcp__claude-flow__security_scan({
+  "target": "./",
+  "depth": "comprehensive"
+})
+```
+
+### Monitoring
+```javascript
+// Health check before/after
+mcp__claude-flow__health_check({
+  "components": ["dependencies", "tests", "build"]
+})
+
+// Monitor maintenance progress
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "maintenance-swarm",
+  "interval": 3000
+})
+```