claude-flow-novice 1.3.0 → 1.3.2

package/scripts/test/README.md

@@ -0,0 +1,236 @@
+# Test Scripts
+
+This directory contains all testing and validation scripts for the Claude Flow project.
+
+## Scripts
+
+### Core Test Infrastructure
+
+#### `test-runner.ts` - Universal Test Runner
+Primary test orchestration with multiple test strategies.
+
+#### `test-comprehensive.js` - Comprehensive Test Suite
+Full system testing including unit, integration, and e2e tests.
+
+#### `test-coordination-features.ts` - Coordination Testing
+Tests for Claude Flow's coordination and swarm features.
+
+### Performance & Load Testing
+
+#### `check-performance-regression.ts` - Performance Regression Detection
+Monitors and detects performance regressions between builds.
+
+#### `load-test-swarm.js` - Swarm Load Testing
+High-load testing for swarm coordination and agent management.
+
+#### `coverage-report.ts` - Test Coverage Analysis
+Generates comprehensive test coverage reports and analysis.
+
+### Specialized Testing
+
+#### `test-swarm.ts` - Swarm Functionality Testing
+Core swarm behavior and coordination testing.
+
+#### `test-swarm-integration.sh` - Swarm Integration Tests
+Integration testing for swarm components with external systems.
+
+#### `test-byzantine-resolution.js` - Byzantine Fault Tolerance Testing
+Tests Byzantine fault tolerance and consensus mechanisms.
+
+#### `test-fallback-systems.js` - Fallback System Testing
+Tests failover and recovery mechanisms.
+
+#### `test-mcp.ts` - MCP Protocol Testing
+Model Context Protocol implementation testing.
+
+#### `test-cli-wizard.js` - CLI Interface Testing
+Command-line interface and wizard functionality testing.
+
+#### `test-init-command.ts` - Initialization Testing
+Tests project initialization and setup commands.
+
+#### `test-claude-spawn-options.sh` - Claude Spawn Testing
+Tests Claude agent spawning with various configuration options.
+
+#### `test-batch-tasks.ts` - Batch Task Testing
+Tests batch processing and parallel task execution.
+
+### Validation & Compliance
+
+#### `validation-summary.ts` - Test Validation Summary
+Generates comprehensive validation reports across all test categories.
+
+#### `integration-test-validation.cjs` - Integration Validation
+Validates integration test results and system compatibility.
+
+#### `run-phase3-compliance-tests.js` - Phase 3 Compliance Testing
+Specific compliance testing for Phase 3 project requirements.
+
+#### `check-links.ts` - Link Validation
+Validates internal and external links in documentation and code.
+
+### Test Generation
+
+#### `generate-swarm-tests.js` - Automated Test Generation
+Automatically generates test cases for swarm functionality.
+
+## Package.json Integration
+
+Test scripts are integrated into package.json:
+
+```json
+{
+  "scripts": {
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --config=config/jest/jest.config.js --bail --maxWorkers=1 --forceExit",
+    "test:unit": "NODE_OPTIONS='--experimental-vm-modules' jest src/__tests__/unit",
+    "test:integration": "NODE_OPTIONS='--experimental-vm-modules' jest src/__tests__/integration",
+    "test:e2e": "NODE_OPTIONS='--experimental-vm-modules' jest src/__tests__/e2e",
+    "test:performance": "NODE_OPTIONS='--experimental-vm-modules' jest src/__tests__/performance",
+    "test:coverage": "NODE_OPTIONS='--experimental-vm-modules' jest --config=config/jest/jest.config.js --coverage",
+    "test:ci": "NODE_OPTIONS='--experimental-vm-modules' jest --config=config/jest/jest.config.js --ci --coverage --maxWorkers=2"
+  }
+}
+```
+
+## Test Categories
+
+### 1. Unit Tests
+- Individual component testing
+- Isolated functionality verification
+- Mock-based testing
+
+### 2. Integration Tests
+- Component interaction testing
+- API integration verification
+- Database connectivity testing
+
+### 3. End-to-End Tests
+- Full workflow testing
+- User journey verification
+- Complete system testing
+
+### 4. Performance Tests
+- Load testing
+- Stress testing
+- Performance regression detection
+- Resource usage monitoring
+
+### 5. Swarm Tests
+- Agent coordination testing
+- Consensus mechanism testing
+- Fault tolerance testing
+- Byzantine failure handling
+
+### 6. Compliance Tests
+- Phase requirements verification
+- Security compliance testing
+- Protocol compliance verification
+
+## Running Tests
+
+### Basic Test Execution
+```bash
+# Run all tests
+npm test
+
+# Run specific test categories
+npm run test:unit
+npm run test:integration
+npm run test:e2e
+npm run test:performance
+
+# Generate coverage reports
+npm run test:coverage
+```
+
+### Specialized Testing
+```bash
+# Performance regression testing
+node scripts/test/check-performance-regression.ts
+
+# Swarm load testing
+node scripts/test/load-test-swarm.js
+
+# Comprehensive testing
+node scripts/test/test-comprehensive.js
+
+# Generate test reports
+node scripts/test/validation-summary.ts
+```
+
+## Test Configuration
+
+### Jest Configuration
+Tests use Jest with custom configuration located in `config/jest/jest.config.js`.
+
+### Node.js Options
+Tests require experimental VM modules:
+```bash
+NODE_OPTIONS='--experimental-vm-modules'
+```
+
+### Test Environment
+- Isolated test execution (maxWorkers=1)
+- Fail-fast mode (--bail)
+- Forced exit (--forceExit)
+- CI-optimized settings
+
+## Test Data & Fixtures
+
+Test data and fixtures should be placed in appropriate test directories:
+- `src/__tests__/fixtures/` - Test data files
+- `src/__tests__/mocks/` - Mock implementations
+- `src/__tests__/helpers/` - Test helper functions
+
+## Continuous Integration
+
+CI-specific test configuration:
+```bash
+npm run test:ci
+```
+
+Features:
+- Parallel execution (maxWorkers=2)
+- Coverage reporting
+- CI-optimized timeouts
+- Artifact generation
+
+## Troubleshooting
+
+### Common Issues
+
+**Test Failures:**
+```bash
+# Run tests with verbose output
+npm test -- --verbose
+
+# Run specific test file
+npm test -- --testPathPattern=specific-test.test.js
+```
+
+**Performance Test Issues:**
+```bash
+# Check system resources
+node scripts/test/check-performance-regression.ts
+
+# Run isolated performance tests
+npm run test:performance
+```
+
+**Swarm Test Failures:**
+```bash
+# Test swarm coordination
+node scripts/test/test-swarm.ts
+
+# Check Byzantine fault tolerance
+node scripts/test/test-byzantine-resolution.js
+```
+
+### Memory Issues
+If tests fail due to memory issues:
+```bash
+# Increase Node.js memory limit
+NODE_OPTIONS='--experimental-vm-modules --max-old-space-size=4096' npm test
+```
+
+For legacy test scripts, see `../legacy/` directory.

package/scripts/test/check-links.ts

@@ -0,0 +1,274 @@
+#!/usr/bin/env deno run --allow-net --allow-read
+
+/**
+ * Documentation Link Checker
+ * Scans documentation files for broken links
+ */
+
+import { walk } from "https://deno.land/std@0.220.0/fs/mod.ts";
+
+interface LinkCheckResult {
+  file: string;
+  url: string;
+  status: 'ok' | 'broken' | 'timeout' | 'error';
+  statusCode?: number;
+  error?: string;
+}
+
+interface ScanResult {
+  totalFiles: number;
+  totalLinks: number;
+  brokenLinks: LinkCheckResult[];
+  timeouts: LinkCheckResult[];
+  errors: LinkCheckResult[];
+}
+
+const TIMEOUT_MS = 10000; // 10 seconds
+const USER_AGENT = 'Claude-Flow Link Checker';
+const MAX_CONCURRENT = 10;
+
+// Links to skip (known to have issues with automated checking)
+const SKIP_URLS = new Set([
+  'mailto:',
+  'tel:',
+  'javascript:',
+  '#',
+  'localhost',
+  '127.0.0.1',
+  'example.com',
+  'example.org',
+]);
+
+function extractLinks(content: string): string[] {
+  const links: string[] = [];
+  
+  // Markdown links: [text](url)
+  const markdownLinkRegex = /\[([^\]]*)\]\(([^)]+)\)/g;
+  let match;
+  while ((match = markdownLinkRegex.exec(content)) !== null) {
+    links.push(match[2]);
+  }
+  
+  // HTML links: <a href="url">
+  const htmlLinkRegex = /<a[^>]+href\s*=\s*['""]([^'""]+)['""][^>]*>/gi;
+  while ((match = htmlLinkRegex.exec(content)) !== null) {
+    links.push(match[1]);
+  }
+  
+  // URL references: [ref]: url
+  const refLinkRegex = /^\s*\[([^\]]+)\]:\s*(.+)$/gm;
+  while ((match = refLinkRegex.exec(content)) !== null) {
+    links.push(match[2]);
+  }
+  
+  return links;
+}
+
+function shouldSkipUrl(url: string): boolean {
+  // Skip relative links
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    return true;
+  }
+  
+  // Skip specific patterns
+  for (const skipPattern of SKIP_URLS) {
+    if (url.includes(skipPattern)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+async function checkLink(url: string): Promise<{ status: number | null; error?: string }> {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    
+    const response = await fetch(url, {
+      method: 'HEAD', // Use HEAD to avoid downloading content
+      signal: controller.signal,
+      headers: {
+        'User-Agent': USER_AGENT,
+      },
+    });
+    
+    clearTimeout(timeoutId);
+    
+    return {
+      status: response.status,
+    };
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      return { status: null, error: 'timeout' };
+    }
+    
+    return {
+      status: null,
+      error: error.message,
+    };
+  }
+}
+
+async function scanFile(filePath: string): Promise<LinkCheckResult[]> {
+  const results: LinkCheckResult[] = [];
+  
+  try {
+    const content = await Deno.readTextFile(filePath);
+    const links = extractLinks(content);
+    
+    // Remove duplicates and filter
+    const uniqueLinks = [...new Set(links)].filter(url => !shouldSkipUrl(url));
+    
+    // Check links with concurrency control
+    const semaphore = new Array(MAX_CONCURRENT).fill(0);
+    const promises = uniqueLinks.map(async (url) => {
+      // Wait for available slot
+      await new Promise<void>((resolve) => {
+        const checkSlot = () => {
+          const index = semaphore.findIndex(slot => slot === 0);
+          if (index !== -1) {
+            semaphore[index] = 1;
+            resolve();
+          } else {
+            setTimeout(checkSlot, 100);
+          }
+        };
+        checkSlot();
+      });
+      
+      try {
+        const { status, error } = await checkLink(url);
+        
+        let resultStatus: LinkCheckResult['status'];
+        if (error === 'timeout') {
+          resultStatus = 'timeout';
+        } else if (error) {
+          resultStatus = 'error';
+        } else if (status && status >= 200 && status < 400) {
+          resultStatus = 'ok';
+        } else {
+          resultStatus = 'broken';
+        }
+        
+        return {
+          file: filePath,
+          url,
+          status: resultStatus,
+          statusCode: status || undefined,
+          error,
+        };
+      } finally {
+        // Release slot
+        const index = semaphore.findIndex(slot => slot === 1);
+        if (index !== -1) {
+          semaphore[index] = 0;
+        }
+      }
+    });
+    
+    results.push(...await Promise.all(promises));
+  } catch (error) {
+    console.warn(`Failed to scan ${filePath}: ${error.message}`);
+  }
+  
+  return results;
+}
+
+async function main(): Promise<void> {
+  console.log('Checking documentation links...\n');
+  
+  const results: LinkCheckResult[] = [];
+  let fileCount = 0;
+  
+  // Scan markdown and HTML files
+  const extensions = ['.md', '.html', '.htm'];
+  const directories = ['./docs', './README.md', './examples'];
+  
+  for (const dir of directories) {
+    try {
+      const stat = await Deno.stat(dir);
+      if (stat.isFile) {
+        // Single file
+        const fileResults = await scanFile(dir);
+        results.push(...fileResults);
+        fileCount++;
+      } else if (stat.isDirectory) {
+        // Directory
+        for await (const entry of walk(dir, { exts: extensions })) {
+          if (entry.isFile) {
+            const fileResults = await scanFile(entry.path);
+            results.push(...fileResults);
+            fileCount++;
+          }
+        }
+      }
+    } catch (error) {
+      if (!(error instanceof Deno.errors.NotFound)) {
+        console.warn(`Failed to process ${dir}: ${error.message}`);
+      }
+    }
+  }
+  
+  // Analyze results
+  const scanResult: ScanResult = {
+    totalFiles: fileCount,
+    totalLinks: results.length,
+    brokenLinks: results.filter(r => r.status === 'broken'),
+    timeouts: results.filter(r => r.status === 'timeout'),
+    errors: results.filter(r => r.status === 'error'),
+  };
+  
+  // Report results
+  console.log(`📊 Scan Summary:`);
+  console.log(`   Files scanned: ${scanResult.totalFiles}`);
+  console.log(`   Links checked: ${scanResult.totalLinks}`);
+  console.log(`   Broken links: ${scanResult.brokenLinks.length}`);
+  console.log(`   Timeouts: ${scanResult.timeouts.length}`);
+  console.log(`   Errors: ${scanResult.errors.length}\n`);
+  
+  // Report broken links
+  if (scanResult.brokenLinks.length > 0) {
+    console.log('❌ Broken Links:');
+    for (const result of scanResult.brokenLinks) {
+      console.log(`   ${result.file}: ${result.url} (${result.statusCode})`);
+    }
+    console.log('');
+  }
+  
+  // Report timeouts
+  if (scanResult.timeouts.length > 0) {
+    console.log('⏱️  Timeouts:');
+    for (const result of scanResult.timeouts) {
+      console.log(`   ${result.file}: ${result.url}`);
+    }
+    console.log('');
+  }
+  
+  // Report other errors
+  if (scanResult.errors.length > 0) {
+    console.log('⚠️  Errors:');
+    for (const result of scanResult.errors) {
+      console.log(`   ${result.file}: ${result.url} (${result.error})`);
+    }
+    console.log('');
+  }
+  
+  // Summary
+  const totalIssues = scanResult.brokenLinks.length + scanResult.timeouts.length + scanResult.errors.length;
+  
+  if (totalIssues === 0) {
+    console.log('✅ All links are working!');
+  } else {
+    console.error(`❌ Found ${totalIssues} link issues!`);
+    
+    // Don't fail CI for timeouts or minor errors, only broken links
+    if (scanResult.brokenLinks.length > 0) {
+      Deno.exit(1);
+    }
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}

package/scripts/test/check-performance-regression.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env deno run --allow-read --allow-write
+
+/**
+ * Performance Regression Checker
+ * Compares current performance metrics against baseline
+ */
+
+interface PerformanceMetric {
+  name: string;
+  value: number;
+  unit: string;
+  threshold: number; // Maximum allowed regression percentage
+}
+
+interface PerformanceReport {
+  timestamp: string;
+  gitHash: string;
+  metrics: PerformanceMetric[];
+}
+
+const BASELINE_FILE = 'performance-baseline.json';
+const CURRENT_RESULTS_FILE = 'performance-results.json';
+const REGRESSION_THRESHOLD = 20; // 20% regression threshold
+
+async function loadBaseline(): Promise<PerformanceReport | null> {
+  try {
+    const baselineData = await Deno.readTextFile(BASELINE_FILE);
+    return JSON.parse(baselineData);
+  } catch (error) {
+    if (error instanceof Deno.errors.NotFound) {
+      console.log('No baseline found, creating initial baseline...');
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function loadCurrentResults(): Promise<PerformanceReport> {
+  try {
+    const currentData = await Deno.readTextFile(CURRENT_RESULTS_FILE);
+    return JSON.parse(currentData);
+  } catch (error) {
+    console.error('Failed to load current performance results:', error.message);
+    Deno.exit(1);
+  }
+}
+
+async function saveBaseline(report: PerformanceReport): Promise<void> {
+  await Deno.writeTextFile(BASELINE_FILE, JSON.stringify(report, null, 2));
+  console.log('Baseline updated successfully');
+}
+
+function calculateRegression(baseline: number, current: number): number {
+  return ((current - baseline) / baseline) * 100;
+}
+
+function checkRegressions(baseline: PerformanceReport, current: PerformanceReport): {
+  regressions: Array<{ metric: string; regression: number; threshold: number }>;
+  hasRegressions: boolean;
+} {
+  const regressions: Array<{ metric: string; regression: number; threshold: number }> = [];
+  
+  for (const currentMetric of current.metrics) {
+    const baselineMetric = baseline.metrics.find(m => m.name === currentMetric.name);
+    
+    if (!baselineMetric) {
+      console.log(`New metric detected: ${currentMetric.name}`);
+      continue;
+    }
+    
+    const regression = calculateRegression(baselineMetric.value, currentMetric.value);
+    const threshold = currentMetric.threshold || REGRESSION_THRESHOLD;
+    
+    if (regression > threshold) {
+      regressions.push({
+        metric: currentMetric.name,
+        regression,
+        threshold,
+      });
+    }
+  }
+  
+  return {
+    regressions,
+    hasRegressions: regressions.length > 0,
+  };
+}
+
+function generateReport(
+  baseline: PerformanceReport,
+  current: PerformanceReport,
+  regressions: Array<{ metric: string; regression: number; threshold: number }>
+): void {
+  console.log('\n=== Performance Regression Report ===\n');
+  
+  console.log(`Baseline: ${baseline.timestamp} (${baseline.gitHash})`);
+  console.log(`Current:  ${current.timestamp} (${current.gitHash})\n`);
+  
+  if (regressions.length === 0) {
+    console.log('✅ No performance regressions detected!\n');
+  } else {
+    console.log('❌ Performance regressions detected:\n');
+    
+    for (const regression of regressions) {
+      const baselineMetric = baseline.metrics.find(m => m.name === regression.metric)!;
+      const currentMetric = current.metrics.find(m => m.name === regression.metric)!;
+      
+      console.log(`  ${regression.metric}:`);
+      console.log(`    Baseline: ${baselineMetric.value} ${baselineMetric.unit}`);
+      console.log(`    Current:  ${currentMetric.value} ${currentMetric.unit}`);
+      console.log(`    Regression: ${regression.regression.toFixed(2)}% (threshold: ${regression.threshold}%)`);
+      console.log('');
+    }
+  }
+  
+  // Show all metrics for reference
+  console.log('📊 All Performance Metrics:\n');
+  
+  for (const currentMetric of current.metrics) {
+    const baselineMetric = baseline.metrics.find(m => m.name === currentMetric.name);
+    
+    if (baselineMetric) {
+      const regression = calculateRegression(baselineMetric.value, currentMetric.value);
+      const status = regression > (currentMetric.threshold || REGRESSION_THRESHOLD) ? '❌' : '✅';
+      
+      console.log(`  ${status} ${currentMetric.name}: ${currentMetric.value} ${currentMetric.unit} (${regression > 0 ? '+' : ''}${regression.toFixed(2)}%)`);
+    } else {
+      console.log(`  🆕 ${currentMetric.name}: ${currentMetric.value} ${currentMetric.unit} (new metric)`);
+    }
+  }
+  
+  console.log('');
+}
+
+async function main(): Promise<void> {
+  console.log('Checking for performance regressions...\n');
+  
+  const baseline = await loadBaseline();
+  const current = await loadCurrentResults();
+  
+  if (!baseline) {
+    console.log('No baseline found, establishing current results as baseline...');
+    await saveBaseline(current);
+    console.log('Baseline established successfully');
+    return;
+  }
+  
+  const { regressions, hasRegressions } = checkRegressions(baseline, current);
+  
+  generateReport(baseline, current, regressions);
+  
+  if (hasRegressions) {
+    console.error('Performance regressions detected! Please investigate and fix before merging.');
+    Deno.exit(1);
+  } else {
+    console.log('Performance check passed! 🎉');
+    
+    // Update baseline if this is a main branch build
+    const branch = Deno.env.get('GITHUB_REF');
+    if (branch === 'refs/heads/main') {
+      await saveBaseline(current);
+    }
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}