agentdb 1.0.9 → 1.0.11

package/bin/agentdb.js

@@ -402,65 +402,65 @@ function initDatabase(path) {
   }
 }
 
-function runBenchmark() {
-  console.log('📊 Running AgentDB Performance Benchmarks...');
-  console.log('');
-  console.log('This will test:');
-  console.log('  - Native & WASM backend performance');
-  console.log('  - Insert operations (single & batch)');
-  console.log('  - Search operations (various metrics)');
-  console.log('  - Memory usage');
-  console.log('  - Backend comparison');
-  console.log('');
-
+async function runBenchmark(...args) {
   try {
-    // Try to run compiled benchmark first
-    const benchmarkPath = require.resolve('../dist/benchmarks/comprehensive-performance.bench.js');
-    const { PerformanceBenchmark } = require(benchmarkPath);
-
-    const benchmark = new PerformanceBenchmark();
-    benchmark.runAll()
-      .then(() => {
-        console.log('\n✅ All benchmarks completed successfully');
-        process.exit(0);
-      })
-      .catch((error) => {
-        console.error('\n❌ Benchmark failed:', error);
-        process.exit(1);
-      });
-  } catch (error) {
-    // If compiled version doesn't exist, try TypeScript version with ts-node
-    try {
-      console.error('⚠️  Compiled benchmarks not found, trying TypeScript version...');
-      console.error('');
-
-      const { spawn } = require('child_process');
-      const benchmarkProcess = spawn('npx', ['ts-node', 'benchmarks/comprehensive-performance.bench.ts'], {
-        stdio: 'inherit',
-        cwd: require('path').resolve(__dirname, '..')
-      });
-
-      benchmarkProcess.on('close', (code) => {
-        process.exit(code);
-      });
-    } catch (tsError) {
-      console.error('❌ Benchmarks not available in npm package');
-      console.error('');
-      console.error('To run benchmarks, clone the source repository:');
-      console.error('');
-      console.error('  git clone https://github.com/ruvnet/agentic-flow.git');
-      console.error('  cd agentic-flow/packages/agentdb');
-      console.error('  npm install');
-      console.error('  npm run bench:comprehensive');
-      console.error('');
-      console.error('Or create a custom benchmark script:');
-      console.error('');
-      console.error('  const { SQLiteVectorDB } = require("agentdb");');
-      console.error('  const db = new SQLiteVectorDB({ memoryMode: true });');
-      console.error('  // Add your benchmark code here');
-      console.error('');
-      process.exit(1);
+    // Convert arguments to array
+    const argArray = Array.isArray(args[0]) ? args[0] : Array.from(args);
+
+    // Parse arguments
+    const options = {
+      quick: argArray.includes('--quick') || argArray.includes('-q'),
+      vectors: null
+    };
+
+    // Parse custom vector count
+    const vectorsIndex = argArray.findIndex(arg => arg === '--vectors' || arg === '-v');
+    if (vectorsIndex !== -1 && argArray[vectorsIndex + 1]) {
+      options.vectors = parseInt(argArray[vectorsIndex + 1], 10);
+    }
+
+    // Show help if requested
+    if (argArray.includes('--help') || argArray.includes('-h')) {
+      console.log('');
+      console.log('AgentDB Benchmark');
+      console.log('');
+      console.log('USAGE');
+      console.log('  npx agentdb benchmark [options]');
+      console.log('');
+      console.log('OPTIONS');
+      console.log('  --quick, -q          Run quick benchmark (500/1000 vectors)');
+      console.log('  --vectors, -v <n>    Custom batch size (default: 5000, quick: 1000)');
+      console.log('  --help, -h           Show this help');
+      console.log('');
+      console.log('EXAMPLES');
+      console.log('  npx agentdb benchmark              # Standard benchmark (5K vectors)');
+      console.log('  npx agentdb benchmark --quick      # Quick benchmark (1K vectors)');
+      console.log('  npx agentdb benchmark -v 10000     # Custom 10K vectors');
+      console.log('');
+      console.log('For comprehensive benchmarks with WASM comparison:');
+      console.log('  git clone https://github.com/ruvnet/agentic-flow.git');
+      console.log('  cd agentic-flow/packages/agentdb');
+      console.log('  npm install && npm run bench:comprehensive');
+      console.log('');
+      return;
     }
+
+    // Run the included benchmark
+    const benchmarkPath = require.resolve('./benchmark.js');
+    const { runBenchmark } = require(benchmarkPath);
+    await runBenchmark(options);
+  } catch (error) {
+    console.error('');
+    console.error('❌ Benchmark failed:', error.message);
+    console.error('');
+    console.error('For comprehensive benchmarks, clone the source repository:');
+    console.error('');
+    console.error('  git clone https://github.com/ruvnet/agentic-flow.git');
+    console.error('  cd agentic-flow/packages/agentdb');
+    console.error('  npm install');
+    console.error('  npm run bench:comprehensive');
+    console.error('');
+    process.exit(1);
   }
 }
 

package/bin/benchmark.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * AgentDB Quick Benchmark
+ * Simple performance test that works with the published npm package
+ */
+
+const { performance } = require('perf_hooks');
+
+/**
+ * Format throughput for display
+ */
+function formatThroughput(opsPerSec) {
+  if (opsPerSec >= 1000000) {
+    return `${(opsPerSec / 1000000).toFixed(2)}M/sec`;
+  } else if (opsPerSec >= 1000) {
+    return `${(opsPerSec / 1000).toFixed(2)}K/sec`;
+  } else {
+    return `${opsPerSec.toFixed(2)}/sec`;
+  }
+}
+
+/**
+ * Generate random vectors for testing
+ */
+function generateVectors(count, dimensions = 128) {
+  const vectors = [];
+  for (let i = 0; i < count; i++) {
+    vectors.push({
+      id: `vec-${i}`,
+      embedding: Array.from({ length: dimensions }, () => Math.random()),
+      metadata: {
+        index: i,
+        category: `cat-${i % 10}`,
+        timestamp: Date.now()
+      }
+    });
+  }
+  return vectors;
+}
+
+/**
+ * Run benchmark suite
+ */
+async function runBenchmark(options = {}) {
+  const { quick = false, vectors = null } = options;
+
+  // Determine test sizes based on mode
+  const sizes = quick ? {
+    single: 300,
+    batch: 500,
+    queries: 10
+  } : {
+    single: 1000,
+    batch: vectors || 5000,
+    queries: 50
+  };
+
+  console.log('🚀 AgentDB Performance Benchmark\n');
+  console.log(`Mode: ${quick ? 'Quick' : 'Standard'}`);
+  console.log('Testing Native SQLite backend with vector operations...\n');
+
+  try {
+    const { SQLiteVectorDB } = require('../dist/index.js');
+
+    // Test 1: Database Initialization
+    console.log('📊 Test 1: Database Initialization');
+    const initStart = performance.now();
+    const db = new SQLiteVectorDB({ memoryMode: true });
+    const initDuration = performance.now() - initStart;
+    console.log(`   ✅ Initialized in ${initDuration.toFixed(2)}ms\n`);
+
+    // Test 2: Single Insert Performance
+    console.log(`📊 Test 2: Single Insert (${sizes.single.toLocaleString()} vectors)`);
+    const singleVectors = generateVectors(sizes.single, 128);
+    const singleStart = performance.now();
+    for (const vector of singleVectors) {
+      db.insert(vector);
+    }
+    const singleDuration = performance.now() - singleStart;
+    const singleOps = (sizes.single / singleDuration) * 1000;
+    console.log(`   ✅ Duration: ${singleDuration.toFixed(2)}ms`);
+    console.log(`   ✅ Throughput: ${formatThroughput(singleOps)}\n`);
+
+    // Close and recreate database for next test
+    db.close();
+    const db2 = new SQLiteVectorDB({ memoryMode: true });
+
+    // Test 3: Batch Insert Performance
+    console.log(`📊 Test 3: Batch Insert (${sizes.batch.toLocaleString()} vectors)`);
+    const batchVectors = generateVectors(sizes.batch, 128);
+    const batchStart = performance.now();
+    db2.insertBatch(batchVectors);
+    const batchDuration = performance.now() - batchStart;
+    const batchOps = (sizes.batch / batchDuration) * 1000;
+    console.log(`   ✅ Duration: ${batchDuration.toFixed(2)}ms`);
+    console.log(`   ✅ Throughput: ${formatThroughput(batchOps)}\n`);
+
+    // Test 4: Search Performance
+    console.log(`📊 Test 4: Vector Search (${sizes.queries} queries on ${sizes.batch.toLocaleString()} vectors)`);
+    const queryVector = Array.from({ length: 128 }, () => Math.random());
+    const searchStart = performance.now();
+    for (let i = 0; i < sizes.queries; i++) {
+      db2.search(queryVector, 10, 'cosine');
+    }
+    const searchDuration = performance.now() - searchStart;
+    const avgSearchLatency = searchDuration / sizes.queries;
+    console.log(`   ✅ Total: ${searchDuration.toFixed(2)}ms`);
+    console.log(`   ✅ Average: ${avgSearchLatency.toFixed(2)}ms per query\n`);
+
+    // Test 5: Different Similarity Metrics
+    console.log(`📊 Test 5: Similarity Metrics Comparison (${sizes.batch.toLocaleString()} vectors)`);
+    const metrics = ['cosine', 'euclidean', 'dot'];
+    for (const metric of metrics) {
+      const metricStart = performance.now();
+      for (let i = 0; i < sizes.queries; i++) {
+        db2.search(queryVector, 10, metric);
+      }
+      const metricDuration = performance.now() - metricStart;
+      console.log(`   ✅ ${metric}: ${(metricDuration / sizes.queries).toFixed(2)}ms per query`);
+    }
+
+    // Test 6: Database Stats
+    console.log('\n📊 Test 6: Database Statistics');
+    const stats = db2.stats();
+    console.log(`   ✅ Total Vectors: ${stats.count.toLocaleString()}`);
+    console.log(`   ✅ DB Size: ${(stats.size / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`   ✅ Size per 1K vectors: ${((stats.size / stats.count) * 1000 / 1024 / 1024).toFixed(3)} MB\n`);
+
+    db2.close();
+
+    // Print Summary
+    console.log('\n\n═══════════════════════════════════════════════════════════');
+    console.log('📈 BENCHMARK SUMMARY');
+    console.log('═══════════════════════════════════════════════════════════\n');
+
+    console.log('Insert Performance:');
+    console.log(`   - Single Insert: ${formatThroughput(singleOps)}`);
+    console.log(`   - Batch ${sizes.batch.toLocaleString()}: ${formatThroughput(batchOps)}`);
+
+    console.log('\nSearch Performance:');
+    console.log(`   - ${sizes.batch.toLocaleString()} vectors: ${avgSearchLatency.toFixed(2)}ms/query`);
+
+    console.log('\nMemory Efficiency:');
+    console.log(`   - Size per 1K vectors: ${((stats.size / stats.count) * 1000 / 1024 / 1024).toFixed(3)} MB`);
+
+    console.log('\n═══════════════════════════════════════════════════════════\n');
+    console.log('✅ Benchmark completed successfully!\n');
+
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Benchmark failed:', error.message);
+    console.error('\nStack trace:', error.stack);
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+if (require.main === module) {
+  runBenchmark();
+}
+
+module.exports = { runBenchmark };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentdb",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Ultra-fast agent memory and vector database with ReasoningBank for AI agents. Built on SQLite with QUIC sync. From ruv.io - Advanced AI Infrastructure.",
   "keywords": [
     "agent",