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

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

@@ -1,50 +1,77 @@
 // optimized-slash-commands.js - Create batchtools-optimized Claude Code slash commands
 
-import { createOptimizedSparcSlashCommand, createOptimizedMainSparcCommand } from './optimized-sparc-commands.js';
+import {
+  createOptimizedSparcSlashCommand,
+  createOptimizedMainSparcCommand,
+} from './optimized-sparc-commands.js';
 import { createOptimizedClaudeFlowCommands } from './optimized-claude-flow-commands.js';
+import { copyTemplates } from '../template-copier.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
 
 // Create batchtools-optimized Claude Code slash commands for SPARC modes
 export async function createOptimizedClaudeSlashCommands(workingDir, selectedModes = null) {
   try {
     console.log('\n🚀 Creating batchtools-optimized Claude Code slash commands...');
-    
-    // Parse .roomodes to get all SPARC modes
-    const roomodesContent = await Deno.readTextFile(`${workingDir}/.roomodes`);
-    const roomodes = JSON.parse(roomodesContent);
-    
-    // Filter modes if selective initialization is requested
-    const modesToCreate = selectedModes 
-      ? roomodes.customModes.filter(mode => selectedModes.includes(mode.slug))
-      : roomodes.customModes;
-    
-    console.log(`  📝 Creating optimized commands for ${modesToCreate.length} modes...`);
-    
-    // Create slash commands for each SPARC mode with batchtools optimization
-    const commandPromises = modesToCreate.map(async (mode) => {
-      const commandPath = `${workingDir}/.claude/commands/sparc/${mode.slug}.md`;
-      const commandContent = createOptimizedSparcSlashCommand(mode);
+
+    // Use template copier with optimized flag
+    const optimizedOptions = {
+      sparc: true,
+      optimized: true,
+      force: true,
+      dryRun: false,
+      selectedModes: selectedModes,
+    };
+
+    // Check if .roomodes exists for dynamic generation
+    const roomodesPath = `${workingDir}/.roomodes`;
+    try {
+      const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
+      const roomodes = JSON.parse(roomodesContent);
+
+      // Filter modes if selective initialization is requested
+      const modesToCreate = selectedModes
+        ? roomodes.customModes.filter((mode) => selectedModes.includes(mode.slug))
+        : roomodes.customModes;
+
+      console.log(`  📝 Creating optimized commands for ${modesToCreate.length} modes...`);
+
+      // Create slash commands for each SPARC mode with batchtools optimization
+      const commandPromises = modesToCreate.map(async (mode) => {
+        const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
+        const commandContent = createOptimizedSparcSlashCommand(mode);
+
+        await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), { recursive: true });
+        await fs.writeFile(commandPath, commandContent);
+        console.log(`  ✓ Created optimized slash command: /sparc-${mode.slug} (Batchtools enhanced)`);
+      });
+
+      // Execute all command creations in parallel
+      await Promise.all(commandPromises);
+
+      // Create main SPARC command with batchtools optimization
+      const mainSparcCommand = createOptimizedMainSparcCommand(roomodes.customModes);
+      await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md'), mainSparcCommand);
+      console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
+
+      console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
+    } catch (err) {
+      // Fallback to template copier if .roomodes doesn't exist
+      console.log('  🔄 Using template copier for optimized SPARC commands...');
+      const copyResults = await copyTemplates(workingDir, optimizedOptions);
       
-      await Deno.writeTextFile(commandPath, commandContent);
-      console.log(`  ✓ Created optimized slash command: /sparc-${mode.slug} (Batchtools enhanced)`);
-    });
-    
-    // Execute all command creations in parallel
-    await Promise.all(commandPromises);
-    
-    // Create main SPARC command with batchtools optimization
-    const mainSparcCommand = createOptimizedMainSparcCommand(roomodes.customModes);
-    await Deno.writeTextFile(`${workingDir}/.claude/commands/sparc.md`, mainSparcCommand);
-    console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
-    
+      if (!copyResults.success) {
+        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+      }
+    }
+
     // Create claude-flow specific commands with batchtools optimization
     await createOptimizedClaudeFlowCommands(workingDir);
-    
+
     // Create batchtools-specific commands
     await createBatchtoolsCommands(workingDir);
-    
-    console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
+
     console.log('  💡 All commands include parallel processing and performance optimizations');
-    
   } catch (err) {
     console.log(`  ⚠️  Could not create optimized Claude Code slash commands: ${err.message}`);
   }
@@ -220,10 +247,10 @@ Chain operations with parallel execution at each stage:
 
 For detailed documentation, see: https://github.com/ruvnet/claude-code-flow/docs/batchtools.md
 `;
-  
+
   await Deno.writeTextFile(`${workingDir}/.claude/commands/batchtools.md`, batchtoolsCommand);
   console.log('  ✓ Created slash command: /batchtools');
-  
+
   // Performance monitoring command
   const performanceCommand = `---
 name: performance
@@ -318,7 +345,7 @@ Real-time performance monitoring and optimization tools for Claude-Flow operatio
 
 For comprehensive performance guides, see: https://github.com/ruvnet/claude-code-flow/docs/performance.md
 `;
-  
+
   await Deno.writeTextFile(`${workingDir}/.claude/commands/performance.md`, performanceCommand);
   console.log('  ✓ Created slash command: /performance');
-}
+}

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

@@ -2,34 +2,55 @@
 
 import { createSparcSlashCommand, createMainSparcCommand } from './sparc-commands.js';
 import { createClaudeFlowCommands } from './claude-flow-commands.js';
+import { copyTemplates } from '../template-copier.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
 
 // Create Claude Code slash commands for SPARC modes
 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);
+
+    // Use template copier for SPARC slash commands
+    const slashCommandOptions = {
+      sparc: true,
+      force: true,
+      dryRun: false,
+    };
+
+    // Check if .roomodes exists for dynamic generation
+    const roomodesPath = `${workingDir}/.roomodes`;
+    try {
+      const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
+      const roomodes = JSON.parse(roomodesContent);
+
+      // Create slash commands for each SPARC mode
+      for (const mode of roomodes.customModes) {
+        const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
+        const commandContent = createSparcSlashCommand(mode);
+
+        await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), { recursive: true });
+        await fs.writeFile(commandPath, commandContent);
+        console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
+      }
+
+      // Create main SPARC command
+      const mainSparcCommand = createMainSparcCommand(roomodes.customModes);
+      await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md'), mainSparcCommand);
+      console.log('  ✓ Created main slash command: /sparc');
+    } catch (err) {
+      // Fallback to template copier if .roomodes doesn't exist
+      console.log('  🔄 Using template copier for SPARC commands...');
+      const copyResults = await copyTemplates(workingDir, slashCommandOptions);
       
-      await Deno.writeTextFile(commandPath, commandContent);
-      console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
+      if (!copyResults.success) {
+        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+      }
     }
-    
-    // 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}`);
   }
-}
+}