recallnest 2.2.0 → 2.2.1

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

@@ -1,153 +0,0 @@
-/**
- * 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

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

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

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