cozo-memory 1.2.6 → 1.2.10

package/dist/logger.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+describe("Logger", () => {
+    let consoleErrorSpy;
+    let consoleWarnSpy;
+    beforeEach(() => {
+        consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => { });
+        consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        logger_1.logger.setLevel(logger_1.LogLevel.INFO);
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+    });
+    describe("Log Level Filtering", () => {
+        it("should log ERROR messages", () => {
+            logger_1.logger.error("TestComponent", "Error message");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[TestComponent] ERROR:"), "Error message");
+        });
+        it("should log WARN messages", () => {
+            logger_1.logger.warn("TestComponent", "Warn message");
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("[TestComponent] WARN:"), "Warn message");
+        });
+        it("should log INFO messages", () => {
+            logger_1.logger.info("TestComponent", "Info message");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[TestComponent] INFO:"), "Info message");
+        });
+        it("should NOT log DEBUG messages at INFO level", () => {
+            logger_1.logger.debug("TestComponent", "Debug message");
+            expect(consoleErrorSpy).not.toHaveBeenCalled();
+        });
+        it("should NOT log TRACE messages at INFO level", () => {
+            logger_1.logger.trace("TestComponent", "Trace message");
+            expect(consoleErrorSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe("Level Changes", () => {
+        it("should log DEBUG after setting DEBUG level", () => {
+            logger_1.logger.setLevel(logger_1.LogLevel.DEBUG);
+            logger_1.logger.debug("TestComponent", "Debug message");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[TestComponent] DEBUG:"), "Debug message");
+        });
+        it("should log TRACE after setting TRACE level", () => {
+            logger_1.logger.setLevel(logger_1.LogLevel.TRACE);
+            logger_1.logger.trace("TestComponent", "Trace message");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[TestComponent] TRACE:"), "Trace message");
+        });
+        it("should NOT log INFO after setting ERROR level", () => {
+            logger_1.logger.setLevel(logger_1.LogLevel.ERROR);
+            logger_1.logger.info("TestComponent", "Info message");
+            expect(consoleErrorSpy).not.toHaveBeenCalled();
+        });
+        it("should NOT log WARN after setting ERROR level", () => {
+            logger_1.logger.setLevel(logger_1.LogLevel.ERROR);
+            logger_1.logger.warn("TestComponent", "Warn message");
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe("Message Formatting", () => {
+        it("should include prefix and component in output", () => {
+            logger_1.logger.info("MyComp", "Hello World");
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[CozoDB]"), "Hello World");
+        });
+        it("should pass additional arguments", () => {
+            const error = new Error("Test error");
+            logger_1.logger.error("ErrComp", "Something failed", error);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[ErrComp] ERROR:"), "Something failed", error);
+        });
+        it("should pass multiple extra arguments", () => {
+            logger_1.logger.warn("WarnComp", "Warning", { code: 42 }, "context");
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("[WarnComp] WARN:"), "Warning", { code: 42 }, "context");
+        });
+    });
+});

package/dist/memory-service.test.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// ESM-Module und Dependencies mocken, die nicht mit ts-jest/commonjs kompatibel sind
+let uuidCounter = 0;
+jest.mock("uuid", () => ({
+    v4: jest.fn(() => `mocked-uuid-${++uuidCounter}`),
+    validate: jest.fn(() => true),
+}));
+jest.mock("pdfjs-dist/legacy/build/pdf.mjs", () => ({
+    getDocument: jest.fn(() => ({
+        promise: Promise.resolve({ numPages: 0 }),
+    })),
+}));
+jest.mock("onnxruntime-node", () => ({}), { virtual: true });
+jest.mock("./performance-monitor", () => ({
+    perfMonitor: {
+        start: jest.fn(),
+        end: jest.fn(),
+    },
+}));
+// Logger mocken (damit loggt er nicht in die Tast-Ausgabe)
+jest.mock("./logger", () => ({
+    logger: {
+        error: jest.fn(),
+        warn: jest.fn(),
+        info: jest.fn(),
+        debug: jest.fn(),
+        trace: jest.fn(),
+    },
+}));
+const memory_service_1 = require("./memory-service");
+const db_service_1 = require("./db-service");
+const embedding_service_1 = require("./embedding-service");
+// EmbeddingService mocken – gibt immer gleichbleibende Dummy-Vektoren zurück
+jest.mock("./embedding-service", () => {
+    return {
+        EmbeddingService: jest.fn().mockImplementation(() => ({
+            embed: jest.fn().mockImplementation(async (text) => {
+                // Deterministic embedding based on text length
+                const dim = 4;
+                const base = text.length % 10;
+                return [base * 0.1, (base + 1) * 0.1, (base + 2) * 0.1, (base + 3) * 0.1];
+            }),
+            embedBatch: jest.fn().mockImplementation(async (texts) => {
+                return texts.map((t) => {
+                    const base = t.length % 10;
+                    return [base * 0.1, (base + 1) * 0.1, (base + 2) * 0.1, (base + 3) * 0.1];
+                });
+            }),
+            getDimensions: jest.fn().mockReturnValue(4),
+            getCacheStats: jest.fn().mockReturnValue({ size: 0, maxSize: 1000, model: "test", backend: "mock", dimensions: 4 }),
+            clearCache: jest.fn(),
+        })),
+    };
+});
+describe("MemoryService", () => {
+    let db;
+    let embeddings;
+    let memory;
+    beforeEach(async () => {
+        uuidCounter = 0;
+        db = new db_service_1.DatabaseService(":memory:", "sqlite");
+        await db.initialize();
+        embeddings = new embedding_service_1.EmbeddingService();
+        // MemoryService braucht EmbeddingService für createEntity & search
+        memory = new memory_service_1.MemoryService(db, embeddings);
+    });
+    // ── Entity Operations ────────────────────────────────────────
+    describe("Entity Operations", () => {
+        it("should create an entity", async () => {
+            const entity = await memory.createEntity("Test Person", "Person", { role: "developer" });
+            expect(entity.id).toBeDefined();
+            expect(entity.name).toBe("Test Person");
+            expect(entity.type).toBe("Person");
+            expect(entity.metadata).toEqual({ role: "developer" });
+            expect(entity.embedding).toHaveLength(4);
+            expect(entity.created_at).toBeGreaterThan(0);
+        });
+        it("should get a created entity by id", async () => {
+            const created = await memory.createEntity("Alice", "Person");
+            const fetched = await memory.getEntity(created.id);
+            expect(fetched).not.toBeNull();
+            expect(fetched.name).toBe("Alice");
+        });
+        it("should return null for non-existent entity", async () => {
+            const result = await memory.getEntity("non-existent-id");
+            expect(result).toBeNull();
+        });
+        it("should update an existing entity", async () => {
+            const entity = await memory.createEntity("Old Name", "Person");
+            await memory.updateEntity(entity.id, { name: "New Name" });
+            const updated = await memory.getEntity(entity.id);
+            expect(updated.name).toBe("New Name");
+        });
+        it("should delete an entity", async () => {
+            const entity = await memory.createEntity("To Delete", "Temp");
+            await memory.deleteEntity(entity.id);
+            const result = await memory.getEntity(entity.id);
+            expect(result).toBeNull();
+        });
+    });
+    // ── Observation Operations ───────────────────────────────────
+    describe("Observation Operations", () => {
+        let entityId;
+        beforeEach(async () => {
+            const entity = await memory.createEntity("Observed Entity", "Test");
+            entityId = entity.id;
+        });
+        it("should add an observation to an entity", async () => {
+            const obs = await memory.addObservation(entityId, "This is an important observation");
+            expect(obs.id).toBeDefined();
+            expect(obs.entity_id).toBe(entityId);
+            expect(obs.text).toBe("This is an important observation");
+            expect(obs.embedding).toHaveLength(4);
+        });
+        it("should list observations for an entity", async () => {
+            await memory.addObservation(entityId, "Observation 1");
+            await memory.addObservation(entityId, "Observation 2");
+            await memory.addObservation(entityId, "Observation 3");
+            const obs = await memory.getObservations(entityId);
+            expect(obs).toHaveLength(3);
+        });
+        it("should return empty array for entity with no observations", async () => {
+            const obs = await memory.getObservations(entityId);
+            expect(obs).toHaveLength(0);
+        });
+    });
+    // ── Relation Operations ──────────────────────────────────────
+    describe("Relation Operations", () => {
+        let idA;
+        let idB;
+        beforeEach(async () => {
+            const a = await memory.createEntity("Entity A", "TypeA");
+            const b = await memory.createEntity("Entity B", "TypeB");
+            idA = a.id;
+            idB = b.id;
+        });
+        it("should create a relation between entities", async () => {
+            const rel = await memory.createRelation(idA, idB, "knows", 0.8);
+            expect(rel.from_id).toBe(idA);
+            expect(rel.to_id).toBe(idB);
+            expect(rel.relation_type).toBe("knows");
+            expect(rel.strength).toBe(0.8);
+        });
+        it("should reject self-references", async () => {
+            await expect(memory.createRelation(idA, idA, "self", 1.0)).rejects.toThrow("Self-references are not allowed");
+        });
+        it("should list relations from an entity", async () => {
+            await memory.createRelation(idA, idB, "knows");
+            const rels = await memory.getRelations(idA);
+            expect(rels).toHaveLength(1);
+            expect(rels[0].to_id).toBe(idB);
+        });
+    });
+    // ── Search ───────────────────────────────────────────────────
+    describe("Search", () => {
+        beforeEach(async () => {
+            await memory.createEntity("Python Programming", "Topic", { description: "A programming language" });
+            await memory.createEntity("JavaScript Programming", "Topic", { description: "Another programming language" });
+            await memory.createEntity("Cooking Recipes", "Topic", { description: "Food and recipes" });
+        });
+        it("should search and return results", async () => {
+            const results = await memory.search("programming", 10);
+            expect(results.length).toBeGreaterThan(0);
+        });
+        it("should filter results by entity type", async () => {
+            // Create a non-Topic entity
+            await memory.createEntity("Random Note", "Note", {});
+            const results = await memory.search("programming", 10, ["Topic"]);
+            expect(results.length).toBeGreaterThan(0);
+            results.forEach(r => {
+                expect(r.entity.type).toBe("Topic");
+            });
+        });
+        it("should return empty array for non-matching query", async () => {
+            // Der gemockte EmbeddingService basiert auf Textlänge – daher können
+            // auch "nicht passende" Queries matches liefern. Das testen wir hier nicht.
+            // Stattdessen: search wirft keinen Fehler
+            await expect(memory.search("xyznonexistent", 10)).resolves.toBeDefined();
+        });
+        it("should respect the limit parameter", async () => {
+            const results = await memory.search("programming", 1);
+            expect(results.length).toBeLessThanOrEqual(1);
+        });
+    });
+    // ── Context ──────────────────────────────────────────────────
+    describe("Context", () => {
+        it("should return context for a query", async () => {
+            const entity = await memory.createEntity("Test Context", "Test");
+            await memory.addObservation(entity.id, "Context observation");
+            const context = await memory.getContext("Test", 10);
+            expect(context).toHaveProperty("query");
+            expect(context).toHaveProperty("entities");
+            expect(context).toHaveProperty("total_entities");
+            expect(context.total_entities).toBeGreaterThan(0);
+            expect(context.entities[0]).toHaveProperty("observations");
+            expect(context.entities[0]).toHaveProperty("relations");
+        });
+    });
+    // ── Health ────────────────────────────────────────────────────
+    describe("Health", () => {
+        it("should return healthy status", async () => {
+            const health = await memory.health();
+            expect(health.status).toBe("healthy");
+            expect(health).toHaveProperty("database");
+            expect(health).toHaveProperty("cache");
+            expect(health).toHaveProperty("timestamp");
+        });
+        it("should include correct db stats", async () => {
+            await memory.createEntity("Health Check Entity", "Test");
+            const health = await memory.health();
+            expect(health.database.entities).toBe(1);
+        });
+    });
+    // ── Snapshots ────────────────────────────────────────────────
+    describe("Snapshots", () => {
+        it("should create a snapshot", async () => {
+            const snapshotId = await memory.createSnapshot({ reason: "test" });
+            expect(snapshotId).toBeDefined();
+        });
+    });
+});

package/dist/timestamp-utils.test.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const timestamp_utils_1 = require("./timestamp-utils");
+describe("toDualTimestamp", () => {
+    it("should convert microseconds to DualTimestamp", () => {
+        const result = (0, timestamp_utils_1.toDualTimestamp)(1_700_000_000_000_000);
+        expect(result.timestamp).toBe(1_700_000_000_000_000);
+        expect(result.iso).toBe("2023-11-14T22:13:20.000Z");
+    });
+    it("should round milliseconds floor", () => {
+        const result = (0, timestamp_utils_1.toDualTimestamp)(1_700_000_000_000_999);
+        expect(result.iso.endsWith(".000Z")).toBe(true);
+    });
+    it("should handle zero timestamp", () => {
+        const result = (0, timestamp_utils_1.toDualTimestamp)(0);
+        expect(result.timestamp).toBe(0);
+        expect(result.iso).toBe("1970-01-01T00:00:00.000Z");
+    });
+    it("should handle large future timestamps", () => {
+        const future = 2_100_000_000_000_000; // ~2036
+        const result = (0, timestamp_utils_1.toDualTimestamp)(future);
+        expect(result.timestamp).toBe(future);
+        expect(result.iso).toContain("2036");
+    });
+});
+describe("nowDual", () => {
+    it("should return current time with both formats", () => {
+        const before = Date.now() * 1000;
+        const result = (0, timestamp_utils_1.nowDual)();
+        const after = Date.now() * 1000;
+        expect(result.timestamp).toBeGreaterThanOrEqual(before);
+        expect(result.timestamp).toBeLessThanOrEqual(after);
+        expect(result.iso).toBeDefined();
+        expect(result.iso).toContain("T");
+        expect(result.iso.endsWith("Z")).toBe(true);
+    });
+    it("should be consistent between timestamp and iso", () => {
+        const result = (0, timestamp_utils_1.nowDual)();
+        // Convert ISO back and compare
+        const reconstructed = new Date(result.iso).getTime() * 1000;
+        // Allow small delta due to execution time
+        expect(Math.abs(reconstructed - result.timestamp)).toBeLessThan(100_000); // <100ms
+    });
+});
+describe("parseToDual", () => {
+    it("should parse a number as microseconds", () => {
+        const result = (0, timestamp_utils_1.parseToDual)(1_700_000_000_000_000);
+        expect(result.timestamp).toBe(1_700_000_000_000_000);
+        expect(result.iso).toBe("2023-11-14T22:13:20.000Z");
+    });
+    it("should parse an ISO string", () => {
+        const input = "2024-01-15T10:30:00.000Z";
+        const result = (0, timestamp_utils_1.parseToDual)(input);
+        // 2024-01-15T10:30:00.000Z = 1705314600000 ms = 1705314600000000 µs
+        expect(result.timestamp).toBe(1_705_314_600_000_000);
+        expect(result.iso).toBe(input);
+    });
+    it("should parse ISO string without Z suffix", () => {
+        const input = "2024-06-01T12:00:00.000";
+        const result = (0, timestamp_utils_1.parseToDual)(input);
+        expect(result.timestamp).toBeDefined();
+        expect(result.iso).toContain("2024-06-01");
+    });
+    it("should throw for invalid date string", () => {
+        // parseToDual ruft date.toISOString() auf, das für Invalid Date einen RangeError wirft
+        expect(() => (0, timestamp_utils_1.parseToDual)("not-a-date")).toThrow(RangeError);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozo-memory",
-  "version": "1.2.6",
+  "version": "1.2.10",
   "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",
@@ -35,7 +35,10 @@
     "dev:tui": "ts-node src/tui-launcher.ts",
     "clean": "rm -rf dist",
     "rebuild": "npm run clean && npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:verbose": "jest --verbose",
     "benchmark": "ts-node src/benchmark.ts",
     "eval": "ts-node src/eval-suite.ts",
     "download-model": "ts-node src/download-model.ts",
@@ -97,4 +100,4 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
-}
+}