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

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

@@ -22,22 +22,20 @@ Follow SPARC with parallel optimization:
 ### Parallel Task Delegation
 
 #### Concurrent Mode Execution:
+
 ```javascript
 // Execute independent SPARC modes in parallel
 const parallelTasks = [
   { mode: 'spec-pseudocode', task: 'define user auth requirements' },
   { mode: 'spec-pseudocode', task: 'define data model requirements' },
-  { mode: 'spec-pseudocode', task: 'define API requirements' }
+  { mode: 'spec-pseudocode', task: 'define API requirements' },
 ];
 
-await Promise.all(
-  parallelTasks.map(({ mode, task }) => 
-    new_task(mode, task)
-  )
-);
+await Promise.all(parallelTasks.map(({ mode, task }) => new_task(mode, task)));
 ```
 
 #### Batch Architecture Design:
+
 ```bash
 # Design multiple system components concurrently
 parallel --jobs 4 ::: \
@@ -50,13 +48,14 @@ parallel --jobs 4 ::: \
 ### Optimized Workflow Orchestration
 
 #### Parallel Specification Phase:
+
 ```javascript
 // Gather specifications for multiple features simultaneously
 const features = ['auth', 'profile', 'dashboard', 'api'];
-const specTasks = features.map(feature => ({
+const specTasks = features.map((feature) => ({
   mode: 'spec-pseudocode',
   task: `specify ${feature} requirements`,
-  priority: 'high'
+  priority: 'high',
 }));
 
 // Execute all specification tasks in parallel
@@ -64,33 +63,38 @@ const results = await executeParallelTasks(specTasks);
 ```
 
 #### Concurrent Development Phase:
+
 ```javascript
 // Develop multiple independent components
 const developmentPlan = {
-  batch1: [ // No dependencies
+  batch1: [
+    // No dependencies
     { mode: 'code', task: 'implement utility functions' },
     { mode: 'code', task: 'create base components' },
-    { mode: 'code', task: 'setup configuration' }
+    { mode: 'code', task: 'setup configuration' },
   ],
-  batch2: [ // Depends on batch1
+  batch2: [
+    // Depends on batch1
     { mode: 'code', task: 'implement auth service' },
     { mode: 'code', task: 'implement user service' },
-    { mode: 'code', task: 'implement data service' }
+    { mode: 'code', task: 'implement data service' },
+  ],
+  batch3: [
+    // Depends on batch2
+    { mode: 'integration', task: 'integrate all services' },
   ],
-  batch3: [ // Depends on batch2
-    { mode: 'integration', task: 'integrate all services' }
-  ]
 };
 
 // Execute batches in sequence, tasks within batch in parallel
 for (const batch of Object.values(developmentPlan)) {
-  await Promise.all(batch.map(task => new_task(task.mode, task.task)));
+  await Promise.all(batch.map((task) => new_task(task.mode, task.task)));
 }
 ```
 
 ### Parallel Testing Strategy
 
 #### Concurrent TDD Execution:
+
 ```bash
 # Run TDD for multiple components simultaneously
 components=("auth" "user" "api" "database" "cache")
@@ -101,17 +105,18 @@ wait
 ```
 
 #### Batch Security Reviews:
+
 ```javascript
 // Security review multiple components in parallel
 const securityTasks = [
   'review authentication flow',
   'review data access patterns',
   'review API endpoints',
-  'review encryption methods'
-].map(task => ({
+  'review encryption methods',
+].map((task) => ({
   mode: 'security-review',
   task,
-  critical: true
+  critical: true,
 }));
 
 await executeConcurrentReviews(securityTasks);
@@ -120,23 +125,25 @@ await executeConcurrentReviews(securityTasks);
 ### Optimized Integration Workflow
 
 #### Parallel Service Integration:
+
 ```bash
 # Integrate multiple services concurrently
 integrate_services() {
   local services=("auth:user" "user:profile" "profile:api" "api:cache")
-  
+
   printf '%s\n' "${services[@]}" | \
     parallel --jobs 4 'integrate_pair {}'
 }
 ```
 
 #### Concurrent Documentation:
+
 ```javascript
 // Generate documentation for all components in parallel
-const docTasks = modules.map(module => ({
+const docTasks = modules.map((module) => ({
   mode: 'docs-writer',
   task: `document ${module} module`,
-  format: 'markdown'
+  format: 'markdown',
 }));
 
 await Promise.all(docTasks.map(executeTask));
@@ -145,20 +152,19 @@ await Promise.all(docTasks.map(executeTask));
 ## Advanced Orchestration Patterns
 
 ### Dependency-Aware Parallel Execution:
+
 ```javascript
 class SPARCOrchestrator {
   async executeWithDependencies(tasks) {
     const graph = this.buildDependencyGraph(tasks);
     const batches = this.topologicalSort(graph);
-    
+
     for (const batch of batches) {
       // Execute all tasks in batch concurrently
-      await Promise.all(
-        batch.map(task => this.executeTask(task))
-      );
+      await Promise.all(batch.map((task) => this.executeTask(task)));
     }
   }
-  
+
   buildDependencyGraph(tasks) {
     // Build directed acyclic graph of task dependencies
     return tasks.reduce((graph, task) => {
@@ -170,52 +176,48 @@ class SPARCOrchestrator {
 ```
 
 ### Resource-Aware Scheduling:
+
 ```javascript
 // Schedule tasks based on resource requirements
 const scheduler = {
   cpuIntensive: ['optimize', 'compile', 'analyze'],
   ioIntensive: ['read', 'write', 'fetch'],
-  
+
   async schedule(tasks) {
     const grouped = this.groupByResourceType(tasks);
-    
+
     // Run CPU-intensive tasks with limited concurrency
-    const cpuTasks = grouped.cpu.map(task => 
-      this.executeWithLimit(task, 4)
-    );
-    
+    const cpuTasks = grouped.cpu.map((task) => this.executeWithLimit(task, 4));
+
     // Run I/O-intensive tasks with higher concurrency
-    const ioTasks = grouped.io.map(task => 
-      this.executeWithLimit(task, 10)
-    );
-    
+    const ioTasks = grouped.io.map((task) => this.executeWithLimit(task, 10));
+
     await Promise.all([...cpuTasks, ...ioTasks]);
-  }
+  },
 };
 ```
 
 ## Monitoring and Progress Tracking
 
 ### Parallel Progress Monitoring:
+
 ```javascript
 // Monitor multiple task executions concurrently
 class ProgressMonitor {
   async trackParallelTasks(tasks) {
-    const monitors = tasks.map(task => ({
+    const monitors = tasks.map((task) => ({
       id: task.id,
       promise: this.executeWithProgress(task),
-      startTime: Date.now()
+      startTime: Date.now(),
     }));
-    
+
     // Update progress in real-time
     const progressInterval = setInterval(() => {
       this.displayProgress(monitors);
     }, 1000);
-    
-    const results = await Promise.all(
-      monitors.map(m => m.promise)
-    );
-    
+
+    const results = await Promise.all(monitors.map((m) => m.promise));
+
     clearInterval(progressInterval);
     return results;
   }
@@ -225,18 +227,21 @@ class ProgressMonitor {
 ## Tool Usage Guidelines (Optimized)
 
 ### For Task Delegation:
+
 • Group independent tasks for parallel execution
 • Use `new_task` in batches for related operations
 • Execute non-conflicting modes concurrently
 • Monitor all parallel executions for completion
 
 ### For Workflow Management:
+
 • Identify task dependencies before parallelization
 • Execute dependency-free tasks simultaneously
 • Batch similar operations together
 • Use topological sorting for complex workflows
 
 ### For Validation:
+
 • Run all validation checks concurrently
 • Batch file size checks across modules
 • Verify environment variables in parallel
@@ -251,6 +256,7 @@ class ProgressMonitor {
 • **Faster feedback loops** with parallel testing and validation
 
 ## Groups/Permissions
+
 - All permissions inherited from standard SPARC
 - parallel (for batchtools optimization)
 
@@ -273,8 +279,9 @@ npx claude-flow sparc run sparc-optimized "create microservices architecture wit
 ```
 
 ## Validation Checklist (Parallelized)
+
 ✅ Files < 500 lines (checked concurrently)
 ✅ No hard-coded env vars (validated in parallel)
 ✅ Modular, testable outputs (verified simultaneously)
 ✅ All subtasks end with `attempt_completion`
-✅ Parallel execution tracking and monitoring
+✅ Parallel execution tracking and monitoring

package/src/templates/claude-optimized/.claude/commands/sparc/spec-pseudocode.md

@@ -29,16 +29,19 @@ const analysisTask = [
   { tool: 'Glob', params: { pattern: '**/*.{ts,js,tsx,jsx}' } },
   { tool: 'Glob', params: { pattern: '**/package.json' } },
   { tool: 'Glob', params: { pattern: '**/*.test.*' } },
-  
+
   // Concurrent search for key patterns
   { tool: 'Grep', params: { pattern: 'TODO|FIXME|HACK', include: '*.{ts,js}' } },
   { tool: 'Grep', params: { pattern: 'class.*extends|interface.*{', include: '*.ts' } },
-  { tool: 'Grep', params: { pattern: 'export (default |const |function |class)', include: '*.{ts,js}' } },
-  
+  {
+    tool: 'Grep',
+    params: { pattern: 'export (default |const |function |class)', include: '*.{ts,js}' },
+  },
+
   // Parallel configuration analysis
   { tool: 'Read', params: { file_path: 'package.json' } },
   { tool: 'Read', params: { file_path: 'tsconfig.json' } },
-  { tool: 'Read', params: { file_path: '.env.example' } }
+  { tool: 'Read', params: { file_path: '.env.example' } },
 ];
 
 // Execute comprehensive analysis in parallel
@@ -48,18 +51,21 @@ const results = await batchtools.execute(analysisTask);
 ### Specification Generation Patterns
 
 1. **System Architecture Specs**:
+
    - Analyze all module exports and imports in parallel
    - Map component dependencies using concurrent file reading
    - Generate architecture diagrams data simultaneously
    - Create module interaction specs in batch
 
 2. **API Specification**:
+
    - Read all route definitions concurrently
    - Extract request/response schemas in parallel
    - Analyze middleware and authentication flows simultaneously
    - Generate OpenAPI specs using batch operations
 
 3. **Data Model Specs**:
+
    - Analyze all database schemas and models in parallel
    - Extract validation rules and constraints concurrently
    - Map relationships between entities using batch operations
@@ -77,39 +83,43 @@ const results = await batchtools.execute(analysisTask);
 // Example: Parallel pseudocode generation for authentication system
 const pseudocodeTask = [
   // Phase 1: Requirements Analysis (Parallel)
-  { 
+  {
     tool: 'MultiEdit',
     params: {
       file_path: 'specs/01_requirements.md',
       edits: [
-        { old_string: '', new_string: '# Authentication Requirements\n\n## Functional Requirements\n' },
+        {
+          old_string: '',
+          new_string: '# Authentication Requirements\n\n## Functional Requirements\n',
+        },
         { old_string: '', new_string: '## Non-Functional Requirements\n' },
-        { old_string: '', new_string: '## Edge Cases\n' }
-      ]
-    }
+        { old_string: '', new_string: '## Edge Cases\n' },
+      ],
+    },
   },
-  
+
   // Phase 2: Flow Diagrams (Concurrent)
   {
     tool: 'Write',
     params: {
       file_path: 'specs/02_auth_flow.md',
-      content: generateAuthFlowPseudocode()
-    }
+      content: generateAuthFlowPseudocode(),
+    },
   },
-  
+
   // Phase 3: Data Structures (Parallel)
   {
     tool: 'Write',
     params: {
       file_path: 'specs/03_data_structures.md',
-      content: generateDataStructureSpecs()
-    }
-  }
+      content: generateDataStructureSpecs(),
+    },
+  },
 ];
 ```
 
 ## Groups/Permissions
+
 - read
 - edit
 - batchtools
@@ -154,4 +164,4 @@ npx claude-flow sparc run spec-pseudocode "document database architecture using
 1. **Dependency Mapping**: Use parallel file reading to build complete dependency graphs
 2. **Convention Detection**: Identify coding patterns across the entire codebase simultaneously
 3. **Gap Analysis**: Compare existing code with requirements using parallel operations
-4. **Test Coverage Mapping**: Analyze test files and source files concurrently for coverage insights
+4. **Test Coverage Mapping**: Analyze test files and source files concurrently for coverage insights

package/src/templates/claude-optimized/.claude/commands/sparc/supabase-admin.md

@@ -24,6 +24,7 @@ Review supabase using @/mcp-instructions.txt. Never use the CLI, only the MCP se
 ### Parallel Database Operations
 
 #### Schema Creation:
+
 ```bash
 # Create multiple tables concurrently
 parallel --jobs 4 ::: \
@@ -34,6 +35,7 @@ parallel --jobs 4 ::: \
 ```
 
 #### RLS Policy Implementation:
+
 ```bash
 # Apply multiple RLS policies in parallel
 <use_mcp_tool>
@@ -65,6 +67,7 @@ parallel --jobs 4 ::: \
 ### Concurrent Resource Management
 
 #### Batch Table Analysis:
+
 ```bash
 # Analyze multiple schemas simultaneously
 <use_mcp_tool>
@@ -78,6 +81,7 @@ parallel --jobs 4 ::: \
 ```
 
 #### Parallel Migration Application:
+
 ```bash
 # Apply independent migrations concurrently
 migrations=("create_users" "create_profiles" "create_posts" "create_indexes")
@@ -90,6 +94,7 @@ wait
 ### Batch Performance Optimization
 
 #### Index Creation:
+
 ```bash
 # Create multiple indexes in parallel
 parallel --jobs 6 ::: \
@@ -102,6 +107,7 @@ parallel --jobs 6 ::: \
 ```
 
 #### Concurrent Function Creation:
+
 ```bash
 # Create multiple database functions simultaneously
 create_function "handle_new_user" &
@@ -114,18 +120,21 @@ wait
 ## Optimized Tool Usage Guidelines
 
 ### For Project Management:
+
 • List all projects and organizations concurrently
 • Batch cost checks for multiple resources
 • Create development branches in parallel when needed
 • Monitor multiple project statuses simultaneously
 
 ### For Database Operations:
+
 • Execute independent DDL operations in parallel
 • Batch similar DML operations together
 • Apply non-conflicting migrations concurrently
 • Generate TypeScript types for multiple tables at once
 
 ### For Security Implementation:
+
 • Apply RLS policies to multiple tables concurrently
 • Create authentication flows with parallel policy setup
 • Batch permission checks across tables
@@ -134,6 +143,7 @@ wait
 ## Workflow Optimization Examples
 
 ### Complete Database Setup:
+
 ```bash
 # 1. Parallel schema creation
 npx claude-flow sparc run supabase-admin-optimized "create all tables"
@@ -149,6 +159,7 @@ npx claude-flow sparc run supabase-admin-optimized "deploy all functions"
 ```
 
 ### Monitoring and Maintenance:
+
 ```bash
 # Check multiple services concurrently
 parallel --jobs 4 ::: \
@@ -161,23 +172,25 @@ parallel --jobs 4 ::: \
 ## Batch Operations Reference
 
 ### Parallel Table Operations:
+
 ```javascript
 // Create multiple tables with relationships
 const tableDefinitions = [
   { name: 'users', deps: [] },
   { name: 'profiles', deps: ['users'] },
   { name: 'posts', deps: ['users'] },
-  { name: 'comments', deps: ['posts', 'users'] }
+  { name: 'comments', deps: ['posts', 'users'] },
 ];
 
 // Sort by dependencies and create in parallel batches
 const batches = topologicalSort(tableDefinitions);
 for (const batch of batches) {
-  await Promise.all(batch.map(table => createTable(table)));
+  await Promise.all(batch.map((table) => createTable(table)));
 }
 ```
 
 ### Concurrent Policy Application:
+
 ```sql
 -- Apply multiple policies in a single transaction
 BEGIN;
@@ -185,7 +198,7 @@ BEGIN;
   ALTER TABLE profiles ENABLE ROW LEVEL SECURITY;
   ALTER TABLE posts ENABLE ROW LEVEL SECURITY;
   ALTER TABLE comments ENABLE ROW LEVEL SECURITY;
-  
+
   CREATE POLICY "Users can view own profile" ON users FOR SELECT USING (auth.uid() = id);
   CREATE POLICY "Users can update own profile" ON users FOR UPDATE USING (auth.uid() = id);
   CREATE POLICY "Profiles are viewable by everyone" ON profiles FOR SELECT USING (true);
@@ -202,6 +215,7 @@ COMMIT;
 • **Better resource utilization** with parallel index creation
 
 ## Groups/Permissions
+
 - read
 - edit
 - mcp
@@ -223,4 +237,4 @@ npx claude-flow sparc run supabase-admin-optimized "implement complete e-commerc
 
 # Batch security implementation
 npx claude-flow sparc run supabase-admin-optimized "apply RLS to all tables"
-```
+```

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

@@ -12,7 +12,9 @@ You implement Test-Driven Development (TDD, London School) with parallel test cr
 Optimize TDD workflow using batchtools for parallel test development and execution:
 
 ### Parallel Test Development (Red Phase)
+
 1. **Batch Test Creation**: Write multiple failing tests simultaneously:
+
    - Create unit tests for all methods in parallel
    - Generate integration tests concurrently
    - Build edge case tests in batch operations
@@ -24,12 +26,14 @@ Optimize TDD workflow using batchtools for parallel test development and executi
      { path: '/tests/unit/auth.service.test.ts', content: authServiceTests },
      { path: '/tests/unit/auth.controller.test.ts', content: authControllerTests },
      { path: '/tests/integration/auth.integration.test.ts', content: authIntegrationTests },
-     { path: '/tests/e2e/auth.e2e.test.ts', content: authE2ETests }
+     { path: '/tests/e2e/auth.e2e.test.ts', content: authE2ETests },
    ]);
    ```
 
 ### Efficient Implementation (Green Phase)
+
 1. **Parallel Minimal Implementation**:
+
    - Implement multiple functions to pass tests concurrently
    - Create stubs and mocks in parallel
    - Generate minimal code across layers simultaneously
@@ -41,12 +45,14 @@ Optimize TDD workflow using batchtools for parallel test development and executi
      runUnitTests(),
      runIntegrationTests(),
      runE2ETests(),
-     checkCoverage()
+     checkCoverage(),
    ]);
    ```
 
 ### Concurrent Refactoring (Refactor Phase)
+
 1. **Parallel Code Improvements**:
+
    - Refactor multiple components simultaneously
    - Optimize algorithms across files concurrently
    - Clean up code patterns in batch operations
@@ -58,11 +64,12 @@ Optimize TDD workflow using batchtools for parallel test development and executi
      validateCodeQuality(),
      checkTestCoverage(),
      runLinters(),
-     analyzePerformance()
+     analyzePerformance(),
    ]);
    ```
 
 ### TDD Workflow Optimization
+
 ```
 1. Red Phase (Parallel):
    ├── Write unit tests for all components
@@ -84,7 +91,9 @@ Optimize TDD workflow using batchtools for parallel test development and executi
 ```
 
 ### Batchtools Test Patterns
+
 - **Parallel Test Generation**:
+
   ```javascript
   // Generate tests for multiple methods at once
   const methods = ['create', 'read', 'update', 'delete'];
@@ -100,11 +109,12 @@ Optimize TDD workflow using batchtools for parallel test development and executi
     unit: () => exec('npm run test:unit'),
     integration: () => exec('npm run test:integration'),
     e2e: () => exec('npm run test:e2e'),
-    coverage: () => exec('npm run test:coverage')
+    coverage: () => exec('npm run test:coverage'),
   });
   ```
 
 ### Test Organization
+
 ```
 /tests/
   ├── unit/          # Created in parallel batches
@@ -116,6 +126,7 @@ Optimize TDD workflow using batchtools for parallel test development and executi
 Write failing tests first. Implement only enough code to pass. Refactor after green. Ensure tests do not hardcode secrets. Keep files < 500 lines. Validate modularity, test coverage, and clarity before using `attempt_completion`.
 
 ## Groups/Permissions
+
 - read
 - edit
 - browser
@@ -139,6 +150,7 @@ npx claude-flow sparc run tdd "implement user authentication"
 ## Batchtools TDD Examples
 
 ### Parallel Test Suite Creation
+
 ```javascript
 // Create complete test suite for a feature
 await batchtools.createTestSuite({
@@ -146,28 +158,30 @@ await batchtools.createTestSuite({
   tests: [
     { type: 'unit', targets: ['service', 'controller', 'middleware'] },
     { type: 'integration', scenarios: ['login', 'logout', 'refresh'] },
-    { type: 'e2e', flows: ['complete-auth-flow', 'error-handling'] }
-  ]
+    { type: 'e2e', flows: ['complete-auth-flow', 'error-handling'] },
+  ],
 });
 ```
 
 ### Concurrent Test-Code Cycle
+
 ```javascript
 // Run Red-Green cycle in parallel for multiple components
 await batchtools.parallel([
   { component: 'authService', test: writeAuthServiceTests, implement: implementAuthService },
   { component: 'tokenService', test: writeTokenServiceTests, implement: implementTokenService },
-  { component: 'userValidator', test: writeValidatorTests, implement: implementValidator }
+  { component: 'userValidator', test: writeValidatorTests, implement: implementValidator },
 ]);
 ```
 
 ### Batch Test Coverage Analysis
+
 ```javascript
 // Analyze coverage across all modules simultaneously
 const coverage = await batchtools.analyzeCoverage([
   '/src/services/**/*.ts',
   '/src/controllers/**/*.ts',
   '/src/middleware/**/*.ts',
-  '/src/validators/**/*.ts'
+  '/src/validators/**/*.ts',
 ]);
-```
+```