@gethmy/mcp 2.5.0 → 2.5.2

package/src/__tests__/memory-park.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  fitToBudget,
-  type ParkInput,
-  relevanceFromRank,
-  rescore,
-} from "../memory-park.js";
-
-const NOW = new Date("2026-05-08T12:00:00Z");
-
-function entity(
-  partial: Partial<ParkInput> & {
-    id: string;
-    title?: string;
-    content?: string;
-  },
-): ParkInput & { id: string; title?: string; content?: string } {
-  return {
-    id: partial.id,
-    type: partial.type ?? "pattern",
-    importance: partial.importance,
-    last_accessed_at: partial.last_accessed_at,
-    created_at: partial.created_at,
-    title: partial.title,
-    content: partial.content,
-  };
-}
-
-describe("memory-park rescore", () => {
-  test("fresh + high-importance pattern beats stale + low-importance pattern", () => {
-    const fresh = entity({
-      id: "fresh",
-      type: "pattern",
-      importance: 9,
-      last_accessed_at: "2026-05-08T11:00:00Z",
-    });
-    const stale = entity({
-      id: "stale",
-      type: "pattern",
-      importance: 4,
-      last_accessed_at: "2024-05-08T11:00:00Z", // 2y old
-    });
-    const out = rescore([stale, fresh], { now: NOW });
-    expect(out[0]?.entity.id).toBe("fresh");
-    expect(out[1]?.entity.id).toBe("stale");
-    expect(out[0]?.score).toBeGreaterThan(out[1]?.score ?? 0);
-  });
-
-  test("preferences never decay (tau=Infinity → recency=1)", () => {
-    const ancient = entity({
-      id: "p",
-      type: "preference",
-      importance: 9,
-      last_accessed_at: "2020-01-01T00:00:00Z",
-    });
-    const out = rescore([ancient], { now: NOW });
-    expect(out[0]?.recency).toBe(1);
-  });
-
-  test("caller-supplied relevance dominates when weight is high", () => {
-    const a = entity({
-      id: "a",
-      type: "pattern",
-      importance: 5,
-      last_accessed_at: "2026-04-01T00:00:00Z",
-    });
-    const b = entity({
-      id: "b",
-      type: "pattern",
-      importance: 9,
-      last_accessed_at: "2026-04-01T00:00:00Z",
-    });
-    const relevance = new Map([
-      ["a", 1.0],
-      ["b", 0.0],
-    ]);
-    const out = rescore([a, b], { now: NOW, relevance });
-    expect(out[0]?.entity.id).toBe("a");
-  });
-
-  test("missing importance falls back to per-type default", () => {
-    const e = entity({
-      id: "p",
-      type: "preference", // default 9
-      importance: null,
-      last_accessed_at: "2026-05-08T11:00:00Z",
-    });
-    const out = rescore([e], { now: NOW });
-    expect(out[0]?.importance).toBeCloseTo(0.9);
-  });
-
-  test("clamps importance to [1,10]", () => {
-    const tooLow = entity({ id: "lo", type: "pattern", importance: -5 });
-    const tooHigh = entity({ id: "hi", type: "pattern", importance: 99 });
-    const out = rescore([tooLow, tooHigh], { now: NOW });
-    const lo = out.find((s) => s.entity.id === "lo");
-    const hi = out.find((s) => s.entity.id === "hi");
-    expect(lo?.importance).toBeCloseTo(0.1);
-    expect(hi?.importance).toBeCloseTo(1.0);
-  });
-
-  test("score is α·relevance + β·recency + γ·importance", () => {
-    const e = entity({
-      id: "x",
-      type: "pattern",
-      importance: 5,
-      last_accessed_at: "2026-05-08T11:00:00Z", // very fresh
-    });
-    const out = rescore([e], {
-      now: NOW,
-      relevance: new Map([["x", 1.0]]),
-    });
-    const r = out[0]!;
-    const expected = 0.55 * r.relevance + 0.25 * r.recency + 0.2 * r.importance;
-    expect(r.score).toBeCloseTo(expected, 5);
-  });
-});
-
-describe("memory-park relevanceFromRank (hybrid retrieval bridge)", () => {
-  test("top-ranked entity gets relevance 1.0", () => {
-    const ranked = [{ id: "a" }, { id: "b" }, { id: "c" }];
-    const map = relevanceFromRank(ranked);
-    expect(map.get("a")).toBeCloseTo(1.0);
-  });
-
-  test("relevance decays exponentially with rank", () => {
-    const ranked = Array.from({ length: 20 }, (_, i) => ({ id: `r${i}` }));
-    const map = relevanceFromRank(ranked, 10);
-    expect(map.get("r0")).toBeCloseTo(1.0);
-    expect(map.get("r10")).toBeCloseTo(Math.exp(-1));
-    expect(map.get("r20")).toBeUndefined();
-  });
-
-  test("hybrid-ranked top-1 dominates Park rescore over a stale high-importance pattern", () => {
-    const matchedByQuery = entity({
-      id: "match",
-      type: "pattern",
-      importance: 5,
-      last_accessed_at: "2025-05-08T11:00:00Z",
-    });
-    const stalePopular = entity({
-      id: "popular",
-      type: "pattern",
-      importance: 9,
-      last_accessed_at: "2024-05-08T11:00:00Z",
-    });
-    const ranked = [{ id: "match" }, { id: "popular" }];
-    const relevance = relevanceFromRank(ranked);
-    const scored = rescore([stalePopular, matchedByQuery], {
-      now: NOW,
-      relevance,
-    });
-    expect(scored[0]?.entity.id).toBe("match");
-  });
-
-  test("custom decay scales the falloff curve", () => {
-    const ranked = Array.from({ length: 5 }, (_, i) => ({ id: `r${i}` }));
-    const tight = relevanceFromRank(ranked, 1);
-    const loose = relevanceFromRank(ranked, 100);
-    expect(tight.get("r1")).toBeLessThan(loose.get("r1") ?? 0);
-  });
-});
-
-describe("memory-park fitToBudget", () => {
-  test("returns prefix that fits within token budget", () => {
-    const ents = [
-      entity({
-        id: "1",
-        type: "pattern",
-        title: "x".repeat(40),
-        content: "y".repeat(40),
-      }),
-      entity({
-        id: "2",
-        type: "pattern",
-        title: "x".repeat(40),
-        content: "y".repeat(40),
-      }),
-      entity({
-        id: "3",
-        type: "pattern",
-        title: "x".repeat(40),
-        content: "y".repeat(40),
-      }),
-    ];
-    const scored = rescore(ents, { now: NOW });
-    // Each entity ~ (40/4) + (40/4) + 4 = 24 tokens
-    const fit = fitToBudget(scored, 50);
-    expect(fit.length).toBe(2);
-  });
-
-  test("always includes top result even if over budget", () => {
-    const big = entity({
-      id: "big",
-      type: "pattern",
-      title: "x".repeat(2000),
-      content: "y".repeat(2000),
-    });
-    const scored = rescore([big], { now: NOW });
-    const fit = fitToBudget(scored, 10);
-    expect(fit.length).toBe(1);
-    expect(fit[0]?.entity.id).toBe("big");
-  });
-
-  test("zero or negative budget returns empty", () => {
-    const ents = [
-      entity({ id: "1", type: "pattern", title: "abc", content: "def" }),
-    ];
-    const scored = rescore(ents, { now: NOW });
-    expect(fitToBudget(scored, 0)).toHaveLength(0);
-    expect(fitToBudget(scored, -10)).toHaveLength(0);
-  });
-});

package/src/__tests__/memory-session.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  isSessionScope,
-  resolveSessionScope,
-  sessionScopeFor,
-} from "../memory-session.js";
-
-describe("resolveSessionScope", () => {
-  it("returns undefined when caller did not pass a scope", () => {
-    expect(resolveSessionScope(undefined, "abc-123")).toBeUndefined();
-  });
-
-  it("passes a non-alias scope through unchanged", () => {
-    expect(resolveSessionScope("project", "abc-123")).toBe("project");
-    expect(resolveSessionScope("private", undefined)).toBe("private");
-    expect(resolveSessionScope("workspace", "abc-123")).toBe("workspace");
-    expect(resolveSessionScope("global", undefined)).toBe("global");
-  });
-
-  it("resolves the 'session' alias to session:<id> when a session is active", () => {
-    expect(
-      resolveSessionScope("session", "11111111-1111-1111-1111-111111111111"),
-    ).toBe("session:11111111-1111-1111-1111-111111111111");
-  });
-
-  it("throws when 'session' alias is used without an active session", () => {
-    expect(() => resolveSessionScope("session", undefined)).toThrow(
-      /requires an active agent session/i,
-    );
-    expect(() => resolveSessionScope("session", "")).toThrow(
-      /requires an active agent session/i,
-    );
-  });
-
-  it("does not auto-bind any other scope to the active session", () => {
-    expect(resolveSessionScope("project", "abc-123")).toBe("project");
-    expect(resolveSessionScope("private", "abc-123")).toBe("private");
-  });
-});
-
-describe("isSessionScope", () => {
-  it("recognizes concrete session:<id> values", () => {
-    expect(isSessionScope("session:abc-123")).toBe(true);
-    expect(isSessionScope("session:11111111-1111-1111-1111-111111111111")).toBe(
-      true,
-    );
-  });
-
-  it("rejects the bare 'session' alias (not yet resolved)", () => {
-    expect(isSessionScope("session")).toBe(false);
-    expect(isSessionScope("session:")).toBe(false);
-  });
-
-  it("rejects standard scopes", () => {
-    expect(isSessionScope("private")).toBe(false);
-    expect(isSessionScope("project")).toBe(false);
-    expect(isSessionScope("workspace")).toBe(false);
-    expect(isSessionScope("global")).toBe(false);
-  });
-
-  it("rejects non-string inputs", () => {
-    expect(isSessionScope(undefined)).toBe(false);
-    expect(isSessionScope(null)).toBe(false);
-  });
-});
-
-describe("sessionScopeFor", () => {
-  it("constructs the canonical scope value for a session id", () => {
-    expect(sessionScopeFor("abc-123")).toBe("session:abc-123");
-  });
-
-  it("output round-trips through isSessionScope", () => {
-    const scope = sessionScopeFor("11111111-1111-1111-1111-111111111111");
-    expect(isSessionScope(scope)).toBe(true);
-  });
-});