agentic-flow 2.0.1 → 2.0.2-alpha

package/validation/docker/README.md

@@ -1,234 +0,0 @@
-# Docker Validation for ReasoningBank
-
-This directory contains Docker-based validation scripts to test agentic-flow package in clean, isolated environments.
-
-## Purpose
-
-Validates that agentic-flow works correctly when installed via npm/npx in a fresh Node.js environment, testing:
-
-1. **Package Installation** - npm install works correctly
-2. **Backend Selector** - Environment detection functions properly
-3. **Node.js Backend** - SQLite backend initializes and works
-4. **WASM Backend** - WASM module loads and functions in Node.js
-5. **Package Exports** - All export paths resolve correctly
-
-## Quick Start
-
-### Test Local Build
-
-```bash
-# From agentic-flow root directory
-
-# 1. Build the package
-npm run build
-
-# 2. Create package tarball
-npm pack
-
-# 3. Run Docker validation
-cd validation/docker
-docker build -f Dockerfile.reasoningbank-local -t agentic-flow-test:local ../..
-docker run --rm agentic-flow-test:local
-```
-
-### Test Published Version
-
-```bash
-# Test latest published version from npm
-docker build -f Dockerfile.reasoningbank-test -t agentic-flow-test:latest ../..
-docker run --rm agentic-flow-test:latest
-
-# Or use docker-compose
-docker-compose up reasoningbank-test-latest
-```
-
-## Files
-
-| File | Purpose |
-|------|---------|
-| `Dockerfile.reasoningbank-test` | Tests published npm package |
-| `Dockerfile.reasoningbank-local` | Tests local build (npm pack) |
-| `test-reasoningbank-npx.mjs` | Validation test suite |
-| `docker-compose.yml` | Orchestrates multiple test scenarios |
-| `README.md` | This file |
-
-## Test Suite
-
-The validation script (`test-reasoningbank-npx.mjs`) runs:
-
-### Test 1: Package Installation
-- Initializes package.json
-- Installs agentic-flow via npm
-- Verifies installation success
-
-### Test 2: Backend Selector
-- Imports backend-selector module
-- Tests environment detection (expects 'nodejs')
-- Validates backend info structure
-- Checks environment validation
-
-### Test 3: Node.js Backend (SQLite)
-- Creates ReasoningBank with optimal backend
-- Verifies Node.js backend selected
-- Checks db module is present
-- Tests database initialization
-
-### Test 4: WASM Backend
-- Imports WASM adapter
-- Creates WASM ReasoningBank instance
-- Stores test pattern
-- Performs category search
-- Runs semantic similarity search
-- Validates similarity scores
-- Checks stats reporting
-
-### Test 5: Package Exports
-- Tests main export (`agentic-flow`)
-- Tests reasoningbank export (conditional)
-- Tests backend-selector export
-- Tests wasm-adapter export
-
-## Expected Output
-
-```
-🐳 Docker Validation: agentic-flow ReasoningBank
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ Created test directory: /test/validation-workspace
-
-📦 Test 1: Package Installation via npm
-
-   Installing agentic-flow@latest...
-✅ Package installation
-   Installed agentic-flow@1.5.13
-
-🔍 Test 2: Backend Selector Environment Detection
-
-✅ Backend selector import
-   Detected: nodejs
-
-✅ Environment detection
-   Expected nodejs, got nodejs
-
-💾 Test 3: Node.js Backend (SQLite)
-
-✅ Node.js backend initialization
-   SQLite backend loaded
-
-✅ Node.js backend detection
-   db module present
-
-⚡ Test 4: WASM Backend (In-Memory)
-
-✅ WASM backend initialization
-   WASM module loaded
-
-✅ WASM pattern storage
-   In-memory storage works
-
-✅ WASM semantic search
-   Similarity matching works
-
-✅ WASM similarity scoring
-   Score: 0.5401
-
-📦 Test 5: Package Exports
-
-✅ Package exports
-   All import paths valid
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📊 VALIDATION SUMMARY
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Total Tests: 10
-✅ Passed: 10
-❌ Failed: 0
-⏱️  Duration: 45.23s
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-🎉 All tests passed! Package is working correctly.
-```
-
-## Troubleshooting
-
-### Test Failures
-
-If tests fail, check:
-
-1. **Package installation fails**
-   - Verify network connectivity
-   - Check npm registry is accessible
-   - Try with `--registry https://registry.npmjs.org`
-
-2. **Backend selector fails**
-   - Check package.json exports field
-   - Verify conditional exports syntax
-   - Test with `node --experimental-modules`
-
-3. **WASM backend fails**
-   - Ensure `--experimental-wasm-modules` flag is set
-   - Check WASM binary is included in dist/
-   - Verify wasm-pack build completed
-
-4. **SQLite backend fails**
-   - Check better-sqlite3 is in dependencies
-   - Verify native module compilation
-   - Test on matching Node.js version
-
-### Local Testing
-
-To test locally without Docker:
-
-```bash
-cd /tmp
-mkdir reasoningbank-test && cd reasoningbank-test
-npm init -y
-npm install agentic-flow@latest
-
-# Run individual tests
-node --experimental-wasm-modules <<EOF
-import { getRecommendedBackend } from 'agentic-flow/reasoningbank/backend-selector';
-console.log('Backend:', getRecommendedBackend());
-EOF
-```
-
-## CI/CD Integration
-
-Add to GitHub Actions:
-
-```yaml
-- name: Validate agentic-flow in Docker
-  run: |
-    cd validation/docker
-    docker build -f Dockerfile.reasoningbank-local -t test ../..
-    docker run --rm test
-```
-
-## Performance Benchmarks
-
-Expected performance in Docker:
-
-| Operation | Time |
-|-----------|------|
-| Package install | 15-30s |
-| Backend detection | <100ms |
-| WASM initialization | 50-100ms |
-| Pattern storage | 1-5ms |
-| Semantic search | 50-100ms |
-
-## Environment Details
-
-- **Base Image**: `node:20-slim`
-- **Node.js Version**: 20.x LTS
-- **Architecture**: linux/amd64
-- **Dependencies**: git, curl
-
-## Support
-
-If validation fails:
-
-1. Check the [REASONINGBANK_BACKENDS.md](../../docs/REASONINGBANK_BACKENDS.md) guide
-2. Review [IMPLEMENTATION_SUMMARY.md](../../docs/IMPLEMENTATION_SUMMARY.md)
-3. Open an issue at https://github.com/ruvnet/agentic-flow/issues

package/validation/docker/docker-compose.yml

@@ -1,29 +0,0 @@
-version: '3.8'
-
-services:
-  # Test with latest published version from npm
-  reasoningbank-test-latest:
-    build:
-      context: ../..
-      dockerfile: validation/docker/Dockerfile.reasoningbank-test
-    environment:
-      - PACKAGE_VERSION=latest
-      - NODE_ENV=production
-    command: node --experimental-wasm-modules /test/test-reasoningbank-npx.mjs
-    networks:
-      - test-network
-
-  # Test with local build (after npm pack)
-  reasoningbank-test-local:
-    build:
-      context: ../..
-      dockerfile: validation/docker/Dockerfile.reasoningbank-local
-    environment:
-      - NODE_ENV=production
-    command: node --experimental-wasm-modules /test/test-reasoningbank-npx.mjs
-    networks:
-      - test-network
-
-networks:
-  test-network:
-    driver: bridge

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

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