@claude-flow/cli 3.0.0-alpha.33 → 3.0.0-alpha.35

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

@@ -0,0 +1,44 @@
+# Initialize Coordination Framework
+
+## 🎯 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_init`
+
+## Parameters
+```json
+{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}
+```
+
+## Description
+Set up a coordination topology to guide Claude Code's approach to complex tasks
+
+## Details
+This tool creates a coordination framework that helps Claude Code:
+- Break down complex problems systematically
+- Approach tasks from multiple perspectives
+- Maintain consistency across large projects
+- Work more efficiently through structured coordination
+
+Remember: This does NOT create actual coding agents. It creates a coordination pattern for Claude Code to follow.
+
+## Example Usage
+
+**In Claude Code:**
+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
+
+## 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/coordination/orchestrate.md

@@ -0,0 +1,43 @@
+# Coordinate Task Execution
+
+## 🎯 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__task_orchestrate`
+
+## Parameters
+```json
+{"task": "Implement authentication system", "strategy": "parallel", "priority": "high"}
+```
+
+## Description
+Break down and coordinate complex tasks for systematic execution by Claude Code
+
+## Details
+Orchestration strategies:
+- **parallel**: Claude Code works on independent components simultaneously
+- **sequential**: Step-by-step execution for dependent tasks
+- **adaptive**: Dynamically adjusts based on task complexity
+
+The orchestrator creates a plan that Claude Code follows using its native tools.
+
+## Example Usage
+
+**In Claude Code:**
+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
+
+## 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/coordination/spawn.md

@@ -0,0 +1,45 @@
+# Create Cognitive 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_spawn`
+
+## Parameters
+```json
+{"type": "researcher", "name": "Literature Analysis", "capabilities": ["deep-analysis"]}
+```
+
+## Description
+Define cognitive patterns that represent different approaches Claude Code can take
+
+## Details
+Agent types represent thinking patterns, not actual coders:
+- **researcher**: Systematic exploration approach
+- **coder**: Implementation-focused thinking
+- **analyst**: Data-driven decision making
+- **architect**: Big-picture system design
+- **reviewer**: Quality and consistency checking
+
+These patterns guide how Claude Code approaches different aspects of your task.
+
+## Example Usage
+
+**In Claude Code:**
+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
+
+## 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/coordination/swarm-init.md

@@ -0,0 +1,85 @@
+# swarm init
+
+Initialize a Claude Flow swarm with specified topology and configuration.
+
+## Usage
+
+```bash
+npx claude-flow swarm init [options]
+```
+
+## Options
+
+- `--topology, -t <type>` - Swarm topology: mesh, hierarchical, ring, star (default: hierarchical)
+- `--max-agents, -m <number>` - Maximum number of agents (default: 8)
+- `--strategy, -s <type>` - Execution strategy: balanced, parallel, sequential (default: parallel)
+- `--auto-spawn` - Automatically spawn agents based on task complexity
+- `--memory` - Enable cross-session memory persistence
+- `--github` - Enable GitHub integration features
+
+## Examples
+
+### Basic initialization
+
+```bash
+npx claude-flow swarm init
+```
+
+### Mesh topology for research
+
+```bash
+npx claude-flow swarm init --topology mesh --max-agents 5 --strategy balanced
+```
+
+### Hierarchical for development
+
+```bash
+npx claude-flow swarm init --topology hierarchical --max-agents 10 --strategy parallel --auto-spawn
+```
+
+### GitHub-focused swarm
+
+```bash
+npx claude-flow swarm init --topology star --github --memory
+```
+
+## Topologies
+
+### Mesh
+
+- All agents connect to all others
+- Best for: Research, exploration, brainstorming
+- Communication: High overhead, maximum information sharing
+
+### Hierarchical
+
+- Tree structure with clear command chain
+- Best for: Development, structured tasks, large projects
+- Communication: Efficient, clear responsibilities
+
+### Ring
+
+- Agents connect in a circle
+- Best for: Pipeline processing, sequential workflows
+- Communication: Low overhead, ordered processing
+
+### Star
+
+- Central coordinator with satellite agents
+- Best for: Simple tasks, centralized control
+- Communication: Minimal overhead, clear coordination
+
+## Integration with Claude Code
+
+Once initialized, use MCP tools in Claude Code:
+
+```javascript
+mcp__claude-flow__swarm_init { topology: "hierarchical", maxAgents: 8 }
+```
+
+## See Also
+
+- `agent spawn` - Create swarm agents
+- `task orchestrate` - Coordinate task execution
+- `swarm status` - Check swarm state
+- `swarm monitor` - Real-time monitoring

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

@@ -0,0 +1,25 @@
+# task-orchestrate
+
+Orchestrate complex tasks across the swarm.
+
+## Usage
+```bash
+npx claude-flow task orchestrate [options]
+```
+
+## Options
+- `--task <description>` - Task description
+- `--strategy <type>` - Orchestration strategy
+- `--priority <level>` - Task priority (low, medium, high, critical)
+
+## Examples
+```bash
+# Orchestrate development task
+npx claude-flow task orchestrate --task "Implement user authentication"
+
+# High priority task
+npx claude-flow task orchestrate --task "Fix production bug" --priority critical
+
+# With specific strategy
+npx claude-flow task orchestrate --task "Refactor codebase" --strategy parallel
+```

package/.claude/commands/flow-nexus/app-store.md

@@ -0,0 +1,124 @@
+---
+name: flow-nexus-app-store
+description: Browse, publish, and deploy applications
+---
+
+# Flow Nexus App Store
+
+Browse templates, publish apps, and deploy solutions.
+
+## Browse Apps
+```javascript
+// Search apps
+mcp__flow-nexus__app_search({
+  search: "authentication",
+  category: "backend",
+  featured: true,
+  limit: 20
+})
+
+// Get app details
+mcp__flow-nexus__app_get({ app_id: "app_id" })
+
+// List templates
+mcp__flow-nexus__app_store_list_templates({
+  category: "web-api",
+  tags: ["express", "jwt"],
+  limit: 20
+})
+```
+
+## Publish App
+```javascript
+mcp__flow-nexus__app_store_publish_app({
+  name: "My Auth Service",
+  description: "JWT-based authentication microservice",
+  category: "backend",
+  version: "1.0.0",
+  source_code: sourceCode,
+  tags: ["auth", "jwt", "express"],
+  metadata: {
+    author: "Your Name",
+    license: "MIT",
+    repository: "github.com/user/repo"
+  }
+})
+```
+
+## Deploy Templates
+```javascript
+// Get template details
+mcp__flow-nexus__template_get({
+  template_name: "express-api-starter"
+})
+
+// Deploy template
+mcp__flow-nexus__template_deploy({
+  template_name: "express-api-starter",
+  deployment_name: "my-api",
+  variables: {
+    api_key: "your_key",
+    database_url: "postgres://..."
+  },
+  env_vars: {
+    NODE_ENV: "production"
+  }
+})
+```
+
+## Analytics
+```javascript
+// Get app analytics
+mcp__flow-nexus__app_analytics({
+  app_id: "your_app_id",
+  timeframe: "30d" // 24h, 7d, 30d, 90d
+})
+
+// View installed apps
+mcp__flow-nexus__app_installed({
+  user_id: "your_id"
+})
+```
+
+## Update App
+```javascript
+mcp__flow-nexus__app_update({
+  app_id: "app_id",
+  updates: {
+    version: "1.1.0",
+    description: "Updated description",
+    tags: ["new", "tags"]
+  }
+})
+```
+
+## Market Data
+```javascript
+// Get market statistics
+mcp__flow-nexus__market_data()
+```
+
+## Template Categories
+- **web-api**: RESTful APIs and microservices
+- **frontend**: React, Vue, Angular apps
+- **full-stack**: Complete applications
+- **cli-tools**: Command-line utilities
+- **data-processing**: ETL and analytics
+- **ml-models**: Pre-trained models
+- **blockchain**: Web3 applications
+- **mobile**: React Native apps
+
+## Publishing Best Practices
+1. Include comprehensive documentation
+2. Add example usage and configuration
+3. Include tests and CI/CD setup
+4. Use semantic versioning
+5. Add clear license information
+6. Include docker/deployment configs
+7. Provide migration guides for updates
+
+## Revenue Sharing
+- Earn rUv credits when others use your templates
+- Set pricing (0 for free templates)
+- Track usage and earnings in analytics
+- Withdraw credits or use for Flow Nexus services

package/.claude/commands/flow-nexus/challenges.md

@@ -0,0 +1,120 @@
+---
+name: flow-nexus-challenges
+description: Coding challenges, achievements, and leaderboards
+---
+
+# Flow Nexus Challenges
+
+Complete coding challenges to earn rUv credits and climb the leaderboard.
+
+## List Challenges
+```javascript
+mcp__flow-nexus__challenges_list({
+  difficulty: "intermediate", // beginner, advanced, expert
+  category: "algorithms",
+  status: "active",
+  limit: 20
+})
+```
+
+## Get Challenge Details
+```javascript
+mcp__flow-nexus__challenge_get({
+  challenge_id: "two-sum-problem"
+})
+```
+
+## Submit Solution
+```javascript
+mcp__flow-nexus__challenge_submit({
+  challenge_id: "challenge_id",
+  user_id: "your_id",
+  solution_code: `
+    function solution(nums, target) {
+      const map = new Map();
+      for (let i = 0; i < nums.length; i++) {
+        const complement = target - nums[i];
+        if (map.has(complement)) {
+          return [map.get(complement), i];
+        }
+        map.set(nums[i], i);
+      }
+      return [];
+    }
+  `,
+  language: "javascript",
+  execution_time: 45 // milliseconds
+})
+```
+
+## Complete Challenge
+```javascript
+mcp__flow-nexus__app_store_complete_challenge({
+  challenge_id: "challenge_id",
+  user_id: "your_id",
+  submission_data: {
+    passed_tests: 10,
+    total_tests: 10,
+    execution_time: 45
+  }
+})
+```
+
+## Leaderboards
+```javascript
+// Global leaderboard
+mcp__flow-nexus__leaderboard_get({
+  type: "global", // weekly, monthly, challenge
+  limit: 10
+})
+
+// Challenge-specific leaderboard
+mcp__flow-nexus__leaderboard_get({
+  type: "challenge",
+  challenge_id: "specific_challenge",
+  limit: 25
+})
+```
+
+## Achievements
+```javascript
+mcp__flow-nexus__achievements_list({
+  user_id: "your_id",
+  category: "speed_demon" // Categories vary
+})
+```
+
+## rUv Credits
+```javascript
+// Check balance
+mcp__flow-nexus__ruv_balance({ user_id: "your_id" })
+
+// View history
+mcp__flow-nexus__ruv_history({
+  user_id: "your_id",
+  limit: 20
+})
+
+// Earn credits (automatic on completion)
+mcp__flow-nexus__app_store_earn_ruv({
+  user_id: "your_id",
+  amount: 100,
+  reason: "Completed expert challenge",
+  source: "challenge"
+})
+```
+
+## Challenge Categories
+- **algorithms**: Classic algorithm problems
+- **data-structures**: DS implementation challenges
+- **system-design**: Architecture challenges
+- **optimization**: Performance challenges
+- **security**: Security-focused problems
+- **ml-basics**: Machine learning fundamentals
+
+## Tips
+1. Start with beginner challenges
+2. Review other solutions after completing
+3. Optimize for both correctness and speed
+4. Complete daily challenges for bonus credits
+5. Unlock achievements for extra rewards

package/.claude/commands/flow-nexus/login-registration.md

@@ -0,0 +1,65 @@
+---
+name: flow-nexus-auth
+description: Flow Nexus authentication and user management
+---
+
+# Flow Nexus Authentication
+
+Quick commands for Flow Nexus login and registration.
+
+## Register New Account
+```javascript
+mcp__flow-nexus__user_register({
+  email: "user@example.com",
+  password: "secure_password",
+  full_name: "Your Name" // optional
+})
+```
+
+## Login
+```javascript
+mcp__flow-nexus__user_login({
+  email: "user@example.com",
+  password: "your_password"
+})
+```
+
+## Check Auth Status
+```javascript
+mcp__flow-nexus__auth_status({ detailed: true })
+```
+
+## Logout
+```javascript
+mcp__flow-nexus__user_logout()
+```
+
+## Password Reset
+```javascript
+// Request reset
+mcp__flow-nexus__user_reset_password({ email: "user@example.com" })
+
+// Update with token
+mcp__flow-nexus__user_update_password({
+  token: "reset_token",
+  new_password: "new_secure_password"
+})
+```
+
+## Profile Management
+```javascript
+// Get profile
+mcp__flow-nexus__user_profile({ user_id: "your_id" })
+
+// Update profile
+mcp__flow-nexus__user_update_profile({
+  user_id: "your_id",
+  updates: { full_name: "New Name" }
+})
+```
+
+## Quick Start
+1. Register with your email
+2. Check your email for verification
+3. Login to access all features
+4. Configure auto-refill for uninterrupted service

package/.claude/commands/flow-nexus/neural-network.md

@@ -0,0 +1,134 @@
+---
+name: flow-nexus-neural
+description: Train and deploy neural networks in distributed sandboxes
+---
+
+# Flow Nexus Neural Networks
+
+Train custom neural networks with distributed computing.
+
+## Train Model
+```javascript
+mcp__flow-nexus__neural_train({
+  config: {
+    architecture: {
+      type: "feedforward", // lstm, gan, autoencoder, transformer
+      layers: [
+        { type: "dense", units: 128, activation: "relu" },
+        { type: "dropout", rate: 0.2 },
+        { type: "dense", units: 10, activation: "softmax" }
+      ]
+    },
+    training: {
+      epochs: 100,
+      batch_size: 32,
+      learning_rate: 0.001,
+      optimizer: "adam"
+    }
+  },
+  tier: "small" // nano, mini, small, medium, large
+})
+```
+
+## Run Inference
+```javascript
+mcp__flow-nexus__neural_predict({
+  model_id: "model_id",
+  input: [[0.5, 0.3, 0.2], [0.1, 0.8, 0.1]],
+  user_id: "your_id"
+})
+```
+
+## Use Templates
+```javascript
+// List templates
+mcp__flow-nexus__neural_list_templates({
+  category: "classification", // regression, nlp, vision, anomaly
+  tier: "free",
+  limit: 20
+})
+
+// Deploy template
+mcp__flow-nexus__neural_deploy_template({
+  template_id: "sentiment-analysis",
+  custom_config: {
+    training: { epochs: 50 }
+  }
+})
+```
+
+## Distributed Training
+```javascript
+// Initialize cluster
+mcp__flow-nexus__neural_cluster_init({
+  name: "training-cluster",
+  architecture: "transformer",
+  topology: "mesh",
+  consensus: "proof-of-learning",
+  wasmOptimization: true
+})
+
+// Deploy nodes
+mcp__flow-nexus__neural_node_deploy({
+  cluster_id: "cluster_id",
+  node_type: "worker", // parameter_server, aggregator
+  model: "large",
+  capabilities: ["training", "inference"]
+})
+
+// Start training
+mcp__flow-nexus__neural_train_distributed({
+  cluster_id: "cluster_id",
+  dataset: "mnist",
+  epochs: 100,
+  federated: true // Enable federated learning
+})
+```
+
+## Model Management
+```javascript
+// List your models
+mcp__flow-nexus__neural_list_models({
+  user_id: "your_id",
+  include_public: true
+})
+
+// Benchmark performance
+mcp__flow-nexus__neural_performance_benchmark({
+  model_id: "model_id",
+  benchmark_type: "comprehensive"
+})
+
+// Publish as template
+mcp__flow-nexus__neural_publish_template({
+  model_id: "model_id",
+  name: "My Custom Model",
+  description: "Highly accurate classifier",
+  category: "classification",
+  price: 0 // Free template
+})
+```
+
+## Common Patterns
+
+### Image Classification
+```javascript
+mcp__flow-nexus__neural_train({
+  config: {
+    architecture: { type: "cnn" },
+    training: { epochs: 50, batch_size: 64 }
+  },
+  tier: "medium"
+})
+```
+
+### Time Series Prediction
+```javascript
+mcp__flow-nexus__neural_train({
+  config: {
+    architecture: { type: "lstm" },
+    training: { epochs: 100, learning_rate: 0.01 }
+  },
+  tier: "small"
+})
+```