claude-flow-novice 2.2.4 → 2.2.5

package/scripts/utils/simple-test-fixer.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * Simple ES module test file fixer
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+
+async function findTestFiles() {
+  const testFiles = [];
+
+  async function walkDir(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Skip node_modules, dist, bin directories
+        if (!['node_modules', 'dist', 'bin', '.git'].includes(entry.name)) {
+          await walkDir(fullPath);
+        }
+      } else if (entry.isFile() && (entry.name.endsWith('.test.js') || entry.name.endsWith('.spec.js'))) {
+        testFiles.push(fullPath);
+      }
+    }
+  }
+
+  await walkDir(projectRoot);
+  return testFiles;
+}
+
+function fixImportExtensions(content) {
+  const changes = [];
+
+  // Fix relative imports without .js extension
+  let newContent = content.replace(
+    /import\s+(.+?)\s+from\s+['"`](\.\/.+?)['"`];?/g,
+    (match, imported, modulePath) => {
+      if (!modulePath.endsWith('.js') && !modulePath.endsWith('.ts') && !modulePath.includes('node_modules')) {
+        // Check if it's a relative import
+        if (modulePath.startsWith('./') || modulePath.startsWith('../')) {
+          const correctedPath = modulePath + '.js';
+          changes.push('Add .js extension to relative import');
+          return `import ${imported} from '${correctedPath}';`;
+        }
+      }
+      return match;
+    }
+  );
+
+  return { content: newContent, changes };
+}
+
+function fixJestImports(content) {
+  const changes = [];
+
+  // Add Jest globals import if test functions are used but not imported
+  const hasJestFunctions = /\b(describe|test|it|expect|beforeEach|afterEach|beforeAll|afterAll)\b/.test(content);
+  const hasJestImport = /import.*@jest\/globals/.test(content);
+
+  if (hasJestFunctions && !hasJestImport) {
+    // Check which Jest functions are used
+    const jestFunctions = ['describe', 'test', 'it', 'expect', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll'];
+    const usedFunctions = jestFunctions.filter(fn => new RegExp(`\\b${fn}\\b`).test(content));
+
+    if (usedFunctions.length > 0) {
+      const jestImport = `import { ${usedFunctions.join(', ')} } from '@jest/globals';\n`;
+      content = jestImport + content;
+      changes.push('Add Jest globals import');
+    }
+  }
+
+  return { content, changes };
+}
+
+function fixDirnameFilename(content) {
+  const changes = [];
+
+  const hasDirname = /__dirname/.test(content);
+  const hasFilename = /__filename/.test(content);
+
+  if (hasDirname || hasFilename) {
+    // Add ES module equivalents at the top
+    const imports = [];
+    if (!content.includes('import { fileURLToPath }')) {
+      imports.push("import { fileURLToPath } from 'url';");
+      imports.push("import { dirname } from 'path';");
+    }
+
+    if (hasDirname && !content.includes('const __dirname')) {
+      imports.push("const __filename = fileURLToPath(import.meta.url);");
+      imports.push("const __dirname = dirname(__filename);");
+    } else if (hasFilename && !content.includes('const __filename')) {
+      imports.push("const __filename = fileURLToPath(import.meta.url);");
+    }
+
+    if (imports.length > 0) {
+      content = imports.join('\n') + '\n' + content;
+      changes.push('Add ES module __dirname/__filename equivalents');
+    }
+  }
+
+  return { content, changes };
+}
+
+async function fixTestFile(filePath) {
+  const result = {
+    file: filePath,
+    changes: [],
+    success: false
+  };
+
+  try {
+    const originalContent = await fs.readFile(filePath, 'utf8');
+    let content = originalContent;
+
+    // Apply fixes
+    const importFixes = fixImportExtensions(content);
+    content = importFixes.content;
+    result.changes.push(...importFixes.changes);
+
+    const jestFixes = fixJestImports(content);
+    content = jestFixes.content;
+    result.changes.push(...jestFixes.changes);
+
+    const dirnameFixes = fixDirnameFilename(content);
+    content = dirnameFixes.content;
+    result.changes.push(...dirnameFixes.changes);
+
+    // Only write if changes were made
+    if (content !== originalContent) {
+      await fs.writeFile(filePath, content, 'utf8');
+      result.success = true;
+    } else {
+      result.success = true; // No changes needed
+    }
+
+  } catch (error) {
+    result.error = error.message;
+  }
+
+  return result;
+}
+
+async function main() {
+  console.log('🚀 Starting ES module test file migration...\n');
+  console.log(`Project root: ${projectRoot}`);
+
+  try {
+    const testFiles = await findTestFiles();
+    console.log(`Found ${testFiles.length} test files to process...`);
+
+    const results = [];
+    for (const file of testFiles) {
+      const result = await fixTestFile(file);
+      results.push(result);
+
+      if (result.success && result.changes.length > 0) {
+        console.log(`✅ Fixed ${path.relative(projectRoot, file)}: ${result.changes.join(', ')}`);
+      } else if (!result.success) {
+        console.log(`❌ Failed to fix ${path.relative(projectRoot, file)}: ${result.error}`);
+      }
+    }
+
+    // Summary
+    const fixedFiles = results.filter(r => r.success && r.changes.length > 0);
+    const totalChanges = results.reduce((sum, r) => sum + r.changes.length, 0);
+
+    console.log('\n📊 Migration Summary:');
+    console.log(`- Total files processed: ${results.length}`);
+    console.log(`- Files with fixes: ${fixedFiles.length}`);
+    console.log(`- Total changes applied: ${totalChanges}`);
+
+    console.log('\n✅ ES module test file migration completed!');
+
+  } catch (error) {
+    console.error('❌ Migration failed:', error);
+    process.exit(1);
+  }
+}
+
+main();

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

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