claude-flow-novice 2.3.1 → 2.3.3

package/scripts/validate-entry-points.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+/**
+ * Entry Point Validation Script
+ * Validates all package.json entry points work correctly after build
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+// ANSI colors for output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m'
+};
+
+class EntryPointValidator {
+  constructor() {
+    this.results = {
+      passed: [],
+      failed: [],
+      warnings: []
+    };
+  }
+
+  log(message, color = 'reset') {
+    console.log(colors[color] + message + colors.reset);
+  }
+
+  async validatePackageJson() {
+    this.log('\n🔍 Reading package.json...', 'blue');
+
+    const pkgPath = path.join(rootDir, 'package.json');
+    const pkgContent = await fs.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(pkgContent);
+
+    return {
+      main: pkg.main,
+      types: pkg.types,
+      bin: pkg.bin,
+      exports: pkg.exports
+    };
+  }
+
+  async checkFileExists(filePath, description) {
+    const fullPath = path.join(rootDir, filePath);
+
+    try {
+      await fs.access(fullPath);
+      this.log(`  ✓ ${description}: ${filePath}`, 'green');
+      this.results.passed.push({ type: 'file-exists', description, path: filePath });
+      return true;
+    } catch {
+      this.log(`  ✗ ${description}: ${filePath}`, 'red');
+      this.results.failed.push({ type: 'file-missing', description, path: filePath });
+      return false;
+    }
+  }
+
+  async testImport(filePath, description) {
+    const fullPath = path.join(rootDir, filePath);
+
+    try {
+      // Convert to file URL for dynamic import
+      const fileUrl = pathToFileURL(fullPath).href;
+      await import(fileUrl);
+      this.log(`  ✓ ${description}: imports successfully`, 'green');
+      this.results.passed.push({ type: 'import', description, path: filePath });
+      return true;
+    } catch (error) {
+      this.log(`  ✗ ${description}: ${error.message}`, 'red');
+      this.results.failed.push({
+        type: 'import-failed',
+        description,
+        path: filePath,
+        error: error.message
+      });
+      return false;
+    }
+  }
+
+  async validateMainEntry(pkg) {
+    this.log('\n📦 Validating main entry point...', 'blue');
+
+    if (!pkg.main) {
+      this.results.warnings.push('No main entry point defined');
+      this.log('  ⚠ No main entry point defined', 'yellow');
+      return;
+    }
+
+    await this.checkFileExists(pkg.main, 'main');
+    await this.testImport(pkg.main, 'main');
+  }
+
+  async validateTypesEntry(pkg) {
+    this.log('\n📘 Validating TypeScript types...', 'blue');
+
+    if (!pkg.types) {
+      this.results.warnings.push('No types entry point defined');
+      this.log('  ⚠ No types entry point defined', 'yellow');
+      return;
+    }
+
+    await this.checkFileExists(pkg.types, 'types');
+  }
+
+  async validateBinEntries(pkg) {
+    this.log('\n🔧 Validating bin entries...', 'blue');
+
+    if (!pkg.bin) {
+      this.results.warnings.push('No bin entries defined');
+      this.log('  ⚠ No bin entries defined', 'yellow');
+      return;
+    }
+
+    for (const [name, binPath] of Object.entries(pkg.bin)) {
+      await this.checkFileExists(binPath, `bin/${name}`);
+
+      // Check if bin file has shebang
+      try {
+        const fullPath = path.join(rootDir, binPath);
+        const content = await fs.readFile(fullPath, 'utf8');
+        const firstLine = content.split('\n')[0];
+
+        if (!firstLine.startsWith('#!')) {
+          this.results.warnings.push(`bin/${name} missing shebang: ${binPath}`);
+          this.log(`  ⚠ ${name}: missing shebang`, 'yellow');
+        } else {
+          this.log(`  ✓ ${name}: has shebang`, 'gray');
+        }
+      } catch {
+        // File doesn't exist, already reported above
+      }
+    }
+  }
+
+  async validateExports(pkg) {
+    this.log('\n📤 Validating exports...', 'blue');
+
+    if (!pkg.exports) {
+      this.results.warnings.push('No exports defined');
+      this.log('  ⚠ No exports defined', 'yellow');
+      return;
+    }
+
+    for (const [exportName, exportPath] of Object.entries(pkg.exports)) {
+      const description = exportName === '.' ? 'exports (default)' : `exports (${exportName})`;
+      await this.checkFileExists(exportPath, description);
+    }
+  }
+
+  async validateImportable(pkg) {
+    this.log('\n🧪 Testing module imports...', 'blue');
+
+    // Test main entry
+    if (pkg.main) {
+      await this.testImport(pkg.main, 'main entry');
+    }
+
+    // Test key exports
+    const criticalExports = [
+      { key: '.', name: 'default export' },
+      { key: './cli', name: 'CLI export' },
+      { key: './mcp', name: 'MCP export' }
+    ];
+
+    for (const { key, name } of criticalExports) {
+      if (pkg.exports && pkg.exports[key]) {
+        await this.testImport(pkg.exports[key], name);
+      }
+    }
+  }
+
+  async validateBuildStructure() {
+    this.log('\n🏗️  Validating build structure...', 'blue');
+
+    const criticalPaths = [
+      '.claude-flow-novice/dist/src',
+      '.claude-flow-novice/dist/src/cli',
+      '.claude-flow-novice/dist/src/core',
+      '.claude-flow-novice/dist/src/agents'
+    ];
+
+    for (const dirPath of criticalPaths) {
+      await this.checkFileExists(dirPath, `directory: ${dirPath}`);
+    }
+  }
+
+  printSummary() {
+    this.log('\n' + '='.repeat(60), 'blue');
+    this.log('📊 VALIDATION SUMMARY', 'blue');
+    this.log('='.repeat(60), 'blue');
+
+    this.log(`\n✓ Passed: ${this.results.passed.length}`, 'green');
+    this.log(`✗ Failed: ${this.results.failed.length}`, this.results.failed.length > 0 ? 'red' : 'green');
+    this.log(`⚠ Warnings: ${this.results.warnings.length}`, this.results.warnings.length > 0 ? 'yellow' : 'gray');
+
+    if (this.results.failed.length > 0) {
+      this.log('\n❌ FAILURES:', 'red');
+      this.results.failed.forEach(failure => {
+        this.log(`  • ${failure.description}: ${failure.path}`, 'red');
+        if (failure.error) {
+          this.log(`    ${failure.error}`, 'gray');
+        }
+      });
+    }
+
+    if (this.results.warnings.length > 0) {
+      this.log('\n⚠️  WARNINGS:', 'yellow');
+      this.results.warnings.forEach(warning => {
+        this.log(`  • ${warning}`, 'yellow');
+      });
+    }
+
+    const confidence = this.calculateConfidence();
+    this.log(`\n🎯 Confidence Score: ${(confidence * 100).toFixed(1)}%`,
+      confidence >= 0.75 ? 'green' : 'red');
+
+    return {
+      passed: this.results.passed.length,
+      failed: this.results.failed.length,
+      warnings: this.results.warnings.length,
+      confidence,
+      success: this.results.failed.length === 0
+    };
+  }
+
+  calculateConfidence() {
+    const total = this.results.passed.length + this.results.failed.length;
+    if (total === 0) return 0;
+
+    const passRate = this.results.passed.length / total;
+    const warningPenalty = Math.min(this.results.warnings.length * 0.02, 0.1);
+
+    return Math.max(0, Math.min(1, passRate - warningPenalty));
+  }
+
+  async exportReport() {
+    const reportPath = path.join(rootDir, 'entry-points-validation-report.json');
+    const report = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        passed: this.results.passed.length,
+        failed: this.results.failed.length,
+        warnings: this.results.warnings.length,
+        confidence: this.calculateConfidence()
+      },
+      results: this.results
+    };
+
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    this.log(`\n📄 Report exported to: ${reportPath}`, 'blue');
+  }
+
+  async run() {
+    this.log('🚀 Entry Point Validation Starting...', 'blue');
+
+    try {
+      const pkg = await this.validatePackageJson();
+
+      await this.validateBuildStructure();
+      await this.validateMainEntry(pkg);
+      await this.validateTypesEntry(pkg);
+      await this.validateBinEntries(pkg);
+      await this.validateExports(pkg);
+      await this.validateImportable(pkg);
+
+      const summary = this.printSummary();
+      await this.exportReport();
+
+      // Exit with error code if validation failed
+      if (!summary.success) {
+        process.exit(1);
+      }
+
+      this.log('\n✅ All entry points validated successfully!', 'green');
+
+    } catch (error) {
+      this.log(`\n❌ Fatal validation error: ${error.message}`, 'red');
+      console.error(error);
+      process.exit(1);
+    }
+  }
+}
+
+// Run validation
+const validator = new EntryPointValidator();
+validator.run().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/scripts/validate-memory-monitoring.sh

@@ -0,0 +1,225 @@
+#!/bin/bash
+
+# Memory Monitoring Configuration Validation Script
+# Ensures consistent configuration across CFN distributed systems
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+echo "🔍 CFN Memory Monitoring Configuration Validation"
+echo "=================================================="
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+validation_passed=true
+
+# Function to check file exists and report
+check_file() {
+    local file="$1"
+    local description="$2"
+    local required="${3:-true}"
+
+    if [ -f "$file" ]; then
+        echo -e "${GREEN}✓${NC} $description: $file"
+        return 0
+    else
+        if [ "$required" = "true" ]; then
+            echo -e "${RED}✗${NC} $description: $file (MISSING)"
+            validation_passed=false
+            return 1
+        else
+            echo -e "${YELLOW}⚠${NC} $description: $file (OPTIONAL - MISSING)"
+            return 0
+        fi
+    fi
+}
+
+# Function to check if files are identical
+check_identical() {
+    local file1="$1"
+    local file2="$2"
+    local description="$3"
+
+    if [ -f "$file1" ] && [ -f "$file2" ]; then
+        if diff -q "$file1" "$file2" > /dev/null 2>&1; then
+            echo -e "${GREEN}✓${NC} $description: IDENTICAL"
+            return 0
+        else
+            echo -e "${YELLOW}⚠${NC} $description: DIFFERENT"
+            echo "   Differences found between:"
+            echo "   - $file1"
+            echo "   - $file2"
+            return 1
+        fi
+    else
+        echo -e "${RED}✗${NC} $description: One or both files missing"
+        validation_passed=false
+        return 1
+    fi
+}
+
+echo -e "\n${BLUE}📋 Checking Core Configuration Files${NC}"
+
+# Check shared configuration
+CONFIG_FILE="$PROJECT_ROOT/config/memory-monitoring-config.js"
+check_file "$CONFIG_FILE" "Shared Configuration"
+
+# Check core monitoring scripts
+UNIFIED_MONITOR="$PROJECT_ROOT/scripts/unified-memory-monitor.js"
+check_file "$UNIFIED_MONITOR" "Unified Memory Monitor"
+
+ENHANCED_KILLER="$PROJECT_ROOT/scripts/enhanced-memory-spiral-killer.sh"
+check_file "$ENHANCED_KILLER" "Enhanced Memory Spiral Killer"
+
+LEGACY_MONITOR="$PROJECT_ROOT/scripts/memory-monitor-coordinator.js"
+check_file "$LEGACY_MONITOR" "Legacy Memory Monitor"
+
+echo -e "\n${BLUE}🔧 Checking Script Executability${NC}"
+
+if [ -f "$ENHANCED_KILLER" ]; then
+    if [ -x "$ENHANCED_KILLER" ]; then
+        echo -e "${GREEN}✓${NC} Enhanced Memory Spiral Killer is executable"
+    else
+        echo -e "${YELLOW}⚠${NC} Enhanced Memory Spiral Killer is not executable"
+        echo "   Run: chmod +x $ENHANCED_KILLER"
+    fi
+fi
+
+echo -e "\n${BLUE}📊 Validating Configuration Values${NC}"
+
+if [ -f "$CONFIG_FILE" ]; then
+    # Check for key configuration values
+    echo "Checking for required configuration values..."
+
+    if grep -q "cfn-coordinator-mvp" "$CONFIG_FILE"; then
+        echo -e "${GREEN}✓${NC} CFN Coordinator MVP threshold defined"
+    else
+        echo -e "${RED}✗${NC} CFN Coordinator MVP threshold missing"
+        validation_passed=false
+    fi
+
+    if grep -q "growthRateThreshold.*5\.0" "$CONFIG_FILE"; then
+        echo -e "${GREEN}✓${NC} Updated growth rate threshold (5.0 MB/s)"
+    else
+        echo -e "${YELLOW}⚠${NC} Growth rate threshold may be outdated"
+    fi
+
+    if grep -q "sigtermToSigkillDelay.*30000" "$CONFIG_FILE"; then
+        echo -e "${GREEN}✓${NC} Updated SIGTERM to SIGKILL delay (30s)"
+    else
+        echo -e "${YELLOW}⚠${NC} SIGTERM to SIGKILL delay may be outdated"
+    fi
+fi
+
+echo -e "\n${BLUE}🔍 Validating Node.js Scripts${NC}"
+
+# Check if Node.js scripts have proper syntax
+for script in "$UNIFIED_MONITOR" "$LEGACY_MONITOR"; do
+    if [ -f "$script" ]; then
+        if node -c "$script" 2>/dev/null; then
+            echo -e "${GREEN}✓${NC} $(basename "$script"): Valid JavaScript syntax"
+        else
+            echo -e "${RED}✗${NC} $(basename "$script"): Invalid JavaScript syntax"
+            validation_passed=false
+        fi
+    fi
+done
+
+echo -e "\n${BLUE}📋 Checking Documentation${NC}"
+
+DOC_FILE="$PROJECT_ROOT/UNIFIED_MEMORY_MONITORING.md"
+check_file "$DOC_FILE" "Unified Memory Monitoring Documentation" "false"
+
+if [ -f "$DOC_FILE" ]; then
+    if grep -q "CFN Distribution" "$DOC_FILE"; then
+        echo -e "${GREEN}✓${NC} Documentation includes CFN distribution information"
+    fi
+fi
+
+echo -e "\n${BLUE}🔄 Cross-Project Validation${NC}"
+
+# Check if main project exists for comparison
+MAIN_PROJECT="/mnt/c/Users/masha/Documents/claude-flow-novice"
+if [ -d "$MAIN_PROJECT" ]; then
+    echo "Comparing with main project at: $MAIN_PROJECT"
+
+    # Compare configuration files
+    MAIN_CONFIG="$MAIN_PROJECT/config/memory-monitoring-config.js"
+    check_identical "$CONFIG_FILE" "$MAIN_CONFIG" "Configuration Files"
+
+    # Compare core scripts
+    MAIN_UNIFIED="$MAIN_PROJECT/scripts/unified-memory-monitor.js"
+    check_identical "$UNIFIED_MONITOR" "$MAIN_UNIFIED" "Unified Monitor"
+
+    MAIN_ENHANCED="$MAIN_PROJECT/scripts/enhanced-memory-spiral-killer.sh"
+    check_identical "$ENHANCED_KILLER" "$MAIN_ENHANCED" "Enhanced Killer"
+
+    MAIN_LEGACY="$MAIN_PROJECT/scripts/memory-monitor-coordinator.js"
+    check_identical "$LEGACY_MONITOR" "$MAIN_LEGACY" "Legacy Monitor"
+else
+    echo -e "${YELLOW}⚠${NC} Main project not found at: $MAIN_PROJECT"
+    echo "   Cross-project validation skipped"
+fi
+
+echo -e "\n${BLUE}🚀 Functional Testing${NC}"
+
+# Test if unified monitor can start with --help
+if [ -f "$UNIFIED_MONITOR" ]; then
+    if timeout 5 node "$UNIFIED_MONITOR" --help > /dev/null 2>&1; then
+        echo -e "${GREEN}✓${NC} Unified Monitor starts successfully"
+    else
+        echo -e "${YELLOW}⚠${NC} Unified Monitor may have startup issues"
+    fi
+fi
+
+# Test if enhanced killer has proper shebang
+if [ -f "$ENHANCED_KILLER" ]; then
+    if head -1 "$ENHANCED_KILLER" | grep -q "#!/bin/bash"; then
+        echo -e "${GREEN}✓${NC} Enhanced Killer has proper bash shebang"
+    else
+        echo -e "${YELLOW}⚠${NC} Enhanced Killer missing proper shebang"
+    fi
+fi
+
+echo -e "\n${BLUE}📈 Configuration Summary${NC}"
+
+if [ -f "$CONFIG_FILE" ]; then
+    echo "Key Configuration Values:"
+    echo "  - CFN Coordinators: $(grep -o '"cfn-coordinator-[^"]*"[^:]*:[^}]*"memory":[^,}]*' "$CONFIG_FILE" | wc -l) definitions"
+    echo "  - Growth Rate Threshold: $(grep -o "growthRateThreshold.*[0-9.]*" "$CONFIG_FILE" | cut -d':' -f2 | tr -d ' ') MB/s"
+    echo "  - SIGTERM Delay: $(grep -o "sigtermToSigkillDelay.*[0-9]*" "$CONFIG_FILE" | cut -d':' -f2 | tr -d ' ') ms"
+    echo "  - Warning Threshold: $(grep -o "warningThreshold.*[0-9.]*" "$CONFIG_FILE" | cut -d':' -f2 | tr -d ' ')%"
+fi
+
+echo -e "\n${BLUE}🎯 Validation Results${NC}"
+
+if [ "$validation_passed" = true ]; then
+    echo -e "${GREEN}✅ ALL VALIDATIONS PASSED${NC}"
+    echo ""
+    echo "The memory monitoring system is properly configured and ready for CFN distribution."
+    echo ""
+    echo "Next steps:"
+    echo "  1. Test the monitoring scripts in a safe environment"
+    echo "  2. Review the unified documentation"
+    echo "  3. Deploy with confidence that both projects have identical configurations"
+    exit 0
+else
+    echo -e "${RED}❌ VALIDATION FAILED${NC}"
+    echo ""
+    echo "Some issues were found that need to be addressed before CFN distribution:"
+    echo ""
+    echo "Required actions:"
+    echo "  1. Fix missing or misconfigured files"
+    echo "  2. Ensure both projects have identical configurations"
+    echo "  3. Re-run this validation script"
+    echo ""
+    echo "Refer to the unified documentation for troubleshooting guidance."
+    exit 1
+fi