Skip to content
Python
9.8 KB
Raw Blame
import type {
  GovernedMemory,
  MemoryGraphResponse,
  MemoryLibraryPage,
  SourceResponse,
} from "@one-memory/contracts";
import { describe, expect, it } from "vitest";
import {
  mapGroups,
  projectMap,
  projectPagedSourceMap,
} from "./memory-map-model";

const memories = [
  { memory_id: "a", content: "Alpha", tags: ["设计"], status: "confirmed" },
  {
    memory_id: "b",
    content: "Beta",
    tags: ["设计", "测试"],
    status: "confirmed",
  },
  { memory_id: "c", content: "Gamma", tags: ["测试"], status: "confirmed" },
] as GovernedMemory[];
const graph = {
  total_memories: 3,
  projected_memories: 3,
  hy_graph_available: false,
  nodes: [
    ...memories.map((m) => ({
      node_id: `memory:${m.memory_id}`,
      node_type: "memory",
      memory_id: m.memory_id,
      label: m.content,
    })),
    {
      node_id: "source:codex",
      node_type: "source",
      source_id: "codex",
      label: "Codex",
    },
    {
      node_id: "source:cursor",
      node_type: "source",
      source_id: "cursor",
      label: "Cursor",
    },
  ],
  edges: [
    {
      edge_id: "a",
      source_node_id: "source:codex",
      target_node_id: "memory:a",
      origin: "provenance",
      relation: "evidence_source",
    },
    {
      edge_id: "b",
      source_node_id: "memory:b",
      target_node_id: "source:codex",
      origin: "provenance",
      relation: "evidence_source",
    },
    {
      edge_id: "c",
      source_node_id: "source:cursor",
      target_node_id: "memory:c",
      origin: "provenance",
      relation: "evidence_source",
    },
  ],
} as MemoryGraphResponse;

describe("memory map membership", () => {
  it("counts only actual provenance rather than every imported source", () => {
    expect(
      mapGroups(memories, graph, "source").map((g) => [g.key, g.memoryIds]),
    ).toEqual([
      ["source:codex", ["a", "b"]],
      ["source:cursor", ["c"]],
    ]);
    expect(
      mapGroups(memories, graph, "topic").find((g) => g.label === "设计")
        ?.sourceCount,
    ).toBe(1);
  });
  it("topic membership is many-to-many and does not infer a matter", () => {
    expect(
      mapGroups(memories, graph, "topic").find((g) => g.label === "测试")
        ?.memoryIds,
    ).toEqual(["b", "c"]);
  });
  it("filters to selected memories and their actual related nodes only", () => {
    const result = projectMap(graph, memories, "source", ["a", "b"]);
    expect(result.nodes.map((n) => n.node_id)).not.toContain("source:cursor");
    expect(result.nodes.map((n) => n.node_id)).not.toContain("memory:c");
    expect(result.edges).toHaveLength(2);
  });
  it("builds topic edges only from actual tags, without creating new facts", () => {
    const result = projectMap(graph, memories, "topic", ["a", "b"]);
    expect(result.nodes.filter((n) => n.node_type === "memory")).toHaveLength(
      2,
    );
    expect(result.nodes.filter((n) => n.node_type === "source")).toHaveLength(
      0,
    );
    expect(result.edges.filter((e) => e.origin === "shared_tag")).toHaveLength(
      3,
    );
    expect(projectMap(graph, memories, "source", []).nodes).toEqual([]);
  });
});

describe("page-receipted source projection", () => {
  const sources = [
    { source_id: "codex", display_name: "Codex", authorized: true },
    { source_id: "cursor", display_name: "Cursor", authorized: true },
  ] as SourceResponse[];
  const page = (
    overrides: Partial<MemoryLibraryPage> = {},
  ): MemoryLibraryPage => ({
    items: memories,
    total: 501,
    offset: 100,
    limit: 100,
    source_ids_by_memory: { a: ["cursor"], b: ["codex", "cursor"], c: [] },
    ...overrides,
  });

  it("adds source nodes and provenance for off-graph page memories using the receipt", () => {
    const result = projectPagedSourceMap(null, page(), sources);
    expect(result.total_memories).toBe(501);
    expect(result.projected_memories).toBe(3);
    expect(
      result.nodes.find((node) => node.node_id === "source:cursor")?.label,
    ).toBe("Cursor");
    expect(
      [...mapGroups(memories, result, "source")].map((group) => [
        group.key,
        group.memoryIds,
      ]),
    ).toEqual([
      ["source:cursor", ["a", "b"]],
      ["source:codex", ["b"]],
    ]);
    expect(result.edges).toHaveLength(3);
    expect(
      result.edges.every(
        (edge) =>
          edge.origin === "provenance" &&
          edge.relation === "evidence_source" &&
          edge.weight === null,
      ),
    ).toBe(true);
  });

  it("replaces stale provenance instead of combining conflicting graph guesses", () => {
    const before = JSON.stringify({ graph, memories });
    const result = projectPagedSourceMap(graph, page(), sources);
    expect(
      mapGroups(memories, result, "source").find(
        (group) => group.key === "source:codex",
      )?.memoryIds,
    ).toEqual(["b"]);
    expect(
      result.nodes.find((node) => node.node_id === "memory:c"),
    ).toBeTruthy();
    expect(
      result.edges.some((edge) =>
        [edge.source_node_id, edge.target_node_id].includes("memory:c"),
      ),
    ).toBe(false);
    expect(JSON.stringify({ graph, memories })).toBe(before);
  });

  it("keeps only current confirmed memories and does not project off-page mapping entries", () => {
    const result = projectPagedSourceMap(
      graph,
      page({
        items: [
          memories[1],
          { ...memories[0], status: "deleted" },
          { ...memories[2], status: "superseded" },
        ],
        source_ids_by_memory: {
          a: ["cursor"],
          b: ["codex"],
          c: ["cursor"],
          other: ["cursor"],
        },
      }),
      sources,
    );
    expect(
      result.nodes
        .filter((node) => node.node_type === "memory")
        .map((node) => node.memory_id),
    ).toEqual(["b"]);
    expect(result.projected_memories).toBe(1);
    expect(result.edges).toHaveLength(1);
  });

  it("does not keep any part of mixed-source memory after an explicit source revocation", () => {
    const result = projectPagedSourceMap(
      graph,
      page(),
      sources.map((source) => ({
        ...source,
        authorized: source.source_id !== "cursor",
      })),
    );
    expect(
      result.nodes
        .filter((node) => node.node_type === "memory")
        .map((node) => node.memory_id),
    ).toEqual(["c"]);
    expect(result.nodes.some((node) => node.node_type === "source")).toBe(
      false,
    );
    expect(result.edges).toEqual([]);
  });

  it("missing receipt fields never use old graph membership or tag labels", () => {
    const result = projectPagedSourceMap(
      graph,
      page({ source_ids_by_memory: undefined }),
      sources,
    );
    expect(
      result.nodes.filter((node) => node.node_type === "memory"),
    ).toHaveLength(3);
    expect(result.nodes.some((node) => node.node_type === "source")).toBe(
      false,
    );
    expect(result.edges).toEqual([]);
    const partial = projectPagedSourceMap(
      graph,
      page({ source_ids_by_memory: { b: ["codex"] } }),
      sources,
    );
    expect(partial.edges).toHaveLength(1);
  });

  it("uses the receipted source ID when the current source catalog lacks a display name", () => {
    const result = projectPagedSourceMap(
      null,
      page({
        source_ids_by_memory: { a: ["historical-source"], b: [], c: [] },
      }),
      sources,
    );
    expect(
      result.nodes.find((node) => node.source_id === "historical-source")
        ?.label,
    ).toBe("historical-source");
  });

  it("preserves current-page topic relationships and the existing topic projection", () => {
    const topics = projectMap(graph, memories, "topic", ["a", "b", "c"]);
    const result = projectPagedSourceMap(topics, page(), sources);
    expect(result.edges.filter((edge) => edge.origin === "shared_tag")).toEqual(
      topics.edges,
    );
    const topicView = projectMap(result, memories, "topic", ["a", "b"]);
    expect(topicView.nodes.some((node) => node.node_type === "source")).toBe(
      false,
    );
    expect(
      topicView.edges.filter((edge) => edge.origin === "shared_tag"),
    ).toHaveLength(3);
  });

  it("is deterministic and does not duplicate nodes or edges on repeated projection", () => {
    const first = projectPagedSourceMap(graph, page(), sources);
    expect(projectPagedSourceMap(first, page(), sources)).toEqual(first);
    expect(new Set(first.nodes.map((node) => node.node_id)).size).toBe(
      first.nodes.length,
    );
    expect(new Set(first.edges.map((edge) => edge.edge_id)).size).toBe(
      first.edges.length,
    );
  });

  it("null page clears graph body and old sources rather than retaining an earlier page", () => {
    const result = projectPagedSourceMap(graph, null, sources);
    expect(result.nodes).toEqual([]);
    expect(result.edges).toEqual([]);
    expect(result.projected_memories).toBe(0);
  });

  it("never builds a source edge from malformed or inherited metadata", () => {
    const inherited = Object.create({ a: ["codex"] });
    inherited.b = ["cursor"];
    inherited.c = [null];
    const result = projectPagedSourceMap(
      graph,
      page({ source_ids_by_memory: inherited }),
      sources,
    );
    expect(result.edges).toHaveLength(1);
    expect(result.edges[0].target_node_id).toBe("memory:b");
    expect(result.edges[0].source_node_id).toBe("source:cursor");
  });

  it("deduplicates receipted source IDs and excludes tombstoned active records", () => {
    const result = projectPagedSourceMap(
      null,
      page({
        items: [
          memories[0],
          { ...memories[1], deleted_at: "2026-09-20T00:00:00Z" },
        ],
        source_ids_by_memory: { a: ["codex", "codex"], b: ["cursor"] },
      }),
      sources,
    );
    expect(result.projected_memories).toBe(1);
    expect(result.edges).toHaveLength(1);
    expect(result.nodes.map((node) => node.node_id)).toEqual([
      "memory:a",
      "source:codex",
    ]);
  });
});