cozo-memory 1.1.6 → 1.1.7

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozo-memory",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "mcpName": "io.github.tobs-code/cozo-memory",
   "description": "Local-first persistent memory system for AI agents with hybrid search, graph reasoning, and MCP integration",
   "main": "dist/index.js",