@agentmemory/agentmemory 0.7.2 → 0.7.3

package/test/fallback-chain.test.ts

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

@@ -1,485 +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 { 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");
-    });
-  });
-});