lynkr 8.0.0 → 8.0.1

package/test/memory/retriever.test.js.bak

@@ -1,585 +0,0 @@
-const assert = require("assert");
-const { describe, it, beforeEach, afterEach } = require("node:test");
-const fs = require("fs");
-const path = require("path");
-
-describe("Memory Retriever", () => {
-  let store;
-  let retriever;
-  let testDbPath;
-
-  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")];
-    delete require.cache[require.resolve("../../src/memory/search")];
-    delete require.cache[require.resolve("../../src/memory/retriever")];
-
-    // Set test environment
-    process.env.DB_PATH = testDbPath;
-
-    // Initialize database with schema
-    require("../../src/db");
-
-    // Load modules
-    store = require("../../src/memory/store");
-    retriever = require("../../src/memory/retriever");
-
-    // Create test memories with different characteristics
-    const now = Date.now();
-
-    // Recent + important + relevant
-    store.createMemory({
-      content: "User prefers Python for data processing and machine learning",
-      type: "preference",
-      category: "user",
-      importance: 0.9,
-      surpriseScore: 0.8
-    });
-
-    // Old but important
-    const db = require("../../src/db");
-    const oldTimestamp = now - (30 * 24 * 60 * 60 * 1000); // 30 days ago
-    db.prepare(`
-      INSERT INTO memories (content, type, category, importance, surprise_score, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      "Critical: Always validate user input for SQL injection",
-      "fact",
-      "security",
-      0.95,
-      0.9,
-      oldTimestamp,
-      oldTimestamp
-    );
-
-    // Recent but less important
-    store.createMemory({
-      content: "User mentioned liking the color blue",
-      type: "preference",
-      category: "user",
-      importance: 0.3,
-      surpriseScore: 0.2
-    });
-
-    // Relevant to specific queries
-    store.createMemory({
-      content: "This project uses Express.js with TypeScript and JWT authentication",
-      type: "fact",
-      category: "project",
-      importance: 0.7,
-      surpriseScore: 0.6
-    });
-
-    store.createMemory({
-      content: "Database connection pool configured with max 20 connections",
-      type: "fact",
-      category: "code",
-      importance: 0.6,
-      surpriseScore: 0.5
-    });
-  });
-
-  afterEach(() => {
-    // Clean up test database
-    try {
-      if (fs.existsSync(testDbPath)) {
-        fs.unlinkSync(testDbPath);
-      }
-    } catch (err) {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("retrieveRelevantMemories()", () => {
-    it("should retrieve memories relevant to query", () => {
-      const memories = retriever.retrieveRelevantMemories("Python programming");
-      assert.ok(memories.length > 0);
-      assert.ok(memories.some(m => m.content.toLowerCase().includes("python")));
-    });
-
-    it("should respect limit parameter", () => {
-      const memories = retriever.retrieveRelevantMemories("project", { limit: 2 });
-      assert.ok(memories.length <= 2);
-    });
-
-    it("should rank by multi-signal scoring", () => {
-      const memories = retriever.retrieveRelevantMemories("authentication security", { limit: 5 });
-
-      if (memories.length > 1) {
-        // First result should have highest score
-        const scores = memories.map(m =>
-          retriever.calculateRetrievalScore(m, "authentication security", {
-            recencyWeight: 0.3,
-            importanceWeight: 0.4,
-            relevanceWeight: 0.3
-          })
-        );
-
-        for (let i = 1; i < scores.length; i++) {
-          assert.ok(scores[i - 1] >= scores[i],
-            `Memory ${i-1} score ${scores[i-1]} should be >= memory ${i} score ${scores[i]}`);
-        }
-      }
-    });
-
-    it("should combine recency, importance, and relevance", () => {
-      const memories = retriever.retrieveRelevantMemories("Python", { limit: 5 });
-
-      // Should include the high-importance Python memory
-      assert.ok(memories.some(m =>
-        m.content.includes("Python") && m.importance >= 0.8
-      ));
-    });
-
-    it("should filter by session id when specified", () => {
-      // Use null for sessionId to avoid FOREIGN KEY constraint
-      store.createMemory({
-        content: "Session-specific memory about testing",
-        type: "fact",
-        sessionId: null, // Changed from "test-session-123" to avoid FK constraint
-        importance: 0.8
-      });
-
-      const memories = retriever.retrieveRelevantMemories("testing", {
-        sessionId: null,
-        includeGlobal: true
-      });
-
-      // Should include memories
-      assert.ok(Array.isArray(memories));
-    });
-
-    it("should include global memories when includeGlobal is true", () => {
-      // All memories use null sessionId to avoid FK constraint
-      store.createMemory({
-        content: "Memory about databases type A",
-        type: "fact",
-        sessionId: null,
-        importance: 0.5
-      });
-
-      store.createMemory({
-        content: "Global memory about databases type B",
-        type: "fact",
-        sessionId: null,
-        importance: 0.9
-      });
-
-      const memories = retriever.retrieveRelevantMemories("databases", {
-        sessionId: null,
-        includeGlobal: true,
-        limit: 10
-      });
-
-      // Should include memories
-      assert.ok(memories.length >= 0);
-    });
-
-    it("should handle empty query gracefully", () => {
-      const memories = retriever.retrieveRelevantMemories("", { limit: 3 });
-      // Should return recent/important memories even without query
-      assert.ok(Array.isArray(memories));
-    });
-
-    it("should handle queries with no matches", () => {
-      const memories = retriever.retrieveRelevantMemories("nonexistent-keyword-xyz");
-      // Should still return some memories (e.g., by importance)
-      assert.ok(Array.isArray(memories));
-    });
-  });
-
-  describe("calculateRetrievalScore()", () => {
-    it("should calculate score with default weights", () => {
-      const memory = {
-        content: "User prefers Python for data processing",
-        importance: 0.8,
-        createdAt: Date.now(),
-        accessCount: 5
-      };
-
-      const score = retriever.calculateRetrievalScore(memory, "Python data", {
-        recencyWeight: 0.3,
-        importanceWeight: 0.4,
-        relevanceWeight: 0.3
-      });
-      assert.ok(score >= 0 && score <= 1, `Score ${score} should be in [0,1]`);
-    });
-
-    it("should give higher scores to recent memories", () => {
-      const recent = {
-        content: "Recent memory about Python",
-        importance: 0.5,
-        createdAt: Date.now(),
-        accessCount: 0
-      };
-
-      const old = {
-        content: "Old memory about Python",
-        importance: 0.5,
-        createdAt: Date.now() - (60 * 24 * 60 * 60 * 1000), // 60 days ago
-        accessCount: 0
-      };
-
-      const weights = { recencyWeight: 0.3, importanceWeight: 0.4, relevanceWeight: 0.3 };
-      const recentScore = retriever.calculateRetrievalScore(recent, "Python", weights);
-      const oldScore = retriever.calculateRetrievalScore(old, "Python", weights);
-
-      assert.ok(recentScore > oldScore,
-        `Recent score ${recentScore} should be > old score ${oldScore}`);
-    });
-
-    it("should give higher scores to important memories", () => {
-      const important = {
-        content: "Important memory about Python",
-        importance: 0.9,
-        createdAt: Date.now(),
-        accessCount: 0
-      };
-
-      const unimportant = {
-        content: "Unimportant memory about Python",
-        importance: 0.2,
-        createdAt: Date.now(),
-        accessCount: 0
-      };
-
-      const weights = { recencyWeight: 0.3, importanceWeight: 0.4, relevanceWeight: 0.3 };
-      const importantScore = retriever.calculateRetrievalScore(important, "Python", weights);
-      const unimportantScore = retriever.calculateRetrievalScore(unimportant, "Python", weights);
-
-      assert.ok(importantScore > unimportantScore,
-        `Important score ${importantScore} should be > unimportant score ${unimportantScore}`);
-    });
-
-    it("should give higher scores to relevant content", () => {
-      const relevant = {
-        content: "Python programming language for data processing and machine learning",
-        importance: 0.5,
-        createdAt: Date.now(),
-        accessCount: 0
-      };
-
-      const irrelevant = {
-        content: "JavaScript framework for web development",
-        importance: 0.5,
-        createdAt: Date.now(),
-        accessCount: 0
-      };
-
-      const weights = { recencyWeight: 0.3, importanceWeight: 0.4, relevanceWeight: 0.3 };
-      const relevantScore = retriever.calculateRetrievalScore(relevant, "Python programming", weights);
-      const irrelevantScore = retriever.calculateRetrievalScore(irrelevant, "Python programming", weights);
-
-      assert.ok(relevantScore > irrelevantScore,
-        `Relevant score ${relevantScore} should be > irrelevant score ${irrelevantScore}`);
-    });
-
-    it("should allow custom weight configuration", () => {
-      const memory = {
-        content: "Test memory",
-        importance: 0.8,
-        createdAt: Date.now() - (30 * 24 * 60 * 60 * 1000),
-        accessCount: 0
-      };
-
-      // Emphasize importance over recency
-      const importanceHeavy = retriever.calculateRetrievalScore(memory, "test", {
-        recencyWeight: 0.1,
-        importanceWeight: 0.8,
-        relevanceWeight: 0.1
-      });
-
-      // Emphasize recency over importance
-      const recencyHeavy = retriever.calculateRetrievalScore(memory, "test", {
-        recencyWeight: 0.8,
-        importanceWeight: 0.1,
-        relevanceWeight: 0.1
-      });
-
-      // For an old but important memory, importance-heavy should score higher
-      assert.ok(importanceHeavy > recencyHeavy,
-        `Importance-heavy ${importanceHeavy} should be > recency-heavy ${recencyHeavy} for old memory`);
-    });
-  });
-
-  describe("formatMemoriesForContext()", () => {
-    it("should format memories as readable text", () => {
-      const memories = store.getRecentMemories({ limit: 3 });
-      const formatted = retriever.formatMemoriesForContext(memories);
-
-      assert.ok(typeof formatted === "string");
-      assert.ok(formatted.length > 0);
-
-      // Should include memory types and content
-      memories.forEach(m => {
-        assert.ok(formatted.includes(m.type) || formatted.includes(m.content));
-      });
-    });
-
-    it("should handle empty memories array", () => {
-      const formatted = retriever.formatMemoriesForContext([]);
-      assert.strictEqual(formatted, "");
-    });
-
-    it("should include relative timestamps", () => {
-      const memories = store.getRecentMemories({ limit: 2 });
-      const formatted = retriever.formatMemoriesForContext(memories);
-
-      // Should include time indicators
-      assert.ok(
-        formatted.includes("ago") ||
-        formatted.includes("recently") ||
-        formatted.includes("just now")
-      );
-    });
-
-    it("should group by type", () => {
-      const memories = [
-        { content: "Preference 1", type: "preference", createdAt: Date.now() },
-        { content: "Preference 2", type: "preference", createdAt: Date.now() },
-        { content: "Fact 1", type: "fact", createdAt: Date.now() }
-      ];
-
-      const formatted = retriever.formatMemoriesForContext(memories);
-
-      // Should mention types
-      assert.ok(formatted.includes("preference") || formatted.includes("Preference"));
-      assert.ok(formatted.includes("fact") || formatted.includes("Fact"));
-    });
-  });
-
-  describe("injectMemoriesIntoSystem()", () => {
-    it("should inject memories into system prompt", () => {
-      const originalSystem = "You are a helpful assistant.";
-      const memories = store.getRecentMemories({ limit: 2 });
-
-      const injected = retriever.injectMemoriesIntoSystem(originalSystem, memories);
-
-      assert.ok(typeof injected === "string");
-      assert.ok(injected.includes(originalSystem));
-      assert.ok(injected.length > originalSystem.length);
-    });
-
-    it("should include memory content in injection", () => {
-      const originalSystem = "You are a helpful assistant.";
-      const memories = [
-        {
-          content: "User prefers Python",
-          type: "preference",
-          createdAt: Date.now()
-        }
-      ];
-
-      const injected = retriever.injectMemoriesIntoSystem(originalSystem, memories);
-
-      assert.ok(injected.includes("Python") || injected.includes("prefer"));
-    });
-
-    it("should handle empty memories", () => {
-      const originalSystem = "You are a helpful assistant.";
-      const injected = retriever.injectMemoriesIntoSystem(originalSystem, []);
-
-      assert.strictEqual(injected, originalSystem);
-    });
-
-    it("should handle null/undefined system prompt", () => {
-      const memories = store.getRecentMemories({ limit: 2 });
-
-      const fromNull = retriever.injectMemoriesIntoSystem(null, memories);
-      const fromUndefined = retriever.injectMemoriesIntoSystem(undefined, memories);
-
-      assert.ok(typeof fromNull === "string");
-      assert.ok(typeof fromUndefined === "string");
-    });
-
-    it("should support different injection formats", () => {
-      const memories = store.getRecentMemories({ limit: 2 });
-
-      const systemFormat = retriever.injectMemoriesIntoSystem(
-        "You are helpful.",
-        memories,
-        "system"
-      );
-
-      const preambleFormat = retriever.injectMemoriesIntoSystem(
-        "You are helpful.",
-        memories,
-        "assistant_preamble"
-      );
-
-      assert.ok(typeof systemFormat === "string");
-      // assistant_preamble format returns an object
-      assert.ok(typeof preambleFormat === "object");
-      assert.ok(preambleFormat.system === "You are helpful.");
-      assert.ok(typeof preambleFormat.memoryPreamble === "string");
-      assert.ok(preambleFormat.memoryPreamble.length > 0);
-    });
-  });
-
-  describe("getMemoryStats()", () => {
-    it("should return statistics about memories", () => {
-      const stats = retriever.getMemoryStats();
-
-      assert.ok(stats.total >= 0);
-      assert.ok(stats.byType);
-      assert.ok(stats.byCategory);
-      assert.ok(typeof stats.avgImportance === "number");
-    });
-
-    it("should count memories by type", () => {
-      const stats = retriever.getMemoryStats();
-
-      assert.ok(typeof stats.byType === "object");
-      // Should have counts for types we created
-      assert.ok(stats.byType.preference >= 0);
-      assert.ok(stats.byType.fact >= 0);
-    });
-
-    it("should count memories by category", () => {
-      const stats = retriever.getMemoryStats();
-
-      assert.ok(typeof stats.byCategory === "object");
-      // Should have counts for categories we created
-      assert.ok(stats.byCategory.user >= 0 || stats.byCategory.project >= 0);
-    });
-
-    it("should calculate average importance", () => {
-      const stats = retriever.getMemoryStats();
-
-      assert.ok(stats.avgImportance >= 0 && stats.avgImportance <= 1);
-    });
-
-    it("should filter stats by session", () => {
-      store.createMemory({
-        content: "Session memory",
-        type: "fact",
-        sessionId: "test-session"
-      });
-
-      const globalStats = retriever.getMemoryStats();
-      const sessionStats = retriever.getMemoryStats({ sessionId: "test-session" });
-
-      assert.ok(sessionStats.total <= globalStats.total);
-    });
-  });
-
-  describe("extractQueryFromMessage()", () => {
-    it("should extract query from simple user message", () => {
-      const message = {
-        role: "user",
-        content: "How do I use Python for data processing?"
-      };
-
-      const query = retriever.extractQueryFromMessage(message);
-      assert.ok(typeof query === "string");
-      assert.ok(query.length > 0);
-    });
-
-    it("should handle messages with tool use", () => {
-      const message = {
-        role: "user",
-        content: [
-          { type: "text", text: "Search for Python tutorials" },
-          { type: "tool_use", name: "search" }
-        ]
-      };
-
-      const query = retriever.extractQueryFromMessage(message);
-      assert.ok(typeof query === "string");
-    });
-
-    it("should handle empty messages", () => {
-      const message = { role: "user", content: "" };
-      const query = retriever.extractQueryFromMessage(message);
-      assert.strictEqual(query, "");
-    });
-
-    it("should extract key terms from longer messages", () => {
-      const message = {
-        role: "user",
-        content: "I'm working on a new feature that requires authentication. Can you help me implement JWT tokens?"
-      };
-
-      const query = retriever.extractQueryFromMessage(message);
-      assert.ok(query.includes("authentication") || query.includes("JWT"));
-    });
-  });
-
-  describe("Performance", () => {
-    it("should retrieve memories within 50ms target", () => {
-      // Create more memories for realistic test
-      for (let i = 0; i < 50; i++) {
-        store.createMemory({
-          content: `Test memory ${i} about various topics`,
-          type: "fact",
-          importance: Math.random()
-        });
-      }
-
-      const start = Date.now();
-      const memories = retriever.retrieveRelevantMemories("test topics", { limit: 10 });
-      const duration = Date.now() - start;
-
-      assert.ok(memories.length > 0);
-      assert.ok(duration < 50, `Retrieval took ${duration}ms, expected < 50ms`);
-    });
-
-    it("should handle concurrent retrievals", () => {
-      const queries = [
-        "Python programming",
-        "JavaScript frameworks",
-        "database connections",
-        "authentication security"
-      ];
-
-      const results = queries.map(q =>
-        retriever.retrieveRelevantMemories(q, { limit: 5 })
-      );
-
-      results.forEach(memories => {
-        assert.ok(Array.isArray(memories));
-      });
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("should handle very long queries", () => {
-      const longQuery = "Python ".repeat(100);
-      assert.doesNotThrow(() => {
-        retriever.retrieveRelevantMemories(longQuery, { limit: 5 });
-      });
-    });
-
-    it("should handle special characters in queries", () => {
-      assert.doesNotThrow(() => {
-        retriever.retrieveRelevantMemories("@angular/core ^16.0.0", { limit: 5 });
-      });
-    });
-
-    it("should handle zero limit", () => {
-      const memories = retriever.retrieveRelevantMemories("test", { limit: 0 });
-      assert.strictEqual(memories.length, 0);
-    });
-
-    it("should handle negative weights gracefully", () => {
-      const memory = {
-        content: "Test",
-        importance: 0.5,
-        createdAt: Date.now()
-      };
-
-      // Should normalize or clamp weights
-      assert.doesNotThrow(() => {
-        retriever.calculateRetrievalScore(memory, "test", {
-          recencyWeight: -0.5,
-          importanceWeight: 1.5,
-          relevanceWeight: 0.5
-        });
-      });
-    });
-  });
-});