cozo-memory 1.1.8 → 1.2.1

package/dist/test-advanced-search-mcp.js

@@ -0,0 +1,204 @@
+"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_advanced_search_mcp';
+async function runTest() {
+    console.error('=== Testing qafd_search and hierarchical_memory_query MCP Tools ===\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 and relationships...');
+        const entity1 = await server.createEntity({
+            name: 'Machine Learning',
+            type: 'Topic',
+            metadata: {}
+        });
+        const entity2 = await server.createEntity({
+            name: 'Neural Networks',
+            type: 'Topic',
+            metadata: {}
+        });
+        const entity3 = await server.createEntity({
+            name: 'Deep Learning',
+            type: 'Topic',
+            metadata: {}
+        });
+        console.error(`✓ Created 3 entities\n`);
+        // Create relationships
+        await server.createRelation({
+            from_id: entity1.id,
+            to_id: entity2.id,
+            relation_type: 'includes',
+            strength: 0.9
+        });
+        await server.createRelation({
+            from_id: entity2.id,
+            to_id: entity3.id,
+            relation_type: 'specializes_to',
+            strength: 0.85
+        });
+        console.error('✓ Created relationships\n');
+        // Add observations at different levels
+        await server.addObservation({
+            entity_id: entity1.id,
+            text: 'Machine learning is a subset of artificial intelligence',
+            metadata: { memory_level: 0 },
+            deduplicate: false
+        });
+        await server.addObservation({
+            entity_id: entity2.id,
+            text: 'Neural networks are inspired by biological neurons',
+            metadata: { memory_level: 0 },
+            deduplicate: false
+        });
+        await server.addObservation({
+            entity_id: entity3.id,
+            text: 'Deep learning uses multiple layers of neural networks',
+            metadata: { memory_level: 1 },
+            deduplicate: false
+        });
+        console.error('✓ Added observations at different memory levels\n');
+        console.error('2. Testing qafd_search (Query-Aware Flow Diffusion)...');
+        const qafdResult = await server.getQueryAwareTraversal().hybridSearch('artificial intelligence and neural networks', {
+            seedTopK: 2,
+            maxHops: 2,
+            dampingFactor: 0.85,
+            minScore: 0.05,
+            topK: 10
+        });
+        console.error(`✓ QAFD search completed: ${qafdResult.length} results found`);
+        if (qafdResult.length > 0) {
+            console.error('\n3. Analyzing QAFD results...');
+            qafdResult.slice(0, 3).forEach((result, i) => {
+                console.error(`\n  Result ${i + 1}:`);
+                console.error(`    Entity: ${result.name || result.entity_name || 'Unknown'}`);
+                console.error(`    Score: ${result.score?.toFixed(4) || result.finalScore?.toFixed(4) || 'N/A'}`);
+                console.error(`    Hops: ${result.hops || result.hop || 0}`);
+            });
+        }
+        console.error('\n4. Testing hierarchical_memory_query...');
+        // Query all levels
+        const queryEmbedding = await server.embeddingService.embed('neural networks and deep learning');
+        const allLevelsResult = await server.db.run(`
+      ?[id, entity_id, text, memory_level, dist] :=
+        ~observation:semantic{
+          id | 
+          query: vec($embedding), 
+          k: 10, 
+          ef: 100, 
+          bind_distance: dist
+        },
+        *observation{id, entity_id, text, metadata, @ "NOW"},
+        memory_level = get(metadata, "memory_level", 0)
+      
+      :order dist
+    `, { embedding: queryEmbedding });
+        const observations = allLevelsResult.rows.map((r) => ({
+            id: r[0],
+            entity_id: r[1],
+            text: r[2],
+            memory_level: r[3],
+            distance: r[4]
+        }));
+        console.error(`✓ Hierarchical memory query completed: ${observations.length} results found`);
+        if (observations.length > 0) {
+            console.error('\n5. Analyzing hierarchical memory results...');
+            const byLevel = {};
+            observations.forEach((obs) => {
+                byLevel[obs.memory_level] = (byLevel[obs.memory_level] || 0) + 1;
+            });
+            console.error('  Distribution by level:');
+            Object.entries(byLevel).forEach(([level, count]) => {
+                console.error(`    L${level}: ${count} observations`);
+            });
+            console.error('\n  Top 3 results:');
+            observations.slice(0, 3).forEach((obs, i) => {
+                console.error(`\n    ${i + 1}. Level ${obs.memory_level}`);
+                console.error(`       Text: ${obs.text.substring(0, 60)}...`);
+                console.error(`       Distance: ${obs.distance.toFixed(4)}`);
+            });
+        }
+        console.error('\n6. Testing hierarchical_memory_query with level filter...');
+        const l0OnlyResult = await server.db.run(`
+      ?[id, entity_id, text, memory_level, dist] :=
+        ~observation:semantic{
+          id | 
+          query: vec($embedding), 
+          k: 10, 
+          ef: 100, 
+          bind_distance: dist
+        },
+        *observation{id, entity_id, text, metadata, @ "NOW"},
+        memory_level = get(metadata, "memory_level", 0),
+        memory_level = 0
+      
+      :order dist
+    `, { embedding: queryEmbedding });
+        console.error(`✓ L0-only query completed: ${l0OnlyResult.rows.length} results found`);
+        console.error('\n=== ✓ Advanced Search MCP Tools 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-conflicts-mcp.js

@@ -0,0 +1,173 @@
+"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_conflicts_mcp';
+async function runTest() {
+    console.error('=== Testing detect_conflicts and resolve_conflicts MCP Tools ===\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 entity...');
+        const entityResult = await server.createEntity({
+            name: 'Project Alpha',
+            type: 'Project',
+            metadata: {}
+        });
+        const entityId = entityResult.id;
+        console.error(`✓ Created entity: ${entityId}\n`);
+        console.error('2. Adding observations with potential conflicts...');
+        // Add first observation
+        const obs1 = await server.addObservation({
+            entity_id: entityId,
+            text: 'Project status is pending approval',
+            metadata: { timestamp: Date.now() }
+        });
+        console.error(`✓ Added observation 1: ${obs1.id?.substring(0, 8)}...`);
+        // Wait a bit to ensure different timestamps
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Add redundant observation (very similar)
+        const obs2 = await server.addObservation({
+            entity_id: entityId,
+            text: 'Project status is pending approval and waiting',
+            metadata: { timestamp: Date.now() }
+        });
+        console.error(`✓ Added observation 2 (redundant): ${obs2.id?.substring(0, 8)}...`);
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Add superseding observation
+        const obs3 = await server.addObservation({
+            entity_id: entityId,
+            text: 'Project status updated: now approved and in progress',
+            metadata: { timestamp: Date.now() }
+        });
+        console.error(`✓ Added observation 3 (superseding): ${obs3.id?.substring(0, 8)}...`);
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Add contradictory observation
+        const obs4 = await server.addObservation({
+            entity_id: entityId,
+            text: 'Project is not approved and has been rejected',
+            metadata: { timestamp: Date.now() }
+        });
+        console.error(`✓ Added observation 4 (contradictory): ${obs4.id?.substring(0, 8)}...\n`);
+        console.error('3. Testing detect_conflicts...');
+        const conflicts = await server.getConflictService().detectConflicts(entityId);
+        console.error(`✓ Conflict detection completed: ${conflicts.length} conflicts found`);
+        if (conflicts.length > 0) {
+            console.error('\n4. Analyzing detected conflicts...');
+            conflicts.forEach((conflict, i) => {
+                console.error(`\n  Conflict ${i + 1}:`);
+                console.error(`    Type: ${conflict.conflict_type}`);
+                console.error(`    Confidence: ${conflict.confidence.toFixed(2)} (${conflict.confidence_level})`);
+                console.error(`    Older: "${conflict.older_text.substring(0, 50)}..."`);
+                console.error(`    Newer: "${conflict.newer_text.substring(0, 50)}..."`);
+                console.error(`    Reason: ${conflict.reason}`);
+            });
+            // Verify conflict types
+            console.error('\n5. Verifying conflict types...');
+            const redundancyConflicts = conflicts.filter(c => c.conflict_type === 'temporal_redundancy');
+            const contradictionConflicts = conflicts.filter(c => c.conflict_type === 'semantic_contradiction');
+            const supersededConflicts = conflicts.filter(c => c.conflict_type === 'superseded_fact');
+            console.error(`  - Temporal Redundancy: ${redundancyConflicts.length}`);
+            console.error(`  - Semantic Contradiction: ${contradictionConflicts.length}`);
+            console.error(`  - Superseded Fact: ${supersededConflicts.length}`);
+            // Check confidence levels
+            const highConfidence = conflicts.filter(c => c.confidence_level === 'high');
+            const mediumConfidence = conflicts.filter(c => c.confidence_level === 'medium');
+            const lowConfidence = conflicts.filter(c => c.confidence_level === 'low');
+            console.error('\n6. Confidence distribution:');
+            console.error(`  - High: ${highConfidence.length}`);
+            console.error(`  - Medium: ${mediumConfidence.length}`);
+            console.error(`  - Low: ${lowConfidence.length}`);
+            console.error('\n7. Testing resolve_conflicts...');
+            const resolution = await server.getConflictService().resolveConflicts(entityId);
+            console.error(`✓ Conflict resolution completed:`);
+            console.error(`  - Resolved conflicts: ${resolution.resolved_conflicts}`);
+            console.error(`  - Invalidated observations: ${resolution.invalidated_observations.length}`);
+            console.error(`  - Audit trail entries: ${resolution.audit_observations.length}`);
+            if (resolution.invalidated_observations.length > 0) {
+                console.error('\n8. Verifying invalidated observations...');
+                console.error(`  Invalidated IDs: ${resolution.invalidated_observations.map(id => id.substring(0, 8)).join(', ')}...`);
+            }
+            if (resolution.audit_observations.length > 0) {
+                console.error('\n9. Verifying audit trail...');
+                console.error(`  Audit IDs: ${resolution.audit_observations.map(id => id.substring(0, 8)).join(', ')}...`);
+            }
+            console.error('\n10. Re-checking for conflicts after resolution...');
+            const remainingConflicts = await server.getConflictService().detectConflicts(entityId);
+            console.error(`✓ Remaining conflicts: ${remainingConflicts.length} (expected: 0)`);
+            if (remainingConflicts.length === 0) {
+                console.error('  ✓ All conflicts successfully resolved!');
+            }
+            else {
+                console.error('  ⚠ Some conflicts remain (this may be expected for certain conflict types)');
+            }
+        }
+        else {
+            console.error('⚠ No conflicts detected (observations may be too dissimilar)');
+        }
+        console.error('\n=== ✓ Conflict Detection and Resolution MCP Tools 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-emotional-salience.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const emotional_salience_1 = require("./emotional-salience");
+async function testEmotionalSalience() {
+    console.log('=== Emotional Salience Weighting Test ===\n');
+    const db = new cozo_node_1.CozoDb();
+    const salienceService = new emotional_salience_1.EmotionalSalienceService(db, {
+        enableSalience: true,
+        salienceBoostFactor: 2.0,
+        decaySlowdownFactor: 0.5,
+        minSalienceThreshold: 0.3
+    });
+    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?,
+      }
+    `);
+        console.log('✓ Database initialized\n');
+        // Test 1: Create test observations with varying emotional salience
+        console.log('Test 1: Creating observations with different salience levels...');
+        const testObservations = [
+            {
+                text: 'CRITICAL: Never forget to backup the database before deployment. This is extremely important!',
+                expected: 'high'
+            },
+            {
+                text: 'Important reminder: The deadline for the project is next Friday.',
+                expected: 'medium'
+            },
+            {
+                text: 'Interesting discovery: The new algorithm is 20% faster than the old one.',
+                expected: 'medium'
+            },
+            {
+                text: 'Note: The meeting is scheduled for 3 PM tomorrow.',
+                expected: 'low'
+            },
+            {
+                text: 'The weather is nice today.',
+                expected: 'neutral'
+            },
+            {
+                text: 'URGENT: Security vulnerability detected in authentication module. Immediate action required!',
+                expected: 'high'
+            },
+            {
+                text: 'Surprising breakthrough in machine learning research announced today.',
+                expected: 'medium'
+            }
+        ];
+        // Create entity
+        const entityResult = await db.run(`
+      ?[id, name, type] <- [['test-entity', 'Test Entity', 'Test']]
+      :put entity {id, name, type}
+    `);
+        for (const obs of testObservations) {
+            const obsId = `obs-${Math.random().toString(36).substring(7)}`;
+            await db.run(`
+        ?[id, entity_id, text, metadata] <- [[
+          $id,
+          'test-entity',
+          $text,
+          {}
+        ]]
+        :put observation {id, entity_id, text, metadata}
+      `, { id: obsId, text: obs.text });
+        }
+        console.log(`✓ Created ${testObservations.length} test observations\n`);
+        // Test 2: Calculate salience scores
+        console.log('Test 2: Calculating salience scores...');
+        const scores = await salienceService.scoreAllObservations();
+        console.log(`\nSalience Scores (sorted by score):`);
+        console.log('─'.repeat(80));
+        for (const score of scores.slice(0, 10)) {
+            console.log(`Score: ${score.salienceScore.toFixed(3)} | Category: ${score.category.toUpperCase()}`);
+            console.log(`Text: ${score.text.substring(0, 70)}${score.text.length > 70 ? '...' : ''}`);
+            console.log(`Keywords: ${score.detectedKeywords.join(', ')}`);
+            console.log(`Boost: Strength ×${score.boost.strengthMultiplier.toFixed(2)}, Decay -${(score.boost.decayReduction * 100).toFixed(0)}%`);
+            console.log(`Reason: ${score.reason}`);
+            console.log('─'.repeat(80));
+        }
+        // Test 3: Verify keyword detection
+        console.log('\nTest 3: Verifying keyword detection accuracy...');
+        let correctDetections = 0;
+        for (let i = 0; i < testObservations.length; i++) {
+            const expected = testObservations[i].expected;
+            const actual = scores.find(s => s.text === testObservations[i].text)?.category || 'neutral';
+            const match = expected === actual;
+            correctDetections += match ? 1 : 0;
+            console.log(`${match ? '✓' : '✗'} Expected: ${expected.padEnd(8)} | Actual: ${actual.padEnd(8)} | "${testObservations[i].text.substring(0, 50)}..."`);
+        }
+        console.log(`\nAccuracy: ${correctDetections}/${testObservations.length} (${(correctDetections / testObservations.length * 100).toFixed(1)}%)\n`);
+        // Test 4: Apply salience metadata (dry run)
+        console.log('Test 4: Applying salience metadata (dry run)...');
+        const dryRunResult = await salienceService.applySalienceMetadata(true);
+        console.log(`Would update ${dryRunResult.updated} observations (dry run)`);
+        console.log(`Observations with salience >= threshold: ${dryRunResult.scores.length}\n`);
+        // Test 5: Apply salience metadata (actual)
+        console.log('Test 5: Applying salience metadata (actual)...');
+        const applyResult = await salienceService.applySalienceMetadata(false);
+        console.log(`✓ Updated ${applyResult.updated} observations with salience metadata\n`);
+        // Test 6: Get statistics
+        console.log('Test 6: Getting salience statistics...');
+        const stats = await salienceService.getSalienceStats();
+        console.log(`Total Observations: ${stats.totalObservations}`);
+        console.log(`With Salience (>= threshold): ${stats.withSalience}`);
+        console.log(`Average Salience: ${stats.averageSalience.toFixed(3)}`);
+        console.log(`\nDistribution:`);
+        console.log(`  High (>= 0.7):    ${stats.distribution.high}`);
+        console.log(`  Medium (0.4-0.7): ${stats.distribution.medium}`);
+        console.log(`  Low (0.3-0.4):    ${stats.distribution.low}`);
+        console.log(`  Neutral (< 0.3):  ${stats.distribution.neutral}`);
+        console.log(`\nTop Keywords:`);
+        for (const { keyword, count } of stats.topKeywords.slice(0, 5)) {
+            console.log(`  ${keyword.padEnd(20)} ${count}`);
+        }
+        console.log();
+        // Test 7: Get specific observation salience
+        console.log('Test 7: Getting salience for specific observation...');
+        const firstScore = scores[0];
+        const specificSalience = await salienceService.getObservationSalience(firstScore.observationId);
+        if (specificSalience) {
+            console.log(`✓ Retrieved salience for observation: ${specificSalience.observationId}`);
+            console.log(`  Score: ${specificSalience.salienceScore.toFixed(3)}`);
+            console.log(`  Category: ${specificSalience.category}`);
+            console.log(`  Keywords: ${specificSalience.detectedKeywords.join(', ')}`);
+        }
+        console.log();
+        // Test 8: Test edge cases
+        console.log('Test 8: Testing edge cases...');
+        const edgeCases = [
+            { text: '', expected: 0 },
+            { text: 'CRITICAL URGENT IMPORTANT NEVER FORGET', expected: 1.0 },
+            { text: 'critical critical critical', expected: 1.0 }, // Duplicate keywords
+            { text: 'This is critically important and urgent!', expected: 0.8 }
+        ];
+        for (const testCase of edgeCases) {
+            const result = salienceService.calculateSalienceScore(testCase.text);
+            const pass = Math.abs(result.score - testCase.expected) < 0.2; // Allow 0.2 tolerance
+            console.log(`${pass ? '✓' : '✗'} "${testCase.text}" => ${result.score.toFixed(3)} (expected ~${testCase.expected})`);
+        }
+        console.log();
+        // Test 9: Integration with Memory Activation
+        console.log('Test 9: Demonstrating integration with Memory Activation...');
+        console.log('Salience boosts can be applied to ACT-R Memory Activation:');
+        console.log('  - High salience (0.8): Strength ×1.8, Decay -40%');
+        console.log('  - Medium salience (0.5): Strength ×1.5, Decay -25%');
+        console.log('  - Low salience (0.3): Strength ×1.3, Decay -15%');
+        console.log('  - Neutral (0.0): No boost applied');
+        console.log('\nThis slows down Ebbinghaus forgetting curve for emotionally salient memories.\n');
+        console.log('=== All Tests Completed Successfully ===');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+// Run tests
+testEmotionalSalience().catch(console.error);