Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

This commit is contained in:
ruv
2026-02-28 14:39:40 -05:00
7854 changed files with 3522914 additions and 0 deletions

View File

@@ -0,0 +1,269 @@
#!/usr/bin/env node
/**
* AgentDB 2.0.0-alpha.2.11 Verification Script
*
* This script verifies all key features of the published package:
* - All 5 RuVector packages installation
* - All 5 attention mechanisms
* - Vector search functionality
* - GNN (Graph Neural Networks)
* - Graph database with Cypher queries
*/
const AgentDB = require('agentdb');
console.log('🔍 AgentDB Package Verification\n');
console.log('=' .repeat(60));
// Test Results Tracker
const results = {
passed: [],
failed: [],
warnings: []
};
function pass(test) {
console.log(`${test}`);
results.passed.push(test);
}
function fail(test, error) {
console.log(`${test}`);
console.log(` Error: ${error.message}`);
results.failed.push({ test, error: error.message });
}
function warn(message) {
console.log(`⚠️ ${message}`);
results.warnings.push(message);
}
async function verifyPackageStructure() {
console.log('\n📦 Package Structure Verification\n');
try {
// Verify AgentDB main module
if (typeof AgentDB === 'object' || typeof AgentDB === 'function') {
pass('AgentDB module loaded');
} else {
throw new Error('AgentDB module not properly exported');
}
// Verify RuVector packages are accessible
const packages = [
'@ruvector/attention',
'@ruvector/gnn',
'@ruvector/graph-node',
'@ruvector/router',
'ruvector'
];
for (const pkg of packages) {
try {
const module = require(pkg);
pass(`${pkg} accessible`);
} catch (err) {
fail(`${pkg} accessible`, err);
}
}
} catch (error) {
fail('Package structure verification', error);
}
}
async function verifyAttentionMechanisms() {
console.log('\n🧠 Attention Mechanisms Verification\n');
try {
const attention = require('@ruvector/attention');
// Check if attention mechanisms are exported
const mechanisms = {
'Multi-Head Attention': attention.MultiHeadAttention || attention.multihead,
'Flash Attention': attention.FlashAttention || attention.flash,
'Linear Attention': attention.LinearAttention || attention.linear,
'Hyperbolic Attention': attention.HyperbolicAttention || attention.hyperbolic,
'MoE Attention': attention.MoEAttention || attention.moe
};
for (const [name, impl] of Object.entries(mechanisms)) {
if (impl) {
pass(`${name} available`);
} else {
warn(`${name} not found in exports`);
}
}
// Try to list all exports
console.log('\n Available exports:', Object.keys(attention).join(', '));
} catch (error) {
fail('Attention mechanisms verification', error);
}
}
async function verifyVectorSearch() {
console.log('\n🔎 Vector Search Verification\n');
try {
const ruvector = require('ruvector');
// Create a simple vector database
if (ruvector.VectorDB || ruvector.default) {
pass('RuVector VectorDB available');
// Try to perform basic operations
try {
// This is a basic check - actual implementation may vary
const VectorDB = ruvector.VectorDB || ruvector.default || ruvector;
if (typeof VectorDB === 'function' || typeof VectorDB.search === 'function') {
pass('VectorDB has expected interface');
}
} catch (err) {
warn(`VectorDB interface check: ${err.message}`);
}
} else {
warn('VectorDB not found in expected exports');
}
console.log('\n Available exports:', Object.keys(ruvector).join(', '));
} catch (error) {
fail('Vector search verification', error);
}
}
async function verifyGNN() {
console.log('\n🕸 Graph Neural Network Verification\n');
try {
const gnn = require('@ruvector/gnn');
if (gnn) {
pass('GNN module loaded');
// Check for common GNN exports
const expectedExports = ['GNN', 'GraphNeuralNetwork', 'TensorCompression'];
const availableExports = Object.keys(gnn);
console.log('\n Available exports:', availableExports.join(', '));
if (availableExports.length > 0) {
pass('GNN has exports');
}
}
} catch (error) {
fail('GNN verification', error);
}
}
async function verifyGraphDatabase() {
console.log('\n🗄 Graph Database Verification\n');
try {
const graphNode = require('@ruvector/graph-node');
if (graphNode) {
pass('Graph Node module loaded');
const availableExports = Object.keys(graphNode);
console.log('\n Available exports:', availableExports.join(', '));
// Check for Cypher query support
if (graphNode.query || graphNode.cypher || graphNode.Query) {
pass('Cypher query support detected');
} else {
warn('Cypher query support not found in exports');
}
// Check for hyperedge support
if (graphNode.HyperEdge || graphNode.hyperedge) {
pass('Hyperedge support detected');
} else {
warn('Hyperedge support not found in exports');
}
}
} catch (error) {
fail('Graph database verification', error);
}
}
async function verifyRouter() {
console.log('\n🔀 Semantic Router Verification\n');
try {
const router = require('@ruvector/router');
if (router) {
pass('Router module loaded');
const availableExports = Object.keys(router);
console.log('\n Available exports:', availableExports.join(', '));
if (router.Router || router.SemanticRouter) {
pass('Semantic router available');
}
}
} catch (error) {
fail('Router verification', error);
}
}
async function printSummary() {
console.log('\n' + '='.repeat(60));
console.log('\n📊 Verification Summary\n');
console.log(`✅ Passed: ${results.passed.length} tests`);
console.log(`❌ Failed: ${results.failed.length} tests`);
console.log(`⚠️ Warnings: ${results.warnings.length} items`);
if (results.failed.length > 0) {
console.log('\n❌ Failed Tests:');
results.failed.forEach(({ test, error }) => {
console.log(` - ${test}: ${error}`);
});
}
if (results.warnings.length > 0) {
console.log('\n⚠ Warnings:');
results.warnings.forEach(warning => {
console.log(` - ${warning}`);
});
}
console.log('\n' + '='.repeat(60));
// Exit with appropriate code
if (results.failed.length > 0) {
console.log('\n❌ Verification FAILED\n');
process.exit(1);
} else {
console.log('\n✅ Verification PASSED\n');
console.log('🎉 agentdb@2.0.0-alpha.2.11 is working correctly!\n');
process.exit(0);
}
}
// Run all verifications
async function runVerification() {
try {
await verifyPackageStructure();
await verifyAttentionMechanisms();
await verifyVectorSearch();
await verifyGNN();
await verifyGraphDatabase();
await verifyRouter();
await printSummary();
} catch (error) {
console.error('\n💥 Fatal error during verification:', error);
process.exit(1);
}
}
// Start verification
runVerification().catch(console.error);