claude-flow-novice 2.3.5 → 2.3.6

package/dist/scripts/utils/validate-metrics-structure.cjs

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Metrics Structure Validation Script
- * Validates the organized metrics directory structure and data integrity
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const METRICS_BASE = '.claude-flow/metrics';
-const REQUIRED_STRUCTURE = {
-  'performance': ['consolidated-performance.json', 'execution-history.json', 'agent-performance.json'],
-  'system': ['real-time-metrics.json'],
-  'benchmarks': [],
-  'historical': [],
-  'verification-archive': []
-};
-
-function validateStructure() {
-  console.log('🔍 Validating metrics directory structure...\n');
-
-  let isValid = true;
-
-  // Check if config.json exists
-  const configPath = path.join(METRICS_BASE, 'config.json');
-  if (!fs.existsSync(configPath)) {
-    console.error('❌ Missing config.json in metrics directory');
-    isValid = false;
-  } else {
-    console.log('✅ Config file exists');
-
-    // Validate config structure
-    try {
-      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      if (config.version && config.structure) {
-        console.log('✅ Config structure is valid');
-      } else {
-        console.error('❌ Invalid config.json structure');
-        isValid = false;
-      }
-    } catch (error) {
-      console.error('❌ Config.json is not valid JSON:', error.message);
-      isValid = false;
-    }
-  }
-
-  // Check directory structure
-  for (const [dir, files] of Object.entries(REQUIRED_STRUCTURE)) {
-    const dirPath = path.join(METRICS_BASE, dir);
-
-    if (!fs.existsSync(dirPath)) {
-      console.error(`❌ Missing directory: ${dir}`);
-      isValid = false;
-    } else {
-      console.log(`✅ Directory exists: ${dir}`);
-
-      // Check required files
-      for (const file of files) {
-        const filePath = path.join(dirPath, file);
-        if (!fs.existsSync(filePath)) {
-          console.error(`❌ Missing required file: ${dir}/${file}`);
-          isValid = false;
-        } else {
-          console.log(`  ✅ ${file}`);
-
-          // Validate JSON files
-          if (file.endsWith('.json')) {
-            try {
-              const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-              if (content.metadata) {
-                console.log(`    ✅ Valid JSON with metadata`);
-              }
-            } catch (error) {
-              console.error(`    ❌ Invalid JSON in ${file}:`, error.message);
-              isValid = false;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Check for leftover legacy files
-  const metricsFiles = fs.readdirSync(METRICS_BASE);
-  const legacyFiles = metricsFiles.filter(file =>
-    file.endsWith('.json') &&
-    !['config.json'].includes(file)
-  );
-
-  if (legacyFiles.length > 0) {
-    console.warn('⚠️  Legacy files still in root metrics directory:');
-    legacyFiles.forEach(file => console.warn(`  - ${file}`));
-    console.log('  Consider moving these to historical/ directory');
-  }
-
-  console.log('\n📊 Validation Summary:');
-  console.log(`Status: ${isValid ? '✅ PASSED' : '❌ FAILED'}`);
-  console.log(`Directories: ${Object.keys(REQUIRED_STRUCTURE).length}`);
-  console.log(`Required files: ${Object.values(REQUIRED_STRUCTURE).flat().length}`);
-
-  return isValid;
-}
-
-function testDataCollection() {
-  console.log('\n🧪 Testing data collection endpoints...\n');
-
-  const endpoints = [
-    'performance/consolidated-performance.json',
-    'system/real-time-metrics.json',
-    '../dashboard/data.json'
-  ];
-
-  for (const endpoint of endpoints) {
-    const filePath = path.join(METRICS_BASE, endpoint);
-    if (fs.existsSync(filePath)) {
-      try {
-        const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        console.log(`✅ ${endpoint} - readable and valid JSON`);
-
-        // Check if data is recent (within last hour)
-        if (data.timestamp || data.metadata?.consolidated_at) {
-          console.log(`  📅 Contains timestamp data`);
-        }
-      } catch (error) {
-        console.error(`❌ ${endpoint} - JSON parsing failed:`, error.message);
-      }
-    } else {
-      console.error(`❌ ${endpoint} - file not found`);
-    }
-  }
-}
-
-// Main execution
-console.log('📋 Claude Flow Metrics Structure Validation\n');
-console.log('=' * 50);
-
-const structureValid = validateStructure();
-testDataCollection();
-
-console.log('\n' + '=' * 50);
-console.log(`🎯 Overall Status: ${structureValid ? 'METRICS STRUCTURE VALID' : 'VALIDATION FAILED'}`);
-
-process.exit(structureValid ? 0 : 1);

package/dist/scripts/validate-agent-hooks.js

@@ -1,506 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Agent Lifecycle Hooks Validator
- *
- * Validates agent profile hooks for:
- * - Shell syntax correctness
- * - Environment variable usage
- * - Dangerous commands
- * - Performance anti-patterns
- * - Security vulnerabilities
- *
- * Usage:
- *   node scripts/validate-agent-hooks.js --all                    # Validate all agents
- *   node scripts/validate-agent-hooks.js <agent-file.md>          # Validate specific agent
- *   node scripts/validate-agent-hooks.js --all --ci               # CI mode (exit 1 on errors)
- *   node scripts/validate-agent-hooks.js --all --verbose          # Verbose output
- *
- * Sprint: 2.2 - Agent Lifecycle Hooks
- * Epic: production-blocking-coordination
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
-import yaml from 'js-yaml';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// ===== CONFIGURATION =====
-
-const HOOK_NAMES = ['on_blocking_start', 'on_signal_received', 'on_blocking_timeout'];
-
-const REQUIRED_ENV_VARS = ['AGENT_ID', 'TASK', 'SWARM_ID', 'ITERATION', 'PHASE'];
-
-const DANGEROUS_PATTERNS = [
-  { pattern: /rm\s+-rf\s+\//, severity: 'critical', message: 'Destructive: rm -rf /' },
-  { pattern: /dd\s+if=/, severity: 'critical', message: 'Dangerous: dd command' },
-  { pattern: /mkfs/, severity: 'critical', message: 'Dangerous: mkfs command' },
-  { pattern: /chmod\s+777/, severity: 'high', message: 'Security: chmod 777' },
-  { pattern: /sudo\s+/, severity: 'high', message: 'Privilege escalation: sudo' },
-  { pattern: /nc\s+-l/, severity: 'medium', message: 'Network: netcat listener' },
-  { pattern: /sqlite3.*DROP/, severity: 'critical', message: 'Database: Direct DROP statement' },
-  { pattern: /eval\s+/, severity: 'high', message: 'Security: eval command' },
-  { pattern: /\$\([^)]*rm[^)]*\)/, severity: 'high', message: 'Command substitution with rm' },
-  { pattern: />\s*\/dev\/sd[a-z]/, severity: 'critical', message: 'Direct disk write' },
-];
-
-const PERFORMANCE_ANTI_PATTERNS = [
-  { pattern: /sleep\s+[5-9]\d+/, severity: 'high', message: 'Performance: sleep > 50 seconds' },
-  { pattern: /for\s+\w+\s+in\s+\$\(find/, severity: 'medium', message: 'Performance: Loop over find' },
-  { pattern: /curl.*--max-time\s+[5-9]\d+/, severity: 'medium', message: 'Performance: Long HTTP timeout' },
-  { pattern: /while\s+true/, severity: 'high', message: 'Performance: Infinite loop detected' },
-];
-
-const SHELL_SYNTAX_PATTERNS = [
-  { pattern: /\$\{[^}]+\}/, name: 'Variable expansion', valid: true },
-  { pattern: /\$\([^)]+\)/, name: 'Command substitution', valid: true },
-  { pattern: /\$[A-Z_][A-Z0-9_]*\b(?!\{)/, name: 'Unquoted variable', valid: false, fix: 'Use "${VAR}" instead of $VAR' },
-  { pattern: /\|\|/, name: 'OR operator', valid: true },
-  { pattern: /&&/, name: 'AND operator', valid: true },
-];
-
-// ===== VALIDATION FUNCTIONS =====
-
-/**
- * Extract YAML frontmatter from markdown file
- */
-function extractFrontmatter(content) {
-  // Normalize line endings to handle both LF and CRLF
-  const normalizedContent = content.replace(/\r\n/g, '\n');
-  const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
-  const match = normalizedContent.match(frontmatterRegex);
-
-  if (!match) {
-    return null;
-  }
-
-  try {
-    return yaml.load(match[1]);
-  } catch (error) {
-    throw new Error(`Invalid YAML frontmatter: ${error.message}`);
-  }
-}
-
-/**
- * Validate shell syntax using bash -n
- */
-function validateShellSyntax(hookScript, hookName) {
-  const issues = [];
-
-  try {
-    // Create temporary file for syntax check
-    const tempFile = `/tmp/hook_validate_${Date.now()}.sh`;
-    fs.writeFileSync(tempFile, `#!/bin/bash\n${hookScript}`);
-
-    // Run bash syntax check
-    execSync(`bash -n ${tempFile}`, { encoding: 'utf8', stdio: 'pipe' });
-
-    // Clean up
-    fs.unlinkSync(tempFile);
-
-    issues.push({
-      severity: 'info',
-      message: `Shell syntax valid for ${hookName}`,
-      type: 'syntax',
-    });
-  } catch (error) {
-    issues.push({
-      severity: 'error',
-      message: `Shell syntax error in ${hookName}: ${error.stderr || error.message}`,
-      type: 'syntax',
-    });
-  }
-
-  return issues;
-}
-
-/**
- * Check for environment variable usage
- */
-function validateEnvVars(hookScript, hookName) {
-  const issues = [];
-  const usedVars = new Set();
-
-  // Extract all ${VAR} patterns
-  const varPattern = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
-  let match;
-
-  while ((match = varPattern.exec(hookScript)) !== null) {
-    usedVars.add(match[1]);
-  }
-
-  // Check for required variables
-  const missingRequired = REQUIRED_ENV_VARS.filter((v) => !usedVars.has(v));
-
-  if (missingRequired.length > 0 && hookName === 'on_blocking_start') {
-    issues.push({
-      severity: 'warning',
-      message: `${hookName}: Consider using required variables: ${missingRequired.join(', ')}`,
-      type: 'env_vars',
-    });
-  }
-
-  // Check for unquoted variables (security risk)
-  const unquotedPattern = /\$([A-Z_][A-Z0-9_]*)\b(?!\{)/g;
-  const unquotedMatches = [];
-
-  while ((match = unquotedPattern.exec(hookScript)) !== null) {
-    unquotedMatches.push(match[1]);
-  }
-
-  if (unquotedMatches.length > 0) {
-    issues.push({
-      severity: 'high',
-      message: `${hookName}: Unquoted variables (injection risk): ${unquotedMatches.join(', ')}`,
-      type: 'security',
-      fix: 'Use "${VAR}" instead of $VAR',
-    });
-  }
-
-  return issues;
-}
-
-/**
- * Check for dangerous commands
- */
-function validateDangerousCommands(hookScript, hookName) {
-  const issues = [];
-
-  for (const { pattern, severity, message } of DANGEROUS_PATTERNS) {
-    if (pattern.test(hookScript)) {
-      issues.push({
-        severity,
-        message: `${hookName}: ${message}`,
-        type: 'dangerous_command',
-        pattern: pattern.toString(),
-      });
-    }
-  }
-
-  return issues;
-}
-
-/**
- * Check for performance anti-patterns
- */
-function validatePerformance(hookScript, hookName) {
-  const issues = [];
-
-  for (const { pattern, severity, message } of PERFORMANCE_ANTI_PATTERNS) {
-    if (pattern.test(hookScript)) {
-      issues.push({
-        severity,
-        message: `${hookName}: ${message}`,
-        type: 'performance',
-        pattern: pattern.toString(),
-      });
-    }
-  }
-
-  // Check for missing error handling
-  if (!hookScript.includes('|| true') && !hookScript.includes('|| echo')) {
-    issues.push({
-      severity: 'medium',
-      message: `${hookName}: Missing error handling (consider '|| true' for non-critical commands)`,
-      type: 'error_handling',
-    });
-  }
-
-  return issues;
-}
-
-/**
- * Validate hook execution time estimate
- */
-function estimateExecutionTime(hookScript, hookName) {
-  const issues = [];
-  let estimatedTime = 0;
-
-  // Estimate based on patterns
-  if (hookScript.includes('find')) estimatedTime += 2000; // 2s for find
-  if (hookScript.includes('curl') || hookScript.includes('wget')) estimatedTime += 3000; // 3s for HTTP
-  if (hookScript.includes('git')) estimatedTime += 1000; // 1s for git
-  if (hookScript.includes('/sqlite-memory')) estimatedTime += 500; // 500ms for memory op
-  if (hookScript.includes('/eventbus')) estimatedTime += 300; // 300ms for event
-
-  // Count command substitutions
-  const cmdSubCount = (hookScript.match(/\$\(/g) || []).length;
-  estimatedTime += cmdSubCount * 200; // 200ms per command substitution
-
-  if (estimatedTime > 5000) {
-    issues.push({
-      severity: 'critical',
-      message: `${hookName}: Estimated execution time ${estimatedTime}ms exceeds 5s timeout`,
-      type: 'performance',
-      estimatedTime,
-    });
-  } else if (estimatedTime > 3000) {
-    issues.push({
-      severity: 'warning',
-      message: `${hookName}: Estimated execution time ${estimatedTime}ms (consider optimizing for < 3s)`,
-      type: 'performance',
-      estimatedTime,
-    });
-  } else {
-    issues.push({
-      severity: 'info',
-      message: `${hookName}: Estimated execution time ${estimatedTime}ms (good)`,
-      type: 'performance',
-      estimatedTime,
-    });
-  }
-
-  return issues;
-}
-
-/**
- * Validate a single hook
- */
-function validateHook(hookScript, hookName) {
-  const issues = [];
-
-  if (!hookScript || hookScript.trim().length === 0) {
-    return [
-      {
-        severity: 'info',
-        message: `${hookName}: Empty hook (no-op)`,
-        type: 'empty',
-      },
-    ];
-  }
-
-  // Run all validations
-  issues.push(...validateShellSyntax(hookScript, hookName));
-  issues.push(...validateEnvVars(hookScript, hookName));
-  issues.push(...validateDangerousCommands(hookScript, hookName));
-  issues.push(...validatePerformance(hookScript, hookName));
-  issues.push(...estimateExecutionTime(hookScript, hookName));
-
-  return issues;
-}
-
-/**
- * Validate agent profile file
- */
-function validateAgentProfile(filePath) {
-  const results = {
-    file: filePath,
-    valid: true,
-    issues: [],
-    hooks: {},
-  };
-
-  try {
-    // Read file
-    const content = fs.readFileSync(filePath, 'utf8');
-
-    // Extract frontmatter
-    const frontmatter = extractFrontmatter(content);
-
-    if (!frontmatter) {
-      results.valid = false;
-      results.issues.push({
-        severity: 'error',
-        message: 'No YAML frontmatter found',
-        type: 'frontmatter',
-      });
-      return results;
-    }
-
-    // Check if hooks exist
-    if (!frontmatter.hooks) {
-      results.issues.push({
-        severity: 'info',
-        message: 'No hooks defined (optional)',
-        type: 'hooks',
-      });
-      return results;
-    }
-
-    // Validate each hook
-    for (const hookName of HOOK_NAMES) {
-      if (frontmatter.hooks[hookName]) {
-        const hookIssues = validateHook(frontmatter.hooks[hookName], hookName);
-        results.hooks[hookName] = hookIssues;
-        results.issues.push(...hookIssues);
-      }
-    }
-
-    // Check for unknown hooks
-    const unknownHooks = Object.keys(frontmatter.hooks).filter((h) => !HOOK_NAMES.includes(h));
-    if (unknownHooks.length > 0) {
-      results.issues.push({
-        severity: 'warning',
-        message: `Unknown hooks: ${unknownHooks.join(', ')}`,
-        type: 'hooks',
-      });
-    }
-
-    // Determine overall validity
-    const hasCritical = results.issues.some((i) => i.severity === 'critical');
-    const hasError = results.issues.some((i) => i.severity === 'error');
-
-    results.valid = !hasCritical && !hasError;
-  } catch (error) {
-    results.valid = false;
-    results.issues.push({
-      severity: 'error',
-      message: `Validation failed: ${error.message}`,
-      type: 'exception',
-    });
-  }
-
-  return results;
-}
-
-/**
- * Find all agent profile files
- */
-function findAgentProfiles() {
-  const agentsDir = path.join(__dirname, '..', '.claude', 'agents');
-  const profiles = [];
-
-  function scanDir(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory()) {
-        scanDir(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith('.md')) {
-        profiles.push(fullPath);
-      }
-    }
-  }
-
-  scanDir(agentsDir);
-  return profiles;
-}
-
-/**
- * Format validation results
- */
-function formatResults(results, verbose = false) {
-  const severityColors = {
-    critical: '\x1b[31m', // Red
-    error: '\x1b[31m', // Red
-    high: '\x1b[33m', // Yellow
-    warning: '\x1b[33m', // Yellow
-    medium: '\x1b[36m', // Cyan
-    info: '\x1b[32m', // Green
-  };
-  const reset = '\x1b[0m';
-
-  console.log(`\n${results.valid ? '✅' : '❌'} ${path.basename(results.file)}`);
-
-  if (verbose || !results.valid) {
-    const groupedIssues = {};
-
-    for (const issue of results.issues) {
-      if (!groupedIssues[issue.severity]) {
-        groupedIssues[issue.severity] = [];
-      }
-      groupedIssues[issue.severity].push(issue);
-    }
-
-    for (const [severity, issues] of Object.entries(groupedIssues)) {
-      const color = severityColors[severity] || '';
-      console.log(`\n  ${color}${severity.toUpperCase()}${reset}:`);
-
-      for (const issue of issues) {
-        console.log(`    - ${issue.message}`);
-        if (issue.fix) {
-          console.log(`      Fix: ${issue.fix}`);
-        }
-        if (verbose && issue.pattern) {
-          console.log(`      Pattern: ${issue.pattern}`);
-        }
-      }
-    }
-  }
-
-  return results.valid;
-}
-
-/**
- * Generate summary report
- */
-function generateSummary(allResults) {
-  const total = allResults.length;
-  const valid = allResults.filter((r) => r.valid).length;
-  const invalid = total - valid;
-
-  const issuesBySeverity = {};
-  for (const result of allResults) {
-    for (const issue of result.issues) {
-      issuesBySeverity[issue.severity] = (issuesBySeverity[issue.severity] || 0) + 1;
-    }
-  }
-
-  console.log('\n' + '='.repeat(60));
-  console.log('VALIDATION SUMMARY');
-  console.log('='.repeat(60));
-  console.log(`\nTotal agents: ${total}`);
-  console.log(`Valid: ${valid} ✅`);
-  console.log(`Invalid: ${invalid} ❌`);
-
-  if (Object.keys(issuesBySeverity).length > 0) {
-    console.log('\nIssues by severity:');
-    for (const [severity, count] of Object.entries(issuesBySeverity)) {
-      console.log(`  ${severity}: ${count}`);
-    }
-  }
-
-  console.log('\n' + '='.repeat(60) + '\n');
-
-  return invalid === 0;
-}
-
-// ===== MAIN =====
-
-async function main() {
-  const args = process.argv.slice(2);
-  const flags = {
-    all: args.includes('--all'),
-    ci: args.includes('--ci'),
-    verbose: args.includes('--verbose'),
-  };
-
-  const files = args.filter((arg) => !arg.startsWith('--'));
-
-  let profilesToValidate = [];
-
-  if (flags.all) {
-    profilesToValidate = findAgentProfiles();
-    console.log(`Found ${profilesToValidate.length} agent profiles`);
-  } else if (files.length > 0) {
-    profilesToValidate = files.map((f) => path.resolve(f));
-  } else {
-    console.error('Usage: node validate-agent-hooks.js [--all] [--ci] [--verbose] [file.md...]');
-    process.exit(1);
-  }
-
-  const allResults = [];
-
-  for (const filePath of profilesToValidate) {
-    const results = validateAgentProfile(filePath);
-    allResults.push(results);
-    formatResults(results, flags.verbose);
-  }
-
-  const success = generateSummary(allResults);
-
-  if (flags.ci && !success) {
-    process.exit(1);
-  }
-}
-
-main().catch((error) => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});