claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/test/ai-mesh-coordination-test.js

@@ -1,416 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * AI-Driven Mesh Coordination Test
- *
- * Real-world scenario using actual Claude Code CLI agents
- * 7 AI coordinators in mesh topology with 70 language combinations
- * Complete inter-agent communication logging
- */
-
-import { spawn } from 'child_process';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-class AIMeshCoordinator {
-  constructor() {
-    this.outputDir = path.join(__dirname, '../ai-mesh-results');
-    this.communicationLog = path.join(this.outputDir, 'ai-communications.log');
-    this.coordinators = new Map();
-    this.subAgents = new Map();
-    this.agentProcesses = new Map();
-    this.communicationCapture = new Map();
-
-    this.programmingLanguages = [
-      'Python', 'JavaScript', 'Rust', 'Go', 'Java', 'C++', 'TypeScript'
-    ];
-
-    this.verbalLanguages = [
-      'Spanish', 'French', 'German', 'Italian', 'Portuguese',
-      'Japanese', 'Russian', 'Chinese', 'Arabic', 'Hindi'
-    ];
-  }
-
-  async start() {
-    console.log('🤖 Starting AI-Driven Mesh Coordination Test');
-    console.log('   Programming Languages: 7');
-    console.log('   Verbal Languages: 10');
-    console.log('   Target Combinations: 70 (7x10)');
-    console.log('   Method: REAL AI agents via Claude Code CLI\n');
-
-    await fs.mkdir(this.outputDir, { recursive: true });
-    await this.setupCommunicationCapture();
-
-    // Step 1: Spawn 7 AI coordinators
-    await this.spawnAICoordinators();
-
-    // Step 2: Monitor real coordination
-    await this.monitorAICoordination();
-
-    // Step 3: Collect and analyze results
-    await this.collectResults();
-  }
-
-  async setupCommunicationCapture() {
-    // Initialize communication logging
-    const logHeader = {
-      timestamp: Date.now(),
-      testType: 'AI_DRIVEN_MESH_COORDINATION',
-      config: {
-        coordinators: 7,
-        subAgentsPerCoordinator: 10,
-        totalSubAgents: 70,
-        programmingLanguages: this.programmingLanguages.length,
-        verbalLanguages: this.verbalLanguages.length
-      }
-    };
-
-    await fs.appendFile(this.communicationLog, JSON.stringify(logHeader) + '\n');
-    console.log('📝 Communication logging initialized');
-  }
-
-  async spawnAICoordinators() {
-    console.log('🚀 Step 1: Spawning 7 AI Coordinators');
-
-    for (let i = 1; i <= 7; i++) {
-      const coordinatorId = `ai-coordinator-${i}`;
-
-      // Prepare coordinator instructions
-      const instructions = this.generateCoordinatorInstructions(i);
-
-      // Spawn AI coordinator using Claude Code CLI
-      const aiCoordinator = await this.spawnAIAgent(coordinatorId, instructions);
-
-      this.coordinators.set(coordinatorId, {
-        id: coordinatorId,
-        process: aiCoordinator,
-        status: 'active',
-        assignedLanguage: null,
-        subAgents: []
-      });
-
-      console.log(`   ✅ ${coordinatorId} spawned as AI agent`);
-
-      // Small delay between spawns
-      await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-
-    console.log('✅ All 7 AI coordinators spawned\n');
-  }
-
-  generateCoordinatorInstructions(coordinatorNumber) {
-    return `
-You are AI Coordinator ${coordinatorNumber} in a 7-coordinator mesh system.
-
-YOUR MISSION:
-- Coordinate with 6 other AI coordinators to cover 70 unique language combinations
-- Choose ONE programming language from: ${this.programmingLanguages.join(', ')}
-- Communicate with other coordinators to avoid conflicts
-- Once assigned a language, create 10 Hello World functions in 10 different verbal languages
-
-VERBAL LANGUAGES TO ASSIGN: ${this.verbalLanguages.join(', ')}
-
-COORDINATION PROTOCOL:
-1. Start by proposing your preferred programming language
-2. Listen to other coordinators' proposals
-3. If conflicts arise, negotiate and resolve through discussion
-4. Once consensus is reached, implement your 10 language combinations
-
-COMMUNICATION REQUIREMENTS:
-- All messages must be logged to /dev/shm/ai-coordinator-${coordinatorNumber}-messages.log
-- Include your reasoning for language selection
-- Document all conflict resolution discussions
-- Report final assignments clearly
-
-FILE OUTPUT:
-- Create Hello World files in ./ai-mesh-results/
-- Use naming: hello_world_[verbal]_[programming].extension
-- Example: hello_world_spanish_python.py
-
-WORK autonomously but coordinate with other AI coordinators to achieve ZERO OVERLAP across all 70 combinations.
-`;
-  }
-
-  async spawnAIAgent(agentId, instructions) {
-    const messageFile = `/dev/shm/${agentId}-instructions.txt`;
-    await fs.writeFile(messageFile, instructions);
-
-    // Use Claude Code CLI to spawn actual AI agent
-    const agentProcess = spawn('claude', [
-      'flow-novice', 'swarm', 'spawn',
-      '--agent-type', 'coordinator',
-      '--name', agentId,
-      '--instructions', messageFile
-    ], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      detached: true
-    });
-
-    // Set up communication capture
-    await this.setupAgentCommunicationCapture(agentId, agentProcess);
-
-    this.agentProcesses.set(agentId, agentProcess);
-
-    return agentProcess;
-  }
-
-  async setupAgentCommunicationCapture(agentId, process) {
-    const commFile = `/dev/shm/${agentId}-messages.log`;
-
-    // Capture stdout
-    process.stdout.on('data', async (data) => {
-      const message = {
-        timestamp: Date.now(),
-        agentId: agentId,
-        type: 'STDOUT',
-        content: data.toString().trim()
-      };
-
-      await this.logCommunication(message);
-      await fs.appendFile(commFile, JSON.stringify(message) + '\n');
-    });
-
-    // Capture stderr
-    process.stderr.on('data', async (data) => {
-      const message = {
-        timestamp: Date.now(),
-        agentId: agentId,
-        type: 'STDERR',
-        content: data.toString().trim()
-      };
-
-      await this.logCommunication(message);
-      await fs.appendFile(commFile, JSON.stringify(message) + '\n');
-    });
-
-    // Log process events
-    process.on('close', async (code) => {
-      const message = {
-        timestamp: Date.now(),
-        agentId: agentId,
-        type: 'PROCESS_CLOSE',
-        content: `Process closed with code: ${code}`
-      };
-
-      await this.logCommunication(message);
-      await fs.appendFile(commFile, JSON.stringify(message) + '\n');
-    });
-  }
-
-  async logCommunication(message) {
-    // Central logging for all inter-agent communications
-    const logEntry = {
-      timestamp: message.timestamp,
-      agentId: message.agentId,
-      type: message.type,
-      content: message.content,
-      globalTimestamp: Date.now()
-    };
-
-    await fs.appendFile(this.communicationLog, JSON.stringify(logEntry) + '\n');
-
-    // Also track per-agent communication patterns
-    if (!this.communicationCapture.has(message.agentId)) {
-      this.communicationCapture.set(message.agentId, []);
-    }
-    this.communicationCapture.get(message.agentId).push(logEntry);
-
-    // Real-time monitoring output
-    console.log(`[${message.agentId}] ${message.type}: ${message.content.substring(0, 100)}...`);
-  }
-
-  async monitorAICoordination() {
-    console.log('📡 Step 2: Monitoring AI Coordinator Inter-Communication');
-    console.log('   AI agents will now coordinate autonomously...\n');
-
-    // Let AI coordinators work for specified time
-    const monitoringDuration = 5 * 60 * 1000; // 5 minutes
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < monitoringDuration) {
-      await new Promise(resolve => setTimeout(resolve, 30000)); // Check every 30 seconds
-
-      // Check agent status
-      const activeAgents = Array.from(this.coordinators.values()).filter(c => c.status === 'active').length;
-      console.log(`   📊 Active AI coordinators: ${activeAgents}/7`);
-
-      // Look for coordination evidence
-      await this.analyzeCoordinationProgress();
-    }
-
-    console.log('⏰ AI coordination period ended\n');
-  }
-
-  async analyzeCoordinationProgress() {
-    // Look for evidence of coordination in communication logs
-    try {
-      const logContent = await fs.readFile(this.communicationLog, 'utf8');
-      const messages = logContent.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
-
-      const agentMessages = new Map();
-      messages.forEach(msg => {
-        if (!agentMessages.has(msg.agentId)) {
-          agentMessages.set(msg.agentId, 0);
-        }
-        agentMessages.set(msg.agentId, agentMessages.get(msg.agentId) + 1);
-      });
-
-      console.log('   📈 Message activity by agent:');
-      agentMessages.forEach((count, agentId) => {
-        console.log(`      ${agentId}: ${count} messages`);
-      });
-
-    } catch (error) {
-      console.log('   ⚠️  Could not analyze coordination progress');
-    }
-  }
-
-  async collectResults() {
-    console.log('📋 Step 3: Collecting AI Coordination Results');
-
-    // Check for generated files
-    const generatedFiles = await this.scanGeneratedFiles();
-
-    // Analyze communication patterns
-    const communicationAnalysis = await this.analyzeCommunications();
-
-    // Generate final report
-    const results = {
-      timestamp: Date.now(),
-      testType: 'AI_DRIVEN_MESH_COORDINATION',
-      results: {
-        generatedFiles: generatedFiles,
-        communicationAnalysis: communicationAnalysis,
-        agentStatus: this.getAgentStatus()
-      }
-    };
-
-    const resultsFile = path.join(this.outputDir, `ai-results-${Date.now()}.json`);
-    await fs.writeFile(resultsFile, JSON.stringify(results, null, 2));
-
-    console.log(`📁 Results saved to: ${resultsFile}`);
-    console.log('📊 Communication analysis saved to: ai-communications.log');
-
-    // Cleanup
-    await this.cleanup();
-  }
-
-  async scanGeneratedFiles() {
-    try {
-      const files = await fs.readdir(this.outputDir);
-      const helloFiles = files.filter(file => file.startsWith('hello_world_'));
-
-      console.log(`   📄 Found ${helloFiles.length} Hello World files`);
-
-      return {
-        totalFiles: helloFiles.length,
-        fileList: helloFiles,
-        languageCombinations: this.analyzeLanguageCombinations(helloFiles)
-      };
-
-    } catch (error) {
-      console.log('   ❌ Could not scan generated files');
-      return { totalFiles: 0, fileList: [], languageCombinations: {} };
-    }
-  }
-
-  analyzeLanguageCombinations(files) {
-    const combinations = {};
-
-    files.forEach(file => {
-      // Parse filename to extract languages
-      const parts = file.replace('hello_world_', '').replace(/\.[^/.]+$/, '').split('_');
-      if (parts.length >= 2) {
-        const verbal = parts[0];
-        const programming = parts[1];
-        const key = `${programming}+${verbal}`;
-
-        combinations[key] = (combinations[key] || 0) + 1;
-      }
-    });
-
-    return combinations;
-  }
-
-  async analyzeCommunications() {
-    const analysis = {
-      totalMessages: 0,
-      messagesByAgent: {},
-      communicationTypes: {},
-      coordinationEvidence: false
-    };
-
-    this.communicationCapture.forEach((messages, agentId) => {
-      analysis.messagesByAgent[agentId] = messages.length;
-      analysis.totalMessages += messages.length;
-
-      messages.forEach(msg => {
-        analysis.communicationTypes[msg.type] = (analysis.communicationTypes[msg.type] || 0) + 1;
-
-        // Look for coordination keywords
-        if (msg.content.toLowerCase().includes('coordinator') ||
-            msg.content.toLowerCase().includes('language') ||
-            msg.content.toLowerCase().includes('conflict')) {
-          analysis.coordinationEvidence = true;
-        }
-      });
-    });
-
-    return analysis;
-  }
-
-  getAgentStatus() {
-    const status = {};
-    this.coordinators.forEach((coordinator, id) => {
-      status[id] = {
-        status: coordinator.status,
-        assignedLanguage: coordinator.assignedLanguage,
-        processId: coordinator.process.pid
-      };
-    });
-    return status;
-  }
-
-  async cleanup() {
-    console.log('🧹 Cleaning up AI processes...');
-
-    // Terminate all AI agent processes
-    this.agentProcesses.forEach((process, agentId) => {
-      try {
-        process.kill('SIGTERM');
-        console.log(`   ✅ Terminated ${agentId}`);
-      } catch (error) {
-        console.log(`   ⚠️  Could not terminate ${agentId}`);
-      }
-    });
-
-    // Cleanup temp files
-    try {
-      const tempFiles = [
-        '/dev/shm/ai-coordinator-*-instructions.txt',
-        '/dev/shm/ai-coordinator-*-messages.log'
-      ];
-
-      for (const pattern of tempFiles) {
-        const { execSync } = await import('child_process');
-        try {
-          execSync(`rm -f ${pattern}`);
-        } catch (error) {
-          // Ignore cleanup errors
-        }
-      }
-    } catch (error) {
-      // Ignore cleanup errors
-    }
-
-    console.log('✅ Cleanup complete');
-  }
-}
-
-// Run the AI mesh coordinator test
-const aiMesh = new AIMeshCoordinator();
-aiMesh.start().catch(console.error);

package/dist/scripts/test/check-links.ts

@@ -1,274 +0,0 @@
-#!/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();
-}