#!/usr/bin/env node
import { SequentialGraphitiIntegration } from './src/core/SequentialGraphitiIntegration.js';
console.log('🚗 meMCP System Test Drive\n');
console.log('Testing memory persistence, session handling, and real-world usage\n');
async function testDriveMeMCP() {
const integration = new SequentialGraphitiIntegration();
try {
// === INITIALIZATION TEST ===
console.log('🔧 INITIALIZATION TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
await integration.initialize();
const initialStats = await integration.factStore.getStats();
console.log(`✅ System initialized with ${initialStats.totalFacts} existing facts`);
console.log(` - This demonstrates PERSISTENCE across sessions!`);
console.log(` - Facts from previous sessions are automatically loaded\n`);
// === MEMORY STORAGE TEST ===
console.log('💾 MEMORY STORAGE TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
const sessionId = `session_${Date.now()}`;
console.log(`Session ID: ${sessionId}\n`);
// Store various types of insights
const testInsights = [
{
content: `In ${sessionId}: React useCallback should be used for expensive function recreations to prevent unnecessary re-renders`,
type: 'verified_pattern',
domain: 'react',
tags: ['performance', 'hooks', 'optimization'],
context: { sessionId, framework: 'react', pattern: 'useCallback' }
},
{
content: `In ${sessionId}: Database indexes should be created on frequently queried columns, but too many indexes slow down writes`,
type: 'optimization',
domain: 'database',
tags: ['database', 'performance', 'indexing'],
context: { sessionId, type: 'database-optimization' }
},
{
content: `In ${sessionId}: When debugging memory leaks, use Chrome DevTools Memory tab with heap snapshots comparison`,
type: 'debugging_solution',
domain: 'debugging',
tags: ['memory-leak', 'chrome-devtools', 'debugging'],
context: { sessionId, tool: 'chrome-devtools' }
},
{
content: `In ${sessionId}: TypeScript strict mode catches more bugs but requires more upfront type definitions`,
type: 'decision_rationale',
domain: 'typescript',
tags: ['typescript', 'strict-mode', 'type-safety'],
context: { sessionId, language: 'typescript' }
}
];
console.log(`Storing ${testInsights.length} insights for this session...`);
const storedInsights = [];
for (const insight of testInsights) {
const result = await integration.memoryTools.storeInsight(insight);
storedInsights.push(result);
console.log(` ✅ ${result.factId}: "${insight.content.substring(0, 50)}..." (Quality: ${result.qualityScore})`);
}
console.log();
// === SEARCH AND RETRIEVAL TEST ===
console.log('🔍 SEARCH AND RETRIEVAL TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
// Test semantic search
console.log('Testing semantic search across ALL sessions...\n');
const searchQueries = [
'React performance optimization',
'database performance',
'debugging memory issues',
'TypeScript configuration'
];
for (const query of searchQueries) {
console.log(`🔍 Searching for: "${query}"`);
const searchResult = await integration.factStore.queryFacts({
query,
limit: 3,
sortBy: 'relevance'
});
console.log(` Found ${searchResult.facts.length} results:`);
searchResult.facts.forEach((fact, i) => {
const isFromCurrentSession = fact.content.includes(sessionId);
const sessionMarker = isFromCurrentSession ? '[THIS SESSION]' : '[PREVIOUS SESSION]';
console.log(` ${i + 1}. ${sessionMarker} Score: ${fact.relevanceScore?.toFixed(2) || 'N/A'}`);
console.log(` "${fact.content.substring(0, 80)}..."`);
});
console.log();
}
// === SESSION TRACKING TEST ===
console.log('📊 SESSION TRACKING TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━');
// Query facts from current session
const currentSessionFacts = await integration.factStore.queryFacts({
query: sessionId,
limit: 10
});
console.log(`Facts from current session (${sessionId}):`);
console.log(` Found: ${currentSessionFacts.facts.length} facts from this session`);
// Query facts from all sessions
const allFacts = await integration.factStore.getAllFacts();
const sessionGroups = new Map();
allFacts.forEach(fact => {
const factSessionId = fact.context?.sessionId || 'unknown-session';
if (!sessionGroups.has(factSessionId)) {
sessionGroups.set(factSessionId, []);
}
sessionGroups.get(factSessionId).push(fact);
});
console.log(`\n📈 Session Distribution (showing persistent memory across sessions):`);
Array.from(sessionGroups.entries())
.sort(([,a], [,b]) => b.length - a.length)
.slice(0, 5)
.forEach(([sessionId, facts]) => {
const isCurrentSession = sessionId.includes(Date.now().toString().substring(0, 8));
const marker = isCurrentSession ? ' 👈 CURRENT' : '';
console.log(` ${sessionId}: ${facts.length} facts${marker}`);
});
console.log();
// === FACT RELATIONSHIPS TEST ===
console.log('🔗 FACT RELATIONSHIPS TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
// Find similar facts using semantic similarity
if (storedInsights.length > 0) {
const firstFactId = storedInsights[0].factId;
const similarFacts = await integration.factStore.findSimilarFacts(firstFactId, {
limit: 3,
threshold: 0.1
});
console.log(`Similar facts to "${storedInsights[0].content.substring(0, 50)}...":`);
similarFacts.forEach((similar, i) => {
console.log(` ${i + 1}. Similarity: ${similar.similarity.toFixed(3)}`);
console.log(` "${similar.content.substring(0, 80)}..."`);
});
console.log();
}
// === STREAMING TEST ===
console.log('📡 STREAMING TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━');
console.log('Testing streaming for large result sets...');
const streamId = await integration.memoryTools.streamingManager.createBatchStream(
{ query: '', type: '', domain: '' }, // Get all facts
integration.factStore,
{ chunkSize: 5, maxResults: 20 }
);
console.log(` Stream created: ${streamId}`);
let chunkCount = 0;
let totalStreamed = 0;
while (true) {
try {
const chunk = await integration.memoryTools.streamingManager.getNextChunk(streamId);
chunkCount++;
totalStreamed += chunk.facts.length;
console.log(` Chunk ${chunkCount}: ${chunk.facts.length} facts (Progress: ${chunk.progress.percentage}%)`);
if (chunk.isLastChunk) {
console.log(` ✅ Streaming complete: ${totalStreamed} facts streamed`);
break;
}
if (chunkCount >= 3) { // Limit for demo
await integration.memoryTools.streamingManager.cancelStream(streamId);
console.log(` ⏹️ Stream cancelled for demo (processed ${chunkCount} chunks)`);
break;
}
} catch (error) {
console.log(` ❌ Stream ended: ${error.message}`);
break;
}
}
console.log();
// === SYSTEM HEALTH TEST ===
console.log('🏥 SYSTEM HEALTH TEST');
console.log('━━━━━━━━━━━━━━━━━━━━━━');
const finalStats = await integration.factStore.getStats();
const semanticStats = integration.factStore.getSemanticStats();
console.log('System Health Report:');
console.log(` 📊 Total Facts: ${finalStats.totalFacts}`);
console.log(` 📈 Average Quality: ${finalStats.averageQualityScore}/100`);
console.log(` 🧠 Semantic Index: ${semanticStats.totalDocuments} docs, ${semanticStats.vocabularySize} terms`);
console.log(` 🏷️ Fact Types: ${Object.keys(finalStats.factsByType).length}`);
console.log(` 🌐 Domains: ${Object.keys(finalStats.factsByDomain).length}`);
// Test cleanup functionality
console.log('\n🧹 Testing cleanup (dry run)...');
const mockServer = {
registerTool(name, description, schema, handler) {
this.handler = handler;
}
};
integration.memoryTools.management.registerTools(mockServer);
const cleanupResult = await mockServer.handler({
dryRun: true,
minQualityScore: 30
});
const cleanupText = cleanupResult.content[0].text;
const deleteLine = cleanupText.split('\n').find(line => line.includes('Would delete'));
console.log(` ${deleteLine || 'No facts would be deleted'}`);
console.log('\n🎯 PERSISTENCE SUMMARY');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━');
console.log('✅ Memory IS persistent across sessions');
console.log('✅ Facts are stored permanently until explicitly deleted');
console.log('✅ Each session can add to the shared knowledge base');
console.log('✅ Search works across ALL sessions, not just current one');
console.log('✅ Semantic relationships span multiple sessions');
console.log('✅ System maintains integrity across restarts');
console.log('\n📝 ANSWER TO YOUR QUESTIONS:');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
console.log('Q: Is memory persistent across sessions?');
console.log('A: YES! Facts are stored permanently in JSON files and loaded on startup');
console.log('');
console.log('Q: Is it per session?');
console.log('A: NO! It\'s a SHARED knowledge base across all sessions');
console.log(' - Each session adds to the same persistent memory');
console.log(' - Search queries return results from ALL sessions');
console.log(' - The system builds knowledge over time');
console.log(' - Optional session tracking available via context metadata');
} catch (error) {
console.error('❌ Error in test drive:', error);
} finally {
await integration.shutdown();
console.log('\n🏁 Test drive complete!');
}
}
testDriveMeMCP().catch(console.error);
