cozo-memory 1.0.0

package/dist/test-time-filter.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testTimeFilter() {
+    const dbPath = "test-time.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    const EMBEDDING_DIM = 4;
+    try {
+        console.log("Creating table with Validity...");
+        await db.run(`{:create test_time {id: String, created_at: Validity => type: String, embedding: <F32; ${EMBEDDING_DIM}>}}`);
+        await db.run(`{::hnsw create test_time:semantic {dim: ${EMBEDDING_DIM}, m: 16, dtype: F32, fields: [embedding], distance: Cosine, ef_construction: 200}}`);
+        const now = Date.now();
+        const vec = [0.1, 0.2, 0.3, 0.4];
+        // CozoDB uses microseconds for timestamps if they are integers? 
+        // Or ISO strings? Let's use integers for now.
+        // Actually CozoDB Validity often uses integers as unix timestamps in milliseconds or microseconds.
+        const data = [
+            ['old', [now - 10000000, true], 'old_type', vec],
+            ['new', [now, true], 'new_type', vec]
+        ];
+        await db.run(`
+            ?[id, created_at, type, embedding] <- $data
+            :put test_time {id, created_at => type, embedding}
+        `, { data });
+        console.log("--- Test 1: Validity lower() in body ---");
+        try {
+            const min_ts = now - 5000000;
+            const res = await db.run(`
+                ?[id, start_ts] := *test_time{id, created_at, @ "NOW"}, start_ts = lower(created_at), start_ts > $min_ts
+            `, { min_ts });
+            console.log("Results body filter:", res.rows);
+        }
+        catch (e) {
+            console.error("Error body filter:", e.message || e);
+        }
+        console.log("--- Test 3: Direct Validity comparison in HNSW filter ---");
+        try {
+            const min_ts = now - 5000000;
+            const res = await db.run(`
+                ?[id] := ~test_time:semantic{id, created_at | query: vec($vec), k: 10, ef: 100, filter: created_at > $min_ts}
+            `, { vec, min_ts });
+            console.log("Results direct HNSW filter:", res.rows);
+        }
+        catch (e) {
+            console.error("Error direct HNSW filter:", e.message || e);
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+    finally {
+        // Cleanup
+        // db.close(); // Cozo-node doesn't have close()?
+    }
+}
+testTimeFilter();

package/dist/test-time-functions.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testTimeFunctions() {
+    const dbPath = "test-time-funcs.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [['id1', [now - 1000, true], 'typeA']];
+        await db.run(`?[id, v, t] <- $data :put test_v {id, v => t}`, { data });
+        const functionsToTest = ['valid_from', 'start', 'beginning', 'lower_bound'];
+        for (const fn of functionsToTest) {
+            console.log(`--- Testing ${fn}(v) ---`);
+            try {
+                const res = await db.run(`?[id, val] := *test_v{id, v}, val = ${fn}(v)`);
+                console.log(`${fn}(v) success:`, res.rows);
+            }
+            catch (e) {
+                console.log(`${fn}(v) failed:`, e.message || e);
+            }
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testTimeFunctions();

package/dist/test-triggers.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testTriggers() {
+    console.log('--- Testing CozoDB Triggers ---');
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    try {
+        // 1. Test Self-Loop Trigger
+        console.log('\nTesting self-loop trigger...');
+        const selfLoopRes = await server.createRelation({
+            from_id: 'entity_1',
+            to_id: 'entity_1', // Self-loop
+            relation_type: 'self_reference'
+        });
+        if (selfLoopRes && selfLoopRes.error) {
+            console.log('✅ Success: Self-loop trigger blocked the operation:', selfLoopRes.error);
+        }
+        else {
+            console.error('❌ Error: Self-loop trigger failed (allowed self-loop)');
+        }
+        // 2. Test Metadata Conflict Trigger
+        console.log('\nTesting metadata conflict trigger...');
+        const conflictRes = await server.createEntity({
+            name: 'Conflict Entity ' + Math.random(),
+            type: 'Test',
+            metadata: {
+                status: 'active',
+                archived: true // Should conflict with status: 'active'
+            }
+        });
+        if (conflictRes && conflictRes.error) {
+            console.log('✅ Success: Metadata conflict trigger blocked the operation:', conflictRes.error);
+        }
+        else {
+            console.error('❌ Error: Metadata conflict trigger failed (allowed conflicting metadata)');
+        }
+        // 3. Test Valid Entity
+        console.log('\nTesting valid entity...');
+        try {
+            const valid = await server.createEntity({
+                name: 'Valid Entity',
+                type: 'Test',
+                metadata: {
+                    status: 'active',
+                    archived: false
+                }
+            });
+            console.log('✅ Success: Valid entity created');
+        }
+        catch (e) {
+            console.error('❌ Error: Valid entity was blocked:', e.message);
+        }
+    }
+    finally {
+        // Clean up or close if needed
+        process.exit(0);
+    }
+}
+testTriggers().catch(console.error);

package/dist/test-ts-ort.js

@@ -0,0 +1,48 @@
+"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 });
+// @ts-ignore
+const ort = __importStar(require("onnxruntime-node"));
+async function test() {
+    console.log("TS-Node ONNX Test");
+    try {
+        // @ts-ignore
+        await ort.InferenceSession.create("non-existent.onnx");
+    }
+    catch (e) {
+        console.log("Error:", e.message);
+    }
+}
+test();

package/dist/test-validity-access.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityAccess() {
+    const dbPath = "test-validity-access.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [['id1', [now - 1000, true], 'typeA']];
+        await db.run(`?[id, v, t] <- $data :put test_v {id, v => t}`, { data });
+        console.log("--- Test get(v, 0) ---");
+        try {
+            const res = await db.run(`?[id, start] := *test_v{id, v}, start = get(v, 0)`);
+            console.log("get(v, 0) results:", res.rows);
+        }
+        catch (e) {
+            console.error("get(v, 0) error:", e.message || e);
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityAccess();

package/dist/test-validity-body.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityBody() {
+    const dbPath = "test-validity-body.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, created_at: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [['id1', [now - 1000, true], 'typeA']];
+        await db.run(`?[id, created_at, t] <- $data :put test_v {id, created_at => t}`, { data });
+        console.log("--- Querying with Validity in body ---");
+        try {
+            const res = await db.run(`?[id] := *test_v{id, created_at: c}, c <- [[ts, _]], ts > 0`);
+            console.log("c <- [[ts, _]] results:", res.rows);
+        }
+        catch (e) {
+            console.log("c <- [[ts, _]] failed:", e.message || e);
+        }
+        try {
+            const res = await db.run(`?[id] := *test_v{id, created_at: c}, [ts, _] = c, ts > 0`);
+            console.log("Explicit decomposition results:", res.rows);
+        }
+        catch (e) {
+            console.log("Explicit decomposition failed:", e.message || e);
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityBody();

package/dist/test-validity-decomp.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityDecomposition() {
+    const dbPath = "test-validity-decomp.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [['id1', [now - 1000, true], 'typeA']];
+        await db.run(`?[id, v, t] <- $data :put test_v {id, v => t}`, { data });
+        console.log("--- Testing v as a list/array ---");
+        try {
+            // In CozoDB, Validity is often handled via special temporal joins (@)
+            // But let's see if we can just treat it as a list if we don't use @
+            const res = await db.run(`?[id, v_start] := *test_v{id, v}, [v_start, _] = v`);
+            console.log("Decomposition results:", res.rows);
+        }
+        catch (e) {
+            console.log("Decomposition failed:", e.message || e);
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityDecomposition();

package/dist/test-validity-extraction.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityExtraction() {
+    const dbPath = "test-validity-extraction.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [['id1', [now - 1000, true], 'typeA']];
+        await db.run(`?[id, v, t] <- $data :put test_v {id, v => t}`, { data });
+        const methods = [
+            'val = v.0',
+            'val = v[0]',
+            '[val, _] = v',
+            'val = get(v, 0)',
+            '[[val, _]] <- [v]',
+            '[val, _] <- [v]'
+        ];
+        for (const method of methods) {
+            console.log(`--- Testing: ${method} ---`);
+            try {
+                const res = await db.run(`?[id, val] := *test_v{id, v}, ${method}`);
+                console.log(`Success:`, res.rows);
+            }
+            catch (e) {
+                console.log(`Failed:`, e.message || e);
+            }
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityExtraction();

package/dist/test-validity-json.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityToJson() {
+    const dbPath = "test-validity-json.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [['id1', [now - 1000, true], 'typeA']];
+        await db.run(`?[id, v, t] <- $data :put test_v {id, v => t}`, { data });
+        console.log("--- Testing: start = get(to_json(v), 0) ---");
+        try {
+            const res = await db.run(`?[id, val] := *test_v{id, v}, val = get(to_json(v), 0)`);
+            console.log(`Success:`, res.rows);
+        }
+        catch (e) {
+            console.log(`Failed:`, e.message || e);
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityToJson();

package/dist/test-validity.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidity() {
+    const dbPath = "test-validity.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    const EMBEDDING_DIM = 4;
+    try {
+        console.log("Creating table with Validity...");
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const now = Date.now();
+        const data = [
+            ['id1', [now - 1000, true], 'typeA'],
+            ['id2', [now, true], 'typeB']
+        ];
+        await db.run(`
+            ?[id, v, t] <- $data
+            :put test_v {id, v => t}
+        `, { data });
+        console.log("--- Querying Validity directly ---");
+        const res = await db.run(`?[id, v] := *test_v{id, v}`);
+        console.log("Raw results:", JSON.stringify(res.rows));
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidity();

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Core types for CozoDB Memory MCP Server
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/verify-gpu.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const embedding_service_1 = require("./embedding-service");
+async function verifyGpu() {
+    console.log("Starting GPU Verification for EmbeddingService...");
+    try {
+        const service = new embedding_service_1.EmbeddingService();
+        console.log("Service created. Generating embedding (Run 1)...");
+        let start = performance.now();
+        let embedding = await service.embed("This is a test sentence to verify GPU usage.");
+        let end = performance.now();
+        console.log(`Run 1: Embedding generated in ${(end - start).toFixed(2)}ms`);
+        console.log("Generating embedding (Run 2)...");
+        start = performance.now();
+        embedding = await service.embed("This is a second test sentence.");
+        end = performance.now();
+        console.log(`Run 2: Embedding generated in ${(end - start).toFixed(2)}ms`);
+        console.log(`Embedding length: ${embedding.length}`);
+        if (embedding.length > 0 && embedding.some(v => v !== 0)) {
+            console.log("Embedding contains non-zero values (Success).");
+        }
+        else {
+            console.log("Embedding contains all zeros (Failure/Fallback triggered).");
+        }
+    }
+    catch (error) {
+        console.error("Verification failed:", error);
+    }
+}
+verifyGpu();

package/dist/verify_transaction_tool.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testTransaction() {
+    console.log("Starting Transaction Test...");
+    const server = new index_1.MemoryServer(index_1.DB_PATH);
+    await server.initPromise;
+    const testEntityName = "Transaction-Test-Entity-" + Date.now();
+    const ops = [
+        {
+            action: "create_entity",
+            params: {
+                name: testEntityName,
+                type: "Test",
+                metadata: { source: "test-script" }
+            }
+        },
+        {
+            action: "add_observation",
+            params: {
+                entity_name: testEntityName,
+                text: "Dies ist eine Test-Beobachtung aus einer Transaktion.",
+                metadata: { priority: "low" }
+            }
+        }
+    ];
+    try {
+        console.log("Executing Transaction...");
+        const result = await server.runTransaction({ operations: ops });
+        console.log("Transaction Result:", JSON.stringify(result, null, 2));
+        if (result.error) {
+            console.error("FAILED: Transaction returned an error.");
+        }
+        else {
+            console.log("SUCCESS: Transaction completed successfully.");
+        }
+    }
+    catch (e) {
+        console.error("CRITICAL ERROR:", e.message);
+    }
+    finally {
+        // Cozo might keep the file locked if we don't close it, but MemoryServer doesn't have a close() method.
+        // In a real test, we would handle this.
+    }
+}
+testTransaction().catch(console.error);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "cozo-memory",
+  "version": "1.0.0",
+  "description": "Local-first persistent memory system for AI agents with hybrid search, graph reasoning, and MCP integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "cozo-memory": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tobs-code/cozo-memory.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tobs-code/cozo-memory/issues"
+  },
+  "homepage": "https://github.com/tobs-code/cozo-memory#readme",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "bridge": "tsc && node dist/api_bridge.js",
+    "dev": "ts-node src/index.ts",
+    "clean": "rm -rf dist",
+    "rebuild": "npm run clean && npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "benchmark": "ts-node src/benchmark.ts",
+    "download-model": "ts-node src/download-model.ts"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "ai",
+    "agent",
+    "cozodb",
+    "graph-database",
+    "vector-search",
+    "hybrid-search",
+    "embeddings",
+    "knowledge-graph"
+  ],
+  "author": "tobs <tobsgo1@gmail.com>",
+  "license": "Apache-2.0",
+  "type": "commonjs",
+  "dependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@xenova/transformers": "^2.17.2",
+    "cors": "^2.8.6",
+    "cozo-node": "^0.7.6",
+    "express": "^5.2.1",
+    "fastmcp": "^3.31.0",
+    "ollama": "^0.6.3",
+    "onnxruntime-node": "^1.24.2",
+    "uuid": "^13.0.0",
+    "zod": "^4.3.6"
+  },
+  "overrides": {
+    "onnxruntime-node": "$onnxruntime-node"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.2.0",
+    "@types/uuid": "^10.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}