@agentmemory/agentmemory 0.7.0

package/test/fallback-chain.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import { FallbackChainProvider } from "../src/providers/fallback-chain.js";
+import type { MemoryProvider } from "../src/types.js";
+
+function makeProvider(
+  name: string,
+  impl?: Partial<MemoryProvider>,
+): MemoryProvider {
+  return {
+    name,
+    compress: impl?.compress ?? (async () => `compressed by ${name}`),
+    summarize: impl?.summarize ?? (async () => `summarized by ${name}`),
+  };
+}
+
+describe("FallbackChainProvider", () => {
+  it("returns result from first provider when it succeeds", async () => {
+    const chain = new FallbackChainProvider([
+      makeProvider("primary"),
+      makeProvider("secondary"),
+    ]);
+    const result = await chain.compress("sys", "user");
+    expect(result).toBe("compressed by primary");
+  });
+
+  it("falls back to second provider when first fails", async () => {
+    const failing: MemoryProvider = {
+      name: "failing",
+      compress: async () => {
+        throw new Error("primary down");
+      },
+      summarize: async () => {
+        throw new Error("primary down");
+      },
+    };
+    const chain = new FallbackChainProvider([
+      failing,
+      makeProvider("backup"),
+    ]);
+    const result = await chain.compress("sys", "user");
+    expect(result).toBe("compressed by backup");
+  });
+
+  it("throws the last error when all providers fail", async () => {
+    const failing1: MemoryProvider = {
+      name: "fail1",
+      compress: async () => {
+        throw new Error("fail1 error");
+      },
+      summarize: async () => {
+        throw new Error("fail1 error");
+      },
+    };
+    const failing2: MemoryProvider = {
+      name: "fail2",
+      compress: async () => {
+        throw new Error("fail2 error");
+      },
+      summarize: async () => {
+        throw new Error("fail2 error");
+      },
+    };
+    const chain = new FallbackChainProvider([failing1, failing2]);
+    await expect(chain.compress("sys", "user")).rejects.toThrow("fail2 error");
+  });
+
+  it("formats the name correctly", () => {
+    const chain = new FallbackChainProvider([
+      makeProvider("anthropic"),
+      makeProvider("gemini"),
+      makeProvider("openrouter"),
+    ]);
+    expect(chain.name).toBe("fallback(anthropic -> gemini -> openrouter)");
+  });
+
+  it("summarize also uses fallback chain", async () => {
+    const failing: MemoryProvider = {
+      name: "failing",
+      compress: async () => {
+        throw new Error("down");
+      },
+      summarize: async () => {
+        throw new Error("down");
+      },
+    };
+    const chain = new FallbackChainProvider([
+      failing,
+      makeProvider("backup"),
+    ]);
+    const result = await chain.summarize("sys", "user");
+    expect(result).toBe("summarized by backup");
+  });
+});

package/test/frontier.test.ts

@@ -0,0 +1,485 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerFrontierFunction } from "../src/functions/frontier.js";
+import { registerActionsFunction } from "../src/functions/actions.js";
+import type { Action, ActionEdge, Checkpoint, Lease } from "../src/types.js";
+import type { FrontierItem } from "../src/functions/frontier.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 makeAction(overrides: Partial<Action>): Action {
+  const now = new Date().toISOString();
+  return {
+    id: overrides.id || `act_${Math.random().toString(36).slice(2, 10)}`,
+    title: overrides.title || "Test action",
+    description: overrides.description || "",
+    status: overrides.status || "pending",
+    priority: overrides.priority || 5,
+    createdAt: overrides.createdAt || now,
+    updatedAt: overrides.updatedAt || now,
+    createdBy: overrides.createdBy || "agent-1",
+    assignedTo: overrides.assignedTo,
+    project: overrides.project,
+    tags: overrides.tags || [],
+    sourceObservationIds: overrides.sourceObservationIds || [],
+    sourceMemoryIds: overrides.sourceMemoryIds || [],
+    result: overrides.result,
+    parentId: overrides.parentId,
+    metadata: overrides.metadata,
+  };
+}
+
+describe("Frontier Functions", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(() => {
+    sdk = mockSdk();
+    kv = mockKV();
+    registerActionsFunction(sdk as never, kv as never);
+    registerFrontierFunction(sdk as never, kv as never);
+  });
+
+  describe("mem::frontier", () => {
+    it("returns empty frontier when no actions exist", async () => {
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+        totalActions: number;
+        totalUnblocked: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.frontier).toEqual([]);
+      expect(result.totalActions).toBe(0);
+      expect(result.totalUnblocked).toBe(0);
+    });
+
+    it("returns pending actions sorted by score", async () => {
+      const lowPriority = makeAction({
+        id: "act_low",
+        title: "Low priority",
+        priority: 2,
+      });
+      const highPriority = makeAction({
+        id: "act_high",
+        title: "High priority",
+        priority: 9,
+      });
+
+      await kv.set("mem:actions", lowPriority.id, lowPriority);
+      await kv.set("mem:actions", highPriority.id, highPriority);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.frontier.length).toBe(2);
+      expect(result.frontier[0].action.id).toBe("act_high");
+      expect(result.frontier[1].action.id).toBe("act_low");
+      expect(result.frontier[0].score).toBeGreaterThan(
+        result.frontier[1].score,
+      );
+    });
+
+    it("excludes done and cancelled actions", async () => {
+      const pending = makeAction({
+        id: "act_pending",
+        title: "Pending",
+        status: "pending",
+      });
+      const done = makeAction({
+        id: "act_done",
+        title: "Done",
+        status: "done",
+      });
+      const cancelled = makeAction({
+        id: "act_cancelled",
+        title: "Cancelled",
+        status: "cancelled",
+      });
+
+      await kv.set("mem:actions", pending.id, pending);
+      await kv.set("mem:actions", done.id, done);
+      await kv.set("mem:actions", cancelled.id, cancelled);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+        totalActions: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.frontier.length).toBe(1);
+      expect(result.frontier[0].action.id).toBe("act_pending");
+      expect(result.totalActions).toBe(3);
+    });
+
+    it("excludes blocked actions with unsatisfied requires edge", async () => {
+      const dependency = makeAction({
+        id: "act_dep",
+        title: "Dependency",
+        status: "pending",
+      });
+      const blocked = makeAction({
+        id: "act_blocked",
+        title: "Blocked",
+        status: "blocked",
+      });
+
+      await kv.set("mem:actions", dependency.id, dependency);
+      await kv.set("mem:actions", blocked.id, blocked);
+
+      const edge: ActionEdge = {
+        id: "ae_1",
+        type: "requires",
+        sourceActionId: blocked.id,
+        targetActionId: dependency.id,
+        createdAt: new Date().toISOString(),
+      };
+      await kv.set("mem:action-edges", edge.id, edge);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+      };
+
+      expect(result.success).toBe(true);
+      const ids = result.frontier.map((f) => f.action.id);
+      expect(ids).toContain("act_dep");
+      expect(ids).not.toContain("act_blocked");
+    });
+
+    it("respects project filter", async () => {
+      const alphaAction = makeAction({
+        id: "act_alpha",
+        title: "Alpha task",
+        project: "alpha",
+      });
+      const betaAction = makeAction({
+        id: "act_beta",
+        title: "Beta task",
+        project: "beta",
+      });
+
+      await kv.set("mem:actions", alphaAction.id, alphaAction);
+      await kv.set("mem:actions", betaAction.id, betaAction);
+
+      const result = (await sdk.trigger("mem::frontier", {
+        project: "alpha",
+      })) as { success: boolean; frontier: FrontierItem[] };
+
+      expect(result.success).toBe(true);
+      expect(result.frontier.length).toBe(1);
+      expect(result.frontier[0].action.project).toBe("alpha");
+    });
+
+    it("higher priority scores higher", async () => {
+      const low = makeAction({
+        id: "act_low",
+        title: "Low",
+        priority: 1,
+        createdAt: new Date().toISOString(),
+      });
+      const high = makeAction({
+        id: "act_high",
+        title: "High",
+        priority: 10,
+        createdAt: new Date().toISOString(),
+      });
+
+      await kv.set("mem:actions", low.id, low);
+      await kv.set("mem:actions", high.id, high);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+      };
+
+      expect(result.frontier[0].action.id).toBe("act_high");
+      expect(result.frontier[0].score).toBeGreaterThan(
+        result.frontier[1].score,
+      );
+    });
+
+    it("excludes actions gated by pending checkpoint", async () => {
+      const gatedAction = makeAction({
+        id: "act_gated",
+        title: "Gated action",
+        status: "pending",
+      });
+
+      const checkpoint: Checkpoint = {
+        id: "ckpt_1",
+        name: "CI check",
+        description: "Waiting for CI",
+        status: "pending",
+        type: "ci",
+        createdAt: new Date().toISOString(),
+        linkedActionIds: ["act_gated"],
+      };
+
+      await kv.set("mem:actions", gatedAction.id, gatedAction);
+      await kv.set("mem:checkpoints", checkpoint.id, checkpoint);
+
+      const gateEdge: ActionEdge = {
+        id: "ae_gate",
+        type: "gated_by",
+        sourceActionId: gatedAction.id,
+        targetActionId: checkpoint.id,
+        createdAt: new Date().toISOString(),
+      };
+      await kv.set("mem:action-edges", gateEdge.id, gateEdge);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+      };
+
+      expect(result.frontier.length).toBe(0);
+    });
+
+    it("excludes actions conflicting with active actions", async () => {
+      const activeAction = makeAction({
+        id: "act_active",
+        title: "Active task",
+        status: "active",
+      });
+      const conflictAction = makeAction({
+        id: "act_conflict",
+        title: "Conflicting task",
+        status: "pending",
+      });
+
+      await kv.set("mem:actions", activeAction.id, activeAction);
+      await kv.set("mem:actions", conflictAction.id, conflictAction);
+
+      const conflictEdge: ActionEdge = {
+        id: "ae_conflict",
+        type: "conflicts_with",
+        sourceActionId: conflictAction.id,
+        targetActionId: activeAction.id,
+        createdAt: new Date().toISOString(),
+      };
+      await kv.set("mem:action-edges", conflictEdge.id, conflictEdge);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+      };
+
+      const ids = result.frontier.map((f) => f.action.id);
+      expect(ids).toContain("act_active");
+      expect(ids).not.toContain("act_conflict");
+    });
+
+    it("active actions get score bonus", async () => {
+      const pendingAction = makeAction({
+        id: "act_pending",
+        title: "Pending",
+        status: "pending",
+        priority: 5,
+        createdAt: new Date().toISOString(),
+      });
+      const activeAction = makeAction({
+        id: "act_active",
+        title: "Active",
+        status: "active",
+        priority: 5,
+        createdAt: new Date().toISOString(),
+      });
+
+      await kv.set("mem:actions", pendingAction.id, pendingAction);
+      await kv.set("mem:actions", activeAction.id, activeAction);
+
+      const result = (await sdk.trigger("mem::frontier", {})) as {
+        success: boolean;
+        frontier: FrontierItem[];
+      };
+
+      const activeItem = result.frontier.find(
+        (f) => f.action.id === "act_active",
+      )!;
+      const pendingItem = result.frontier.find(
+        (f) => f.action.id === "act_pending",
+      )!;
+
+      expect(activeItem.score).toBeGreaterThan(pendingItem.score);
+    });
+  });
+
+  describe("mem::next", () => {
+    it("returns top suggestion when actions exist", async () => {
+      const action = makeAction({
+        id: "act_1",
+        title: "Top task",
+        priority: 8,
+        tags: ["urgent"],
+      });
+      await kv.set("mem:actions", action.id, action);
+
+      const result = (await sdk.trigger("mem::next", {})) as {
+        success: boolean;
+        suggestion: {
+          actionId: string;
+          title: string;
+          description: string;
+          priority: number;
+          score: number;
+          tags: string[];
+        } | null;
+        message: string;
+        totalActions: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.suggestion).not.toBeNull();
+      expect(result.suggestion!.actionId).toBe("act_1");
+      expect(result.suggestion!.title).toBe("Top task");
+      expect(result.suggestion!.priority).toBe(8);
+      expect(result.suggestion!.tags).toEqual(["urgent"]);
+      expect(result.message).toContain("Top task");
+      expect(result.totalActions).toBe(1);
+    });
+
+    it("returns null suggestion when no actions exist", async () => {
+      const result = (await sdk.trigger("mem::next", {})) as {
+        success: boolean;
+        suggestion: null;
+        message: string;
+        totalActions: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.suggestion).toBeNull();
+      expect(result.message).toContain("No actionable work");
+      expect(result.totalActions).toBe(0);
+    });
+
+    it("returns null when all actions are done", async () => {
+      const doneAction = makeAction({
+        id: "act_done",
+        title: "Completed",
+        status: "done",
+      });
+      await kv.set("mem:actions", doneAction.id, doneAction);
+
+      const result = (await sdk.trigger("mem::next", {})) as {
+        success: boolean;
+        suggestion: null;
+        message: string;
+        totalActions: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.suggestion).toBeNull();
+      expect(result.totalActions).toBe(1);
+    });
+
+    it("propagates failure when frontier fails", async () => {
+      const originalFunctions = new Map<string, Function>();
+
+      const failSdk = {
+        registerFunction: (opts: { id: string }, handler: Function) => {
+          originalFunctions.set(opts.id, handler);
+        },
+        registerTrigger: () => {},
+        trigger: async (id: string, data: unknown) => {
+          if (id === "mem::frontier") {
+            return { success: false, error: "internal failure" };
+          }
+          const fn = originalFunctions.get(id);
+          if (!fn) throw new Error(`No function: ${id}`);
+          return fn(data);
+        },
+      };
+
+      const failKv = mockKV();
+      registerFrontierFunction(failSdk as never, failKv as never);
+
+      const nextFn = originalFunctions.get("mem::next")!;
+      const result = (await nextFn({})) as {
+        success: boolean;
+        suggestion: null;
+        message: string;
+        totalActions: number;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.suggestion).toBeNull();
+      expect(result.message).toContain("Failed to compute frontier");
+      expect(result.totalActions).toBe(0);
+    });
+
+    it("respects project filter", async () => {
+      const alphaAction = makeAction({
+        id: "act_alpha",
+        title: "Alpha task",
+        project: "alpha",
+        priority: 5,
+      });
+      const betaAction = makeAction({
+        id: "act_beta",
+        title: "Beta task",
+        project: "beta",
+        priority: 10,
+      });
+
+      await kv.set("mem:actions", alphaAction.id, alphaAction);
+      await kv.set("mem:actions", betaAction.id, betaAction);
+
+      const result = (await sdk.trigger("mem::next", {
+        project: "alpha",
+      })) as {
+        success: boolean;
+        suggestion: { actionId: string; title: string } | null;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.suggestion).not.toBeNull();
+      expect(result.suggestion!.actionId).toBe("act_alpha");
+    });
+  });
+});