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

package/src/templates/claude-optimized/.claude/commands/claude-flow-swarm.md

@@ -8,6 +8,7 @@ description: Coordinate multi-agent swarms with batchtools optimization for comp
 Swarm mode with batchtools enables massively parallel multi-agent coordination for complex tasks with enhanced efficiency.
 
 ## Enhanced Basic Usage
+
 ```bash
 # Traditional single swarm
 npx claude-flow swarm "your complex task" --strategy <type> [options]
@@ -17,6 +18,7 @@ npx claude-flow swarm batch --tasks "frontend:dev,backend:dev,database:architect
 ```
 
 ## Parallel Strategy Execution
+
 ```bash
 # Execute multiple strategies concurrently
 npx claude-flow swarm multi-strategy --config '{
@@ -28,6 +30,7 @@ npx claude-flow swarm multi-strategy --config '{
 ```
 
 ## Enhanced Strategies with Batch Operations
+
 - `development` - Parallel code implementation across modules
 - `research` - Concurrent information gathering from multiple sources
 - `analysis` - Parallel data processing pipelines
@@ -38,6 +41,7 @@ npx claude-flow swarm multi-strategy --config '{
 - `deployment` - Concurrent multi-environment deployment
 
 ## Advanced Batch Options
+
 - `--parallel-tasks <n>` - Number of concurrent tasks
 - `--batch-size <n>` - Task batch size for processing
 - `--pipeline` - Enable pipeline parallelization
@@ -50,6 +54,7 @@ npx claude-flow swarm multi-strategy --config '{
 ## Batch Examples
 
 ### Parallel Development Swarm
+
 ```bash
 # Develop multiple microservices concurrently
 npx claude-flow swarm batch-dev --services '{
@@ -61,6 +66,7 @@ npx claude-flow swarm batch-dev --services '{
 ```
 
 ### Distributed Research Swarm
+
 ```bash
 # Parallel research across multiple domains
 npx claude-flow swarm batch-research --topics '{
@@ -71,6 +77,7 @@ npx claude-flow swarm batch-research --topics '{
 ```
 
 ### Massive Testing Swarm
+
 ```bash
 # Execute comprehensive parallel testing
 npx claude-flow swarm batch-test --suites '{
@@ -84,6 +91,7 @@ npx claude-flow swarm batch-test --suites '{
 ## Pipeline Operations
 
 ### Development Pipeline
+
 ```bash
 # Create development pipeline with parallel stages
 npx claude-flow swarm pipeline --config '{
@@ -97,6 +105,7 @@ npx claude-flow swarm pipeline --config '{
 ```
 
 ### Analysis Pipeline
+
 ```bash
 # Parallel data analysis pipeline
 npx claude-flow swarm analyze-pipeline --stages '{
@@ -110,6 +119,7 @@ npx claude-flow swarm analyze-pipeline --stages '{
 ## Distributed Coordination
 
 ### Multi-Region Deployment
+
 ```bash
 # Deploy across regions in parallel
 npx claude-flow swarm deploy-multi --regions '{
@@ -120,6 +130,7 @@ npx claude-flow swarm deploy-multi --regions '{
 ```
 
 ### Federated Learning
+
 ```bash
 # Coordinate distributed model training
 npx claude-flow swarm federated-train --nodes 20 --parallel --aggregate-method "secure"
@@ -128,6 +139,7 @@ npx claude-flow swarm federated-train --nodes 20 --parallel --aggregate-method "
 ## Advanced Monitoring & Control
 
 ### Real-time Batch Monitoring
+
 ```bash
 # Monitor all swarm operations
 npx claude-flow swarm monitor-batch --metrics '{
@@ -138,6 +150,7 @@ npx claude-flow swarm monitor-batch --metrics '{
 ```
 
 ### Dynamic Resource Management
+
 ```bash
 # Auto-scale based on load
 npx claude-flow swarm auto-manage --rules '{
@@ -150,6 +163,7 @@ npx claude-flow swarm auto-manage --rules '{
 ## Batch Optimization Features
 
 ### Work Distribution
+
 ```bash
 # Intelligent work distribution
 npx claude-flow swarm distribute --algorithm "weighted" --factors '{
@@ -160,6 +174,7 @@ npx claude-flow swarm distribute --algorithm "weighted" --factors '{
 ```
 
 ### Failure Handling
+
 ```bash
 # Resilient batch execution
 npx claude-flow swarm batch-execute --resilient '{
@@ -172,6 +187,7 @@ npx claude-flow swarm batch-execute --resilient '{
 ## Performance Optimizations
 
 ### Caching Strategy
+
 ```bash
 # Enable intelligent caching
 npx claude-flow swarm batch --cache '{
@@ -182,6 +198,7 @@ npx claude-flow swarm batch --cache '{
 ```
 
 ### Network Optimization
+
 ```bash
 # Optimize network communication
 npx claude-flow swarm optimize-network --compression "gzip" --batching 100 --keepalive
@@ -190,6 +207,7 @@ npx claude-flow swarm optimize-network --compression "gzip" --batching 100 --kee
 ## Complex Workflow Examples
 
 ### Full-Stack Application Development
+
 ```bash
 # Orchestrate complete application development
 npx claude-flow swarm full-stack --project "e-commerce" --parallel-components '{
@@ -203,6 +221,7 @@ npx claude-flow swarm full-stack --project "e-commerce" --parallel-components '{
 ```
 
 ### Data Pipeline Processing
+
 ```bash
 # Massive parallel data processing
 npx claude-flow swarm data-pipeline --config '{
@@ -214,6 +233,7 @@ npx claude-flow swarm data-pipeline --config '{
 ```
 
 ### Security Audit Swarm
+
 ```bash
 # Comprehensive security analysis
 npx claude-flow swarm security-audit --parallel-scans '{
@@ -222,4 +242,4 @@ npx claude-flow swarm security-audit --parallel-scans '{
   "runtime": { "tools": ["dast", "fuzzing"], "agents": 4 },
   "compliance": { "standards": ["owasp", "pci"], "agents": 2 }
 }' --report --remediate
-```
+```

package/src/templates/claude-optimized/.claude/commands/sparc/architect.md

@@ -12,7 +12,9 @@ You design scalable, secure, and modular architectures based on functional specs
 Create architecture mermaid diagrams, data flows, and integration points leveraging batchtools for efficient multi-component analysis:
 
 ### Parallel Architecture Analysis
+
 1. **Batch Code Analysis**: Use batchtools to simultaneously analyze multiple existing components:
+
    - Read all relevant source files in parallel
    - Grep for architectural patterns across the codebase concurrently
    - Analyze dependencies and interfaces in batch operations
@@ -23,17 +25,18 @@ Create architecture mermaid diagrams, data flows, and integration points leverag
    - Build security models concurrently with integration designs
 
 ### Batchtools Optimization Strategies
+
 - **Parallel File Operations**: When creating architecture documentation, use batchtools to:
   - Create multiple diagram files simultaneously
   - Generate component specifications in parallel
   - Write interface definitions concurrently
-  
 - **Concurrent Analysis**: Leverage batchtools for:
   - Analyzing multiple service boundaries at once
   - Checking integration points across components in parallel
   - Validating security patterns throughout the codebase simultaneously
 
 ### Architecture Documentation Structure
+
 ```
 /architecture/
   ├── diagrams/        # Created in parallel
@@ -43,6 +46,7 @@ Create architecture mermaid diagrams, data flows, and integration points leverag
 ```
 
 ### Efficient Workflow
+
 1. Use batchtools to read all existing code and documentation in one operation
 2. Analyze patterns, dependencies, and interfaces concurrently
 3. Generate all architectural artifacts in parallel batches
@@ -51,6 +55,7 @@ Create architecture mermaid diagrams, data flows, and integration points leverag
 Ensure no part of the design includes secrets or hardcoded env values. Emphasize modular boundaries and maintain extensibility. All descriptions and diagrams must fit within a single file or modular folder.
 
 ## Groups/Permissions
+
 - read
 - edit
 
@@ -71,23 +76,25 @@ npx claude-flow sparc run architect "implement user authentication"
 ## Batchtools Integration Examples
 
 ### Parallel Component Analysis
+
 ```javascript
 // Analyze multiple components simultaneously
 const analyses = await batchtools.parallel([
   analyzeComponent('auth-service'),
   analyzeComponent('user-service'),
   analyzeComponent('api-gateway'),
-  analyzeComponent('database-layer')
+  analyzeComponent('database-layer'),
 ]);
 ```
 
 ### Concurrent Diagram Generation
+
 ```javascript
 // Generate all architecture diagrams in parallel
 await batchtools.createFiles([
   { path: '/architecture/diagrams/system-overview.mmd', content: systemDiagram },
   { path: '/architecture/diagrams/data-flow.mmd', content: dataFlowDiagram },
   { path: '/architecture/diagrams/component-map.mmd', content: componentDiagram },
-  { path: '/architecture/diagrams/deployment.mmd', content: deploymentDiagram }
+  { path: '/architecture/diagrams/deployment.mmd', content: deploymentDiagram },
 ]);
-```
+```

package/src/templates/claude-optimized/.claude/commands/sparc/ask.md

@@ -47,15 +47,15 @@ const taskAnalysis = [
   { tool: 'Read', params: { file_path: 'package.json' } },
   { tool: 'Read', params: { file_path: '.roomodes' } },
   { tool: 'Glob', params: { pattern: 'src/**/*.{ts,js}' } },
-  
+
   // Concurrent pattern analysis
   { tool: 'Grep', params: { pattern: 'TODO|FIXME', include: '*.{ts,js}' } },
   { tool: 'Grep', params: { pattern: 'test\\(|describe\\(', include: '*.test.{ts,js}' } },
   { tool: 'Grep', params: { pattern: 'import.*from', include: '*.{ts,js}' } },
-  
+
   // Parallel documentation search
   { tool: 'Glob', params: { pattern: '**/*.md' } },
-  { tool: 'Grep', params: { pattern: 'sparc (run|mode)', include: '*.md' } }
+  { tool: 'Grep', params: { pattern: 'sparc (run|mode)', include: '*.md' } },
 ];
 
 // Analyze all aspects in parallel for intelligent routing
@@ -65,18 +65,21 @@ const results = await batchtools.execute(taskAnalysis);
 ### Task Formulation Patterns
 
 1. **Multi-Mode Task Analysis**:
+
    - Evaluate task requirements against all modes simultaneously
    - Score mode fitness using parallel criteria evaluation
    - Generate mode recommendations with confidence levels
    - Provide alternative approaches in parallel
 
 2. **Task Decomposition**:
+
    - Break complex tasks into SPARC-aligned subtasks
    - Identify dependencies between tasks in parallel
    - Generate execution order recommendations
    - Create task delegation templates concurrently
 
 3. **Context-Aware Suggestions**:
+
    - Analyze current project state in parallel
    - Search for similar completed tasks simultaneously
    - Extract patterns from successful implementations
@@ -96,17 +99,17 @@ const processQuestion = async (userQuestion) => {
   const analysis = [
     // Analyze question intent
     { tool: 'analyzeIntent', params: { text: userQuestion } },
-    
+
     // Search for similar questions/solutions
     { tool: 'Grep', params: { pattern: extractKeywords(userQuestion), include: '*.md' } },
-    
+
     // Find relevant code examples
     { tool: 'Grep', params: { pattern: extractCodePatterns(userQuestion), include: '*.{ts,js}' } },
-    
+
     // Check existing implementations
-    { tool: 'Glob', params: { pattern: `**/*${extractFeature(userQuestion)}*` } }
+    { tool: 'Glob', params: { pattern: `**/*${extractFeature(userQuestion)}*` } },
   ];
-  
+
   const results = await batchtools.execute(analysis);
   return generateSmartResponse(results);
 };
@@ -115,6 +118,7 @@ const processQuestion = async (userQuestion) => {
 ### Advanced Routing Features
 
 1. **Smart Mode Selection**:
+
    ```javascript
    // Parallel mode evaluation
    const modeScores = await Promise.all([
@@ -122,11 +126,12 @@ const processQuestion = async (userQuestion) => {
      evaluateModeF('architect', taskContext),
      evaluateModeF('code', taskContext),
      evaluateModeF('tdd', taskContext),
-     evaluateModeF('debug', taskContext)
+     evaluateModeF('debug', taskContext),
    ]);
    ```
 
 2. **Task Chain Generation**:
+
    - Create optimal task sequences
    - Identify parallel execution opportunities
    - Generate dependency graphs
@@ -139,6 +144,7 @@ const processQuestion = async (userQuestion) => {
    - Provide before/after comparisons
 
 ## Groups/Permissions
+
 - read
 - analyze
 - batchtools
@@ -190,4 +196,4 @@ npx claude-flow sparc run ask "which mode should I use for database schema refac
 1. **Instant Feedback**: Provide immediate task analysis results
 2. **Visual Task Graphs**: Generate task dependency visualizations
 3. **Confidence Scores**: Show confidence levels for each recommendation
-4. **Alternative Paths**: Suggest multiple valid approaches in parallel
+4. **Alternative Paths**: Suggest multiple valid approaches in parallel

package/src/templates/claude-optimized/.claude/commands/sparc/code.md

@@ -12,7 +12,9 @@ You write clean, efficient, modular code based on pseudocode and architecture us
 Write modular code using clean architecture principles with batchtools optimization:
 
 ### Parallel Code Generation
+
 1. **Batch File Creation**: Generate multiple related files simultaneously:
+
    - Create interfaces, implementations, and tests in parallel
    - Generate model, controller, and service layers concurrently
    - Build configuration and documentation files together
@@ -23,7 +25,9 @@ Write modular code using clean architecture principles with batchtools optimizat
    - Build validation and middleware components concurrently
 
 ### Batchtools Code Patterns
+
 - **Parallel Component Generation**:
+
   ```javascript
   // Generate complete feature modules in parallel
   await batchtools.parallel([
@@ -31,7 +35,7 @@ Write modular code using clean architecture principles with batchtools optimizat
     generateService(entity),
     generateRepository(entity),
     generateTests(entity),
-    generateDocs(entity)
+    generateDocs(entity),
   ]);
   ```
 
@@ -42,17 +46,20 @@ Write modular code using clean architecture principles with batchtools optimizat
     { path: '/src/controllers/user.controller.ts', content: userController },
     { path: '/src/services/user.service.ts', content: userService },
     { path: '/src/models/user.model.ts', content: userModel },
-    { path: '/src/validators/user.validator.ts', content: userValidator }
+    { path: '/src/validators/user.validator.ts', content: userValidator },
   ]);
   ```
 
 ### Efficient Development Workflow
+
 1. **Parallel Analysis Phase**:
+
    - Read all related specifications concurrently
    - Analyze existing codebase patterns in parallel
    - Check dependencies and interfaces simultaneously
 
 2. **Concurrent Implementation**:
+
    - Generate boilerplate code for multiple components at once
    - Implement business logic across layers in parallel
    - Create utility functions and helpers concurrently
@@ -63,6 +70,7 @@ Write modular code using clean architecture principles with batchtools optimizat
    - Set up error handling and logging concurrently
 
 ### Code Organization Strategy
+
 ```
 /src/
   ├── controllers/    # Generated in parallel
@@ -75,6 +83,7 @@ Write modular code using clean architecture principles with batchtools optimizat
 Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.
 
 ## Tool Usage Guidelines:
+
 - Use batchtools for creating multiple files at once instead of sequential `insert_content`
 - Leverage parallel operations when modifying multiple existing files
 - Use concurrent searches to find patterns across the codebase
@@ -82,6 +91,7 @@ Never hardcode secrets or environment values. Split code into files < 500 lines.
 - Always verify all required parameters are included before executing any tool
 
 ## Groups/Permissions
+
 - read
 - edit
 - browser
@@ -105,6 +115,7 @@ npx claude-flow sparc run code "implement user authentication"
 ## Batchtools Optimization Examples
 
 ### Parallel Feature Implementation
+
 ```javascript
 // Implement complete feature across all layers
 const implementations = await batchtools.parallel([
@@ -112,29 +123,37 @@ const implementations = await batchtools.parallel([
   implementAuthService(),
   implementAuthMiddleware(),
   implementAuthValidators(),
-  implementAuthUtils()
+  implementAuthUtils(),
 ]);
 ```
 
 ### Batch CRUD Generation
+
 ```javascript
 // Generate CRUD operations for multiple entities
 const entities = ['User', 'Product', 'Order'];
 await batchtools.forEach(entities, async (entity) => {
   await batchtools.createFiles([
-    { path: `/src/controllers/${entity.toLowerCase()}.controller.ts`, content: generateController(entity) },
+    {
+      path: `/src/controllers/${entity.toLowerCase()}.controller.ts`,
+      content: generateController(entity),
+    },
     { path: `/src/services/${entity.toLowerCase()}.service.ts`, content: generateService(entity) },
-    { path: `/src/repositories/${entity.toLowerCase()}.repository.ts`, content: generateRepository(entity) }
+    {
+      path: `/src/repositories/${entity.toLowerCase()}.repository.ts`,
+      content: generateRepository(entity),
+    },
   ]);
 });
 ```
 
 ### Concurrent Refactoring
+
 ```javascript
 // Refactor multiple files simultaneously
 await batchtools.modifyFiles([
   { path: '/src/services/auth.service.ts', modifications: authServiceRefactoring },
   { path: '/src/services/user.service.ts', modifications: userServiceRefactoring },
-  { path: '/src/services/token.service.ts', modifications: tokenServiceRefactoring }
+  { path: '/src/services/token.service.ts', modifications: tokenServiceRefactoring },
 ]);
-```
+```

package/src/templates/claude-optimized/.claude/commands/sparc/debug.md

@@ -12,17 +12,20 @@ You troubleshoot runtime bugs, logic errors, or integration failures by tracing,
 ### Parallel Debugging Strategy
 
 1. **Initial Parallel Analysis** - Execute simultaneously:
+
    - Scan all error logs and stack traces
    - Identify all related source files
    - Check all test files for failures
    - Review recent git changes in affected areas
 
 2. **Batch File Operations**:
+
    - Read multiple related files in parallel using batchtools
    - Search for error patterns across the entire codebase concurrently
    - Analyze dependencies and imports in batch mode
 
 3. **Concurrent Trace Analysis**:
+
    - Parse multiple log files simultaneously
    - Cross-reference error messages with source code in parallel
    - Check multiple environment configurations at once
@@ -35,6 +38,7 @@ You troubleshoot runtime bugs, logic errors, or integration failures by tracing,
 ### Optimization Techniques
 
 **Use batchtools for:**
+
 - Reading multiple log files simultaneously: `batchtools.readFiles([...logPaths])`
 - Searching for error patterns across files: `batchtools.grep(pattern, fileGlobs)`
 - Analyzing multiple stack traces in parallel
@@ -42,13 +46,14 @@ You troubleshoot runtime bugs, logic errors, or integration failures by tracing,
 - Checking multiple configuration files at once
 
 **Parallel Workflows:**
+
 ```javascript
 // Example: Debug authentication issues
 const debugTasks = [
   { type: 'read', paths: ['logs/auth.log', 'logs/app.log', 'logs/error.log'] },
   { type: 'grep', pattern: 'AuthError|TokenExpired', glob: 'src/**/*.ts' },
   { type: 'test', suites: ['auth.test.ts', 'token.test.ts', 'session.test.ts'] },
-  { type: 'git', commands: ['log --oneline -10', 'diff HEAD~5'] }
+  { type: 'git', commands: ['log --oneline -10', 'diff HEAD~5'] },
 ];
 await batchtools.executeBatch(debugTasks);
 ```
@@ -62,23 +67,28 @@ await batchtools.executeBatch(debugTasks);
 5. **Parallel Dependency Checks**: Analyze module dependencies concurrently
 
 ### Refactoring Guidelines
+
 - If debugging reveals files > 500 lines, create refactoring tasks in batch
 - Use parallel file splitting for large modules
 - Apply fixes to multiple similar issues simultaneously
 
 ### Task Delegation
+
 Use `new_task` with batch specifications to:
+
 - Delegate parallel test creation
 - Assign concurrent security scans
 - Distribute modular fixes across components
 
 Return `attempt_completion` with:
+
 - Parallel debugging results summary
 - Batch test outcomes
 - Performance metrics from concurrent operations
 - Consolidated fix recommendations
 
 ## Groups/Permissions
+
 - read
 - edit
 - browser
@@ -116,7 +126,7 @@ const errorAnalysis = await batchtools.parallel([
   () => analyzeLogFile('app.log'),
   () => analyzeLogFile('error.log'),
   () => analyzeStackTraces('crashes/*.txt'),
-  () => checkTestFailures('**/*.test.ts')
+  () => checkTestFailures('**/*.test.ts'),
 ]);
 
 // Concurrent pattern search
@@ -127,6 +137,6 @@ const results = await batchtools.searchPatterns(patterns, 'src/**/*.{ts,js}');
 const fixes = await batchtools.validateFixes([
   { file: 'auth.ts', test: 'auth.test.ts' },
   { file: 'token.ts', test: 'token.test.ts' },
-  { file: 'session.ts', test: 'session.test.ts' }
+  { file: 'session.ts', test: 'session.test.ts' },
 ]);
-```
+```