@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/governance.test.ts

@@ -1,147 +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 { registerGovernanceFunction } from "../src/functions/governance.js";
-import type { Memory, AuditEntry } 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 makeMemory(id: string, type: Memory["type"] = "pattern"): Memory {
-  return {
-    id,
-    createdAt: "2026-02-01T00:00:00Z",
-    updatedAt: "2026-02-01T00:00:00Z",
-    type,
-    title: `Memory ${id}`,
-    content: `Content for ${id}`,
-    concepts: ["test"],
-    files: [],
-    sessionIds: ["ses_1"],
-    strength: 5,
-    version: 1,
-    isLatest: true,
-  };
-}
-
-describe("Governance Functions", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(async () => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerGovernanceFunction(sdk as never, kv as never);
-
-    await kv.set("mem:memories", "mem_1", makeMemory("mem_1", "pattern"));
-    await kv.set("mem:memories", "mem_2", makeMemory("mem_2", "bug"));
-    await kv.set("mem:memories", "mem_3", makeMemory("mem_3", "pattern"));
-  });
-
-  it("governance-delete removes specified memories", async () => {
-    const result = (await sdk.trigger("mem::governance-delete", {
-      memoryIds: ["mem_1"],
-      reason: "outdated",
-    })) as { success: boolean; deleted: number; total: number };
-
-    expect(result.success).toBe(true);
-    expect(result.deleted).toBe(1);
-    expect(result.total).toBe(1);
-
-    const remaining = await kv.list("mem:memories");
-    expect(remaining.length).toBe(2);
-  });
-
-  it("governance-delete handles non-existent IDs gracefully", async () => {
-    const result = (await sdk.trigger("mem::governance-delete", {
-      memoryIds: ["nonexistent_1", "nonexistent_2"],
-    })) as { success: boolean; deleted: number; total: number };
-
-    expect(result.success).toBe(true);
-    expect(result.deleted).toBe(0);
-    expect(result.total).toBe(2);
-
-    const remaining = await kv.list("mem:memories");
-    expect(remaining.length).toBe(3);
-  });
-
-  it("governance-bulk deletes by type filter", async () => {
-    const result = (await sdk.trigger("mem::governance-bulk", {
-      type: ["pattern"],
-    })) as { success: boolean; deleted: number };
-
-    expect(result.success).toBe(true);
-    expect(result.deleted).toBe(2);
-
-    const remaining = await kv.list<Memory>("mem:memories");
-    expect(remaining.length).toBe(1);
-    expect(remaining[0].type).toBe("bug");
-  });
-
-  it("governance-bulk respects dryRun", async () => {
-    const result = (await sdk.trigger("mem::governance-bulk", {
-      type: ["pattern"],
-      dryRun: true,
-    })) as { success: boolean; dryRun: boolean; wouldDelete: number; ids: string[] };
-
-    expect(result.success).toBe(true);
-    expect(result.dryRun).toBe(true);
-    expect(result.wouldDelete).toBe(2);
-    expect(result.ids).toContain("mem_1");
-    expect(result.ids).toContain("mem_3");
-
-    const remaining = await kv.list("mem:memories");
-    expect(remaining.length).toBe(3);
-  });
-
-  it("audit-query returns audit entries", async () => {
-    await sdk.trigger("mem::governance-delete", {
-      memoryIds: ["mem_1"],
-      reason: "cleanup",
-    });
-
-    const entries = (await sdk.trigger("mem::audit-query", {})) as AuditEntry[];
-
-    expect(entries.length).toBe(1);
-    expect(entries[0].operation).toBe("delete");
-    expect(entries[0].functionId).toBe("mem::governance-delete");
-  });
-});

package/test/graph-retrieval.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { GraphRetrieval } from "../src/functions/graph-retrieval.js";
-import type { GraphNode, GraphEdge } from "../src/types.js";
-
-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);
-
-  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 makeNode(
-  id: string,
-  name: string,
-  type: GraphNode["type"] = "concept",
-  obsIds: string[] = ["obs_1"],
-): GraphNode {
-  return {
-    id,
-    type,
-    name,
-    properties: {},
-    sourceObservationIds: obsIds,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-function makeEdge(
-  id: string,
-  sourceNodeId: string,
-  targetNodeId: string,
-  type: GraphEdge["type"] = "related_to",
-  weight = 0.8,
-): GraphEdge {
-  return {
-    id,
-    type,
-    sourceNodeId,
-    targetNodeId,
-    weight,
-    sourceObservationIds: ["obs_1"],
-    createdAt: new Date().toISOString(),
-    tcommit: new Date().toISOString(),
-    isLatest: true,
-  };
-}
-
-describe("GraphRetrieval", () => {
-  it("finds entities by name", async () => {
-    const nodes = [
-      makeNode("n1", "React", "library", ["obs_1"]),
-      makeNode("n2", "Vue", "library", ["obs_2"]),
-    ];
-    const kv = mockKV(nodes, []);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const results = await retrieval.searchByEntities(["React"]);
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].obsId).toBe("obs_1");
-  });
-
-  it("finds entities by partial name match", async () => {
-    const nodes = [makeNode("n1", "auth-middleware", "function", ["obs_1"])];
-    const kv = mockKV(nodes, []);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const results = await retrieval.searchByEntities(["auth"]);
-    expect(results.length).toBeGreaterThan(0);
-  });
-
-  it("traverses graph edges to find related observations", async () => {
-    const nodes = [
-      makeNode("n1", "React", "library", ["obs_1"]),
-      makeNode("n2", "Component", "concept", ["obs_2"]),
-    ];
-    const edges = [makeEdge("e1", "n1", "n2", "uses")];
-    const kv = mockKV(nodes, edges);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const results = await retrieval.searchByEntities(["React"], 2);
-    const obsIds = results.map((r) => r.obsId);
-    expect(obsIds).toContain("obs_1");
-    expect(obsIds).toContain("obs_2");
-  });
-
-  it("returns empty for no matches", async () => {
-    const kv = mockKV([], []);
-    const retrieval = new GraphRetrieval(kv as never);
-    const results = await retrieval.searchByEntities(["nonexistent"]);
-    expect(results).toEqual([]);
-  });
-
-  it("expands from existing chunks", async () => {
-    const nodes = [
-      makeNode("n1", "auth.ts", "file", ["obs_1"]),
-      makeNode("n2", "jwt", "concept", ["obs_2"]),
-    ];
-    const edges = [makeEdge("e1", "n1", "n2", "uses")];
-    const kv = mockKV(nodes, edges);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const results = await retrieval.expandFromChunks(["obs_1"]);
-    const obsIds = results.map((r) => r.obsId);
-    expect(obsIds).toContain("obs_2");
-  });
-
-  it("does not duplicate already-seen observations in expansion", async () => {
-    const nodes = [makeNode("n1", "file.ts", "file", ["obs_1", "obs_2"])];
-    const kv = mockKV(nodes, []);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const results = await retrieval.expandFromChunks(["obs_1"]);
-    const obsIds = results.map((r) => r.obsId);
-    expect(obsIds).not.toContain("obs_1");
-  });
-
-  it("performs temporal query - current state", async () => {
-    const nodes = [makeNode("n1", "Alice", "person", ["obs_1"])];
-    const edges = [
-      makeEdge("e1", "n1", "n1", "located_in" as any, 0.9),
-      {
-        ...makeEdge("e2", "n1", "n1", "located_in" as any, 0.9),
-        tvalid: "2024-06-01",
-        isLatest: true,
-      },
-    ];
-    const kv = mockKV(nodes, edges);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const result = await retrieval.temporalQuery("Alice");
-    expect(result.entity).toBeDefined();
-    expect(result.entity!.name).toBe("Alice");
-    expect(result.currentState.length).toBeGreaterThan(0);
-  });
-
-  it("returns null entity for unknown name", async () => {
-    const kv = mockKV([], []);
-    const retrieval = new GraphRetrieval(kv as never);
-    const result = await retrieval.temporalQuery("Unknown");
-    expect(result.entity).toBeNull();
-  });
-
-  it("scores closer paths higher", async () => {
-    const nodes = [
-      makeNode("n1", "React", "library", ["obs_1"]),
-      makeNode("n2", "Hook", "concept", ["obs_2"]),
-      makeNode("n3", "State", "concept", ["obs_3"]),
-    ];
-    const edges = [
-      makeEdge("e1", "n1", "n2", "uses", 0.9),
-      makeEdge("e2", "n2", "n3", "related_to", 0.8),
-    ];
-    const kv = mockKV(nodes, edges);
-    const retrieval = new GraphRetrieval(kv as never);
-
-    const results = await retrieval.searchByEntities(["React"], 3);
-    const directScore = results.find((r) => r.obsId === "obs_1")?.score ?? 0;
-    const indirectScore = results.find((r) => r.obsId === "obs_3")?.score ?? 0;
-    expect(directScore).toBeGreaterThan(indirectScore);
-  });
-});

package/test/graph.test.ts

@@ -1,160 +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 { registerGraphFunction } from "../src/functions/graph.js";
-import type {
-  CompressedObservation,
-  GraphNode,
-  GraphEdge,
-  GraphQueryResult,
-} 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);
-    },
-  };
-}
-
-const mockProvider = {
-  name: "test",
-  compress: vi.fn().mockResolvedValue(`<entities>
-<entity type="file" name="src/index.ts"><property key="path">src/index.ts</property></entity>
-<entity type="function" name="main"><property key="lang">typescript</property></entity>
-</entities>
-<relationships>
-<relationship type="uses" source="src/index.ts" target="main" weight="0.9"/>
-</relationships>`),
-  summarize: vi.fn(),
-};
-
-const testObs: CompressedObservation = {
-  id: "obs_1",
-  sessionId: "ses_1",
-  timestamp: "2026-02-01T10:00:00Z",
-  type: "file_edit",
-  title: "Edit index file",
-  facts: ["Modified main function"],
-  narrative: "Updated index.ts with main function",
-  concepts: ["typescript", "entry-point"],
-  files: ["src/index.ts"],
-  importance: 7,
-};
-
-describe("Graph Functions", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    sdk = mockSdk();
-    kv = mockKV();
-    vi.clearAllMocks();
-    registerGraphFunction(sdk as never, kv as never, mockProvider as never);
-  });
-
-  it("graph-extract creates nodes and edges from XML response", async () => {
-    const result = (await sdk.trigger("mem::graph-extract", {
-      observations: [testObs],
-    })) as { success: boolean; nodesAdded: number; edgesAdded: number };
-
-    expect(result.success).toBe(true);
-    expect(result.nodesAdded).toBe(2);
-    expect(result.edgesAdded).toBe(1);
-
-    const nodes = await kv.list<GraphNode>("mem:graph:nodes");
-    expect(nodes.length).toBe(2);
-    expect(nodes.find((n) => n.name === "src/index.ts")).toBeDefined();
-    expect(nodes.find((n) => n.name === "main")).toBeDefined();
-
-    const edges = await kv.list<GraphEdge>("mem:graph:edges");
-    expect(edges.length).toBe(1);
-    expect(edges[0].type).toBe("uses");
-  });
-
-  it("graph-query with search returns matching nodes", async () => {
-    await sdk.trigger("mem::graph-extract", { observations: [testObs] });
-
-    const result = (await sdk.trigger("mem::graph-query", {
-      query: "index",
-    })) as GraphQueryResult;
-
-    expect(result.nodes.length).toBeGreaterThanOrEqual(1);
-    expect(result.nodes.some((n) => n.name.includes("index"))).toBe(true);
-  });
-
-  it("graph-query with startNodeId does BFS traversal", async () => {
-    await sdk.trigger("mem::graph-extract", { observations: [testObs] });
-
-    const nodes = await kv.list<GraphNode>("mem:graph:nodes");
-    const fileNode = nodes.find((n) => n.name === "src/index.ts")!;
-
-    const result = (await sdk.trigger("mem::graph-query", {
-      startNodeId: fileNode.id,
-      maxDepth: 2,
-    })) as GraphQueryResult;
-
-    expect(result.nodes.length).toBeGreaterThanOrEqual(1);
-    expect(result.edges.length).toBeGreaterThanOrEqual(1);
-    expect(result.depth).toBe(2);
-  });
-
-  it("graph-stats returns counts by type", async () => {
-    await sdk.trigger("mem::graph-extract", { observations: [testObs] });
-
-    const result = (await sdk.trigger("mem::graph-stats", {})) as {
-      totalNodes: number;
-      totalEdges: number;
-      nodesByType: Record<string, number>;
-      edgesByType: Record<string, number>;
-    };
-
-    expect(result.totalNodes).toBe(2);
-    expect(result.totalEdges).toBe(1);
-    expect(result.nodesByType.file).toBe(1);
-    expect(result.nodesByType.function).toBe(1);
-    expect(result.edgesByType.uses).toBe(1);
-  });
-
-  it("graph-extract returns error for empty observations", async () => {
-    const result = (await sdk.trigger("mem::graph-extract", {
-      observations: [],
-    })) as { success: boolean; error: string };
-
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("No observations");
-  });
-});

package/test/helpers/mocks.ts

@@ -1,40 +0,0 @@
-import { vi } from "vitest";
-
-type Handler = (data: unknown) => Promise<unknown>;
-
-export 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[]) : [];
-    },
-  };
-}
-
-export function mockSdk() {
-  const functions = new Map<string, Handler>();
-  return {
-    registerFunction: (opts: { id: string }, handler: Handler) => {
-      functions.set(opts.id, handler);
-    },
-    registerTrigger: vi.fn(),
-    trigger: async (id: string, data: unknown) => {
-      const fn = functions.get(id);
-      if (!fn) throw new Error(`No function: ${id}`);
-      return fn(data);
-    },
-    triggerVoid: vi.fn(),
-  };
-}

package/test/hybrid-search.test.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { HybridSearch } from "../src/state/hybrid-search.js";
-import { SearchIndex } from "../src/state/search-index.js";
-import type { CompressedObservation, EmbeddingProvider } from "../src/types.js";
-
-function makeObs(
-  overrides: Partial<CompressedObservation> = {},
-): CompressedObservation {
-  return {
-    id: "obs_1",
-    sessionId: "ses_1",
-    timestamp: new Date().toISOString(),
-    type: "file_edit",
-    title: "Edit auth middleware",
-    subtitle: "JWT validation",
-    facts: ["Added token check"],
-    narrative: "Modified the auth middleware to validate JWT tokens",
-    concepts: ["authentication", "jwt"],
-    files: ["src/middleware/auth.ts"],
-    importance: 7,
-    ...overrides,
-  };
-}
-
-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[]) : [];
-    },
-  };
-}
-
-describe("HybridSearch", () => {
-  let bm25: SearchIndex;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    bm25 = new SearchIndex();
-    kv = mockKV();
-  });
-
-  it("returns BM25-only results when no vector index is provided", async () => {
-    const obs = makeObs({ id: "obs_1", sessionId: "ses_1" });
-    bm25.add(obs);
-    await kv.set("mem:obs:ses_1", "obs_1", obs);
-
-    const hybrid = new HybridSearch(bm25, null, null, kv as never);
-    const results = await hybrid.search("auth");
-
-    expect(results.length).toBe(1);
-    expect(results[0].observation.id).toBe("obs_1");
-    expect(results[0].vectorScore).toBe(0);
-    expect(results[0].bm25Score).toBeGreaterThan(0);
-  });
-
-  it("returns empty results for no-match query", async () => {
-    const obs = makeObs({ id: "obs_1", sessionId: "ses_1" });
-    bm25.add(obs);
-    await kv.set("mem:obs:ses_1", "obs_1", obs);
-
-    const hybrid = new HybridSearch(bm25, null, null, kv as never);
-    const results = await hybrid.search("database");
-    expect(results).toEqual([]);
-  });
-
-  it("combinedScore is derived from bm25Score when no vector index", async () => {
-    const obs = makeObs({ id: "obs_1", sessionId: "ses_1" });
-    bm25.add(obs);
-    await kv.set("mem:obs:ses_1", "obs_1", obs);
-
-    const hybrid = new HybridSearch(bm25, null, null, kv as never);
-    const results = await hybrid.search("auth");
-
-    expect(results[0].combinedScore).toBeGreaterThan(0);
-    expect(results[0].vectorScore).toBe(0);
-    expect(results[0].graphScore).toBe(0);
-  });
-
-  it("results are sorted by combinedScore descending", async () => {
-    const obs1 = makeObs({
-      id: "obs_1",
-      sessionId: "ses_1",
-      title: "auth handler",
-      narrative: "auth auth auth module",
-      concepts: ["auth"],
-    });
-    const obs2 = makeObs({
-      id: "obs_2",
-      sessionId: "ses_1",
-      title: "database setup",
-      narrative: "auth connection config",
-      concepts: ["database"],
-    });
-    bm25.add(obs1);
-    bm25.add(obs2);
-    await kv.set("mem:obs:ses_1", "obs_1", obs1);
-    await kv.set("mem:obs:ses_1", "obs_2", obs2);
-
-    const hybrid = new HybridSearch(bm25, null, null, kv as never);
-    const results = await hybrid.search("auth");
-
-    expect(results.length).toBe(2);
-    expect(results[0].combinedScore).toBeGreaterThanOrEqual(
-      results[1].combinedScore,
-    );
-  });
-
-  it("respects limit parameter", async () => {
-    for (let i = 0; i < 10; i++) {
-      const obs = makeObs({
-        id: `obs_${i}`,
-        sessionId: "ses_1",
-        title: `auth feature ${i}`,
-      });
-      bm25.add(obs);
-      await kv.set("mem:obs:ses_1", `obs_${i}`, obs);
-    }
-
-    const hybrid = new HybridSearch(bm25, null, null, kv as never);
-    const results = await hybrid.search("auth", 3);
-    expect(results.length).toBe(3);
-  });
-
-  it("skips observations not found in KV", async () => {
-    const obs = makeObs({ id: "obs_missing", sessionId: "ses_1" });
-    bm25.add(obs);
-
-    const hybrid = new HybridSearch(bm25, null, null, kv as never);
-    const results = await hybrid.search("auth");
-    expect(results).toEqual([]);
-  });
-});