agentdb 1.0.10 → 1.0.12

package/bin/agentdb.js

@@ -402,59 +402,64 @@ 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);
-      });
+    // 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 (~5 seconds, 300 vectors)');
+      console.log('  --vectors, -v <n>    Custom batch size (default: 1000, quick: 300)');
+      console.log('  --help, -h           Show this help');
+      console.log('');
+      console.log('EXAMPLES');
+      console.log('  npx agentdb benchmark              # Standard benchmark (1K vectors, ~20s)');
+      console.log('  npx agentdb benchmark --quick      # Quick benchmark (300 vectors, ~5s)');
+      console.log('  npx agentdb benchmark -v 2000      # Custom 2K vectors (~60s)');
+      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) {
-    // Benchmarks are not included in npm package
     console.error('');
-    console.error('❌ Benchmarks not available in npm package');
+    console.error('❌ Benchmark failed:', error.message);
     console.error('');
-    console.error('To run benchmarks, clone the source repository:');
+    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('');
-    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('  ');
-    console.error('  // Insert test vectors');
-    console.error('  const vectors = Array.from({ length: 1000 }, () => ({');
-    console.error('    embedding: Array(128).fill(0).map(() => Math.random()),');
-    console.error('    metadata: { test: true }');
-    console.error('  }));');
-    console.error('  ');
-    console.error('  const start = Date.now();');
-    console.error('  vectors.forEach(v => db.insert(v));');
-    console.error('  console.log(`Inserted 1000 vectors in ${Date.now() - start}ms`);');
-    console.error('');
     process.exit(1);
   }
 }

package/bin/benchmark.js

@@ -0,0 +1,165 @@
+#!/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
+  // Note: HNSW index building is O(n log n), so batch sizes > 2000 can be slow
+  const sizes = quick ? {
+    single: 200,
+    batch: 300,
+    queries: 10
+  } : {
+    single: 500,
+    batch: vectors || 1000,
+    queries: 20
+  };
+
+  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)`);
+    console.log(`   ⏳ Generating ${sizes.batch.toLocaleString()} random vectors...`);
+    const batchVectors = generateVectors(sizes.batch, 128);
+    console.log(`   ⏳ Inserting batch (this may take a moment for HNSW indexing)...`);
+    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 (includes HNSW index building)`);
+    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.10",
+  "version": "1.0.12",
   "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",