recallnest 1.4.1

package/src/__tests__/embedder.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "bun:test";
+
+import { Embedder } from "../embedder.js";
+
+describe("Embedder transient retry", () => {
+  it("retries a transient single-embedding connection error", async () => {
+    const embedder = new Embedder({
+      provider: "openai-compatible",
+      apiKey: "test-key",
+      model: "text-embedding-3-small",
+      dimensions: 3,
+    });
+
+    let calls = 0;
+    (embedder as any).client = {
+      embeddings: {
+        create: async () => {
+          calls += 1;
+          if (calls === 1) {
+            throw new Error("Connection error. ECONNRESET");
+          }
+          return {
+            data: [{ embedding: [1, 2, 3] }],
+          };
+        },
+      },
+    };
+
+    await expect(embedder.embedPassage("hello")).resolves.toEqual([1, 2, 3]);
+    expect(calls).toBe(2);
+  });
+
+  it("retries a transient batch embedding connection error", async () => {
+    const embedder = new Embedder({
+      provider: "openai-compatible",
+      apiKey: "test-key",
+      model: "text-embedding-3-small",
+      dimensions: 3,
+    });
+
+    let calls = 0;
+    (embedder as any).client = {
+      embeddings: {
+        create: async () => {
+          calls += 1;
+          if (calls === 1) {
+            throw new Error("The socket connection was closed unexpectedly. ECONNRESET");
+          }
+          return {
+            data: [
+              { embedding: [1, 2, 3] },
+              { embedding: [4, 5, 6] },
+            ],
+          };
+        },
+      },
+    };
+
+    await expect(embedder.embedBatchPassage(["a", "b"])).resolves.toEqual([
+      [1, 2, 3],
+      [4, 5, 6],
+    ]);
+    expect(calls).toBe(2);
+  });
+
+  it("does not retry non-transient embedding errors", async () => {
+    const embedder = new Embedder({
+      provider: "openai-compatible",
+      apiKey: "test-key",
+      model: "text-embedding-3-small",
+      dimensions: 3,
+    });
+
+    let calls = 0;
+    (embedder as any).client = {
+      embeddings: {
+        create: async () => {
+          calls += 1;
+          throw new Error("Authentication failed");
+        },
+      },
+    };
+
+    await expect(embedder.embedPassage("hello")).rejects.toThrow("Failed to generate embedding: Authentication failed");
+    expect(calls).toBe(1);
+  });
+
+  it("limits concurrent embedding requests", async () => {
+    const embedder = new Embedder({
+      provider: "openai-compatible",
+      apiKey: "test-key",
+      model: "text-embedding-3-small",
+      dimensions: 3,
+    });
+
+    (embedder as any)._maxConcurrentRequests = 1;
+
+    let inFlight = 0;
+    let maxInFlight = 0;
+    (embedder as any).client = {
+      embeddings: {
+        create: async () => {
+          inFlight += 1;
+          maxInFlight = Math.max(maxInFlight, inFlight);
+          await new Promise((resolve) => setTimeout(resolve, 20));
+          inFlight -= 1;
+          return {
+            data: [{ embedding: [1, 2, 3] }],
+          };
+        },
+      },
+    };
+
+    await Promise.all([
+      embedder.embedPassage("first"),
+      embedder.embedPassage("second"),
+      embedder.embedPassage("third"),
+    ]);
+
+    expect(maxInFlight).toBe(1);
+  });
+});

package/src/__tests__/entity-resolver.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "bun:test";
+
+import { EntityResolver, BUILTIN_ALIASES, defaultResolver, resolveQueryEntities } from "../entity-resolver.js";
+
+describe("EntityResolver", () => {
+  it("resolves known aliases", () => {
+    expect(defaultResolver.resolve("ts")).toBe("typescript");
+    expect(defaultResolver.resolve("TS")).toBe("typescript");
+    expect(defaultResolver.resolve("k8s")).toBe("kubernetes");
+    expect(defaultResolver.resolve("pg")).toBe("postgresql");
+  });
+
+  it("returns term as-is for unknown aliases", () => {
+    expect(defaultResolver.resolve("unknownThing")).toBe("unknownThing");
+    expect(defaultResolver.resolve("")).toBe("");
+  });
+
+  it("supports user aliases that override builtins", () => {
+    const resolver = new EntityResolver(BUILTIN_ALIASES, { "ts": "my-custom-ts" });
+    expect(resolver.resolve("ts")).toBe("my-custom-ts");
+  });
+
+  it("resolveText replaces aliases in context", () => {
+    const text = "I'm using TS with k8s and pg for the backend";
+    const resolved = defaultResolver.resolveText(text);
+    expect(resolved).toContain("typescript");
+    expect(resolved).toContain("kubernetes");
+    expect(resolved).toContain("postgresql");
+  });
+
+  it("resolveText handles longer aliases first", () => {
+    const text = "Using docker-compose for local dev";
+    const resolved = defaultResolver.resolveText(text);
+    expect(resolved).toContain("docker compose");
+  });
+
+  it("hasAlias returns true for known aliases", () => {
+    expect(defaultResolver.hasAlias("ts")).toBe(true);
+    expect(defaultResolver.hasAlias("unknown")).toBe(false);
+  });
+
+  it("size returns the number of aliases", () => {
+    expect(defaultResolver.size).toBeGreaterThan(40);
+  });
+});
+
+describe("resolveQueryEntities", () => {
+  it("normalizes entities in a search query", () => {
+    const result = resolveQueryEntities("search for ts config in k8s");
+    expect(result).toContain("typescript");
+    expect(result).toContain("kubernetes");
+  });
+
+  it("passes through queries with no aliases", () => {
+    const result = resolveQueryEntities("how to deploy a web app");
+    expect(result).toBe("how to deploy a web app");
+  });
+});

package/src/__tests__/event-segmenter.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "bun:test";
+import { segmentEvents, type EventSegmenterConfig } from "../event-segmenter.js";
+
+const cfg: EventSegmenterConfig = { maxSegmentSize: 500, minSegmentSize: 50 };
+
+describe("segmentEvents", () => {
+  it("returns single segment for short text", () => {
+    const result = segmentEvents("Hello world", cfg);
+    expect(result).toHaveLength(1);
+    expect(result[0].boundaryType).toBe("initial");
+  });
+
+  it("returns empty for empty input", () => {
+    expect(segmentEvents("", cfg)).toHaveLength(0);
+    expect(segmentEvents("   ", cfg)).toHaveLength(0);
+  });
+
+  it("splits on topic shift markers (Chinese)", () => {
+    const text = [
+      "[用户] 帮我查一下 TypeScript 的配置方法",
+      "[助手] TypeScript 需要 tsconfig.json 文件来配置编译选项...",
+      "这里有一些常见的配置项：strictNullChecks, target, module 等等。你可以根据项目需要来选择。",
+      "[用户] 另外，帮我看看 Docker 的问题",
+      "[助手] Docker 的问题是什么呢？请描述一下具体的错误信息。",
+    ].join("\n");
+
+    const result = segmentEvents(text, cfg);
+    expect(result.length).toBeGreaterThanOrEqual(2);
+    // First segment should contain TypeScript content
+    expect(result[0].text).toContain("TypeScript");
+    // Second segment should start with the Docker topic
+    expect(result[result.length - 1].text).toContain("Docker");
+  });
+
+  it("splits on topic shift markers (English)", () => {
+    const text = [
+      "[用户] How do I configure TypeScript?",
+      "[助手] You need a tsconfig.json file with compiler options like strictNullChecks and target settings for your project.",
+      "[用户] By the way, what about Docker setup?",
+      "[助手] For Docker, you'll need a Dockerfile and optionally a docker-compose.yml for multi-service setups.",
+    ].join("\n");
+
+    const result = segmentEvents(text, cfg);
+    expect(result.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("splits on Q&A boundaries (user after assistant)", () => {
+    const longAssistant = "A".repeat(200);
+    const text = [
+      `[用户] First question about performance`,
+      `[助手] ${longAssistant}`,
+      `[用户] Second question about security`,
+      `[助手] Security requires authentication and authorization checks.`,
+    ].join("\n");
+
+    const result = segmentEvents(text, { maxSegmentSize: 500, minSegmentSize: 50 });
+    expect(result.length).toBeGreaterThanOrEqual(2);
+    expect(result[0].text).toContain("performance");
+  });
+
+  it("does not split inside code blocks", () => {
+    const text = [
+      "[用户] Show me the code",
+      "[助手] Here's the implementation:",
+      "```typescript",
+      "function hello() {",
+      "  // 另外 this is NOT a topic shift inside code",
+      '  console.log("hello");',
+      "}",
+      "```",
+      "That's the basic structure you need. Let me explain more about the details and configuration options.",
+    ].join("\n");
+
+    const result = segmentEvents(text, cfg);
+    // Should keep code block intact — "另外" inside ``` should not trigger split
+    const codeSegment = result.find(s => s.text.includes("```typescript"));
+    expect(codeSegment).toBeDefined();
+    expect(codeSegment!.text).toContain('console.log("hello")');
+  });
+
+  it("keeps numbered lists intact", () => {
+    const text = [
+      "[助手] Here are the steps to follow for this configuration:",
+      "1. Install the package using npm install",
+      "2. Create config file in your project root",
+      "3. Run the build command to verify",
+      "4. Deploy to staging environment first",
+      "5. Monitor logs for errors before production",
+      "",
+      "[用户] 另外，帮我看看另一个问题",
+    ].join("\n");
+
+    const result = segmentEvents(text, cfg);
+    // The list should be in one segment
+    const listSegment = result.find(s => s.text.includes("1. Install"));
+    expect(listSegment).toBeDefined();
+    expect(listSegment!.text).toContain("5. Monitor");
+  });
+
+  it("detects time jumps", () => {
+    const text = [
+      "[用户] 帮我看看这个 bug，已经排查了很久了。",
+      "[助手] 好的，让我看看错误日志。根据分析，这个问题是由于内存泄漏导致的。",
+      "[用户] 2024-03-15 下午我又遇到了另一个问题",
+      "[助手] 请描述一下新的问题现象。",
+    ].join("\n");
+
+    const result = segmentEvents(text, cfg);
+    // Should split at the date marker
+    const timeSegment = result.find(s => s.text.includes("2024-03-15"));
+    expect(timeSegment).toBeDefined();
+  });
+
+  it("respects max segment size", () => {
+    const longLine = "A".repeat(300);
+    const text = Array.from({ length: 10 }, (_, i) => `Line ${i}: ${longLine}`).join("\n");
+
+    const result = segmentEvents(text, { maxSegmentSize: 800, minSegmentSize: 100 });
+    // All segments should respect max size (with some tolerance for boundary alignment)
+    for (const seg of result) {
+      expect(seg.text.length).toBeLessThanOrEqual(800 * 1.5); // Allow some overshoot for boundary alignment
+    }
+  });
+
+  it("merges tiny trailing segments", () => {
+    const text = [
+      "[用户] " + "A".repeat(400),
+      "[助手] 好的",  // This tiny trailing bit should merge with previous
+    ].join("\n");
+
+    const result = segmentEvents(text, { maxSegmentSize: 500, minSegmentSize: 50 });
+    // Should not produce a segment with just "好的"
+    const tinySegments = result.filter(s => s.text.length < 50);
+    expect(tinySegments).toHaveLength(0);
+  });
+
+  it("handles bullet lists with - markers", () => {
+    const text = [
+      "[助手] Key considerations when designing this system:",
+      "- Performance: optimize hot paths and cache results",
+      "- Security: validate all inputs at system boundaries",
+      "- Reliability: add retry logic with exponential backoff",
+      "- Observability: structured logging with trace IDs",
+      "",
+      "[用户] 另外还有什么需要注意的吗？",
+    ].join("\n");
+
+    const result = segmentEvents(text, cfg);
+    const listSeg = result.find(s => s.text.includes("- Performance"));
+    expect(listSeg).toBeDefined();
+    expect(listSeg!.text).toContain("- Observability");
+  });
+});

package/src/__tests__/hotness-blend.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "bun:test";
+import { computeHotnessScore, parseAccessMetadata } from "../access-tracker.js";
+
+describe("computeHotnessScore", () => {
+  it("returns 0 for zero accesses", () => {
+    expect(computeHotnessScore(0, Date.now())).toBe(0);
+  });
+
+  it("returns positive score for accessed memories", () => {
+    const score = computeHotnessScore(5, Date.now());
+    expect(score).toBeGreaterThan(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+
+  it("higher access count yields higher score", () => {
+    const now = Date.now();
+    const low = computeHotnessScore(1, now);
+    const mid = computeHotnessScore(5, now);
+    const high = computeHotnessScore(50, now);
+    expect(low).toBeLessThan(mid);
+    expect(mid).toBeLessThan(high);
+  });
+
+  it("recent access yields higher score than old access", () => {
+    const now = Date.now();
+    const recent = computeHotnessScore(5, now);
+    const weekAgo = computeHotnessScore(5, now - 7 * 86_400_000);
+    const monthAgo = computeHotnessScore(5, now - 30 * 86_400_000);
+    expect(recent).toBeGreaterThan(weekAgo);
+    expect(weekAgo).toBeGreaterThan(monthAgo);
+  });
+
+  it("decays to near-zero for very old accesses", () => {
+    const score = computeHotnessScore(5, Date.now() - 365 * 86_400_000);
+    expect(score).toBeLessThan(0.01);
+  });
+
+  it("caps at 1.0 even with extreme access counts", () => {
+    const score = computeHotnessScore(10_000, Date.now());
+    expect(score).toBeLessThanOrEqual(1.0);
+  });
+
+  it("respects custom decay rate", () => {
+    const now = Date.now();
+    const fast = computeHotnessScore(5, now - 7 * 86_400_000, 0.5);
+    const slow = computeHotnessScore(5, now - 7 * 86_400_000, 0.01);
+    expect(slow).toBeGreaterThan(fast);
+  });
+});
+
+describe("parseAccessMetadata", () => {
+  it("parses valid metadata", () => {
+    const meta = JSON.stringify({ accessCount: 5, lastAccessedAt: 1234567890 });
+    const result = parseAccessMetadata(meta);
+    expect(result.accessCount).toBe(5);
+    expect(result.lastAccessedAt).toBe(1234567890);
+  });
+
+  it("returns defaults for missing fields", () => {
+    const result = parseAccessMetadata("{}");
+    expect(result.accessCount).toBe(0);
+    expect(result.lastAccessedAt).toBe(0);
+  });
+
+  it("handles undefined input", () => {
+    const result = parseAccessMetadata(undefined);
+    expect(result.accessCount).toBe(0);
+    expect(result.lastAccessedAt).toBe(0);
+  });
+
+  it("handles malformed JSON", () => {
+    const result = parseAccessMetadata("not-json");
+    expect(result.accessCount).toBe(0);
+    expect(result.lastAccessedAt).toBe(0);
+  });
+});