claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.62

package/src/cli/simple-commands/init/claude-commands/optimized-sparc-commands.js

@@ -3,9 +3,10 @@
 // Create batchtools-optimized SPARC mode slash command
 export function createOptimizedSparcSlashCommand(mode) {
   // Extract the full description without truncation
-  const fullDescription = mode.roleDefinition.length > 100 
-    ? `${mode.roleDefinition.substring(0, 97)}...` 
-    : mode.roleDefinition;
+  const fullDescription =
+    mode.roleDefinition.length > 100
+      ? `${mode.roleDefinition.substring(0, 97)}...`
+      : mode.roleDefinition;
 
   return `---
 name: sparc-${mode.slug}
@@ -35,14 +36,20 @@ ${mode.customInstructions}
 - **Resource Optimization**: Efficient utilization with parallel processing
 
 ## Available Tools (Enhanced)
-${Array.isArray(mode.groups) ? mode.groups.map(g => {
-  if (typeof g === 'string') {
-    return `- **${g}**: ${getOptimizedToolDescription(g)}`;
-  } else if (Array.isArray(g)) {
-    return `- **${g[0]}**: ${g[1]?.description || getOptimizedToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''} - *Batchtools enabled*`;
-  }
-  return `- ${JSON.stringify(g)}`;
-}).join('\n') : 'None'}
+${
+  Array.isArray(mode.groups)
+    ? mode.groups
+        .map((g) => {
+          if (typeof g === 'string') {
+            return `- **${g}**: ${getOptimizedToolDescription(g)}`;
+          } else if (Array.isArray(g)) {
+            return `- **${g[0]}**: ${g[1]?.description || getOptimizedToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''} - *Batchtools enabled*`;
+          }
+          return `- ${JSON.stringify(g)}`;
+        })
+        .join('\n')
+    : 'None'
+}
 
 ### Batchtools Integration
 - **parallel()**: Execute multiple operations concurrently
@@ -179,11 +186,11 @@ For detailed ${mode.name} documentation and batchtools integration guides, see:
 // Helper function to get optimized tool descriptions
 function getOptimizedToolDescription(tool) {
   const toolDescriptions = {
-    'read': 'File reading and viewing with parallel processing',
-    'edit': 'File modification and creation with batch operations',
-    'browser': 'Web browsing capabilities with concurrent requests',
-    'mcp': 'Model Context Protocol tools with parallel communication',
-    'command': 'Command execution with concurrent processing'
+    read: 'File reading and viewing with parallel processing',
+    edit: 'File modification and creation with batch operations',
+    browser: 'Web browsing capabilities with concurrent requests',
+    mcp: 'Model Context Protocol tools with parallel communication',
+    command: 'Command execution with concurrent processing',
   };
   return toolDescriptions[tool] || 'Tool access with batchtools optimization';
 }
@@ -191,23 +198,24 @@ function getOptimizedToolDescription(tool) {
 // Helper function to get optimized example tasks
 function getOptimizedExampleTask(slug) {
   const examples = {
-    'architect': 'design microservices architecture with parallel component analysis',
-    'code': 'implement REST API endpoints with concurrent optimization',
-    'tdd': 'create user authentication tests with parallel test generation',
-    'debug': 'fix memory leak in service with concurrent analysis',
+    architect: 'design microservices architecture with parallel component analysis',
+    code: 'implement REST API endpoints with concurrent optimization',
+    tdd: 'create user authentication tests with parallel test generation',
+    debug: 'fix memory leak in service with concurrent analysis',
     'security-review': 'audit API security with parallel vulnerability assessment',
     'docs-writer': 'create API documentation with concurrent content generation',
-    'integration': 'connect payment service with parallel testing',
-    'post-deployment-monitoring-mode': 'monitor production metrics with real-time parallel analysis',
+    integration: 'connect payment service with parallel testing',
+    'post-deployment-monitoring-mode':
+      'monitor production metrics with real-time parallel analysis',
     'refinement-optimization-mode': 'optimize database queries with concurrent profiling',
-    'devops': 'deploy to AWS Lambda with parallel environment setup',
+    devops: 'deploy to AWS Lambda with parallel environment setup',
     'supabase-admin': 'create user authentication schema with batch operations',
     'spec-pseudocode': 'define payment flow requirements with concurrent validation',
-    'mcp': 'integrate with external API using parallel configuration',
-    'swarm': 'build complete feature with parallel testing and documentation',
-    'sparc': 'orchestrate authentication system with concurrent coordination',
-    'ask': 'help me choose the right mode with parallel analysis',
-    'tutorial': 'guide me through SPARC methodology with interactive parallel examples'
+    mcp: 'integrate with external API using parallel configuration',
+    swarm: 'build complete feature with parallel testing and documentation',
+    sparc: 'orchestrate authentication system with concurrent coordination',
+    ask: 'help me choose the right mode with parallel analysis',
+    tutorial: 'guide me through SPARC methodology with interactive parallel examples',
   };
   return examples[slug] || 'implement feature with batchtools optimization';
 }
@@ -215,99 +223,105 @@ function getOptimizedExampleTask(slug) {
 // Helper function to get batchtools best practices for specific modes
 function getBatchtoolsPractices(slug) {
   const practices = {
-    'architect': {
+    architect: {
       parallel: [
         'Analyzing multiple architectural patterns simultaneously',
         'Generating component diagrams concurrently',
         'Validating integration points in parallel',
-        'Creating multiple design alternatives simultaneously'
+        'Creating multiple design alternatives simultaneously',
       ],
       optimization: [
         'Use batch operations for creating multiple architecture documents',
         'Enable parallel analysis for complex system designs',
         'Implement concurrent validation for architectural decisions',
-        'Use pipeline processing for multi-stage architecture design'
+        'Use pipeline processing for multi-stage architecture design',
       ],
       performance: [
         'Monitor resource usage during large architecture analysis',
         'Use smart batching for related architectural components',
         'Enable concurrent processing for independent design elements',
-        'Implement parallel validation for architecture consistency'
-      ]
+        'Implement parallel validation for architecture consistency',
+      ],
     },
-    'code': {
+    code: {
       parallel: [
         'Implementing multiple functions or classes simultaneously',
         'Analyzing code patterns across multiple files',
         'Performing concurrent code optimization',
-        'Generating multiple code modules in parallel'
+        'Generating multiple code modules in parallel',
       ],
       optimization: [
         'Use batch operations for creating multiple source files',
         'Enable parallel code analysis for large codebases',
         'Implement concurrent optimization for performance improvements',
-        'Use pipeline processing for multi-stage code generation'
+        'Use pipeline processing for multi-stage code generation',
       ],
       performance: [
         'Monitor compilation performance during parallel code generation',
         'Use smart batching for related code modules',
         'Enable concurrent processing for independent code components',
-        'Implement parallel validation for code quality checks'
-      ]
+        'Implement parallel validation for code quality checks',
+      ],
     },
-    'tdd': {
+    tdd: {
       parallel: [
         'Creating multiple test cases simultaneously',
         'Running test suites concurrently',
         'Analyzing test coverage in parallel',
-        'Generating test data and fixtures simultaneously'
+        'Generating test data and fixtures simultaneously',
       ],
       optimization: [
         'Use batch operations for creating comprehensive test suites',
         'Enable parallel test execution for faster feedback',
         'Implement concurrent test analysis for coverage reports',
-        'Use pipeline processing for multi-stage testing workflows'
+        'Use pipeline processing for multi-stage testing workflows',
       ],
       performance: [
         'Monitor test execution performance during parallel runs',
         'Use smart batching for related test scenarios',
         'Enable concurrent processing for independent test modules',
-        'Implement parallel validation for test result analysis'
-      ]
-    }
-  };
-  
-  return practices[slug] || {
-    parallel: [
-      'Processing multiple independent components simultaneously',
-      'Analyzing different aspects concurrently',
-      'Generating multiple artifacts in parallel',
-      'Validating multiple criteria simultaneously'
-    ],
-    optimization: [
-      'Use batch operations for related tasks',
-      'Enable parallel processing for independent operations',
-      'Implement concurrent validation and analysis',
-      'Use pipeline processing for complex workflows'
-    ],
-    performance: [
-      'Monitor system resources during parallel operations',
-      'Use smart batching for optimal performance',
-      'Enable concurrent processing based on system capabilities',
-      'Implement parallel validation for comprehensive analysis'
-    ]
+        'Implement parallel validation for test result analysis',
+      ],
+    },
   };
+
+  return (
+    practices[slug] || {
+      parallel: [
+        'Processing multiple independent components simultaneously',
+        'Analyzing different aspects concurrently',
+        'Generating multiple artifacts in parallel',
+        'Validating multiple criteria simultaneously',
+      ],
+      optimization: [
+        'Use batch operations for related tasks',
+        'Enable parallel processing for independent operations',
+        'Implement concurrent validation and analysis',
+        'Use pipeline processing for complex workflows',
+      ],
+      performance: [
+        'Monitor system resources during parallel operations',
+        'Use smart batching for optimal performance',
+        'Enable concurrent processing based on system capabilities',
+        'Implement parallel validation for comprehensive analysis',
+      ],
+    }
+  );
 }
 
 // Create optimized main SPARC command
 export function createOptimizedMainSparcCommand(modes) {
-  const modeList = modes.map(m => `- \`/sparc-${m.slug}\` - ${m.name} (Batchtools optimized)`).join('\n');
-  
+  const modeList = modes
+    .map((m) => `- \`/sparc-${m.slug}\` - ${m.name} (Batchtools optimized)`)
+    .join('\n');
+
   // Find the sparc orchestrator mode for its full description
-  const sparcMode = modes.find(m => m.slug === 'sparc');
-  const sparcDescription = sparcMode ? sparcMode.roleDefinition : 'SPARC orchestrator for complex workflows';
+  const sparcMode = modes.find((m) => m.slug === 'sparc');
+  const sparcDescription = sparcMode
+    ? sparcMode.roleDefinition
+    : 'SPARC orchestrator for complex workflows';
   const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
-  
+
   return `---
 name: sparc
 description: Execute SPARC methodology workflows with Claude-Flow and batchtools optimization
@@ -484,4 +498,4 @@ For comprehensive SPARC and batchtools documentation, see:
 - Batchtools Documentation: https://github.com/ruvnet/claude-code-flow/docs/batchtools.md
 - Performance Optimization: https://github.com/ruvnet/claude-code-flow/docs/performance.md
 `;
-}
+}

package/src/cli/simple-commands/init/claude-commands/slash-commands.js

@@ -7,29 +7,28 @@ import { createClaudeFlowCommands } from './claude-flow-commands.js';
 export async function createClaudeSlashCommands(workingDir) {
   try {
     console.log('\n📝 Creating Claude Code slash commands...');
-    
+
     // Parse .roomodes to get all SPARC modes
     const roomodesContent = await Deno.readTextFile(`${workingDir}/.roomodes`);
     const roomodes = JSON.parse(roomodesContent);
-    
+
     // Create slash commands for each SPARC mode
     for (const mode of roomodes.customModes) {
       const commandPath = `${workingDir}/.claude/commands/sparc/${mode.slug}.md`;
       const commandContent = createSparcSlashCommand(mode);
-      
+
       await Deno.writeTextFile(commandPath, commandContent);
       console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
     }
-    
+
     // Create main SPARC command
     const mainSparcCommand = createMainSparcCommand(roomodes.customModes);
     await Deno.writeTextFile(`${workingDir}/.claude/commands/sparc.md`, mainSparcCommand);
     console.log('  ✓ Created main slash command: /sparc');
-    
+
     // Create claude-flow specific commands
     await createClaudeFlowCommands(workingDir);
-    
   } catch (err) {
     console.log(`  ⚠️  Could not create Claude Code slash commands: ${err.message}`);
   }
-}
+}

package/src/cli/simple-commands/init/claude-commands/sparc-commands.js

@@ -3,9 +3,10 @@
 // Create SPARC mode slash command
 export function createSparcSlashCommand(mode) {
   // Extract the full description without truncation
-  const fullDescription = mode.roleDefinition.length > 100 
-    ? `${mode.roleDefinition.substring(0, 97)}...` 
-    : mode.roleDefinition;
+  const fullDescription =
+    mode.roleDefinition.length > 100
+      ? `${mode.roleDefinition.substring(0, 97)}...`
+      : mode.roleDefinition;
 
   return `---
 name: sparc-${mode.slug}
@@ -21,14 +22,20 @@ ${mode.roleDefinition}
 ${mode.customInstructions}
 
 ## Available Tools
-${Array.isArray(mode.groups) ? mode.groups.map(g => {
-  if (typeof g === 'string') {
-    return `- **${g}**: ${getToolDescription(g)}`;
-  } else if (Array.isArray(g)) {
-    return `- **${g[0]}**: ${g[1]?.description || getToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''}`;
-  }
-  return `- ${JSON.stringify(g)}`;
-}).join('\n') : 'None'}
+${
+  Array.isArray(mode.groups)
+    ? mode.groups
+        .map((g) => {
+          if (typeof g === 'string') {
+            return `- **${g}**: ${getToolDescription(g)}`;
+          } else if (Array.isArray(g)) {
+            return `- **${g[0]}**: ${g[1]?.description || getToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''}`;
+          }
+          return `- ${JSON.stringify(g)}`;
+        })
+        .join('\n')
+    : 'None'
+}
 
 ## Usage
 
@@ -67,11 +74,11 @@ To use this SPARC mode, you can:
 // Helper function to get tool descriptions
 function getToolDescription(tool) {
   const toolDescriptions = {
-    'read': 'File reading and viewing',
-    'edit': 'File modification and creation',
-    'browser': 'Web browsing capabilities',
-    'mcp': 'Model Context Protocol tools',
-    'command': 'Command execution'
+    read: 'File reading and viewing',
+    edit: 'File modification and creation',
+    browser: 'Web browsing capabilities',
+    mcp: 'Model Context Protocol tools',
+    command: 'Command execution',
   };
   return toolDescriptions[tool] || 'Tool access';
 }
@@ -79,36 +86,38 @@ function getToolDescription(tool) {
 // Helper function to get example tasks
 function getExampleTask(slug) {
   const examples = {
-    'architect': 'design microservices architecture',
-    'code': 'implement REST API endpoints',
-    'tdd': 'create user authentication tests',
-    'debug': 'fix memory leak in service',
+    architect: 'design microservices architecture',
+    code: 'implement REST API endpoints',
+    tdd: 'create user authentication tests',
+    debug: 'fix memory leak in service',
     'security-review': 'audit API security',
     'docs-writer': 'create API documentation',
-    'integration': 'connect payment service',
+    integration: 'connect payment service',
     'post-deployment-monitoring-mode': 'monitor production metrics',
     'refinement-optimization-mode': 'optimize database queries',
-    'devops': 'deploy to AWS Lambda',
+    devops: 'deploy to AWS Lambda',
     'supabase-admin': 'create user authentication schema',
     'spec-pseudocode': 'define payment flow requirements',
-    'mcp': 'integrate with external API',
-    'swarm': 'build complete feature with tests',
-    'sparc': 'orchestrate authentication system',
-    'ask': 'help me choose the right mode',
-    'tutorial': 'guide me through SPARC methodology'
+    mcp: 'integrate with external API',
+    swarm: 'build complete feature with tests',
+    sparc: 'orchestrate authentication system',
+    ask: 'help me choose the right mode',
+    tutorial: 'guide me through SPARC methodology',
   };
   return examples[slug] || 'implement feature';
 }
 
 // Create main SPARC command
 export function createMainSparcCommand(modes) {
-  const modeList = modes.map(m => `- \`/sparc-${m.slug}\` - ${m.name}`).join('\n');
-  
+  const modeList = modes.map((m) => `- \`/sparc-${m.slug}\` - ${m.name}`).join('\n');
+
   // Find the sparc orchestrator mode for its full description
-  const sparcMode = modes.find(m => m.slug === 'sparc');
-  const sparcDescription = sparcMode ? sparcMode.roleDefinition : 'SPARC orchestrator for complex workflows';
+  const sparcMode = modes.find((m) => m.slug === 'sparc');
+  const sparcDescription = sparcMode
+    ? sparcMode.roleDefinition
+    : 'SPARC orchestrator for complex workflows';
   const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
-  
+
   return `---
 name: sparc
 description: Execute SPARC methodology workflows with Claude-Flow
@@ -207,4 +216,4 @@ For CI/CD integration and automation:
 
 See \`/claude-flow-help\` for all available commands.
 `;
-}
+}

package/src/cli/simple-commands/init/executable-wrapper.js

@@ -51,13 +51,13 @@ npx claude-flow@latest %*
         console.log('  ✓ Created local claude-flow.cmd executable wrapper');
         console.log('    You can now use: claude-flow instead of npx claude-flow');
       }
-      
     } else {
       // Check if we're in development mode (claude-code-flow repo)
       const isDevelopment = workingDir.includes('claude-code-flow');
-      const devBinPath = isDevelopment ? 
-        workingDir.split('claude-code-flow')[0] + 'claude-code-flow/bin/claude-flow' : '';
-      
+      const devBinPath = isDevelopment
+        ? workingDir.split('claude-code-flow')[0] + 'claude-code-flow/bin/claude-flow'
+        : '';
+
       // Create Unix/Linux/Mac shell script
       const wrapperScript = `#!/usr/bin/env bash
 # Claude-Flow local wrapper
@@ -73,13 +73,17 @@ export CLAUDE_WORKING_DIR="\${PROJECT_DIR}"
 # Try to find claude-flow binary
 # Check common locations for npm/npx installations
 
-${isDevelopment ? `# Development mode - use local bin
+${
+  isDevelopment
+    ? `# Development mode - use local bin
 if [ -f "${devBinPath}" ]; then
   cd "\${PROJECT_DIR}"
   exec "${devBinPath}" "$@"
 fi
 
-` : ''}# 1. Local node_modules (npm install claude-flow)
+`
+    : ''
+}# 1. Local node_modules (npm install claude-flow)
 if [ -f "\${PROJECT_DIR}/node_modules/.bin/claude-flow" ]; then
   cd "\${PROJECT_DIR}"
   exec "\${PROJECT_DIR}/node_modules/.bin/claude-flow" "$@"
@@ -104,16 +108,15 @@ fi
       // Write the wrapper script
       if (!dryRun) {
         await writeFile(`${workingDir}/claude-flow`, wrapperScript, 'utf8');
-        
+
         // Make it executable
         await chmod(`${workingDir}/claude-flow`, 0o755);
-        
+
         console.log('  ✓ Created local claude-flow executable wrapper');
         console.log('    You can now use: ./claude-flow instead of npx claude-flow');
       }
     }
-    
   } catch (err) {
     console.log(`  ⚠️  Could not create local executable: ${err.message}`);
   }
-}
+}

package/src/cli/simple-commands/init/gitignore-updater.js

@@ -44,63 +44,64 @@ hive-mind-prompt-*.txt
  */
 export async function updateGitignore(workingDir, force = false, dryRun = false) {
   const gitignorePath = `${workingDir}/.gitignore`;
-  
+
   try {
     let gitignoreContent = '';
     let fileExists = false;
-    
+
     // Check if .gitignore exists
     if (existsSync(gitignorePath)) {
       fileExists = true;
       gitignoreContent = await readTextFile(gitignorePath);
     }
-    
+
     // Check if Claude Flow section already exists
     const claudeFlowMarker = '# Claude Flow generated files';
     if (gitignoreContent.includes(claudeFlowMarker) && !force) {
       return {
         success: true,
-        message: '.gitignore already contains Claude Flow entries'
+        message: '.gitignore already contains Claude Flow entries',
       };
     }
-    
+
     // Prepare the new content
     let newContent = gitignoreContent;
-    
+
     // Remove existing Claude Flow section if force updating
     if (force && gitignoreContent.includes(claudeFlowMarker)) {
       const startIndex = gitignoreContent.indexOf(claudeFlowMarker);
       const endIndex = gitignoreContent.indexOf('\n# ', startIndex + 1);
       if (endIndex !== -1) {
-        newContent = gitignoreContent.substring(0, startIndex) + gitignoreContent.substring(endIndex);
+        newContent =
+          gitignoreContent.substring(0, startIndex) + gitignoreContent.substring(endIndex);
       } else {
         // Claude Flow section is at the end
         newContent = gitignoreContent.substring(0, startIndex);
       }
     }
-    
+
     // Add Claude Flow entries
     if (!newContent.endsWith('\n') && newContent.length > 0) {
       newContent += '\n';
     }
     newContent += CLAUDE_FLOW_GITIGNORE_ENTRIES;
-    
+
     // Write the file
     if (!dryRun) {
       await writeTextFile(gitignorePath, newContent);
     }
-    
+
     return {
       success: true,
-      message: fileExists 
-        ? (dryRun ? '[DRY RUN] Would update' : 'Updated') + ' existing .gitignore with Claude Flow entries'
-        : (dryRun ? '[DRY RUN] Would create' : 'Created') + ' .gitignore with Claude Flow entries'
+      message: fileExists
+        ? (dryRun ? '[DRY RUN] Would update' : 'Updated') +
+          ' existing .gitignore with Claude Flow entries'
+        : (dryRun ? '[DRY RUN] Would create' : 'Created') + ' .gitignore with Claude Flow entries',
     };
-    
   } catch (error) {
     return {
       success: false,
-      message: `Failed to update .gitignore: ${error.message}`
+      message: `Failed to update .gitignore: ${error.message}`,
     };
   }
 }
@@ -112,11 +113,11 @@ export async function updateGitignore(workingDir, force = false, dryRun = false)
  */
 export async function needsGitignoreUpdate(workingDir) {
   const gitignorePath = `${workingDir}/.gitignore`;
-  
+
   if (!existsSync(gitignorePath)) {
     return true;
   }
-  
+
   try {
     const content = await readTextFile(gitignorePath);
     return !content.includes('# Claude Flow generated files');
@@ -130,8 +131,7 @@ export async function needsGitignoreUpdate(workingDir) {
  * @returns {string[]}
  */
 export function getGitignorePatterns() {
-  return CLAUDE_FLOW_GITIGNORE_ENTRIES
-    .split('\n')
-    .filter(line => line.trim() && !line.startsWith('#') && !line.startsWith('!'))
-    .map(line => line.trim());
-}
+  return CLAUDE_FLOW_GITIGNORE_ENTRIES.split('\n')
+    .filter((line) => line.trim() && !line.startsWith('#') && !line.startsWith('!'))
+    .map((line) => line.trim());
+}

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

@@ -46,7 +46,9 @@ export function showInitHelp() {
   console.log('🚀 STANDARD INITIALIZATION:');
   console.log('  npx claude-flow@latest init --sparc --force  # ⭐ RECOMMENDED: Optimized setup');
   console.log('  npx claude-flow@latest init --sparc          # Standard SPARC setup');
-  console.log('  claude-flow init --sparc --force             # Optimized setup (existing project)');
+  console.log(
+    '  claude-flow init --sparc --force             # Optimized setup (existing project)',
+  );
   console.log('  claude-flow init --sparc --modes architect,tdd,code  # Selective initialization');
   console.log('  claude-flow init --dry-run --sparc          # Preview initialization');
   console.log('  claude-flow init --minimal                  # Minimal setup');
@@ -92,4 +94,4 @@ export function showInitHelp() {
   console.log('  • And 7+ more specialized modes...');
   console.log();
   console.log('Learn more: https://github.com/ruvnet/claude-code-flow');
-}
+}