claude-flow-novice 1.2.1 → 1.3.1

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

@@ -0,0 +1,29 @@
+// Test case for TDD agent
+export const tddTestCase = {
+  name: "String Utility Library TDD",
+  description: "Test the TDD agent's ability to follow red-green-refactor cycle",
+  task: "Using Test-Driven Development, create a string utility library with the following functions: capitalizeWords (capitalize first letter of each word), truncateWithEllipsis (truncate string to length with ...), countVowels, isPalindrome, reverseWords (reverse word order), and camelToSnakeCase. Write comprehensive tests first, then implement each function",
+  expectedOutputs: [
+    "Test suite with multiple test cases",
+    "Implementation of all functions",
+    "Red-Green-Refactor cycle evidence",
+    "Edge case testing",
+    "Test coverage information"
+  ],
+  validateOutput: (output: string): boolean => {
+    const hasTests = output.includes("describe") || output.includes("test") || output.includes("it(");
+    const hasImplementation = output.includes("function") || output.includes("const") || output.includes("=>");
+    const hasTDDMarkers = output.includes("// Red") || output.includes("// Green") || output.includes("fail") || output.includes("pass");
+    
+    const functionNames = [
+      "capitalizeWords",
+      "truncateWithEllipsis",
+      "countVowels",
+      "isPalindrome"
+    ];
+    
+    const hasFunctions = functionNames.some(fn => output.includes(fn));
+    
+    return hasTests && hasImplementation && (hasTDDMarkers || hasFunctions);
+  }
+};

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

@@ -0,0 +1,191 @@
+#!/usr/bin/env ts-node
+
+/**
+ * Tester Agent Test - Designed for parallel execution
+ * This agent tests and validates functionality
+ */
+
+export class TesterAgent {
+  private agentId: string;
+  private startTime: number;
+
+  constructor(id: string = 'tester-001') {
+    this.agentId = id;
+    this.startTime = Date.now();
+  }
+
+  async writeUnitTests(component: string): Promise<any> {
+    console.log(`[${this.agentId}] Writing unit tests for: ${component}`);
+    
+    await this.simulateWork(1000);
+    
+    const unitTests = {
+      framework: 'Jest',
+      testCases: Math.floor(Math.random() * 20) + 15,
+      coverage: Math.floor(Math.random() * 15) + 85,
+      testSuites: [
+        `${component}.controller.test.ts`,
+        `${component}.service.test.ts`,
+        `${component}.validator.test.ts`,
+        `${component}.utils.test.ts`
+      ],
+      mockingStrategy: 'Full mocking of external dependencies',
+      assertions: Math.floor(Math.random() * 50) + 50,
+      edgeCasesCovered: [
+        'Null inputs',
+        'Empty arrays',
+        'Invalid data types',
+        'Boundary values',
+        'Concurrent access'
+      ]
+    };
+    
+    console.log(`[${this.agentId}] Unit tests created`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      component,
+      unitTests
+    };
+  }
+
+  async runIntegrationTests(system: string): Promise<any> {
+    console.log(`[${this.agentId}] Running integration tests for: ${system}`);
+    
+    await this.simulateWork(2000);
+    
+    const totalTests = Math.floor(Math.random() * 30) + 20;
+    const passedTests = Math.floor(totalTests * 0.9);
+    
+    const integrationResults = {
+      totalTests,
+      passed: passedTests,
+      failed: totalTests - passedTests,
+      duration: '3m 45s',
+      testScenarios: [
+        { name: 'User login flow', status: 'passed', time: '245ms' },
+        { name: 'Token refresh', status: 'passed', time: '189ms' },
+        { name: 'Concurrent authentication', status: 'passed', time: '567ms' },
+        { name: 'Database failover', status: 'failed', time: '3021ms' },
+        { name: 'API rate limiting', status: 'passed', time: '432ms' }
+      ],
+      coverage: {
+        endpoints: '92%',
+        scenarios: '87%',
+        errorCases: '78%'
+      },
+      recommendations: [
+        'Fix database failover handling',
+        'Add more edge case scenarios',
+        'Improve error message validation'
+      ]
+    };
+    
+    console.log(`[${this.agentId}] Integration tests completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      system,
+      results: integrationResults
+    };
+  }
+
+  async runPerformanceTests(endpoint: string): Promise<any> {
+    console.log(`[${this.agentId}] Running performance tests for: ${endpoint}`);
+    
+    await this.simulateWork(3000);
+    
+    const performanceResults = {
+      endpoint,
+      virtualUsers: 1000,
+      duration: '5 minutes',
+      metrics: {
+        avgResponseTime: '145ms',
+        p50ResponseTime: '120ms',
+        p95ResponseTime: '280ms',
+        p99ResponseTime: '450ms',
+        maxResponseTime: '1230ms',
+        requestsPerSecond: 850,
+        errorRate: '0.2%',
+        throughput: '12.5 MB/s'
+      },
+      bottlenecks: [
+        'Database connection pooling',
+        'JSON serialization overhead'
+      ],
+      recommendations: [
+        'Increase connection pool size',
+        'Implement response caching',
+        'Optimize database queries'
+      ],
+      passedSLA: true
+    };
+    
+    console.log(`[${this.agentId}] Performance tests completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      endpoint,
+      results: performanceResults
+    };
+  }
+
+  async runSecurityTests(component: string): Promise<any> {
+    console.log(`[${this.agentId}] Running security tests for: ${component}`);
+    
+    await this.simulateWork(2500);
+    
+    const securityResults = {
+      vulnerabilitiesFound: 3,
+      criticalIssues: 0,
+      highIssues: 1,
+      mediumIssues: 2,
+      lowIssues: 0,
+      testsConducted: [
+        'SQL Injection',
+        'XSS Attacks',
+        'CSRF Protection',
+        'Authentication Bypass',
+        'Authorization Flaws',
+        'Session Management',
+        'Input Validation'
+      ],
+      findings: [
+        { type: 'High', issue: 'Weak password policy', recommendation: 'Enforce minimum 12 characters' },
+        { type: 'Medium', issue: 'Missing rate limiting', recommendation: 'Implement API rate limiting' },
+        { type: 'Medium', issue: 'Verbose error messages', recommendation: 'Sanitize error responses' }
+      ],
+      complianceStatus: {
+        OWASP: '85%',
+        PCI_DSS: 'N/A',
+        GDPR: '90%'
+      }
+    };
+    
+    console.log(`[${this.agentId}] Security tests completed`);
+    return {
+      agentId: this.agentId,
+      duration: Date.now() - this.startTime,
+      component,
+      results: securityResults
+    };
+  }
+
+  private async simulateWork(ms: number): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// Allow direct execution
+if (require.main === module) {
+  const tester = new TesterAgent();
+  
+  Promise.all([
+    tester.writeUnitTests('UserAuthentication'),
+    tester.runIntegrationTests('Authentication System'),
+    tester.runPerformanceTests('/api/v1/authenticate'),
+    tester.runSecurityTests('AuthenticationModule')
+  ]).then(results => {
+    console.log('\nTester Agent Results:', JSON.stringify(results, null, 2));
+  });
+}

package/examples/parallel-2/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./",
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}