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

package/src/templates/claude-optimized/.claude/commands/sparc/post-deployment-monitoring-mode.md

@@ -16,17 +16,19 @@ Configure metrics, logs, uptime checks, and alerts using batch operations for co
 ### Core Monitoring Operations
 
 1. **Concurrent Metrics Collection**:
+
    ```javascript
    const metrics = await batchtools.parallel([
      () => collectCPUMetrics(allServices),
      () => collectMemoryMetrics(allServices),
      () => collectNetworkMetrics(allServices),
      () => collectDiskMetrics(allServices),
-     () => collectCustomMetrics(businessKPIs)
+     () => collectCustomMetrics(businessKPIs),
    ]);
    ```
 
 2. **Parallel Log Analysis**:
+
    ```javascript
    const logAnalysis = await batchtools.analyzeLogs({
      sources: ['app.log', 'error.log', 'access.log', 'security.log'],
@@ -34,21 +36,22 @@ Configure metrics, logs, uptime checks, and alerts using batch operations for co
        errors: /ERROR|FATAL|CRITICAL/i,
        warnings: /WARN|WARNING/i,
        slowQueries: /query took \d{4,}ms/i,
-       failures: /failed|timeout|refused/i
+       failures: /failed|timeout|refused/i,
      },
      timeRange: 'last-hour',
-     parallel: true
+     parallel: true,
    });
    ```
 
 3. **Batch Uptime Monitoring**:
+
    ```javascript
    const endpoints = await getHealthCheckEndpoints();
    const uptimeResults = await batchtools.checkEndpoints(endpoints, {
      parallel: true,
      timeout: 5000,
      retries: 3,
-     regions: ['us-east-1', 'eu-west-1', 'ap-south-1']
+     regions: ['us-east-1', 'eu-west-1', 'ap-south-1'],
    });
    ```
 
@@ -59,66 +62,75 @@ Configure metrics, logs, uptime checks, and alerts using batch operations for co
      { metric: 'memory', threshold: 90, duration: '3m', severity: 'critical' },
      { metric: 'error_rate', threshold: 5, duration: '1m', severity: 'critical' },
      { metric: 'response_time', threshold: 1000, duration: '2m', severity: 'warning' },
-     { metric: 'disk_space', threshold: 85, duration: '10m', severity: 'warning' }
+     { metric: 'disk_space', threshold: 85, duration: '10m', severity: 'warning' },
    ]);
    ```
 
 ### Advanced Monitoring Workflows
 
 **Real-time Performance Analysis**:
+
 ```javascript
 const performanceMonitoring = await batchtools.streamMetrics({
   services: getAllServices(),
   metrics: ['latency', 'throughput', 'error_rate', 'saturation'],
   aggregations: ['p50', 'p95', 'p99', 'mean', 'max'],
   interval: '1m',
-  parallel: true
+  parallel: true,
 });
 ```
 
 **Parallel Regression Detection**:
+
 ```javascript
 const regressionChecks = await batchtools.parallel([
   () => compareMetrics('current', 'baseline', 'response_time'),
   () => analyzeErrorRateChanges('last-deploy'),
   () => detectMemoryLeaks(memoryPatterns),
   () => checkDatabasePerformance(queryMetrics),
-  () => validateCacheHitRates(cacheMetrics)
+  () => validateCacheHitRates(cacheMetrics),
 ]);
 ```
 
 **Batch User Experience Monitoring**:
+
 ```javascript
 const uxMetrics = await batchtools.batch([
   { type: 'synthetic', tests: syntheticTests, regions: allRegions },
   { type: 'real-user', metrics: ['load_time', 'interaction_delay'] },
   { type: 'errors', track: ['js_errors', '4xx', '5xx'] },
-  { type: 'conversions', funnels: businessFunnels }
+  { type: 'conversions', funnels: businessFunnels },
 ]);
 ```
 
 ### Comprehensive System Health Checks
 
 1. **Multi-Region Monitoring**:
+
    ```javascript
    const regions = ['us-east-1', 'eu-west-1', 'ap-south-1'];
-   const regionalHealth = await batchtools.map(regions, async (region) => {
-     return {
-       region,
-       services: await checkServicesInRegion(region),
-       latency: await measureCrossRegionLatency(region),
-       capacity: await checkRegionalCapacity(region)
-     };
-   }, { concurrency: regions.length });
+   const regionalHealth = await batchtools.map(
+     regions,
+     async (region) => {
+       return {
+         region,
+         services: await checkServicesInRegion(region),
+         latency: await measureCrossRegionLatency(region),
+         capacity: await checkRegionalCapacity(region),
+       };
+     },
+     { concurrency: regions.length },
+   );
    ```
 
 2. **Dependency Health Monitoring**:
+
    ```javascript
    const dependencies = await batchtools.monitorDependencies({
      external: ['payment-api', 'email-service', 'cdn'],
      internal: ['database', 'cache', 'queue'],
      checks: ['availability', 'latency', 'error_rate'],
-     parallel: true
+     parallel: true,
    });
    ```
 
@@ -129,7 +141,7 @@ const uxMetrics = await batchtools.batch([
      algorithms: ['statistical', 'ml-based', 'rule-based'],
      sensitivity: 'medium',
      lookback: '7d',
-     parallel: true
+     parallel: true,
    });
    ```
 
@@ -140,17 +152,17 @@ const uxMetrics = await batchtools.batch([
 const incidentResponse = await batchtools.handleIncidents({
   detection: {
     sources: ['metrics', 'logs', 'alerts', 'user-reports'],
-    parallel: true
+    parallel: true,
   },
   classification: {
     severity: ['critical', 'high', 'medium', 'low'],
-    impact: ['user-facing', 'internal', 'performance']
+    impact: ['user-facing', 'internal', 'performance'],
   },
   response: {
     autoRemediation: true,
     notifications: ['slack', 'pagerduty', 'email'],
-    runbooks: automatedRunbooks
-  }
+    runbooks: automatedRunbooks,
+  },
 });
 ```
 
@@ -163,13 +175,14 @@ const reports = await batchtools.parallel([
   () => createAvailabilityReport(uptimeData),
   () => compileErrorAnalysis(errorLogs),
   () => summarizeUserImpact(uxMetrics),
-  () => calculateSLACompliance(slaTargets)
+  () => calculateSLACompliance(slaTargets),
 ]);
 ```
 
 ### Task Delegation
 
 Use `new_task` with batch specifications to:
+
 - Escalate performance degradations for optimization
 - Trigger parallel hotfix deployments
 - Coordinate multi-team incident response
@@ -184,6 +197,7 @@ Use `new_task` with batch specifications to:
 5. **Automated Remediation**: Implement self-healing for common issues
 
 Return `attempt_completion` with:
+
 - Consolidated monitoring dashboard data
 - Parallel analysis results across all services
 - Performance comparison with baselines
@@ -192,6 +206,7 @@ Return `attempt_completion` with:
 - SLA/SLO compliance status
 
 ## Groups/Permissions
+
 - read
 - edit
 - browser
@@ -236,9 +251,9 @@ const continuousMonitoring = async () => {
       () => collectAllMetrics(),
       () => analyzeAllLogs(),
       () => checkAllEndpoints(),
-      () => validateAllSLAs()
+      () => validateAllSLAs(),
     ]);
-    
+
     await processSnapshot(snapshot);
     await sleep(60000); // 1 minute interval
   }
@@ -250,9 +265,9 @@ const capacityPlanning = async () => {
     { collect: 'usage_trends', period: '30d' },
     { collect: 'growth_rate', period: '90d' },
     { collect: 'peak_patterns', period: '7d' },
-    { collect: 'resource_limits', current: true }
+    { collect: 'resource_limits', current: true },
   ]);
-  
+
   return await predictCapacityNeeds(data);
 };
 
@@ -263,9 +278,9 @@ const healthScore = async () => {
     () => calculatePerformanceScore(),
     () => calculateErrorScore(),
     () => calculateUserSatisfactionScore(),
-    () => calculateSecurityScore()
+    () => calculateSecurityScore(),
   ]);
-  
+
   return aggregateHealthScore(dimensions);
 };
-```
+```

package/src/templates/claude-optimized/.claude/commands/sparc/refinement-optimization-mode.md

@@ -16,6 +16,7 @@ Audit files for clarity, modularity, and size using parallel operations. Break l
 ### Parallel File Analysis
 
 #### Concurrent Size Checking:
+
 ```bash
 # Check all files for size violations in parallel
 find . -name "*.ts" -o -name "*.js" | \
@@ -23,6 +24,7 @@ find . -name "*.ts" -o -name "*.js" | \
 ```
 
 #### Batch Complexity Analysis:
+
 ```bash
 # Analyze multiple files for complexity metrics
 parallel --jobs 8 ::: \
@@ -35,21 +37,21 @@ parallel --jobs 8 ::: \
 ### Concurrent Refactoring Operations
 
 #### Parallel Module Extraction:
+
 ```javascript
 // Identify and extract modules concurrently
 const largeFiles = await findLargeFiles();
-const extractionTasks = largeFiles.map(file => ({
+const extractionTasks = largeFiles.map((file) => ({
   file,
-  modules: identifyExtractableModules(file)
+  modules: identifyExtractableModules(file),
 }));
 
 // Process extractions in parallel
-await Promise.all(
-  extractionTasks.map(task => extractModules(task))
-);
+await Promise.all(extractionTasks.map((task) => extractModules(task)));
 ```
 
 #### Batch Import Optimization:
+
 ```bash
 # Optimize imports across multiple files
 parallel --jobs 6 ::: \
@@ -64,6 +66,7 @@ parallel --jobs 6 ::: \
 ### Performance Optimization Batches
 
 #### Concurrent Bundle Analysis:
+
 ```bash
 # Analyze multiple bundles simultaneously
 parallel --jobs 4 ::: \
@@ -74,22 +77,22 @@ parallel --jobs 4 ::: \
 ```
 
 #### Parallel Code Splitting:
+
 ```javascript
 // Split code into chunks concurrently
 const splitPoints = [
   { route: '/dashboard', components: ['Dashboard', 'Charts'] },
   { route: '/profile', components: ['Profile', 'Settings'] },
-  { route: '/admin', components: ['Admin', 'Users'] }
+  { route: '/admin', components: ['Admin', 'Users'] },
 ];
 
-await Promise.all(
-  splitPoints.map(point => createLazyChunk(point))
-);
+await Promise.all(splitPoints.map((point) => createLazyChunk(point)));
 ```
 
 ### Configuration Optimization
 
 #### Batch Environment Variable Extraction:
+
 ```bash
 # Extract inline configs from multiple files
 find . -name "*.ts" -o -name "*.js" | \
@@ -100,6 +103,7 @@ cat *.env | sort | uniq > .env.consolidated
 ```
 
 #### Parallel Dependency Analysis:
+
 ```bash
 # Analyze dependencies across modules
 parallel --jobs 6 ::: \
@@ -114,6 +118,7 @@ parallel --jobs 6 ::: \
 ## Optimized Refactoring Workflows
 
 ### Large File Breakdown:
+
 ```bash
 # 1. Find all large files in parallel
 find_large_files() {
@@ -142,6 +147,7 @@ execute_refactoring() {
 ```
 
 ### Performance Optimization Pipeline:
+
 ```bash
 # Run all optimizations concurrently
 optimize_all() {
@@ -151,10 +157,10 @@ optimize_all() {
   optimize_styles &
   optimize_scripts &
   optimize_fonts &
-  
+
   # Wait for all to complete
   wait
-  
+
   # Generate optimization report
   generate_optimization_report
 }
@@ -166,7 +172,7 @@ optimize_all() {
 # Run tests for refactored modules in parallel
 test_refactored_modules() {
   local modules=("auth" "user" "dashboard" "api" "utils")
-  
+
   printf '%s\n' "${modules[@]}" | \
     parallel --jobs 5 'npm test -- --testPathPattern={}'
 }
@@ -184,18 +190,21 @@ verify_refactoring() {
 ## Tool Usage Guidelines (Optimized)
 
 ### For Analysis:
+
 • Use parallel file reading for large codebases
 • Batch similar analysis operations together
 • Run independent metrics calculations concurrently
 • Generate reports from multiple sources simultaneously
 
 ### For Refactoring:
+
 • Extract modules from multiple files in parallel
 • Apply similar transformations in batches
 • Update imports across files concurrently
 • Test refactored code in parallel
 
 ### For Optimization:
+
 • Analyze multiple performance metrics simultaneously
 • Apply optimizations to independent modules concurrently
 • Batch configuration updates together
@@ -210,6 +219,7 @@ verify_refactoring() {
 • **Better resource utilization** during large-scale refactoring
 
 ## Groups/Permissions
+
 - read
 - edit
 - browser
@@ -233,4 +243,4 @@ npx claude-flow sparc run refinement-optimization-mode-optimized "optimize all m
 
 # Batch refactor large files
 npx claude-flow sparc run refinement-optimization-mode-optimized "break down all files over 500 lines"
-```
+```

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

@@ -12,17 +12,19 @@ You perform static and dynamic audits using parallel scanning and batch analysis
 ### Parallel Security Scanning Strategy
 
 1. **Concurrent Vulnerability Detection**:
+
    ```javascript
    const securityScans = await batchtools.parallel([
      () => scanForSecrets(['**/*.js', '**/*.ts', '**/*.env']),
      () => checkDependencyVulnerabilities('package.json'),
      () => analyzeCodePatterns(['SQL injection', 'XSS', 'CSRF']),
      () => auditFilePermissions('**/*'),
-     () => validateCryptoUsage('src/**/*.{ts,js}')
+     () => validateCryptoUsage('src/**/*.{ts,js}'),
    ]);
    ```
 
 2. **Batch Secret Detection**:
+
    - Scan all file types simultaneously for exposed credentials
    - Check multiple pattern types in parallel (API keys, passwords, tokens)
    - Analyze git history for accidentally committed secrets
@@ -37,6 +39,7 @@ You perform static and dynamic audits using parallel scanning and batch analysis
 ### Security Audit Workflows
 
 **Comprehensive Security Scan**:
+
 ```javascript
 const auditResults = await batchtools.securityAudit({
   targets: ['src/', 'tests/', 'config/', 'scripts/'],
@@ -47,30 +50,32 @@ const auditResults = await batchtools.securityAudit({
     'injection',
     'crypto',
     'authentication',
-    'authorization'
+    'authorization',
   ],
-  parallel: true
+  parallel: true,
 });
 ```
 
 **Batch Vulnerability Analysis**:
+
 ```javascript
 // Check multiple vulnerability databases
 const vulnDatabases = ['npm-audit', 'snyk', 'owasp', 'cve'];
 const vulnerabilities = await batchtools.checkVulnerabilities(vulnDatabases, {
   includeDevDeps: true,
-  severityThreshold: 'medium'
+  severityThreshold: 'medium',
 });
 ```
 
 **Parallel Pattern Detection**:
+
 ```javascript
 const securityPatterns = [
   { pattern: /password\s*=\s*["'][^"']+["']/gi, risk: 'high' },
   { pattern: /api[_-]?key\s*[:=]\s*["'][^"']+["']/gi, risk: 'critical' },
   { pattern: /eval\s*\(/g, risk: 'high' },
   { pattern: /innerHTML\s*=/g, risk: 'medium' },
-  { pattern: /SELECT.*FROM.*WHERE/gi, risk: 'medium' }
+  { pattern: /SELECT.*FROM.*WHERE/gi, risk: 'medium' },
 ];
 
 const findings = await batchtools.searchPatterns(securityPatterns, '**/*.{js,ts}');
@@ -79,6 +84,7 @@ const findings = await batchtools.searchPatterns(securityPatterns, '**/*.{js,ts}
 ### Advanced Security Checks
 
 1. **Parallel OWASP Top 10 Scanning**:
+
    ```javascript
    const owaspChecks = await batchtools.parallel([
      () => checkInjectionVulnerabilities(),
@@ -90,11 +96,12 @@ const findings = await batchtools.searchPatterns(securityPatterns, '**/*.{js,ts}
      () => checkXSS(),
      () => validateDeserialization(),
      () => auditComponentVulnerabilities(),
-     () => checkLoggingMonitoring()
+     () => checkLoggingMonitoring(),
    ]);
    ```
 
 2. **Batch Compliance Validation**:
+
    - Check GDPR compliance across all data handlers
    - Validate PCI DSS requirements in parallel
    - Audit HIPAA compliance for health data
@@ -106,7 +113,7 @@ const findings = await batchtools.searchPatterns(securityPatterns, '**/*.{js,ts}
      { check: 'algorithms', validate: ['AES-256', 'RSA-2048'] },
      { check: 'randomness', sources: ['crypto.getRandomValues'] },
      { check: 'keyStorage', forbidden: ['localStorage', 'cookies'] },
-     { check: 'tlsVersions', minimum: 'TLS1.2' }
+     { check: 'tlsVersions', minimum: 'TLS1.2' },
    ]);
    ```
 
@@ -118,7 +125,7 @@ const codeQuality = await batchtools.parallel([
   () => findLargeFiles({ maxLines: 500, extensions: ['.js', '.ts'] }),
   () => analyzeModuleCoupling({ maxDependencies: 10 }),
   () => detectCircularDependencies(),
-  () => checkCodeDuplication({ threshold: 0.2 })
+  () => checkCodeDuplication({ threshold: 0.2 }),
 ]);
 ```
 
@@ -130,13 +137,14 @@ const remediations = await batchtools.generateFixes({
   secrets: { action: 'move-to-env', validate: true },
   largeFiles: { action: 'split-module', maxSize: 300 },
   vulnerabilities: { action: 'update-deps', test: true },
-  permissions: { action: 'restrict', mode: '644' }
+  permissions: { action: 'restrict', mode: '644' },
 });
 ```
 
 ### Task Delegation
 
 Use `new_task` with batch specifications to:
+
 - Assign parallel sub-audits for different modules
 - Delegate specific vulnerability fixes
 - Create batch refactoring tasks for oversized files
@@ -145,6 +153,7 @@ Use `new_task` with batch specifications to:
 ### Reporting
 
 Return `attempt_completion` with:
+
 - Consolidated security findings from all parallel scans
 - Batch vulnerability assessment results
 - Performance metrics showing scan efficiency
@@ -160,6 +169,7 @@ Return `attempt_completion` with:
 5. **Continuous Monitoring**: Set up parallel watchers for real-time security
 
 ## Groups/Permissions
+
 - read
 - edit
 - batchtools
@@ -200,19 +210,23 @@ const securityGate = async (commit) => {
     () => scanCommitForSecrets(commit),
     () => checkNewDependencies(commit),
     () => validateSecurityPolicies(commit),
-    () => runStaticAnalysis(commit)
+    () => runStaticAnalysis(commit),
   ]);
-  
-  return results.every(r => r.passed);
+
+  return results.every((r) => r.passed);
 };
 
 // Scheduled Security Audit
 const weeklyAudit = async () => {
   const services = await getServiceList();
-  const audits = await batchtools.map(services, async (service) => {
-    return await comprehensiveSecurityAudit(service);
-  }, { concurrency: 5 });
-  
+  const audits = await batchtools.map(
+    services,
+    async (service) => {
+      return await comprehensiveSecurityAudit(service);
+    },
+    { concurrency: 5 },
+  );
+
   await generateSecurityReport(audits);
 };
-```
+```