cozo-memory 1.0.5 → 1.0.7

package/dist/test-hybrid-debug.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function debugHybridSearch() {
+    console.log('Initializing MemoryServer...');
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    // Check database content
+    console.log('\n=== Database Content ===');
+    const entities = await server.db.run('?[id, name, type] := *entity{id, name, type, @ "NOW"}');
+    console.log(`Entities: ${entities.rows.length}`);
+    entities.rows.slice(0, 3).forEach((row) => {
+        console.log(`  - ${row[1]} (${row[2]})`);
+    });
+    const observations = await server.db.run('?[id, text] := *observation{id, text, @ "NOW"}');
+    console.log(`\nObservations: ${observations.rows.length}`);
+    observations.rows.slice(0, 3).forEach((row) => {
+        console.log(`  - ${row[1].substring(0, 60)}...`);
+    });
+    // Test embedding
+    console.log('\n=== Test Embedding ===');
+    const testEmbedding = await server.embeddingService.embed('Alice');
+    console.log(`Embedding dimensions: ${testEmbedding.length}`);
+    console.log(`First 5 values: ${testEmbedding.slice(0, 5)}`);
+    // Test HNSW search directly
+    console.log('\n=== Test HNSW Search Directly ===');
+    try {
+        const hnswQuery = `
+      ?[id, name, type, dist] := 
+        ~entity:name_semantic{id | query: vec([${testEmbedding.join(',')}]), k: 5, bind_distance: dist},
+        *entity{id, name, type, @ "NOW"}
+    `;
+        const hnswResult = await server.db.run(hnswQuery);
+        console.log(`HNSW results: ${hnswResult.rows.length}`);
+        hnswResult.rows.forEach((row) => {
+            console.log(`  - ${row[1]} (${row[2]}) - distance: ${row[3]}`);
+        });
+    }
+    catch (e) {
+        console.error('HNSW error:', e.message);
+    }
+    // Test hybridSearch
+    console.log('\n=== Test HybridSearch ===');
+    const searchResult = await server.hybridSearch.search({
+        query: 'Alice',
+        limit: 5,
+        includeEntities: true,
+        includeObservations: true
+    });
+    console.log('HybridSearch result:', JSON.stringify(searchResult, null, 2));
+}
+debugHybridSearch().catch(console.error);

package/dist/test-mcp-search.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testMCPSearch() {
+    console.log('Initializing MemoryServer...');
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    console.log('\n=== Test 1: Create Entity via MCP mutate_memory ===');
+    const createResult = await server.mutateMemory({
+        action: 'create_entity',
+        name: 'Test Search Entity',
+        type: 'test',
+        metadata: { purpose: 'search_test' }
+    });
+    console.log('Created:', createResult);
+    const entityId = createResult.id;
+    console.log('\n=== Test 2: Add Observation via MCP mutate_memory ===');
+    const obsResult = await server.mutateMemory({
+        action: 'add_observation',
+        entity_id: entityId,
+        text: 'This is a test observation for searching with keywords like authentication and OAuth',
+        metadata: { test: true }
+    });
+    console.log('Added observation:', obsResult);
+    console.log('\n=== Test 3: Search via MCP query_memory ===');
+    const searchResult = await server.queryMemory({
+        action: 'search',
+        query: 'authentication',
+        limit: 5
+    });
+    console.log('Search result:', JSON.stringify(searchResult, null, 2));
+    console.log('\n=== Test 4: Search for "Alice" ===');
+    const aliceResult = await server.queryMemory({
+        action: 'search',
+        query: 'Alice',
+        limit: 5
+    });
+    console.log('Alice search result:', JSON.stringify(aliceResult, null, 2));
+    console.log('\n=== Test 5: Search for "TypeScript" ===');
+    const tsResult = await server.queryMemory({
+        action: 'search',
+        query: 'TypeScript',
+        limit: 5
+    });
+    console.log('TypeScript search result:', JSON.stringify(tsResult, null, 2));
+}
+testMCPSearch().catch(console.error);

package/dist/test-search-simple.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testSearch() {
+    console.log('Initializing MemoryServer...');
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    console.log('\n=== Testing Search ===');
+    // Test simple search
+    const result = await server.hybridSearch.search({
+        query: 'Alice',
+        limit: 5,
+        includeEntities: true,
+        includeObservations: true
+    });
+    console.log('Search result:', JSON.stringify(result, null, 2));
+    // Check if result is array or object
+    console.log('\nResult type:', typeof result);
+    console.log('Is array:', Array.isArray(result));
+    if (Array.isArray(result)) {
+        console.log(`Found ${result.length} results`);
+    }
+    else {
+        console.log('Result keys:', Object.keys(result));
+    }
+}
+testSearch().catch(console.error);

package/dist/test-user-profile.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testUserProfileEditing() {
+    console.log("=== Testing User Profile Editing ===\n");
+    const server = new index_1.MemoryServer();
+    await server.start();
+    try {
+        // 1. View current profile
+        console.log("1. Current user profile:");
+        const currentProfile = await server.editUserProfile({});
+        console.log(JSON.stringify(currentProfile, null, 2));
+        // 2. Update metadata
+        console.log("\n2. Updating profile metadata:");
+        const metadataUpdate = await server.editUserProfile({
+            metadata: {
+                timezone: "Europe/Berlin",
+                language: "de",
+                work_hours: "09:00-17:00"
+            }
+        });
+        console.log(JSON.stringify(metadataUpdate, null, 2));
+        // 3. Add new preferences
+        console.log("\n3. Adding new preferences:");
+        const addPrefs = await server.editUserProfile({
+            observations: [
+                { text: "Prefers TypeScript over JavaScript for type safety" },
+                { text: "Likes clean, minimal code without unnecessary comments" },
+                { text: "Prefers functional programming patterns" }
+            ]
+        });
+        console.log(JSON.stringify(addPrefs, null, 2));
+        // 4. Clear and reset preferences
+        console.log("\n4. Clearing and resetting preferences:");
+        const resetPrefs = await server.editUserProfile({
+            clear_observations: true,
+            observations: [
+                { text: "Works primarily with Node.js and TypeScript", metadata: { category: "tech_stack" } },
+                { text: "Prefers concise documentation", metadata: { category: "style" } }
+            ]
+        });
+        console.log(JSON.stringify(resetPrefs, null, 2));
+        // 5. Update name and type
+        console.log("\n5. Updating profile name and type:");
+        const nameUpdate = await server.editUserProfile({
+            name: "Developer Profile",
+            type: "UserProfile"
+        });
+        console.log(JSON.stringify(nameUpdate, null, 2));
+        console.log("\n=== Test completed successfully ===");
+    }
+    catch (error) {
+        console.error("Test failed:", error);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+testUserProfileEditing();

package/dist/timestamp-utils.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Utility functions for timestamp handling
+ * Provides both Unix microsecond timestamps and ISO 8601 strings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDualTimestamp = toDualTimestamp;
+exports.nowDual = nowDual;
+exports.parseToDual = parseToDual;
+/**
+ * Convert CozoDB microsecond timestamp to dual format
+ */
+function toDualTimestamp(microseconds) {
+    const milliseconds = Math.floor(microseconds / 1000);
+    const date = new Date(milliseconds);
+    return {
+        timestamp: microseconds,
+        iso: date.toISOString()
+    };
+}
+/**
+ * Get current time in dual format
+ */
+function nowDual() {
+    const now = Date.now();
+    return {
+        timestamp: now * 1000, // Convert to microseconds
+        iso: new Date(now).toISOString()
+    };
+}
+/**
+ * Parse ISO string or Unix timestamp to dual format
+ */
+function parseToDual(input) {
+    if (typeof input === 'number') {
+        return toDualTimestamp(input);
+    }
+    const date = new Date(input);
+    const milliseconds = date.getTime();
+    return {
+        timestamp: milliseconds * 1000, // Convert to microseconds
+        iso: date.toISOString()
+    };
+}