claude-flow 3.0.0-alpha.3 → 3.0.0-alpha.39

package/.claude/commands/workflows/development.md

@@ -0,0 +1,78 @@
+# Development Workflow Coordination
+
+## Purpose
+Structure Claude Code's approach to complex development tasks for maximum efficiency.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Development Framework
+```
+Tool: mcp__claude-flow__swarm_init
+Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
+```
+Creates hierarchical structure for organized, top-down development.
+
+### 2. Define Development Perspectives
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "architect",
+  "name": "System Design",
+  "capabilities": ["api-design", "database-schema"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "coder",
+  "name": "Implementation Focus",
+  "capabilities": ["nodejs", "typescript", "express"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "tester",
+  "name": "Quality Assurance",
+  "capabilities": ["unit-testing", "integration-testing"]
+}
+```
+Sets up architectural and implementation thinking patterns.
+
+### 3. Coordinate Implementation
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {
+  "task": "Build REST API with authentication",
+  "strategy": "parallel",
+  "priority": "high",
+  "dependencies": ["database setup", "auth system"]
+}
+```
+
+### 4. Monitor Progress
+```
+Tool: mcp__claude-flow__task_status
+Parameters: {"taskId": "api-build-task-123"}
+```
+
+## What Claude Code Actually Does
+1. Uses **Write** tool to create new files
+2. Uses **Edit/MultiEdit** tools for code modifications
+3. Uses **Bash** tool for testing and building
+4. Uses **TodoWrite** tool for task tracking
+5. Follows coordination patterns for systematic implementation
+
+Remember: All code is written by Claude Code using its native tools!
+
+## CLI Usage
+```bash
+# Start development workflow via CLI
+npx claude-flow workflow dev "REST API with auth"
+
+# Create custom workflow
+npx claude-flow workflow create --name "api-dev" --steps "design,implement,test,deploy"
+
+# Execute saved workflow
+npx claude-flow workflow execute api-dev
+```

package/.claude/commands/workflows/research.md

@@ -0,0 +1,63 @@
+# Research Workflow Coordination
+
+## Purpose
+Coordinate Claude Code's research activities for comprehensive, systematic exploration.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Research Framework
+```
+Tool: mcp__claude-flow__swarm_init
+Parameters: {"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}
+```
+Creates a mesh topology for comprehensive exploration from multiple angles.
+
+### 2. Define Research Perspectives
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {"type": "researcher", "name": "Literature Review"}
+```
+```
+Tool: mcp__claude-flow__agent_spawn  
+Parameters: {"type": "analyst", "name": "Data Analysis"}
+```
+Sets up different analytical approaches for Claude Code to use.
+
+### 3. Execute Coordinated Research
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {
+  "task": "Research modern web frameworks performance",
+  "strategy": "adaptive",
+  "priority": "medium"
+}
+```
+
+### 4. Store Research Findings
+```
+Tool: mcp__claude-flow__memory_usage
+Parameters: {
+  "action": "store",
+  "key": "research_findings",
+  "value": "framework performance analysis results",
+  "namespace": "research"
+}
+```
+
+## What Claude Code Actually Does
+1. Uses **WebSearch** tool for finding resources
+2. Uses **Read** tool for analyzing documentation
+3. Uses **Task** tool for parallel exploration
+4. Synthesizes findings using coordination patterns
+5. Stores insights in memory for future reference
+
+Remember: The swarm coordinates HOW Claude Code researches, not WHAT it finds.
+
+## CLI Usage
+```bash
+# Start research workflow via CLI
+npx claude-flow workflow research "modern web frameworks"
+
+# Export research workflow
+npx claude-flow workflow export research --format json
+```

package/.claude/commands/workflows/workflow-create.md

@@ -0,0 +1,25 @@
+# workflow-create
+
+Create reusable workflow templates.
+
+## Usage
+```bash
+npx claude-flow workflow create [options]
+```
+
+## Options
+- `--name <name>` - Workflow name
+- `--from-history` - Create from history
+- `--interactive` - Interactive creation
+
+## Examples
+```bash
+# Create workflow
+npx claude-flow workflow create --name "deploy-api"
+
+# From history
+npx claude-flow workflow create --name "test-suite" --from-history
+
+# Interactive mode
+npx claude-flow workflow create --interactive
+```

package/.claude/commands/workflows/workflow-execute.md

@@ -0,0 +1,25 @@
+# workflow-execute
+
+Execute saved workflows.
+
+## Usage
+```bash
+npx claude-flow workflow execute [options]
+```
+
+## Options
+- `--name <name>` - Workflow name
+- `--params <json>` - Workflow parameters
+- `--dry-run` - Preview execution
+
+## Examples
+```bash
+# Execute workflow
+npx claude-flow workflow execute --name "deploy-api"
+
+# With parameters
+npx claude-flow workflow execute --name "test-suite" --params '{"env": "staging"}'
+
+# Dry run
+npx claude-flow workflow execute --name "deploy-api" --dry-run
+```

package/.claude/commands/workflows/workflow-export.md

@@ -0,0 +1,25 @@
+# workflow-export
+
+Export workflows for sharing.
+
+## Usage
+```bash
+npx claude-flow workflow export [options]
+```
+
+## Options
+- `--name <name>` - Workflow to export
+- `--format <type>` - Export format
+- `--include-history` - Include execution history
+
+## Examples
+```bash
+# Export workflow
+npx claude-flow workflow export --name "deploy-api"
+
+# As YAML
+npx claude-flow workflow export --name "test-suite" --format yaml
+
+# With history
+npx claude-flow workflow export --name "deploy-api" --include-history
+```

package/.claude/config/v3-dependency-optimization.json

@@ -0,0 +1,266 @@
+{
+  "v3DependencyOptimization": {
+    "version": "3.0.0",
+    "strategy": "enhanced_parallelism",
+    "description": "Optimized dependency chain for maximum parallel execution efficiency",
+
+    "originalDependencies": {
+      "description": "Current dependency chain with blocking issues",
+      "issues": [
+        "Some agents wait unnecessarily for unrelated dependencies",
+        "Phase boundaries too rigid, reducing parallelism",
+        "Agent #11 and #12 have excessive blocking dependencies"
+      ]
+    },
+
+    "optimizedDependencies": {
+      "description": "Enhanced parallel execution with reduced blocking",
+
+      "phases": {
+        "phase1_enhanced": {
+          "name": "Enhanced Foundation (Weeks 1-3)",
+          "description": "Increased parallelism in foundation phase",
+          "parallel_groups": [
+            {
+              "group": "security_foundation",
+              "agents": [2, 3, 4],
+              "dependencies": [],
+              "description": "Security agents run in full parallel",
+              "estimated_duration": "2 weeks"
+            },
+            {
+              "group": "core_architecture",
+              "agents": [5],
+              "dependencies": [],
+              "description": "Core architect starts immediately with security",
+              "estimated_duration": "1 week"
+            },
+            {
+              "group": "testing_foundation",
+              "agents": [13],
+              "dependencies": [],
+              "description": "TDD engineer starts early for framework setup",
+              "estimated_duration": "1 week"
+            },
+            {
+              "group": "performance_setup",
+              "agents": [14],
+              "dependencies": [],
+              "description": "Performance engineer starts benchmark setup",
+              "estimated_duration": "1 week"
+            }
+          ]
+        },
+
+        "phase2_enhanced": {
+          "name": "Enhanced Core Systems (Weeks 2-6)",
+          "description": "Overlapped execution with phase 1",
+          "parallel_groups": [
+            {
+              "group": "core_implementation",
+              "agents": [6, 7, 8],
+              "dependencies": [5],
+              "description": "Core implementation agents start after architect",
+              "estimated_duration": "3 weeks"
+            },
+            {
+              "group": "mcp_optimization",
+              "agents": [9],
+              "dependencies": [5],
+              "description": "MCP specialist works in parallel with core",
+              "estimated_duration": "2 weeks"
+            },
+            {
+              "group": "queen_coordination",
+              "agents": [1],
+              "dependencies": [2, 5],
+              "description": "Queen starts once security baseline + architecture ready",
+              "estimated_duration": "4 weeks"
+            }
+          ]
+        },
+
+        "phase3_enhanced": {
+          "name": "Enhanced Integration (Weeks 5-9)",
+          "description": "Reduced blocking dependencies for integration agents",
+          "parallel_groups": [
+            {
+              "group": "integration_core",
+              "agents": [10],
+              "dependencies": [5, 7],
+              "description": "Integration architect needs only core arch + memory",
+              "estimated_duration": "3 weeks"
+            },
+            {
+              "group": "cli_modernization",
+              "agents": [11],
+              "dependencies": [5],
+              "description": "CLI developer needs only core architecture (reduced from [5,10])",
+              "estimated_duration": "2 weeks"
+            },
+            {
+              "group": "neural_learning",
+              "agents": [12],
+              "dependencies": [5],
+              "description": "Neural developer needs only core architecture (reduced from [7,10])",
+              "estimated_duration": "2 weeks"
+            }
+          ]
+        },
+
+        "phase4_enhanced": {
+          "name": "Enhanced Polish & Release (Weeks 9-16)",
+          "description": "Final optimization with all agents active",
+          "parallel_groups": [
+            {
+              "group": "release_preparation",
+              "agents": [15],
+              "dependencies": [13, 14],
+              "description": "Release engineer waits for testing + performance validation",
+              "estimated_duration": "2 weeks"
+            },
+            {
+              "group": "final_optimization",
+              "agents": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
+              "dependencies": [],
+              "description": "All agents perform final optimization in parallel",
+              "estimated_duration": "1 week"
+            }
+          ]
+        }
+      }
+    },
+
+    "reducedBlockingDependencies": {
+      "description": "Specific dependency reductions to enable better parallelism",
+      "changes": [
+        {
+          "agent": "cli-hooks-developer (11)",
+          "original_dependencies": [5, 10],
+          "optimized_dependencies": [5],
+          "rationale": "CLI can be modernized with just core architecture, integration can happen later",
+          "parallel_gain": "Can start 2 weeks earlier"
+        },
+        {
+          "agent": "neural-learning-developer (12)",
+          "original_dependencies": [7, 10],
+          "optimized_dependencies": [5],
+          "rationale": "Neural learning can start with core architecture, memory/integration can be added incrementally",
+          "parallel_gain": "Can start 3 weeks earlier"
+        },
+        {
+          "agent": "queen-coordinator (1)",
+          "original_dependencies": [],
+          "optimized_dependencies": [2, 5],
+          "rationale": "Queen should wait for security baseline and core architecture before orchestrating",
+          "coordination_benefit": "More intelligent coordination with foundation in place"
+        }
+      ]
+    },
+
+    "phaseBoundaryOptimization": {
+      "description": "Flexible phase boundaries to maximize parallel efficiency",
+      "strategy": "overlapping_phases",
+      "rules": {
+        "phase_overlap": "50%",
+        "description": "Phases can overlap by 50% once foundation requirements are met",
+        "example": "Phase 2 core systems can start in week 2 while Phase 1 security continues"
+      },
+
+      "flexibility_rules": [
+        {
+          "condition": "Agent dependencies satisfied",
+          "action": "Allow early phase advancement",
+          "benefit": "Maximize parallel agent utilization"
+        },
+        {
+          "condition": "Critical path agents complete",
+          "action": "Start next phase critical agents early",
+          "benefit": "Reduce overall timeline"
+        },
+        {
+          "condition": "Blocking issues detected",
+          "action": "Reassign free agents to unblocked work",
+          "benefit": "Maintain productivity during blocks"
+        }
+      ]
+    },
+
+    "parallelEfficiencyTargets": {
+      "phase1": {
+        "agent_utilization": "85%",
+        "parallel_agents": "4-6 concurrent",
+        "timeline_efficiency": "20% improvement"
+      },
+      "phase2": {
+        "agent_utilization": "90%",
+        "parallel_agents": "6-8 concurrent",
+        "timeline_efficiency": "25% improvement"
+      },
+      "phase3": {
+        "agent_utilization": "95%",
+        "parallel_agents": "8-12 concurrent",
+        "timeline_efficiency": "30% improvement"
+      },
+      "phase4": {
+        "agent_utilization": "100%",
+        "parallel_agents": "15 concurrent",
+        "timeline_efficiency": "Maximum parallel execution"
+      }
+    },
+
+    "riskMitigation": {
+      "description": "Risk management for optimized dependency chain",
+      "strategies": [
+        {
+          "risk": "Early agent starts without sufficient foundation",
+          "mitigation": "Minimum viable dependencies enforced",
+          "monitoring": "Regular dependency satisfaction checks"
+        },
+        {
+          "risk": "Coordination overhead with more parallel agents",
+          "mitigation": "Queen coordinator with enhanced GitHub integration",
+          "monitoring": "Agent coordination latency tracking"
+        },
+        {
+          "risk": "Integration complexity with reduced dependencies",
+          "mitigation": "Incremental integration approach",
+          "monitoring": "Integration test coverage requirements"
+        }
+      ]
+    },
+
+    "implementation": {
+      "tooling": {
+        "dependency_tracker": "GitHub project boards with agent assignments",
+        "parallel_monitor": "Real-time agent utilization dashboard",
+        "coordination": "Queen coordinator with MCP orchestration tools"
+      },
+
+      "coordination_patterns": {
+        "daily_standups": "Agent status and dependency updates",
+        "blocker_resolution": "Immediate reassignment protocols",
+        "phase_transitions": "Gradual transition with readiness checks"
+      }
+    },
+
+    "success_metrics": {
+      "efficiency": {
+        "target": "90% average agent utilization",
+        "measurement": "Time agents spend on productive work vs waiting"
+      },
+      "timeline": {
+        "target": "16 weeks total (vs 20 weeks with original dependencies)",
+        "measurement": "Overall project completion time"
+      },
+      "coordination": {
+        "target": "<4 hours average blocker resolution time",
+        "measurement": "Time from blocker identification to resolution"
+      },
+      "quality": {
+        "target": "No degradation in output quality due to rushed dependencies",
+        "measurement": "Test coverage and review completion rates"
+      }
+    }
+  }
+}