cozo-memory 1.2.0 → 1.2.2

package/dist/test-metadata-update.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+async function testMetadataUpdate() {
+    console.log('=== Testing Metadata Update ===\n');
+    const db = new cozo_node_1.CozoDb('sqlite', 'memory_db.cozo.db');
+    try {
+        const obsId = '0edaaeaa-5e3e-479e-a759-42227f59c868';
+        // Get current metadata
+        console.log('1. Current metadata:');
+        const current = await db.run(`
+      ?[id, metadata] := *observation{id, metadata, @ "NOW"}, id = $id
+    `, { id: obsId });
+        console.log('   ', JSON.stringify(current.rows[0][1], null, 2));
+        console.log();
+        // Try updating with concat
+        console.log('2. Attempting update with concat...');
+        try {
+            await db.run(`
+        ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] := 
+          *observation{id, created_at, entity_id, session_id, task_id, text, embedding, metadata, @ "NOW"},
+          id = $id,
+          new_metadata = {
+            "zettelkasten_test": "value1",
+            "zettelkasten_enriched": true
+          },
+          metadata = if(is_null(metadata), new_metadata, concat(metadata, new_metadata))
+        
+        :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+      `, { id: obsId });
+            console.log('   Success!');
+        }
+        catch (error) {
+            console.log('   Failed:', error.message);
+        }
+        console.log();
+        // Check if it worked
+        console.log('3. Metadata after concat attempt:');
+        const after1 = await db.run(`
+      ?[id, metadata] := *observation{id, metadata, @ "NOW"}, id = $id
+    `, { id: obsId });
+        console.log('   ', JSON.stringify(after1.rows[0][1], null, 2));
+        console.log();
+        // Try a different approach - merge manually
+        console.log('4. Attempting update with manual merge...');
+        try {
+            const currentMeta = await db.run(`
+        ?[metadata] := *observation{id, metadata, @ "NOW"}, id = $id
+      `, { id: obsId });
+            const existingMeta = currentMeta.rows[0][0] || {};
+            const mergedMeta = {
+                ...existingMeta,
+                zettelkasten_test2: "value2",
+                zettelkasten_enriched: true,
+                zettelkasten_keywords: ["test", "keywords"]
+            };
+            await db.run(`
+        ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] := 
+          *observation{id, created_at, entity_id, session_id, task_id, text, embedding, @ "NOW"},
+          id = $id,
+          metadata = $new_metadata
+        
+        :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+      `, { id: obsId, new_metadata: mergedMeta });
+            console.log('   Success!');
+        }
+        catch (error) {
+            console.log('   Failed:', error.message);
+        }
+        console.log();
+        // Check final result
+        console.log('5. Final metadata:');
+        const final = await db.run(`
+      ?[id, metadata] := *observation{id, metadata, @ "NOW"}, id = $id
+    `, { id: obsId });
+        console.log('   ', JSON.stringify(final.rows[0][1], null, 2));
+        console.log();
+        // Check if zettelkasten_enriched is now detectable
+        console.log('6. Can we query for zettelkasten_enriched?');
+        const enrichedCheck = await db.run(`
+      ?[id] := 
+        *observation{id, metadata, @ "NOW"},
+        metadata != null,
+        metadata->'zettelkasten_enriched' == true
+    `);
+        console.log(`   Found ${enrichedCheck.rows.length} enriched observations`);
+    }
+    catch (error) {
+        console.error('Error:', error);
+    }
+}
+testMetadataUpdate().catch(console.error);

package/dist/test-pre-storage-reasoning.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const pre_storage_reasoning_1 = require("./pre-storage-reasoning");
+async function testPreStorageReasoning() {
+    console.log('=== Pre-Storage Reasoning Test ===\n');
+    const db = new cozo_node_1.CozoDb();
+    const preStorageService = new pre_storage_reasoning_1.PreStorageReasoningService(db, {
+        enablePreStorage: true,
+        ollamaModel: 'llama3.2:3b',
+        extractEntities: true,
+        extractRelationships: true,
+        detectContradictions: true,
+        minConfidence: 0.6
+    });
+    try {
+        // Initialize database schema
+        await db.run(`
+      :create entity {
+        id: String,
+        =>
+        name: String,
+        type: String,
+      }
+    `);
+        await db.run(`
+      :create observation {
+        id: String,
+        =>
+        entity_id: String,
+        text: String,
+        metadata: Json?,
+      }
+    `);
+        await db.run(`
+      :create relationship {
+        from_id: String,
+        to_id: String,
+        relation_type: String,
+        =>
+        strength: Float,
+        metadata: Json?,
+      }
+    `);
+        console.log('✓ Database initialized\n');
+        // Create test entity
+        await db.run(`
+      ?[id, name, type] <- [['project-alpha', 'Project Alpha', 'Project']]
+      :put entity {id, name, type}
+    `);
+        // Test 1: Entity Extraction
+        console.log('Test 1: Entity Extraction...');
+        const text1 = 'Alice Johnson is working on the new authentication module using TypeScript and PostgreSQL.';
+        const analysis1 = await preStorageService.analyzeBeforeStorage(text1, 'project-alpha');
+        console.log(`Text: "${text1}"`);
+        console.log(`Processing time: ${analysis1.processingTime}ms`);
+        console.log(`\nExtracted Entities (${analysis1.entitySuggestions.length}):`);
+        for (const entity of analysis1.entitySuggestions) {
+            console.log(`  - ${entity.name} (${entity.type}) [confidence: ${entity.confidence.toFixed(2)}]`);
+            console.log(`    Reason: ${entity.reason}`);
+        }
+        console.log();
+        // Test 2: Relationship Extraction
+        console.log('Test 2: Relationship Extraction...');
+        const text2 = 'Bob manages the frontend team and Alice reports to Bob. The team uses React for the UI.';
+        const analysis2 = await preStorageService.analyzeBeforeStorage(text2, 'project-alpha');
+        console.log(`Text: "${text2}"`);
+        console.log(`\nExtracted Relationships (${analysis2.relationshipSuggestions.length}):`);
+        for (const rel of analysis2.relationshipSuggestions) {
+            console.log(`  - ${rel.fromEntity} --[${rel.relationType}]--> ${rel.toEntity} [confidence: ${rel.confidence.toFixed(2)}]`);
+            console.log(`    Reason: ${rel.reason}`);
+        }
+        console.log();
+        // Test 3: Contradiction Detection
+        console.log('Test 3: Contradiction Detection...');
+        // Add existing observation
+        await db.run(`
+      ?[id, entity_id, text, metadata] <- [[
+        'obs-1',
+        'project-alpha',
+        'The project deadline is December 15th, 2025',
+        {}
+      ]]
+      :put observation {id, entity_id, text, metadata}
+    `);
+        const existingObs = await preStorageService.getExistingObservations('project-alpha');
+        const text3 = 'The project deadline has been moved to January 30th, 2026';
+        const analysis3 = await preStorageService.analyzeBeforeStorage(text3, 'project-alpha', existingObs);
+        console.log(`New text: "${text3}"`);
+        console.log(`Existing observations: ${existingObs.length}`);
+        console.log(`\nDetected Contradictions (${analysis3.contradictionWarnings.length}):`);
+        for (const warning of analysis3.contradictionWarnings) {
+            console.log(`  ⚠ Contradiction detected [confidence: ${warning.confidence.toFixed(2)}]`);
+            console.log(`    Existing: "${warning.existingObservation}"`);
+            console.log(`    Contradicts: ${warning.contradiction}`);
+            console.log(`    Reason: ${warning.reason}`);
+        }
+        console.log();
+        // Test 4: Auto-Apply Suggestions
+        console.log('Test 4: Auto-Apply Suggestions...');
+        const text4 = 'Sarah leads the DevOps team and works closely with the infrastructure team on Kubernetes deployment.';
+        const analysis4 = await preStorageService.analyzeBeforeStorage(text4, 'project-alpha');
+        console.log(`Text: "${text4}"`);
+        console.log(`Entities suggested: ${analysis4.entitySuggestions.length}`);
+        console.log(`Relationships suggested: ${analysis4.relationshipSuggestions.length}`);
+        const applied = await preStorageService.autoApplySuggestions(analysis4, true, // auto-create entities
+        true // auto-create relationships
+        );
+        console.log(`\n✓ Auto-applied:`);
+        console.log(`  - Entities created: ${applied.entitiesCreated}`);
+        console.log(`  - Relationships created: ${applied.relationshipsCreated}`);
+        console.log();
+        // Test 5: Performance Test
+        console.log('Test 5: Performance Test...');
+        const perfTests = [
+            'Quick note: Meeting at 3 PM',
+            'The API endpoint /users returns a list of all users in JSON format',
+            'Critical bug: Authentication fails when using OAuth2 with Google provider'
+        ];
+        let totalTime = 0;
+        for (const text of perfTests) {
+            const analysis = await preStorageService.analyzeBeforeStorage(text, 'project-alpha');
+            totalTime += analysis.processingTime;
+            console.log(`  "${text.substring(0, 50)}..." => ${analysis.processingTime}ms`);
+        }
+        console.log(`Average processing time: ${(totalTime / perfTests.length).toFixed(0)}ms\n`);
+        // Test 6: Disabled Mode
+        console.log('Test 6: Disabled Mode...');
+        const disabledService = new pre_storage_reasoning_1.PreStorageReasoningService(db, {
+            enablePreStorage: false
+        });
+        const analysis6 = await disabledService.analyzeBeforeStorage('This should not be analyzed', 'project-alpha');
+        console.log(`✓ Disabled mode: ${analysis6.processingTime}ms (should be 0)`);
+        console.log(`  Entities: ${analysis6.entitySuggestions.length}`);
+        console.log(`  Relationships: ${analysis6.relationshipSuggestions.length}`);
+        console.log(`  Contradictions: ${analysis6.contradictionWarnings.length}`);
+        console.log();
+        console.log('=== All Tests Completed Successfully ===');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+// Run tests
+testPreStorageReasoning().catch(console.error);

package/dist/test-salience-mcp.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testSalienceMCPTool() {
+    console.log("=== Testing Emotional Salience MCP Tool ===\n");
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    try {
+        // Step 1: Create test entity
+        console.log("1. Creating test entity...");
+        const entityResult = await server.createEntity({
+            name: "Salience Test Entity",
+            type: "TestEntity",
+            metadata: { purpose: "testing salience" }
+        });
+        console.log("✓ Entity created:", entityResult.id);
+        // Step 2: Add observations with varying emotional salience
+        console.log("\n2. Adding observations with different emotional levels...");
+        const observations = [
+            "URGENT: Critical security vulnerability discovered in production system!",
+            "Important meeting scheduled for tomorrow at 10 AM",
+            "The weather is nice today",
+            "DEADLINE: Project must be completed by Friday or we lose the client",
+            "Regular status update: everything is proceeding normally",
+            "Exciting news: We won the innovation award!",
+            "Failed deployment caused major outage affecting 10,000 users",
+            "Coffee machine needs refilling",
+            "Emergency: Server crash requires immediate attention",
+            "Routine maintenance completed successfully"
+        ];
+        for (const text of observations) {
+            await server.addObservation({
+                entity_id: entityResult.id,
+                text: text,
+                metadata: { test: true }
+            });
+            console.log(`✓ Added: "${text.substring(0, 50)}..."`);
+        }
+        // Step 3: Test get_salience_stats
+        console.log("\n3. Testing get_salience_stats...");
+        const stats = await server.getSalienceService().getSalienceStats();
+        console.log("✓ Salience stats retrieved:");
+        console.log(`  - Total observations: ${stats.totalObservations}`);
+        console.log(`  - With salience (≥0.3): ${stats.withSalience}`);
+        console.log(`  - Average salience: ${stats.averageSalience.toFixed(3)}`);
+        console.log(`  - Distribution:`);
+        console.log(`    • High: ${stats.distribution.high}`);
+        console.log(`    • Medium: ${stats.distribution.medium}`);
+        console.log(`    • Low: ${stats.distribution.low}`);
+        console.log(`    • Neutral: ${stats.distribution.neutral}`);
+        if (stats.topKeywords.length > 0) {
+            console.log(`  - Top keywords:`);
+            stats.topKeywords.slice(0, 5).forEach((kw, idx) => {
+                console.log(`    ${idx + 1}. ${kw.keyword} (${kw.count})`);
+            });
+        }
+        // Step 4: Verify high-salience observations
+        console.log("\n4. Verifying high-salience observations...");
+        const allScores = await server.getSalienceService().scoreAllObservations();
+        const highSalience = allScores.filter(s => s.category === 'high');
+        console.log(`✓ Found ${highSalience.length} high-salience observations:`);
+        highSalience.forEach((score, idx) => {
+            console.log(`  ${idx + 1}. Score: ${score.salienceScore.toFixed(2)}, Keywords: ${score.detectedKeywords.join(", ")}`);
+            console.log(`     Text: "${score.text.substring(0, 60)}..."`);
+        });
+        // Step 5: Check emotional categories
+        console.log("\n5. Checking emotional category distribution...");
+        const categories = {
+            critical: allScores.filter(s => s.detectedKeywords.some(k => ['urgent', 'critical', 'emergency'].includes(k.toLowerCase()))).length,
+            important: allScores.filter(s => s.detectedKeywords.some(k => ['important', 'deadline'].includes(k.toLowerCase()))).length,
+            emotional: allScores.filter(s => s.detectedKeywords.some(k => ['exciting', 'failed'].includes(k.toLowerCase()))).length,
+            neutral: allScores.filter(s => s.salienceScore === 0).length
+        };
+        console.log("✓ Category breakdown:");
+        console.log(`  - Critical/Emergency: ${categories.critical}`);
+        console.log(`  - Important/Deadline: ${categories.important}`);
+        console.log(`  - Emotional: ${categories.emotional}`);
+        console.log(`  - Neutral: ${categories.neutral}`);
+        // Step 6: Verify salience affects activation
+        console.log("\n6. Verifying salience integration with ACT-R...");
+        const activationStats = await server.getActivationService().getActivationStats(entityResult.id);
+        console.log("✓ ACT-R activation stats:");
+        console.log(`  - Total observations: ${activationStats.totalObservations}`);
+        console.log(`  - Average strength: ${activationStats.averageStrength.toFixed(2)}`);
+        console.log(`  - Note: High-salience observations have boosted strength`);
+        console.log("\n=== ✓ Emotional Salience MCP Tool Test Passed ===");
+    }
+    catch (error) {
+        console.error("\n✗ Test failed:", error);
+        process.exit(1);
+    }
+}
+testSalienceMCPTool();

package/dist/test-spreading-mcp.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const fs = __importStar(require("fs"));
+const TEST_DB_PATH = 'test_spreading_mcp';
+async function runTest() {
+    console.error('=== Testing spreading_activation MCP Tool ===\n');
+    // Clean up old test database
+    const dbFile = `${TEST_DB_PATH}.db`;
+    if (fs.existsSync(dbFile)) {
+        try {
+            fs.unlinkSync(dbFile);
+            console.error('[Cleanup] Removed old test database');
+        }
+        catch (e) {
+            console.error('[Cleanup] Warning: Could not remove old database:', e);
+        }
+    }
+    const server = new index_1.MemoryServer(TEST_DB_PATH);
+    await server.initPromise;
+    try {
+        console.error('1. Creating test knowledge graph...');
+        // Create entities
+        const aiResult = await server.createEntity({ name: 'Artificial Intelligence', type: 'Concept', metadata: {} });
+        const aiId = aiResult.id;
+        console.error(`✓ Created AI: ${aiId}`);
+        const mlResult = await server.createEntity({ name: 'Machine Learning', type: 'Concept', metadata: {} });
+        const mlId = mlResult.id;
+        console.error(`✓ Created ML: ${mlId}`);
+        const dlResult = await server.createEntity({ name: 'Deep Learning', type: 'Concept', metadata: {} });
+        const dlId = dlResult.id;
+        console.error(`✓ Created DL: ${dlId}`);
+        const nnResult = await server.createEntity({ name: 'Neural Networks', type: 'Concept', metadata: {} });
+        const nnId = nnResult.id;
+        console.error(`✓ Created NN: ${nnId}`);
+        const cnnResult = await server.createEntity({ name: 'Convolutional Neural Networks', type: 'Concept', metadata: {} });
+        const cnnId = cnnResult.id;
+        console.error(`✓ Created CNN: ${cnnId}`);
+        const rnnResult = await server.createEntity({ name: 'Recurrent Neural Networks', type: 'Concept', metadata: {} });
+        const rnnId = rnnResult.id;
+        console.error(`✓ Created RNN: ${rnnId}`);
+        const transformerResult = await server.createEntity({ name: 'Transformers', type: 'Concept', metadata: {} });
+        const transformerId = transformerResult.id;
+        console.error(`✓ Created Transformers: ${transformerId}\n`);
+        console.error('2. Creating relationships (knowledge graph structure)...');
+        // AI -> ML -> DL -> NN -> CNN/RNN/Transformers
+        await server.createRelation({ from_id: aiId, to_id: mlId, relation_type: 'includes', strength: 1.0, metadata: {} });
+        console.error('✓ AI includes ML');
+        await server.createRelation({ from_id: mlId, to_id: dlId, relation_type: 'includes', strength: 0.9, metadata: {} });
+        console.error('✓ ML includes DL');
+        await server.createRelation({ from_id: dlId, to_id: nnId, relation_type: 'uses', strength: 1.0, metadata: {} });
+        console.error('✓ DL uses NN');
+        await server.createRelation({ from_id: nnId, to_id: cnnId, relation_type: 'type_of', strength: 0.8, metadata: {} });
+        console.error('✓ NN type_of CNN');
+        await server.createRelation({ from_id: nnId, to_id: rnnId, relation_type: 'type_of', strength: 0.8, metadata: {} });
+        console.error('✓ NN type_of RNN');
+        await server.createRelation({ from_id: nnId, to_id: transformerId, relation_type: 'type_of', strength: 0.9, metadata: {} });
+        console.error('✓ NN type_of Transformers\n');
+        console.error('3. Testing spreading_activation with query "neural networks"...');
+        const result = await server.getSpreadingService().spreadActivation('neural networks', 3);
+        console.error('✓ Spreading activation completed:', {
+            totalScores: result.scores.length,
+            iterations: result.iterations,
+            converged: result.converged,
+            seedNodes: result.seedNodes.length
+        });
+        if (result.scores.length > 0) {
+            console.error('\n4. Analyzing activation scores...');
+            result.scores.slice(0, 10).forEach((score, i) => {
+                console.error(`  ${i + 1}. Entity: ${score.entityId.substring(0, 8)}...`);
+                console.error(`     Activation: ${score.activation.toFixed(4)}`);
+                console.error(`     Source: ${score.source}`);
+                console.error(`     Hops: ${score.hops}`);
+                console.error('');
+            });
+            // Verify seed nodes
+            console.error('5. Verifying seed nodes...');
+            const seedCount = result.scores.filter(s => s.source === 'seed').length;
+            const propagatedCount = result.scores.filter(s => s.source === 'propagated').length;
+            console.error(`  - Seed nodes: ${seedCount}`);
+            console.error(`  - Propagated nodes: ${propagatedCount}`);
+            // Check convergence
+            console.error('\n6. Convergence analysis:');
+            console.error(`  - Converged: ${result.converged ? 'Yes' : 'No'}`);
+            console.error(`  - Iterations: ${result.iterations}`);
+            // Verify activation distribution
+            const highActivation = result.scores.filter(s => s.activation >= 0.7).length;
+            const mediumActivation = result.scores.filter(s => s.activation >= 0.3 && s.activation < 0.7).length;
+            const lowActivation = result.scores.filter(s => s.activation < 0.3).length;
+            console.error('\n7. Activation distribution:');
+            console.error(`  - High (≥0.7): ${highActivation}`);
+            console.error(`  - Medium (0.3-0.7): ${mediumActivation}`);
+            console.error(`  - Low (<0.3): ${lowActivation}`);
+        }
+        else {
+            console.error('⚠ No activation scores found');
+        }
+        console.error('\n8. Testing with different seed_top_k...');
+        const result2 = await server.getSpreadingService().spreadActivation('deep learning', 2);
+        console.error(`✓ With seed_top_k=2: ${result2.scores.length} results, ${result2.iterations} iterations`);
+        console.error('\n=== ✓ spreading_activation MCP Tool Test Passed ===\n');
+    }
+    catch (error) {
+        console.error('\n=== ✗ Test Failed ===');
+        console.error('Error:', error);
+        throw error;
+    }
+    finally {
+        // Cleanup
+        server.db.close();
+        if (fs.existsSync(dbFile)) {
+            try {
+                fs.unlinkSync(dbFile);
+                console.error('[Cleanup] Test database removed');
+            }
+            catch (e) {
+                console.error('[Cleanup] Warning: Could not remove test database');
+            }
+        }
+    }
+}
+runTest().catch(console.error);

package/dist/test-suggest-connections-mcp.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const fs = __importStar(require("fs"));
+const TEST_DB_PATH = 'test_suggest_connections_mcp';
+async function runTest() {
+    console.error('=== Testing suggest_connections MCP Tool ===\n');
+    // Clean up old test database
+    const dbFile = `${TEST_DB_PATH}.db`;
+    if (fs.existsSync(dbFile)) {
+        try {
+            fs.unlinkSync(dbFile);
+            console.error('[Cleanup] Removed old test database');
+        }
+        catch (e) {
+            console.error('[Cleanup] Warning: Could not remove old database:', e);
+        }
+    }
+    const server = new index_1.MemoryServer(TEST_DB_PATH);
+    await server.initPromise;
+    try {
+        console.error('1. Creating test entities...');
+        // Create entities
+        const aliceResult = await server.createEntity({ name: 'Alice', type: 'Person', metadata: { role: 'Developer', team: 'Backend' } });
+        const aliceId = aliceResult.id;
+        console.error(`✓ Created Alice: ${aliceId}`);
+        const bobResult = await server.createEntity({ name: 'Bob', type: 'Person', metadata: { role: 'Engineer', team: 'Backend' } });
+        const bobId = bobResult.id;
+        console.error(`✓ Created Bob: ${bobId}`);
+        const charlieResult = await server.createEntity({ name: 'Charlie', type: 'Person', metadata: { role: 'Manager', team: 'Backend' } });
+        const charlieId = charlieResult.id;
+        console.error(`✓ Created Charlie: ${charlieId}`);
+        const davidResult = await server.createEntity({ name: 'David', type: 'Person', metadata: { role: 'Designer', team: 'Frontend' } });
+        const davidId = davidResult.id;
+        console.error(`✓ Created David: ${davidId}`);
+        const projectXResult = await server.createEntity({ name: 'Project X', type: 'Project', metadata: { status: 'active' } });
+        const projectXId = projectXResult.id;
+        console.error(`✓ Created Project X: ${projectXId}`);
+        const projectYResult = await server.createEntity({ name: 'Project Y', type: 'Project', metadata: { status: 'planning' } });
+        const projectYId = projectYResult.id;
+        console.error(`✓ Created Project Y: ${projectYId}\n`);
+        console.error('2. Creating relationships...');
+        // Alice works on Project X
+        await server.createRelation({ from_id: aliceId, to_id: projectXId, relation_type: 'works_on', strength: 1.0, metadata: {} });
+        console.error('✓ Alice works_on Project X');
+        // Bob works on Project X
+        await server.createRelation({ from_id: bobId, to_id: projectXId, relation_type: 'works_on', strength: 1.0, metadata: {} });
+        console.error('✓ Bob works_on Project X');
+        // Charlie manages Project X
+        await server.createRelation({ from_id: charlieId, to_id: projectXId, relation_type: 'manages', strength: 1.0, metadata: {} });
+        console.error('✓ Charlie manages Project X');
+        // Bob knows Charlie
+        await server.createRelation({ from_id: bobId, to_id: charlieId, relation_type: 'knows', strength: 0.8, metadata: {} });
+        console.error('✓ Bob knows Charlie');
+        // David works on Project Y
+        await server.createRelation({ from_id: davidId, to_id: projectYId, relation_type: 'works_on', strength: 1.0, metadata: {} });
+        console.error('✓ David works_on Project Y\n');
+        console.error('3. Testing suggest_connections for Alice via direct method...');
+        const suggestions = await server.getSuggestionsService().suggestConnections(aliceId);
+        console.error('✓ Suggestions retrieved:', {
+            entity_id: aliceId,
+            count: suggestions.length
+        });
+        console.error('3. Testing suggest_connections for Alice via direct method...');
+        const aliceSuggestions = await server.getSuggestionsService().suggestConnections(aliceId);
+        console.error('✓ Suggestions retrieved:', {
+            entity_id: aliceId,
+            count: aliceSuggestions.length
+        });
+        if (aliceSuggestions && aliceSuggestions.length > 0) {
+            console.error('\n4. Analyzing suggestions...');
+            aliceSuggestions.forEach((s, i) => {
+                console.error(`  ${i + 1}. ${s.entity_name} (${s.entity_type})`);
+                console.error(`     Source: ${s.source}`);
+                console.error(`     Confidence: ${s.confidence.toFixed(2)} (${s.confidence_level})`);
+                console.error(`     Reason: ${s.reason}`);
+                if (s.metadata) {
+                    console.error(`     Metadata:`, JSON.stringify(s.metadata));
+                }
+                console.error('');
+            });
+            // Verify expected suggestions
+            console.error('5. Verifying expected patterns...');
+            const bobSuggestion = aliceSuggestions.find((s) => s.entity_name === 'Bob');
+            if (bobSuggestion) {
+                console.error('✓ Found Bob (common neighbor via Project X)');
+            }
+            const charlieSuggestion = aliceSuggestions.find((s) => s.entity_name === 'Charlie');
+            if (charlieSuggestion) {
+                console.error('✓ Found Charlie (graph proximity via Project X)');
+            }
+            const projectYSuggestion = aliceSuggestions.find((s) => s.entity_name === 'Project Y');
+            if (projectYSuggestion) {
+                console.error('✓ Found Project Y (vector similarity)');
+            }
+            // Check confidence levels
+            const highConfidence = aliceSuggestions.filter((s) => s.confidence_level === 'high');
+            const mediumConfidence = aliceSuggestions.filter((s) => s.confidence_level === 'medium');
+            const lowConfidence = aliceSuggestions.filter((s) => s.confidence_level === 'low');
+            console.error('\n6. Confidence distribution:');
+            console.error(`  - High: ${highConfidence.length}`);
+            console.error(`  - Medium: ${mediumConfidence.length}`);
+            console.error(`  - Low: ${lowConfidence.length}`);
+            // Check sources
+            const sources = new Set(aliceSuggestions.map((s) => s.source));
+            console.error('\n7. Discovery sources used:');
+            sources.forEach(source => {
+                const count = aliceSuggestions.filter((s) => s.source === source).length;
+                console.error(`  - ${source}: ${count}`);
+            });
+        }
+        else {
+            console.error('⚠ No suggestions found (this might be expected for sparse graphs)');
+        }
+        console.error('\n8. Testing with custom parameters...');
+        const customSuggestions = await server.getSuggestionsService().suggestConnections(bobId);
+        console.error(`✓ Custom suggestions for Bob: ${customSuggestions.length} results`);
+        console.error('\n=== ✓ suggest_connections MCP Tool Test Passed ===\n');
+    }
+    catch (error) {
+        console.error('\n=== ✗ Test Failed ===');
+        console.error('Error:', error);
+        throw error;
+    }
+    finally {
+        // Cleanup
+        server.db.close();
+        if (fs.existsSync(dbFile)) {
+            try {
+                fs.unlinkSync(dbFile);
+                console.error('[Cleanup] Test database removed');
+            }
+            catch (e) {
+                console.error('[Cleanup] Warning: Could not remove test database');
+            }
+        }
+    }
+}
+runTest().catch(console.error);