@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/temporal-graph.test.ts

@@ -1,378 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import type { GraphNode, GraphEdge, MemoryProvider } from "../src/types.js";
-
-vi.mock("iii-sdk", () => ({
-  getContext: () => ({
-    logger: {
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-    },
-  }),
-}));
-
-function mockKV(
-  nodes: GraphNode[] = [],
-  edges: GraphEdge[] = [],
-) {
-  const store = new Map<string, Map<string, unknown>>();
-  const nodesMap = new Map<string, unknown>();
-  for (const n of nodes) nodesMap.set(n.id, n);
-  store.set("mem:graph:nodes", nodesMap);
-
-  const edgesMap = new Map<string, unknown>();
-  for (const e of edges) edgesMap.set(e.id, e);
-  store.set("mem:graph:edges", edgesMap);
-
-  store.set("mem:graph:edge-history", new Map());
-
-  return {
-    get: async <T>(scope: string, key: string): Promise<T | null> => {
-      return (store.get(scope)?.get(key) as T) ?? null;
-    },
-    set: async <T>(scope: string, key: string, data: T): Promise<T> => {
-      if (!store.has(scope)) store.set(scope, new Map());
-      store.get(scope)!.set(key, data);
-      return data;
-    },
-    delete: async (scope: string, key: string): Promise<void> => {
-      store.get(scope)?.delete(key);
-    },
-    list: async <T>(scope: string): Promise<T[]> => {
-      const entries = store.get(scope);
-      return entries ? (Array.from(entries.values()) as T[]) : [];
-    },
-  };
-}
-
-function mockSdk() {
-  const functions = new Map<string, Function>();
-  return {
-    registerFunction: (opts: { id: string }, fn: Function) => {
-      functions.set(opts.id, fn);
-    },
-    trigger: async (id: string, data: unknown) => {
-      const fn = functions.get(id);
-      if (fn) return fn(data);
-      return null;
-    },
-  };
-}
-
-describe("TemporalGraph", () => {
-  it("imports without errors", async () => {
-    const mod = await import("../src/functions/temporal-graph.js");
-    expect(mod.registerTemporalGraphFunctions).toBeDefined();
-  });
-
-  it("registers all three functions", async () => {
-    const { registerTemporalGraphFunctions } = await import(
-      "../src/functions/temporal-graph.js"
-    );
-    const sdk = mockSdk();
-    const kv = mockKV();
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn().mockResolvedValue(""),
-      summarize: vi.fn().mockResolvedValue(""),
-    };
-
-    registerTemporalGraphFunctions(sdk as never, kv as never, provider);
-
-    const fns = Array.from((sdk as any).trigger ? [] : []);
-    expect(sdk.trigger).toBeDefined();
-  });
-
-  it("extracts temporal graph with context metadata", async () => {
-    const { registerTemporalGraphFunctions } = await import(
-      "../src/functions/temporal-graph.js"
-    );
-
-    const response = `<temporal_graph>
-  <entities>
-    <entity type="person" name="Alice">
-      <property key="role">engineer</property>
-    </entity>
-    <entity type="organization" name="Acme Corp">
-      <property key="industry">tech</property>
-    </entity>
-  </entities>
-  <relationships>
-    <relationship type="works_at" source="Alice" target="Acme Corp" weight="0.9" valid_from="2024-01-01" valid_to="current">
-      <reasoning>Alice joined Acme Corp as an engineer</reasoning>
-      <sentiment>positive</sentiment>
-    </relationship>
-  </relationships>
-</temporal_graph>`;
-
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn().mockResolvedValue(response),
-      summarize: vi.fn().mockResolvedValue(response),
-    };
-
-    const sdk = mockSdk();
-    const kv = mockKV();
-    registerTemporalGraphFunctions(sdk as never, kv as never, provider);
-
-    const result = (await sdk.trigger("mem::temporal-graph-extract", {
-      observations: [
-        {
-          id: "obs_1",
-          title: "Alice at Acme",
-          narrative: "Alice works at Acme Corp as an engineer",
-          concepts: ["career"],
-          files: [],
-          type: "conversation",
-          timestamp: "2024-01-01T00:00:00Z",
-        },
-      ],
-    })) as { success: boolean; nodesAdded: number; edgesAdded: number };
-
-    expect(result.success).toBe(true);
-    expect(result.nodesAdded).toBe(2);
-    expect(result.edgesAdded).toBe(1);
-
-    const storedEdges = await kv.list<GraphEdge>("mem:graph:edges");
-    expect(storedEdges.length).toBe(1);
-    expect(storedEdges[0].tcommit).toBeDefined();
-    expect(storedEdges[0].tvalid).toBe("2024-01-01");
-    expect(storedEdges[0].context?.reasoning).toBe(
-      "Alice joined Acme Corp as an engineer",
-    );
-    expect(storedEdges[0].context?.sentiment).toBe("positive");
-    expect(storedEdges[0].isLatest).toBe(true);
-    expect(storedEdges[0].version).toBe(1);
-  });
-
-  it("appends new edge version instead of overwriting", async () => {
-    const { registerTemporalGraphFunctions } = await import(
-      "../src/functions/temporal-graph.js"
-    );
-
-    const existingNode: GraphNode = {
-      id: "gn_existing_alice",
-      type: "person",
-      name: "Alice",
-      properties: { role: "engineer" },
-      sourceObservationIds: ["obs_0"],
-      createdAt: "2024-01-01T00:00:00Z",
-    };
-    const existingNode2: GraphNode = {
-      id: "gn_existing_acme",
-      type: "organization",
-      name: "Acme Corp",
-      properties: {},
-      sourceObservationIds: ["obs_0"],
-      createdAt: "2024-01-01T00:00:00Z",
-    };
-    const existingEdge: GraphEdge = {
-      id: "ge_old",
-      type: "works_at" as any,
-      sourceNodeId: "gn_existing_alice",
-      targetNodeId: "gn_existing_acme",
-      weight: 0.9,
-      sourceObservationIds: ["obs_0"],
-      createdAt: "2024-01-01T00:00:00Z",
-      tcommit: "2024-01-01T00:00:00Z",
-      tvalid: "2024-01-01",
-      version: 1,
-      isLatest: true,
-    };
-
-    const response = `<temporal_graph>
-  <entities>
-    <entity type="person" name="Alice">
-      <property key="role">senior engineer</property>
-    </entity>
-    <entity type="organization" name="Acme Corp">
-    </entity>
-  </entities>
-  <relationships>
-    <relationship type="works_at" source="Alice" target="Acme Corp" weight="0.95" valid_from="2025-01-01" valid_to="current">
-      <reasoning>Alice was promoted to senior engineer</reasoning>
-      <sentiment>positive</sentiment>
-    </relationship>
-  </relationships>
-</temporal_graph>`;
-
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn().mockResolvedValue(response),
-      summarize: vi.fn().mockResolvedValue(response),
-    };
-
-    const sdk = mockSdk();
-    const kv = mockKV([existingNode, existingNode2], [existingEdge]);
-    registerTemporalGraphFunctions(sdk as never, kv as never, provider);
-
-    const result = (await sdk.trigger("mem::temporal-graph-extract", {
-      observations: [
-        {
-          id: "obs_1",
-          title: "Alice promotion",
-          narrative: "Alice was promoted to senior engineer at Acme Corp",
-          concepts: [],
-          files: [],
-          type: "conversation",
-          timestamp: "2025-01-01T00:00:00Z",
-        },
-      ],
-    })) as { success: boolean; nodesAdded: number; edgesAdded: number };
-
-    expect(result.success).toBe(true);
-
-    const allEdges = await kv.list<GraphEdge>("mem:graph:edges");
-    expect(allEdges.length).toBe(2);
-
-    const oldEdge = allEdges.find((e) => e.id === "ge_old");
-    expect(oldEdge?.isLatest).toBe(false);
-    expect(oldEdge?.tvalidEnd).toBeDefined();
-
-    const newEdge = allEdges.find((e) => e.id !== "ge_old");
-    expect(newEdge?.isLatest).toBe(true);
-    expect(newEdge?.version).toBe(2);
-    expect(newEdge?.tvalid).toBe("2025-01-01");
-  });
-
-  it("temporal query returns current state", async () => {
-    const { registerTemporalGraphFunctions } = await import(
-      "../src/functions/temporal-graph.js"
-    );
-
-    const node: GraphNode = {
-      id: "gn_1",
-      type: "person",
-      name: "Bob",
-      properties: {},
-      sourceObservationIds: ["obs_1"],
-      createdAt: "2024-01-01T00:00:00Z",
-    };
-    const edge1: GraphEdge = {
-      id: "ge_1",
-      type: "located_in" as any,
-      sourceNodeId: "gn_1",
-      targetNodeId: "gn_2",
-      weight: 0.9,
-      sourceObservationIds: ["obs_1"],
-      createdAt: "2023-01-01T00:00:00Z",
-      tcommit: "2023-01-01T00:00:00Z",
-      tvalid: "2023-01-01",
-      tvalidEnd: "2024-06-01",
-      version: 1,
-      isLatest: false,
-    };
-    const edge2: GraphEdge = {
-      id: "ge_2",
-      type: "located_in" as any,
-      sourceNodeId: "gn_1",
-      targetNodeId: "gn_3",
-      weight: 0.9,
-      sourceObservationIds: ["obs_2"],
-      createdAt: "2024-06-01T00:00:00Z",
-      tcommit: "2024-06-01T00:00:00Z",
-      tvalid: "2024-06-01",
-      version: 2,
-      isLatest: true,
-    };
-
-    const sdk = mockSdk();
-    const kv = mockKV([node], [edge1, edge2]);
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn(),
-      summarize: vi.fn(),
-    };
-    registerTemporalGraphFunctions(sdk as never, kv as never, provider);
-
-    const result = (await sdk.trigger("mem::temporal-query", {
-      entityName: "Bob",
-    })) as any;
-
-    expect(result.entity).toBeDefined();
-    expect(result.entity.name).toBe("Bob");
-    expect(result.currentEdges.length).toBe(1);
-    expect(result.currentEdges[0].id).toBe("ge_2");
-  });
-
-  it("temporal query with asOf returns historical state", async () => {
-    const { registerTemporalGraphFunctions } = await import(
-      "../src/functions/temporal-graph.js"
-    );
-
-    const node: GraphNode = {
-      id: "gn_1",
-      type: "person",
-      name: "Charlie",
-      properties: {},
-      sourceObservationIds: ["obs_1"],
-      createdAt: "2023-01-01T00:00:00Z",
-    };
-    const edge1: GraphEdge = {
-      id: "ge_1",
-      type: "located_in" as any,
-      sourceNodeId: "gn_1",
-      targetNodeId: "gn_nyc",
-      weight: 0.9,
-      sourceObservationIds: ["obs_1"],
-      createdAt: "2023-01-01T00:00:00Z",
-      tcommit: "2023-01-01T00:00:00Z",
-      tvalid: "2023-01-01",
-      tvalidEnd: "2024-06-01",
-      version: 1,
-      isLatest: false,
-    };
-    const edge2: GraphEdge = {
-      id: "ge_2",
-      type: "located_in" as any,
-      sourceNodeId: "gn_1",
-      targetNodeId: "gn_london",
-      weight: 0.9,
-      sourceObservationIds: ["obs_2"],
-      createdAt: "2024-06-01T00:00:00Z",
-      tcommit: "2024-06-01T00:00:00Z",
-      tvalid: "2024-06-01",
-      version: 2,
-      isLatest: true,
-    };
-
-    const sdk = mockSdk();
-    const kv = mockKV([node], [edge1, edge2]);
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn(),
-      summarize: vi.fn(),
-    };
-    registerTemporalGraphFunctions(sdk as never, kv as never, provider);
-
-    const result = (await sdk.trigger("mem::temporal-query", {
-      entityName: "Charlie",
-      asOf: "2023-06-01T00:00:00Z",
-    })) as any;
-
-    expect(result.entity.name).toBe("Charlie");
-    expect(result.currentEdges.length).toBe(1);
-    expect(result.currentEdges[0].targetNodeId).toBe("gn_nyc");
-  });
-
-  it("handles empty observations gracefully", async () => {
-    const { registerTemporalGraphFunctions } = await import(
-      "../src/functions/temporal-graph.js"
-    );
-    const sdk = mockSdk();
-    const kv = mockKV();
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn(),
-      summarize: vi.fn(),
-    };
-    registerTemporalGraphFunctions(sdk as never, kv as never, provider);
-
-    const result = (await sdk.trigger("mem::temporal-graph-extract", {
-      observations: [],
-    })) as any;
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("No observations provided");
-  });
-});

package/test/timeline.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-vi.mock("iii-sdk", () => ({
-  getContext: () => ({
-    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
-  }),
-}));
-
-import { registerTimelineFunction } from "../src/functions/timeline.js";
-import type { CompressedObservation, Session, TimelineEntry } from "../src/types.js";
-
-function mockKV() {
-  const store = new Map<string, Map<string, unknown>>();
-  return {
-    get: async <T>(scope: string, key: string): Promise<T | null> => {
-      return (store.get(scope)?.get(key) as T) ?? null;
-    },
-    set: async <T>(scope: string, key: string, data: T): Promise<T> => {
-      if (!store.has(scope)) store.set(scope, new Map());
-      store.get(scope)!.set(key, data);
-      return data;
-    },
-    delete: async (scope: string, key: string): Promise<void> => {
-      store.get(scope)?.delete(key);
-    },
-    list: async <T>(scope: string): Promise<T[]> => {
-      const entries = store.get(scope);
-      return entries ? (Array.from(entries.values()) as T[]) : [];
-    },
-  };
-}
-
-function mockSdk() {
-  const functions = new Map<string, Function>();
-  return {
-    registerFunction: (opts: { id: string }, handler: Function) => {
-      functions.set(opts.id, handler);
-    },
-    registerTrigger: () => {},
-    trigger: async (id: string, data: unknown) => {
-      const fn = functions.get(id);
-      if (!fn) throw new Error(`No function: ${id}`);
-      return fn(data);
-    },
-  };
-}
-
-function makeObs(
-  id: string,
-  timestamp: string,
-  title: string,
-): CompressedObservation {
-  return {
-    id,
-    sessionId: "ses_1",
-    timestamp,
-    type: "file_edit",
-    title,
-    facts: [],
-    narrative: title,
-    concepts: [],
-    files: [],
-    importance: 5,
-  };
-}
-
-describe("Timeline Function", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(async () => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerTimelineFunction(sdk as never, kv as never);
-
-    const session: Session = {
-      id: "ses_1",
-      project: "my-project",
-      cwd: "/tmp",
-      startedAt: "2026-02-01T00:00:00Z",
-      status: "completed",
-      observationCount: 5,
-    };
-    await kv.set("mem:sessions", "ses_1", session);
-
-    await kv.set("mem:obs:ses_1", "obs_1", makeObs("obs_1", "2026-02-01T10:00:00Z", "First edit"));
-    await kv.set("mem:obs:ses_1", "obs_2", makeObs("obs_2", "2026-02-01T11:00:00Z", "Second edit"));
-    await kv.set("mem:obs:ses_1", "obs_3", makeObs("obs_3", "2026-02-01T12:00:00Z", "Third edit"));
-    await kv.set("mem:obs:ses_1", "obs_4", makeObs("obs_4", "2026-02-01T13:00:00Z", "Fourth edit"));
-    await kv.set("mem:obs:ses_1", "obs_5", makeObs("obs_5", "2026-02-01T14:00:00Z", "Fifth edit"));
-  });
-
-  it("anchors by ISO date and returns surrounding observations", async () => {
-    const result = (await sdk.trigger("mem::timeline", {
-      anchor: "2026-02-01T12:00:00Z",
-      before: 2,
-      after: 2,
-    })) as { entries: TimelineEntry[] };
-
-    expect(result.entries.length).toBe(5);
-    expect(result.entries[0].observation.id).toBe("obs_1");
-    expect(result.entries[4].observation.id).toBe("obs_5");
-  });
-
-  it("relativePosition is correct relative to anchor", async () => {
-    const result = (await sdk.trigger("mem::timeline", {
-      anchor: "2026-02-01T12:00:00Z",
-      before: 2,
-      after: 2,
-    })) as { entries: TimelineEntry[] };
-
-    const positions = result.entries.map((e) => e.relativePosition);
-    expect(positions).toEqual([-2, -1, 0, 1, 2]);
-  });
-
-  it("respects before and after limits", async () => {
-    const result = (await sdk.trigger("mem::timeline", {
-      anchor: "2026-02-01T12:00:00Z",
-      before: 1,
-      after: 1,
-    })) as { entries: TimelineEntry[] };
-
-    expect(result.entries.length).toBe(3);
-    expect(result.entries[0].observation.id).toBe("obs_2");
-    expect(result.entries[2].observation.id).toBe("obs_4");
-  });
-
-  it("returns empty entries when no sessions exist for project", async () => {
-    const result = (await sdk.trigger("mem::timeline", {
-      anchor: "2026-02-01T12:00:00Z",
-      project: "nonexistent-project",
-    })) as { entries: TimelineEntry[] };
-
-    expect(result.entries.length).toBe(0);
-  });
-
-  it("handles keyword anchor by finding matching observation", async () => {
-    const result = (await sdk.trigger("mem::timeline", {
-      anchor: "Third",
-      before: 1,
-      after: 1,
-    })) as { entries: TimelineEntry[] };
-
-    expect(result.entries.length).toBe(3);
-    const titles = result.entries.map((e) => e.observation.title);
-    expect(titles).toContain("Third edit");
-  });
-});

package/test/vector-index.test.ts

@@ -1,79 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { VectorIndex } from "../src/state/vector-index.js";
-
-describe("VectorIndex", () => {
-  let index: VectorIndex;
-
-  beforeEach(() => {
-    index = new VectorIndex();
-  });
-
-  it("starts empty", () => {
-    expect(index.size).toBe(0);
-  });
-
-  it("adds and retrieves vectors", () => {
-    index.add("obs_1", "ses_1", new Float32Array([0.1, 0.2, 0.3]));
-    expect(index.size).toBe(1);
-  });
-
-  it("removes a vector", () => {
-    index.add("obs_1", "ses_1", new Float32Array([0.1, 0.2, 0.3]));
-    index.remove("obs_1");
-    expect(index.size).toBe(0);
-  });
-
-  it("returns empty array when searching empty index", () => {
-    const results = index.search(new Float32Array([0.1, 0.2, 0.3]));
-    expect(results).toEqual([]);
-  });
-
-  it("returns results sorted by cosine similarity", () => {
-    index.add("obs_close", "ses_1", new Float32Array([1, 0, 0]));
-    index.add("obs_far", "ses_1", new Float32Array([0, 1, 0]));
-    index.add("obs_medium", "ses_1", new Float32Array([0.7, 0.7, 0]));
-
-    const results = index.search(new Float32Array([1, 0, 0]));
-    expect(results[0].obsId).toBe("obs_close");
-    expect(results[0].score).toBeCloseTo(1.0, 5);
-    expect(results[1].obsId).toBe("obs_medium");
-    expect(results[2].obsId).toBe("obs_far");
-    expect(results[2].score).toBeCloseTo(0.0, 5);
-  });
-
-  it("respects the limit parameter", () => {
-    for (let i = 0; i < 10; i++) {
-      index.add(`obs_${i}`, "ses_1", new Float32Array([i * 0.1, 0.5, 0.5]));
-    }
-    const results = index.search(new Float32Array([0.9, 0.5, 0.5]), 3);
-    expect(results.length).toBe(3);
-  });
-
-  it("clears all vectors", () => {
-    index.add("obs_1", "ses_1", new Float32Array([0.1, 0.2, 0.3]));
-    index.add("obs_2", "ses_1", new Float32Array([0.4, 0.5, 0.6]));
-    index.clear();
-    expect(index.size).toBe(0);
-    expect(index.search(new Float32Array([0.1, 0.2, 0.3]))).toEqual([]);
-  });
-
-  it("serialize and deserialize round-trip preserves data", () => {
-    index.add("obs_1", "ses_1", new Float32Array([0.1, 0.2, 0.3]));
-    index.add("obs_2", "ses_2", new Float32Array([0.4, 0.5, 0.6]));
-
-    const json = index.serialize();
-    const restored = VectorIndex.deserialize(json);
-
-    expect(restored.size).toBe(2);
-    const results = restored.search(new Float32Array([0.1, 0.2, 0.3]), 2);
-    expect(results.length).toBe(2);
-    expect(results[0].obsId).toBe("obs_1");
-    expect(results[0].sessionId).toBe("ses_1");
-  });
-
-  it("handles zero vectors without error", () => {
-    index.add("obs_zero", "ses_1", new Float32Array([0, 0, 0]));
-    const results = index.search(new Float32Array([1, 0, 0]));
-    expect(results[0].score).toBe(0);
-  });
-});