snow-flow 1.4.11 → 1.4.12

package/CLAUDE.md

@@ -737,17 +737,17 @@ If ANY answer is "No", you MUST combine operations into a single message!
 
 **✅ CORRECT Workflow:**
 
-1. **MCP**: `mcp__claude-flow__swarm_init` (coordination setup)
-2. **MCP**: `mcp__claude-flow__agent_spawn` (planning agents)
-3. **MCP**: `mcp__claude-flow__task_orchestrate` (task coordination)
+1. **MCP**: `mcp__snow-flow__swarm_init` (coordination setup)
+2. **MCP**: `mcp__snow-flow__agent_spawn` (planning agents)
+3. **MCP**: `mcp__snow-flow__task_orchestrate` (task coordination)
 4. **Claude Code**: `Task` tool to spawn agents with coordination instructions
 5. **Claude Code**: `TodoWrite` with ALL todos batched (5-10+ in ONE call)
 6. **Claude Code**: `Read`, `Write`, `Edit`, `Bash` (actual work)
-7. **MCP**: `mcp__claude-flow__memory_usage` (store results)
+7. **MCP**: `mcp__snow-flow__memory_usage` (store results)
 
 **❌ WRONG Workflow:**
 
-1. **MCP**: `mcp__claude-flow__terminal_execute` (DON'T DO THIS)
+1. **MCP**: `mcp__snow-flow__terminal_execute` (DON'T DO THIS)
 2. **MCP**: File creation via MCP (DON'T DO THIS)
 3. **MCP**: Code generation via MCP (DON'T DO THIS)
 4. **Claude Code**: Sequential Task calls (DON'T DO THIS)
@@ -792,12 +792,12 @@ If you need to do X operations, they should be in 1 message, not X messages
 ```javascript
 [Single Message with BatchTool]:
   // MCP coordination setup
-  mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 6 }
-  mcp__claude-flow__agent_spawn { type: "researcher" }
-  mcp__claude-flow__agent_spawn { type: "coder" }
-  mcp__claude-flow__agent_spawn { type: "analyst" }
-  mcp__claude-flow__agent_spawn { type: "tester" }
-  mcp__claude-flow__agent_spawn { type: "coordinator" }
+  mcp__snow-flow__swarm_init { topology: "mesh", maxAgents: 6 }
+  mcp__snow-flow__agent_spawn { type: "researcher" }
+  mcp__snow-flow__agent_spawn { type: "coder" }
+  mcp__snow-flow__agent_spawn { type: "analyst" }
+  mcp__snow-flow__agent_spawn { type: "tester" }
+  mcp__snow-flow__agent_spawn { type: "coordinator" }
 
   // Claude Code execution - ALL in parallel
   Task("You are researcher agent. MUST coordinate via hooks...")
@@ -816,7 +816,7 @@ If you need to do X operations, they should be in 1 message, not X messages
 **❌ WRONG - Multiple Messages (NEVER DO THIS):**
 
 ```javascript
-Message 1: mcp__claude-flow__swarm_init
+Message 1: mcp__snow-flow__swarm_init
 Message 2: Task("researcher agent")
 Message 3: Task("coder agent")
 Message 4: TodoWrite({ todo: "single todo" })
@@ -868,19 +868,19 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 
 **Initialize a swarm:**
 
-- Use the `mcp__claude-flow__swarm_init` tool to set up coordination topology
+- Use the `mcp__snow-flow__swarm_init` tool to set up coordination topology
 - Choose: mesh, hierarchical, ring, or star
 - This creates a coordination framework for Claude Code's work
 
 **Spawn agents:**
 
-- Use `mcp__claude-flow__agent_spawn` tool to create specialized coordinators
+- Use `mcp__snow-flow__agent_spawn` tool to create specialized coordinators
 - Agent types represent different thinking patterns, not actual coders
 - They help Claude Code approach problems from different angles
 
 **Orchestrate tasks:**
 
-- Use `mcp__claude-flow__task_orchestrate` tool to coordinate complex workflows
+- Use `mcp__snow-flow__task_orchestrate` tool to coordinate complex workflows
 - This breaks down tasks for Claude Code to execute systematically
 - The agents don't write code - they coordinate Claude Code's actions
 
@@ -888,38 +888,38 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 
 ### Coordination Tools:
 
-- `mcp__claude-flow__swarm_init` - Set up coordination topology for Claude Code
-- `mcp__claude-flow__agent_spawn` - Create cognitive patterns to guide Claude Code
-- `mcp__claude-flow__task_orchestrate` - Break down and coordinate complex tasks
+- `mcp__snow-flow__swarm_init` - Set up coordination topology for Claude Code
+- `mcp__snow-flow__agent_spawn` - Create cognitive patterns to guide Claude Code
+- `mcp__snow-flow__task_orchestrate` - Break down and coordinate complex tasks
 
 ### Monitoring Tools:
 
-- `mcp__claude-flow__swarm_status` - Monitor coordination effectiveness
-- `mcp__claude-flow__agent_list` - View active cognitive patterns
-- `mcp__claude-flow__agent_metrics` - Track coordination performance
-- `mcp__claude-flow__task_status` - Check workflow progress
-- `mcp__claude-flow__task_results` - Review coordination outcomes
+- `mcp__snow-flow__swarm_status` - Monitor coordination effectiveness
+- `mcp__snow-flow__agent_list` - View active cognitive patterns
+- `mcp__snow-flow__agent_metrics` - Track coordination performance
+- `mcp__snow-flow__task_status` - Check workflow progress
+- `mcp__snow-flow__task_results` - Review coordination outcomes
 
 ### Memory & Neural Tools:
 
-- `mcp__claude-flow__memory_usage` - Persistent memory across sessions
-- `mcp__claude-flow__neural_status` - Neural pattern effectiveness
-- `mcp__claude-flow__neural_train` - Improve coordination patterns
-- `mcp__claude-flow__neural_patterns` - Analyze thinking approaches
+- `mcp__snow-flow__memory_usage` - Persistent memory across sessions
+- `mcp__snow-flow__neural_status` - Neural pattern effectiveness
+- `mcp__snow-flow__neural_train` - Improve coordination patterns
+- `mcp__snow-flow__neural_patterns` - Analyze thinking approaches
 
 ### GitHub Integration Tools (NEW!):
 
-- `mcp__claude-flow__github_swarm` - Create specialized GitHub management swarms
-- `mcp__claude-flow__repo_analyze` - Deep repository analysis with AI
-- `mcp__claude-flow__pr_enhance` - AI-powered pull request improvements
-- `mcp__claude-flow__issue_triage` - Intelligent issue classification
-- `mcp__claude-flow__code_review` - Automated code review with swarms
+- `mcp__snow-flow__github_swarm` - Create specialized GitHub management swarms
+- `mcp__snow-flow__repo_analyze` - Deep repository analysis with AI
+- `mcp__snow-flow__pr_enhance` - AI-powered pull request improvements
+- `mcp__snow-flow__issue_triage` - Intelligent issue classification
+- `mcp__snow-flow__code_review` - Automated code review with swarms
 
 ### System Tools:
 
-- `mcp__claude-flow__benchmark_run` - Measure coordination efficiency
-- `mcp__claude-flow__features_detect` - Available capabilities
-- `mcp__claude-flow__swarm_monitor` - Real-time coordination tracking
+- `mcp__snow-flow__benchmark_run` - Measure coordination efficiency
+- `mcp__snow-flow__features_detect` - Available capabilities
+- `mcp__snow-flow__swarm_monitor` - Real-time coordination tracking
 
 ## Workflow Examples (Coordination-Focused)
 
@@ -929,21 +929,21 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 
 **Step 1:** Set up research coordination
 
-- Tool: `mcp__claude-flow__swarm_init`
+- Tool: `mcp__snow-flow__swarm_init`
 - Parameters: `{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}`
 - Result: Creates a mesh topology for comprehensive exploration
 
 **Step 2:** Define research perspectives
 
-- Tool: `mcp__claude-flow__agent_spawn`
+- Tool: `mcp__snow-flow__agent_spawn`
 - Parameters: `{"type": "researcher", "name": "Literature Review"}`
-- Tool: `mcp__claude-flow__agent_spawn`
+- Tool: `mcp__snow-flow__agent_spawn`
 - Parameters: `{"type": "analyst", "name": "Data Analysis"}`
 - Result: Different cognitive patterns for Claude Code to use
 
 **Step 3:** Coordinate research execution
 
-- Tool: `mcp__claude-flow__task_orchestrate`
+- Tool: `mcp__snow-flow__task_orchestrate`
 - Parameters: `{"task": "Research neural architecture search papers", "strategy": "adaptive"}`
 - Result: Claude Code systematically searches, reads, and analyzes papers
 
@@ -964,19 +964,19 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 
 **Step 1:** Set up development coordination
 
-- Tool: `mcp__claude-flow__swarm_init`
+- Tool: `mcp__snow-flow__swarm_init`
 - Parameters: `{"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}`
 - Result: Hierarchical structure for organized development
 
 **Step 2:** Define development perspectives
 
-- Tool: `mcp__claude-flow__agent_spawn`
+- Tool: `mcp__snow-flow__agent_spawn`
 - Parameters: `{"type": "architect", "name": "System Design"}`
 - Result: Architectural thinking pattern for Claude Code
 
 **Step 3:** Coordinate implementation
 
-- Tool: `mcp__claude-flow__task_orchestrate`
+- Tool: `mcp__snow-flow__task_orchestrate`
 - Parameters: `{"task": "Implement user authentication with JWT", "strategy": "parallel"}`
 - Result: Claude Code implements features using its native tools
 
@@ -997,19 +997,19 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 
 **Step 1:** Initialize GitHub swarm
 
-- Tool: `mcp__claude-flow__github_swarm`
+- Tool: `mcp__snow-flow__github_swarm`
 - Parameters: `{"repository": "owner/repo", "agents": 5, "focus": "maintenance"}`
 - Result: Specialized swarm for repository management
 
 **Step 2:** Analyze repository health
 
-- Tool: `mcp__claude-flow__repo_analyze`
+- Tool: `mcp__snow-flow__repo_analyze`
 - Parameters: `{"deep": true, "include": ["issues", "prs", "code"]}`
 - Result: Comprehensive repository analysis
 
 **Step 3:** Enhance pull requests
 
-- Tool: `mcp__claude-flow__pr_enhance`
+- Tool: `mcp__snow-flow__pr_enhance`
 - Parameters: `{"pr_number": 123, "add_tests": true, "improve_docs": true}`
 - Result: AI-powered PR improvements
 
@@ -1127,13 +1127,13 @@ See `.claude/commands/` for detailed documentation on all features.
 1. **SPAWN ALL AGENTS IN ONE BATCH** - Use multiple tool calls in a SINGLE message
 2. **EXECUTE TASKS IN PARALLEL** - Never wait for one task before starting another
 3. **USE BATCHTOOL FOR EVERYTHING** - Multiple operations = Single message with multiple tools
-4. **ALL AGENTS MUST USE COORDINATION TOOLS** - Every spawned agent MUST use claude-flow hooks and memory
+4. **ALL AGENTS MUST USE COORDINATION TOOLS** - Every spawned agent MUST use snow-flow hooks and memory
 
 ### 🎯 AGENT COUNT CONFIGURATION
 
 **CRITICAL: Dynamic Agent Count Rules**
 
-1. **Check CLI Arguments First**: If user runs `npx claude-flow@alpha --agents 5`, use 5 agents
+1. **Check CLI Arguments First**: If user runs `npx snow-flow --agents 5`, use 5 agents
 2. **Auto-Decide if No Args**: Without CLI args, analyze task complexity:
    - Simple tasks (1-3 components): 3-4 agents
    - Medium tasks (4-6 components): 5-7 agents
@@ -1147,7 +1147,7 @@ See `.claude/commands/` for detailed documentation on all features.
 **Example Auto-Decision Logic:**
 
 ```javascript
-// If CLI args provided: npx claude-flow@alpha --agents 6
+// If CLI args provided: npx snow-flow --agents 6
 maxAgents = CLI_ARGS.agents || determineAgentCount(task);
 
 function determineAgentCount(task) {
@@ -1230,12 +1230,12 @@ Message 6: TodoWrite (another single todo)
 ```
 Message 1: [BatchTool]
   // MCP coordination setup
-  - mcp__claude-flow__swarm_init
-  - mcp__claude-flow__agent_spawn (researcher)
-  - mcp__claude-flow__agent_spawn (coder)
-  - mcp__claude-flow__agent_spawn (analyst)
-  - mcp__claude-flow__agent_spawn (tester)
-  - mcp__claude-flow__agent_spawn (coordinator)
+  - mcp__snow-flow__swarm_init
+  - mcp__snow-flow__agent_spawn (researcher)
+  - mcp__snow-flow__agent_spawn (coder)
+  - mcp__snow-flow__agent_spawn (analyst)
+  - mcp__snow-flow__agent_spawn (tester)
+  - mcp__snow-flow__agent_spawn (coordinator)
 
 Message 2: [BatchTool - Claude Code execution]
   // Task agents with full coordination instructions
@@ -1269,7 +1269,7 @@ When given ANY complex task with swarms:
 STEP 1: IMMEDIATE PARALLEL SPAWN (Single Message!)
 [BatchTool]:
   // IMPORTANT: Check CLI args for agent count, otherwise auto-decide based on task complexity
-  - mcp__claude-flow__swarm_init {
+  - mcp__snow-flow__swarm_init {
       topology: "hierarchical",
       maxAgents: CLI_ARGS.agents || AUTO_DECIDE(task_complexity), // Use CLI args or auto-decide
       strategy: "parallel"
@@ -1277,19 +1277,19 @@ STEP 1: IMMEDIATE PARALLEL SPAWN (Single Message!)
 
   // Spawn agents based on maxAgents count and task requirements
   // If CLI specifies 3 agents, spawn 3. If no args, auto-decide optimal count (3-12)
-  - mcp__claude-flow__agent_spawn { type: "architect", name: "System Designer" }
-  - mcp__claude-flow__agent_spawn { type: "coder", name: "API Developer" }
-  - mcp__claude-flow__agent_spawn { type: "coder", name: "Frontend Dev" }
-  - mcp__claude-flow__agent_spawn { type: "analyst", name: "DB Designer" }
-  - mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }
-  - mcp__claude-flow__agent_spawn { type: "researcher", name: "Tech Lead" }
-  - mcp__claude-flow__agent_spawn { type: "coordinator", name: "PM" }
+  - mcp__snow-flow__agent_spawn { type: "architect", name: "System Designer" }
+  - mcp__snow-flow__agent_spawn { type: "coder", name: "API Developer" }
+  - mcp__snow-flow__agent_spawn { type: "coder", name: "Frontend Dev" }
+  - mcp__snow-flow__agent_spawn { type: "analyst", name: "DB Designer" }
+  - mcp__snow-flow__agent_spawn { type: "tester", name: "QA Engineer" }
+  - mcp__snow-flow__agent_spawn { type: "researcher", name: "Tech Lead" }
+  - mcp__snow-flow__agent_spawn { type: "coordinator", name: "PM" }
   - TodoWrite { todos: [multiple todos at once] }
 
 STEP 2: PARALLEL TASK EXECUTION (Single Message!)
 [BatchTool]:
-  - mcp__claude-flow__task_orchestrate { task: "main task", strategy: "parallel" }
-  - mcp__claude-flow__memory_usage { action: "store", key: "init", value: {...} }
+  - mcp__snow-flow__task_orchestrate { task: "main task", strategy: "parallel" }
+  - mcp__snow-flow__memory_usage { action: "store", key: "init", value: {...} }
   - Multiple Read operations
   - Multiple Write operations
   - Multiple Bash commands
@@ -1334,13 +1334,13 @@ Dependencies: ↳ X deps | Actionable: ▶
 // ✅ CORRECT: SINGLE MESSAGE with ALL operations
 [BatchTool - Message 1]:
   // Initialize and spawn ALL agents at once
-  mcp__claude-flow__swarm_init { topology: "hierarchical", maxAgents: 8, strategy: "parallel" }
-  mcp__claude-flow__agent_spawn { type: "architect", name: "System Designer" }
-  mcp__claude-flow__agent_spawn { type: "coder", name: "API Developer" }
-  mcp__claude-flow__agent_spawn { type: "coder", name: "Auth Expert" }
-  mcp__claude-flow__agent_spawn { type: "analyst", name: "DB Designer" }
-  mcp__claude-flow__agent_spawn { type: "tester", name: "Test Engineer" }
-  mcp__claude-flow__agent_spawn { type: "coordinator", name: "Lead" }
+  mcp__snow-flow__swarm_init { topology: "hierarchical", maxAgents: 8, strategy: "parallel" }
+  mcp__snow-flow__agent_spawn { type: "architect", name: "System Designer" }
+  mcp__snow-flow__agent_spawn { type: "coder", name: "API Developer" }
+  mcp__snow-flow__agent_spawn { type: "coder", name: "Auth Expert" }
+  mcp__snow-flow__agent_spawn { type: "analyst", name: "DB Designer" }
+  mcp__snow-flow__agent_spawn { type: "tester", name: "Test Engineer" }
+  mcp__snow-flow__agent_spawn { type: "coordinator", name: "Lead" }
 
   // Update ALL todos at once - NEVER split todos!
   TodoWrite { todos: [
@@ -1355,10 +1355,10 @@ Dependencies: ↳ X deps | Actionable: ▶
   ]}
 
   // Start orchestration
-  mcp__claude-flow__task_orchestrate { task: "Build REST API", strategy: "parallel" }
+  mcp__snow-flow__task_orchestrate { task: "Build REST API", strategy: "parallel" }
 
   // Store initial memory
-  mcp__claude-flow__memory_usage { action: "store", key: "project/init", value: { started: Date.now() } }
+  mcp__snow-flow__memory_usage { action: "store", key: "project/init", value: { started: Date.now() } }
 
 [BatchTool - Message 2]:
   // Create ALL directories at once
@@ -1389,9 +1389,9 @@ Dependencies: ↳ X deps | Actionable: ▶
 
 ```javascript
 // ❌ WRONG: Multiple messages, one operation each
-Message 1: mcp__claude-flow__swarm_init
-Message 2: mcp__claude-flow__agent_spawn (just one agent)
-Message 3: mcp__claude-flow__agent_spawn (another agent)
+Message 1: mcp__snow-flow__swarm_init
+Message 2: mcp__snow-flow__agent_spawn (just one agent)
+Message 3: mcp__snow-flow__agent_spawn (another agent)
 Message 4: TodoWrite (single todo)
 Message 5: Write (single file)
 // This is 5x slower and wastes swarm coordination!
@@ -1403,7 +1403,7 @@ Every agent coordination step MUST use memory:
 
 ```
 // After each major decision or implementation
-mcp__claude-flow__memory_usage
+mcp__snow-flow__memory_usage
   action: "store"
   key: "swarm-{id}/agent-{name}/{step}"
   value: {
@@ -1415,12 +1415,12 @@ mcp__claude-flow__memory_usage
   }
 
 // To retrieve coordination data
-mcp__claude-flow__memory_usage
+mcp__snow-flow__memory_usage
   action: "retrieve"
   key: "swarm-{id}/agent-{name}/{step}"
 
 // To check all swarm progress
-mcp__claude-flow__memory_usage
+mcp__snow-flow__memory_usage
   action: "list"
   pattern: "swarm-{id}/*"
 ```
@@ -1430,7 +1430,7 @@ mcp__claude-flow__memory_usage
 1. **Batch Everything**: Never operate on single files when multiple are needed
 2. **Parallel First**: Always think "what can run simultaneously?"
 3. **Memory is Key**: Use memory for ALL cross-agent coordination
-4. **Monitor Progress**: Use mcp**claude-flow**swarm_monitor for real-time tracking
+4. **Monitor Progress**: Use mcp**snow-flow**swarm_monitor for real-time tracking
 5. **Auto-Optimize**: Let hooks handle topology and agent selection
 
 ### 🎨 VISUAL SWARM STATUS
@@ -1513,10 +1513,10 @@ Claude Flow extends the base coordination with:
 
 ## Support
 
-- Documentation: https://github.com/ruvnet/claude-flow
-- Issues: https://github.com/ruvnet/claude-flow/issues
-- Examples: https://github.com/ruvnet/claude-flow/tree/main/examples
+- Documentation: https://github.com/groeimetai/snow-flow
+- Issues: https://github.com/groeimetai/snow-flow/issues
+- Examples: https://github.com/groeimetai/snow-flow/tree/main/examples
 
 ---
 
-Remember: **Claude Flow coordinates, Claude Code creates!** Start with `mcp__claude-flow__swarm_init` to enhance your development workflow.
+Remember: **Snow-Flow coordinates, Claude Code creates!** Start with `mcp__snow-flow__swarm_init` to enhance your development workflow.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "1.4.11",
+  "version": "1.4.12",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 14 AI-powered analysis tools with multi-agent orchestration. Zero Mock Data, 100% Real API Integration. Revolutionize ServiceNow development with hive-mind intelligence.",
   "main": "dist/index.js",
   "type": "commonjs",