cozo-memory 1.1.6 → 1.1.8

package/dist/test-memory-activation.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const memory_activation_1 = require("./memory-activation");
+async function testMemoryActivation() {
+    console.log('=== Memory Activation Service Test ===\n');
+    const db = new cozo_node_1.CozoDb();
+    const activationService = new memory_activation_1.MemoryActivationService(db, {
+        retentionThreshold: 0.1,
+        initialStrength: 1.0,
+        strengthIncrement: 1.0,
+        timeUnit: 'days'
+    });
+    try {
+        // Setup: Create test entity and observations
+        console.log('--- Setup: Creating test data ---');
+        const entityId = 'test-entity-1';
+        const now = Date.now();
+        const oneDayAgo = now - (24 * 60 * 60 * 1000);
+        const threeDaysAgo = now - (3 * 24 * 60 * 60 * 1000);
+        const sevenDaysAgo = now - (7 * 24 * 60 * 60 * 1000);
+        const thirtyDaysAgo = now - (30 * 24 * 60 * 60 * 1000);
+        // Create entity relation
+        await db.run(`
+      :create entity {
+        id: String,
+        name: String,
+        type: String,
+        =>
+        metadata: String
+      }
+    `);
+        await db.run(`
+      ?[id, name, type, metadata] <- [
+        [$id, 'Test Entity', 'test', 'test entity']
+      ]
+      :put entity {id, name, type => metadata}
+    `, { id: entityId });
+        // Create observation relation
+        await db.run(`
+      :create observation {
+        id: String,
+        entity_id: String,
+        text: String,
+        =>
+        metadata: Any,
+        created_at: Int
+      }
+    `);
+        // Create observations with different access patterns
+        const observations = [
+            {
+                id: 'obs-1',
+                text: 'Recently accessed, high strength',
+                metadata: { access_count: 5, last_access_time: oneDayAgo },
+                created_at: thirtyDaysAgo
+            },
+            {
+                id: 'obs-2',
+                text: 'Moderately accessed',
+                metadata: { access_count: 2, last_access_time: threeDaysAgo },
+                created_at: thirtyDaysAgo
+            },
+            {
+                id: 'obs-3',
+                text: 'Rarely accessed, weak memory',
+                metadata: { access_count: 1, last_access_time: sevenDaysAgo },
+                created_at: thirtyDaysAgo
+            },
+            {
+                id: 'obs-4',
+                text: 'Never accessed, very weak',
+                metadata: { access_count: 0, last_access_time: thirtyDaysAgo },
+                created_at: thirtyDaysAgo
+            },
+            {
+                id: 'obs-5',
+                text: 'Frequently accessed, very strong',
+                metadata: { access_count: 10, last_access_time: now },
+                created_at: thirtyDaysAgo
+            }
+        ];
+        for (const obs of observations) {
+            await db.run(`
+        ?[id, entity_id, text, metadata, created_at] <- [
+          [$id, $entity_id, $text, $metadata, $created_at]
+        ]
+        :put observation {id, entity_id, text => metadata, created_at}
+      `, {
+                id: obs.id,
+                entity_id: entityId,
+                text: obs.text,
+                metadata: obs.metadata,
+                created_at: obs.created_at
+            });
+        }
+        console.log(`✓ Created ${observations.length} test observations\n`);
+        // Test 1: Calculate activation scores
+        console.log('--- Test 1: Calculate Activation Scores ---');
+        const scores = await activationService.calculateActivationScores(entityId);
+        console.log('Activation Scores (sorted by activation):');
+        for (const score of scores) {
+            console.log(`  ${score.observationId}:`);
+            console.log(`    Activation: ${score.activation.toFixed(4)}`);
+            console.log(`    Strength: ${score.strength.toFixed(2)}`);
+            console.log(`    Time since access: ${score.timeSinceAccess.toFixed(2)} days`);
+            console.log(`    Access count: ${score.accessCount}`);
+            console.log(`    Should retain: ${score.shouldRetain}`);
+            console.log(`    Reason: ${score.reason}`);
+        }
+        console.log();
+        // Test 2: Get activation statistics
+        console.log('--- Test 2: Activation Statistics ---');
+        const stats = await activationService.getActivationStats(entityId);
+        console.log(`Total observations: ${stats.totalObservations}`);
+        console.log(`Average activation: ${stats.averageActivation.toFixed(4)}`);
+        console.log(`Average strength: ${stats.averageStrength.toFixed(2)}`);
+        console.log(`Below threshold: ${stats.belowThreshold}`);
+        console.log(`Above threshold: ${stats.aboveThreshold}`);
+        console.log('Distribution:');
+        console.log(`  Very weak (<0.1): ${stats.distribution.veryWeak}`);
+        console.log(`  Weak (0.1-0.3): ${stats.distribution.weak}`);
+        console.log(`  Moderate (0.3-0.6): ${stats.distribution.moderate}`);
+        console.log(`  Strong (0.6-0.9): ${stats.distribution.strong}`);
+        console.log(`  Very strong (>0.9): ${stats.distribution.veryStrong}`);
+        console.log();
+        // Test 3: Record access (simulates recall)
+        console.log('--- Test 3: Record Access (Simulate Recall) ---');
+        const weakObsId = 'obs-3';
+        console.log(`Recording access for ${weakObsId}...`);
+        const beforeAccess = scores.find(s => s.observationId === weakObsId);
+        console.log(`Before: activation=${beforeAccess?.activation.toFixed(4)}, strength=${beforeAccess?.strength.toFixed(2)}`);
+        await activationService.recordAccess(weakObsId);
+        const afterScores = await activationService.calculateActivationScores(entityId);
+        const afterAccess = afterScores.find(s => s.observationId === weakObsId);
+        console.log(`After: activation=${afterAccess?.activation.toFixed(4)}, strength=${afterAccess?.strength.toFixed(2)}`);
+        console.log(`✓ Strength increased from ${beforeAccess?.strength.toFixed(2)} to ${afterAccess?.strength.toFixed(2)}`);
+        console.log();
+        // Test 4: Prune weak memories (dry run)
+        console.log('--- Test 4: Prune Weak Memories (Dry Run) ---');
+        const pruneResult = await activationService.pruneWeakMemories(true, entityId);
+        console.log(`Candidates for deletion: ${pruneResult.candidates.length}`);
+        for (const candidate of pruneResult.candidates) {
+            console.log(`  ${candidate.observationId}: ${candidate.reason}`);
+        }
+        console.log(`Would preserve: ${pruneResult.preserved} observations`);
+        console.log();
+        // Test 5: Activation decay over time
+        console.log('--- Test 5: Activation Decay Simulation ---');
+        console.log('Simulating activation decay for obs-2 over time:');
+        const testObs = scores.find(s => s.observationId === 'obs-2');
+        if (testObs) {
+            const strength = testObs.strength;
+            const timePoints = [0, 1, 3, 7, 14, 30, 60, 90];
+            console.log(`Strength: ${strength.toFixed(2)}`);
+            console.log('Time (days) | Activation | Retained?');
+            console.log('------------|------------|----------');
+            for (const days of timePoints) {
+                const activation = Math.exp(-days / strength);
+                const retained = activation >= 0.1;
+                console.log(`${days.toString().padStart(11)} | ${activation.toFixed(4).padStart(10)} | ${retained ? 'Yes' : 'No'}`);
+            }
+        }
+        console.log();
+        // Test 6: Strength progression with repeated recalls
+        console.log('--- Test 6: Strength Progression with Repeated Recalls ---');
+        console.log('Simulating repeated recalls for a new observation:');
+        console.log('Recalls | Strength | Activation (7 days) | Retained?');
+        console.log('--------|----------|---------------------|----------');
+        for (let recalls = 0; recalls <= 10; recalls++) {
+            const strength = 1.0 + recalls * 1.0; // initialStrength + recalls * strengthIncrement
+            const activation = Math.exp(-7 / strength); // 7 days later
+            const retained = activation >= 0.1;
+            console.log(`${recalls.toString().padStart(7)} | ${strength.toFixed(2).padStart(8)} | ${activation.toFixed(4).padStart(19)} | ${retained ? 'Yes' : 'No'}`);
+        }
+        console.log();
+        // Test 7: Compare with different threshold values
+        console.log('--- Test 7: Impact of Different Retention Thresholds ---');
+        const thresholds = [0.05, 0.1, 0.2, 0.3];
+        console.log('Threshold | Retained | Deleted');
+        console.log('----------|----------|--------');
+        for (const threshold of thresholds) {
+            const testService = new memory_activation_1.MemoryActivationService(db, {
+                retentionThreshold: threshold,
+                initialStrength: 1.0,
+                strengthIncrement: 1.0,
+                timeUnit: 'days'
+            });
+            const testScores = await testService.calculateActivationScores(entityId);
+            const retained = testScores.filter(s => s.shouldRetain).length;
+            const deleted = testScores.filter(s => !s.shouldRetain).length;
+            console.log(`${threshold.toFixed(2).padStart(9)} | ${retained.toString().padStart(8)} | ${deleted.toString().padStart(7)}`);
+        }
+        console.log();
+        // Test 8: Verify Ebbinghaus curve shape
+        console.log('--- Test 8: Ebbinghaus Forgetting Curve Verification ---');
+        console.log('Classic Ebbinghaus curve: steep initial decline, then gradual leveling');
+        console.log('Time (days) | Retention (S=1) | Retention (S=5) | Retention (S=10)');
+        console.log('------------|-----------------|-----------------|------------------');
+        const curveTimePoints = [0, 0.5, 1, 2, 5, 10, 20, 30];
+        for (const days of curveTimePoints) {
+            const r1 = Math.exp(-days / 1);
+            const r5 = Math.exp(-days / 5);
+            const r10 = Math.exp(-days / 10);
+            console.log(`${days.toString().padStart(11)} | ${r1.toFixed(4).padStart(15)} | ${r5.toFixed(4).padStart(15)} | ${r10.toFixed(4).padStart(16)}`);
+        }
+        console.log();
+        console.log('✓ All memory activation tests completed successfully!');
+        console.log('\nKey Insights:');
+        console.log('- Higher strength (S) = slower forgetting');
+        console.log('- Each recall increases strength, making memories more durable');
+        console.log('- Activation threshold determines retention policy');
+        console.log('- System naturally implements spaced repetition via activation decay');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+    }
+    finally {
+        db.close();
+    }
+}
+testMemoryActivation();

package/dist/test-query-aware-traversal.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Test: Query-Aware Flow Diffusion Traversal
+ *
+ * Tests the QAFD-RAG inspired query-aware graph traversal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const embedding_service_1 = require("./embedding-service");
+const query_aware_traversal_1 = require("./query-aware-traversal");
+const DB_PATH = 'test_query_aware.cozo.db';
+const EMBEDDING_DIM = 1024;
+async function main() {
+    console.log('='.repeat(80));
+    console.log('Query-Aware Flow Diffusion Traversal Test');
+    console.log('='.repeat(80));
+    // Delete existing database
+    const fs = require('fs');
+    if (fs.existsSync(DB_PATH)) {
+        fs.unlinkSync(DB_PATH);
+        console.log('\n🗑️  Deleted existing database');
+    }
+    // Initialize services
+    const db = new cozo_node_1.CozoDb('sqlite', DB_PATH);
+    const embeddingService = new embedding_service_1.EmbeddingService();
+    const queryAwareTraversal = new query_aware_traversal_1.QueryAwareTraversal(db, embeddingService);
+    try {
+        // Initialize database schema
+        console.log('\n📊 Initializing database schema...');
+        await initializeSchema(db);
+        // Create test data
+        console.log('\n📝 Creating test data...');
+        await createTestData(db, embeddingService);
+        // Test 1: Single-seed traversal
+        console.log('\n' + '='.repeat(80));
+        console.log('Test 1: Query-Aware Traversal from Single Seed');
+        console.log('='.repeat(80));
+        const results1 = await queryAwareTraversal.traverse('typescript', 'TypeScript programming and development', {
+            maxHops: 2,
+            dampingFactor: 0.85,
+            minScore: 0.05,
+            topK: 10
+        });
+        console.log(`\nFound ${results1.length} results:\n`);
+        results1.forEach((result, index) => {
+            console.log(`${index + 1}. ${result.name} (${result.type})`);
+            console.log(`   Score: ${result.score.toFixed(4)}`);
+            console.log(`   Hops: ${result.hops}`);
+            console.log(`   Path Score: ${result.path_score.toFixed(4)}`);
+        });
+        // Test 2: Multi-seed traversal
+        console.log('\n' + '='.repeat(80));
+        console.log('Test 2: Query-Aware Traversal from Multiple Seeds');
+        console.log('='.repeat(80));
+        const results2 = await queryAwareTraversal.traverseFromSeeds(['typescript', 'react'], 'modern web development frameworks', {
+            maxHops: 2,
+            dampingFactor: 0.85,
+            minScore: 0.05,
+            topK: 10
+        });
+        console.log(`\nFound ${results2.length} results:\n`);
+        results2.forEach((result, index) => {
+            console.log(`${index + 1}. ${result.name} (${result.type})`);
+            console.log(`   Score: ${result.score.toFixed(4)}`);
+            console.log(`   Hops: ${result.hops}`);
+        });
+        // Test 3: Hybrid search (Vector + Query-Aware Traversal)
+        console.log('\n' + '='.repeat(80));
+        console.log('Test 3: Hybrid Search (Vector Seeds + Query-Aware Traversal)');
+        console.log('='.repeat(80));
+        const results3 = await queryAwareTraversal.hybridSearch('JavaScript frameworks for building user interfaces', {
+            seedTopK: 3,
+            maxHops: 2,
+            dampingFactor: 0.85,
+            minScore: 0.05,
+            topK: 10
+        });
+        console.log(`\nFound ${results3.length} results:\n`);
+        results3.forEach((result, index) => {
+            console.log(`${index + 1}. ${result.name} (${result.type})`);
+            console.log(`   Score: ${result.score.toFixed(4)}`);
+            console.log(`   Hops: ${result.hops}`);
+            console.log(`   Source: ${result.source}`);
+        });
+        // Test 4: Filtered by relationship type
+        console.log('\n' + '='.repeat(80));
+        console.log('Test 4: Query-Aware Traversal with Relationship Filter');
+        console.log('='.repeat(80));
+        const results4 = await queryAwareTraversal.traverse('alice', 'TypeScript expertise and projects', {
+            maxHops: 2,
+            dampingFactor: 0.85,
+            minScore: 0.05,
+            topK: 10,
+            relationTypes: ['expert_in', 'works_on']
+        });
+        console.log(`\nFound ${results4.length} results (filtered by expert_in, works_on):\n`);
+        results4.forEach((result, index) => {
+            console.log(`${index + 1}. ${result.name} (${result.type})`);
+            console.log(`   Score: ${result.score.toFixed(4)}`);
+            console.log(`   Hops: ${result.hops}`);
+        });
+        console.log('\n' + '='.repeat(80));
+        console.log('✅ All tests completed successfully!');
+        console.log('='.repeat(80));
+    }
+    catch (error) {
+        console.error('\n❌ Test failed:', error);
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+async function initializeSchema(db) {
+    // Drop existing relations if they exist
+    try {
+        await db.run('::remove entity');
+    }
+    catch (e) { }
+    try {
+        await db.run('::remove relationship');
+    }
+    catch (e) { }
+    // Entity relation with embeddings
+    await db.run(`
+    :create entity {
+      id: String,
+      created_at: Validity
+      =>
+      name: String,
+      type: String,
+      embedding: <F32; ${EMBEDDING_DIM}>,
+      metadata: Json
+    }
+  `);
+    // HNSW index for semantic search
+    await db.run(`
+    ::hnsw create entity:semantic {
+      dim: ${EMBEDDING_DIM},
+      m: 50,
+      ef_construction: 200,
+      fields: [embedding],
+      distance: Cosine,
+      extend_candidates: true,
+      keep_pruned_connections: true
+    }
+  `);
+    // Relationship relation
+    await db.run(`
+    :create relationship {
+      from_id: String,
+      to_id: String,
+      relation_type: String,
+      created_at: Validity
+      =>
+      strength: Float,
+      metadata: Json
+    }
+  `);
+    console.log('✅ Schema initialized');
+}
+async function createTestData(db, embeddingService) {
+    const now = Date.now() * 1000; // microseconds
+    // Create entities with embeddings
+    const entities = [
+        { id: 'alice', name: 'Alice Johnson', type: 'Person', text: 'Alice is a senior TypeScript developer and expert in React' },
+        { id: 'bob', name: 'Bob Smith', type: 'Person', text: 'Bob is a JavaScript developer learning TypeScript and Vue.js' },
+        { id: 'typescript', name: 'TypeScript', type: 'Technology', text: 'TypeScript is a typed superset of JavaScript for large-scale applications' },
+        { id: 'javascript', name: 'JavaScript', type: 'Technology', text: 'JavaScript is a dynamic programming language for web development' },
+        { id: 'react', name: 'React', type: 'Framework', text: 'React is a JavaScript library for building user interfaces' },
+        { id: 'vue', name: 'Vue.js', type: 'Framework', text: 'Vue.js is a progressive JavaScript framework for building UIs' },
+        { id: 'angular', name: 'Angular', type: 'Framework', text: 'Angular is a TypeScript-based web application framework' },
+        { id: 'project-x', name: 'Project X', type: 'Project', text: 'Project X is a large-scale TypeScript application using React' },
+        { id: 'project-y', name: 'Project Y', type: 'Project', text: 'Project Y is a Vue.js application with TypeScript support' },
+        { id: 'nodejs', name: 'Node.js', type: 'Runtime', text: 'Node.js is a JavaScript runtime built on Chrome V8 engine' }
+    ];
+    for (const entity of entities) {
+        const embedding = await embeddingService.embed(entity.text);
+        await db.run(`
+      ?[id, created_at, name, type, embedding, metadata] <- [[$id, $created_at, $name, $type, $embedding, $metadata]]
+      :put entity {id, created_at, name, type, embedding, metadata}
+    `, {
+            id: entity.id,
+            created_at: [now, true],
+            name: entity.name,
+            type: entity.type,
+            embedding,
+            metadata: {}
+        });
+    }
+    // Create relationships
+    const relationships = [
+        { from: 'alice', to: 'typescript', type: 'expert_in', strength: 0.95 },
+        { from: 'alice', to: 'react', type: 'expert_in', strength: 0.90 },
+        { from: 'alice', to: 'project-x', type: 'works_on', strength: 0.85 },
+        { from: 'bob', to: 'javascript', type: 'expert_in', strength: 0.80 },
+        { from: 'bob', to: 'typescript', type: 'learning', strength: 0.60 },
+        { from: 'bob', to: 'vue', type: 'uses', strength: 0.75 },
+        { from: 'bob', to: 'project-y', type: 'works_on', strength: 0.70 },
+        { from: 'typescript', to: 'javascript', type: 'extends', strength: 1.0 },
+        { from: 'react', to: 'javascript', type: 'uses', strength: 0.95 },
+        { from: 'vue', to: 'javascript', type: 'uses', strength: 0.95 },
+        { from: 'angular', to: 'typescript', type: 'uses', strength: 1.0 },
+        { from: 'project-x', to: 'typescript', type: 'uses', strength: 1.0 },
+        { from: 'project-x', to: 'react', type: 'uses', strength: 0.95 },
+        { from: 'project-y', to: 'vue', type: 'uses', strength: 0.95 },
+        { from: 'project-y', to: 'typescript', type: 'uses', strength: 0.80 },
+        { from: 'react', to: 'nodejs', type: 'runs_on', strength: 0.85 },
+        { from: 'vue', to: 'nodejs', type: 'runs_on', strength: 0.85 }
+    ];
+    for (const rel of relationships) {
+        await db.run(`
+      ?[from_id, to_id, relation_type, created_at, strength, metadata] <- [[$from_id, $to_id, $relation_type, $created_at, $strength, $metadata]]
+      :put relationship {from_id, to_id, relation_type, created_at, strength, metadata}
+    `, {
+            from_id: rel.from,
+            to_id: rel.to,
+            relation_type: rel.type,
+            created_at: [now, true],
+            strength: rel.strength,
+            metadata: {}
+        });
+    }
+    console.log('✅ Test data created');
+}
+main().catch(console.error);

package/dist/test-query-pipeline.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const embedding_service_1 = require("./embedding-service");
+const hybrid_search_1 = require("./hybrid-search");
+const reranker_service_1 = require("./reranker-service");
+const query_pipeline_1 = require("./query-pipeline");
+async function testQueryPipeline() {
+    console.log('=== Query Pipeline Test ===\n');
+    const db = new cozo_node_1.CozoDb();
+    const embeddingService = new embedding_service_1.EmbeddingService();
+    const hybridSearch = new hybrid_search_1.HybridSearch(db, embeddingService);
+    const reranker = new reranker_service_1.RerankerService();
+    try {
+        console.log('--- Test 1: Pipeline Builder ---');
+        const customPipeline = new query_pipeline_1.PipelineBuilder('test-pipeline')
+            .addPreprocess(query_pipeline_1.preprocessStages.queryNormalization())
+            .addPreprocess(query_pipeline_1.preprocessStages.embedQuery(embeddingService))
+            .addPostProcess(query_pipeline_1.postProcessStages.scoreNormalization())
+            .addPostProcess(query_pipeline_1.postProcessStages.topK())
+            .build();
+        console.log('Pipeline name:', customPipeline.name);
+        console.log('Number of stages:', customPipeline.stages.length);
+        console.log('Stage types:', customPipeline.stages.map(s => s.type).join(', '));
+        console.log('✓ Pipeline builder works\n');
+        // Test 2: Preprocessing Stages
+        console.log('--- Test 2: Preprocessing Stages ---');
+        const pipeline = new query_pipeline_1.QueryPipeline(customPipeline);
+        const result = await pipeline.execute('  HELLO WORLD  ', { topK: 5 });
+        console.log('Original query: "  HELLO WORLD  "');
+        console.log('Normalized query:', result.metadata.query || 'not stored');
+        console.log('Embedding generated:', result.metadata.embedding ? 'yes' : 'no');
+        console.log('Metrics:', result.metrics);
+        console.log('✓ Preprocessing stages work\n');
+        // Test 3: Conditional Execution
+        console.log('--- Test 3: Conditional Execution ---');
+        const conditionalConfig = new query_pipeline_1.PipelineBuilder('conditional')
+            .addPreprocess(query_pipeline_1.preprocessStages.queryNormalization())
+            .addPreprocess({
+            type: 'preprocess',
+            name: 'conditional-stage',
+            enabled: true,
+            condition: (ctx) => ctx.query.length > 5,
+            execute: async (ctx) => {
+                ctx.metadata.conditionalExecuted = true;
+                return ctx;
+            }
+        })
+            .build();
+        const conditionalPipeline = new query_pipeline_1.QueryPipeline(conditionalConfig);
+        const shortResult = await conditionalPipeline.execute('hi', {});
+        console.log('Short query "hi":');
+        console.log('  Conditional executed:', shortResult.metadata.conditionalExecuted || false);
+        const longResult = await conditionalPipeline.execute('hello world', {});
+        console.log('Long query "hello world":');
+        console.log('  Conditional executed:', longResult.metadata.conditionalExecuted || false);
+        console.log('✓ Conditional execution works\n');
+        // Test 4: Stage Metrics
+        console.log('--- Test 4: Stage Metrics ---');
+        const metricsConfig = new query_pipeline_1.PipelineBuilder('metrics-test')
+            .addPreprocess(query_pipeline_1.preprocessStages.queryNormalization())
+            .addPreprocess(query_pipeline_1.preprocessStages.embedQuery(embeddingService))
+            .addPostProcess(query_pipeline_1.postProcessStages.scoreNormalization())
+            .build();
+        const metricsPipeline = new query_pipeline_1.QueryPipeline(metricsConfig);
+        const metricsResult = await metricsPipeline.execute('test query', {});
+        console.log('Stage execution times:');
+        for (const [stage, time] of Object.entries(metricsResult.metrics)) {
+            console.log(`  ${stage}: ${time}ms`);
+        }
+        console.log('✓ Metrics collection works\n');
+        // Test 5: Diversity Reranking (without actual results)
+        console.log('--- Test 5: Diversity Reranking ---');
+        const mockResults = [
+            { id: '1', score: 0.9, embedding: [1, 0, 0] },
+            { id: '2', score: 0.85, embedding: [0.9, 0.1, 0] },
+            { id: '3', score: 0.8, embedding: [0, 1, 0] },
+            { id: '4', score: 0.75, embedding: [0, 0.9, 0.1] }
+        ];
+        const diversityConfig = new query_pipeline_1.PipelineBuilder('diversity-test')
+            .addRerank(query_pipeline_1.rerankStages.diversityRerank())
+            .build();
+        const diversityPipeline = new query_pipeline_1.QueryPipeline(diversityConfig);
+        const diversityResult = await diversityPipeline.execute('test', {});
+        diversityResult.results = mockResults;
+        // Manually execute diversity rerank
+        const rerankStage = diversityConfig.stages[0];
+        const ctx = {
+            query: 'test',
+            results: mockResults,
+            metadata: { diversityWeight: 0.5 },
+            metrics: {}
+        };
+        await rerankStage.execute(ctx);
+        console.log('Original order:', mockResults.map(r => r.id).join(', '));
+        console.log('Reranked order:', ctx.results?.map((r) => r.id).join(', '));
+        console.log('✓ Diversity reranking works\n');
+        // Test 6: Deduplication
+        console.log('--- Test 6: Deduplication ---');
+        const duplicateResults = [
+            { id: '1', entity_id: 'e1', score: 0.9, embedding: [1, 0, 0] },
+            { id: '2', entity_id: 'e1', score: 0.85, embedding: [1, 0, 0] }, // duplicate entity_id
+            { id: '3', entity_id: 'e2', score: 0.8, embedding: [0.99, 0.01, 0] }, // similar embedding
+            { id: '4', entity_id: 'e3', score: 0.75, embedding: [0, 1, 0] }
+        ];
+        const dedupConfig = new query_pipeline_1.PipelineBuilder('dedup-test')
+            .addPostProcess(query_pipeline_1.postProcessStages.deduplication())
+            .build();
+        const dedupPipeline = new query_pipeline_1.QueryPipeline(dedupConfig);
+        const dedupCtx = {
+            query: 'test',
+            results: duplicateResults,
+            metadata: { dedupThreshold: 0.95 },
+            metrics: {}
+        };
+        await dedupConfig.stages[0].execute(dedupCtx);
+        console.log('Before dedup:', duplicateResults.length, 'results');
+        console.log('After dedup:', dedupCtx.results?.length, 'results');
+        console.log('Removed:', duplicateResults.length - (dedupCtx.results?.length || 0), 'duplicates');
+        console.log('✓ Deduplication works\n');
+        // Test 7: Score Normalization
+        console.log('--- Test 7: Score Normalization ---');
+        const unnormalizedResults = [
+            { id: '1', score: 100 },
+            { id: '2', score: 75 },
+            { id: '3', score: 50 },
+            { id: '4', score: 25 }
+        ];
+        const normalizeConfig = new query_pipeline_1.PipelineBuilder('normalize-test')
+            .addPostProcess(query_pipeline_1.postProcessStages.scoreNormalization())
+            .build();
+        const normalizeCtx = {
+            query: 'test',
+            results: [...unnormalizedResults],
+            metadata: {},
+            metrics: {}
+        };
+        await normalizeConfig.stages[0].execute(normalizeCtx);
+        console.log('Original scores:', unnormalizedResults.map(r => r.score).join(', '));
+        console.log('Normalized scores:', normalizeCtx.results?.map((r) => r.score.toFixed(2)).join(', '));
+        console.log('✓ Score normalization works\n');
+        console.log('✓ All pipeline tests completed successfully!');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+    }
+    finally {
+        db.close();
+    }
+}
+testQueryPipeline();