cozo-memory 1.1.4 → 1.1.6

package/dist/test-proactive-suggestions.js

@@ -0,0 +1,240 @@
+"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 cozo_node_1 = require("cozo-node");
+const embedding_service_1 = require("./embedding-service");
+const proactive_suggestions_1 = require("./proactive-suggestions");
+const fs = __importStar(require("fs"));
+const DB_PATH = 'test_proactive.db';
+async function runTests() {
+    console.error('[Test] Starting Proactive Suggestions Tests...\n');
+    // Clean up old database
+    if (fs.existsSync(DB_PATH)) {
+        try {
+            fs.unlinkSync(DB_PATH);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb('sqlite', DB_PATH);
+    const embeddings = new embedding_service_1.EmbeddingService();
+    // Create a wrapper to make ProactiveSuggestionsService work with CozoDb
+    const dbWrapper = {
+        getEntity: async (id) => {
+            const res = await db.run('?[name, type, embedding] := *entity{id: $id, name, type, embedding, @ "NOW"}', { id });
+            if (res.rows.length === 0)
+                return null;
+            return {
+                id,
+                name: res.rows[0][0],
+                type: res.rows[0][1],
+                embedding: res.rows[0][2],
+            };
+        },
+        getRelations: async (fromId, toId) => {
+            let query = '?[from_id, to_id, relation_type, strength] := *relationship{from_id, to_id, relation_type, strength, @ "NOW"}';
+            const params = {};
+            if (fromId) {
+                query += ', from_id = $from_id';
+                params.from_id = fromId;
+            }
+            if (toId) {
+                query += ', to_id = $to_id';
+                params.to_id = toId;
+            }
+            const res = await db.run(query, params);
+            return res.rows.map((r) => ({
+                from_id: r[0],
+                to_id: r[1],
+                relation_type: r[2],
+                strength: r[3],
+            }));
+        },
+        vectorSearchEntity: async (embedding, limit) => {
+            const res = await db.run('?[id, name, type] := *entity{id, name, type, @ "NOW"} :limit $limit', { limit });
+            return res.rows.map((r) => [r[0], r[1], r[2], {}, 0.8]);
+        },
+    };
+    const suggestions = new proactive_suggestions_1.ProactiveSuggestionsService(dbWrapper, embeddings, {
+        maxSuggestions: 5,
+        minConfidence: 0.5,
+        enableVectorSimilarity: true,
+        enableCommonNeighbors: true,
+        enableInference: true,
+        enableGraphProximity: true,
+    });
+    try {
+        // Setup: Create test entities and relationships
+        console.error('[Test] Setting up test data...');
+        const EMBEDDING_DIM = embeddings.getDimensions();
+        // Create entity table
+        try {
+            await db.run(`{:create entity {id: String, created_at: Validity => name: String, type: String, embedding: <F32; ${EMBEDDING_DIM}>, name_embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}}`);
+        }
+        catch (e) { }
+        // Create relationship table
+        try {
+            await db.run('{:create relationship {from_id: String, to_id: String, relation_type: String, created_at: Validity => strength: Float, metadata: Json}}');
+        }
+        catch (e) { }
+        // Create entities
+        const aliceEmb = await embeddings.embed('Alice Developer');
+        const bobEmb = await embeddings.embed('Bob Engineer');
+        const charlieEmb = await embeddings.embed('Charlie Manager');
+        const projectXEmb = await embeddings.embed('Project X Development');
+        const projectYEmb = await embeddings.embed('Project Y Research');
+        const now = Date.now() * 1000;
+        await db.run(`
+      ?[id, created_at, name, type, embedding, name_embedding, metadata] <- [
+        ['alice-id', [${now}, true], 'Alice', 'Person', $emb, $emb, {}]
+      ] :insert entity {id, created_at => name, type, embedding, name_embedding, metadata}
+    `, { emb: aliceEmb });
+        await db.run(`
+      ?[id, created_at, name, type, embedding, name_embedding, metadata] <- [
+        ['bob-id', [${now}, true], 'Bob', 'Person', $emb, $emb, {}]
+      ] :insert entity {id, created_at => name, type, embedding, name_embedding, metadata}
+    `, { emb: bobEmb });
+        await db.run(`
+      ?[id, created_at, name, type, embedding, name_embedding, metadata] <- [
+        ['charlie-id', [${now}, true], 'Charlie', 'Person', $emb, $emb, {}]
+      ] :insert entity {id, created_at => name, type, embedding, name_embedding, metadata}
+    `, { emb: charlieEmb });
+        await db.run(`
+      ?[id, created_at, name, type, embedding, name_embedding, metadata] <- [
+        ['project-x-id', [${now}, true], 'Project X', 'Project', $emb, $emb, {}]
+      ] :insert entity {id, created_at => name, type, embedding, name_embedding, metadata}
+    `, { emb: projectXEmb });
+        await db.run(`
+      ?[id, created_at, name, type, embedding, name_embedding, metadata] <- [
+        ['project-y-id', [${now}, true], 'Project Y', 'Project', $emb, $emb, {}]
+      ] :insert entity {id, created_at => name, type, embedding, name_embedding, metadata}
+    `, { emb: projectYEmb });
+        // Create relationships
+        await db.run(`
+      ?[from_id, to_id, relation_type, created_at, strength, metadata] <- [
+        ['alice-id', 'project-x-id', 'works_on', [${now}, true], 1.0, {}],
+        ['bob-id', 'project-x-id', 'works_on', [${now}, true], 1.0, {}],
+        ['charlie-id', 'alice-id', 'manages', [${now}, true], 0.9, {}],
+        ['bob-id', 'project-y-id', 'works_on', [${now}, true], 0.8, {}],
+        ['alice-id', 'bob-id', 'colleague_of', [${now}, true], 0.85, {}]
+      ] :insert relationship {from_id, to_id, relation_type, created_at => strength, metadata}
+    `);
+        console.error('[Test] Test data created.\n');
+        // Test 1: Vector Similarity
+        console.error('[Test 1] Vector Similarity Discovery');
+        const vectorSuggestions = await suggestions.suggestConnections('alice-id');
+        console.error(`  Found ${vectorSuggestions.length} suggestions for Alice`);
+        vectorSuggestions.forEach(s => {
+            console.error(`    - ${s.entity_name} (${s.source}): confidence=${s.confidence.toFixed(2)}`);
+        });
+        console.error('');
+        // Test 2: Common Neighbors
+        console.error('[Test 2] Common Neighbors Detection');
+        const commonNeighborSuggestions = vectorSuggestions.filter(s => s.source === proactive_suggestions_1.SuggestionSource.COMMON_NEIGHBORS);
+        console.error(`  Found ${commonNeighborSuggestions.length} common neighbor suggestions`);
+        commonNeighborSuggestions.forEach(s => {
+            console.error(`    - ${s.entity_name}: ${s.reason}`);
+        });
+        console.error('');
+        // Test 3: Graph Proximity
+        console.error('[Test 3] Graph Proximity Search');
+        const graphProximitySuggestions = vectorSuggestions.filter(s => s.source === proactive_suggestions_1.SuggestionSource.GRAPH_PROXIMITY);
+        console.error(`  Found ${graphProximitySuggestions.length} graph proximity suggestions`);
+        graphProximitySuggestions.forEach(s => {
+            console.error(`    - ${s.entity_name}: ${s.reason}`);
+        });
+        console.error('');
+        // Test 4: Inference
+        console.error('[Test 4] Inference-Based Suggestions');
+        const inferenceSuggestions = vectorSuggestions.filter(s => s.source === proactive_suggestions_1.SuggestionSource.INFERENCE);
+        console.error(`  Found ${inferenceSuggestions.length} inferred suggestions`);
+        inferenceSuggestions.forEach(s => {
+            console.error(`    - ${s.entity_name}: ${s.reason}`);
+        });
+        console.error('');
+        // Test 5: Confidence Levels
+        console.error('[Test 5] Confidence Level Distribution');
+        const highConfidence = vectorSuggestions.filter(s => s.confidence_level === proactive_suggestions_1.ConfidenceLevel.HIGH);
+        const mediumConfidence = vectorSuggestions.filter(s => s.confidence_level === proactive_suggestions_1.ConfidenceLevel.MEDIUM);
+        const lowConfidence = vectorSuggestions.filter(s => s.confidence_level === proactive_suggestions_1.ConfidenceLevel.LOW);
+        console.error(`  High: ${highConfidence.length}, Medium: ${mediumConfidence.length}, Low: ${lowConfidence.length}`);
+        console.error('');
+        // Test 6: Batch Operations
+        console.error('[Test 6] Batch Suggestions');
+        const batchResults = await suggestions.suggestConnectionsBatch(['alice-id', 'bob-id', 'charlie-id']);
+        console.error(`  Processed ${batchResults.size} entities`);
+        for (const [entityId, suggs] of batchResults.entries()) {
+            console.error(`    ${entityId}: ${suggs.length} suggestions`);
+        }
+        console.error('');
+        // Test 7: Configuration
+        console.error('[Test 7] Configuration Management');
+        const config = suggestions.getConfig();
+        console.error(`  Max Suggestions: ${config.maxSuggestions}`);
+        console.error(`  Min Confidence: ${config.minConfidence}`);
+        console.error(`  Vector Similarity Weight: ${config.vectorSimilarityWeight}`);
+        console.error(`  Common Neighbors Weight: ${config.commonNeighborsWeight}`);
+        console.error(`  Inference Weight: ${config.inferenceWeight}`);
+        console.error(`  Graph Proximity Weight: ${config.graphProximityWeight}`);
+        console.error('');
+        // Test 8: Updated Configuration
+        console.error('[Test 8] Updated Configuration');
+        suggestions.updateConfig({
+            maxSuggestions: 3,
+            minConfidence: 0.7,
+        });
+        const updatedConfig = suggestions.getConfig();
+        console.error(`  Max Suggestions (updated): ${updatedConfig.maxSuggestions}`);
+        console.error(`  Min Confidence (updated): ${updatedConfig.minConfidence}`);
+        const updatedSuggestions = await suggestions.suggestConnections('alice-id');
+        console.error(`  Suggestions with new config: ${updatedSuggestions.length}`);
+        console.error('');
+        console.error('[Test] ✅ All tests completed successfully!\n');
+    }
+    catch (error) {
+        console.error('[Test] ❌ Error during testing:', error);
+    }
+    finally {
+        await db.close();
+        // Clean up
+        if (fs.existsSync(DB_PATH)) {
+            try {
+                fs.unlinkSync(DB_PATH);
+            }
+            catch (e) { }
+        }
+    }
+}
+// Run tests
+runTests().catch(console.error);

package/dist/test-temporal-conflict-resolution.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Test suite for Temporal Conflict Resolution Service
+ *
+ * Tests T-GRAG-inspired conflict detection and resolution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const embedding_service_1 = require("./embedding-service");
+const temporal_conflict_resolution_1 = require("./temporal-conflict-resolution");
+const uuid_1 = require("uuid");
+const DB_PATH = 'test_temporal_conflict.cozo.db';
+async function setupDatabase() {
+    const db = new cozo_node_1.CozoDb('sqlite', DB_PATH);
+    // Create schema matching the main codebase format
+    try {
+        await db.run(`
+      :create entity {
+        id: String,
+        created_at: Validity
+        =>
+        name: String,
+        type: String,
+        embedding: <F32; 1024>,
+        name_embedding: <F32; 1024>,
+        metadata: Json
+      }
+    `);
+    }
+    catch (e) {
+        // Schema already exists, ignore
+    }
+    try {
+        await db.run(`
+      :create observation {
+        id: String,
+        created_at: Validity
+        =>
+        entity_id: String,
+        text: String,
+        embedding: <F32; 1024>,
+        metadata: Json
+      }
+    `);
+    }
+    catch (e) {
+        // Schema already exists, ignore
+    }
+    return db;
+}
+async function createTestEntity(db, embeddings, name) {
+    const entityId = (0, uuid_1.v4)();
+    const embedding = await embeddings.embed(name);
+    const now = Date.now() * 1000; // Convert to microseconds
+    await db.run(`
+    ?[id, created_at, name, type, embedding, name_embedding, metadata] := 
+      id = $id,
+      created_at = $created_at,
+      name = $name,
+      type = $type,
+      embedding = $embedding,
+      name_embedding = $name_embedding,
+      metadata = $metadata
+    
+    :put entity {
+      id, created_at => name, type, embedding, name_embedding, metadata
+    }
+  `, {
+        id: entityId,
+        created_at: [now, true], // Validity format: [timestamp_microseconds, is_valid]
+        name,
+        type: 'test',
+        embedding,
+        name_embedding: embedding,
+        metadata: {},
+    });
+    return entityId;
+}
+async function createTestObservation(db, embeddings, entityId, text, createdAt) {
+    const obsId = (0, uuid_1.v4)();
+    const embedding = await embeddings.embed(text);
+    await db.run(`
+    ?[id, created_at, entity_id, text, embedding, metadata] := 
+      id = $id,
+      created_at = $created_at,
+      entity_id = $entity_id,
+      text = $text,
+      embedding = $embedding,
+      metadata = $metadata
+    
+    :put observation {
+      id, created_at => entity_id, text, embedding, metadata
+    }
+  `, {
+        id: obsId,
+        created_at: [createdAt * 1000, true], // Validity format: [timestamp_microseconds, is_valid]
+        entity_id: entityId,
+        text,
+        embedding,
+        metadata: {},
+    });
+    return obsId;
+}
+async function runTests() {
+    console.log('🧪 Starting Temporal Conflict Resolution Tests\n');
+    const db = await setupDatabase();
+    const embeddings = new embedding_service_1.EmbeddingService();
+    const conflictService = new temporal_conflict_resolution_1.TemporalConflictResolutionService(db, embeddings);
+    try {
+        // Test 1: Temporal Redundancy Detection
+        console.log('Test 1: Temporal Redundancy Detection');
+        const entity1 = await createTestEntity(db, embeddings, 'Project Alpha');
+        const now = Date.now();
+        const oneMonthAgo = now - (30 * 24 * 60 * 60 * 1000);
+        await createTestObservation(db, embeddings, entity1, 'Project Alpha is in active development with 5 team members', oneMonthAgo);
+        await createTestObservation(db, embeddings, entity1, 'Project Alpha is actively being developed by a team of 5 people', now);
+        const conflicts1 = await conflictService.detectConflicts(entity1);
+        console.log(`✓ Found ${conflicts1.length} conflict(s)`);
+        if (conflicts1.length > 0) {
+            console.log(`  Type: ${conflicts1[0].conflict_type}`);
+            console.log(`  Confidence: ${(conflicts1[0].confidence * 100).toFixed(1)}%`);
+            console.log(`  Reason: ${conflicts1[0].reason}`);
+        }
+        console.log('');
+        // Test 2: Semantic Contradiction Detection
+        console.log('Test 2: Semantic Contradiction Detection');
+        const entity2 = await createTestEntity(db, embeddings, 'Service Beta');
+        await createTestObservation(db, embeddings, entity2, 'Service Beta is active and running in production', oneMonthAgo);
+        await createTestObservation(db, embeddings, entity2, 'Service Beta has been discontinued and shut down', now);
+        const conflicts2 = await conflictService.detectConflicts(entity2);
+        console.log(`✓ Found ${conflicts2.length} conflict(s)`);
+        if (conflicts2.length > 0) {
+            console.log(`  Type: ${conflicts2[0].conflict_type}`);
+            console.log(`  Confidence: ${(conflicts2[0].confidence * 100).toFixed(1)}%`);
+            console.log(`  Reason: ${conflicts2[0].reason}`);
+        }
+        console.log('');
+        // Test 3: Superseded Fact Detection
+        console.log('Test 3: Superseded Fact Detection');
+        const entity3 = await createTestEntity(db, embeddings, 'Company Revenue');
+        await createTestObservation(db, embeddings, entity3, 'Company revenue was $10 million in Q1 2025', oneMonthAgo);
+        await createTestObservation(db, embeddings, entity3, 'Updated: Company revenue is now $12 million in Q1 2025 after corrections', now);
+        const conflicts3 = await conflictService.detectConflicts(entity3);
+        console.log(`✓ Found ${conflicts3.length} conflict(s)`);
+        if (conflicts3.length > 0) {
+            console.log(`  Type: ${conflicts3[0].conflict_type}`);
+            console.log(`  Confidence: ${(conflicts3[0].confidence * 100).toFixed(1)}%`);
+            console.log(`  Reason: ${conflicts3[0].reason}`);
+        }
+        console.log('');
+        // Test 4: Conflict Resolution
+        console.log('Test 4: Conflict Resolution');
+        const entity4 = await createTestEntity(db, embeddings, 'Product Gamma');
+        await createTestObservation(db, embeddings, entity4, 'Product Gamma is available for purchase', oneMonthAgo);
+        await createTestObservation(db, embeddings, entity4, 'Product Gamma is no longer available and has been removed from catalog', now);
+        const resolution = await conflictService.resolveConflicts(entity4);
+        console.log(`✓ Resolved ${resolution.resolved_conflicts} conflict(s)`);
+        console.log(`  Invalidated observations: ${resolution.invalidated_observations.length}`);
+        console.log(`  Audit observations created: ${resolution.audit_observations.length}`);
+        console.log('');
+        // Test 5: No Conflicts (Different Topics)
+        console.log('Test 5: No Conflicts (Different Topics)');
+        const entity5 = await createTestEntity(db, embeddings, 'Team Delta');
+        await createTestObservation(db, embeddings, entity5, 'Team Delta is working on the frontend', oneMonthAgo);
+        await createTestObservation(db, embeddings, entity5, 'Team Delta completed the backend integration', now);
+        const conflicts5 = await conflictService.detectConflicts(entity5);
+        console.log(`✓ Found ${conflicts5.length} conflict(s) (expected: 0)`);
+        if (conflicts5.length > 0) {
+            console.log(`  Unexpected conflict found:`);
+            console.log(`  Type: ${conflicts5[0].conflict_type}`);
+            console.log(`  Confidence: ${(conflicts5[0].confidence * 100).toFixed(1)}%`);
+            console.log(`  Reason: ${conflicts5[0].reason}`);
+        }
+        console.log('');
+        // Test 6: Configuration Update
+        console.log('Test 6: Configuration Update');
+        const originalConfig = conflictService.getConfig();
+        console.log(`  Original similarity threshold: ${originalConfig.similarityThreshold}`);
+        conflictService.updateConfig({ similarityThreshold: 0.9 });
+        const updatedConfig = conflictService.getConfig();
+        console.log(`  Updated similarity threshold: ${updatedConfig.similarityThreshold}`);
+        console.log('✓ Configuration updated successfully');
+        console.log('');
+        // Test 7: Time Window Filtering
+        console.log('Test 7: Time Window Filtering');
+        const entity7 = await createTestEntity(db, embeddings, 'Old Project');
+        const twoYearsAgo = now - (730 * 24 * 60 * 60 * 1000);
+        await createTestObservation(db, embeddings, entity7, 'Old Project is active', twoYearsAgo);
+        await createTestObservation(db, embeddings, entity7, 'Old Project is inactive', now);
+        // Should not detect conflict due to time window (default 365 days)
+        const conflicts7 = await conflictService.detectConflicts(entity7);
+        console.log(`✓ Found ${conflicts7.length} conflict(s) (expected: 0 due to time window)`);
+        console.log('');
+        // Test 8: Multiple Conflicts
+        console.log('Test 8: Multiple Conflicts');
+        const entity8 = await createTestEntity(db, embeddings, 'Multi Conflict');
+        const threeMonthsAgo = now - (90 * 24 * 60 * 60 * 1000);
+        const twoMonthsAgo = now - (60 * 24 * 60 * 60 * 1000);
+        await createTestObservation(db, embeddings, entity8, 'Status is enabled and operational', threeMonthsAgo);
+        await createTestObservation(db, embeddings, entity8, 'Status is disabled temporarily', twoMonthsAgo);
+        await createTestObservation(db, embeddings, entity8, 'Status is permanently shut down', now);
+        const conflicts8 = await conflictService.detectConflicts(entity8);
+        console.log(`✓ Found ${conflicts8.length} conflict(s)`);
+        conflicts8.forEach((c, i) => {
+            console.log(`  Conflict ${i + 1}: ${c.conflict_type} (confidence: ${(c.confidence * 100).toFixed(1)}%)`);
+        });
+        console.log('');
+        console.log('✅ All tests completed successfully!');
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        throw error;
+    }
+    finally {
+        // Cleanup
+        try {
+            const fs = await import('fs');
+            if (fs.existsSync(DB_PATH)) {
+                fs.unlinkSync(DB_PATH);
+            }
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+    }
+}
+// Run tests
+runTests().catch(console.error);