claude-flow-novice 1.2.1 → 1.3.0

package/examples/news-scraper/README.md

@@ -0,0 +1,26 @@
+# Application
+
+Created by Claude Flow Swarm
+
+## Overview
+Test and validate the solution
+
+## Installation
+```bash
+npm install
+```
+
+## Usage
+```bash
+npm start
+```
+
+## Development
+```bash
+npm run dev
+```
+
+## Task Details
+- Task ID: task_mbwwu7fo_is3ltnhme-testing
+- Task Type: testing
+- Created: 2025-06-15T00:11:36.479Z

package/examples/news-scraper/app.js

@@ -0,0 +1,14 @@
+// Application created by Claude Flow Swarm
+// Task: Intelligent Testing
+// Description: Test and validate the solution
+
+function main() {
+  console.log('Executing: Test and validate the solution');
+  // Implementation goes here
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

package/examples/parallel-2/README.md

@@ -0,0 +1,174 @@
+# Claude-Flow Parallel Agent Testing
+
+This example demonstrates how to run multiple Claude-Flow SPARC agents in parallel to test their capabilities and measure performance.
+
+## Overview
+
+The parallel test coordinator runs 8 different agent types simultaneously:
+- **Specification Agent**: Creates detailed API specifications
+- **Architecture Agent**: Designs system architectures
+- **Code Agent**: Implements algorithms and data structures
+- **TDD Agent**: Follows Test-Driven Development practices
+- **Debug Agent**: Analyzes and fixes code issues
+- **Documentation Agent**: Creates comprehensive documentation
+- **Security Review Agent**: Analyzes security vulnerabilities
+- **Integration Agent**: Plans system integration strategies
+
+## Installation
+
+```bash
+# Navigate to the parallel-2 directory
+cd examples/parallel-2
+
+# Install dependencies
+npm install
+```
+
+## Usage
+
+### Run the Parallel Test
+```bash
+npm run test
+```
+
+This will:
+1. Launch all agents in parallel
+2. Execute their respective tasks
+3. Save results to `results.json`
+
+### Analyze Results
+```bash
+npm run analyze
+```
+
+This will:
+1. Read the test results
+2. Generate performance statistics
+3. Create a detailed report in `detailed-report.md`
+
+### Full Test Cycle
+```bash
+npm run test:full
+```
+
+This runs the complete test cycle: clean, test, and analyze.
+
+## Test Configuration
+
+Each agent is given a specific task designed to test its capabilities:
+
+| Agent | Task Description |
+|-------|-----------------|
+| Specification | Create calculator API specification |
+| Architecture | Design microservices for e-commerce |
+| Code | Implement binary search tree |
+| TDD | Create string utility library with tests |
+| Debug | Analyze and fix memory leaks |
+| Documentation | Create API documentation |
+| Security | Review authentication implementation |
+| Integration | Plan microservice integration |
+
+## Understanding Results
+
+### results.json
+Contains raw test execution data:
+- Agent execution times
+- Success/failure status
+- Output or error messages
+- Overall statistics
+
+### detailed-report.md
+Provides comprehensive analysis:
+- Executive summary
+- Performance metrics
+- Execution timeline
+- Efficiency calculations
+- Recommendations
+
+## Performance Metrics
+
+The test suite measures:
+- **Individual agent duration**: Time taken by each agent
+- **Parallel efficiency**: Comparison with sequential execution
+- **Success rate**: Percentage of successful agent executions
+- **Resource utilization**: Overall system performance
+
+## Extending the Tests
+
+To add new test cases:
+
+1. Create a new test file in `test-agents/`:
+```typescript
+export const newTestCase = {
+  name: "Test Name",
+  description: "Test description",
+  task: "Detailed task for the agent",
+  expectedOutputs: ["Expected output 1", "Expected output 2"],
+  validateOutput: (output: string): boolean => {
+    // Validation logic
+    return true;
+  }
+};
+```
+
+2. Add the test to `parallel-test.ts`:
+```typescript
+{
+  name: "New Agent",
+  mode: "agent-mode",
+  task: "Your task description",
+  priority: 1
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Agent timeout**: Increase timeout in `coordinator.ts` (default: 5 minutes)
+2. **Missing results**: Ensure all agents complete before analyzing
+3. **Permission errors**: Check write permissions for output files
+
+### Debug Mode
+
+To see detailed agent output, modify `coordinator.ts`:
+```typescript
+console.log(`Agent ${task.name} output:`, stdout);
+```
+
+## Architecture
+
+```
+parallel-2/
+├── coordinator.ts       # Main coordination logic
+├── parallel-test.ts     # Test configuration and runner
+├── analyze-results.ts   # Results analysis tool
+├── test-agents/        # Individual agent test cases
+│   ├── spec-test.ts
+│   ├── architect-test.ts
+│   ├── code-test.ts
+│   ├── tdd-test.ts
+│   └── debug-test.ts
+├── results.json        # Test execution results
+└── detailed-report.md  # Analysis report
+```
+
+## Best Practices
+
+1. **Resource Management**: Monitor system resources during parallel execution
+2. **Task Complexity**: Balance task complexity across agents
+3. **Error Handling**: Implement proper error recovery
+4. **Logging**: Enable detailed logging for debugging
+5. **Scaling**: Consider batching for large numbers of agents
+
+## Contributing
+
+To contribute new test cases or improvements:
+1. Follow the existing test structure
+2. Ensure tests are meaningful and measurable
+3. Update documentation accordingly
+4. Test thoroughly before submitting
+
+## License
+
+This example is part of the Claude-Flow project and follows the same license terms.

package/examples/parallel-2/analyze-results.ts

@@ -0,0 +1,160 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+interface AgentResult {
+  agent: string;
+  success: boolean;
+  output?: string;
+  error?: string;
+  duration: number;
+}
+
+interface ResultsSummary {
+  totalAgents: number;
+  successfulAgents: number;
+  failedAgents: number;
+  totalDuration: number;
+  averageDuration: number;
+}
+
+interface FullResults {
+  summary: ResultsSummary;
+  results: AgentResult[];
+  timestamp: string;
+}
+
+async function analyzeResults() {
+  try {
+    const resultsPath = path.join(__dirname, "results.json");
+    const resultsData = await fs.readFile(resultsPath, "utf-8");
+    const results: FullResults = JSON.parse(resultsData);
+
+    console.log("📊 Claude-Flow Parallel Agent Test Results Analysis");
+    console.log("=" .repeat(50));
+    console.log(`\nTest completed at: ${new Date(results.timestamp).toLocaleString()}`);
+    
+    // Summary statistics
+    console.log("\n📈 Summary Statistics:");
+    console.log(`   Total Agents: ${results.summary.totalAgents}`);
+    console.log(`   Successful: ${results.summary.successfulAgents} (${Math.round(results.summary.successfulAgents / results.summary.totalAgents * 100)}%)`);
+    console.log(`   Failed: ${results.summary.failedAgents} (${Math.round(results.summary.failedAgents / results.summary.totalAgents * 100)}%)`);
+    console.log(`   Total Duration: ${(results.summary.totalDuration / 1000).toFixed(2)}s`);
+    console.log(`   Average Duration: ${(results.summary.averageDuration / 1000).toFixed(2)}s per agent`);
+
+    // Performance analysis
+    const sortedByDuration = [...results.results].sort((a, b) => b.duration - a.duration);
+    
+    console.log("\n⏱️  Performance Breakdown:");
+    console.log("   Slowest agents:");
+    sortedByDuration.slice(0, 3).forEach((result, index) => {
+      console.log(`   ${index + 1}. ${result.agent}: ${(result.duration / 1000).toFixed(2)}s`);
+    });
+    
+    console.log("\n   Fastest agents:");
+    sortedByDuration.slice(-3).reverse().forEach((result, index) => {
+      console.log(`   ${index + 1}. ${result.agent}: ${(result.duration / 1000).toFixed(2)}s`);
+    });
+
+    // Failure analysis
+    const failures = results.results.filter(r => !r.success);
+    if (failures.length > 0) {
+      console.log("\n❌ Failed Agents:");
+      failures.forEach(failure => {
+        console.log(`   - ${failure.agent}: ${failure.error?.split('\n')[0] || 'Unknown error'}`);
+      });
+    }
+
+    // Success analysis
+    const successes = results.results.filter(r => r.success);
+    if (successes.length > 0) {
+      console.log("\n✅ Successful Agents:");
+      successes.forEach(success => {
+        const outputLines = success.output?.split('\n').length || 0;
+        console.log(`   - ${success.agent}: Generated ${outputLines} lines of output`);
+      });
+    }
+
+    // Parallel efficiency
+    const sequentialTime = results.results.reduce((sum, r) => sum + r.duration, 0);
+    const parallelEfficiency = (sequentialTime / results.summary.totalDuration * 100).toFixed(1);
+    
+    console.log("\n🚀 Parallel Execution Efficiency:");
+    console.log(`   Sequential time (if run one by one): ${(sequentialTime / 1000).toFixed(2)}s`);
+    console.log(`   Actual parallel time: ${(results.summary.totalDuration / 1000).toFixed(2)}s`);
+    console.log(`   Efficiency gain: ${parallelEfficiency}%`);
+    console.log(`   Time saved: ${((sequentialTime - results.summary.totalDuration) / 1000).toFixed(2)}s`);
+
+    // Generate detailed report
+    await generateDetailedReport(results);
+
+  } catch (error) {
+    console.error("Error analyzing results:", error);
+    console.log("\nMake sure to run the parallel test first: npm run test:parallel");
+  }
+}
+
+async function generateDetailedReport(results: FullResults) {
+  const report = `# Claude-Flow Parallel Agent Test Report
+
+Generated: ${new Date(results.timestamp).toLocaleString()}
+
+## Executive Summary
+
+- **Total Agents Tested**: ${results.summary.totalAgents}
+- **Success Rate**: ${Math.round(results.summary.successfulAgents / results.summary.totalAgents * 100)}%
+- **Total Execution Time**: ${(results.summary.totalDuration / 1000).toFixed(2)} seconds
+- **Average Agent Duration**: ${(results.summary.averageDuration / 1000).toFixed(2)} seconds
+
+## Detailed Results
+
+| Agent | Status | Duration | Notes |
+|-------|--------|----------|-------|
+${results.results.map(r => 
+  `| ${r.agent} | ${r.success ? '✅ Success' : '❌ Failed'} | ${(r.duration / 1000).toFixed(2)}s | ${r.error ? r.error.split('\n')[0] : 'Completed successfully'} |`
+).join('\n')}
+
+## Performance Analysis
+
+### Execution Timeline
+\`\`\`
+${generateTimeline(results.results, results.summary.totalDuration)}
+\`\`\`
+
+### Efficiency Metrics
+- Sequential execution time: ${(results.results.reduce((sum, r) => sum + r.duration, 0) / 1000).toFixed(2)}s
+- Parallel execution time: ${(results.summary.totalDuration / 1000).toFixed(2)}s
+- Efficiency gain: ${((results.results.reduce((sum, r) => sum + r.duration, 0) / results.summary.totalDuration - 1) * 100).toFixed(1)}%
+
+## Recommendations
+
+1. **Performance Optimization**: Focus on optimizing the slowest agents to improve overall execution time
+2. **Error Handling**: Investigate and fix failures in any failed agents
+3. **Resource Usage**: Monitor system resources during parallel execution to ensure optimal performance
+4. **Scaling**: Consider batching agents based on their resource requirements
+
+---
+*Report generated by Claude-Flow Parallel Test Suite*
+`;
+
+  await fs.writeFile(path.join(__dirname, "detailed-report.md"), report);
+  console.log("\n📄 Detailed report saved to detailed-report.md");
+}
+
+function generateTimeline(results: AgentResult[], totalDuration: number): string {
+  const width = 60;
+  const timeline: string[] = [];
+  
+  results.forEach(result => {
+    const startRatio = 0; // Assuming all start at the same time
+    const durationRatio = result.duration / totalDuration;
+    const barLength = Math.max(1, Math.floor(durationRatio * width));
+    const bar = "█".repeat(barLength);
+    
+    timeline.push(`${result.agent.padEnd(25)} |${bar}`);
+  });
+  
+  return timeline.join('\n');
+}
+
+// Run the analysis
+analyzeResults();

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

@@ -0,0 +1,121 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Analyzer Agent Test - Designed for parallel execution
+ * This agent analyzes data and generates insights independently
+ */
+
+export class AnalyzerAgent {
+  private agentId: string;
+  private startTime: number;
+
+  constructor(id: string = 'analyzer-001') {
+    this.agentId = id;
+    this.startTime = Date.now();
+  }
+
+  async analyzePerformanceMetrics(metrics: any): Promise<any> {
+    console.log(`[${this.agentId}] Starting performance analysis...`);
+    
+    // Simulate analysis work
+    await this.simulateWork(800);
+    
+    const analysis = {
+      avgResponseTime: this.calculateAverage(metrics.response_times || []),
+      errorRate: this.calculateErrorRate(metrics.error_counts || {}),
+      cpuUsage: this.calculateAverage(metrics.cpu_usage || []),
+      memoryUsage: this.calculateAverage(metrics.memory_usage || []),
+      recommendations: [
+        'Optimize database queries',
+        'Implement caching strategy',
+        'Scale horizontally during peak hours'
+      ]
+    };
+    
+    console.log(`[${this.agentId}] Performance analysis completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      analysis
+    };
+  }
+
+  async analyzeCodeQuality(path: string): Promise<any> {
+    console.log(`[${this.agentId}] Analyzing code quality for: ${path}`);
+    
+    await this.simulateWork(600);
+    
+    const qualityMetrics = {
+      complexity: Math.floor(Math.random() * 10) + 5,
+      maintainability: Math.floor(Math.random() * 30) + 70,
+      testCoverage: Math.floor(Math.random() * 40) + 60,
+      duplications: Math.floor(Math.random() * 5),
+      issues: {
+        critical: Math.floor(Math.random() * 3),
+        major: Math.floor(Math.random() * 10),
+        minor: Math.floor(Math.random() * 20)
+      }
+    };
+    
+    console.log(`[${this.agentId}] Code quality analysis completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      path,
+      metrics: qualityMetrics
+    };
+  }
+
+  async analyzeSecurityVulnerabilities(): Promise<any> {
+    console.log(`[${this.agentId}] Scanning for security vulnerabilities...`);
+    
+    await this.simulateWork(1000);
+    
+    const vulnerabilities = [
+      { severity: 'high', type: 'SQL Injection', location: 'UserController.ts:45' },
+      { severity: 'medium', type: 'Weak Password Policy', location: 'auth/config.ts:12' },
+      { severity: 'low', type: 'Missing HTTPS redirect', location: 'server.ts:8' }
+    ];
+    
+    console.log(`[${this.agentId}] Security analysis completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      vulnerabilities,
+      riskScore: 6.5
+    };
+  }
+
+  private calculateAverage(numbers: number[]): number {
+    if (numbers.length === 0) return 0;
+    return numbers.reduce((a, b) => a + b, 0) / numbers.length;
+  }
+
+  private calculateErrorRate(errorCounts: Record<string, number>): number {
+    const total = Object.values(errorCounts).reduce((a, b) => a + b, 0);
+    return total > 0 ? (errorCounts['5xx'] || 0) / total : 0;
+  }
+
+  private async simulateWork(ms: number): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// Allow direct execution
+if (require.main === module) {
+  const analyzer = new AnalyzerAgent();
+  const testMetrics = {
+    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]
+  };
+  
+  Promise.all([
+    analyzer.analyzePerformanceMetrics(testMetrics),
+    analyzer.analyzeCodeQuality('/src/modules/authentication'),
+    analyzer.analyzeSecurityVulnerabilities()
+  ]).then(results => {
+    console.log('\nAnalyzer Agent Results:', JSON.stringify(results, null, 2));
+  });
+}

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

@@ -0,0 +1,124 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Coordinator Agent Test - Designed for parallel execution
+ * This agent orchestrates and manages other agents
+ */
+
+export class CoordinatorAgent {
+  private agentId: string;
+  private startTime: number;
+  private managedAgents: Set<string>;
+
+  constructor(id: string = 'coordinator-001') {
+    this.agentId = id;
+    this.startTime = Date.now();
+    this.managedAgents = new Set();
+  }
+
+  async orchestrateSwarmTask(taskDescription: string, agentCount: number = 3): Promise<any> {
+    console.log(`[${this.agentId}] Orchestrating swarm task: ${taskDescription}`);
+    console.log(`[${this.agentId}] Deploying ${agentCount} agents...`);
+    
+    // Simulate agent deployment
+    await this.simulateWork(500);
+    
+    const agents = [];
+    for (let i = 0; i < agentCount; i++) {
+      const agentId = `agent-${Date.now()}-${i}`;
+      this.managedAgents.add(agentId);
+      agents.push({
+        id: agentId,
+        type: this.selectAgentType(i),
+        status: 'active',
+        task: this.assignTask(taskDescription, i)
+      });
+    }
+    
+    console.log(`[${this.agentId}] Swarm deployed successfully`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      swarmSize: agents.length,
+      agents
+    };
+  }
+
+  async monitorProgress(): Promise<any> {
+    console.log(`[${this.agentId}] Monitoring swarm progress...`);
+    
+    await this.simulateWork(1000);
+    
+    const progress = {
+      totalAgents: this.managedAgents.size,
+      activeAgents: Math.floor(this.managedAgents.size * 0.8),
+      completedTasks: Math.floor(Math.random() * 10) + 5,
+      pendingTasks: Math.floor(Math.random() * 5),
+      avgCompletionTime: Math.floor(Math.random() * 1000) + 500,
+      healthStatus: 'optimal'
+    };
+    
+    console.log(`[${this.agentId}] Progress update generated`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      progress
+    };
+  }
+
+  async rebalanceWorkload(): Promise<any> {
+    console.log(`[${this.agentId}] Rebalancing workload across agents...`);
+    
+    await this.simulateWork(700);
+    
+    const rebalancing = {
+      agentsRebalanced: Math.floor(this.managedAgents.size / 2),
+      tasksRedistributed: Math.floor(Math.random() * 10) + 3,
+      efficiencyGain: `${Math.floor(Math.random() * 20) + 10}%`,
+      newDistribution: Array.from(this.managedAgents).map(id => ({
+        agentId: id,
+        workload: Math.floor(Math.random() * 100)
+      }))
+    };
+    
+    console.log(`[${this.agentId}] Workload rebalancing completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      rebalancing
+    };
+  }
+
+  private selectAgentType(index: number): string {
+    const types = ['researcher', 'developer', 'analyzer', 'reviewer', 'tester'];
+    return types[index % types.length];
+  }
+
+  private assignTask(description: string, index: number): string {
+    const tasks = [
+      `Research ${description}`,
+      `Implement ${description}`,
+      `Analyze ${description}`,
+      `Review ${description}`,
+      `Test ${description}`
+    ];
+    return tasks[index % tasks.length];
+  }
+
+  private async simulateWork(ms: number): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// Allow direct execution
+if (require.main === module) {
+  const coordinator = new CoordinatorAgent();
+  
+  Promise.all([
+    coordinator.orchestrateSwarmTask('Build authentication system', 5),
+    coordinator.monitorProgress(),
+    coordinator.rebalanceWorkload()
+  ]).then(results => {
+    console.log('\nCoordinator Agent Results:', JSON.stringify(results, null, 2));
+  });
+}