agentic-flow 1.5.12 → 1.6.0

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-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 ""

package/validation/docker-quic-validation.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+# Docker QUIC Validation Script
+# Runs comprehensive QUIC tests in isolated Docker environment
+
+set -e
+
+echo "🐳 QUIC Docker Validation Suite"
+echo "================================"
+echo ""
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Navigate to package directory
+cd "$(dirname "$0")/.."
+
+echo "📦 Building Docker validation image..."
+docker build -f Dockerfile.quic-validation -t agentic-flow-quic-validation . 2>&1 | tail -20
+
+if [ $? -ne 0 ]; then
+  echo -e "${RED}❌ Docker build failed${NC}"
+  exit 1
+fi
+
+echo -e "${GREEN}✅ Docker image built successfully${NC}"
+echo ""
+
+echo "🧪 Running QUIC validation tests in Docker..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+# Run validation container
+docker run --rm \
+  --name quic-validation \
+  -e QUIC_PORT=4433 \
+  -e NODE_ENV=production \
+  agentic-flow-quic-validation
+
+VALIDATION_RESULT=$?
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+if [ $VALIDATION_RESULT -eq 0 ]; then
+  echo -e "${GREEN}✅ All QUIC validations passed in Docker!${NC}"
+  echo ""
+  echo "✨ QUIC is ready for:"
+  echo "  • npm publish"
+  echo "  • Remote deployment"
+  echo "  • Production use"
+  exit 0
+else
+  echo -e "${RED}❌ QUIC validation failed in Docker${NC}"
+  echo ""
+  echo "⚠️  Issues detected - fix before publishing"
+  exit 1
+fi