claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/init/claude-commands/claude-flow-commands.js

@@ -1,10 +1,9 @@
-import { promises as fs } from 'fs';
+import { promises as fs } from "fs";
 // claude-flow-commands.js - Claude-Flow specific slash commands
-
 // Create Claude-Flow specific commands
 export async function createClaudeFlowCommands(workingDir) {
-  // Help command
-  const helpCommand = `---
+    // Help command
+    const helpCommand = `---
 name: claude-flow-help
 description: Show Claude-Flow commands and usage
 ---
@@ -108,12 +107,10 @@ npx -y claude-flow@latest init --sparc
 - Examples: https://github.com/ruvnet/claude-code-flow/examples
 - Issues: https://github.com/ruvnet/claude-code-flow/issues
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
-  console.log('  ✓ Created slash command: /claude-flow-help');
-
-  // Memory command
-  const memoryCommand = `---
+    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
+    console.log('  ✓ Created slash command: /claude-flow-help');
+    // Memory command
+    const memoryCommand = `---
 name: claude-flow-memory
 description: Interact with Claude-Flow memory system
 ---
@@ -221,12 +218,10 @@ The memory system provides persistent storage for cross-session and cross-agent
 ./claude-flow-novice memory export project-$(date +%Y%m%d).json --namespace project
 \`\`\`
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
-  console.log('  ✓ Created slash command: /claude-flow-memory');
-
-  // Swarm command
-  const swarmCommand = `---
+    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
+    console.log('  ✓ Created slash command: /claude-flow-memory');
+    // Swarm command
+    const swarmCommand = `---
 name: claude-flow-swarm
 description: Coordinate multi-agent swarms for complex tasks
 ---
@@ -432,7 +427,6 @@ Swarms automatically use distributed memory for collaboration:
 
 For detailed documentation, see: https://github.com/ruvnet/claude-code-flow/docs/swarm-system.md
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
-  console.log('  ✓ Created slash command: /claude-flow-swarm');
+    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
+    console.log('  ✓ Created slash command: /claude-flow-swarm');
 }

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

@@ -1,10 +1,9 @@
-import { promises as fs } from 'fs';
+import { promises as fs } from "fs";
 // optimized-claude-flow-commands.js - Batchtools-optimized Claude-Flow specific slash commands
-
 // Create batchtools-optimized Claude-Flow specific commands
 export async function createOptimizedClaudeFlowCommands(workingDir) {
-  // Help command with batchtools optimization
-  const helpCommand = `---
+    // Help command with batchtools optimization
+    const helpCommand = `---
 name: claude-flow-help
 description: Show Claude-Flow commands and usage with batchtools optimization
 ---
@@ -238,12 +237,10 @@ npx -y claude-flow@latest init --sparc --force
 
 For comprehensive documentation and optimization guides, see the resources above.
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
-  console.log('  ✓ Created optimized slash command: /claude-flow-help (Batchtools enhanced)');
-
-  // Memory command with batchtools optimization
-  const memoryCommand = `---
+    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-help.md`, helpCommand, 'utf8');
+    console.log('  ✓ Created optimized slash command: /claude-flow-help (Batchtools enhanced)');
+    // Memory command with batchtools optimization
+    const memoryCommand = `---
 name: claude-flow-memory
 description: Interact with Claude-Flow memory system using batchtools optimization
 ---
@@ -529,12 +526,10 @@ The memory system provides persistent storage for cross-session and cross-agent
 
 For comprehensive memory system documentation and optimization guides, see: https://github.com/ruvnet/claude-code-flow/docs/memory-batchtools.md
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
-  console.log('  ✓ Created optimized slash command: /claude-flow-memory (Batchtools enhanced)');
-
-  // Swarm command with batchtools optimization
-  const swarmCommand = `---
+    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-memory.md`, memoryCommand, 'utf8');
+    console.log('  ✓ Created optimized slash command: /claude-flow-memory (Batchtools enhanced)');
+    // Swarm command with batchtools optimization
+    const swarmCommand = `---
 name: claude-flow-swarm
 description: Coordinate multi-agent swarms for complex tasks with batchtools optimization
 ---
@@ -870,7 +865,6 @@ Swarms automatically use distributed memory with parallel processing for collabo
 
 For detailed documentation and optimization guides, see: https://github.com/ruvnet/claude-code-flow/docs/swarm-batchtools.md
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
-  console.log('  ✓ Created optimized slash command: /claude-flow-swarm (Batchtools enhanced)');
+    await fs.writeFile(`${workingDir}/.claude/commands/claude-flow-swarm.md`, swarmCommand, 'utf8');
+    console.log('  ✓ Created optimized slash command: /claude-flow-swarm (Batchtools enhanced)');
 }

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

@@ -1,91 +1,67 @@
 // optimized-slash-commands.js - Create batchtools-optimized Claude Code slash commands
-
-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';
-
+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...');
-
-    // 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, 'utf8');
-        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', 'utf8'),
-        mainSparcCommand,
-      );
-      console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
-
-      console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
+        console.log('\n🚀 Creating batchtools-optimized Claude Code slash commands...');
+        // 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, 'utf8');
+                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', 'utf8'), 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);
+            if (!copyResults.success) {
+                console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+            }
+        }
+        // Create claude-flow-novice specific commands with batchtools optimization
+        await createOptimizedClaudeFlowCommands(workingDir);
+        // Create batchtools-specific commands
+        await createBatchtoolsCommands(workingDir);
+        console.log('  💡 All commands include parallel processing and performance optimizations');
     } 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);
-
-      if (!copyResults.success) {
-        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
-      }
+        console.log(`  ⚠️  Could not create optimized Claude Code slash commands: ${err.message}`);
     }
-
-    // Create claude-flow-novice specific commands with batchtools optimization
-    await createOptimizedClaudeFlowCommands(workingDir);
-
-    // Create batchtools-specific commands
-    await createBatchtoolsCommands(workingDir);
-
-    console.log('  💡 All commands include parallel processing and performance optimizations');
-  } catch (err) {
-    console.log(`  ⚠️  Could not create optimized Claude Code slash commands: ${err.message}`);
-  }
 }
-
 // Create batchtools-specific commands
 async function createBatchtoolsCommands(workingDir) {
-  // Batchtools help command
-  const batchtoolsCommand = `---
+    // Batchtools help command
+    const batchtoolsCommand = `---
 name: batchtools
 description: Execute operations with parallel processing and batch optimization
 ---
@@ -252,12 +228,10 @@ Chain operations with parallel execution at each stage:
 
 For detailed documentation, see: https://github.com/ruvnet/claude-code-flow/docs/batchtools.md
 `;
-
-  await fs.writeFile(`${workingDir}/.claude/commands/batchtools.md`, batchtoolsCommand, 'utf8');
-  console.log('  ✓ Created slash command: /batchtools');
-
-  // Performance monitoring command
-  const performanceCommand = `---
+    await fs.writeFile(`${workingDir}/.claude/commands/batchtools.md`, batchtoolsCommand, 'utf8');
+    console.log('  ✓ Created slash command: /batchtools');
+    // Performance monitoring command
+    const performanceCommand = `---
 name: performance
 description: Monitor and optimize system performance with batchtools
 ---
@@ -350,7 +324,6 @@ 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 fs.writeFile(`${workingDir}/.claude/commands/performance.md`, performanceCommand, 'utf8');
-  console.log('  ✓ Created slash command: /performance');
+    await fs.writeFile(`${workingDir}/.claude/commands/performance.md`, performanceCommand, 'utf8');
+    console.log('  ✓ Created slash command: /performance');
 }

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

@@ -1,14 +1,9 @@
 // optimized-sparc-commands.js - Batchtools-optimized SPARC-specific slash commands
-
 // 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;
-
-  return `---
+    // Extract the full description without truncation
+    const fullDescription = mode.roleDefinition.length > 100 ? `${mode.roleDefinition.substring(0, 97)}...` : mode.roleDefinition;
+    return `---
 name: sparc-${mode.slug}
 description: ${mode.name} - ${fullDescription} (Batchtools Optimized)
 ---
@@ -36,20 +31,14 @@ ${mode.customInstructions}
 - **Resource Optimization**: Efficient utilization with parallel processing
 
 ## Available Tools (Enhanced)
-${
-  Array.isArray(mode.groups)
-    ? mode.groups
-        .map((g) => {
-          if (typeof g === 'string') {
+${Array.isArray(mode.groups) ? mode.groups.map((g)=>{
+        if (typeof g === 'string') {
             return `- **${g}**: ${getOptimizedToolDescription(g)}`;
-          } else if (Array.isArray(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'
-}
+        }
+        return `- ${JSON.stringify(g)}`;
+    }).join('\n') : 'None'}
 
 ### Batchtools Integration
 - **parallel()**: Execute multiple operations concurrently
@@ -182,147 +171,133 @@ For detailed ${mode.name} documentation and batchtools integration guides, see:
 - Batchtools Integration: https://github.com/ruvnet/claude-code-flow/docs/batchtools-${mode.slug}.md
 `;
 }
-
 // 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',
-  };
-  return toolDescriptions[tool] || 'Tool access with batchtools optimization';
+    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'
+    };
+    return toolDescriptions[tool] || 'Tool access with batchtools optimization';
 }
-
 // 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',
-    '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',
-    'refinement-optimization-mode': 'optimize database queries with concurrent profiling',
-    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',
-  };
-  return examples[slug] || 'implement feature with batchtools optimization';
+    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',
+        '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',
+        'refinement-optimization-mode': 'optimize database queries with concurrent profiling',
+        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'
+    };
+    return examples[slug] || 'implement feature with batchtools optimization';
 }
-
 // Helper function to get batchtools best practices for specific modes
 function getBatchtoolsPractices(slug) {
-  const practices = {
-    architect: {
-      parallel: [
-        'Analyzing multiple architectural patterns simultaneously',
-        'Generating component diagrams concurrently',
-        'Validating integration points in parallel',
-        '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',
-      ],
-      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',
-      ],
-    },
-    code: {
-      parallel: [
-        'Implementing multiple functions or classes simultaneously',
-        'Analyzing code patterns across multiple files',
-        'Performing concurrent code optimization',
-        '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',
-      ],
-      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',
-      ],
-    },
-    tdd: {
-      parallel: [
-        'Creating multiple test cases simultaneously',
-        'Running test suites concurrently',
-        'Analyzing test coverage in parallel',
-        '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',
-      ],
-      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',
-      ],
-    }
-  );
+    const practices = {
+        architect: {
+            parallel: [
+                'Analyzing multiple architectural patterns simultaneously',
+                'Generating component diagrams concurrently',
+                'Validating integration points in parallel',
+                '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'
+            ],
+            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'
+            ]
+        },
+        code: {
+            parallel: [
+                'Implementing multiple functions or classes simultaneously',
+                'Analyzing code patterns across multiple files',
+                'Performing concurrent code optimization',
+                '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'
+            ],
+            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'
+            ]
+        },
+        tdd: {
+            parallel: [
+                'Creating multiple test cases simultaneously',
+                'Running test suites concurrently',
+                'Analyzing test coverage in parallel',
+                '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'
+            ],
+            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'
+        ]
+    };
 }
-
 // Create optimized main SPARC command
 export function createOptimizedMainSparcCommand(modes) {
-  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 sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
-
-  return `---
+    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 sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
+    return `---
 name: sparc
 description: Execute SPARC methodology workflows with Claude-Flow and batchtools optimization
 ---