recallnest 1.4.1 → 2.2.0

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

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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,56 @@
+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);
+  });
+});

package/src/__tests__/emotion-phase1-integration.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Phase 1 integration tests: Emotional Valence in Decay pipeline.
+ *
+ * Validates the full wiring:
+ * 1. detectEmotion → salience + source fields
+ * 2. computeDecayScore → emotion-aware weights (0.15/0.25/0.45/0.15)
+ * 3. Backward compatibility when emotion flag is off or metadata absent
+ */
+import { describe, test, expect } from "bun:test";
+import { detectEmotion } from "../emotion-detector.js";
+import { computeDecayScore, type EvolutionMetadata } from "../memory-evolution.js";
+
+// ---------------------------------------------------------------------------
+// 1. detectEmotion: salience + source fields
+// ---------------------------------------------------------------------------
+
+describe("detectEmotion salience & source", () => {
+  test("returns salience field as (|valence| + arousal) / 2", () => {
+    const result = detectEmotion("Finally fixed that horrible production bug after 3 days!");
+    expect(result.salience).toBeDefined();
+    expect(typeof result.salience).toBe("number");
+    // salience = (|valence| + arousal) / 2
+    const expected = (Math.abs(result.valence) + result.arousal) / 2;
+    expect(result.salience).toBeCloseTo(expected, 5);
+  });
+
+  test("returns source: keyword", () => {
+    const result = detectEmotion("This is a great success!");
+    expect(result.source).toBe("keyword");
+  });
+
+  test("neutral text returns salience 0", () => {
+    const result = detectEmotion("The meeting is at 3pm tomorrow.");
+    expect(result.salience).toBe(0);
+  });
+
+  test("empty text returns salience 0 and source keyword", () => {
+    const result = detectEmotion("");
+    expect(result.salience).toBe(0);
+    expect(result.source).toBe("keyword");
+  });
+
+  test("high emotion + high arousal gives high salience", () => {
+    const result = detectEmotion("CRITICAL BUG! Everything is broken! Urgent fix needed!");
+    expect(result.salience).toBeGreaterThan(0.2);
+  });
+
+  test("salience is clamped to [0, 1]", () => {
+    const result = detectEmotion("fail fail fail broken broken crash crash urgent urgent critical critical !!!");
+    expect(result.salience).toBeGreaterThanOrEqual(0);
+    expect(result.salience).toBeLessThanOrEqual(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 2. computeDecayScore: emotion-aware weights
+// ---------------------------------------------------------------------------
+
+describe("computeDecayScore with emotion", () => {
+  const now = Date.now();
+  const baseEvo: EvolutionMetadata = {
+    status: "active",
+    version: 1,
+    accessCount: 3,
+    lastAccessedAt: now - 7 * 86_400_000, // 7 days ago
+    supersededBy: null,
+    supersedes: null,
+    evolutionNote: null,
+    consolidatedInto: null,
+    contributedToPattern: null,
+    sourceMemories: [],
+    validFrom: now - 30 * 86_400_000, // 30 days old
+    validUntil: null,
+  };
+
+  // Save and restore env
+  const origFlag = process.env.RECALLNEST_EMOTION_SCORING;
+
+  test("with emotion flag ON and metadata, emotional memory scores higher", () => {
+    process.env.RECALLNEST_EMOTION_SCORING = "true";
+    try {
+      const emotionalMeta = JSON.stringify({
+        emotion: { valence: -0.9, arousal: 0.8, label: "frustration", salience: 0.85, source: "keyword" },
+      });
+      const neutralMeta = JSON.stringify({
+        emotion: { valence: 0, arousal: 0, label: "neutral", salience: 0, source: "keyword" },
+      });
+
+      const emotionalScore = computeDecayScore(baseEvo, 0.5, now, emotionalMeta);
+      const neutralScore = computeDecayScore(baseEvo, 0.5, now, neutralMeta);
+
+      expect(emotionalScore).toBeGreaterThan(neutralScore);
+    } finally {
+      process.env.RECALLNEST_EMOTION_SCORING = origFlag;
+    }
+  });
+
+  test("with emotion flag ON, weights sum close to 1.0", () => {
+    process.env.RECALLNEST_EMOTION_SCORING = "true";
+    try {
+      // At max values: time=1, freq=1, importance=1, salience=1
+      // Score should be 0.15 + 0.25 + 0.45 + 0.15 = 1.0
+      const freshEvo: EvolutionMetadata = {
+        ...baseEvo,
+        accessCount: 100,
+        lastAccessedAt: now,
+        validFrom: now, // just created
+      };
+      const maxMeta = JSON.stringify({
+        emotion: { valence: 1, arousal: 1, label: "positive", salience: 1, source: "keyword" },
+      });
+
+      const score = computeDecayScore(freshEvo, 1.0, now, maxMeta);
+      expect(score).toBeCloseTo(1.0, 1);
+    } finally {
+      process.env.RECALLNEST_EMOTION_SCORING = origFlag;
+    }
+  });
+
+  test("backward compat: no metadata param still works", () => {
+    const score = computeDecayScore(baseEvo, 0.5, now);
+    expect(score).toBeGreaterThan(0);
+    expect(score).toBeLessThanOrEqual(1);
+  });
+
+  test("backward compat: metadata without emotion still works", () => {
+    process.env.RECALLNEST_EMOTION_SCORING = "true";
+    try {
+      const noEmotionMeta = JSON.stringify({ tier: "working" });
+      const score = computeDecayScore(baseEvo, 0.5, now, noEmotionMeta);
+      expect(score).toBeGreaterThan(0);
+      expect(score).toBeLessThanOrEqual(1);
+    } finally {
+      process.env.RECALLNEST_EMOTION_SCORING = origFlag;
+    }
+  });
+
+  test("with emotion flag OFF, metadata is ignored (base weights)", () => {
+    process.env.RECALLNEST_EMOTION_SCORING = "";
+    try {
+      const emotionalMeta = JSON.stringify({
+        emotion: { valence: -0.9, arousal: 0.8, label: "frustration", salience: 0.85, source: "keyword" },
+      });
+
+      const withMeta = computeDecayScore(baseEvo, 0.5, now, emotionalMeta);
+      const withoutMeta = computeDecayScore(baseEvo, 0.5, now);
+
+      expect(withMeta).toBeCloseTo(withoutMeta, 5);
+    } finally {
+      process.env.RECALLNEST_EMOTION_SCORING = origFlag;
+    }
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, test, expect } from "bun:test";
+import { applyEmotionWeight } from "../retriever.js";
+
+describe("applyEmotionWeight", () => {
+  const makeResult = (id: string, score: number, emotionJson?: object) => ({
+    id,
+    text: "test",
+    vector: [],
+    category: "events" as const,
+    scope: "test",
+    importance: 0.5,
+    timestamp: Date.now(),
+    metadata: emotionJson ? JSON.stringify({ emotion: emotionJson }) : "{}",
+    score,
+    sources: {},
+  });
+
+  test("null query emotion returns unchanged", () => {
+    const results = [makeResult("a", 0.8, { valence: 0.9, arousal: 0.5 })];
+    const output = applyEmotionWeight(results, null);
+    expect(output[0].score).toBe(0.8);
+  });
+
+  test("low-valence query returns unchanged", () => {
+    const queryEmotion = { valence: 0.1, arousal: 0, label: "neutral" };
+    const results = [makeResult("a", 0.8, { valence: 0.9, arousal: 0.5 })];
+    const output = applyEmotionWeight(results, queryEmotion);
+    expect(output[0].score).toBe(0.8);
+  });
+
+  test("negative query boosts negative memories", () => {
+    const queryEmotion = { valence: -0.8, arousal: 0.5, label: "frustration" };
+    const results = [
+      makeResult("neg", 0.7, { valence: -0.7, arousal: 0.5 }),
+      makeResult("pos", 0.7, { valence: 0.8, arousal: 0.3 }),
+    ];
+    const output = applyEmotionWeight(results, queryEmotion);
+    expect(output.find(r => r.id === "neg")!.score).toBeGreaterThan(
+      output.find(r => r.id === "pos")!.score
+    );
+  });
+
+  test("no emotion data leaves score unchanged", () => {
+    const queryEmotion = { valence: -0.8, arousal: 0.5, label: "negative" };
+    const results = [makeResult("no-emo", 0.7)];
+    const output = applyEmotionWeight(results, queryEmotion);
+    expect(output[0].score).toBe(0.7);
+  });
+
+  test("max boost is 15%", () => {
+    const queryEmotion = { valence: 1.0, arousal: 1.0, label: "positive" };
+    const results = [makeResult("a", 1.0, { valence: 1.0, arousal: 1.0 })];
+    const output = applyEmotionWeight(results, queryEmotion);
+    expect(output[0].score).toBeCloseTo(1.15, 2);
+  });
+});