@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/audit.test.ts

@@ -1,108 +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 { recordAudit, queryAudit } from "../src/functions/audit.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[]) : [];
-    },
-  };
-}
-
-describe("Audit Functions", () => {
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    kv = mockKV();
-  });
-
-  it("recordAudit creates an entry with proper fields", async () => {
-    const entry = await recordAudit(
-      kv as never,
-      "observe",
-      "mem::compress",
-      ["obs_1", "obs_2"],
-      { count: 2 },
-      0.85,
-      "user-1",
-    );
-
-    expect(entry.id).toMatch(/^aud_/);
-    expect(entry.timestamp).toBeDefined();
-    expect(entry.operation).toBe("observe");
-    expect(entry.functionId).toBe("mem::compress");
-    expect(entry.targetIds).toEqual(["obs_1", "obs_2"]);
-    expect(entry.details).toEqual({ count: 2 });
-    expect(entry.qualityScore).toBe(0.85);
-    expect(entry.userId).toBe("user-1");
-  });
-
-  it("queryAudit returns entries sorted by timestamp desc", async () => {
-    await recordAudit(kv as never, "observe", "fn1", ["a"], {});
-    await new Promise((r) => setTimeout(r, 10));
-    await recordAudit(kv as never, "delete", "fn2", ["b"], {});
-
-    const entries = await queryAudit(kv as never);
-    expect(entries.length).toBe(2);
-    expect(
-      new Date(entries[0].timestamp).getTime(),
-    ).toBeGreaterThanOrEqual(new Date(entries[1].timestamp).getTime());
-  });
-
-  it("queryAudit filters by operation", async () => {
-    await recordAudit(kv as never, "observe", "fn1", [], {});
-    await recordAudit(kv as never, "delete", "fn2", [], {});
-    await recordAudit(kv as never, "observe", "fn3", [], {});
-
-    const entries = await queryAudit(kv as never, { operation: "observe" });
-    expect(entries.length).toBe(2);
-    expect(entries.every((e) => e.operation === "observe")).toBe(true);
-  });
-
-  it("queryAudit filters by dateFrom/dateTo", async () => {
-    const early = await recordAudit(kv as never, "observe", "fn1", [], {});
-    await new Promise((r) => setTimeout(r, 20));
-    const late = await recordAudit(kv as never, "delete", "fn2", [], {});
-
-    const entries = await queryAudit(kv as never, {
-      dateFrom: late.timestamp,
-    });
-    expect(entries.length).toBe(1);
-    expect(entries[0].operation).toBe("delete");
-
-    const entriesBefore = await queryAudit(kv as never, {
-      dateTo: early.timestamp,
-    });
-    expect(entriesBefore.length).toBe(1);
-    expect(entriesBefore[0].operation).toBe("observe");
-  });
-
-  it("queryAudit respects limit", async () => {
-    for (let i = 0; i < 10; i++) {
-      await recordAudit(kv as never, "observe", `fn${i}`, [], {});
-    }
-
-    const entries = await queryAudit(kv as never, { limit: 3 });
-    expect(entries.length).toBe(3);
-  });
-});

package/test/auto-forget.test.ts

@@ -1,188 +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 { registerAutoForgetFunction } from "../src/functions/auto-forget.js";
-import type { Memory, CompressedObservation, Session } 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(overrides: Partial<Memory> = {}): Memory {
-  return {
-    id: "mem_1",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    type: "pattern",
-    title: "Test memory",
-    content: "This is a test memory with enough words for comparison",
-    concepts: ["test"],
-    files: [],
-    sessionIds: ["ses_1"],
-    strength: 5,
-    version: 1,
-    isLatest: true,
-    ...overrides,
-  };
-}
-
-describe("Auto-Forget Function", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerAutoForgetFunction(sdk as never, kv as never);
-  });
-
-  it("detects and deletes TTL-expired memories", async () => {
-    const expired = makeMemory({
-      id: "mem_expired",
-      forgetAfter: "2020-01-01T00:00:00Z",
-    });
-    await kv.set("mem:memories", "mem_expired", expired);
-
-    const result = (await sdk.trigger("mem::auto-forget", {})) as {
-      ttlExpired: string[];
-    };
-
-    expect(result.ttlExpired).toContain("mem_expired");
-    const deleted = await kv.get("mem:memories", "mem_expired");
-    expect(deleted).toBeNull();
-  });
-
-  it("detects contradiction between very similar memories", async () => {
-    const mem1 = makeMemory({
-      id: "mem_1",
-      content: "Use React hooks for state management in all components",
-      createdAt: "2026-01-01T00:00:00Z",
-    });
-    const mem2 = makeMemory({
-      id: "mem_2",
-      content: "Use React hooks for state management in all components",
-      createdAt: "2026-02-01T00:00:00Z",
-    });
-    await kv.set("mem:memories", "mem_1", mem1);
-    await kv.set("mem:memories", "mem_2", mem2);
-
-    const result = (await sdk.trigger("mem::auto-forget", {})) as {
-      contradictions: Array<{
-        memoryA: string;
-        memoryB: string;
-        similarity: number;
-      }>;
-    };
-
-    expect(result.contradictions.length).toBe(1);
-    const older = await kv.get<Memory>("mem:memories", "mem_1");
-    expect(older!.isLatest).toBe(false);
-  });
-
-  it("evicts low-value old observations", async () => {
-    const session: Session = {
-      id: "ses_1",
-      project: "my-project",
-      cwd: "/tmp",
-      startedAt: "2025-01-01T00:00:00Z",
-      status: "completed",
-      observationCount: 1,
-    };
-    await kv.set("mem:sessions", "ses_1", session);
-
-    const oldLowObs: CompressedObservation = {
-      id: "obs_old",
-      sessionId: "ses_1",
-      timestamp: "2025-01-01T00:00:00Z",
-      type: "other",
-      title: "trivial event",
-      facts: [],
-      narrative: "nothing important",
-      concepts: [],
-      files: [],
-      importance: 1,
-    };
-    await kv.set("mem:obs:ses_1", "obs_old", oldLowObs);
-
-    const result = (await sdk.trigger("mem::auto-forget", {})) as {
-      lowValueObs: string[];
-    };
-
-    expect(result.lowValueObs).toContain("obs_old");
-  });
-
-  it("dryRun mode identifies but does not delete anything", async () => {
-    const expired = makeMemory({
-      id: "mem_expired",
-      forgetAfter: "2020-01-01T00:00:00Z",
-    });
-    await kv.set("mem:memories", "mem_expired", expired);
-
-    const result = (await sdk.trigger("mem::auto-forget", { dryRun: true })) as {
-      ttlExpired: string[];
-      dryRun: boolean;
-    };
-
-    expect(result.dryRun).toBe(true);
-    expect(result.ttlExpired).toContain("mem_expired");
-
-    const stillExists = await kv.get("mem:memories", "mem_expired");
-    expect(stillExists).not.toBeNull();
-  });
-
-  it("does not flag non-similar memories as contradictions", async () => {
-    const mem1 = makeMemory({
-      id: "mem_1",
-      content: "We use TypeScript with strict mode enabled for all backend services",
-    });
-    const mem2 = makeMemory({
-      id: "mem_2",
-      content: "The deployment pipeline runs integration tests before merging to main",
-    });
-    await kv.set("mem:memories", "mem_1", mem1);
-    await kv.set("mem:memories", "mem_2", mem2);
-
-    const result = (await sdk.trigger("mem::auto-forget", {})) as {
-      contradictions: unknown[];
-    };
-
-    expect(result.contradictions.length).toBe(0);
-  });
-});

package/test/cascade.test.ts

@@ -1,277 +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 { registerCascadeFunction } from "../src/functions/cascade.js";
-import type { Memory, GraphNode, GraphEdge } from "../src/types.js";
-import { mockKV, mockSdk } from "./helpers/mocks.js";
-
-describe("Cascade Update Function", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    sdk = mockSdk();
-    kv = mockKV();
-    vi.clearAllMocks();
-    registerCascadeFunction(sdk as never, kv as never);
-  });
-
-  it("returns error when supersededMemoryId is missing", async () => {
-    const result = (await sdk.trigger("mem::cascade-update", {})) as {
-      success: boolean;
-      error: string;
-    };
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("supersededMemoryId is required");
-  });
-
-  it("returns error for non-existent memory", async () => {
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_missing",
-    })) as { success: boolean; error: string };
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("superseded memory not found");
-  });
-
-  it("flags graph nodes referencing superseded observation IDs", async () => {
-    const memory: Memory = {
-      id: "mem_old",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "fact",
-      title: "Old fact",
-      content: "Old content",
-      concepts: ["react"],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: false,
-      sourceObservationIds: ["obs_a", "obs_b"],
-    };
-    await kv.set("mem:memories", "mem_old", memory);
-
-    const node: GraphNode = {
-      id: "node_1",
-      type: "concept",
-      name: "react",
-      properties: {},
-      sourceObservationIds: ["obs_a"],
-      createdAt: "2026-03-01T00:00:00Z",
-    };
-    await kv.set("mem:graph:nodes", "node_1", node);
-
-    const unrelatedNode: GraphNode = {
-      id: "node_2",
-      type: "file",
-      name: "index.ts",
-      properties: {},
-      sourceObservationIds: ["obs_c"],
-      createdAt: "2026-03-01T00:00:00Z",
-    };
-    await kv.set("mem:graph:nodes", "node_2", unrelatedNode);
-
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_old",
-    })) as { success: boolean; flagged: { nodes: number; edges: number } };
-
-    expect(result.success).toBe(true);
-    expect(result.flagged.nodes).toBe(1);
-
-    const updated = await kv.get<GraphNode>("mem:graph:nodes", "node_1");
-    expect(updated!.stale).toBe(true);
-
-    const unchanged = await kv.get<GraphNode>("mem:graph:nodes", "node_2");
-    expect(unchanged!.stale).toBeUndefined();
-  });
-
-  it("flags graph edges referencing superseded observation IDs", async () => {
-    const memory: Memory = {
-      id: "mem_old2",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "pattern",
-      title: "Old pattern",
-      content: "Old pattern content",
-      concepts: ["testing"],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: false,
-      sourceObservationIds: ["obs_x"],
-    };
-    await kv.set("mem:memories", "mem_old2", memory);
-
-    const edge: GraphEdge = {
-      id: "edge_1",
-      type: "uses",
-      sourceNodeId: "node_a",
-      targetNodeId: "node_b",
-      weight: 1,
-      sourceObservationIds: ["obs_x", "obs_y"],
-      createdAt: "2026-03-01T00:00:00Z",
-    };
-    await kv.set("mem:graph:edges", "edge_1", edge);
-
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_old2",
-    })) as { success: boolean; flagged: { edges: number } };
-
-    expect(result.success).toBe(true);
-    expect(result.flagged.edges).toBe(1);
-
-    const updated = await kv.get<GraphEdge>("mem:graph:edges", "edge_1");
-    expect(updated!.stale).toBe(true);
-  });
-
-  it("counts sibling memories sharing 2+ concepts", async () => {
-    const superseded: Memory = {
-      id: "mem_superseded",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "architecture",
-      title: "React architecture",
-      content: "Old arch",
-      concepts: ["react", "frontend", "typescript"],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: false,
-    };
-    await kv.set("mem:memories", "mem_superseded", superseded);
-
-    const sibling: Memory = {
-      id: "mem_sibling",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "pattern",
-      title: "React patterns",
-      content: "Sibling memory sharing concepts",
-      concepts: ["react", "typescript"],
-      files: [],
-      sessionIds: [],
-      strength: 6,
-      version: 1,
-      isLatest: true,
-    };
-    await kv.set("mem:memories", "mem_sibling", sibling);
-
-    const unrelated: Memory = {
-      id: "mem_unrelated",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "fact",
-      title: "Python setup",
-      content: "Unrelated memory",
-      concepts: ["python", "backend"],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: true,
-    };
-    await kv.set("mem:memories", "mem_unrelated", unrelated);
-
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_superseded",
-    })) as { success: boolean; flagged: { siblingMemories: number }; total: number };
-
-    expect(result.success).toBe(true);
-    expect(result.flagged.siblingMemories).toBe(1);
-    expect(result.total).toBeGreaterThanOrEqual(1);
-  });
-
-  it("skips already stale nodes", async () => {
-    const memory: Memory = {
-      id: "mem_skip",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "fact",
-      title: "Skip test",
-      content: "Content",
-      concepts: [],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: false,
-      sourceObservationIds: ["obs_s"],
-    };
-    await kv.set("mem:memories", "mem_skip", memory);
-
-    const node: GraphNode = {
-      id: "node_stale",
-      type: "concept",
-      name: "already stale",
-      properties: {},
-      sourceObservationIds: ["obs_s"],
-      createdAt: "2026-03-01T00:00:00Z",
-      stale: true,
-    };
-    await kv.set("mem:graph:nodes", "node_stale", node);
-
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_skip",
-    })) as { success: boolean; flagged: { nodes: number } };
-
-    expect(result.success).toBe(true);
-    expect(result.flagged.nodes).toBe(0);
-  });
-
-  it("does not flag siblings when fewer than 2 shared concepts", async () => {
-    const memory: Memory = {
-      id: "mem_one_concept",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "fact",
-      title: "One concept",
-      content: "Content",
-      concepts: ["react"],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: false,
-    };
-    await kv.set("mem:memories", "mem_one_concept", memory);
-
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_one_concept",
-    })) as { success: boolean; flagged: { siblingMemories: number } };
-
-    expect(result.success).toBe(true);
-    expect(result.flagged.siblingMemories).toBe(0);
-  });
-
-  it("returns zero counts when no sourceObservationIds and < 2 concepts", async () => {
-    const memory: Memory = {
-      id: "mem_empty",
-      createdAt: "2026-03-01T00:00:00Z",
-      updatedAt: "2026-03-01T00:00:00Z",
-      type: "fact",
-      title: "Empty refs",
-      content: "No references",
-      concepts: [],
-      files: [],
-      sessionIds: [],
-      strength: 5,
-      version: 1,
-      isLatest: false,
-    };
-    await kv.set("mem:memories", "mem_empty", memory);
-
-    const result = (await sdk.trigger("mem::cascade-update", {
-      supersededMemoryId: "mem_empty",
-    })) as { success: boolean; total: number };
-
-    expect(result.success).toBe(true);
-    expect(result.total).toBe(0);
-  });
-});