claude-flow-novice 1.2.1 → 1.3.0

package/examples/parallel-2/run-all-tests.ts

@@ -0,0 +1,283 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Main test runner for all agent demonstrations
+ * Shows both sequential and parallel execution modes
+ */
+
+import { CoordinatorAgent } from './coordinator-agent-test';
+import { ResearcherAgent } from './researcher-agent-test';
+import { DeveloperAgent } from './developer-agent-test';
+import { AnalyzerAgent } from './analyzer-agent-test';
+import { ReviewerAgent } from './reviewer-agent-test';
+import { TesterAgent } from './tester-agent-test';
+import { DocumenterAgent } from './documenter-agent-test';
+import { MonitorAgent } from './monitor-agent-test';
+import { SpecialistAgent } from './specialist-agent-test';
+
+class AgentTestRunner {
+  async runSequentialTests() {
+    console.log('\n🔄 SEQUENTIAL EXECUTION MODE');
+    console.log('═'.repeat(60));
+    console.log('Running agent tests one after another...\n');
+    
+    const startTime = Date.now();
+    const results = [];
+    
+    // Coordinator test
+    console.log('1️⃣  Testing Coordinator Agent...');
+    const coordinator = new CoordinatorAgent('coordinator-seq-001');
+    results.push(await coordinator.orchestrateSwarmTask('Build authentication system', 3));
+    
+    // Researcher test
+    console.log('2️⃣  Testing Researcher Agent...');
+    const researcher = new ResearcherAgent('researcher-seq-001');
+    results.push(await researcher.conductResearch('REST API best practices'));
+    
+    // Developer test
+    console.log('3️⃣  Testing Developer Agent...');
+    const developer = new DeveloperAgent('developer-seq-001');
+    results.push(await developer.generateCode('user authentication'));
+    
+    // Analyzer test
+    console.log('4️⃣  Testing Analyzer Agent...');
+    const analyzer = new AnalyzerAgent('analyzer-seq-001');
+    results.push(await analyzer.analyzePerformanceMetrics({
+      response_times: [245, 312, 198, 580, 225],
+      error_counts: { '4xx': 12, '5xx': 3 },
+      cpu_usage: [45.2, 52.1, 48.7, 61.3],
+      memory_usage: [1024, 1156, 1298, 1402]
+    }));
+    
+    // Reviewer test
+    console.log('5️⃣  Testing Reviewer Agent...');
+    const reviewer = new ReviewerAgent('reviewer-seq-001');
+    results.push(await reviewer.performCodeReview({
+      title: 'Feature: Add user authentication',
+      author: 'developer123',
+      files: ['src/auth/login.ts', 'src/auth/logout.ts', 'tests/auth.test.ts']
+    }));
+    
+    // Tester test
+    console.log('6️⃣  Testing Tester Agent...');
+    const tester = new TesterAgent('tester-seq-001');
+    results.push(await tester.writeUnitTests('UserAuthentication'));
+    
+    // Documenter test
+    console.log('7️⃣  Testing Documenter Agent...');
+    const documenter = new DocumenterAgent('documenter-seq-001');
+    results.push(await documenter.generateAPIDocumentation({
+      name: 'User Authentication API',
+      version: '1.0',
+      endpoints: ['/auth/login', '/auth/validate', '/auth/refresh', '/auth/logout']
+    }));
+    
+    // Monitor test
+    console.log('8️⃣  Testing Monitor Agent...');
+    const monitor = new MonitorAgent('monitor-seq-001');
+    results.push(await monitor.monitorSystemHealth());
+    
+    // Specialist test
+    console.log('9️⃣  Testing Specialist Agent...');
+    const specialist = new SpecialistAgent('specialist-seq-001');
+    results.push(await specialist.provideMachineLearningExpertise('Customer churn prediction'));
+    
+    const totalTime = Date.now() - startTime;
+    
+    console.log('\n✅ Sequential execution completed');
+    console.log(`Total time: ${totalTime}ms`);
+    console.log(`Tasks completed: ${results.length}`);
+    
+    return { mode: 'sequential', totalTime, taskCount: results.length };
+  }
+
+  async runParallelTests() {
+    console.log('\n⚡ PARALLEL EXECUTION MODE');
+    console.log('═'.repeat(60));
+    console.log('Running all agent tests concurrently...\n');
+    
+    const startTime = Date.now();
+    
+    // Create all agents
+    const agents = {
+      coordinator: new CoordinatorAgent('coordinator-par-001'),
+      researcher: new ResearcherAgent('researcher-par-001'),
+      developer: new DeveloperAgent('developer-par-001'),
+      analyzer: new AnalyzerAgent('analyzer-par-001'),
+      reviewer: new ReviewerAgent('reviewer-par-001'),
+      tester: new TesterAgent('tester-par-001'),
+      documenter: new DocumenterAgent('documenter-par-001'),
+      monitor: new MonitorAgent('monitor-par-001'),
+      specialist: new SpecialistAgent('specialist-par-001')
+    };
+    
+    // Execute all tasks in parallel
+    const tasks = [
+      agents.coordinator.orchestrateSwarmTask('Build authentication system', 3),
+      agents.researcher.conductResearch('REST API best practices'),
+      agents.developer.generateCode('user authentication'),
+      agents.analyzer.analyzePerformanceMetrics({
+        response_times: [245, 312, 198, 580, 225],
+        error_counts: { '4xx': 12, '5xx': 3 },
+        cpu_usage: [45.2, 52.1, 48.7, 61.3],
+        memory_usage: [1024, 1156, 1298, 1402]
+      }),
+      agents.reviewer.performCodeReview({
+        title: 'Feature: Add user authentication',
+        author: 'developer123',
+        files: ['src/auth/login.ts', 'src/auth/logout.ts', 'tests/auth.test.ts']
+      }),
+      agents.tester.writeUnitTests('UserAuthentication'),
+      agents.documenter.generateAPIDocumentation({
+        name: 'User Authentication API',
+        version: '1.0',
+        endpoints: ['/auth/login', '/auth/validate', '/auth/refresh', '/auth/logout']
+      }),
+      agents.monitor.monitorSystemHealth(),
+      agents.specialist.provideMachineLearningExpertise('Customer churn prediction')
+    ];
+    
+    console.log('🚀 Launching all agents simultaneously...');
+    const results = await Promise.all(tasks);
+    
+    const totalTime = Date.now() - startTime;
+    
+    console.log('\n✅ Parallel execution completed');
+    console.log(`Total time: ${totalTime}ms`);
+    console.log(`Tasks completed: ${results.length}`);
+    
+    return { mode: 'parallel', totalTime, taskCount: results.length };
+  }
+
+  async runComparison() {
+    console.log('🎯 CLAUDE-FLOW AGENT EXECUTION COMPARISON');
+    console.log('═'.repeat(60));
+    console.log('Comparing sequential vs parallel agent execution\n');
+    
+    // Run sequential tests
+    const sequentialResult = await this.runSequentialTests();
+    
+    // Add a small delay between tests
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Run parallel tests
+    const parallelResult = await this.runParallelTests();
+    
+    // Display comparison
+    console.log('\n' + '═'.repeat(60));
+    console.log('📊 PERFORMANCE COMPARISON');
+    console.log('═'.repeat(60));
+    console.log(`\nSequential Execution: ${sequentialResult.totalTime}ms`);
+    console.log(`Parallel Execution: ${parallelResult.totalTime}ms`);
+    console.log(`\nTime Saved: ${sequentialResult.totalTime - parallelResult.totalTime}ms`);
+    console.log(`Speed Improvement: ${((sequentialResult.totalTime / parallelResult.totalTime) * 100).toFixed(1)}%`);
+    console.log(`\nEfficiency Factor: ${(sequentialResult.totalTime / parallelResult.totalTime).toFixed(2)}x faster`);
+    
+    console.log('\n💡 KEY INSIGHTS:');
+    console.log('- Parallel execution dramatically reduces total execution time');
+    console.log('- All agents can work independently without conflicts');
+    console.log('- Swarm architecture enables efficient resource utilization');
+    console.log('- Suitable for complex, multi-faceted software engineering tasks');
+  }
+
+  async runIndividualAgentDemo(agentType: string) {
+    console.log(`\n🤖 Running ${agentType.toUpperCase()} Agent Demo`);
+    console.log('─'.repeat(40));
+    
+    switch (agentType.toLowerCase()) {
+      case 'coordinator':
+        const coordinator = new CoordinatorAgent();
+        await coordinator.orchestrateSwarmTask('Build authentication system', 5);
+        await coordinator.monitorProgress();
+        break;
+        
+      case 'researcher':
+        const researcher = new ResearcherAgent();
+        await researcher.conductResearch('REST API best practices');
+        await researcher.analyzeData([42, 38, 51, 47, 39, 52, 48, 45, 98, 41]);
+        break;
+        
+      case 'developer':
+        const developer = new DeveloperAgent();
+        await developer.generateCode('user authentication');
+        await developer.refactorCode('legacy payment module');
+        break;
+        
+      case 'analyzer':
+        const analyzer = new AnalyzerAgent();
+        await analyzer.analyzePerformanceMetrics({
+          response_times: [245, 312, 198, 580, 225],
+          error_counts: { '4xx': 12, '5xx': 3 },
+          cpu_usage: [45.2, 52.1, 48.7, 61.3],
+          memory_usage: [1024, 1156, 1298, 1402]
+        });
+        break;
+        
+      case 'reviewer':
+        const reviewer = new ReviewerAgent();
+        await reviewer.performCodeReview({
+          title: 'Feature: Add user authentication',
+          author: 'developer123',
+          files: ['src/auth/login.ts', 'src/auth/logout.ts', 'tests/auth.test.ts']
+        });
+        break;
+        
+      case 'tester':
+        const tester = new TesterAgent();
+        await tester.writeUnitTests('UserAuthentication');
+        await tester.runPerformanceTests('/api/v1/authenticate');
+        break;
+        
+      case 'documenter':
+        const documenter = new DocumenterAgent();
+        await documenter.generateAPIDocumentation({
+          name: 'User Authentication API',
+          version: '1.0',
+          endpoints: ['/auth/login', '/auth/validate', '/auth/refresh', '/auth/logout']
+        });
+        break;
+        
+      case 'monitor':
+        const monitor = new MonitorAgent();
+        await monitor.monitorSystemHealth();
+        await monitor.trackPerformanceMetrics();
+        break;
+        
+      case 'specialist':
+        const specialist = new SpecialistAgent();
+        await specialist.provideMachineLearningExpertise('Customer churn prediction');
+        await specialist.provideSecurityExpertise('User Authentication Module');
+        break;
+        
+      default:
+        console.log(`Unknown agent type: ${agentType}`);
+    }
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const runner = new AgentTestRunner();
+  
+  // Check command line arguments
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0 || args[0] === 'compare') {
+    // Run comparison by default
+    runner.runComparison().catch(console.error);
+  } else if (args[0] === 'sequential') {
+    runner.runSequentialTests().catch(console.error);
+  } else if (args[0] === 'parallel') {
+    runner.runParallelTests().catch(console.error);
+  } else if (args[0] === 'agent' && args[1]) {
+    runner.runIndividualAgentDemo(args[1]).catch(console.error);
+  } else {
+    console.log('Usage:');
+    console.log('  ts-node run-all-tests.ts [compare]    - Run comparison (default)');
+    console.log('  ts-node run-all-tests.ts sequential   - Run sequential tests only');
+    console.log('  ts-node run-all-tests.ts parallel     - Run parallel tests only');
+    console.log('  ts-node run-all-tests.ts agent <type> - Run specific agent demo');
+    console.log('\nAgent types: coordinator, researcher, developer, analyzer,');
+    console.log('             reviewer, tester, documenter, monitor, specialist');
+  }
+}

package/examples/parallel-2/specialist-agent-test.ts

@@ -0,0 +1,268 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Specialist Agent Test - Designed for parallel execution
+ * This agent provides domain-specific expertise
+ */
+
+export class SpecialistAgent {
+  private agentId: string;
+  private startTime: number;
+  private specialty: string;
+
+  constructor(id: string = 'specialist-001', specialty: string = 'general') {
+    this.agentId = id;
+    this.startTime = Date.now();
+    this.specialty = specialty;
+  }
+
+  async provideMachineLearningExpertise(problem: string): Promise<any> {
+    console.log(`[${this.agentId}] Analyzing ML problem: ${problem}`);
+    
+    await this.simulateWork(1500);
+    
+    const mlAnalysis = {
+      problemType: 'Binary Classification',
+      recommendedApproach: {
+        algorithm: 'Gradient Boosting (XGBoost)',
+        alternativeAlgorithms: ['Random Forest', 'Neural Network', 'SVM'],
+        reasoning: 'Handles mixed data types well, good for tabular data'
+      },
+      dataRequirements: {
+        minimumSamples: 10000,
+        recommendedSamples: 50000,
+        features: [
+          'Customer demographics',
+          'Purchase history',
+          'Engagement metrics',
+          'Support interactions'
+        ],
+        preprocessing: [
+          'Handle missing values',
+          'Encode categorical variables',
+          'Normalize numerical features',
+          'Feature engineering for recency/frequency'
+        ]
+      },
+      expectedPerformance: {
+        accuracy: '85-90%',
+        precision: '82-87%',
+        recall: '80-85%',
+        f1Score: '81-86%'
+      },
+      implementation: {
+        estimatedTime: '2-3 weeks',
+        requiredTools: ['Python', 'scikit-learn', 'XGBoost', 'pandas'],
+        deployment: 'REST API with model versioning'
+      }
+    };
+    
+    console.log(`[${this.agentId}] ML analysis completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      specialty: 'Machine Learning',
+      problem,
+      analysis: mlAnalysis
+    };
+  }
+
+  async provideSecurityExpertise(component: string): Promise<any> {
+    console.log(`[${this.agentId}] Security analysis for: ${component}`);
+    
+    await this.simulateWork(1200);
+    
+    const securityAnalysis = {
+      threatModel: {
+        assets: ['User credentials', 'Session tokens', 'Personal data'],
+        threats: [
+          'Brute force attacks',
+          'Session hijacking',
+          'Token replay attacks',
+          'SQL injection',
+          'XSS attacks'
+        ],
+        riskLevel: 'Medium-High'
+      },
+      recommendations: {
+        authentication: [
+          'Implement PKCE for OAuth flows',
+          'Use argon2 for password hashing',
+          'Enforce MFA for sensitive operations',
+          'Implement account lockout policies'
+        ],
+        sessionManagement: [
+          'Use secure, httpOnly, sameSite cookies',
+          'Implement JWT rotation',
+          'Set appropriate token expiration',
+          'Store refresh tokens securely'
+        ],
+        dataProtection: [
+          'Encrypt sensitive data at rest',
+          'Use TLS 1.3 for transport',
+          'Implement field-level encryption',
+          'Regular security key rotation'
+        ]
+      },
+      complianceConsiderations: {
+        GDPR: ['Right to deletion', 'Data portability', 'Consent management'],
+        PCI_DSS: ['Not applicable unless handling payment data'],
+        SOC2: ['Access controls', 'Audit logging', 'Encryption']
+      },
+      securityScore: 7.5
+    };
+    
+    console.log(`[${this.agentId}] Security analysis completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      specialty: 'Security',
+      component,
+      analysis: securityAnalysis
+    };
+  }
+
+  async provideCloudArchitectureExpertise(requirements: any): Promise<any> {
+    console.log(`[${this.agentId}] Designing cloud architecture for: ${requirements.application}`);
+    
+    await this.simulateWork(2000);
+    
+    const cloudArchitecture = {
+      provider: 'AWS',
+      architecture: 'Microservices with Serverless components',
+      services: {
+        compute: ['ECS Fargate', 'Lambda', 'API Gateway'],
+        storage: ['S3', 'DynamoDB', 'ElastiCache'],
+        networking: ['VPC', 'CloudFront', 'Route53'],
+        security: ['WAF', 'Secrets Manager', 'IAM'],
+        monitoring: ['CloudWatch', 'X-Ray', 'CloudTrail']
+      },
+      scalingStrategy: {
+        type: 'Auto-scaling',
+        minInstances: 2,
+        maxInstances: 100,
+        targetCPU: 70,
+        targetMemory: 80
+      },
+      disasterRecovery: {
+        rto: '4 hours',
+        rpo: '1 hour',
+        backupStrategy: 'Cross-region replication',
+        failoverStrategy: 'Active-passive with Route53'
+      },
+      costEstimate: {
+        monthly: '$2,850',
+        breakdown: {
+          compute: '$1,200',
+          storage: '$450',
+          networking: '$600',
+          other: '$600'
+        },
+        optimization: [
+          'Use Spot instances for non-critical workloads',
+          'Implement S3 lifecycle policies',
+          'Reserved instances for baseline capacity'
+        ]
+      },
+      implementationPlan: {
+        phase1: 'Core infrastructure (2 weeks)',
+        phase2: 'Service deployment (3 weeks)',
+        phase3: 'Security hardening (1 week)',
+        phase4: 'Performance optimization (1 week)'
+      }
+    };
+    
+    console.log(`[${this.agentId}] Cloud architecture design completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      specialty: 'Cloud Architecture',
+      requirements: requirements.application,
+      architecture: cloudArchitecture,
+      monthlyCost: cloudArchitecture.costEstimate.monthly
+    };
+  }
+
+  async providePerformanceOptimization(system: string): Promise<any> {
+    console.log(`[${this.agentId}] Optimizing performance for: ${system}`);
+    
+    await this.simulateWork(1800);
+    
+    const optimization = {
+      currentPerformance: {
+        responseTime: '450ms avg',
+        throughput: '1,200 req/s',
+        errorRate: '1.2%',
+        cpuUsage: '75%',
+        memoryUsage: '82%'
+      },
+      bottlenecks: [
+        { area: 'Database queries', impact: 'High', solution: 'Query optimization and indexing' },
+        { area: 'API serialization', impact: 'Medium', solution: 'Implement response caching' },
+        { area: 'Memory allocation', impact: 'Medium', solution: 'Object pooling and GC tuning' }
+      ],
+      optimizationPlan: {
+        immediate: [
+          'Add database indexes on frequently queried columns',
+          'Implement Redis caching for hot data',
+          'Enable HTTP response compression'
+        ],
+        shortTerm: [
+          'Refactor N+1 queries',
+          'Implement database connection pooling',
+          'Add CDN for static assets'
+        ],
+        longTerm: [
+          'Migrate to read replicas',
+          'Implement CQRS pattern',
+          'Consider microservices decomposition'
+        ]
+      },
+      expectedImprovements: {
+        responseTime: '150ms avg (-67%)',
+        throughput: '3,500 req/s (+192%)',
+        errorRate: '0.3% (-75%)',
+        cpuUsage: '45% (-40%)',
+        memoryUsage: '60% (-27%)'
+      },
+      roi: {
+        implementationCost: '$15,000',
+        monthlySavings: '$3,500',
+        paybackPeriod: '4.3 months'
+      }
+    };
+    
+    console.log(`[${this.agentId}] Performance optimization completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      specialty: 'Performance Engineering',
+      system,
+      optimization
+    };
+  }
+
+  private async simulateWork(ms: number): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// Allow direct execution
+if (require.main === module) {
+  const specialist = new SpecialistAgent();
+  const cloudRequirements = {
+    application: 'E-commerce Platform',
+    expectedUsers: 500000,
+    regions: ['US', 'EU', 'Asia'],
+    budget: '$3000/month'
+  };
+  
+  Promise.all([
+    specialist.provideMachineLearningExpertise('Customer churn prediction'),
+    specialist.provideSecurityExpertise('User Authentication Module'),
+    specialist.provideCloudArchitectureExpertise(cloudRequirements),
+    specialist.providePerformanceOptimization('Order Processing System')
+  ]).then(results => {
+    console.log('\nSpecialist Agent Results:', JSON.stringify(results, null, 2));
+  });
+}

package/examples/parallel-2/test-agents/architect-test.ts

@@ -0,0 +1,27 @@
+// Test case for architect agent
+export const architectTestCase = {
+  name: "Microservices Architecture Design",
+  description: "Test the architect agent's ability to design scalable systems",
+  task: "Design a microservices architecture for an e-commerce platform with the following services: user management, product catalog, shopping cart, order processing, payment integration, and notification service. Include API gateway, service discovery, load balancing, and data consistency strategies",
+  expectedOutputs: [
+    "Service boundaries and responsibilities",
+    "Inter-service communication patterns",
+    "Data management strategy",
+    "Security architecture",
+    "Scalability considerations",
+    "Technology stack recommendations"
+  ],
+  validateOutput: (output: string): boolean => {
+    const requiredConcepts = [
+      "service",
+      "api",
+      "database",
+      "communication",
+      "security"
+    ];
+    
+    return requiredConcepts.every(concept => 
+      output.toLowerCase().includes(concept)
+    );
+  }
+};

package/examples/parallel-2/test-agents/code-test.ts

@@ -0,0 +1,29 @@
+// Test case for code agent
+export const codeTestCase = {
+  name: "Algorithm Implementation",
+  description: "Test the code agent's ability to implement complex algorithms",
+  task: "Implement a comprehensive binary search tree (BST) class in TypeScript with the following methods: insert, delete, search, findMin, findMax, inOrderTraversal, preOrderTraversal, postOrderTraversal, getHeight, isBalanced, and rotateLeft/rotateRight for balancing",
+  expectedOutputs: [
+    "TypeScript class definition",
+    "All requested methods implemented",
+    "Proper type annotations",
+    "Edge case handling",
+    "Time complexity comments"
+  ],
+  validateOutput: (output: string): boolean => {
+    const requiredMethods = [
+      "insert",
+      "delete",
+      "search",
+      "findMin",
+      "findMax",
+      "traversal"
+    ];
+    
+    const hasClass = output.includes("class") && output.includes("BST");
+    const hasTypes = output.includes("<T>") || output.includes(": number") || output.includes(": boolean");
+    const hasMethods = requiredMethods.every(method => output.includes(method));
+    
+    return hasClass && hasTypes && hasMethods;
+  }
+};

package/examples/parallel-2/test-agents/debug-test.ts

@@ -0,0 +1,32 @@
+// Test case for debug agent
+export const debugTestCase = {
+  name: "Memory Leak Analysis",
+  description: "Test the debug agent's ability to identify and fix issues",
+  task: "Analyze the following Node.js code snippet for memory leaks and performance issues: A web server that maintains a global array of all incoming requests without cleanup, creates new event listeners on each request without removing old ones, and has circular references in cached objects. Identify the issues, explain why they cause memory leaks, and provide fixed code",
+  expectedOutputs: [
+    "Issue identification",
+    "Root cause analysis",
+    "Memory leak explanation",
+    "Performance impact assessment",
+    "Fixed code implementation",
+    "Prevention recommendations"
+  ],
+  validateOutput: (output: string): boolean => {
+    const debugConcepts = [
+      "memory",
+      "leak",
+      "garbage collection",
+      "reference",
+      "event listener"
+    ];
+    
+    const hasDiagnostics = debugConcepts.some(concept => 
+      output.toLowerCase().includes(concept)
+    );
+    
+    const hasSolution = output.includes("fix") || output.includes("solution") || output.includes("resolved");
+    const hasCode = output.includes("```") || output.includes("function") || output.includes("const");
+    
+    return hasDiagnostics && hasSolution && hasCode;
+  }
+};

package/examples/parallel-2/test-agents/spec-test.ts

@@ -0,0 +1,26 @@
+// Test case for spec-pseudocode agent
+export const specTestCase = {
+  name: "Calculator API Specification",
+  description: "Test the specification agent's ability to create detailed API specs",
+  task: "Create a comprehensive specification for a calculator REST API with the following requirements: basic arithmetic operations (add, subtract, multiply, divide), error handling for division by zero, input validation, response format standardization, and rate limiting considerations",
+  expectedOutputs: [
+    "API endpoints definition",
+    "Request/response schemas", 
+    "Error codes and messages",
+    "Input validation rules",
+    "Non-functional requirements"
+  ],
+  validateOutput: (output: string): boolean => {
+    const requiredElements = [
+      "endpoint",
+      "request",
+      "response",
+      "error",
+      "validation"
+    ];
+    
+    return requiredElements.every(element => 
+      output.toLowerCase().includes(element)
+    );
+  }
+};