@agentmemory/agentmemory 0.7.0

package/test/leases.test.ts

@@ -0,0 +1,399 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerLeasesFunction } from "../src/functions/leases.js";
+import type { Action, Lease } 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 makeAction(
+  id: string,
+  status: Action["status"] = "pending",
+): Action {
+  return {
+    id,
+    title: `Action ${id}`,
+    description: `Description for ${id}`,
+    status,
+    priority: 5,
+    createdAt: "2026-02-01T00:00:00Z",
+    updatedAt: "2026-02-01T00:00:00Z",
+    createdBy: "agent-setup",
+    tags: [],
+    sourceObservationIds: [],
+    sourceMemoryIds: [],
+  };
+}
+
+describe("Lease Functions", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(async () => {
+    sdk = mockSdk();
+    kv = mockKV();
+    registerLeasesFunction(sdk as never, kv as never);
+
+    await kv.set("mem:actions", "act_1", makeAction("act_1", "pending"));
+    await kv.set("mem:actions", "act_2", makeAction("act_2", "done"));
+    await kv.set("mem:actions", "act_3", makeAction("act_3", "cancelled"));
+    await kv.set("mem:actions", "act_4", makeAction("act_4", "pending"));
+  });
+
+  describe("mem::lease-acquire", () => {
+    it("acquires a lease for a valid action", async () => {
+      const result = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease; renewed: boolean };
+
+      expect(result.success).toBe(true);
+      expect(result.lease.actionId).toBe("act_1");
+      expect(result.lease.agentId).toBe("agent-a");
+      expect(result.lease.status).toBe("active");
+      expect(result.renewed).toBe(false);
+      expect(result.lease.id).toMatch(/^lse_/);
+    });
+
+    it("returns error when actionId or agentId is missing", async () => {
+      const r1 = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "",
+      })) as { success: boolean; error: string };
+      expect(r1.success).toBe(false);
+      expect(r1.error).toBe("actionId and agentId are required");
+
+      const r2 = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+      expect(r2.success).toBe(false);
+      expect(r2.error).toBe("actionId and agentId are required");
+    });
+
+    it("returns error for nonexistent action", async () => {
+      const result = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_nonexistent",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("action not found");
+    });
+
+    it("returns error for done action", async () => {
+      const result = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_2",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("action already completed");
+    });
+
+    it("returns error for cancelled action", async () => {
+      const result = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_3",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("action already completed");
+    });
+
+    it("returns existing lease when same agent already holds it", async () => {
+      const first = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      const second = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease; renewed: boolean; message: string };
+
+      expect(second.success).toBe(true);
+      expect(second.lease.id).toBe(first.lease.id);
+      expect(second.renewed).toBe(false);
+      expect(second.message).toBe("Already holding this lease");
+    });
+
+    it("returns conflict error when different agent holds the lease", async () => {
+      await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      const result = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-b",
+      })) as { success: boolean; error: string; heldBy: string; expiresAt: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("action already leased");
+      expect(result.heldBy).toBe("agent-a");
+      expect(result.expiresAt).toBeDefined();
+    });
+
+    it("sets action status to active after acquire", async () => {
+      await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      const action = await kv.get<Action>("mem:actions", "act_1");
+      expect(action!.status).toBe("active");
+      expect(action!.assignedTo).toBe("agent-a");
+    });
+  });
+
+  describe("mem::lease-release", () => {
+    it("releases an active lease", async () => {
+      await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      const result = (await sdk.trigger("mem::lease-release", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; released: boolean };
+
+      expect(result.success).toBe(true);
+      expect(result.released).toBe(true);
+    });
+
+    it("sets action to done when result is provided", async () => {
+      await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      await sdk.trigger("mem::lease-release", {
+        actionId: "act_1",
+        agentId: "agent-a",
+        result: "completed successfully",
+      });
+
+      const action = await kv.get<Action>("mem:actions", "act_1");
+      expect(action!.status).toBe("done");
+      expect(action!.result).toBe("completed successfully");
+      expect(action!.assignedTo).toBeUndefined();
+    });
+
+    it("sets action to pending when no result is provided", async () => {
+      await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      await sdk.trigger("mem::lease-release", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      const action = await kv.get<Action>("mem:actions", "act_1");
+      expect(action!.status).toBe("pending");
+      expect(action!.assignedTo).toBeUndefined();
+    });
+
+    it("returns error when no active lease exists for agent", async () => {
+      const result = (await sdk.trigger("mem::lease-release", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("no active lease found for this agent");
+    });
+
+    it("returns error when actionId or agentId is missing", async () => {
+      const result = (await sdk.trigger("mem::lease-release", {
+        actionId: "",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("actionId and agentId are required");
+    });
+  });
+
+  describe("mem::lease-renew", () => {
+    it("renews an active non-expired lease", async () => {
+      const acquired = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      const originalExpiry = acquired.lease.expiresAt;
+
+      const result = (await sdk.trigger("mem::lease-renew", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      expect(result.success).toBe(true);
+      expect(result.lease.renewedAt).toBeDefined();
+      expect(
+        new Date(result.lease.expiresAt).getTime(),
+      ).toBeGreaterThanOrEqual(new Date(originalExpiry).getTime());
+    });
+
+    it("returns error when lease is expired", async () => {
+      const acquired = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      acquired.lease.expiresAt = new Date(Date.now() - 60000).toISOString();
+      await kv.set("mem:leases", acquired.lease.id, acquired.lease);
+
+      const result = (await sdk.trigger("mem::lease-renew", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("no active (non-expired) lease to renew");
+    });
+
+    it("returns error when actionId or agentId is missing", async () => {
+      const result = (await sdk.trigger("mem::lease-renew", {
+        actionId: "",
+        agentId: "agent-a",
+      })) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("actionId and agentId are required");
+    });
+  });
+
+  describe("mem::lease-cleanup", () => {
+    it("expires active leases past their expiresAt and resets actions to pending", async () => {
+      const acquired = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      acquired.lease.expiresAt = new Date(Date.now() - 60000).toISOString();
+      await kv.set("mem:leases", acquired.lease.id, acquired.lease);
+
+      const result = (await sdk.trigger("mem::lease-cleanup", {})) as {
+        success: boolean;
+        expired: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.expired).toBe(1);
+
+      const lease = await kv.get<Lease>("mem:leases", acquired.lease.id);
+      expect(lease!.status).toBe("expired");
+
+      const action = await kv.get<Action>("mem:actions", "act_1");
+      expect(action!.status).toBe("pending");
+      expect(action!.assignedTo).toBeUndefined();
+    });
+
+    it("does not expire non-expired active leases", async () => {
+      await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      });
+
+      const result = (await sdk.trigger("mem::lease-cleanup", {})) as {
+        success: boolean;
+        expired: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.expired).toBe(0);
+
+      const action = await kv.get<Action>("mem:actions", "act_1");
+      expect(action!.status).toBe("active");
+    });
+
+    it("handles multiple expired leases across different actions", async () => {
+      const a1 = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      const a4 = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_4",
+        agentId: "agent-b",
+      })) as { success: boolean; lease: Lease };
+
+      a1.lease.expiresAt = new Date(Date.now() - 60000).toISOString();
+      await kv.set("mem:leases", a1.lease.id, a1.lease);
+
+      a4.lease.expiresAt = new Date(Date.now() - 30000).toISOString();
+      await kv.set("mem:leases", a4.lease.id, a4.lease);
+
+      const result = (await sdk.trigger("mem::lease-cleanup", {})) as {
+        success: boolean;
+        expired: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.expired).toBe(2);
+    });
+
+    it("does not reset action when action is no longer active", async () => {
+      const acquired = (await sdk.trigger("mem::lease-acquire", {
+        actionId: "act_1",
+        agentId: "agent-a",
+      })) as { success: boolean; lease: Lease };
+
+      acquired.lease.expiresAt = new Date(Date.now() - 60000).toISOString();
+      await kv.set("mem:leases", acquired.lease.id, acquired.lease);
+
+      const action = await kv.get<Action>("mem:actions", "act_1");
+      action!.status = "done";
+      await kv.set("mem:actions", "act_1", action);
+
+      await sdk.trigger("mem::lease-cleanup", {});
+
+      const updatedAction = await kv.get<Action>("mem:actions", "act_1");
+      expect(updatedAction!.status).toBe("done");
+    });
+  });
+});

package/test/mcp-prompts.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerMcpEndpoints } from "../src/mcp/server.js";
+import type { Session, SessionSummary, Memory } 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>();
+  const triggerOverrides = new Map<string, Function>();
+  return {
+    registerFunction: (opts: { id: string }, handler: Function) => {
+      functions.set(opts.id, handler);
+    },
+    registerTrigger: () => {},
+    trigger: async (id: string, data: unknown) => {
+      if (triggerOverrides.has(id)) {
+        return triggerOverrides.get(id)!(data);
+      }
+      const fn = functions.get(id);
+      if (!fn) throw new Error(`No function: ${id}`);
+      return fn(data);
+    },
+    overrideTrigger: (id: string, handler: Function) => {
+      triggerOverrides.set(id, handler);
+    },
+    getFunction: (id: string) => functions.get(id),
+  };
+}
+
+function makeReq(body?: unknown, headers?: Record<string, string>) {
+  return {
+    body,
+    headers: headers || {},
+    query_params: {},
+  };
+}
+
+describe("MCP Prompts", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(() => {
+    sdk = mockSdk();
+    kv = mockKV();
+    registerMcpEndpoints(sdk as never, kv as never);
+  });
+
+  it("lists 3 prompts", async () => {
+    const fn = sdk.getFunction("mcp::prompts::list")!;
+    const result = (await fn(makeReq())) as {
+      status_code: number;
+      body: { prompts: unknown[] };
+    };
+
+    expect(result.status_code).toBe(200);
+    expect(result.body.prompts).toHaveLength(3);
+  });
+
+  it("recall_context returns messages with search results", async () => {
+    sdk.overrideTrigger("mem::search", async () => ({
+      results: [{ observation: { title: "Found something" } }],
+    }));
+
+    const mem: Memory = {
+      id: "mem_1",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      type: "pattern",
+      title: "Auth pattern",
+      content: "Always use JWT",
+      concepts: ["auth"],
+      files: [],
+      sessionIds: [],
+      strength: 5,
+      version: 1,
+      isLatest: true,
+    };
+    await kv.set("mem:memories", "mem_1", mem);
+
+    const fn = sdk.getFunction("mcp::prompts::get")!;
+    const result = (await fn(
+      makeReq({
+        name: "recall_context",
+        arguments: { task_description: "implement auth" },
+      }),
+    )) as {
+      status_code: number;
+      body: { messages: Array<{ role: string; content: { text: string } }> };
+    };
+
+    expect(result.status_code).toBe(200);
+    expect(result.body.messages).toHaveLength(1);
+    expect(result.body.messages[0].role).toBe("user");
+    expect(result.body.messages[0].content.text).toContain("implement auth");
+  });
+
+  it("session_handoff returns session data", async () => {
+    const session: Session = {
+      id: "ses_1",
+      project: "/test",
+      cwd: "/test",
+      startedAt: "2026-02-01T00:00:00Z",
+      status: "completed",
+      observationCount: 10,
+    };
+    await kv.set("mem:sessions", "ses_1", session);
+
+    const summary: SessionSummary = {
+      sessionId: "ses_1",
+      project: "/test",
+      createdAt: "2026-02-01T00:00:00Z",
+      title: "Auth implementation",
+      narrative: "Implemented JWT auth",
+      keyDecisions: ["Used JWT"],
+      filesModified: ["src/auth.ts"],
+      concepts: ["auth"],
+      observationCount: 10,
+    };
+    await kv.set("mem:summaries", "ses_1", summary);
+
+    const fn = sdk.getFunction("mcp::prompts::get")!;
+    const result = (await fn(
+      makeReq({
+        name: "session_handoff",
+        arguments: { session_id: "ses_1" },
+      }),
+    )) as {
+      status_code: number;
+      body: { messages: Array<{ role: string; content: { text: string } }> };
+    };
+
+    expect(result.status_code).toBe(200);
+    expect(result.body.messages[0].content.text).toContain("Session Handoff");
+    expect(result.body.messages[0].content.text).toContain("ses_1");
+  });
+
+  it("detect_patterns returns analysis", async () => {
+    sdk.overrideTrigger("mem::patterns", async () => ({
+      fileCoOccurrence: [{ files: ["a.ts", "b.ts"], count: 5 }],
+    }));
+
+    const fn = sdk.getFunction("mcp::prompts::get")!;
+    const result = (await fn(
+      makeReq({
+        name: "detect_patterns",
+        arguments: { project: "/myapp" },
+      }),
+    )) as {
+      status_code: number;
+      body: { messages: Array<{ role: string; content: { text: string } }> };
+    };
+
+    expect(result.status_code).toBe(200);
+    expect(result.body.messages[0].content.text).toContain("Pattern Analysis");
+  });
+
+  it("returns 400 for missing required arg", async () => {
+    const fn = sdk.getFunction("mcp::prompts::get")!;
+    const result = (await fn(
+      makeReq({
+        name: "recall_context",
+        arguments: {},
+      }),
+    )) as { status_code: number };
+
+    expect(result.status_code).toBe(400);
+  });
+
+  it("returns 400 for unknown prompt name", async () => {
+    const fn = sdk.getFunction("mcp::prompts::get")!;
+    const result = (await fn(
+      makeReq({
+        name: "nonexistent_prompt",
+        arguments: {},
+      }),
+    )) as { status_code: number };
+
+    expect(result.status_code).toBe(400);
+  });
+
+  it("returns 400 for non-string argument value", async () => {
+    const fn = sdk.getFunction("mcp::prompts::get")!;
+    const result = (await fn(
+      makeReq({
+        name: "recall_context",
+        arguments: { task_description: 42 },
+      }),
+    )) as { status_code: number };
+
+    expect(result.status_code).toBe(400);
+  });
+});