recallnest 2.2.0 → 2.2.1

package/src/__tests__/dream-pipeline.test.ts

@@ -1,232 +0,0 @@
-import { describe, expect, it, beforeEach } from "bun:test";
-import { runDream, formatDreamResult, type DreamResult } from "../dream-pipeline.js";
-import type { MemoryEntry, MemoryStore } from "../store.js";
-import type { LLMClient } from "../llm-client.js";
-import type { Embedder } from "../embedder.js";
-import { resetWriteCount } from "../activity-counter.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(overrides: Partial<MemoryEntry> & { id: string }): MemoryEntry {
-  return {
-    text: "test memory",
-    vector: [1, 0, 0, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.5,
-    timestamp: Date.now(),
-    metadata: JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        accessCount: 0,
-        lastAccessedAt: null,
-        supersededBy: null,
-        consolidatedInto: null,
-        contributedToPattern: null,
-        sourceMemories: [],
-        validFrom: Date.now(),
-        validUntil: null,
-      },
-    }),
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]): MemoryStore {
-  const stored: MemoryEntry[] = [...entries];
-  let storeCounter = 0;
-
-  return {
-    async list() { return stored; },
-    async stats() {
-      return {
-        totalCount: stored.length,
-        total: stored.length,
-        scopeCounts: {},
-        categoryCounts: {},
-      };
-    },
-    async store(entry: Partial<MemoryEntry>) {
-      const full = {
-        id: entry.id || `dream-${storeCounter++}`,
-        text: entry.text || "",
-        vector: entry.vector || [],
-        category: entry.category || "events",
-        scope: entry.scope || "project:test",
-        importance: entry.importance || 0.5,
-        timestamp: Date.now(),
-        metadata: entry.metadata || "{}",
-      } as MemoryEntry;
-      stored.push(full);
-      return full;
-    },
-    async update(id: string, upd: Partial<MemoryEntry>) {
-      const entry = stored.find(e => e.id === id);
-      if (entry && upd.metadata) entry.metadata = upd.metadata;
-      return entry || { id, text: "", vector: [], category: "events", scope: "project:test", importance: 0.5, timestamp: Date.now(), metadata: "{}" } as MemoryEntry;
-    },
-    async getById(id: string) {
-      return stored.find(e => e.id === id) || null;
-    },
-    async vectorSearch(_vec: number[], limit: number, _threshold: number, _scopes?: string[]) {
-      return stored.slice(0, limit).map(e => ({ entry: e, score: 0.85 }));
-    },
-  } as unknown as MemoryStore;
-}
-
-function createMockLLM(): LLMClient {
-  return {
-    async generateL0() { return "consolidated insight"; },
-    async extractPattern() { return "discovered pattern"; },
-  } as unknown as LLMClient;
-}
-
-function createMockEmbedder(): Pick<Embedder, "embedPassage"> {
-  return {
-    async embedPassage() { return [0.5, 0.5, 0, 0, 0]; },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("runDream", () => {
-  beforeEach(() => {
-    // Reset activity counter between tests
-    resetWriteCount();
-  });
-
-  it("skips when write count is below threshold", async () => {
-    const store = createMockStore([makeEntry({ id: "a" })]);
-    const result = await runDream({
-      store,
-      llm: createMockLLM(),
-      embedder: createMockEmbedder(),
-      scope: "project:test",
-      config: { minWritesForDream: 10 },
-    });
-
-    expect(result.ran).toBe(false);
-    expect(result.reason).toContain("insufficient_writes");
-    expect(result.phases.length).toBe(1);
-    expect(result.phases[0].phase).toBe("orient");
-  });
-
-  it("runs when forced despite low write count", async () => {
-    const entries = [
-      makeEntry({ id: "a", vector: [0.9, 0.1, 0, 0, 0] }),
-      makeEntry({ id: "b", vector: [0.88, 0.12, 0, 0, 0] }),
-      makeEntry({ id: "c", vector: [0.92, 0.08, 0, 0, 0] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await runDream({
-      store,
-      llm: createMockLLM(),
-      embedder: createMockEmbedder(),
-      scope: "project:test",
-      force: true,
-    });
-
-    expect(result.ran).toBe(true);
-    expect(result.phases.length).toBe(4);
-    expect(result.phases.map(p => p.phase)).toEqual(["orient", "gather", "consolidate", "prune"]);
-  });
-
-  it("completes early with too few active entries", async () => {
-    const store = createMockStore([
-      makeEntry({ id: "a" }),
-    ]);
-    const result = await runDream({
-      store,
-      llm: createMockLLM(),
-      embedder: createMockEmbedder(),
-      scope: "project:test",
-      force: true,
-      config: { minClusterSize: 3 },
-    });
-
-    expect(result.ran).toBe(true);
-    expect(result.reason).toBe("completed_early");
-  });
-
-  it("works without LLM (null) — only deterministic consolidation", async () => {
-    const entries = [
-      makeEntry({ id: "a", vector: [0.9, 0.1, 0, 0, 0] }),
-      makeEntry({ id: "b", vector: [0.88, 0.12, 0, 0, 0] }),
-      makeEntry({ id: "c", vector: [0.92, 0.08, 0, 0, 0] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await runDream({
-      store,
-      llm: null,
-      embedder: createMockEmbedder(),
-      scope: "project:test",
-      force: true,
-    });
-
-    expect(result.ran).toBe(true);
-    expect(result.stats.insightsGenerated).toBe(0); // No LLM = no insights
-    expect(result.stats.patternsExtracted).toBe(0);
-  });
-
-  it("reports correct stats structure", async () => {
-    const entries = [
-      makeEntry({ id: "a", vector: [0.9, 0.1, 0, 0, 0] }),
-      makeEntry({ id: "b", vector: [0.88, 0.12, 0, 0, 0] }),
-      makeEntry({ id: "c", vector: [0.92, 0.08, 0, 0, 0] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await runDream({
-      store,
-      llm: createMockLLM(),
-      embedder: createMockEmbedder(),
-      scope: "project:test",
-      force: true,
-    });
-
-    expect(result.stats.totalMemories).toBeGreaterThanOrEqual(0);
-    expect(result.stats.activeMemories).toBeGreaterThanOrEqual(0);
-    expect(typeof result.stats.clustersFound).toBe("number");
-    expect(typeof result.stats.insightsGenerated).toBe("number");
-    expect(typeof result.stats.patternsExtracted).toBe("number");
-    expect(typeof result.stats.mergedCount).toBe("number");
-    expect(typeof result.stats.archivedCount).toBe("number");
-  });
-});
-
-describe("formatDreamResult", () => {
-  it("formats skipped dream", () => {
-    const result: DreamResult = {
-      ran: false,
-      reason: "insufficient_writes (3/10)",
-      phases: [{ phase: "orient", detail: "50 memories, 3 writes" }],
-      stats: { totalMemories: 50, activeMemories: 0, writesSinceLastDream: 3, clustersFound: 0, insightsGenerated: 0, patternsExtracted: 0, mergedCount: 0, archivedCount: 0 },
-    };
-    const output = formatDreamResult(result);
-    expect(output).toContain("skipped");
-    expect(output).toContain("insufficient_writes");
-  });
-
-  it("formats completed dream with all phases", () => {
-    const result: DreamResult = {
-      ran: true,
-      phases: [
-        { phase: "orient", detail: "100 memories, 15 writes" },
-        { phase: "gather", detail: "80 active entries" },
-        { phase: "consolidate", detail: "3 clusters, 1 merged, 2 insights, 1 pattern" },
-        { phase: "prune", detail: "5 entries archived" },
-      ],
-      stats: { totalMemories: 100, activeMemories: 80, writesSinceLastDream: 15, clustersFound: 3, insightsGenerated: 2, patternsExtracted: 1, mergedCount: 1, archivedCount: 5 },
-    };
-    const output = formatDreamResult(result);
-    expect(output).toContain("Dream completed");
-    expect(output).toContain("[orient]");
-    expect(output).toContain("[consolidate]");
-    expect(output).toContain("[prune]");
-    expect(output).toContain("Patterns: 1");
-  });
-});

package/src/__tests__/drill-down.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect } from "bun:test";
-
-describe("Tiered storage: L0/L1/L2 metadata parsing", () => {
-  it("parses L0/L1/L2 from metadata JSON", () => {
-    const metadata = JSON.stringify({
-      l0_abstract: "User prefers TypeScript",
-      l1_overview: "User consistently chooses TypeScript over JavaScript for new projects, citing type safety.",
-      l2_content: "Full detailed content here...",
-    });
-    const parsed = JSON.parse(metadata);
-    expect(parsed.l0_abstract).toBe("User prefers TypeScript");
-    expect(parsed.l1_overview.length).toBeGreaterThan(parsed.l0_abstract.length);
-  });
-
-  it("handles missing L0/L1 fields gracefully", () => {
-    const metadata = JSON.stringify({ accessCount: 5 });
-    const parsed = JSON.parse(metadata);
-    expect(parsed.l0_abstract).toBeUndefined();
-    expect(parsed.l1_overview).toBeUndefined();
-  });
-
-  it("handles malformed metadata JSON", () => {
-    const metadata = "not-json";
-    let parsed = null;
-    try {
-      parsed = JSON.parse(metadata);
-    } catch {
-      // Expected
-    }
-    expect(parsed).toBeNull();
-  });
-});
-
-describe("Tiered storage: drill-down level selection", () => {
-  it("overview level returns L1 when available", () => {
-    const meta = {
-      l0_abstract: "Short summary",
-      l1_overview: "Detailed overview with context and reasoning",
-    };
-    const fullText = "Very long full text content...";
-    const level = "overview";
-
-    const result = level === "overview" && meta.l1_overview
-      ? meta.l1_overview
-      : fullText;
-
-    expect(result).toBe(meta.l1_overview);
-  });
-
-  it("overview level falls back to full text when L1 missing", () => {
-    const meta: Record<string, string> = { l0_abstract: "Short summary" };
-    const fullText = "Very long full text content...";
-    const level = "overview";
-
-    const result = level === "overview" && meta.l1_overview
-      ? meta.l1_overview
-      : fullText;
-
-    expect(result).toBe(fullText);
-  });
-
-  it("full level always returns full text", () => {
-    const meta = {
-      l0_abstract: "Short summary",
-      l1_overview: "Detailed overview",
-    };
-    const fullText = "Very long full text content...";
-    const level = "full";
-
-    const result = level === "full" ? fullText : meta.l1_overview || fullText;
-    expect(result).toBe(fullText);
-  });
-});
-
-describe("Tiered storage: recallDepthDefault config", () => {
-  it("accepts valid depth values", () => {
-    for (const depth of ["l0", "l1", "full"]) {
-      expect(["l0", "l1", "full"].includes(depth)).toBe(true);
-    }
-  });
-
-  it("rejects invalid depth values", () => {
-    for (const depth of ["l3", "summary", "compact"]) {
-      expect(["l0", "l1", "full"].includes(depth)).toBe(false);
-    }
-  });
-
-  it("defaults to full when not set (backward compat)", () => {
-    const configValue = undefined;
-    const resolved = configValue || "full";
-    expect(resolved).toBe("full");
-  });
-});
-
-describe("Tiered storage: L0 injection format", () => {
-  it("L0 abstract is compact enough for context injection", () => {
-    const l0 = "User prefers TypeScript for all new projects";
-    // L0 should be under 100 tokens (~400 chars)
-    expect(l0.length).toBeLessThan(400);
-  });
-
-  it("L1 overview provides medium detail", () => {
-    const l1 = "## Preference\nUser consistently chooses TypeScript over JavaScript. Cited reasons: type safety, better IDE support, easier refactoring.";
-    // L1 should be under 500 tokens (~2000 chars)
-    expect(l1.length).toBeLessThan(2000);
-    expect(l1.length).toBeGreaterThan(50);
-  });
-});

package/src/__tests__/embedder.test.ts

@@ -1,122 +0,0 @@
-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__/emotion-decay.test.ts

@@ -1,46 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { weibullDecay, adjustHalfLifeForEmotion, computeArousalBoost } from "../decay-engine.js";
-
-describe("emotion-adjusted decay", () => {
-  test("returns base half-life when no emotion", () => {
-    expect(adjustHalfLifeForEmotion(60, undefined)).toBe(60);
-    expect(adjustHalfLifeForEmotion(60, null)).toBe(60);
-  });
-
-  test("strong negative emotion extends half-life ~27%", () => {
-    const adjusted = adjustHalfLifeForEmotion(60, { valence: -0.9, arousal: 0.5, label: "frustration" });
-    expect(adjusted).toBeCloseTo(60 * 1.27, 0);
-  });
-
-  test("strong positive emotion extends half-life ~24%", () => {
-    const adjusted = adjustHalfLifeForEmotion(60, { valence: 0.8, arousal: 0.3, label: "excitement" });
-    expect(adjusted).toBeCloseTo(60 * 1.24, 0);
-  });
-
-  test("neutral emotion has negligible effect", () => {
-    const adjusted = adjustHalfLifeForEmotion(60, { valence: 0.05, arousal: 0.1, label: "neutral" });
-    expect(adjusted).toBeCloseTo(60, 0);
-  });
-
-  test("emotional memory decays slower at 30 days", () => {
-    const baseHL = 60;
-    const emotionalHL = adjustHalfLifeForEmotion(baseHL, { valence: -0.8, arousal: 0.7, label: "frustration" });
-    const neutralDecay = weibullDecay(30, baseHL, "working");
-    const emotionalDecay = weibullDecay(30, emotionalHL, "working");
-    expect(emotionalDecay).toBeGreaterThan(neutralDecay);
-  });
-
-  test("arousal boost is 1.0 for zero arousal", () => {
-    expect(computeArousalBoost({ valence: 0.5, arousal: 0, label: "positive" })).toBe(1.0);
-  });
-
-  test("arousal boost max ~1.1 for high arousal", () => {
-    const boost = computeArousalBoost({ valence: 0.5, arousal: 0.9, label: "excitement" });
-    expect(boost).toBeCloseTo(1.09, 1);
-  });
-
-  test("arousal boost is 1.0 for null emotion", () => {
-    expect(computeArousalBoost(undefined)).toBe(1.0);
-    expect(computeArousalBoost(null)).toBe(1.0);
-  });
-});

package/src/__tests__/emotion-detector.test.ts

@@ -1,56 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { detectEmotion } from "../emotion-detector.js";
-
-describe("emotion-detector: heuristic", () => {
-  test("detects strong negative text", () => {
-    const result = detectEmotion("This bug is driving me crazy, everything is broken and wrong");
-    expect(result.valence).toBeLessThan(-0.3);
-    expect(result.label).toBe("negative");
-  });
-
-  test("detects strong positive text", () => {
-    const result = detectEmotion("Finally solved it! Works perfectly, great progress today");
-    expect(result.valence).toBeGreaterThan(0.3);
-    expect(result.label).toBe("positive");
-  });
-
-  test("detects neutral text", () => {
-    const result = detectEmotion("The user prefers dark mode and uses VS Code");
-    expect(Math.abs(result.valence)).toBeLessThan(0.3);
-    expect(result.label).toBe("neutral");
-  });
-
-  test("detects high arousal", () => {
-    const result = detectEmotion("URGENT! Critical production issue, fix immediately!");
-    expect(result.arousal).toBeGreaterThan(0.3);
-  });
-
-  test("detects low arousal for calm text", () => {
-    const result = detectEmotion("The default configuration uses port 3000");
-    expect(result.arousal).toBeLessThan(0.3);
-  });
-
-  test("handles mixed signals with net positive", () => {
-    const result = detectEmotion("Had a frustrating bug but finally solved it perfectly");
-    expect(result.valence).toBeGreaterThan(0);
-  });
-
-  test("handles empty text gracefully", () => {
-    const result = detectEmotion("");
-    expect(result.valence).toBe(0);
-    expect(result.arousal).toBe(0);
-    expect(result.label).toBe("neutral");
-  });
-
-  test("clamps valence to [-1, 1]", () => {
-    const result = detectEmotion("broken error wrong bug failure hate broken error wrong");
-    expect(result.valence).toBeGreaterThanOrEqual(-1);
-    expect(result.valence).toBeLessThanOrEqual(1);
-  });
-
-  test("clamps arousal to [0, 1]", () => {
-    const result = detectEmotion("URGENT! CRITICAL! IMMEDIATELY! ASAP!");
-    expect(result.arousal).toBeGreaterThanOrEqual(0);
-    expect(result.arousal).toBeLessThanOrEqual(1);
-  });
-});