agentic-flow 1.9.0 → 1.9.1

package/validation/docker/test-reasoningbank-npx.mjs

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+/**
+ * Docker Validation Script for ReasoningBank Backends
+ *
+ * Tests agentic-flow package installation via npx and validates:
+ * 1. Backend selector can detect environment
+ * 2. Node.js backend works with SQLite
+ * 3. WASM backend works in Node.js (in-memory)
+ * 4. Package exports work correctly
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const execAsync = promisify(exec);
+
+console.log('🐳 Docker Validation: agentic-flow ReasoningBank\n');
+console.log('━'.repeat(60));
+
+// Test configuration
+const PACKAGE_VERSION = process.env.PACKAGE_VERSION || 'latest';
+const TEST_DIR = '/test/validation-workspace';
+
+// Create test directory
+try {
+  mkdirSync(TEST_DIR, { recursive: true });
+  process.chdir(TEST_DIR);
+  console.log(`✅ Created test directory: ${TEST_DIR}\n`);
+} catch (error) {
+  console.error(`❌ Failed to create test directory: ${error.message}`);
+  process.exit(1);
+}
+
+// Test results tracker
+const results = {
+  passed: 0,
+  failed: 0,
+  tests: []
+};
+
+function recordTest(name, passed, details = '') {
+  results.tests.push({ name, passed, details });
+  if (passed) {
+    results.passed++;
+    console.log(`✅ ${name}`);
+  } else {
+    results.failed++;
+    console.error(`❌ ${name}`);
+  }
+  if (details) {
+    console.log(`   ${details}\n`);
+  }
+}
+
+// Test 1: Install package via npm
+async function testPackageInstallation() {
+  console.log('📦 Test 1: Package Installation via npm\n');
+
+  try {
+    // Initialize package.json
+    writeFileSync(join(TEST_DIR, 'package.json'), JSON.stringify({
+      name: 'reasoningbank-validation',
+      version: '1.0.0',
+      type: 'module',
+      private: true
+    }, null, 2));
+
+    console.log(`   Installing agentic-flow@${PACKAGE_VERSION}...`);
+    const { stdout, stderr } = await execAsync(`npm install agentic-flow@${PACKAGE_VERSION} --no-save`);
+
+    recordTest(
+      'Package installation',
+      true,
+      `Installed agentic-flow@${PACKAGE_VERSION}`
+    );
+    return true;
+  } catch (error) {
+    recordTest(
+      'Package installation',
+      false,
+      `Error: ${error.message}`
+    );
+    return false;
+  }
+}
+
+// Test 2: Backend selector import and environment detection
+async function testBackendSelector() {
+  console.log('🔍 Test 2: Backend Selector Environment Detection\n');
+
+  const testScript = `
+import { getRecommendedBackend, getBackendInfo, validateEnvironment } from 'agentic-flow/reasoningbank/backend-selector';
+
+console.log('Testing backend selector...');
+
+// Test 1: Environment detection
+const backend = getRecommendedBackend();
+console.log('Recommended backend:', backend);
+if (backend !== 'nodejs') {
+  throw new Error('Expected nodejs backend in Node.js environment');
+}
+
+// Test 2: Backend info
+const info = getBackendInfo();
+console.log('Backend info:', JSON.stringify(info, null, 2));
+if (info.backend !== 'nodejs') {
+  throw new Error('Backend info mismatch');
+}
+if (info.environment !== 'nodejs') {
+  throw new Error('Environment detection failed');
+}
+
+// Test 3: Environment validation
+const validation = validateEnvironment();
+console.log('Environment validation:', JSON.stringify(validation, null, 2));
+if (!validation.valid) {
+  console.warn('Warnings:', validation.warnings);
+}
+
+console.log('✅ Backend selector tests passed');
+`;
+
+  try {
+    writeFileSync(join(TEST_DIR, 'test-selector.mjs'), testScript);
+    const { stdout, stderr } = await execAsync('node test-selector.mjs');
+
+    const detectedBackend = stdout.match(/Recommended backend: (\w+)/)?.[1];
+
+    recordTest(
+      'Backend selector import',
+      true,
+      `Detected: ${detectedBackend}`
+    );
+
+    recordTest(
+      'Environment detection',
+      detectedBackend === 'nodejs',
+      `Expected nodejs, got ${detectedBackend}`
+    );
+
+    return true;
+  } catch (error) {
+    recordTest(
+      'Backend selector',
+      false,
+      `Error: ${error.message}\n${error.stderr || ''}`
+    );
+    return false;
+  }
+}
+
+// Test 3: Node.js backend (SQLite)
+async function testNodeBackend() {
+  console.log('💾 Test 3: Node.js Backend (SQLite)\n');
+
+  const testScript = `
+import { createOptimalReasoningBank } from 'agentic-flow/reasoningbank/backend-selector';
+
+console.log('Testing Node.js backend with SQLite...');
+
+// Create ReasoningBank instance
+const rb = await createOptimalReasoningBank('test-db', {
+  dbPath: '.test-swarm/memory.db',
+  verbose: true
+});
+
+console.log('✅ ReasoningBank instance created');
+
+// Test that we got the Node.js backend
+if (!rb.db) {
+  throw new Error('Expected Node.js backend with db module');
+}
+
+console.log('✅ Node.js backend detected (has db module)');
+
+// Check if database was initialized
+try {
+  const stats = await rb.db.getDb();
+  console.log('✅ Database connection verified');
+} catch (error) {
+  console.log('Note: Database not fully initialized, but module loaded correctly');
+}
+
+console.log('✅ Node.js backend tests passed');
+`;
+
+  try {
+    writeFileSync(join(TEST_DIR, 'test-node-backend.mjs'), testScript);
+    const { stdout, stderr } = await execAsync('node test-node-backend.mjs');
+
+    recordTest(
+      'Node.js backend initialization',
+      stdout.includes('ReasoningBank instance created'),
+      'SQLite backend loaded'
+    );
+
+    recordTest(
+      'Node.js backend detection',
+      stdout.includes('Node.js backend detected'),
+      'db module present'
+    );
+
+    return true;
+  } catch (error) {
+    recordTest(
+      'Node.js backend',
+      false,
+      `Error: ${error.message}\n${error.stderr || ''}`
+    );
+    return false;
+  }
+}
+
+// Test 4: WASM backend
+async function testWasmBackend() {
+  console.log('⚡ Test 4: WASM Backend (In-Memory)\n');
+
+  const testScript = `
+import { createReasoningBank } from 'agentic-flow/reasoningbank/wasm-adapter';
+
+console.log('Testing WASM backend...');
+
+// Create WASM instance
+const rb = await createReasoningBank('wasm-test');
+console.log('✅ WASM ReasoningBank instance created');
+
+// Store a pattern
+const patternId = await rb.storePattern({
+  task_description: 'Test pattern for Docker validation',
+  task_category: 'docker-test',
+  strategy: 'validation',
+  success_score: 0.95
+});
+
+console.log('✅ Pattern stored:', patternId);
+
+// Search by category
+const patterns = await rb.searchByCategory('docker-test', 10);
+console.log('✅ Category search returned', patterns.length, 'patterns');
+
+if (patterns.length !== 1) {
+  throw new Error('Expected 1 pattern, got ' + patterns.length);
+}
+
+// Semantic search
+const similar = await rb.findSimilar('test validation', 'docker-test', 5);
+console.log('✅ Semantic search returned', similar.length, 'results');
+
+if (similar.length === 0) {
+  throw new Error('Expected at least 1 similar pattern');
+}
+
+const score = similar[0].similarity_score;
+console.log('   Similarity score:', score);
+
+if (score < 0.3 || score > 1.0) {
+  throw new Error('Similarity score out of range: ' + score);
+}
+
+// Get stats
+const stats = await rb.getStats();
+console.log('✅ Stats:', JSON.stringify(stats, null, 2));
+
+if (stats.total_patterns !== 1) {
+  throw new Error('Expected 1 pattern in stats, got ' + stats.total_patterns);
+}
+
+console.log('✅ WASM backend tests passed');
+`;
+
+  try {
+    writeFileSync(join(TEST_DIR, 'test-wasm-backend.mjs'), testScript);
+    const { stdout, stderr } = await execAsync('node --experimental-wasm-modules test-wasm-backend.mjs');
+
+    recordTest(
+      'WASM backend initialization',
+      stdout.includes('WASM ReasoningBank instance created'),
+      'WASM module loaded'
+    );
+
+    recordTest(
+      'WASM pattern storage',
+      stdout.includes('Pattern stored:'),
+      'In-memory storage works'
+    );
+
+    recordTest(
+      'WASM semantic search',
+      stdout.includes('Semantic search returned'),
+      'Similarity matching works'
+    );
+
+    const scoreMatch = stdout.match(/Similarity score: ([\d.]+)/);
+    if (scoreMatch) {
+      const score = parseFloat(scoreMatch[1]);
+      recordTest(
+        'WASM similarity scoring',
+        score >= 0.3 && score <= 1.0,
+        `Score: ${score.toFixed(4)}`
+      );
+    }
+
+    return true;
+  } catch (error) {
+    recordTest(
+      'WASM backend',
+      false,
+      `Error: ${error.message}\n${error.stderr || ''}`
+    );
+    return false;
+  }
+}
+
+// Test 5: Package exports
+async function testPackageExports() {
+  console.log('📦 Test 5: Package Exports\n');
+
+  const testScript = `
+// Test ReasoningBank export paths
+// Note: Main export requires Claude Code binary, skip in Docker
+
+try {
+  const reasoningbank = await import('agentic-flow/reasoningbank');
+  console.log('✅ reasoningbank export works (auto-selects Node.js)');
+  if (!reasoningbank.db) {
+    throw new Error('Expected db module in reasoningbank export');
+  }
+} catch (error) {
+  console.error('❌ reasoningbank export failed:', error.message);
+  throw error;
+}
+
+try {
+  const selector = await import('agentic-flow/reasoningbank/backend-selector');
+  console.log('✅ backend-selector export works');
+  if (typeof selector.createOptimalReasoningBank !== 'function') {
+    throw new Error('Expected createOptimalReasoningBank function');
+  }
+  if (typeof selector.getRecommendedBackend !== 'function') {
+    throw new Error('Expected getRecommendedBackend function');
+  }
+} catch (error) {
+  console.error('❌ backend-selector export failed:', error.message);
+  throw error;
+}
+
+try {
+  const wasm = await import('agentic-flow/reasoningbank/wasm-adapter');
+  console.log('✅ wasm-adapter export works');
+  if (typeof wasm.createReasoningBank !== 'function') {
+    throw new Error('Expected createReasoningBank function');
+  }
+  if (!wasm.ReasoningBankAdapter) {
+    throw new Error('Expected ReasoningBankAdapter class');
+  }
+} catch (error) {
+  console.error('❌ wasm-adapter export failed:', error.message);
+  throw error;
+}
+
+console.log('✅ All ReasoningBank exports working');
+`;
+
+  try {
+    writeFileSync(join(TEST_DIR, 'test-exports.mjs'), testScript);
+    // Use --experimental-wasm-modules flag for WASM import
+    const { stdout, stderr } = await execAsync('node --experimental-wasm-modules test-exports.mjs');
+
+    recordTest(
+      'ReasoningBank exports',
+      stdout.includes('All ReasoningBank exports working'),
+      'All ReasoningBank import paths valid'
+    );
+
+    return true;
+  } catch (error) {
+    recordTest(
+      'Package exports',
+      false,
+      `Error: ${error.message}\n${error.stderr || ''}`
+    );
+    return false;
+  }
+}
+
+// Run all tests
+async function runAllTests() {
+  console.log(`📋 Running validation tests for agentic-flow@${PACKAGE_VERSION}\n`);
+  console.log('━'.repeat(60) + '\n');
+
+  const startTime = Date.now();
+
+  // Run tests sequentially
+  await testPackageInstallation();
+  await testBackendSelector();
+  await testNodeBackend();
+  await testWasmBackend();
+  await testPackageExports();
+
+  const duration = Date.now() - startTime;
+
+  // Print summary
+  console.log('\n' + '━'.repeat(60));
+  console.log('📊 VALIDATION SUMMARY');
+  console.log('━'.repeat(60) + '\n');
+
+  console.log(`Total Tests: ${results.tests.length}`);
+  console.log(`✅ Passed: ${results.passed}`);
+  console.log(`❌ Failed: ${results.failed}`);
+  console.log(`⏱️  Duration: ${(duration / 1000).toFixed(2)}s\n`);
+
+  // Detailed results
+  if (results.failed > 0) {
+    console.log('Failed Tests:');
+    results.tests
+      .filter(t => !t.passed)
+      .forEach(t => {
+        console.log(`  ❌ ${t.name}`);
+        if (t.details) console.log(`     ${t.details}`);
+      });
+    console.log('');
+  }
+
+  console.log('━'.repeat(60));
+
+  // Exit with appropriate code
+  if (results.failed === 0) {
+    console.log('\n🎉 All tests passed! Package is working correctly.\n');
+    process.exit(0);
+  } else {
+    console.log('\n❌ Some tests failed. Review the output above.\n');
+    process.exit(1);
+  }
+}
+
+// Execute
+runAllTests().catch(error => {
+  console.error('\n💥 Fatal error during validation:', error);
+  process.exit(1);
+});

package/validation/docker-e2e-validation.sh

@@ -0,0 +1,212 @@
+#!/bin/bash
+# Docker E2E Validation for agentic-flow v1.5.10
+# Tests ReasoningBank WASM and QUIC in clean container environment
+
+set -e
+
+echo "🐳 agentic-flow v1.5.10 - Docker E2E Validation"
+echo "================================================"
+echo ""
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Test results
+PASSED=0
+FAILED=0
+TOTAL=0
+
+# Function to run test
+run_test() {
+    local test_name="$1"
+    local test_cmd="$2"
+
+    TOTAL=$((TOTAL + 1))
+    echo -n "Testing: $test_name... "
+
+    if eval "$test_cmd" > /dev/null 2>&1; then
+        echo -e "${GREEN}✓ PASS${NC}"
+        PASSED=$((PASSED + 1))
+        return 0
+    else
+        echo -e "${RED}✗ FAIL${NC}"
+        FAILED=$((FAILED + 1))
+        return 1
+    fi
+}
+
+# Test 1: Package Installation
+echo "📦 Step 1: Package Installation Test"
+echo "======================================"
+run_test "npm install" "npm install"
+run_test "Build project" "npm run build"
+echo ""
+
+# Test 2: ReasoningBank WASM Tests
+echo "🧠 Step 2: ReasoningBank WASM Tests"
+echo "======================================"
+run_test "WASM E2E suite" "npm run test:wasm:e2e"
+run_test "WASM files exist" "test -f wasm/reasoningbank/reasoningbank_wasm_bg.wasm"
+run_test "WASM size correct" "test $(stat -f%z wasm/reasoningbank/reasoningbank_wasm_bg.wasm 2>/dev/null || stat -c%s wasm/reasoningbank/reasoningbank_wasm_bg.wasm) -gt 200000"
+echo ""
+
+# Test 3: Performance Benchmarks
+echo "⚡ Step 3: Performance Benchmarks"
+echo "=================================="
+echo "Running performance tests..."
+
+# Create test file
+cat > /tmp/perf-test.mjs << 'EOF'
+import { createReasoningBank } from './dist/reasoningbank/wasm-adapter.js';
+
+async function testPerformance() {
+    const rb = await createReasoningBank('perf-test');
+    const iterations = 10;
+    const start = Date.now();
+
+    for (let i = 0; i < iterations; i++) {
+        await rb.storePattern({
+            task_description: `Performance test ${i}`,
+            task_category: 'benchmark',
+            strategy: 'speed-test',
+            success_score: 0.85
+        });
+    }
+
+    const duration = Date.now() - start;
+    const avgTime = duration / iterations;
+
+    console.log(JSON.stringify({
+        iterations,
+        totalDuration: duration,
+        avgTime,
+        opsPerSec: Math.round(1000 / avgTime)
+    }));
+
+    // Verify performance targets
+    if (avgTime > 100) {
+        process.exit(1); // Fail if too slow
+    }
+}
+
+testPerformance().catch(err => {
+    console.error('Performance test failed:', err);
+    process.exit(1);
+});
+EOF
+
+if node /tmp/perf-test.mjs 2>&1 | grep -q '"avgTime"'; then
+    PERF_RESULTS=$(node /tmp/perf-test.mjs 2>&1)
+    AVG_TIME=$(echo "$PERF_RESULTS" | grep -o '"avgTime":[0-9.]*' | cut -d: -f2)
+
+    if (( $(echo "$AVG_TIME < 100" | bc -l) )); then
+        echo -e "  Average time per operation: ${GREEN}${AVG_TIME}ms${NC} ✓"
+        PASSED=$((PASSED + 1))
+    else
+        echo -e "  Average time per operation: ${RED}${AVG_TIME}ms${NC} ✗ (target: <100ms)"
+        FAILED=$((FAILED + 1))
+    fi
+    TOTAL=$((TOTAL + 1))
+else
+    echo -e "  ${RED}✗ Performance test failed${NC}"
+    FAILED=$((FAILED + 1))
+    TOTAL=$((TOTAL + 1))
+fi
+
+rm -f /tmp/perf-test.mjs
+echo ""
+
+# Test 4: Memory Leak Detection
+echo "💾 Step 4: Memory Leak Detection"
+echo "=================================="
+cat > /tmp/memory-test.mjs << 'EOF'
+import { createReasoningBank } from './dist/reasoningbank/wasm-adapter.js';
+
+async function testMemory() {
+    const initialMem = process.memoryUsage().heapUsed;
+    const rb = await createReasoningBank('memory-test');
+
+    for (let i = 0; i < 100; i++) {
+        await rb.storePattern({
+            task_description: `Memory test ${i}`,
+            task_category: 'memory',
+            strategy: 'stability',
+            success_score: 0.9
+        });
+    }
+
+    if (global.gc) global.gc();
+    const finalMem = process.memoryUsage().heapUsed;
+    const memDelta = (finalMem - initialMem) / 1024 / 1024;
+
+    console.log(JSON.stringify({
+        initialMB: Math.round(initialMem / 1024 / 1024),
+        finalMB: Math.round(finalMem / 1024 / 1024),
+        deltaMB: Math.round(memDelta * 100) / 100
+    }));
+
+    // Fail if memory leak > 50MB
+    if (memDelta > 50) {
+        process.exit(1);
+    }
+}
+
+testMemory().catch(err => {
+    console.error('Memory test failed:', err);
+    process.exit(1);
+});
+EOF
+
+if node --expose-gc /tmp/memory-test.mjs 2>&1 | grep -q '"deltaMB"'; then
+    MEM_RESULTS=$(node --expose-gc /tmp/memory-test.mjs 2>&1)
+    MEM_DELTA=$(echo "$MEM_RESULTS" | grep -o '"deltaMB":[0-9.-]*' | cut -d: -f2)
+
+    if (( $(echo "$MEM_DELTA < 50" | bc -l) )); then
+        echo -e "  Memory delta after 100 ops: ${GREEN}${MEM_DELTA}MB${NC} ✓"
+        PASSED=$((PASSED + 1))
+    else
+        echo -e "  Memory delta: ${RED}${MEM_DELTA}MB${NC} ✗ (threshold: <50MB)"
+        FAILED=$((FAILED + 1))
+    fi
+    TOTAL=$((TOTAL + 1))
+else
+    echo -e "  ${RED}✗ Memory test failed${NC}"
+    FAILED=$((FAILED + 1))
+    TOTAL=$((TOTAL + 1))
+fi
+
+rm -f /tmp/memory-test.mjs
+echo ""
+
+# Test 5: QUIC Implementation Status
+echo "🚀 Step 5: QUIC Implementation Check"
+echo "======================================"
+run_test "QUIC transport compiled" "test -f dist/transport/quic.js"
+run_test "QUIC config compiled" "test -f dist/config/quic.js"
+run_test "QUIC proxy compiled" "test -f dist/proxy/quic-proxy.js"
+echo ""
+
+# Summary
+echo "================================================"
+echo "📊 Test Summary"
+echo "================================================"
+echo ""
+echo "Total Tests: $TOTAL"
+echo -e "Passed: ${GREEN}$PASSED${NC}"
+echo -e "Failed: ${RED}$FAILED${NC}"
+echo ""
+
+if [ $FAILED -eq 0 ]; then
+    echo -e "${GREEN}✅ ALL TESTS PASSED!${NC}"
+    echo ""
+    echo "agentic-flow v1.5.10 is READY FOR PUBLICATION"
+    exit 0
+else
+    echo -e "${RED}❌ SOME TESTS FAILED${NC}"
+    echo ""
+    echo "Please fix failing tests before publishing"
+    exit 1
+fi

package/validation/docker-quic-test.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+#
+# Docker-based QUIC transport validation
+# Tests QUIC integration in a clean containerized environment
+#
+
+set -e
+
+echo "🐳 QUIC Transport Docker Validation"
+echo "===================================="
+echo ""
+
+# Build Docker image
+echo "📦 Building Docker test image..."
+docker build -f Dockerfile.quic-test -t agentic-flow-quic-test . || {
+    echo "❌ Docker build failed"
+    exit 1
+}
+
+echo ""
+echo "✅ Docker image built successfully"
+echo ""
+
+# Run tests in container
+echo "🧪 Running QUIC tests in Docker container..."
+echo ""
+
+docker run --rm agentic-flow-quic-test || {
+    echo ""
+    echo "❌ Docker tests failed"
+    exit 1
+}
+
+echo ""
+echo "✅ All Docker-based QUIC tests passed!"
+echo ""
+echo "📊 Validation Summary:"
+echo "   ✓ WASM bindings load in containerized environment"
+echo "   ✓ Package exports are correctly configured"
+echo "   ✓ Dependencies resolve properly"
+echo "   ✓ Integration works in production-like setup"
+echo ""