cozo-memory 1.2.0 → 1.2.2

package/dist/test-zettelkasten-evolution.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const zettelkasten_evolution_1 = require("./zettelkasten-evolution");
+const embedding_service_1 = require("./embedding-service");
+async function testZettelkastenEvolution() {
+    console.log('=== Zettelkasten Memory Evolution Test ===\n');
+    const db = new cozo_node_1.CozoDb();
+    const embeddingService = new embedding_service_1.EmbeddingService();
+    const zettelService = new zettelkasten_evolution_1.ZettelkastenEvolutionService(db, embeddingService, {
+        enableEvolution: true,
+        similarityThreshold: 0.7,
+        maxRelatedNotes: 5,
+        minKeywordFrequency: 1, // Lower for testing
+        autoExtractKeywords: true,
+        autoBidirectionalLinks: true,
+        enrichmentDepth: 'shallow'
+    });
+    try {
+        // Initialize database schema
+        await db.run(`
+      :create entity {
+        id: String,
+        =>
+        name: String,
+        type: String,
+      }
+    `);
+        await db.run(`
+      :create observation {
+        id: String,
+        created_at: Validity,
+        =>
+        entity_id: String,
+        session_id: String?,
+        task_id: String?,
+        text: String,
+        embedding: <F32; 1024>,
+        metadata: Json?,
+      }
+    `);
+        await db.run(`
+      :create relationship {
+        from_id: String,
+        to_id: String,
+        relation_type: String,
+        =>
+        strength: Float,
+        metadata: Json?,
+      }
+    `);
+        // Create HNSW index for semantic search
+        await db.run(`
+      ::hnsw create observation:semantic {
+        dim: 1024,
+        m: 50,
+        dtype: F32,
+        fields: [embedding],
+        distance: Cosine,
+        ef_construction: 200
+      }
+    `);
+        console.log('✓ Database initialized\n');
+        // Test 1: Create test entity
+        console.log('Test 1: Creating test entity...');
+        await db.run(`
+      ?[id, name, type] <- [['test-entity', 'Knowledge Base', 'System']]
+      :put entity {id, name, type}
+    `);
+        console.log('✓ Entity created\n');
+        // Test 2: Create initial observations
+        console.log('Test 2: Creating initial observations...');
+        const testObservations = [
+            {
+                id: 'obs-1',
+                text: 'Machine learning algorithms require large datasets for training. Deep learning models especially need millions of examples.',
+            },
+            {
+                id: 'obs-2',
+                text: 'Neural networks are inspired by biological neurons. They consist of layers of interconnected nodes.',
+            },
+            {
+                id: 'obs-3',
+                text: 'TypeScript provides static typing for JavaScript. This helps catch errors during development.',
+            }
+        ];
+        for (const obs of testObservations) {
+            const embedding = await embeddingService.embed(obs.text);
+            const now = Date.now() * 1000; // Microseconds for Validity
+            await db.run(`
+        ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [[
+          $id,
+          $created_at,
+          'test-entity',
+          null,
+          null,
+          $text,
+          $embedding,
+          {}
+        ]]
+        :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+      `, { id: obs.id, created_at: now, text: obs.text, embedding });
+        }
+        console.log(`✓ Created ${testObservations.length} initial observations\n`);
+        // Test 3: Add new observation and trigger evolution
+        console.log('Test 3: Adding new observation with automatic evolution...');
+        const newObsId = 'obs-4';
+        const newObsText = 'Deep learning is a subset of machine learning that uses neural networks with multiple layers. Training requires substantial computational resources and large datasets.';
+        const newObsEmbedding = await embeddingService.embed(newObsText);
+        // Add to database
+        const now = Date.now() * 1000; // Microseconds for Validity
+        await db.run(`
+      ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [[
+        $id,
+        $created_at,
+        'test-entity',
+        null,
+        null,
+        $text,
+        $embedding,
+        {}
+      ]]
+      :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+    `, { id: newObsId, created_at: now, text: newObsText, embedding: newObsEmbedding });
+        // Trigger evolution
+        const enrichmentResult = await zettelService.enrichObservation(newObsId, newObsText, newObsEmbedding, 'test-entity');
+        console.log(`\nEnrichment Result:`);
+        console.log(`  Observation ID: ${enrichmentResult.observationId}`);
+        console.log(`  Extracted Keywords: ${enrichmentResult.extractedKeywords.join(', ')}`);
+        console.log(`  Added Tags: ${enrichmentResult.addedTags.length > 0 ? enrichmentResult.addedTags.join(', ') : 'none'}`);
+        console.log(`  Related Notes Found: ${enrichmentResult.relatedNotes.length}`);
+        console.log(`  Bidirectional Links Created: ${enrichmentResult.createdLinks}`);
+        console.log(`  Summary: ${enrichmentResult.evolutionSummary}\n`);
+        if (enrichmentResult.relatedNotes.length > 0) {
+            console.log(`Related Notes:`);
+            for (const related of enrichmentResult.relatedNotes) {
+                console.log(`  - ${related.observationId} (similarity: ${related.similarity.toFixed(3)})`);
+                console.log(`    Type: ${related.connectionType}`);
+                console.log(`    Reason: ${related.reason}`);
+                console.log(`    Shared Keywords: ${related.sharedKeywords.join(', ') || 'none'}`);
+                console.log(`    Text: ${related.text.substring(0, 80)}...`);
+            }
+            console.log();
+        }
+        // Test 4: Verify bidirectional links
+        console.log('Test 4: Verifying bidirectional links...');
+        const linksResult = await db.run(`
+      ?[from_id, to_id, relation_type, strength] := 
+        *relationship{from_id, to_id, relation_type, strength},
+        relation_type == 'zettelkasten_link'
+    `);
+        console.log(`✓ Found ${linksResult.rows.length} zettelkasten links`);
+        for (const [from, to, type, strength] of linksResult.rows) {
+            console.log(`  ${from} → ${to} (strength: ${strength.toFixed(3)})`);
+        }
+        console.log();
+        // Test 5: Check metadata enrichment
+        console.log('Test 5: Checking metadata enrichment...');
+        const metadataResult = await db.run(`
+      ?[id, metadata] := 
+        *observation{id, metadata},
+        metadata != null,
+        get(metadata, "zettelkasten_enriched") == true
+    `);
+        console.log(`✓ ${metadataResult.rows.length} observations have been enriched`);
+        for (const [id, metadata] of metadataResult.rows) {
+            const meta = metadata;
+            console.log(`  ${id}:`);
+            if (meta.zettelkasten_keywords) {
+                const keywords = JSON.parse(meta.zettelkasten_keywords);
+                console.log(`    Keywords: ${keywords.join(', ')}`);
+            }
+            if (meta.zettelkasten_related) {
+                const related = JSON.parse(meta.zettelkasten_related);
+                console.log(`    Related: ${related.length} note(s)`);
+            }
+        }
+        console.log();
+        // Test 6: Get evolution statistics
+        console.log('Test 6: Getting evolution statistics...');
+        const stats = await zettelService.getEvolutionStats();
+        console.log(`Total Observations: ${stats.totalObservations}`);
+        console.log(`Enriched Observations: ${stats.enrichedObservations}`);
+        console.log(`Total Zettelkasten Links: ${stats.totalLinks}`);
+        console.log(`Average Links per Note: ${stats.averageLinksPerNote.toFixed(2)}`);
+        console.log();
+        // Test 7: Test keyword extraction
+        console.log('Test 7: Testing keyword extraction...');
+        const testTexts = [
+            'Machine learning algorithms require training data',
+            'The quick brown fox jumps over the lazy dog',
+            'TypeScript TypeScript TypeScript is great for development development'
+        ];
+        for (const text of testTexts) {
+            const keywords = zettelService.extractKeywords(text);
+            console.log(`Text: "${text.substring(0, 50)}..."`);
+            console.log(`Keywords: ${keywords.join(', ') || 'none'}\n`);
+        }
+        // Test 8: Test tag extraction
+        console.log('Test 8: Testing tag extraction...');
+        const tagTexts = [
+            'This is about #machinelearning and #ai',
+            'Category: programming, Type: tutorial',
+            'No tags here'
+        ];
+        for (const text of tagTexts) {
+            const tags = zettelService.extractTags(text);
+            console.log(`Text: "${text}"`);
+            console.log(`Tags: ${tags.join(', ') || 'none'}\n`);
+        }
+        // Test 9: Add another observation to see cascading evolution
+        console.log('Test 9: Testing cascading evolution with another observation...');
+        const cascadeObsId = 'obs-5';
+        const cascadeObsText = 'Training neural networks requires backpropagation algorithm. Machine learning models learn from data patterns.';
+        const cascadeObsEmbedding = await embeddingService.embed(cascadeObsText);
+        const now2 = Date.now() * 1000; // Microseconds for Validity
+        await db.run(`
+      ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [[
+        $id,
+        $created_at,
+        'test-entity',
+        null,
+        null,
+        $text,
+        $embedding,
+        {}
+      ]]
+      :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+    `, { id: cascadeObsId, created_at: now2, text: cascadeObsText, embedding: cascadeObsEmbedding });
+        const cascadeResult = await zettelService.enrichObservation(cascadeObsId, cascadeObsText, cascadeObsEmbedding, 'test-entity');
+        console.log(`✓ Cascade enrichment completed`);
+        console.log(`  Related Notes: ${cascadeResult.relatedNotes.length}`);
+        console.log(`  New Links: ${cascadeResult.createdLinks}`);
+        console.log(`  Keywords: ${cascadeResult.extractedKeywords.join(', ')}`);
+        console.log();
+        // Final stats
+        const finalStats = await zettelService.getEvolutionStats();
+        console.log('Final Statistics:');
+        console.log(`  Total Observations: ${finalStats.totalObservations}`);
+        console.log(`  Enriched: ${finalStats.enrichedObservations} (${(finalStats.enrichedObservations / finalStats.totalObservations * 100).toFixed(1)}%)`);
+        console.log(`  Total Links: ${finalStats.totalLinks}`);
+        console.log(`  Avg Links/Note: ${finalStats.averageLinksPerNote.toFixed(2)}`);
+        console.log();
+        console.log('=== All Tests Completed Successfully ===');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+// Run tests
+testZettelkastenEvolution().catch(console.error);

package/dist/test-zettelkasten-fixed.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const embedding_service_1 = require("./embedding-service");
+const zettelkasten_evolution_1 = require("./zettelkasten-evolution");
+async function testZettelkastenFixed() {
+    console.log('=== Testing Zettelkasten Evolution with Fixed HNSW Query ===\n');
+    // Use the actual database
+    const db = new cozo_node_1.CozoDb('sqlite', 'memory_db.cozo.db');
+    const embeddings = new embedding_service_1.EmbeddingService();
+    const zettelkasten = new zettelkasten_evolution_1.ZettelkastenEvolutionService(db, embeddings, {
+        enableEvolution: true,
+        similarityThreshold: 0.7,
+        maxRelatedNotes: 5,
+        minKeywordFrequency: 1,
+        autoExtractKeywords: true,
+        autoBidirectionalLinks: true,
+        enrichmentDepth: 'shallow'
+    });
+    try {
+        // Get a sample observation from the database
+        const obsResult = await db.run(`
+      ?[id, entity_id, text, embedding] := 
+        *observation{id, entity_id, text, embedding, @ "NOW"}
+      :limit 1
+    `);
+        if (obsResult.rows.length === 0) {
+            console.log('No observations found in database. Please add some data first.');
+            return;
+        }
+        const [obsId, entityId, text, embedding] = obsResult.rows[0];
+        console.log(`Testing with observation: ${obsId}`);
+        console.log(`Text: ${text}\n`);
+        // Test keyword extraction
+        console.log('1. Testing keyword extraction...');
+        const keywords = zettelkasten.extractKeywords(text);
+        console.log(`   Extracted keywords: ${keywords.join(', ')}\n`);
+        // Test tag extraction
+        console.log('2. Testing tag extraction...');
+        const tags = zettelkasten.extractTags(text);
+        console.log(`   Extracted tags: ${tags.join(', ')}\n`);
+        // Test finding related notes (this was failing before)
+        console.log('3. Testing HNSW semantic search for related notes...');
+        const relatedNotes = await zettelkasten.findRelatedNotes(obsId, text, embedding);
+        console.log(`   Found ${relatedNotes.length} related notes:`);
+        relatedNotes.forEach((note, i) => {
+            console.log(`   ${i + 1}. ${note.observationId} (similarity: ${note.similarity.toFixed(3)})`);
+            console.log(`      Connection: ${note.connectionType} - ${note.reason}`);
+            console.log(`      Shared keywords: ${note.sharedKeywords.join(', ')}`);
+        });
+        console.log();
+        // Test full enrichment
+        console.log('4. Testing full observation enrichment...');
+        const enrichmentResult = await zettelkasten.enrichObservation(obsId, text, embedding, entityId);
+        console.log(`   ${enrichmentResult.evolutionSummary}`);
+        console.log(`   Keywords: ${enrichmentResult.extractedKeywords.join(', ')}`);
+        console.log(`   Tags: ${enrichmentResult.addedTags.join(', ')}`);
+        console.log(`   Related notes: ${enrichmentResult.relatedNotes.length}`);
+        console.log(`   Created links: ${enrichmentResult.createdLinks}\n`);
+        // Test evolution stats
+        console.log('5. Testing evolution statistics...');
+        const stats = await zettelkasten.getEvolutionStats();
+        console.log(`   Total observations: ${stats.totalObservations}`);
+        console.log(`   Enriched observations: ${stats.enrichedObservations}`);
+        console.log(`   Total links: ${stats.totalLinks}`);
+        console.log(`   Average links per note: ${stats.averageLinksPerNote.toFixed(2)}\n`);
+        console.log('✅ All tests passed! HNSW query is working correctly.');
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        throw error;
+    }
+}
+testZettelkastenFixed().catch(console.error);

package/dist/test-zettelkasten-live.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const zettelkasten_evolution_1 = require("./zettelkasten-evolution");
+const embedding_service_1 = require("./embedding-service");
+async function testZettelkastenLive() {
+    console.log('=== Zettelkasten Live Test with Existing Data ===\n');
+    // Open the actual database file
+    const db = new cozo_node_1.CozoDb('sqlite', 'memory_db.cozo.db');
+    const embeddingService = new embedding_service_1.EmbeddingService();
+    const zettelService = new zettelkasten_evolution_1.ZettelkastenEvolutionService(db, embeddingService, {
+        enableEvolution: true,
+        similarityThreshold: 0.7,
+        maxRelatedNotes: 5,
+        minKeywordFrequency: 1, // Lower for testing
+        autoExtractKeywords: true,
+        autoBidirectionalLinks: true,
+        enrichmentDepth: 'shallow'
+    });
+    try {
+        // Test 1: Get current evolution stats
+        console.log('Test 1: Getting current evolution statistics...');
+        const stats = await zettelService.getEvolutionStats();
+        console.log(`Total Observations: ${stats.totalObservations}`);
+        console.log(`Enriched Observations: ${stats.enrichedObservations}`);
+        console.log(`Total Zettelkasten Links: ${stats.totalLinks}`);
+        console.log(`Average Links per Note: ${stats.averageLinksPerNote.toFixed(2)}`);
+        console.log();
+        // Test 2: Get the last observation we created
+        console.log('Test 2: Fetching recent observations...');
+        const obsResult = await db.run(`
+      ?[id, entity_id, text, embedding] := 
+        *observation{id, entity_id, text, embedding, @ "NOW"}
+      :limit 5
+    `);
+        if (obsResult.rows.length === 0) {
+            console.log('No observations found in database');
+            return;
+        }
+        console.log(`Found ${obsResult.rows.length} observations\n`);
+        // Test 3: Test keyword extraction on existing observations
+        console.log('Test 3: Testing keyword extraction...');
+        for (const row of obsResult.rows.slice(0, 3)) {
+            const text = row[2];
+            const keywords = zettelService.extractKeywords(text);
+            console.log(`Text: "${text.substring(0, 60)}..."`);
+            console.log(`Keywords: ${keywords.join(', ') || 'none'}\n`);
+        }
+        // Test 4: Test tag extraction
+        console.log('Test 4: Testing tag extraction...');
+        const testTexts = [
+            'This is about #machinelearning and #ai',
+            'Category: programming, Type: tutorial',
+            obsResult.rows[0][2]
+        ];
+        for (const text of testTexts) {
+            const tags = zettelService.extractTags(text);
+            console.log(`Text: "${text.substring(0, 50)}..."`);
+            console.log(`Tags: ${tags.join(', ') || 'none'}\n`);
+        }
+        // Test 5: Find related notes for the first observation
+        console.log('Test 5: Finding related notes...');
+        const firstObs = obsResult.rows[0];
+        const obsId = firstObs[0];
+        const obsText = firstObs[2];
+        const obsEmbedding = firstObs[3];
+        console.log(`Analyzing observation: ${obsId}`);
+        console.log(`Text: "${obsText.substring(0, 80)}..."\n`);
+        const relatedNotes = await zettelService.findRelatedNotes(obsId, obsText, obsEmbedding);
+        console.log(`Found ${relatedNotes.length} related notes:`);
+        for (const related of relatedNotes) {
+            console.log(`  - ${related.observationId}`);
+            console.log(`    Similarity: ${related.similarity.toFixed(3)}`);
+            console.log(`    Type: ${related.connectionType}`);
+            console.log(`    Reason: ${related.reason}`);
+            console.log(`    Shared Keywords: ${related.sharedKeywords.join(', ') || 'none'}`);
+            console.log(`    Text: ${related.text.substring(0, 60)}...`);
+            console.log();
+        }
+        // Test 6: Enrich one observation
+        if (obsResult.rows.length > 0) {
+            console.log('Test 6: Enriching an observation...');
+            const testObs = obsResult.rows[0];
+            const testId = testObs[0];
+            const testText = testObs[2];
+            const testEmbedding = testObs[3];
+            const testEntityId = testObs[1];
+            const enrichmentResult = await zettelService.enrichObservation(testId, testText, testEmbedding, testEntityId);
+            console.log(`Enrichment Result:`);
+            console.log(`  Observation ID: ${enrichmentResult.observationId}`);
+            console.log(`  Extracted Keywords: ${enrichmentResult.extractedKeywords.join(', ')}`);
+            console.log(`  Added Tags: ${enrichmentResult.addedTags.length > 0 ? enrichmentResult.addedTags.join(', ') : 'none'}`);
+            console.log(`  Related Notes: ${enrichmentResult.relatedNotes.length}`);
+            console.log(`  Links Created: ${enrichmentResult.createdLinks}`);
+            console.log(`  Summary: ${enrichmentResult.evolutionSummary}`);
+            console.log();
+        }
+        // Test 7: Check final stats
+        console.log('Test 7: Final statistics...');
+        const finalStats = await zettelService.getEvolutionStats();
+        console.log(`Total Observations: ${finalStats.totalObservations}`);
+        console.log(`Enriched: ${finalStats.enrichedObservations}`);
+        console.log(`Total Links: ${finalStats.totalLinks}`);
+        console.log(`Avg Links/Note: ${finalStats.averageLinksPerNote.toFixed(2)}`);
+        console.log();
+        console.log('=== All Tests Completed Successfully ===');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+// Run tests
+testZettelkastenLive().catch(console.error);

package/dist/test-zettelkasten-mcp.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testZettelkastenMCPTools() {
+    console.log("=== Testing Zettelkasten 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: "Zettelkasten Test",
+            type: "TestEntity",
+            metadata: { purpose: "testing" }
+        });
+        console.log("✓ Entity created:", entityResult.id);
+        // Step 2: Add multiple observations
+        console.log("\n2. Adding test observations...");
+        const observations = [
+            "Machine learning is a subset of artificial intelligence focused on learning from data.",
+            "Neural networks are computational models inspired by biological neurons in the brain.",
+            "Deep learning uses multiple layers of neural networks to learn hierarchical representations.",
+            "Transformers revolutionized NLP by using self-attention mechanisms instead of recurrence.",
+            "Large language models like GPT are trained on massive text corpora using transformers."
+        ];
+        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)}...`);
+            }
+        }
+        // Step 3: Test get_zettelkasten_stats via direct method call
+        console.log("\n3. Testing getZettelkastenStats...");
+        const stats = await server.getZettelkastenService().getEvolutionStats();
+        console.log("✓ Stats retrieved:");
+        console.log(`  - Total observations: ${stats.totalObservations}`);
+        console.log(`  - Enriched observations: ${stats.enrichedObservations}`);
+        console.log(`  - Total links: ${stats.totalLinks}`);
+        console.log(`  - Average links per note: ${stats.averageLinksPerNote.toFixed(2)}`);
+        console.log(`  - Top keywords: ${stats.topKeywords.slice(0, 5).map((k) => k.keyword).join(", ")}`);
+        // Step 4: Test enrich_observation via getting observation data and calling enrichment
+        console.log("\n4. Testing enrichObservation...");
+        const obsRes = await server.db.run(`?[obs_id, entity_id, text, embedding] := *observation{id: $id, entity_id, text, embedding, @ "NOW"}, obs_id = $id`, { id: obsIds[0] });
+        if (obsRes.rows.length > 0) {
+            const [obs_id, entity_id, text, embedding] = obsRes.rows[0];
+            const enrichData = await server.getZettelkastenService().enrichObservation(obs_id, text, embedding, entity_id);
+            console.log("✓ Observation enriched:");
+            console.log(`  - Observation ID: ${enrichData.observationId}`);
+            console.log(`  - Extracted keywords: ${enrichData.extractedKeywords.join(", ")}`);
+            console.log(`  - Added tags: ${enrichData.addedTags.join(", ")}`);
+            console.log(`  - Created links: ${enrichData.createdLinks}`);
+            console.log(`  - Related notes: ${enrichData.relatedNotes.length}`);
+            console.log(`  - Evolution summary: ${enrichData.evolutionSummary}`);
+        }
+        // Step 5: Verify stats updated
+        console.log("\n5. Verifying stats after enrichment...");
+        const stats2 = await server.getZettelkastenService().getEvolutionStats();
+        console.log("✓ Updated stats:");
+        console.log(`  - Total observations: ${stats2.totalObservations}`);
+        console.log(`  - Enriched observations: ${stats2.enrichedObservations}`);
+        console.log(`  - Total links: ${stats2.totalLinks}`);
+        console.log(`  - Average links per note: ${stats2.averageLinksPerNote.toFixed(2)}`);
+        // Step 6: Enrich another observation
+        console.log("\n6. Enriching second observation...");
+        const obsRes2 = await server.db.run(`?[obs_id, entity_id, text, embedding] := *observation{id: $id, entity_id, text, embedding, @ "NOW"}, obs_id = $id`, { id: obsIds[1] });
+        if (obsRes2.rows.length > 0) {
+            const [obs_id, entity_id, text, embedding] = obsRes2.rows[0];
+            const enrichData2 = await server.getZettelkastenService().enrichObservation(obs_id, text, embedding, entity_id);
+            console.log("✓ Second observation enriched:");
+            console.log(`  - Created links: ${enrichData2.createdLinks}`);
+            console.log(`  - Related notes: ${enrichData2.relatedNotes.length}`);
+        }
+        // Step 7: Final stats
+        console.log("\n7. Final statistics...");
+        const stats3 = await server.getZettelkastenService().getEvolutionStats();
+        console.log("✓ Final stats:");
+        console.log(`  - Total observations: ${stats3.totalObservations}`);
+        console.log(`  - Enriched observations: ${stats3.enrichedObservations}`);
+        console.log(`  - Total links: ${stats3.totalLinks}`);
+        console.log(`  - Average links per note: ${stats3.averageLinksPerNote.toFixed(2)}`);
+        console.log(`  - Top keywords: ${stats3.topKeywords.slice(0, 10).map((k) => `${k.keyword}(${k.frequency})`).join(", ")}`);
+        console.log("\n=== ✓ All Zettelkasten MCP Tools Tests Passed ===");
+    }
+    catch (error) {
+        console.error("\n✗ Test failed:", error);
+        process.exit(1);
+    }
+}
+testZettelkastenMCPTools();