@agentmemory/agentmemory 0.7.0

package/test/audit.test.ts

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,277 @@
+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);
+  });
+});