agentic-flow 1.9.0 → 1.9.2

package/validation/test-regression.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+/**
+ * Regression Test Suite for agentic-flow v1.5.13
+ *
+ * Tests to ensure no regressions were introduced by:
+ * - Backend selector implementation
+ * - Package exports updates
+ * - Documentation changes
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+
+console.log('🧪 Regression Test Suite - agentic-flow v1.5.13\n');
+console.log('━'.repeat(60) + '\n');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`✅ ${name}`);
+    passed++;
+  } catch (error) {
+    console.error(`❌ ${name}`);
+    console.error(`   Error: ${error.message}`);
+    failed++;
+  }
+}
+
+async function testAsync(name, fn) {
+  try {
+    await fn();
+    console.log(`✅ ${name}`);
+    passed++;
+  } catch (error) {
+    console.error(`❌ ${name}`);
+    console.error(`   Error: ${error.message}`);
+    failed++;
+  }
+}
+
+// Test 1: Backend Selector Module Exports
+console.log('📦 Test Group 1: Backend Selector Module\n');
+
+await testAsync('Import backend-selector module', async () => {
+  const module = await import('../dist/reasoningbank/backend-selector.js');
+  if (!module.getRecommendedBackend) throw new Error('Missing getRecommendedBackend');
+  if (!module.createOptimalReasoningBank) throw new Error('Missing createOptimalReasoningBank');
+  if (!module.validateEnvironment) throw new Error('Missing validateEnvironment');
+});
+
+await testAsync('getRecommendedBackend() returns valid backend', async () => {
+  const { getRecommendedBackend } = await import('../dist/reasoningbank/backend-selector.js');
+  const backend = getRecommendedBackend();
+  if (backend !== 'nodejs' && backend !== 'wasm') {
+    throw new Error(`Invalid backend: ${backend}`);
+  }
+});
+
+await testAsync('getBackendInfo() returns valid structure', async () => {
+  const { getBackendInfo } = await import('../dist/reasoningbank/backend-selector.js');
+  const info = getBackendInfo();
+  if (!info.backend) throw new Error('Missing backend field');
+  if (!info.environment) throw new Error('Missing environment field');
+  if (!info.features) throw new Error('Missing features field');
+  if (!info.storage) throw new Error('Missing storage field');
+});
+
+await testAsync('validateEnvironment() returns validation object', async () => {
+  const { validateEnvironment } = await import('../dist/reasoningbank/backend-selector.js');
+  const result = validateEnvironment();
+  if (typeof result.valid !== 'boolean') throw new Error('Missing valid field');
+  if (!Array.isArray(result.warnings)) throw new Error('Warnings should be array');
+  if (!result.backend) throw new Error('Missing backend field');
+});
+
+console.log('');
+
+// Test 2: ReasoningBank Core Module (Node.js backend)
+console.log('📦 Test Group 2: ReasoningBank Core Module\n');
+
+await testAsync('Import reasoningbank index module', async () => {
+  const module = await import('../dist/reasoningbank/index.js');
+  if (!module.initialize) throw new Error('Missing initialize function');
+  if (!module.db) throw new Error('Missing db module');
+  if (!module.retrieveMemories) throw new Error('Missing retrieveMemories');
+});
+
+await testAsync('db module has required functions', async () => {
+  const { db } = await import('../dist/reasoningbank/index.js');
+  if (!db.runMigrations) throw new Error('Missing runMigrations');
+  if (!db.getDb) throw new Error('Missing getDb');
+  if (!db.fetchMemoryCandidates) throw new Error('Missing fetchMemoryCandidates');
+});
+
+console.log('');
+
+// Test 3: WASM Adapter Module
+console.log('📦 Test Group 3: WASM Adapter Module (Note: WASM requires --experimental-wasm-modules)\n');
+
+test('WASM adapter file exists', () => {
+  if (!existsSync('./dist/reasoningbank/wasm-adapter.js')) {
+    throw new Error('wasm-adapter.js missing');
+  }
+});
+
+test('WASM binary exists', () => {
+  if (!existsSync('./wasm/reasoningbank/reasoningbank_wasm_bg.wasm')) {
+    throw new Error('WASM binary missing');
+  }
+});
+
+console.log('   ℹ️  WASM import tests skipped (require --experimental-wasm-modules flag)');
+
+console.log('');
+
+// Test 4: Package Exports Resolution
+console.log('📦 Test Group 4: Package Exports\n');
+
+await testAsync('Main export resolves', async () => {
+  try {
+    // This will fail without Claude Code, but should resolve
+    await import('../dist/index.js');
+  } catch (error) {
+    // Expected to fail in test environment, just check it resolves
+    if (error.code === 'ERR_MODULE_NOT_FOUND') throw error;
+    // Other errors are OK (e.g., missing Claude Code binary)
+  }
+});
+
+await testAsync('reasoningbank export resolves (Node.js)', async () => {
+  // In Node.js, should resolve to index.js
+  const module = await import('../dist/reasoningbank/index.js');
+  if (!module.db) throw new Error('Should have db module in Node.js');
+});
+
+await testAsync('backend-selector export resolves', async () => {
+  const module = await import('../dist/reasoningbank/backend-selector.js');
+  if (!module.createOptimalReasoningBank) throw new Error('Missing main function');
+});
+
+test('wasm-adapter export path exists', () => {
+  if (!existsSync('./dist/reasoningbank/wasm-adapter.js')) {
+    throw new Error('wasm-adapter.js not found');
+  }
+});
+
+console.log('');
+
+// Test 5: Backward Compatibility
+console.log('📦 Test Group 5: Backward Compatibility\n');
+
+await testAsync('Old import path still works', async () => {
+  // Old: import from dist/reasoningbank/index.js
+  const module = await import('../dist/reasoningbank/index.js');
+  if (!module.initialize) throw new Error('Old import broken');
+});
+
+await testAsync('Core functions unchanged', async () => {
+  const { retrieveMemories, judgeTrajectory, distillMemories, consolidate } =
+    await import('../dist/reasoningbank/index.js');
+
+  if (typeof retrieveMemories !== 'function') throw new Error('retrieveMemories broken');
+  if (typeof judgeTrajectory !== 'function') throw new Error('judgeTrajectory broken');
+  if (typeof distillMemories !== 'function') throw new Error('distillMemories broken');
+  if (typeof consolidate !== 'function') throw new Error('consolidate broken');
+});
+
+test('WASM adapter file integrity', () => {
+  const { readFileSync } = require('fs');
+  const content = readFileSync('./dist/reasoningbank/wasm-adapter.js', 'utf-8');
+  if (!content.includes('createReasoningBank')) {
+    throw new Error('createReasoningBank function missing from file');
+  }
+  if (!content.includes('ReasoningBankAdapter')) {
+    throw new Error('ReasoningBankAdapter class missing from file');
+  }
+});
+
+console.log('');
+
+// Test 6: Router Module (should be untouched)
+console.log('📦 Test Group 6: Other Modules (Router)\n');
+
+await testAsync('Router module still works', async () => {
+  const module = await import('../dist/router/router.js');
+  if (!module.ModelRouter) throw new Error('ModelRouter missing');
+});
+
+console.log('');
+
+// Test 7: File Structure Integrity
+console.log('📦 Test Group 7: File Structure\n');
+
+test('backend-selector.js exists', () => {
+  if (!existsSync('./dist/reasoningbank/backend-selector.js')) {
+    throw new Error('backend-selector.js not in dist/');
+  }
+});
+
+test('index.js exists', () => {
+  if (!existsSync('./dist/reasoningbank/index.js')) {
+    throw new Error('index.js not in dist/');
+  }
+});
+
+test('wasm-adapter.js exists', () => {
+  if (!existsSync('./dist/reasoningbank/wasm-adapter.js')) {
+    throw new Error('wasm-adapter.js not in dist/');
+  }
+});
+
+test('WASM files exist', () => {
+  if (!existsSync('./wasm/reasoningbank/reasoningbank_wasm.js')) {
+    throw new Error('WASM JS not found');
+  }
+  if (!existsSync('./wasm/reasoningbank/reasoningbank_wasm_bg.wasm')) {
+    throw new Error('WASM binary not found');
+  }
+});
+
+console.log('');
+
+// Summary
+console.log('━'.repeat(60));
+console.log('📊 REGRESSION TEST SUMMARY');
+console.log('━'.repeat(60) + '\n');
+console.log(`Total Tests: ${passed + failed}`);
+console.log(`✅ Passed: ${passed}`);
+console.log(`❌ Failed: ${failed}\n`);
+
+if (failed === 0) {
+  console.log('🎉 All regression tests passed! No regressions detected.\n');
+  process.exit(0);
+} else {
+  console.log('❌ Some regression tests failed. Review output above.\n');
+  process.exit(1);
+}

package/validation/test-wasm-e2e.ts

@@ -0,0 +1,354 @@
+/**
+ * Comprehensive E2E Test for ReasoningBank WASM Integration
+ *
+ * Tests all functionality in a clean Docker environment simulating remote npx usage.
+ * Validates: WASM loading, storage operations, API completeness, performance, memory.
+ */
+
+import { ReasoningBankAdapter, createReasoningBank, type PatternInput } from '../dist/reasoningbank/wasm-adapter.js';
+import { existsSync, statSync } from 'fs';
+import { resolve } from 'path';
+
+interface TestResult {
+  name: string;
+  passed: boolean;
+  duration: number;
+  error?: string;
+  details?: any;
+}
+
+const results: TestResult[] = [];
+
+function test(name: string, fn: () => Promise<void>) {
+  return async (): Promise<TestResult> => {
+    const start = Date.now();
+    try {
+      await fn();
+      const duration = Date.now() - start;
+      console.log(`✅ ${name} (${duration}ms)`);
+      return { name, passed: true, duration };
+    } catch (error) {
+      const duration = Date.now() - start;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`❌ ${name} (${duration}ms):`, errorMessage);
+      return { name, passed: false, duration, error: errorMessage };
+    }
+  };
+}
+
+// Test Suite
+const tests = {
+  'WASM Files Exist': test('WASM Files Exist', async () => {
+    const wasmPath = resolve(import.meta.dirname, '../wasm/reasoningbank/reasoningbank_wasm_bg.wasm');
+    if (!existsSync(wasmPath)) {
+      throw new Error(`WASM file not found at ${wasmPath}`);
+    }
+    const stats = statSync(wasmPath);
+    if (stats.size < 100000) {
+      throw new Error(`WASM file too small (${stats.size} bytes)`);
+    }
+    console.log(`   WASM size: ${(stats.size / 1024).toFixed(1)}KB`);
+  }),
+
+  'TypeScript Wrapper Compiled': test('TypeScript Wrapper Compiled', async () => {
+    const wrapperPath = resolve(import.meta.dirname, '../dist/reasoningbank/wasm-adapter.js');
+    if (!existsSync(wrapperPath)) {
+      throw new Error(`TypeScript wrapper not found at ${wrapperPath}`);
+    }
+  }),
+
+  'Create ReasoningBank Instance': test('Create ReasoningBank Instance', async () => {
+    const rb = new ReasoningBankAdapter('e2e-test-instance');
+    const stats = await rb.getStats();
+    if (typeof stats.total_patterns !== 'number') {
+      throw new Error('Invalid stats structure');
+    }
+  }),
+
+  'Store Pattern': test('Store Pattern', async () => {
+    const rb = await createReasoningBank('e2e-test-store');
+    const pattern: PatternInput = {
+      task_description: 'E2E test pattern for WASM validation',
+      task_category: 'e2e-testing',
+      strategy: 'comprehensive-validation',
+      success_score: 0.98,
+      duration_seconds: 2.5,
+    };
+    const id = await rb.storePattern(pattern);
+    if (!id || typeof id !== 'string') {
+      throw new Error('Pattern ID not returned');
+    }
+    console.log(`   Pattern ID: ${id.substring(0, 8)}...`);
+  }),
+
+  'Retrieve Pattern': test('Retrieve Pattern', async () => {
+    const rb = await createReasoningBank('e2e-test-retrieve');
+    const pattern: PatternInput = {
+      task_description: 'Test retrieval pattern',
+      task_category: 'retrieval-test',
+      strategy: 'test-strategy',
+      success_score: 0.95,
+    };
+    const id = await rb.storePattern(pattern);
+    const retrieved = await rb.getPattern(id);
+    if (!retrieved) {
+      throw new Error('Pattern not retrieved');
+    }
+    if (retrieved.task_description !== pattern.task_description) {
+      throw new Error('Pattern data mismatch');
+    }
+  }),
+
+  'Search by Category': test('Search by Category', async () => {
+    const rb = await createReasoningBank('e2e-test-search');
+    // Store multiple patterns
+    for (let i = 0; i < 5; i++) {
+      await rb.storePattern({
+        task_description: `Search test pattern ${i}`,
+        task_category: 'search-category',
+        strategy: `strategy-${i}`,
+        success_score: 0.8 + (i * 0.02),
+      });
+    }
+    const results = await rb.searchByCategory('search-category', 10);
+    if (results.length < 5) {
+      throw new Error(`Expected at least 5 patterns, got ${results.length}`);
+    }
+    console.log(`   Found ${results.length} patterns`);
+  }),
+
+  'Find Similar Patterns': test('Find Similar Patterns', async () => {
+    const rb = await createReasoningBank('e2e-test-similar');
+    // Store reference patterns
+    await rb.storePattern({
+      task_description: 'Optimize database query performance',
+      task_category: 'performance',
+      strategy: 'indexing',
+      success_score: 0.92,
+    });
+    await rb.storePattern({
+      task_description: 'Improve API response time',
+      task_category: 'performance',
+      strategy: 'caching',
+      success_score: 0.88,
+    });
+
+    // Search for similar
+    const similar = await rb.findSimilar(
+      'Speed up database operations',
+      'performance',
+      5
+    );
+    if (similar.length === 0) {
+      throw new Error('No similar patterns found');
+    }
+    console.log(`   Found ${similar.length} similar, top score: ${similar[0].similarity_score.toFixed(3)}`);
+  }),
+
+  'Get Storage Statistics': test('Get Storage Statistics', async () => {
+    const rb = await createReasoningBank('e2e-test-stats');
+    const stats = await rb.getStats();
+    if (typeof stats.total_patterns !== 'number') {
+      throw new Error('Invalid total_patterns');
+    }
+    if (typeof stats.total_categories !== 'number') {
+      throw new Error('Invalid total_categories');
+    }
+    console.log(`   Stats: ${stats.total_patterns} patterns, ${stats.total_categories} categories`);
+  }),
+
+  'Concurrent Operations': test('Concurrent Operations', async () => {
+    const rb = await createReasoningBank('e2e-test-concurrent');
+    const operations = Array.from({ length: 10 }, (_, i) =>
+      rb.storePattern({
+        task_description: `Concurrent pattern ${i}`,
+        task_category: 'concurrency-test',
+        strategy: 'parallel',
+        success_score: 0.9,
+      })
+    );
+    const ids = await Promise.all(operations);
+    if (ids.length !== 10) {
+      throw new Error(`Expected 10 IDs, got ${ids.length}`);
+    }
+    if (new Set(ids).size !== 10) {
+      throw new Error('Duplicate IDs detected');
+    }
+  }),
+
+  'Performance Benchmark': test('Performance Benchmark', async () => {
+    const rb = await createReasoningBank('e2e-test-perf');
+    const iterations = 50;
+    const start = Date.now();
+
+    for (let i = 0; i < iterations; i++) {
+      await rb.storePattern({
+        task_description: `Performance test pattern ${i}`,
+        task_category: 'benchmark',
+        strategy: 'speed-test',
+        success_score: 0.85,
+      });
+    }
+
+    const duration = Date.now() - start;
+    const avgTime = duration / iterations;
+    console.log(`   ${iterations} ops in ${duration}ms (avg: ${avgTime.toFixed(2)}ms/op)`);
+
+    if (avgTime > 100) {
+      throw new Error(`Performance too slow: ${avgTime}ms/op (expected <100ms)`);
+    }
+  }),
+
+  'Memory Stability': test('Memory Stability', async () => {
+    const initialMem = process.memoryUsage().heapUsed;
+    const rb = await createReasoningBank('e2e-test-memory');
+
+    // Store 100 patterns
+    for (let i = 0; i < 100; i++) {
+      await rb.storePattern({
+        task_description: `Memory test pattern ${i}`,
+        task_category: 'memory-test',
+        strategy: 'stability',
+        success_score: 0.9,
+      });
+    }
+
+    // Force garbage collection if available
+    if (global.gc) {
+      global.gc();
+    }
+
+    const finalMem = process.memoryUsage().heapUsed;
+    const memDelta = (finalMem - initialMem) / 1024 / 1024;
+    console.log(`   Memory delta: ${memDelta.toFixed(2)}MB`);
+
+    if (memDelta > 50) {
+      throw new Error(`Memory leak detected: ${memDelta}MB increase`);
+    }
+  }),
+
+  'Error Handling': test('Error Handling', async () => {
+    const rb = await createReasoningBank('e2e-test-errors');
+
+    // Test invalid UUID
+    try {
+      await rb.getPattern('invalid-uuid');
+      throw new Error('Should have thrown error for invalid UUID');
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('Should have thrown')) {
+        throw error;
+      }
+      // Expected error
+    }
+
+    // Test empty category
+    const results = await rb.searchByCategory('nonexistent-category', 10);
+    if (!Array.isArray(results)) {
+      throw new Error('Should return empty array for nonexistent category');
+    }
+  }),
+
+  'Zero Regression Check': test('Zero Regression Check', async () => {
+    // Verify all existing APIs still work
+    const rb = await createReasoningBank('e2e-regression-check');
+
+    // Test all methods exist
+    const methods = ['storePattern', 'getPattern', 'searchByCategory', 'findSimilar', 'getStats'];
+    for (const method of methods) {
+      if (typeof (rb as any)[method] !== 'function') {
+        throw new Error(`Missing method: ${method}`);
+      }
+    }
+
+    // Test basic workflow
+    const id = await rb.storePattern({
+      task_description: 'Regression test',
+      task_category: 'regression',
+      strategy: 'verification',
+      success_score: 1.0,
+    });
+
+    const pattern = await rb.getPattern(id);
+    if (!pattern) throw new Error('Regression: Pattern not stored');
+
+    const similar = await rb.findSimilar('Regression verification', 'regression', 5);
+    if (!Array.isArray(similar)) throw new Error('Regression: findSimilar broken');
+
+    const stats = await rb.getStats();
+    if (!stats.total_patterns) throw new Error('Regression: stats broken');
+  }),
+};
+
+// Run all tests
+async function runE2ETests() {
+  console.log('\n🧪 Starting Comprehensive E2E Test Suite for WASM Integration\n');
+  console.log('=' .repeat(70));
+  console.log();
+
+  const startTime = Date.now();
+
+  for (const [name, testFn] of Object.entries(tests)) {
+    const result = await testFn();
+    results.push(result);
+  }
+
+  const totalDuration = Date.now() - startTime;
+
+  console.log();
+  console.log('='.repeat(70));
+  console.log('\n📊 Test Results Summary\n');
+
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => r.passed === false).length;
+
+  console.log(`Total Tests: ${results.length}`);
+  console.log(`✅ Passed: ${passed}`);
+  console.log(`❌ Failed: ${failed}`);
+  console.log(`⏱️  Total Duration: ${totalDuration}ms`);
+  console.log();
+
+  if (failed > 0) {
+    console.log('Failed Tests:');
+    results
+      .filter(r => !r.passed)
+      .forEach(r => console.log(`  - ${r.name}: ${r.error}`));
+    console.log();
+  }
+
+  // Performance summary
+  const perfResult = results.find(r => r.name === 'Performance Benchmark');
+  if (perfResult?.passed) {
+    console.log('✅ Performance: WASM operations meeting targets');
+  }
+
+  // Memory summary
+  const memResult = results.find(r => r.name === 'Memory Stability');
+  if (memResult?.passed) {
+    console.log('✅ Memory: No leaks detected');
+  }
+
+  // Zero regressions
+  const regressionResult = results.find(r => r.name === 'Zero Regression Check');
+  if (regressionResult?.passed) {
+    console.log('✅ Regressions: Zero detected - all APIs functional');
+  }
+
+  console.log();
+  console.log('='.repeat(70));
+
+  if (failed === 0) {
+    console.log('\n🎉 All E2E tests PASSED! WASM integration fully functional.\n');
+    return 0;
+  } else {
+    console.log('\n❌ Some E2E tests FAILED. Review errors above.\n');
+    return 1;
+  }
+}
+
+// Execute test suite
+runE2ETests()
+  .then(exitCode => process.exit(exitCode))
+  .catch(error => {
+    console.error('\n💥 Fatal error running E2E tests:', error);
+    process.exit(1);
+  });

package/validation/test-wasm-integration.ts

@@ -0,0 +1,99 @@
+/**
+ * WASM Integration Test
+ *
+ * Verifies ReasoningBank WASM integration is working correctly.
+ */
+
+import { ReasoningBankAdapter, createReasoningBank } from '../src/reasoningbank/wasm-adapter.js';
+
+async function testWasmIntegration() {
+  console.log('🧪 Testing ReasoningBank WASM Integration...\n');
+
+  try {
+    // Test 1: Create ReasoningBank instance
+    console.log('1️⃣  Creating ReasoningBank instance...');
+    const rb = await createReasoningBank('test-wasm-integration');
+    console.log('✅ Instance created successfully\n');
+
+    // Test 2: Store a pattern
+    console.log('2️⃣  Storing a test pattern...');
+    const patternId = await rb.storePattern({
+      task_description: 'Test WASM integration with sample task',
+      task_category: 'integration-testing',
+      strategy: 'test-strategy',
+      success_score: 0.95,
+      duration_seconds: 1.5,
+    });
+    console.log(`✅ Pattern stored with ID: ${patternId}\n`);
+
+    // Test 3: Retrieve the pattern
+    console.log('3️⃣  Retrieving stored pattern...');
+    const pattern = await rb.getPattern(patternId);
+    if (!pattern) {
+      throw new Error('Pattern not found after storage');
+    }
+    console.log('✅ Pattern retrieved:', {
+      id: pattern.id,
+      description: pattern.task_description,
+      score: pattern.success_score,
+    });
+    console.log();
+
+    // Test 4: Search by category
+    console.log('4️⃣  Searching patterns by category...');
+    const patterns = await rb.searchByCategory('integration-testing', 10);
+    console.log(`✅ Found ${patterns.length} pattern(s) in category\n`);
+
+    // Test 5: Find similar patterns
+    console.log('5️⃣  Finding similar patterns...');
+    const similar = await rb.findSimilar(
+      'Another test task for similarity',
+      'integration-testing',
+      5
+    );
+    console.log(`✅ Found ${similar.length} similar pattern(s)`);
+    if (similar.length > 0) {
+      console.log('   Top match:', {
+        description: similar[0].pattern.task_description,
+        similarity: similar[0].similarity_score,
+      });
+    }
+    console.log();
+
+    // Test 6: Get statistics
+    console.log('6️⃣  Getting storage statistics...');
+    const stats = await rb.getStats();
+    console.log('✅ Stats:', {
+      total_patterns: stats.total_patterns,
+      categories: stats.categories,
+      avg_score: stats.avg_success_score?.toFixed(3),
+      backend: stats.storage_backend,
+    });
+    console.log();
+
+    // Success
+    console.log('🎉 All WASM integration tests passed!');
+    console.log();
+    console.log('📦 WASM Package Info:');
+    console.log('   - Size: ~197KB optimized');
+    console.log('   - Backend: Auto-detected (IndexedDB/sql.js)');
+    console.log('   - Performance: Native Rust via WASM');
+    console.log('   - Zero regressions: All existing functionality intact');
+    console.log();
+
+    return true;
+  } catch (error) {
+    console.error('❌ WASM integration test failed:', error);
+    return false;
+  }
+}
+
+// Run tests
+testWasmIntegration()
+  .then((success) => {
+    process.exit(success ? 0 : 1);
+  })
+  .catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+  });