claude-flow 2.0.0-alpha.45 → 2.0.0-alpha.49

package/bin/claude-flow

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Claude-Flow Smart Dispatcher - Detects and uses the best available runtime
 
-VERSION="2.0.0-alpha.45"
+VERSION="2.0.0-alpha.49"
 
 # Determine the correct path based on how the script is invoked
 if [ -L "$0" ]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "2.0.0-alpha.45",
+  "version": "2.0.0-alpha.49",
   "description": "Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)",
   "main": "cli.mjs",
   "bin": {

package/src/cli/help-text.js

@@ -3,7 +3,7 @@
  * Provides clear, actionable command documentation
  */
 
-export const VERSION = '2.0.0-alpha.45';
+export const VERSION = '2.0.0-alpha.49';
 
 export const MAIN_HELP = `
 🌊 Claude-Flow v${VERSION} - Enterprise-Grade AI Agent Orchestration Platform

package/src/cli/index.ts

@@ -186,7 +186,7 @@ function setupSignalHandlers(): void {
 }
 
 // Main entry point
-if (false // import.meta.main not available) {
+if (false) { // import.meta.main not available
   let globalOptions: any = {};
   
   try {

package/src/cli/node-repl.ts

@@ -387,8 +387,8 @@ export async function startNodeREPL(options: any = {}): Promise<void> {
   
   // Set completer function
   // rl.completer = (line: string) => {
-    return completer.complete(line);
-  };
+  //   return completer.complete(line);
+  // };
   
   // Show initial status
   if (options.banner !== false) {

package/src/cli/simple-cli.js

@@ -18,7 +18,7 @@ import process from 'process';
 import readline from 'readline';
 import { getMainHelp, getCommandHelp } from './help-text.js';
 
-const VERSION = '2.0.0';
+const VERSION = '2.0.0-alpha.49';
 
 function printHelp() {
   console.log(getMainHelp());

package/src/cli/simple-commands/init/index.js

@@ -1132,17 +1132,24 @@ ${commands.map(cmd => `- [${cmd}](./${cmd}.md)`).join('\n')}
       
       printSuccess('✓ Initialized memory system');
       
-      // Initialize memory database
+      // Initialize memory database with fallback support
       try {
-        // Import and initialize SqliteMemoryStore to create the database
-        const { SqliteMemoryStore } = await import('../../../memory/sqlite-store.js');
-        const memoryStore = new SqliteMemoryStore();
+        // Import and initialize FallbackMemoryStore to create the database
+        const { FallbackMemoryStore } = await import('../../../memory/fallback-store.js');
+        const memoryStore = new FallbackMemoryStore();
         await memoryStore.initialize();
+        
+        if (memoryStore.isUsingFallback()) {
+          printSuccess('✓ Initialized memory system (in-memory fallback for npx compatibility)');
+          console.log('  💡 For persistent storage, install locally: npm install claude-flow@alpha');
+        } else {
+          printSuccess('✓ Initialized memory database (.swarm/memory.db)');
+        }
+        
         memoryStore.close();
-        printSuccess('✓ Initialized memory database (.swarm/memory.db)');
       } catch (err) {
-        console.log(`  ⚠️  Could not initialize memory database: ${err.message}`);
-        console.log('     The database will be created on first use');
+        console.log(`  ⚠️  Could not initialize memory system: ${err.message}`);
+        console.log('     Memory will be initialized on first use');
       }
     }
     

package/src/cli/simple-commands/init/templates/CLAUDE.md

@@ -8,6 +8,60 @@
 3. **File operations** → Batch ALL reads/writes together
 4. **NEVER** operate sequentially after swarm init
 
+## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
+
+**ABSOLUTE RULE**: ALL operations MUST be concurrent/parallel in a single message:
+
+### 🔴 MANDATORY CONCURRENT PATTERNS:
+1. **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+2. **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
+3. **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+4. **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+5. **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**Examples of CORRECT concurrent execution:**
+```javascript
+// ✅ CORRECT: Everything in ONE message
+[Single Message]:
+  - TodoWrite { todos: [10+ todos with all statuses/priorities] }
+  - Task("Agent 1 with full instructions and hooks")
+  - Task("Agent 2 with full instructions and hooks")
+  - Task("Agent 3 with full instructions and hooks")
+  - Read("file1.js")
+  - Read("file2.js")
+  - Read("file3.js")
+  - Write("output1.js", content)
+  - Write("output2.js", content)
+  - Bash("npm install")
+  - Bash("npm test")
+  - Bash("npm run build")
+```
+
+**Examples of WRONG sequential execution:**
+```javascript
+// ❌ WRONG: Multiple messages (NEVER DO THIS)
+Message 1: TodoWrite { todos: [single todo] }
+Message 2: Task("Agent 1")
+Message 3: Task("Agent 2")
+Message 4: Read("file1.js")
+Message 5: Write("output1.js")
+Message 6: Bash("npm install")
+// This is 6x slower and breaks coordination!
+```
+
+### 🎯 CONCURRENT EXECUTION CHECKLIST:
+
+Before sending ANY message, ask yourself:
+- ✅ Are ALL related TodoWrite operations batched together?
+- ✅ Are ALL Task spawning operations in ONE message?
+- ✅ Are ALL file operations (Read/Write/Edit) batched together?
+- ✅ Are ALL bash commands grouped in ONE message?
+- ✅ Are ALL memory operations concurrent?
+
+If ANY answer is "No", you MUST combine operations into a single message!
+
 ## 🚀 CRITICAL: Claude Code Does ALL Real Work
 
 ### 🎯 CLAUDE CODE IS THE ONLY EXECUTOR
@@ -61,14 +115,17 @@
 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)
-4. **Claude Code**: `Read`, `Write`, `Edit`, `Bash` (actual work)
-5. **Claude Code**: `TodoWrite` (task management)
-6. **MCP**: `mcp__claude-flow__memory_usage` (store results)
+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)
 
 **❌ WRONG Workflow:**
 1. **MCP**: `mcp__claude-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)
+5. **Claude Code**: Individual TodoWrite calls (DON'T DO THIS)
 
 ### 🚨 REMEMBER:
 - **MCP tools** = Coordination, planning, memory, intelligence
@@ -103,13 +160,22 @@ If you need to do X operations, they should be in 1 message, not X messages
 **✅ CORRECT - Everything in ONE Message:**
 ```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" }
-  TodoWrite { todos: [todo1, todo2, todo3, todo4, todo5] }
+  
+  // Claude Code execution - ALL in parallel
+  Task("You are researcher agent. MUST coordinate via hooks...")
+  Task("You are coder agent. MUST coordinate via hooks...")
+  Task("You are analyst agent. MUST coordinate via hooks...")
+  Task("You are tester agent. MUST coordinate via hooks...")
+  TodoWrite { todos: [5-10 todos with all priorities and statuses] }
+  
+  // File operations in parallel
   Bash "mkdir -p app/{src,tests,docs}"
   Write "app/package.json" 
   Write "app/README.md"
@@ -119,9 +185,9 @@ 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 2: mcp__claude-flow__agent_spawn 
-Message 3: mcp__claude-flow__agent_spawn
-Message 4: TodoWrite (one todo)
+Message 2: Task("researcher agent")
+Message 3: Task("coder agent")
+Message 4: TodoWrite({ todo: "single todo" })
 Message 5: Bash "mkdir src"
 Message 6: Write "package.json"
 // This is 6x slower and breaks parallel coordination!
@@ -130,10 +196,11 @@ Message 6: Write "package.json"
 ### 🎯 BATCH OPERATIONS BY TYPE
 
 **Todo and Task Operations (Single Message):**
-- TodoWrite? → ALWAYS include 5-10+ todos in ONE call
-- Task agents? → Spawn ALL agents in ONE message
-- Updates? → Update ALL todo statuses together
-- Never split todos or tasks across messages!
+- **TodoWrite** → ALWAYS include 5-10+ todos in ONE call
+- **Task agents** → Spawn ALL agents with full instructions in ONE message
+- **Agent coordination** → ALL Task calls must include coordination hooks
+- **Status updates** → Update ALL todo statuses together
+- **NEVER** split todos or Task calls across messages!
 
 **File Operations (Single Message):**
 - Read 10 files? → One message with 10 Read calls
@@ -484,22 +551,36 @@ Message 6: TodoWrite (another single todo)
 **THIS IS CORRECT ✅ (Parallel - ALWAYS DO THIS):**
 ```
 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 (coder)  
   - mcp__claude-flow__agent_spawn (analyst)
   - mcp__claude-flow__agent_spawn (tester)
   - mcp__claude-flow__agent_spawn (coordinator)
-  - TodoWrite { todos: [ALL 5-10 todos at once] }
-
-Message 2: [BatchTool]  
-  - Task (spawn agent 1 with full task)
-  - Task (spawn agent 2 with full task)
-  - Task (spawn agent 3 with full task)
-  - Write file1.js
-  - Write file2.js
-  - Write file3.js
-  - Bash mkdir commands
+
+Message 2: [BatchTool - Claude Code execution]
+  // Task agents with full coordination instructions
+  - Task("You are researcher agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Research API patterns")
+  - Task("You are coder agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Implement REST endpoints")
+  - Task("You are analyst agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Analyze performance")
+  - Task("You are tester agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Write comprehensive tests")
+  
+  // TodoWrite with ALL todos batched
+  - TodoWrite { todos: [
+      {id: "research", content: "Research API patterns", status: "in_progress", priority: "high"},
+      {id: "design", content: "Design database schema", status: "pending", priority: "high"},
+      {id: "implement", content: "Build REST endpoints", status: "pending", priority: "high"},
+      {id: "test", content: "Write unit tests", status: "pending", priority: "medium"},
+      {id: "docs", content: "Create API documentation", status: "pending", priority: "low"},
+      {id: "deploy", content: "Setup deployment", status: "pending", priority: "medium"}
+    ]}
+  
+  // File operations in parallel
+  - Write "api/package.json"
+  - Write "api/server.js"
+  - Write "api/routes/users.js"
+  - Bash "mkdir -p api/{routes,models,tests}"
 ```
 
 ### 🎯 MANDATORY SWARM PATTERN

package/src/cli/simple-commands/init/templates/claude-md.js

@@ -3,6 +3,29 @@
 export function createMinimalClaudeMd() {
   return `# Claude Code Configuration
 
+## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
+
+**ABSOLUTE RULE**: ALL operations MUST be concurrent/parallel in a single message:
+
+### 🔴 MANDATORY CONCURRENT PATTERNS:
+1. **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+2. **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
+3. **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+4. **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**✅ CORRECT**: Everything in ONE message
+**❌ WRONG**: Multiple messages for related operations (6x slower!)
+
+### 🎯 CONCURRENT EXECUTION CHECKLIST:
+- ✅ Are ALL related TodoWrite operations batched together?
+- ✅ Are ALL Task spawning operations in ONE message?
+- ✅ Are ALL file operations (Read/Write/Edit) batched together?
+- ✅ Are ALL bash commands grouped in ONE message?
+
+If ANY answer is "No", you MUST combine operations into a single message!
+
 ## Build Commands
 - \`npm run build\`: Build the project
 - \`npm run test\`: Run tests
@@ -21,6 +44,59 @@ This is a Claude-Flow AI agent orchestration system.
 export function createFullClaudeMd() {
   return `# Claude Code Configuration
 
+## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
+
+**ABSOLUTE RULE**: ALL operations MUST be concurrent/parallel in a single message:
+
+### 🔴 MANDATORY CONCURRENT PATTERNS:
+1. **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+2. **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
+3. **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+4. **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+5. **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**Examples of CORRECT concurrent execution:**
+\`\`\`javascript
+// ✅ CORRECT: Everything in ONE message
+[Single Message]:
+  - TodoWrite { todos: [10+ todos with all statuses/priorities] }
+  - Task("Agent 1 with full instructions and hooks")
+  - Task("Agent 2 with full instructions and hooks")
+  - Task("Agent 3 with full instructions and hooks")
+  - Read("file1.js")
+  - Read("file2.js")
+  - Write("output1.js", content)
+  - Write("output2.js", content)
+  - Bash("npm install")
+  - Bash("npm test")
+  - Bash("npm run build")
+\`\`\`
+
+**Examples of WRONG sequential execution:**
+\`\`\`javascript
+// ❌ WRONG: Multiple messages (NEVER DO THIS)
+Message 1: TodoWrite { todos: [single todo] }
+Message 2: Task("Agent 1")
+Message 3: Task("Agent 2")
+Message 4: Read("file1.js")
+Message 5: Write("output1.js")
+Message 6: Bash("npm install")
+// This is 6x slower and breaks coordination!
+\`\`\`
+
+### 🎯 CONCURRENT EXECUTION CHECKLIST:
+
+Before sending ANY message, ask yourself:
+- ✅ Are ALL related TodoWrite operations batched together?
+- ✅ Are ALL Task spawning operations in ONE message?
+- ✅ Are ALL file operations (Read/Write/Edit) batched together?
+- ✅ Are ALL bash commands grouped in ONE message?
+- ✅ Are ALL memory operations concurrent?
+
+If ANY answer is "No", you MUST combine operations into a single message!
+
 ## Build Commands
 - \`npm run build\`: Build the project using Deno compile
 - \`npm run test\`: Run the full test suite
@@ -71,6 +147,59 @@ This is a Claude-Flow AI agent orchestration system with the following component
 export function createSparcClaudeMd() {
   return `# Claude Code Configuration - SPARC Development Environment
 
+## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
+
+**ABSOLUTE RULE**: ALL operations MUST be concurrent/parallel in a single message:
+
+### 🔴 MANDATORY CONCURRENT PATTERNS:
+1. **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+2. **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
+3. **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+4. **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+5. **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**Examples of CORRECT concurrent execution:**
+\`\`\`javascript
+// ✅ CORRECT: Everything in ONE message
+[Single Message]:
+  - TodoWrite { todos: [10+ todos with all statuses/priorities] }
+  - Task("Agent 1 with full instructions and hooks")
+  - Task("Agent 2 with full instructions and hooks")
+  - Task("Agent 3 with full instructions and hooks")
+  - Read("file1.js")
+  - Read("file2.js")
+  - Write("output1.js", content)
+  - Write("output2.js", content)
+  - Bash("npm install")
+  - Bash("npm test")
+  - Bash("npm run build")
+\`\`\`
+
+**Examples of WRONG sequential execution:**
+\`\`\`javascript
+// ❌ WRONG: Multiple messages (NEVER DO THIS)
+Message 1: TodoWrite { todos: [single todo] }
+Message 2: Task("Agent 1")
+Message 3: Task("Agent 2")
+Message 4: Read("file1.js")
+Message 5: Write("output1.js")
+Message 6: Bash("npm install")
+// This is 6x slower and breaks coordination!
+\`\`\`
+
+### 🎯 CONCURRENT EXECUTION CHECKLIST:
+
+Before sending ANY message, ask yourself:
+- ✅ Are ALL related TodoWrite operations batched together?
+- ✅ Are ALL Task spawning operations in ONE message?
+- ✅ Are ALL file operations (Read/Write/Edit) batched together?
+- ✅ Are ALL bash commands grouped in ONE message?
+- ✅ Are ALL memory operations concurrent?
+
+If ANY answer is "No", you MUST combine operations into a single message!
+
 ## Project Overview
 This project uses the SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology for systematic Test-Driven Development with AI assistance through Claude-Flow orchestration.
 
@@ -344,6 +473,59 @@ For more information about SPARC methodology, see: https://github.com/ruvnet/cla
 export async function createOptimizedSparcClaudeMd() {
   return `# Claude Code Configuration - SPARC Development Environment (Batchtools Optimized)
 
+## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
+
+**ABSOLUTE RULE**: ALL operations MUST be concurrent/parallel in a single message:
+
+### 🔴 MANDATORY CONCURRENT PATTERNS:
+1. **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+2. **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
+3. **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+4. **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+5. **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**Examples of CORRECT concurrent execution:**
+\`\`\`javascript
+// ✅ CORRECT: Everything in ONE message
+[Single Message]:
+  - TodoWrite { todos: [10+ todos with all statuses/priorities] }
+  - Task("Agent 1 with full instructions and hooks")
+  - Task("Agent 2 with full instructions and hooks")
+  - Task("Agent 3 with full instructions and hooks")
+  - Read("file1.js")
+  - Read("file2.js")
+  - Write("output1.js", content)
+  - Write("output2.js", content)
+  - Bash("npm install")
+  - Bash("npm test")
+  - Bash("npm run build")
+\`\`\`
+
+**Examples of WRONG sequential execution:**
+\`\`\`javascript
+// ❌ WRONG: Multiple messages (NEVER DO THIS)
+Message 1: TodoWrite { todos: [single todo] }
+Message 2: Task("Agent 1")
+Message 3: Task("Agent 2")
+Message 4: Read("file1.js")
+Message 5: Write("output1.js")
+Message 6: Bash("npm install")
+// This is 6x slower and breaks coordination!
+\`\`\`
+
+### 🎯 CONCURRENT EXECUTION CHECKLIST:
+
+Before sending ANY message, ask yourself:
+- ✅ Are ALL related TodoWrite operations batched together?
+- ✅ Are ALL Task spawning operations in ONE message?
+- ✅ Are ALL file operations (Read/Write/Edit) batched together?
+- ✅ Are ALL bash commands grouped in ONE message?
+- ✅ Are ALL memory operations concurrent?
+
+If ANY answer is "No", you MUST combine operations into a single message!
+
 ## Project Overview
 This project uses the SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology for systematic Test-Driven Development with AI assistance through Claude-Flow orchestration.
 

package/src/mcp/mcp-server.js

@@ -15,7 +15,7 @@ const __dirname = path.dirname(__filename);
 
 class ClaudeFlowMCPServer {
   constructor() {
-    this.version = '2.0.0';
+    this.version = '2.0.0-alpha.49';
     this.memoryStore = new EnhancedMemory();
     this.capabilities = {
       tools: {