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

package/src/cli/simple-commands/sparc/specification.js

@@ -18,9 +18,9 @@ export class SparcSpecification extends SparcPhase {
    */
   async execute() {
     console.log('📋 Starting Specification Phase');
-    
+
     await this.initializePhase();
-    
+
     const result = {
       requirements: [],
       acceptanceCriteria: [],
@@ -31,14 +31,14 @@ export class SparcSpecification extends SparcPhase {
       businessValue: '',
       scope: {
         included: [],
-        excluded: []
+        excluded: [],
       },
       timeline: {
         estimated: '',
-        phases: []
+        phases: [],
       },
       risks: [],
-      dependencies: []
+      dependencies: [],
     };
 
     try {
@@ -48,34 +48,34 @@ export class SparcSpecification extends SparcPhase {
 
       // Extract requirements
       result.requirements = await this.extractRequirements(analysis);
-      
+
       // Define acceptance criteria
       result.acceptanceCriteria = await this.defineAcceptanceCriteria(result.requirements);
-      
+
       // Create user stories
       result.userStories = await this.createUserStories(result.requirements);
-      
+
       // Identify constraints
       result.constraints = await this.identifyConstraints();
-      
+
       // Document assumptions
       result.assumptions = await this.documentAssumptions();
-      
+
       // Identify stakeholders
       result.stakeholders = await this.identifyStakeholders();
-      
+
       // Define business value
       result.businessValue = await this.defineBusiness();
-      
+
       // Define scope
       result.scope = await this.defineScope(result.requirements);
-      
+
       // Estimate timeline
       result.timeline = await this.estimateTimeline(result.requirements);
-      
+
       // Identify risks
       result.risks = await this.identifyRisks(result.requirements);
-      
+
       // Identify dependencies
       result.dependencies = await this.identifyDependencies(result.requirements);
 
@@ -87,7 +87,6 @@ export class SparcSpecification extends SparcPhase {
 
       console.log('✅ Specification phase completed');
       return result;
-
     } catch (error) {
       console.error('❌ Specification phase failed:', error.message);
       throw error;
@@ -104,7 +103,7 @@ export class SparcSpecification extends SparcPhase {
       domain: this.identifyDomain(),
       keywords: this.extractKeywords(),
       verbs: this.extractActionVerbs(),
-      entities: this.extractEntities()
+      entities: this.extractEntities(),
     };
 
     return analysis;
@@ -115,12 +114,24 @@ export class SparcSpecification extends SparcPhase {
    */
   categorizeTask() {
     const taskLower = this.taskDescription.toLowerCase();
-    
-    if (taskLower.includes('api') || taskLower.includes('endpoint') || taskLower.includes('service')) {
+
+    if (
+      taskLower.includes('api') ||
+      taskLower.includes('endpoint') ||
+      taskLower.includes('service')
+    ) {
       return 'api_development';
-    } else if (taskLower.includes('ui') || taskLower.includes('frontend') || taskLower.includes('interface')) {
+    } else if (
+      taskLower.includes('ui') ||
+      taskLower.includes('frontend') ||
+      taskLower.includes('interface')
+    ) {
       return 'frontend_development';
-    } else if (taskLower.includes('database') || taskLower.includes('data') || taskLower.includes('storage')) {
+    } else if (
+      taskLower.includes('database') ||
+      taskLower.includes('data') ||
+      taskLower.includes('storage')
+    ) {
       return 'data_management';
     } else if (taskLower.includes('test') || taskLower.includes('testing')) {
       return 'testing';
@@ -138,9 +149,16 @@ export class SparcSpecification extends SparcPhase {
    */
   assessComplexity() {
     const wordCount = this.taskDescription.split(' ').length;
-    const complexityKeywords = ['integrate', 'complex', 'multiple', 'advanced', 'enterprise', 'scalable'];
-    const hasComplexityKeywords = complexityKeywords.some(keyword => 
-      this.taskDescription.toLowerCase().includes(keyword)
+    const complexityKeywords = [
+      'integrate',
+      'complex',
+      'multiple',
+      'advanced',
+      'enterprise',
+      'scalable',
+    ];
+    const hasComplexityKeywords = complexityKeywords.some((keyword) =>
+      this.taskDescription.toLowerCase().includes(keyword),
     );
 
     if (wordCount > 20 || hasComplexityKeywords) {
@@ -157,19 +175,19 @@ export class SparcSpecification extends SparcPhase {
    */
   identifyDomain() {
     const domains = {
-      'web': ['web', 'website', 'html', 'css', 'javascript'],
-      'mobile': ['mobile', 'app', 'android', 'ios'],
-      'data': ['data', 'analytics', 'ml', 'ai', 'machine learning'],
-      'security': ['security', 'auth', 'authentication', 'encryption'],
-      'devops': ['deploy', 'ci/cd', 'docker', 'kubernetes'],
-      'backend': ['api', 'server', 'database', 'backend'],
-      'frontend': ['ui', 'ux', 'frontend', 'interface']
+      web: ['web', 'website', 'html', 'css', 'javascript'],
+      mobile: ['mobile', 'app', 'android', 'ios'],
+      data: ['data', 'analytics', 'ml', 'ai', 'machine learning'],
+      security: ['security', 'auth', 'authentication', 'encryption'],
+      devops: ['deploy', 'ci/cd', 'docker', 'kubernetes'],
+      backend: ['api', 'server', 'database', 'backend'],
+      frontend: ['ui', 'ux', 'frontend', 'interface'],
     };
 
     const taskLower = this.taskDescription.toLowerCase();
-    
+
     for (const [domain, keywords] of Object.entries(domains)) {
-      if (keywords.some(keyword => taskLower.includes(keyword))) {
+      if (keywords.some((keyword) => taskLower.includes(keyword))) {
         return domain;
       }
     }
@@ -182,10 +200,25 @@ export class SparcSpecification extends SparcPhase {
    */
   extractKeywords() {
     const words = this.taskDescription.toLowerCase().split(/\s+/);
-    const stopWords = ['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'];
-    
+    const stopWords = [
+      'the',
+      'a',
+      'an',
+      'and',
+      'or',
+      'but',
+      'in',
+      'on',
+      'at',
+      'to',
+      'for',
+      'of',
+      'with',
+      'by',
+    ];
+
     return words
-      .filter(word => word.length > 2 && !stopWords.includes(word))
+      .filter((word) => word.length > 2 && !stopWords.includes(word))
       .filter((word, index, arr) => arr.indexOf(word) === index) // Remove duplicates
       .slice(0, 10); // Top 10 keywords
   }
@@ -194,10 +227,23 @@ export class SparcSpecification extends SparcPhase {
    * Extract action verbs
    */
   extractActionVerbs() {
-    const verbs = ['create', 'build', 'develop', 'implement', 'design', 'setup', 'configure', 'deploy', 'test', 'optimize', 'refactor', 'integrate'];
+    const verbs = [
+      'create',
+      'build',
+      'develop',
+      'implement',
+      'design',
+      'setup',
+      'configure',
+      'deploy',
+      'test',
+      'optimize',
+      'refactor',
+      'integrate',
+    ];
     const taskLower = this.taskDescription.toLowerCase();
-    
-    return verbs.filter(verb => taskLower.includes(verb));
+
+    return verbs.filter((verb) => taskLower.includes(verb));
   }
 
   /**
@@ -206,14 +252,18 @@ export class SparcSpecification extends SparcPhase {
   extractEntities() {
     const entities = [];
     const words = this.taskDescription.split(/\s+/);
-    
+
     // Look for capitalized words (potential entities)
     for (const word of words) {
-      if (word.length > 2 && word[0] === word[0].toUpperCase() && word.slice(1) === word.slice(1).toLowerCase()) {
+      if (
+        word.length > 2 &&
+        word[0] === word[0].toUpperCase() &&
+        word.slice(1) === word.slice(1).toLowerCase()
+      ) {
         entities.push(word);
       }
     }
-    
+
     return entities;
   }
 
@@ -222,7 +272,7 @@ export class SparcSpecification extends SparcPhase {
    */
   async extractRequirements(analysis) {
     const requirements = [];
-    
+
     // Functional requirements based on task type
     switch (analysis.type) {
       case 'api_development':
@@ -231,47 +281,47 @@ export class SparcSpecification extends SparcPhase {
           'API must handle authentication and authorization',
           'API must return appropriate HTTP status codes',
           'API must validate input data',
-          'API must handle errors gracefully'
+          'API must handle errors gracefully',
         );
         break;
-        
+
       case 'frontend_development':
         requirements.push(
           'Interface must be responsive and mobile-friendly',
           'User interface must be intuitive and accessible',
           'Application must handle user input validation',
           'Interface must provide feedback for user actions',
-          'Application must be cross-browser compatible'
+          'Application must be cross-browser compatible',
         );
         break;
-        
+
       case 'data_management':
         requirements.push(
           'System must ensure data integrity',
           'Data must be properly normalized',
           'System must handle concurrent access',
           'Data must be backed up regularly',
-          'System must provide data recovery mechanisms'
+          'System must provide data recovery mechanisms',
         );
         break;
-        
+
       case 'testing':
         requirements.push(
           'Test suite must achieve minimum 80% code coverage',
           'Tests must be automated and repeatable',
           'Tests must validate all critical paths',
           'Test data must be properly managed',
-          'Tests must run efficiently'
+          'Tests must run efficiently',
         );
         break;
-        
+
       default:
         requirements.push(
           'System must be reliable and performant',
           'Code must be maintainable and well-documented',
           'System must handle edge cases gracefully',
           'Implementation must follow best practices',
-          'System must be secure and robust'
+          'System must be secure and robust',
         );
     }
 
@@ -281,7 +331,7 @@ export class SparcSpecification extends SparcPhase {
         'System must be scalable and handle high load',
         'Architecture must be modular and extensible',
         'System must have comprehensive monitoring',
-        'Implementation must include performance optimization'
+        'Implementation must include performance optimization',
       );
     }
 
@@ -293,7 +343,7 @@ export class SparcSpecification extends SparcPhase {
    */
   async defineAcceptanceCriteria(requirements) {
     const criteria = [];
-    
+
     for (const requirement of requirements) {
       const criterion = {
         requirement: requirement,
@@ -301,12 +351,12 @@ export class SparcSpecification extends SparcPhase {
         when: this.generateWhenCondition(requirement),
         then: this.generateThenCondition(requirement),
         priority: this.assessRequirementPriority(requirement),
-        testable: true
+        testable: true,
       };
-      
+
       criteria.push(criterion);
     }
-    
+
     return criteria;
   }
 
@@ -355,14 +405,20 @@ export class SparcSpecification extends SparcPhase {
    * Assess requirement priority
    */
   assessRequirementPriority(requirement) {
-    const highPriorityKeywords = ['must', 'critical', 'security', 'authentication', 'data integrity'];
+    const highPriorityKeywords = [
+      'must',
+      'critical',
+      'security',
+      'authentication',
+      'data integrity',
+    ];
     const mediumPriorityKeywords = ['should', 'performance', 'optimization', 'monitoring'];
-    
+
     const reqLower = requirement.toLowerCase();
-    
-    if (highPriorityKeywords.some(keyword => reqLower.includes(keyword))) {
+
+    if (highPriorityKeywords.some((keyword) => reqLower.includes(keyword))) {
       return 'high';
-    } else if (mediumPriorityKeywords.some(keyword => reqLower.includes(keyword))) {
+    } else if (mediumPriorityKeywords.some((keyword) => reqLower.includes(keyword))) {
       return 'medium';
     } else {
       return 'low';
@@ -374,19 +430,19 @@ export class SparcSpecification extends SparcPhase {
    */
   async createUserStories(requirements) {
     const stories = [];
-    
+
     for (const requirement of requirements) {
       const story = {
         title: this.generateStoryTitle(requirement),
         narrative: this.generateStoryNarrative(requirement),
         acceptanceCriteria: this.generateStoryAcceptanceCriteria(requirement),
         priority: this.assessRequirementPriority(requirement),
-        estimation: this.estimateStoryPoints(requirement)
+        estimation: this.estimateStoryPoints(requirement),
       };
-      
+
       stories.push(story);
     }
-    
+
     return stories;
   }
 
@@ -395,9 +451,11 @@ export class SparcSpecification extends SparcPhase {
    */
   generateStoryTitle(requirement) {
     const words = requirement.split(' ');
-    const actionWord = words.find(word => ['provide', 'handle', 'ensure', 'validate'].includes(word.toLowerCase()));
-    const objectWord = words.find(word => ['API', 'data', 'user', 'system'].includes(word));
-    
+    const actionWord = words.find((word) =>
+      ['provide', 'handle', 'ensure', 'validate'].includes(word.toLowerCase()),
+    );
+    const objectWord = words.find((word) => ['API', 'data', 'user', 'system'].includes(word));
+
     return `${actionWord || 'Implement'} ${objectWord || 'functionality'}`;
   }
 
@@ -421,7 +479,7 @@ export class SparcSpecification extends SparcPhase {
   estimateStoryPoints(requirement) {
     const complexity = this.assessComplexity();
     const priority = this.assessRequirementPriority(requirement);
-    
+
     if (complexity === 'high' && priority === 'high') {
       return 8;
     } else if (complexity === 'high' || priority === 'high') {
@@ -445,7 +503,7 @@ export class SparcSpecification extends SparcPhase {
       'Must maintain backward compatibility',
       'Must handle concurrent users',
       'Must have proper error handling',
-      'Must include comprehensive logging'
+      'Must include comprehensive logging',
     ];
   }
 
@@ -461,7 +519,7 @@ export class SparcSpecification extends SparcPhase {
       'Third-party APIs are stable',
       'Security protocols are established',
       'Backup procedures are in place',
-      'Monitoring systems are operational'
+      'Monitoring systems are operational',
     ];
   }
 
@@ -475,7 +533,7 @@ export class SparcSpecification extends SparcPhase {
       { role: 'QA Team', responsibility: 'Testing and validation' },
       { role: 'DevOps Team', responsibility: 'Deployment and operations' },
       { role: 'Security Team', responsibility: 'Security review' },
-      { role: 'End Users', responsibility: 'Feedback and acceptance' }
+      { role: 'End Users', responsibility: 'Feedback and acceptance' },
     ];
   }
 
@@ -484,7 +542,7 @@ export class SparcSpecification extends SparcPhase {
    */
   async defineBusiness() {
     const analysis = await this.analyzeTaskDescription();
-    
+
     switch (analysis.type) {
       case 'api_development':
         return 'Enables system integration and data exchange, improving operational efficiency';
@@ -512,7 +570,7 @@ export class SparcSpecification extends SparcPhase {
       'Advanced analytics and reporting',
       'Mobile-specific optimizations',
       'Legacy system migration',
-      'Third-party plugin development'
+      'Third-party plugin development',
     ];
 
     return { included, excluded };
@@ -525,7 +583,7 @@ export class SparcSpecification extends SparcPhase {
     const totalStoryPoints = requirements.length * 3; // Average 3 points per requirement
     const developmentVelocity = 10; // Points per sprint
     const sprintsNeeded = Math.ceil(totalStoryPoints / developmentVelocity);
-    
+
     return {
       estimated: `${sprintsNeeded * 2} weeks`,
       phases: [
@@ -533,8 +591,8 @@ export class SparcSpecification extends SparcPhase {
         { name: 'Architecture', duration: '1 week' },
         { name: 'Development', duration: `${sprintsNeeded} weeks` },
         { name: 'Testing', duration: '1 week' },
-        { name: 'Deployment', duration: '1 week' }
-      ]
+        { name: 'Deployment', duration: '1 week' },
+      ],
     };
   }
 
@@ -547,26 +605,26 @@ export class SparcSpecification extends SparcPhase {
         risk: 'Technical complexity higher than estimated',
         probability: 'Medium',
         impact: 'High',
-        mitigation: 'Conduct proof of concept before full implementation'
+        mitigation: 'Conduct proof of concept before full implementation',
       },
       {
         risk: 'Requirements change during development',
         probability: 'High',
         impact: 'Medium',
-        mitigation: 'Implement agile development with regular reviews'
+        mitigation: 'Implement agile development with regular reviews',
       },
       {
         risk: 'Integration issues with external systems',
         probability: 'Medium',
         impact: 'High',
-        mitigation: 'Early integration testing and API validation'
+        mitigation: 'Early integration testing and API validation',
       },
       {
         risk: 'Performance issues under load',
         probability: 'Low',
         impact: 'High',
-        mitigation: 'Load testing and performance monitoring'
-      }
+        mitigation: 'Load testing and performance monitoring',
+      },
     ];
   }
 
@@ -575,7 +633,7 @@ export class SparcSpecification extends SparcPhase {
    */
   async identifyDependencies(requirements) {
     const dependencies = [];
-    
+
     for (const requirement of requirements) {
       if (requirement.includes('API')) {
         dependencies.push('Database schema definition');
@@ -590,7 +648,7 @@ export class SparcSpecification extends SparcPhase {
         dependencies.push('Certificate management');
       }
     }
-    
+
     return [...new Set(dependencies)]; // Remove duplicates
   }
 
@@ -607,22 +665,30 @@ ${result.businessValue}
 ${result.requirements.map((req, index) => `${index + 1}. ${req}`).join('\n')}
 
 ## Acceptance Criteria
-${result.acceptanceCriteria.map((criteria, index) => `
+${result.acceptanceCriteria
+  .map(
+    (criteria, index) => `
 ### ${index + 1}. ${criteria.requirement}
 - **Given**: ${criteria.given}
 - **When**: ${criteria.when}
 - **Then**: ${criteria.then}
 - **Priority**: ${criteria.priority}
-`).join('\n')}
+`,
+  )
+  .join('\n')}
 
 ## User Stories
-${result.userStories.map((story, index) => `
+${result.userStories
+  .map(
+    (story, index) => `
 ### ${index + 1}. ${story.title}
 ${story.narrative}
 **Acceptance Criteria**: ${story.acceptanceCriteria.join(', ')}
 **Priority**: ${story.priority}
 **Estimation**: ${story.estimation} points
-`).join('\n')}
+`,
+  )
+  .join('\n')}
 
 ## Constraints
 ${result.constraints.map((constraint, index) => `${index + 1}. ${constraint}`).join('\n')}
@@ -640,21 +706,25 @@ ${result.scope.excluded.map((item, index) => `${index + 1}. ${item}`).join('\n')
 ## Timeline
 **Estimated Duration**: ${result.timeline.estimated}
 
-${result.timeline.phases.map(phase => `- ${phase.name}: ${phase.duration}`).join('\n')}
+${result.timeline.phases.map((phase) => `- ${phase.name}: ${phase.duration}`).join('\n')}
 
 ## Risks
-${result.risks.map((risk, index) => `
+${result.risks
+  .map(
+    (risk, index) => `
 ### ${index + 1}. ${risk.risk}
 - **Probability**: ${risk.probability}
 - **Impact**: ${risk.impact}
 - **Mitigation**: ${risk.mitigation}
-`).join('\n')}
+`,
+  )
+  .join('\n')}
 
 ## Dependencies
 ${result.dependencies.map((dep, index) => `${index + 1}. ${dep}`).join('\n')}
 
 ## Stakeholders
-${result.stakeholders.map(stakeholder => `- **${stakeholder.role}**: ${stakeholder.responsibility}`).join('\n')}
+${result.stakeholders.map((stakeholder) => `- **${stakeholder.role}**: ${stakeholder.responsibility}`).join('\n')}
 `;
 
     // Save document
@@ -663,4 +733,4 @@ ${result.stakeholders.map(stakeholder => `- **${stakeholder.role}**: ${stakehold
   }
 }
 
-export default SparcSpecification;
+export default SparcSpecification;

package/src/cli/simple-commands/sparc-modes/architect.js

@@ -122,4 +122,4 @@ npx claude-flow swarm "Full implementation of ${taskDescription} architecture" \
 npx claude-flow status
 tail -f ./swarm-runs/*/swarm.log
 \`\`\``;
-}
+}

package/src/cli/simple-commands/sparc-modes/ask.js

@@ -123,4 +123,4 @@ npx claude-flow memory list
 Based on your request "${taskDescription}", which SPARC mode would you like to use? Or would you like me to help you break down your task into smaller, mode-specific subtasks?
 
 Remember: The SPARC methodology ensures systematic, high-quality development. Each mode has a specific purpose - use them in combination for best results!`;
-}
+}

package/src/cli/simple-commands/sparc-modes/code.js

@@ -145,4 +145,4 @@ npx claude-flow swarm "Integration testing and production deployment preparation
 npx claude-flow status
 tail -f ./swarm-runs/*/swarm.log
 \`\`\``;
-}
+}

package/src/cli/simple-commands/sparc-modes/debug.js

@@ -109,4 +109,4 @@ After debugging completes:
 - \`npx claude-flow sparc run security-review "Review security impact of ${taskDescription} fix" --non-interactive\`
 - \`npx claude-flow sparc run refinement-optimization-mode "Refactor affected modules for better maintainability" --non-interactive\`
 - \`npx claude-flow sparc run post-deployment-monitoring-mode "Monitor ${taskDescription} fix in production" --non-interactive\``;
-}
+}

package/src/cli/simple-commands/sparc-modes/devops.js

@@ -134,4 +134,4 @@ After DevOps setup:
 - \`npx claude-flow sparc run post-deployment-monitoring-mode "Verify production deployment health" --non-interactive\`
 - \`npx claude-flow sparc run security-review "Audit infrastructure security" --non-interactive\`
 - \`npx claude-flow sparc run refinement-optimization-mode "Optimize deployment performance" --non-interactive\``;
-}
+}

package/src/cli/simple-commands/sparc-modes/docs-writer.js

@@ -35,4 +35,4 @@ export function getDocsWriterOrchestration(taskDescription, memoryNamespace) {
    - docs/getting-started.md
    - docs/api-reference.md
    - docs/troubleshooting.md`;
-}
+}

package/src/cli/simple-commands/sparc-modes/generic.js

@@ -31,4 +31,4 @@ export function getGenericOrchestration(taskDescription, memoryNamespace) {
    - Completed implementation
    - Documentation
    - Test results`;
-}
+}