@gethmy/mcp 2.3.4 → 2.4.1

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

@@ -0,0 +1,386 @@
+/**
+ * Unit tests for memory quality audit.
+ *
+ * Run with: bun test packages/mcp-server/src/__tests__/memory-audit.test.ts
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import { runMemoryAudit } from "../memory-audit.js";
+
+function daysAgo(days: number): string {
+  return new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+}
+
+function makeMockClient(
+  entities: unknown[],
+  relations?: Record<string, number>,
+) {
+  const deletedIds: string[] = [];
+  const updatedEntities: Array<{
+    id: string;
+    updates: Record<string, unknown>;
+  }> = [];
+
+  return {
+    client: {
+      listMemoryEntities: mock(async (opts: { offset?: number }) => {
+        const offset = opts.offset ?? 0;
+        if (offset > 0) return { entities: [], count: 0 };
+        return { entities, count: entities.length };
+      }),
+      getRelatedEntities: mock(async (id: string) => {
+        const n = relations?.[id] ?? 0;
+        return {
+          outgoing: Array(n).fill({}),
+          incoming: [],
+        };
+      }),
+      deleteMemoryEntity: mock(async (id: string) => {
+        deletedIds.push(id);
+        return { success: true };
+      }),
+      updateMemoryEntity: mock(
+        async (id: string, updates: Record<string, unknown>) => {
+          updatedEntities.push({ id, updates });
+          return { entity: { id, ...updates } };
+        },
+      ),
+    } as any,
+    deletedIds,
+    updatedEntities,
+  };
+}
+
+describe("runMemoryAudit", () => {
+  test("buckets a healthy modern entity into 'keep'", async () => {
+    const { client } = makeMockClient(
+      [
+        {
+          id: "healthy",
+          type: "pattern",
+          title: "Auth refresh token rotation pattern",
+          content:
+            "Rotate refresh tokens on every use. Keep a rolling window of two valid tokens to allow retry on network failures.",
+          confidence: 0.95,
+          memory_tier: "reference",
+          access_count: 25,
+          last_accessed_at: daysAgo(1),
+          created_at: daysAgo(90),
+          tags: ["auth", "security"],
+          embedding: [0.1, 0.2, 0.3],
+          promoted_from_id: "orig-1",
+          metadata: {},
+        },
+      ],
+      { healthy: 3 },
+    );
+
+    const report = await runMemoryAudit(client, "ws-1");
+    expect(report.summary.keep).toBe(1);
+    expect(report.summary.delete).toBe(0);
+    expect(report.lowest[0].score).toBeGreaterThanOrEqual(70);
+  });
+
+  test("buckets a legacy default-confidence entity into archive/delete", async () => {
+    const { client } = makeMockClient([
+      {
+        id: "legacy",
+        type: "context",
+        title: "x",
+        content: "",
+        confidence: 1.0,
+        memory_tier: "draft",
+        access_count: 0,
+        last_accessed_at: null,
+        created_at: daysAgo(120),
+        tags: [],
+        embedding: null,
+        promoted_from_id: null,
+        metadata: {},
+      },
+    ]);
+
+    const report = await runMemoryAudit(client, "ws-1");
+    expect(report.summary.legacyCount).toBe(1);
+    const a = report.lowest[0];
+    expect(a.legacy).toBe(true);
+    expect(a.bucket === "archive" || a.bucket === "delete").toBe(true);
+    expect(a.legacyReasons.length).toBeGreaterThan(1);
+  });
+
+  test("dryRun does not delete, archive, or flag", async () => {
+    const { client, deletedIds, updatedEntities } = makeMockClient([
+      {
+        id: "bad",
+        type: "context",
+        title: "x",
+        content: "",
+        confidence: 0.1,
+        memory_tier: "draft",
+        access_count: 0,
+        last_accessed_at: null,
+        created_at: daysAgo(100),
+        tags: [],
+        embedding: null,
+      },
+    ]);
+
+    await runMemoryAudit(client, "ws-1", undefined, { dryRun: true });
+    expect(deletedIds).toHaveLength(0);
+    expect(updatedEntities).toHaveLength(0);
+  });
+
+  test("executes delete + archive + flag in non-dryRun", async () => {
+    const { client, deletedIds, updatedEntities } = makeMockClient([
+      // delete (very low)
+      {
+        id: "trash",
+        type: "context",
+        title: "x",
+        content: "",
+        confidence: 0.05,
+        memory_tier: "draft",
+        access_count: 0,
+        last_accessed_at: null,
+        created_at: daysAgo(200),
+        tags: [],
+      },
+      // archive (middling-low)
+      {
+        id: "archive-me",
+        type: "pattern",
+        title: "Partial pattern that lacks context here",
+        content: "Some content that is a bit more substantive than nothing.",
+        confidence: 0.3,
+        memory_tier: "draft",
+        access_count: 0,
+        last_accessed_at: daysAgo(40),
+        created_at: daysAgo(40),
+        tags: [],
+      },
+      // review (medium) — decent content but no tags, no relations, no embedding
+      {
+        id: "review-me",
+        type: "pattern",
+        title: "Reasonable pattern with decent content body here",
+        content:
+          "This entity has enough content to pass the length check. Confidence is moderate, access is limited.",
+        confidence: 0.5,
+        memory_tier: "episode",
+        access_count: 1,
+        last_accessed_at: daysAgo(25),
+        created_at: daysAgo(40),
+        tags: [],
+        embedding: null,
+      },
+    ]);
+
+    const report = await runMemoryAudit(client, "ws-1", undefined, {
+      dryRun: false,
+    });
+
+    expect(deletedIds).toContain("trash");
+    expect(
+      updatedEntities.find((u) => u.id === "archive-me")?.updates.confidence,
+    ).toBe(0.25);
+    expect(
+      (
+        updatedEntities.find((u) => u.id === "review-me")?.updates
+          .metadata as Record<string, unknown>
+      )?.needs_review,
+    ).toBe(true);
+
+    expect(report.actionsTaken.deleted).toBeGreaterThanOrEqual(1);
+    expect(report.actionsTaken.archived).toBeGreaterThanOrEqual(1);
+    expect(report.actionsTaken.flaggedReview).toBeGreaterThanOrEqual(1);
+  });
+
+  test("detects stuck-draft legacy signal", async () => {
+    const { client } = makeMockClient([
+      {
+        id: "stuck",
+        type: "context",
+        title: "Old draft that never made it",
+        content:
+          "Some content that is long enough to not count as thin content right here.",
+        confidence: 0.6,
+        memory_tier: "draft",
+        access_count: 1,
+        last_accessed_at: daysAgo(70),
+        created_at: daysAgo(75),
+        tags: ["x"],
+        embedding: [0.1],
+        promoted_from_id: null,
+      },
+    ]);
+
+    const report = await runMemoryAudit(client, "ws-1");
+    expect(report.legacyBreakdown.stuckDraft).toBe(1);
+    expect(report.lowest[0].reasons).toContain(
+      "stuck draft >60d never promoted",
+    );
+  });
+
+  test("distribution buckets sum to scanned count", async () => {
+    const entities = Array.from({ length: 10 }, (_, i) => ({
+      id: `e${i}`,
+      type: "context",
+      title: `Entity number ${i} with decent title length`,
+      content: "Some content string that is long enough to count properly.",
+      confidence: 0.1 * (i + 1),
+      memory_tier: i % 3 === 0 ? "reference" : "episode",
+      access_count: i,
+      last_accessed_at: daysAgo(i * 2),
+      created_at: daysAgo(i * 5 + 1),
+      tags: i % 2 === 0 ? ["tag"] : [],
+      embedding: i % 2 === 0 ? [0.1] : null,
+    }));
+    const { client } = makeMockClient(entities);
+
+    const report = await runMemoryAudit(client, "ws-1");
+    const total =
+      report.distribution["0-20"] +
+      report.distribution["20-40"] +
+      report.distribution["40-70"] +
+      report.distribution["70-100"];
+    expect(total).toBe(report.summary.scanned);
+    expect(report.summary.scanned).toBe(10);
+  });
+
+  test("empty workspace returns success with zeros", async () => {
+    const { client } = makeMockClient([]);
+    const report = await runMemoryAudit(client, "ws-1");
+    expect(report.success).toBe(true);
+    expect(report.summary.scanned).toBe(0);
+    expect(report.lowest).toHaveLength(0);
+  });
+
+  test("deleteBelow=0 disables deletion entirely", async () => {
+    const { client, deletedIds, updatedEntities } = makeMockClient([
+      {
+        id: "trash",
+        type: "context",
+        title: "x",
+        content: "",
+        confidence: 0.05,
+        memory_tier: "draft",
+        access_count: 0,
+        last_accessed_at: null,
+        created_at: daysAgo(200),
+        tags: [],
+      },
+    ]);
+
+    await runMemoryAudit(client, "ws-1", undefined, {
+      dryRun: false,
+      deleteBelow: 0,
+    });
+    expect(deletedIds).toHaveLength(0);
+    // Should land in archive bucket (score < 40 but >= 0)
+    expect(
+      updatedEntities.find((u) => u.id === "trash")?.updates.confidence,
+    ).toBe(0.25);
+  });
+
+  test("stale-draft filter flags draft+0access+age>threshold separately from bucket", async () => {
+    const { client } = makeMockClient(
+      [
+        // Stale draft — should be flagged by the filter, but otherwise healthy
+        // enough to bucket as "review" (not archive).
+        {
+          id: "stale-draft",
+          type: "context",
+          title:
+            "Task transition: feature work started but never touched again",
+          content:
+            "This draft has enough content and tags to score reasonably, " +
+            "but nobody ever accessed it after creation — classic promote-or-drop candidate.",
+          confidence: 0.4,
+          memory_tier: "draft",
+          access_count: 0,
+          last_accessed_at: null,
+          created_at: daysAgo(10),
+          tags: ["task"],
+          embedding: [0.1],
+        },
+        // Fresh draft — same shape but under the age threshold, must NOT flag.
+        {
+          id: "fresh-draft",
+          type: "context",
+          title: "Task transition: a fresh draft still within the grace window",
+          content:
+            "Content long enough to not be thin at all, really properly sized.",
+          confidence: 0.4,
+          memory_tier: "draft",
+          access_count: 0,
+          last_accessed_at: null,
+          created_at: daysAgo(3),
+          tags: ["task"],
+          embedding: [0.1],
+        },
+        // Non-draft old zero-access — must NOT flag (filter is draft-only).
+        {
+          id: "old-episode",
+          type: "pattern",
+          title: "Episode entity that is old and unaccessed but not a draft",
+          content:
+            "Sometimes reference/episode tier entities sit unaccessed; " +
+            "they're not draft-promotion candidates so the filter should skip them.",
+          confidence: 0.8,
+          memory_tier: "episode",
+          access_count: 0,
+          last_accessed_at: null,
+          created_at: daysAgo(30),
+          tags: ["pat"],
+          embedding: [0.1],
+        },
+      ],
+      { "stale-draft": 1, "fresh-draft": 1, "old-episode": 2 },
+    );
+
+    const report = await runMemoryAudit(client, "ws-1");
+    expect(report.summary.staleDraftCount).toBe(1);
+    expect(report.staleDrafts).toHaveLength(1);
+    expect(report.staleDrafts[0].id).toBe("stale-draft");
+    expect(report.healthReport).toContain("Stale Drafts");
+  });
+
+  test("staleDraftAgeDays option tunes the filter threshold", async () => {
+    const { client } = makeMockClient([
+      {
+        id: "draft-5d",
+        type: "context",
+        title: "Five-day-old untouched draft",
+        content:
+          "Content long enough to pass the thin-content check, absolutely.",
+        confidence: 0.4,
+        memory_tier: "draft",
+        access_count: 0,
+        last_accessed_at: null,
+        created_at: daysAgo(5),
+        tags: ["x"],
+        embedding: [0.1],
+      },
+    ]);
+
+    const defaultRun = await runMemoryAudit(client, "ws-1");
+    expect(defaultRun.summary.staleDraftCount).toBe(0);
+
+    const tightRun = await runMemoryAudit(client, "ws-1", undefined, {
+      staleDraftAgeDays: 3,
+    });
+    expect(tightRun.summary.staleDraftCount).toBe(1);
+  });
+
+  test("fetch error surfaces as report.success=false", async () => {
+    const client = {
+      listMemoryEntities: mock(async () => {
+        throw new Error("API down");
+      }),
+    } as any;
+
+    const report = await runMemoryAudit(client, "ws-1");
+    expect(report.success).toBe(false);
+    expect(report.errors.length).toBeGreaterThan(0);
+  });
+});