lynkr 8.0.0 → 8.0.1

package/test/memory/store.test.js

@@ -1,344 +0,0 @@
-const assert = require("assert");
-const { describe, it, beforeEach, afterEach } = require("node:test");
-const fs = require("fs");
-const path = require("path");
-const Database = require("better-sqlite3");
-
-describe("Memory Store", () => {
-  let store;
-  let testDbPath;
-  let originalDb;
-
-  beforeEach(() => {
-    // Create a unique temporary test database
-    const timestamp = Date.now();
-    const random = Math.floor(Math.random() * 1000000);
-    testDbPath = path.join(__dirname, `../../data/test-store-${timestamp}-${random}.db`);
-
-    // Set test environment to new database (correct env var is SESSION_DB_PATH)
-    process.env.SESSION_DB_PATH = testDbPath;
-
-    // Clear ALL module cache to ensure fresh config is loaded
-    delete require.cache[require.resolve("../../src/config")];
-    delete require.cache[require.resolve("../../src/db")];
-    delete require.cache[require.resolve("../../src/memory/store")];
-
-    // Initialize database with schema (this creates a fresh database)
-    require("../../src/db");
-
-    // Load store module
-    store = require("../../src/memory/store");
-  });
-
-  afterEach(() => {
-    // Close database connection first
-    try {
-      const db = require("../../src/db");
-      if (db && typeof db.close === 'function') {
-        db.close();
-      }
-    } catch (err) {
-      // Ignore if already closed
-    }
-
-    // Clear module cache to release all references
-    delete require.cache[require.resolve("../../src/db")];
-    delete require.cache[require.resolve("../../src/memory/store")];
-
-    // Clean up all SQLite files (db, wal, shm)
-    try {
-      const files = [
-        testDbPath,
-        `${testDbPath}-wal`,
-        `${testDbPath}-shm`,
-        `${testDbPath}-journal`
-      ];
-
-      for (const file of files) {
-        if (fs.existsSync(file)) {
-          fs.unlinkSync(file);
-        }
-      }
-    } catch (err) {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("createMemory()", () => {
-    it("should create a new memory with all fields", () => {
-      const memory = store.createMemory({
-        content: "User prefers Python for data processing",
-        type: "preference",
-        category: "user",
-        importance: 0.8,
-        surpriseScore: 0.6,
-        sessionId: null,
-        metadata: { source: "conversation" }
-      });
-
-      assert.ok(memory.id);
-      assert.strictEqual(memory.content, "User prefers Python for data processing");
-      assert.strictEqual(memory.type, "preference");
-      assert.strictEqual(memory.category, "user");
-      assert.strictEqual(memory.importance, 0.8);
-      assert.strictEqual(memory.surpriseScore, 0.6);
-      assert.strictEqual(memory.sessionId, null);
-      assert.ok(memory.createdAt);
-      assert.ok(memory.updatedAt);
-    });
-
-    it("should create memory with default values", () => {
-      const memory = store.createMemory({
-        content: "Test memory",
-        type: "fact"
-      });
-
-      assert.strictEqual(memory.importance, 0.5);
-      assert.strictEqual(memory.surpriseScore, 0.0);
-      assert.strictEqual(memory.accessCount, 0);
-      assert.strictEqual(memory.decayFactor, 1.0);
-    });
-
-    it("should throw error for missing required fields", () => {
-      assert.throws(() => {
-        store.createMemory({ type: "fact" });
-      }, /content.*required/i);
-
-      assert.throws(() => {
-        store.createMemory({ content: "Test" });
-      }, /type.*required/i);
-    });
-  });
-
-  describe("getMemory()", () => {
-    it("should retrieve memory by id", () => {
-      const created = store.createMemory({
-        content: "This project uses Express.js",
-        type: "fact",
-        category: "project"
-      });
-
-      const retrieved = store.getMemory(created.id);
-      assert.strictEqual(retrieved.id, created.id);
-      assert.strictEqual(retrieved.content, "This project uses Express.js");
-    });
-
-    it("should return null for non-existent id", () => {
-      const memory = store.getMemory(99999);
-      assert.strictEqual(memory, null);
-    });
-
-    it("should increment access count when requested", () => {
-      const created = store.createMemory({
-        content: "Test memory",
-        type: "fact"
-      });
-
-      const retrieved1 = store.getMemory(created.id, { incrementAccess: true });
-      assert.strictEqual(retrieved1.accessCount, 1);
-
-      const retrieved2 = store.getMemory(created.id, { incrementAccess: true });
-      assert.strictEqual(retrieved2.accessCount, 2);
-    });
-  });
-
-  describe("updateMemory()", () => {
-    it("should update memory fields", async () => {
-      const created = store.createMemory({
-        content: "Original content",
-        type: "fact",
-        importance: 0.5
-      });
-
-      // Add tiny delay to ensure different timestamp
-      await new Promise(resolve => setTimeout(resolve, 5));
-
-      const updated = store.updateMemory(created.id, {
-        content: "Updated content",
-        importance: 0.9
-      });
-
-      assert.strictEqual(updated.content, "Updated content");
-      assert.strictEqual(updated.importance, 0.9);
-      assert.ok(updated.updatedAt >= created.updatedAt);
-    });
-
-    it("should throw error for non-existent memory", () => {
-      assert.throws(() => {
-        store.updateMemory(99999, { content: "Test" });
-      });
-    });
-  });
-
-  describe("deleteMemory()", () => {
-    it("should delete memory by id", () => {
-      const created = store.createMemory({
-        content: "Memory to delete",
-        type: "fact"
-      });
-
-      const result = store.deleteMemory(created.id);
-      assert.strictEqual(result, true);
-
-      const retrieved = store.getMemory(created.id);
-      assert.strictEqual(retrieved, null);
-    });
-
-    it("should return false for non-existent memory", () => {
-      const result = store.deleteMemory(99999);
-      assert.strictEqual(result, false);
-    });
-  });
-
-  describe("getRecentMemories()", () => {
-    it("should retrieve recent memories", async () => {
-      store.createMemory({ content: "Memory 1", type: "fact" });
-      await new Promise(resolve => setTimeout(resolve, 2));
-      store.createMemory({ content: "Memory 2", type: "fact" });
-      await new Promise(resolve => setTimeout(resolve, 2));
-      store.createMemory({ content: "Memory 3", type: "fact" });
-
-      const recent = store.getRecentMemories({ limit: 2 });
-      assert.strictEqual(recent.length, 2);
-      assert.strictEqual(recent[0].content, "Memory 3"); // Most recent first
-      assert.strictEqual(recent[1].content, "Memory 2");
-    });
-
-    it("should filter by session id", () => {
-      store.createMemory({ content: "Session 1 memory", type: "fact", sessionId: null }); // was: "session-1"
-      store.createMemory({ content: "Session 2 memory", type: "fact", sessionId: null }); // was: "session-2"
-      store.createMemory({ content: "Global memory", type: "fact" });
-
-      const session1Memories = store.getRecentMemories({ sessionId: null }); // was: "session-1"
-      // All three memories will be returned since they all have null sessionId
-      assert.ok(session1Memories.length >= 1);
-      assert.ok(session1Memories.some(m => m.content === "Session 1 memory"));
-    });
-  });
-
-  describe("getMemoriesByImportance()", () => {
-    it("should retrieve memories sorted by importance", () => {
-      store.createMemory({ content: "Low importance", type: "fact", importance: 0.3 });
-      store.createMemory({ content: "High importance", type: "fact", importance: 0.9 });
-      store.createMemory({ content: "Medium importance", type: "fact", importance: 0.6 });
-
-      const memories = store.getMemoriesByImportance({ limit: 3 });
-      assert.strictEqual(memories.length, 3);
-      assert.strictEqual(memories[0].content, "High importance");
-      assert.strictEqual(memories[1].content, "Medium importance");
-      assert.strictEqual(memories[2].content, "Low importance");
-    });
-  });
-
-  describe("getMemoriesBySurprise()", () => {
-    it("should retrieve memories sorted by surprise score", () => {
-      store.createMemory({ content: "Low surprise", type: "fact", surpriseScore: 0.2 });
-      store.createMemory({ content: "High surprise", type: "fact", surpriseScore: 0.8 });
-      store.createMemory({ content: "Medium surprise", type: "fact", surpriseScore: 0.5 });
-
-      const memories = store.getMemoriesBySurprise({ limit: 2 });
-      assert.strictEqual(memories.length, 2);
-      assert.strictEqual(memories[0].content, "High surprise");
-      assert.strictEqual(memories[1].content, "Medium surprise");
-    });
-  });
-
-  describe("getMemoriesByType()", () => {
-    it("should filter memories by type", () => {
-      store.createMemory({ content: "Preference 1", type: "preference" });
-      store.createMemory({ content: "Fact 1", type: "fact" });
-      store.createMemory({ content: "Preference 2", type: "preference" });
-
-      const preferences = store.getMemoriesByType("preference");
-      assert.strictEqual(preferences.length, 2);
-      assert.ok(preferences.every(m => m.type === "preference"));
-    });
-  });
-
-  describe("pruneOldMemories()", () => {
-    it("should delete memories older than specified days", () => {
-      const oldTimestamp = Date.now() - (100 * 24 * 60 * 60 * 1000); // 100 days ago
-
-      // Create old memory by directly manipulating DB (since we can't set createdAt via API)
-      const db = require("../../src/db");
-      db.prepare(`
-        INSERT INTO memories (content, type, importance, surprise_score, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run("Old memory", "fact", 0.5, 0.0, oldTimestamp, oldTimestamp);
-
-      store.createMemory({ content: "New memory", type: "fact" });
-
-      const deletedCount = store.pruneOldMemories({ maxAgeDays: 90 });
-      assert.strictEqual(deletedCount, 1);
-
-      const remaining = store.getRecentMemories({ limit: 10 });
-      assert.strictEqual(remaining.length, 1);
-      assert.strictEqual(remaining[0].content, "New memory");
-    });
-  });
-
-  describe("pruneByCount()", () => {
-    it("should keep only most important memories up to maxCount", () => {
-      store.createMemory({ content: "Low 1", type: "fact", importance: 0.2 });
-      store.createMemory({ content: "High 1", type: "fact", importance: 0.9 });
-      store.createMemory({ content: "Low 2", type: "fact", importance: 0.3 });
-      store.createMemory({ content: "High 2", type: "fact", importance: 0.8 });
-      store.createMemory({ content: "Medium", type: "fact", importance: 0.5 });
-
-      const deletedCount = store.pruneByCount({ maxCount: 3 });
-      assert.strictEqual(deletedCount, 2);
-
-      const remaining = store.getMemoriesByImportance({ limit: 10 });
-      assert.strictEqual(remaining.length, 3);
-      assert.ok(remaining.every(m => m.importance >= 0.5));
-    });
-  });
-
-  describe("countMemories()", () => {
-    it("should return total memory count", () => {
-      assert.strictEqual(store.countMemories(), 0);
-
-      store.createMemory({ content: "Memory 1", type: "fact" });
-      store.createMemory({ content: "Memory 2", type: "fact" });
-      store.createMemory({ content: "Memory 3", type: "fact" });
-
-      assert.strictEqual(store.countMemories(), 3);
-    });
-
-    it("should filter count by session id", () => {
-      store.createMemory({ content: "Session 1", type: "fact", sessionId: null }); // was: "session-1"
-      store.createMemory({ content: "Session 2", type: "fact", sessionId: null }); // was: "session-2"
-
-      // Both have null sessionId, so filtering by null returns both
-      assert.strictEqual(store.countMemories({ sessionId: null }), 2);
-      assert.strictEqual(store.countMemories(), 2);
-    });
-  });
-
-  describe("Entity Tracking", () => {
-    it("should track entities", () => {
-      store.trackEntity({ name: "Express.js", type: "library", context: { version: "5.x" } });
-
-      const entity = store.getEntity("Express.js");
-      assert.strictEqual(entity.name, "Express.js");
-      assert.strictEqual(entity.type, "library");
-      assert.strictEqual(entity.count, 1);
-    });
-
-    it("should increment count for existing entities", () => {
-      store.trackEntity({ name: "React", type: "library" });
-      store.trackEntity({ name: "React", type: "library" });
-
-      const entity = store.getEntity("React");
-      assert.strictEqual(entity.count, 2);
-    });
-
-    it("should retrieve all entities", () => {
-      store.trackEntity({ name: "Python", type: "language" });
-      store.trackEntity({ name: "JavaScript", type: "language" });
-
-      const entities = store.getAllEntities();
-      assert.strictEqual(entities.length, 2);
-    });
-  });
-});

package/test/memory/store.test.js.bak

@@ -1,312 +0,0 @@
-const assert = require("assert");
-const { describe, it, beforeEach, afterEach } = require("node:test");
-const fs = require("fs");
-const path = require("path");
-const Database = require("better-sqlite3");
-
-describe("Memory Store", () => {
-  let store;
-  let testDbPath;
-  let originalDb;
-
-  beforeEach(() => {
-    // Create a temporary test database
-    testDbPath = path.join(__dirname, `../../data/test-memory-${Date.now()}.db`);
-
-    // Clear module cache
-    delete require.cache[require.resolve("../../src/db")];
-    delete require.cache[require.resolve("../../src/memory/store")];
-
-    // Set test environment
-    process.env.DB_PATH = testDbPath;
-
-    // Initialize database with schema
-    const db = require("../../src/db");
-
-    // Load store module
-    store = require("../../src/memory/store");
-  });
-
-  afterEach(() => {
-    // Clean up test database
-    try {
-      if (fs.existsSync(testDbPath)) {
-        fs.unlinkSync(testDbPath);
-      }
-    } catch (err) {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("createMemory()", () => {
-    it("should create a new memory with all fields", () => {
-      const memory = store.createMemory({
-        content: "User prefers Python for data processing",
-        type: "preference",
-        category: "user",
-        importance: 0.8,
-        surpriseScore: 0.6,
-        sessionId: null,
-        metadata: { source: "conversation" }
-      });
-
-      assert.ok(memory.id);
-      assert.strictEqual(memory.content, "User prefers Python for data processing");
-      assert.strictEqual(memory.type, "preference");
-      assert.strictEqual(memory.category, "user");
-      assert.strictEqual(memory.importance, 0.8);
-      assert.strictEqual(memory.surpriseScore, 0.6);
-      assert.strictEqual(memory.sessionId, null);
-      assert.ok(memory.createdAt);
-      assert.ok(memory.updatedAt);
-    });
-
-    it("should create memory with default values", () => {
-      const memory = store.createMemory({
-        content: "Test memory",
-        type: "fact"
-      });
-
-      assert.strictEqual(memory.importance, 0.5);
-      assert.strictEqual(memory.surpriseScore, 0.0);
-      assert.strictEqual(memory.accessCount, 0);
-      assert.strictEqual(memory.decayFactor, 1.0);
-    });
-
-    it("should throw error for missing required fields", () => {
-      assert.throws(() => {
-        store.createMemory({ type: "fact" });
-      }, /content.*required/i);
-
-      assert.throws(() => {
-        store.createMemory({ content: "Test" });
-      }, /type.*required/i);
-    });
-  });
-
-  describe("getMemory()", () => {
-    it("should retrieve memory by id", () => {
-      const created = store.createMemory({
-        content: "This project uses Express.js",
-        type: "fact",
-        category: "project"
-      });
-
-      const retrieved = store.getMemory(created.id);
-      assert.strictEqual(retrieved.id, created.id);
-      assert.strictEqual(retrieved.content, "This project uses Express.js");
-    });
-
-    it("should return null for non-existent id", () => {
-      const memory = store.getMemory(99999);
-      assert.strictEqual(memory, null);
-    });
-
-    it("should increment access count when requested", () => {
-      const created = store.createMemory({
-        content: "Test memory",
-        type: "fact"
-      });
-
-      const retrieved1 = store.getMemory(created.id, { incrementAccess: true });
-      assert.strictEqual(retrieved1.accessCount, 1);
-
-      const retrieved2 = store.getMemory(created.id, { incrementAccess: true });
-      assert.strictEqual(retrieved2.accessCount, 2);
-    });
-  });
-
-  describe("updateMemory()", () => {
-    it("should update memory fields", () => {
-      const created = store.createMemory({
-        content: "Original content",
-        type: "fact",
-        importance: 0.5
-      });
-
-      const updated = store.updateMemory(created.id, {
-        content: "Updated content",
-        importance: 0.9
-      });
-
-      assert.strictEqual(updated.content, "Updated content");
-      assert.strictEqual(updated.importance, 0.9);
-      assert.ok(updated.updatedAt > created.updatedAt);
-    });
-
-    it("should throw error for non-existent memory", () => {
-      assert.throws(() => {
-        store.updateMemory(99999, { content: "Test" });
-      });
-    });
-  });
-
-  describe("deleteMemory()", () => {
-    it("should delete memory by id", () => {
-      const created = store.createMemory({
-        content: "Memory to delete",
-        type: "fact"
-      });
-
-      const result = store.deleteMemory(created.id);
-      assert.strictEqual(result, true);
-
-      const retrieved = store.getMemory(created.id);
-      assert.strictEqual(retrieved, null);
-    });
-
-    it("should return false for non-existent memory", () => {
-      const result = store.deleteMemory(99999);
-      assert.strictEqual(result, false);
-    });
-  });
-
-  describe("getRecentMemories()", () => {
-    it("should retrieve recent memories", () => {
-      store.createMemory({ content: "Memory 1", type: "fact" });
-      store.createMemory({ content: "Memory 2", type: "fact" });
-      store.createMemory({ content: "Memory 3", type: "fact" });
-
-      const recent = store.getRecentMemories({ limit: 2 });
-      assert.strictEqual(recent.length, 2);
-      assert.strictEqual(recent[0].content, "Memory 3"); // Most recent first
-      assert.strictEqual(recent[1].content, "Memory 2");
-    });
-
-    it("should filter by session id", () => {
-      store.createMemory({ content: "Session 1 memory", type: "fact", sessionId: "session-1" });
-      store.createMemory({ content: "Session 2 memory", type: "fact", sessionId: "session-2" });
-      store.createMemory({ content: "Global memory", type: "fact" });
-
-      const session1Memories = store.getRecentMemories({ sessionId: "session-1" });
-      assert.strictEqual(session1Memories.length, 1);
-      assert.strictEqual(session1Memories[0].content, "Session 1 memory");
-    });
-  });
-
-  describe("getMemoriesByImportance()", () => {
-    it("should retrieve memories sorted by importance", () => {
-      store.createMemory({ content: "Low importance", type: "fact", importance: 0.3 });
-      store.createMemory({ content: "High importance", type: "fact", importance: 0.9 });
-      store.createMemory({ content: "Medium importance", type: "fact", importance: 0.6 });
-
-      const memories = store.getMemoriesByImportance({ limit: 3 });
-      assert.strictEqual(memories.length, 3);
-      assert.strictEqual(memories[0].content, "High importance");
-      assert.strictEqual(memories[1].content, "Medium importance");
-      assert.strictEqual(memories[2].content, "Low importance");
-    });
-  });
-
-  describe("getMemoriesBySurprise()", () => {
-    it("should retrieve memories sorted by surprise score", () => {
-      store.createMemory({ content: "Low surprise", type: "fact", surpriseScore: 0.2 });
-      store.createMemory({ content: "High surprise", type: "fact", surpriseScore: 0.8 });
-      store.createMemory({ content: "Medium surprise", type: "fact", surpriseScore: 0.5 });
-
-      const memories = store.getMemoriesBySurprise({ limit: 2 });
-      assert.strictEqual(memories.length, 2);
-      assert.strictEqual(memories[0].content, "High surprise");
-      assert.strictEqual(memories[1].content, "Medium surprise");
-    });
-  });
-
-  describe("getMemoriesByType()", () => {
-    it("should filter memories by type", () => {
-      store.createMemory({ content: "Preference 1", type: "preference" });
-      store.createMemory({ content: "Fact 1", type: "fact" });
-      store.createMemory({ content: "Preference 2", type: "preference" });
-
-      const preferences = store.getMemoriesByType("preference");
-      assert.strictEqual(preferences.length, 2);
-      assert.ok(preferences.every(m => m.type === "preference"));
-    });
-  });
-
-  describe("pruneOldMemories()", () => {
-    it("should delete memories older than specified days", () => {
-      const oldTimestamp = Date.now() - (100 * 24 * 60 * 60 * 1000); // 100 days ago
-
-      // Create old memory by directly manipulating DB (since we can't set createdAt via API)
-      const db = require("../../src/db");
-      db.prepare(`
-        INSERT INTO memories (content, type, importance, surprise_score, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run("Old memory", "fact", 0.5, 0.0, oldTimestamp, oldTimestamp);
-
-      store.createMemory({ content: "New memory", type: "fact" });
-
-      const deletedCount = store.pruneOldMemories({ maxAgeDays: 90 });
-      assert.strictEqual(deletedCount, 1);
-
-      const remaining = store.getRecentMemories({ limit: 10 });
-      assert.strictEqual(remaining.length, 1);
-      assert.strictEqual(remaining[0].content, "New memory");
-    });
-  });
-
-  describe("pruneByCount()", () => {
-    it("should keep only most important memories up to maxCount", () => {
-      store.createMemory({ content: "Low 1", type: "fact", importance: 0.2 });
-      store.createMemory({ content: "High 1", type: "fact", importance: 0.9 });
-      store.createMemory({ content: "Low 2", type: "fact", importance: 0.3 });
-      store.createMemory({ content: "High 2", type: "fact", importance: 0.8 });
-      store.createMemory({ content: "Medium", type: "fact", importance: 0.5 });
-
-      const deletedCount = store.pruneByCount({ maxCount: 3 });
-      assert.strictEqual(deletedCount, 2);
-
-      const remaining = store.getMemoriesByImportance({ limit: 10 });
-      assert.strictEqual(remaining.length, 3);
-      assert.ok(remaining.every(m => m.importance >= 0.5));
-    });
-  });
-
-  describe("countMemories()", () => {
-    it("should return total memory count", () => {
-      assert.strictEqual(store.countMemories(), 0);
-
-      store.createMemory({ content: "Memory 1", type: "fact" });
-      store.createMemory({ content: "Memory 2", type: "fact" });
-      store.createMemory({ content: "Memory 3", type: "fact" });
-
-      assert.strictEqual(store.countMemories(), 3);
-    });
-
-    it("should filter count by session id", () => {
-      store.createMemory({ content: "Session 1", type: "fact", sessionId: "session-1" });
-      store.createMemory({ content: "Session 2", type: "fact", sessionId: "session-2" });
-
-      assert.strictEqual(store.countMemories({ sessionId: "session-1" }), 1);
-      assert.strictEqual(store.countMemories({ sessionId: "session-2" }), 1);
-      assert.strictEqual(store.countMemories(), 2);
-    });
-  });
-
-  describe("Entity Tracking", () => {
-    it("should track entities", () => {
-      store.trackEntity({ name: "Express.js", type: "library", context: { version: "5.x" } });
-
-      const entity = store.getEntity("Express.js");
-      assert.strictEqual(entity.name, "Express.js");
-      assert.strictEqual(entity.type, "library");
-      assert.strictEqual(entity.count, 1);
-    });
-
-    it("should increment count for existing entities", () => {
-      store.trackEntity({ name: "React", type: "library" });
-      store.trackEntity({ name: "React", type: "library" });
-
-      const entity = store.getEntity("React");
-      assert.strictEqual(entity.count, 2);
-    });
-
-    it("should retrieve all entities", () => {
-      store.trackEntity({ name: "Python", type: "language" });
-      store.trackEntity({ name: "JavaScript", type: "language" });
-
-      const entities = store.getAllEntities();
-      assert.strictEqual(entities.length, 2);
-    });
-  });
-});