cozo-memory 1.2.0 → 1.2.2

package/dist/temporal-conflict-resolution.js

@@ -283,20 +283,22 @@ class TemporalConflictResolutionService {
     async invalidateObservation(observationId) {
         // Delete the observation (query without @ "NOW" and filter manually)
         const datalog = `
-      ?[id, created_at, entity_id, text, embedding, metadata] := 
+      ?[id, created_at, entity_id, text, embedding, metadata, session_id, task_id] := 
         *observation{
           id,
           created_at,
           entity_id,
           text,
           embedding,
-          metadata
+          metadata,
+          session_id,
+          task_id
         },
         id = $id,
         to_bool(created_at)
       
       :delete observation {
-        id, created_at, entity_id, text, embedding, metadata
+        id, created_at, entity_id, text, embedding, metadata, session_id, task_id
       }
     `;
         await this.db.run(datalog, { id: observationId });
@@ -311,16 +313,18 @@ class TemporalConflictResolutionService {
         const auditText = `[CONFLICT RESOLVED] ${conflict.conflict_type}: Observation superseded by newer information (confidence: ${(conflict.confidence * 100).toFixed(1)}%)`;
         const embedding = await this.embeddings.embed(auditText);
         const datalog = `
-      ?[id, created_at, entity_id, text, embedding, metadata] := 
+      ?[id, created_at, entity_id, text, embedding, metadata, session_id, task_id] := 
         id = $id,
         created_at = $created_at,
         entity_id = $entity_id,
         text = $text,
         embedding = $embedding,
-        metadata = $metadata
+        metadata = $metadata,
+        session_id = "",
+        task_id = ""
       
       :put observation {
-        id, created_at => entity_id, text, embedding, metadata
+        id, created_at => entity_id, text, embedding, metadata, session_id, task_id
       }
     `;
         await this.db.run(datalog, {

package/dist/test-activation-mcp.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testActivationMCPTools() {
+    console.log("=== Testing ACT-R Memory Activation MCP Tools ===\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: "ACT-R Test Entity",
+            type: "TestEntity",
+            metadata: { purpose: "testing activation" }
+        });
+        console.log("✓ Entity created:", entityResult.id);
+        // Step 2: Add multiple observations
+        console.log("\n2. Adding test observations...");
+        const observations = [
+            "First observation - should have low activation initially",
+            "Second observation - will be accessed multiple times",
+            "Third observation - will remain unaccessed",
+            "Fourth observation - emotionally salient content with URGENT deadline",
+            "Fifth observation - normal content"
+        ];
+        const obsIds = [];
+        for (const text of observations) {
+            const obs = await server.addObservation({
+                entity_id: entityResult.id,
+                text: text,
+                metadata: { test: true }
+            });
+            if (obs.id) {
+                obsIds.push(obs.id);
+                console.log(`✓ Observation added: ${obs.id.substring(0, 8)}...`);
+            }
+        }
+        // Wait a bit to simulate time passing
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // Step 3: Test get_activation_stats (initial state)
+        console.log("\n3. Testing get_activation_stats (initial state)...");
+        const stats1 = await server.getActivationService().getActivationStats(entityResult.id);
+        console.log("✓ Initial activation stats:");
+        console.log(`  - Total observations: ${stats1.totalObservations}`);
+        console.log(`  - Average activation: ${stats1.averageActivation.toFixed(3)}`);
+        console.log(`  - Average strength: ${stats1.averageStrength.toFixed(2)}`);
+        console.log(`  - Below threshold: ${stats1.belowThreshold}`);
+        console.log(`  - Above threshold: ${stats1.aboveThreshold}`);
+        console.log(`  - Distribution:`, stats1.distribution);
+        // Step 4: Test record_memory_access
+        console.log("\n4. Testing record_memory_access...");
+        // Access the second observation multiple times
+        for (let i = 0; i < 3; i++) {
+            await server.getActivationService().recordAccess(obsIds[1]);
+            console.log(`✓ Access ${i + 1} recorded for observation ${obsIds[1].substring(0, 8)}...`);
+        }
+        // Access the first observation once
+        await server.getActivationService().recordAccess(obsIds[0]);
+        console.log(`✓ Access recorded for observation ${obsIds[0].substring(0, 8)}...`);
+        // Step 5: Check activation stats after accesses
+        console.log("\n5. Checking activation stats after accesses...");
+        const stats2 = await server.getActivationService().getActivationStats(entityResult.id);
+        console.log("✓ Updated activation stats:");
+        console.log(`  - Total observations: ${stats2.totalObservations}`);
+        console.log(`  - Average activation: ${stats2.averageActivation.toFixed(3)}`);
+        console.log(`  - Average strength: ${stats2.averageStrength.toFixed(2)}`);
+        console.log(`  - Below threshold: ${stats2.belowThreshold}`);
+        console.log(`  - Above threshold: ${stats2.aboveThreshold}`);
+        console.log(`  - Distribution:`, stats2.distribution);
+        // Step 6: Get detailed activation scores
+        console.log("\n6. Getting detailed activation scores...");
+        const scores = await server.getActivationService().calculateActivationScores(entityResult.id);
+        console.log("✓ Top 3 most active observations:");
+        scores.slice(0, 3).forEach((score, idx) => {
+            console.log(`  ${idx + 1}. Activation: ${score.activation.toFixed(3)}, Strength: ${score.strength.toFixed(1)}, Access count: ${score.accessCount}`);
+        });
+        // Step 7: Test prune_weak_memories (dry run)
+        console.log("\n7. Testing prune_weak_memories (dry run)...");
+        const pruneResult1 = await server.getActivationService().pruneWeakMemories(true, entityResult.id);
+        console.log("✓ Dry run prune result:");
+        console.log(`  - Would prune: ${pruneResult1.pruned}`);
+        console.log(`  - Would preserve: ${pruneResult1.preserved}`);
+        console.log(`  - Candidates for pruning: ${pruneResult1.candidates.length}`);
+        if (pruneResult1.candidates.length > 0) {
+            console.log(`  - Sample candidate: activation=${pruneResult1.candidates[0].activation.toFixed(3)}, reason="${pruneResult1.candidates[0].reason}"`);
+        }
+        // Step 8: Test prune_weak_memories (actual prune)
+        console.log("\n8. Testing prune_weak_memories (actual prune)...");
+        const pruneResult2 = await server.getActivationService().pruneWeakMemories(false, entityResult.id);
+        console.log("✓ Actual prune result:");
+        console.log(`  - Pruned: ${pruneResult2.pruned}`);
+        console.log(`  - Preserved: ${pruneResult2.preserved}`);
+        // Step 9: Final activation stats
+        console.log("\n9. Final activation stats after pruning...");
+        const stats3 = await server.getActivationService().getActivationStats(entityResult.id);
+        console.log("✓ Final stats:");
+        console.log(`  - Total observations: ${stats3.totalObservations}`);
+        console.log(`  - Average activation: ${stats3.averageActivation.toFixed(3)}`);
+        console.log(`  - Average strength: ${stats3.averageStrength.toFixed(2)}`);
+        console.log(`  - Below threshold: ${stats3.belowThreshold}`);
+        console.log(`  - Above threshold: ${stats3.aboveThreshold}`);
+        // Step 10: Test global stats (all entities)
+        console.log("\n10. Testing global activation stats (all entities)...");
+        const globalStats = await server.getActivationService().getActivationStats();
+        console.log("✓ Global stats:");
+        console.log(`  - Total observations: ${globalStats.totalObservations}`);
+        console.log(`  - Average activation: ${globalStats.averageActivation.toFixed(3)}`);
+        console.log(`  - Below threshold: ${globalStats.belowThreshold}`);
+        console.log(`  - Above threshold: ${globalStats.aboveThreshold}`);
+        console.log("\n=== ✓ All ACT-R Memory Activation MCP Tools Tests Passed ===");
+    }
+    catch (error) {
+        console.error("\n✗ Test failed:", error);
+        process.exit(1);
+    }
+}
+testActivationMCPTools();

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);