test-modular-memory-tools.js•6.01 kB
#!/usr/bin/env node
import { SequentialGraphitiIntegration } from './src/core/SequentialGraphitiIntegration.js';
console.log('🧪 Testing Modularized MemoryTools Integration\n');
async function testModularMemoryTools() {
const integration = new SequentialGraphitiIntegration();
try {
await integration.initialize();
console.log('✅ meMCP system initialized\n');
// Test that all modular components are accessible
console.log('🔧 Testing modular component access...');
const memoryTools = integration.memoryTools;
// Check that modular components exist
console.log(`✅ Operations module: ${memoryTools.operations ? 'Available' : 'Missing'}`);
console.log(`✅ Query handler: ${memoryTools.queryHandler ? 'Available' : 'Missing'}`);
console.log(`✅ Streaming tools: ${memoryTools.streamingTools ? 'Available' : 'Missing'}`);
console.log(`✅ Management tools: ${memoryTools.management ? 'Available' : 'Missing'}`);
console.log(`✅ Streaming manager: ${memoryTools.streamingManager ? 'Available' : 'Missing'}\n`);
// Test direct insight storage (backward compatibility)
console.log('📝 Testing direct insight storage...');
const testInsight = {
content: 'Modular architecture improves code maintainability and testability',
type: 'verified_pattern',
domain: 'software-architecture',
tags: ['modularity', 'architecture', 'maintainability'],
context: {
framework: 'Node.js',
pattern: 'modular-design'
}
};
const storeResult = await memoryTools.storeInsight(testInsight);
console.log(`✅ Insight stored: ${storeResult.factId} (Quality: ${storeResult.qualityScore})\n`);
// Test query functionality via modules
console.log('🔍 Testing modular query functionality...');
const queryResult = await memoryTools.queryHandler.getRecentFacts(5);
console.log(`✅ Recent facts retrieved: ${queryResult.facts ? queryResult.facts.length : queryResult.length} facts\n`);
// Test semantic search via modules
console.log('🧠 Testing semantic search via modules...');
const semanticStats = await memoryTools.queryHandler.getSemanticStats();
console.log(`✅ Semantic stats: ${semanticStats.totalDocuments} documents, ${semanticStats.vocabularySize} terms\n`);
// Test streaming functionality via modules
console.log('📡 Testing streaming functionality...');
const streamResult = await memoryTools.streamingTools.createBatchStream(
{ query: 'architecture' },
{ chunkSize: 2, maxResults: 5 }
);
console.log(`✅ Stream created: ${streamResult.streamId}\n`);
// Test streaming stats
const streamStats = await memoryTools.streamingTools.getStreamStats();
console.log(`✅ Stream stats: ${streamStats.totalStreams} total streams, ${streamStats.activeStreams} active\n`);
// Test management functionality
console.log('🛠️ Testing management functionality...');
const maintenanceStats = await memoryTools.management.getMaintenanceStats();
console.log(`✅ Maintenance stats retrieved: ${maintenanceStats.factStore.totalFacts} total facts\n`);
// Test cleanup dry run
console.log('🧹 Testing cleanup (dry run)...');
const mockServer = {
responses: [],
registerTool(name, description, schema, handler) {
this.currentHandler = handler;
}
};
// Register cleanup tool and test it
memoryTools.management.registerTools(mockServer);
if (mockServer.currentHandler) {
const cleanupResult = await mockServer.currentHandler({
dryRun: true,
minQualityScore: 30
});
const resultText = cleanupResult.content[0].text;
console.log('✅ Cleanup dry run completed');
console.log(` ${resultText.split('\n')[2]}\n`);
}
// Test component integration
console.log('🔗 Testing component integration...');
// Test that backward compatibility methods work
const testQuery = {
query: 'modular',
limit: 3
};
const compatibilityResult = await memoryTools.handleQuery(testQuery);
console.log(`✅ Backward compatibility: Query handled via delegation\n`);
// Test fact operations
console.log('📊 Testing fact operations...');
const statsResult = await memoryTools.handleGetStats({});
console.log('✅ Stats retrieved via modular components\n');
// Verify modular structure
console.log('🏗️ Verifying modular structure...');
const moduleTests = [
{ name: 'MemoryOperations', obj: memoryTools.operations, methods: ['handleStoreInsight', 'storeInsight'] },
{ name: 'MemoryQueryHandler', obj: memoryTools.queryHandler, methods: ['handleQuery', 'searchSimilarFacts'] },
{ name: 'MemoryStreamingTools', obj: memoryTools.streamingTools, methods: ['createBatchStream', 'getStreamStats'] },
{ name: 'MemoryManagement', obj: memoryTools.management, methods: ['handleCleanup', 'getMaintenanceStats'] }
];
for (const test of moduleTests) {
const methodCount = test.methods.filter(method => typeof test.obj[method] === 'function').length;
console.log(`✅ ${test.name}: ${methodCount}/${test.methods.length} key methods available`);
}
console.log('\n🎉 All modular memory tools tests passed!');
console.log('\n📊 Final System State:');
console.log(` - Total facts: ${(await integration.factStore.getStats()).totalFacts}`);
console.log(` - Semantic index: ${(await integration.factStore.getSemanticStats()).totalDocuments} documents`);
console.log(` - Active streams: ${(await memoryTools.streamingTools.getStreamStats()).activeStreams}`);
} catch (error) {
console.error('❌ Error in modular memory tools test:', error);
console.error('Stack trace:', error.stack);
} finally {
await integration.shutdown();
}
}
testModularMemoryTools().catch(console.error);