claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/pre-publish-validation.js

@@ -1,429 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Pre-Publish Validation Script
- *
- * Validates that the package is ready for NPM publication
- * Enhanced with package size, coverage, and comprehensive checks
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const projectRoot = path.resolve(__dirname, '..');
-
-console.log('🔍 Running pre-publish validation...\n');
-
-const MAX_PACKAGE_SIZE = 100 * 1024 * 1024; // 100MB
-const MIN_COVERAGE_TARGET = 95; // 95% coverage target
-
-const validations = [
-  {
-    name: 'Build output exists',
-    critical: true,
-    validate: () => {
-      const indexPath = path.join(projectRoot, '.claude-flow-novice/dist/src/index.js');
-      if (!fs.existsSync(indexPath)) {
-        throw new Error('Build output not found. Run "npm run build" first.');
-      }
-      return { passed: true, details: `Found: ${indexPath}` };
-    }
-  },
-  {
-    name: 'Type declarations exist',
-    critical: true,
-    validate: () => {
-      const typesPath = path.join(projectRoot, '.claude-flow-novice/dist/index.d.ts');
-      if (!fs.existsSync(typesPath)) {
-        throw new Error('Type declarations not found. Run "npm run build" first.');
-      }
-      return { passed: true, details: `Found: ${typesPath}` };
-    }
-  },
-  {
-    name: 'Package.json is valid',
-    critical: true,
-    validate: () => {
-      const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
-
-      if (!packageJson.name || !packageJson.version || !packageJson.main) {
-        throw new Error('package.json is missing required fields (name, version, main)');
-      }
-
-      if (!packageJson.types) {
-        throw new Error('package.json is missing "types" field');
-      }
-
-      return {
-        passed: true,
-        details: `${packageJson.name}@${packageJson.version}`
-      };
-    }
-  },
-  {
-    name: 'Entry points are valid',
-    critical: true,
-    validate: () => {
-      const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
-      const mainPath = path.join(projectRoot, packageJson.main);
-      const typesPath = path.join(projectRoot, packageJson.types);
-
-      if (!fs.existsSync(mainPath)) {
-        throw new Error(`Main entry point not found: ${mainPath}`);
-      }
-
-      if (!fs.existsSync(typesPath)) {
-        throw new Error(`Types entry point not found: ${typesPath}`);
-      }
-
-      // Validate exports
-      let exportCount = 0;
-      if (packageJson.exports) {
-        exportCount = Object.keys(packageJson.exports).length;
-      }
-
-      return {
-        passed: true,
-        details: `Main entry valid, ${exportCount} exports defined`
-      };
-    }
-  },
-  {
-    name: 'Binary files exist',
-    critical: true,
-    validate: () => {
-      const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
-      const binaries = [];
-
-      if (packageJson.bin) {
-        for (const [name, filePath] of Object.entries(packageJson.bin)) {
-          const fullPath = path.join(projectRoot, filePath);
-          if (!fs.existsSync(fullPath)) {
-            throw new Error(`Binary file not found: ${name} -> ${fullPath}`);
-          }
-          binaries.push(name);
-        }
-      }
-
-      return {
-        passed: true,
-        details: `${binaries.length} binaries validated: ${binaries.join(', ')}`
-      };
-    }
-  },
-  {
-    name: 'Package size validation',
-    critical: true,
-    validate: () => {
-      try {
-        // Create package tarball temporarily
-        execSync('npm pack', { cwd: projectRoot, stdio: 'pipe' });
-
-        // Find the tarball
-        const files = fs.readdirSync(projectRoot);
-        const tarball = files.find(f => f.startsWith('claude-flow-novice-') && f.endsWith('.tgz'));
-
-        if (!tarball) {
-          throw new Error('Package tarball not found');
-        }
-
-        const tarballPath = path.join(projectRoot, tarball);
-        const stats = fs.statSync(tarballPath);
-        const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-
-        // Clean up tarball
-        fs.unlinkSync(tarballPath);
-
-        if (stats.size > MAX_PACKAGE_SIZE) {
-          throw new Error(`Package size ${sizeMB}MB exceeds 100MB limit`);
-        }
-
-        return {
-          passed: true,
-          details: `Package size: ${sizeMB}MB (within 100MB limit)`
-        };
-      } catch (error) {
-        throw new Error(`Package size check failed: ${error.message}`);
-      }
-    }
-  },
-  {
-    name: 'Test coverage validation',
-    critical: false,
-    validate: () => {
-      const coveragePath = path.join(projectRoot, 'coverage/coverage-summary.json');
-
-      if (!fs.existsSync(coveragePath)) {
-        return {
-          passed: false,
-          details: 'Coverage report not found. Run tests with coverage first.'
-        };
-      }
-
-      const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
-      const total = coverage.total;
-
-      const avgCoverage = Math.round(
-        (total.lines.pct + total.statements.pct + total.functions.pct + total.branches.pct) / 4
-      );
-
-      if (avgCoverage < MIN_COVERAGE_TARGET) {
-        return {
-          passed: false,
-          details: `Coverage ${avgCoverage}% below ${MIN_COVERAGE_TARGET}% target (Lines: ${total.lines.pct}%, Statements: ${total.statements.pct}%, Functions: ${total.functions.pct}%, Branches: ${total.branches.pct}%)`
-        };
-      }
-
-      return {
-        passed: true,
-        details: `Coverage: ${avgCoverage}% (Lines: ${total.lines.pct}%, Statements: ${total.statements.pct}%, Functions: ${total.functions.pct}%, Branches: ${total.branches.pct}%)`
-      };
-    }
-  },
-  {
-    name: 'No source files in distribution',
-    critical: true,
-    validate: () => {
-      const npmignorePath = path.join(projectRoot, '.npmignore');
-
-      if (!fs.existsSync(npmignorePath)) {
-        throw new Error('.npmignore file not found');
-      }
-
-      const npmignore = fs.readFileSync(npmignorePath, 'utf8');
-      const excludedPatterns = ['src/', 'tests/', 'test/', '*.test.js', '*.test.ts'];
-      const missing = excludedPatterns.filter(pattern => !npmignore.includes(pattern));
-
-      if (missing.length > 0) {
-        throw new Error(`Missing exclusions in .npmignore: ${missing.join(', ')}`);
-      }
-
-      return {
-        passed: true,
-        details: 'Source files properly excluded from package'
-      };
-    }
-  },
-  {
-    name: 'Security audit passed',
-    critical: true,
-    validate: () => {
-      try {
-        const result = execSync('npm audit --audit-level moderate', {
-          encoding: 'utf8',
-          stdio: 'pipe',
-          cwd: projectRoot
-        });
-
-        if (result.includes('vulnerabilities')) {
-          const lines = result.split('\n');
-          const vulnLine = lines.find(line => line.includes('vulnerabilities'));
-          if (vulnLine && !vulnLine.includes('0 vulnerabilities')) {
-            throw new Error(`Security issues found: ${vulnLine.trim()}`);
-          }
-        }
-
-        return { passed: true, details: 'No security vulnerabilities detected' };
-      } catch (error) {
-        // npm audit returns non-zero exit code when vulnerabilities found
-        if (error.stdout && error.stdout.includes('vulnerabilities')) {
-          const lines = error.stdout.split('\n');
-          const vulnLine = lines.find(line => line.includes('vulnerabilities'));
-          if (vulnLine && !vulnLine.includes('0 vulnerabilities')) {
-            throw new Error(`Security issues: ${vulnLine.trim()}`);
-          }
-        }
-        throw new Error(`Security audit failed: ${error.message}`);
-      }
-    }
-  },
-  {
-    name: 'Dependencies are up to date',
-    critical: false,
-    validate: () => {
-      try {
-        const result = execSync('npm outdated --json', {
-          encoding: 'utf8',
-          stdio: 'pipe',
-          cwd: projectRoot
-        });
-
-        const outdated = result ? JSON.parse(result) : {};
-        const outdatedCount = Object.keys(outdated).length;
-
-        if (outdatedCount > 0) {
-          const majorUpdates = Object.entries(outdated)
-            .filter(([, info]) => {
-              const current = info.current.split('.')[0];
-              const wanted = info.wanted.split('.')[0];
-              return current !== wanted;
-            });
-
-          if (majorUpdates.length > 0) {
-            const packages = majorUpdates.map(([name]) => name).join(', ');
-            return {
-              passed: false,
-              details: `${majorUpdates.length} major updates available: ${packages}`
-            };
-          }
-        }
-
-        return {
-          passed: true,
-          details: outdatedCount === 0 ? 'All dependencies up to date' : `${outdatedCount} minor updates available`
-        };
-      } catch (error) {
-        // npm outdated returns non-zero when there are outdated packages
-        return { passed: true, details: 'Dependency check completed' };
-      }
-    }
-  },
-  {
-    name: 'Build artifacts integrity',
-    critical: true,
-    validate: () => {
-      const distDir = path.join(projectRoot, '.claude-flow-novice/dist');
-
-      if (!fs.existsSync(distDir)) {
-        throw new Error('Build directory not found');
-      }
-
-      // Check for essential files
-      const essentialFiles = [
-        'src/index.js',
-        'src/cli/index.js',
-        'src/cli/main.js'
-      ];
-
-      const missing = essentialFiles.filter(file =>
-        !fs.existsSync(path.join(distDir, file))
-      );
-
-      if (missing.length > 0) {
-        throw new Error(`Missing build artifacts: ${missing.join(', ')}`);
-      }
-
-      // Count total files
-      const countFiles = (dir) => {
-        let count = 0;
-        const items = fs.readdirSync(dir);
-        items.forEach(item => {
-          const fullPath = path.join(dir, item);
-          if (fs.statSync(fullPath).isDirectory()) {
-            count += countFiles(fullPath);
-          } else {
-            count++;
-          }
-        });
-        return count;
-      };
-
-      const fileCount = countFiles(distDir);
-
-      return {
-        passed: true,
-        details: `${fileCount} files in build output`
-      };
-    }
-  }
-];
-
-// Run validations
-let criticalPassed = true;
-let allPassed = true;
-const results = [];
-
-console.log('═'.repeat(60));
-console.log('Critical Validations:');
-console.log('═'.repeat(60));
-
-validations.filter(v => v.critical).forEach(({ name, validate }) => {
-  try {
-    const result = validate();
-    console.log(`✅ ${name}`);
-    if (result.details) {
-      console.log(`   ${result.details}`);
-    }
-    results.push({ name, passed: true, critical: true, details: result.details });
-  } catch (error) {
-    console.log(`❌ ${name}`);
-    console.log(`   ${error.message}`);
-    criticalPassed = false;
-    allPassed = false;
-    results.push({ name, passed: false, critical: true, error: error.message });
-  }
-});
-
-console.log('\n' + '═'.repeat(60));
-console.log('Optional Validations:');
-console.log('═'.repeat(60));
-
-validations.filter(v => !v.critical).forEach(({ name, validate }) => {
-  try {
-    const result = validate();
-    console.log(`${result.passed ? '✅' : '⚠️'} ${name}`);
-    if (result.details) {
-      console.log(`   ${result.details}`);
-    }
-    results.push({ name, passed: result.passed, critical: false, details: result.details });
-    if (!result.passed) {
-      allPassed = false;
-    }
-  } catch (error) {
-    console.log(`⚠️ ${name}`);
-    console.log(`   ${error.message}`);
-    results.push({ name, passed: false, critical: false, error: error.message });
-    allPassed = false;
-  }
-});
-
-// Generate summary report
-console.log('\n' + '═'.repeat(60));
-console.log('Validation Summary:');
-console.log('═'.repeat(60));
-
-const criticalCount = results.filter(r => r.critical).length;
-const criticalPassedCount = results.filter(r => r.critical && r.passed).length;
-const optionalCount = results.filter(r => !r.critical).length;
-const optionalPassedCount = results.filter(r => !r.critical && r.passed).length;
-
-console.log(`Critical: ${criticalPassedCount}/${criticalCount} passed`);
-console.log(`Optional: ${optionalPassedCount}/${optionalCount} passed`);
-console.log(`Total: ${criticalPassedCount + optionalPassedCount}/${results.length} passed`);
-
-// Save detailed report
-const reportPath = path.join(projectRoot, '.claude-flow-novice/pre-publish-validation-report.json');
-fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-fs.writeFileSync(reportPath, JSON.stringify({
-  timestamp: new Date().toISOString(),
-  summary: {
-    total: results.length,
-    passed: criticalPassedCount + optionalPassedCount,
-    failed: results.length - (criticalPassedCount + optionalPassedCount),
-    criticalPassed: criticalPassedCount,
-    criticalTotal: criticalCount,
-    optionalPassed: optionalPassedCount,
-    optionalTotal: optionalCount
-  },
-  results
-}, null, 2));
-
-console.log(`\n📊 Detailed report saved: ${reportPath}`);
-
-// Exit with appropriate code
-if (!criticalPassed) {
-  console.log('\n❌ Critical validations failed. Package is NOT ready for publication.');
-  console.log('   Please fix critical issues before publishing.\n');
-  process.exit(1);
-} else if (!allPassed) {
-  console.log('\n⚠️ All critical validations passed, but some optional checks failed.');
-  console.log('   Package can be published, but consider addressing warnings.\n');
-  process.exit(0);
-} else {
-  console.log('\n🎉 All validations passed! Package is ready for publication.\n');
-  process.exit(0);
-}

package/dist/scripts/redis-lua/cleanup-blocking-coordination.lua

@@ -1,198 +0,0 @@
---[[
-  cleanup-blocking-coordination.lua
-
-  High-performance Redis Lua script for cleaning up stale blocking coordinator state.
-  Target: <5s for 10,000 coordinators (2,000 coordinators/sec)
-
-  Strategy:
-  1. Single SCAN with high COUNT to minimize round trips
-  2. Batch MGET to retrieve all heartbeat states in one operation
-  3. Filter stale coordinators (startTime < current - 600s)
-  4. Batch collection of all related keys (ACKs, signals, idempotency, activity)
-  5. Batch DEL of all stale keys in one atomic operation
-
-  Safety:
-  - Uses SCAN (non-blocking) for key discovery
-  - TTL-based staleness check (10 minutes = 600 seconds)
-  - Preserves active coordinators
-  - Atomic execution prevents race conditions
-
-  Performance optimizations:
-  - Minimize network round trips (single SCAN, single MGET, single DEL)
-  - Lua execution is atomic and server-side
-  - No inter-command latency
-  - Batch processing reduces overhead
-
-  KEYS: None (discovers keys dynamically)
-  ARGV[1]: Stale threshold in seconds (default: 600)
-  ARGV[2]: Dry run flag (0 = production, 1 = dry run)
-
-  Returns: JSON string with cleanup metrics
-  {
-    "totalCoordinatorsChecked": 0,
-    "staleCoordinatorsFound": 0,
-    "keysDeleted": 0,
-    "executionTimeMs": 0,
-    "staleCoordinatorIds": []
-  }
-]]
-
-local STALE_THRESHOLD_SECONDS = tonumber(ARGV[1]) or 600
-local DRY_RUN = tonumber(ARGV[2]) or 0
-local start_time = redis.call('TIME')
-local start_time_ms = tonumber(start_time[1]) * 1000 + math.floor(tonumber(start_time[2]) / 1000)
-
--- Metrics tracking
-local metrics = {
-  totalCoordinatorsChecked = 0,
-  staleCoordinatorsFound = 0,
-  keysDeleted = 0,
-  executionTimeMs = 0,
-  staleCoordinatorIds = {}
-}
-
--- Helper: Get current timestamp in seconds
-local function current_timestamp_seconds()
-  local time = redis.call('TIME')
-  return tonumber(time[1])
-end
-
--- Helper: Extract coordinator ID from heartbeat key
-local function extract_coordinator_id(heartbeat_key)
-  -- Format: blocking:heartbeat:{coordinatorId}
-  return string.match(heartbeat_key, "^blocking:heartbeat:(.+)$")
-end
-
--- Helper: Parse JSON timestamp from heartbeat value
-local function parse_heartbeat_timestamp(heartbeat_value)
-  -- Format: {"coordinatorId":"...","timestamp":1234567890123,...}
-  local timestamp_ms = string.match(heartbeat_value, '"timestamp":(%d+)')
-  if timestamp_ms then
-    return tonumber(timestamp_ms)
-  end
-  return nil
-end
-
--- Helper: Check if coordinator is stale
-local function is_stale(heartbeat_value, current_time_seconds)
-  local timestamp_ms = parse_heartbeat_timestamp(heartbeat_value)
-  if not timestamp_ms then
-    return false  -- Invalid heartbeat, skip
-  end
-
-  local timestamp_seconds = math.floor(timestamp_ms / 1000)
-  local age_seconds = current_time_seconds - timestamp_seconds
-
-  return age_seconds > STALE_THRESHOLD_SECONDS
-end
-
--- Helper: Collect all related keys for a coordinator
-local function collect_coordinator_keys(coordinator_id)
-  local keys = {}
-
-  -- 1. Heartbeat key
-  table.insert(keys, "blocking:heartbeat:" .. coordinator_id)
-
-  -- 2. Signal ACK keys (blocking:ack:coordinatorId:*)
-  local ack_cursor = "0"
-  repeat
-    local ack_result = redis.call('SCAN', ack_cursor, 'MATCH', 'blocking:ack:' .. coordinator_id .. ':*', 'COUNT', 1000)
-    ack_cursor = ack_result[1]
-    for _, key in ipairs(ack_result[2]) do
-      table.insert(keys, key)
-    end
-  until ack_cursor == "0"
-
-  -- 3. Signal key
-  table.insert(keys, "blocking:signal:" .. coordinator_id)
-
-  -- 4. Idempotency keys (blocking:idempotency:*coordinatorId*)
-  local idemp_cursor = "0"
-  repeat
-    local idemp_result = redis.call('SCAN', idemp_cursor, 'MATCH', 'blocking:idempotency:*' .. coordinator_id .. '*', 'COUNT', 1000)
-    idemp_cursor = idemp_result[1]
-    for _, key in ipairs(idemp_result[2]) do
-      table.insert(keys, key)
-    end
-  until idemp_cursor == "0"
-
-  -- 5. Activity tracking key
-  table.insert(keys, "coordinator:activity:" .. coordinator_id)
-
-  return keys
-end
-
--- Step 1: Scan for all heartbeat keys with high COUNT
-local heartbeat_keys = {}
-local cursor = "0"
-repeat
-  -- Use COUNT 10000 to minimize SCAN iterations
-  local result = redis.call('SCAN', cursor, 'MATCH', 'blocking:heartbeat:*', 'COUNT', 10000)
-  cursor = result[1]
-  for _, key in ipairs(result[2]) do
-    table.insert(heartbeat_keys, key)
-  end
-until cursor == "0"
-
--- Early exit if no coordinators found
-if #heartbeat_keys == 0 then
-  metrics.executionTimeMs = 0
-  return cjson.encode(metrics)
-end
-
-metrics.totalCoordinatorsChecked = #heartbeat_keys
-
--- Step 2: Batch MGET all heartbeat values
-local heartbeat_values = redis.call('MGET', unpack(heartbeat_keys))
-
--- Step 3: Filter stale coordinators and collect all keys to delete
-local current_time_seconds = current_timestamp_seconds()
-local keys_to_delete = {}
-local stale_coordinator_ids = {}
-
-for i, heartbeat_key in ipairs(heartbeat_keys) do
-  local heartbeat_value = heartbeat_values[i]
-
-  if heartbeat_value and is_stale(heartbeat_value, current_time_seconds) then
-    local coordinator_id = extract_coordinator_id(heartbeat_key)
-    if coordinator_id then
-      table.insert(stale_coordinator_ids, coordinator_id)
-
-      -- Collect all related keys for this stale coordinator
-      local coordinator_keys = collect_coordinator_keys(coordinator_id)
-      for _, key in ipairs(coordinator_keys) do
-        table.insert(keys_to_delete, key)
-      end
-    end
-  end
-end
-
-metrics.staleCoordinatorsFound = #stale_coordinator_ids
-metrics.staleCoordinatorIds = stale_coordinator_ids
-
--- Step 4: Batch DEL all stale keys
-if #keys_to_delete > 0 and DRY_RUN == 0 then
-  -- Redis DEL command accepts up to ~1M keys, but we'll batch in chunks of 10000 for safety
-  local batch_size = 10000
-  local deleted_count = 0
-
-  for i = 1, #keys_to_delete, batch_size do
-    local batch_end = math.min(i + batch_size - 1, #keys_to_delete)
-    local batch = {}
-    for j = i, batch_end do
-      table.insert(batch, keys_to_delete[j])
-    end
-    deleted_count = deleted_count + redis.call('DEL', unpack(batch))
-  end
-
-  metrics.keysDeleted = deleted_count
-elseif DRY_RUN == 1 then
-  metrics.keysDeleted = #keys_to_delete  -- Report what would be deleted
-end
-
--- Calculate execution time
-local end_time = redis.call('TIME')
-local end_time_ms = tonumber(end_time[1]) * 1000 + math.floor(tonumber(end_time[2]) / 1000)
-metrics.executionTimeMs = end_time_ms - start_time_ms
-
-return cjson.encode(metrics)