@agentmemory/agentmemory 0.7.2 → 0.7.3

package/test/routines.test.ts

@@ -1,497 +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 { registerRoutinesFunction } from "../src/functions/routines.js";
-import type { Action, Routine, RoutineRun } 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);
-    },
-  };
-}
-
-describe("Routines Functions", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerRoutinesFunction(sdk as never, kv as never);
-  });
-
-  describe("mem::routine-create", () => {
-    it("creates a routine with valid data", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Deploy Pipeline",
-        description: "Standard deploy steps",
-        steps: [
-          { title: "Build", description: "Run build", actionTemplate: {}, dependsOn: [] },
-          { title: "Test", description: "Run tests", actionTemplate: {}, dependsOn: [0] },
-        ],
-        tags: ["deploy", "ci"],
-      })) as { success: boolean; routine: Routine };
-
-      expect(result.success).toBe(true);
-      expect(result.routine.id).toMatch(/^rtn_/);
-      expect(result.routine.name).toBe("Deploy Pipeline");
-      expect(result.routine.description).toBe("Standard deploy steps");
-      expect(result.routine.steps.length).toBe(2);
-      expect(result.routine.tags).toEqual(["deploy", "ci"]);
-      expect(result.routine.createdAt).toBeDefined();
-      expect(result.routine.updatedAt).toBeDefined();
-      expect(result.routine.frozen).toBe(true);
-    });
-
-    it("returns error when name is missing", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "",
-        steps: [{ title: "Step 1", description: "", actionTemplate: {}, dependsOn: [] }],
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("name and steps are required");
-    });
-
-    it("returns error when steps array is empty", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Empty Routine",
-        steps: [],
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("name and steps are required");
-    });
-
-    it("returns error when a step has no title", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Bad Steps",
-        steps: [
-          { title: "Good Step", description: "ok", actionTemplate: {}, dependsOn: [] },
-          { title: "   ", description: "no title", actionTemplate: {}, dependsOn: [] },
-        ],
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("step 1 must have a title");
-    });
-
-    it("assigns correct order to steps", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Ordered Routine",
-        steps: [
-          { title: "First", description: "", actionTemplate: {}, dependsOn: [] },
-          { title: "Second", description: "", actionTemplate: {}, dependsOn: [] },
-          { title: "Third", description: "", actionTemplate: {}, dependsOn: [] },
-        ],
-      })) as { success: boolean; routine: Routine };
-
-      expect(result.success).toBe(true);
-      expect(result.routine.steps[0].order).toBe(0);
-      expect(result.routine.steps[1].order).toBe(1);
-      expect(result.routine.steps[2].order).toBe(2);
-    });
-
-    it("preserves explicit order values", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Custom Order",
-        steps: [
-          { order: 10, title: "First", description: "", actionTemplate: {}, dependsOn: [] },
-          { order: 20, title: "Second", description: "", actionTemplate: {}, dependsOn: [] },
-        ],
-      })) as { success: boolean; routine: Routine };
-
-      expect(result.success).toBe(true);
-      expect(result.routine.steps[0].order).toBe(10);
-      expect(result.routine.steps[1].order).toBe(20);
-    });
-
-    it("defaults frozen to true when not specified", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Default Frozen",
-        steps: [{ title: "Step", description: "", actionTemplate: {}, dependsOn: [] }],
-      })) as { success: boolean; routine: Routine };
-
-      expect(result.success).toBe(true);
-      expect(result.routine.frozen).toBe(true);
-    });
-
-    it("respects frozen=false when explicitly set", async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Unfrozen",
-        steps: [{ title: "Step", description: "", actionTemplate: {}, dependsOn: [] }],
-        frozen: false,
-      })) as { success: boolean; routine: Routine };
-
-      expect(result.success).toBe(true);
-      expect(result.routine.frozen).toBe(false);
-    });
-  });
-
-  describe("mem::routine-list", () => {
-    beforeEach(async () => {
-      await sdk.trigger("mem::routine-create", {
-        name: "Routine A",
-        steps: [{ title: "S1", description: "", actionTemplate: {}, dependsOn: [] }],
-        tags: ["deploy"],
-        frozen: true,
-      });
-      await sdk.trigger("mem::routine-create", {
-        name: "Routine B",
-        steps: [{ title: "S1", description: "", actionTemplate: {}, dependsOn: [] }],
-        tags: ["test", "ci"],
-        frozen: false,
-      });
-      await sdk.trigger("mem::routine-create", {
-        name: "Routine C",
-        steps: [{ title: "S1", description: "", actionTemplate: {}, dependsOn: [] }],
-        tags: ["deploy", "ci"],
-        frozen: true,
-      });
-    });
-
-    it("lists all routines", async () => {
-      const result = (await sdk.trigger("mem::routine-list", {})) as {
-        success: boolean;
-        routines: Routine[];
-      };
-
-      expect(result.success).toBe(true);
-      expect(result.routines.length).toBe(3);
-    });
-
-    it("filters by frozen=true", async () => {
-      const result = (await sdk.trigger("mem::routine-list", {
-        frozen: true,
-      })) as { success: boolean; routines: Routine[] };
-
-      expect(result.success).toBe(true);
-      expect(result.routines.length).toBe(2);
-      expect(result.routines.every((r) => r.frozen === true)).toBe(true);
-    });
-
-    it("filters by frozen=false", async () => {
-      const result = (await sdk.trigger("mem::routine-list", {
-        frozen: false,
-      })) as { success: boolean; routines: Routine[] };
-
-      expect(result.success).toBe(true);
-      expect(result.routines.length).toBe(1);
-      expect(result.routines[0].name).toBe("Routine B");
-    });
-
-    it("filters by tags", async () => {
-      const result = (await sdk.trigger("mem::routine-list", {
-        tags: ["deploy"],
-      })) as { success: boolean; routines: Routine[] };
-
-      expect(result.success).toBe(true);
-      expect(result.routines.length).toBe(2);
-      const names = result.routines.map((r) => r.name);
-      expect(names).toContain("Routine A");
-      expect(names).toContain("Routine C");
-    });
-
-    it("filters by tags with multiple matches", async () => {
-      const result = (await sdk.trigger("mem::routine-list", {
-        tags: ["ci"],
-      })) as { success: boolean; routines: Routine[] };
-
-      expect(result.success).toBe(true);
-      expect(result.routines.length).toBe(2);
-      const names = result.routines.map((r) => r.name);
-      expect(names).toContain("Routine B");
-      expect(names).toContain("Routine C");
-    });
-  });
-
-  describe("mem::routine-run", () => {
-    let routineId: string;
-
-    beforeEach(async () => {
-      const result = (await sdk.trigger("mem::routine-create", {
-        name: "Test Pipeline",
-        steps: [
-          { order: 0, title: "Build", description: "Build step", actionTemplate: { priority: 3 }, dependsOn: [] },
-          { order: 1, title: "Test", description: "Test step", actionTemplate: { priority: 5 }, dependsOn: [0] },
-          { order: 2, title: "Deploy", description: "Deploy step", actionTemplate: {}, dependsOn: [0, 1] },
-        ],
-      })) as { success: boolean; routine: Routine };
-      routineId = result.routine.id;
-    });
-
-    it("creates actions for each step", async () => {
-      const result = (await sdk.trigger("mem::routine-run", {
-        routineId,
-        initiatedBy: "user-1",
-      })) as { success: boolean; run: RoutineRun; actionsCreated: number };
-
-      expect(result.success).toBe(true);
-      expect(result.actionsCreated).toBe(3);
-      expect(result.run.actionIds.length).toBe(3);
-      expect(result.run.status).toBe("running");
-      expect(result.run.initiatedBy).toBe("user-1");
-
-      const actions = await kv.list<Action>("mem:actions");
-      expect(actions.length).toBe(3);
-      const titles = actions.map((a) => a.title);
-      expect(titles).toContain("Build");
-      expect(titles).toContain("Test");
-      expect(titles).toContain("Deploy");
-    });
-
-    it("creates dependency edges between steps", async () => {
-      const result = (await sdk.trigger("mem::routine-run", {
-        routineId,
-      })) as { success: boolean; run: RoutineRun; actionsCreated: number };
-
-      expect(result.success).toBe(true);
-
-      const edges = await kv.list<{
-        id: string;
-        type: string;
-        sourceActionId: string;
-        targetActionId: string;
-      }>("mem:action-edges");
-
-      expect(edges.length).toBe(3);
-      expect(edges.every((e) => e.type === "requires")).toBe(true);
-    });
-
-    it("creates routine run tracking object", async () => {
-      const result = (await sdk.trigger("mem::routine-run", {
-        routineId,
-        initiatedBy: "agent-x",
-      })) as { success: boolean; run: RoutineRun };
-
-      expect(result.run.id).toMatch(/^run_/);
-      expect(result.run.routineId).toBe(routineId);
-      expect(result.run.status).toBe("running");
-      expect(result.run.startedAt).toBeDefined();
-      expect(result.run.actionIds.length).toBe(3);
-      expect(result.run.initiatedBy).toBe("agent-x");
-
-      const stored = await kv.get<RoutineRun>("mem:routine-runs", result.run.id);
-      expect(stored).not.toBeNull();
-      expect(stored!.routineId).toBe(routineId);
-    });
-
-    it("preserves priority 0 via nullish coalescing", async () => {
-      const createResult = (await sdk.trigger("mem::routine-create", {
-        name: "Zero Priority",
-        steps: [
-          { order: 0, title: "Step Zero", description: "", actionTemplate: { priority: 0 }, dependsOn: [] },
-        ],
-      })) as { success: boolean; routine: Routine };
-
-      const runResult = (await sdk.trigger("mem::routine-run", {
-        routineId: createResult.routine.id,
-      })) as { success: boolean; run: RoutineRun };
-
-      const actionId = runResult.run.actionIds[0];
-      const action = await kv.get<Action>("mem:actions", actionId);
-      expect(action!.priority).toBe(0);
-    });
-
-    it("tags actions with routine id", async () => {
-      const result = (await sdk.trigger("mem::routine-run", {
-        routineId,
-      })) as { success: boolean; run: RoutineRun };
-
-      for (const actionId of result.run.actionIds) {
-        const action = await kv.get<Action>("mem:actions", actionId);
-        expect(action!.tags).toContain(`routine:${routineId}`);
-      }
-    });
-
-    it("returns error when routineId is missing", async () => {
-      const result = (await sdk.trigger("mem::routine-run", {
-        routineId: "",
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("routineId is required");
-    });
-
-    it("returns error when routine is not found", async () => {
-      const result = (await sdk.trigger("mem::routine-run", {
-        routineId: "rtn_nonexistent",
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("routine not found");
-    });
-  });
-
-  describe("mem::routine-status", () => {
-    let runId: string;
-    let actionIds: string[];
-
-    beforeEach(async () => {
-      const createResult = (await sdk.trigger("mem::routine-create", {
-        name: "Status Test",
-        steps: [
-          { order: 0, title: "Step A", description: "", actionTemplate: {}, dependsOn: [] },
-          { order: 1, title: "Step B", description: "", actionTemplate: {}, dependsOn: [] },
-          { order: 2, title: "Step C", description: "", actionTemplate: {}, dependsOn: [] },
-        ],
-      })) as { success: boolean; routine: Routine };
-
-      const runResult = (await sdk.trigger("mem::routine-run", {
-        routineId: createResult.routine.id,
-      })) as { success: boolean; run: RoutineRun };
-
-      runId = runResult.run.id;
-      actionIds = runResult.run.actionIds;
-    });
-
-    it("reports running status when actions are in progress", async () => {
-      const result = (await sdk.trigger("mem::routine-status", {
-        runId,
-      })) as { success: boolean; run: RoutineRun; progress: { total: number; pending: number } };
-
-      expect(result.success).toBe(true);
-      expect(result.run.status).toBe("running");
-      expect(result.progress.total).toBe(3);
-      expect(result.progress.pending).toBe(3);
-    });
-
-    it("marks run completed when all actions are done", async () => {
-      for (const actionId of actionIds) {
-        const action = await kv.get<Action>("mem:actions", actionId);
-        action!.status = "done";
-        await kv.set("mem:actions", actionId, action);
-      }
-
-      const result = (await sdk.trigger("mem::routine-status", {
-        runId,
-      })) as { success: boolean; run: RoutineRun; progress: { done: number; total: number } };
-
-      expect(result.success).toBe(true);
-      expect(result.run.status).toBe("completed");
-      expect(result.run.completedAt).toBeDefined();
-      expect(result.progress.done).toBe(3);
-    });
-
-    it("marks run failed when any action is cancelled", async () => {
-      const action = await kv.get<Action>("mem:actions", actionIds[0]);
-      action!.status = "cancelled";
-      await kv.set("mem:actions", actionIds[0], action);
-
-      const result = (await sdk.trigger("mem::routine-status", {
-        runId,
-      })) as { success: boolean; run: RoutineRun };
-
-      expect(result.success).toBe(true);
-      expect(result.run.status).toBe("failed");
-    });
-
-    it("marks run failed when any action is cancelled (mixed statuses)", async () => {
-      const action = await kv.get<Action>("mem:actions", actionIds[1]);
-      (action as Action).status = "done";
-      await kv.set("mem:actions", actionIds[1], action);
-
-      const action2 = await kv.get<Action>("mem:actions", actionIds[2]);
-      (action2 as Action).status = "cancelled";
-      await kv.set("mem:actions", actionIds[2], action2);
-
-      const result = (await sdk.trigger("mem::routine-status", {
-        runId,
-      })) as { success: boolean; run: RoutineRun };
-
-      expect(result.success).toBe(true);
-      expect(result.run.status).toBe("failed");
-    });
-
-    it("returns error when runId is missing", async () => {
-      const result = (await sdk.trigger("mem::routine-status", {
-        runId: "",
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("runId is required");
-    });
-
-    it("returns error when run is not found", async () => {
-      const result = (await sdk.trigger("mem::routine-status", {
-        runId: "run_nonexistent",
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("run not found");
-    });
-  });
-
-  describe("mem::routine-freeze", () => {
-    it("freezes a routine", async () => {
-      const createResult = (await sdk.trigger("mem::routine-create", {
-        name: "Unfreeze Me",
-        steps: [{ title: "Step", description: "", actionTemplate: {}, dependsOn: [] }],
-        frozen: false,
-      })) as { success: boolean; routine: Routine };
-
-      expect(createResult.routine.frozen).toBe(false);
-
-      const result = (await sdk.trigger("mem::routine-freeze", {
-        routineId: createResult.routine.id,
-      })) as { success: boolean; routine: Routine };
-
-      expect(result.success).toBe(true);
-      expect(result.routine.frozen).toBe(true);
-      expect(result.routine.updatedAt).toBeDefined();
-    });
-
-    it("returns error when routineId is missing", async () => {
-      const result = (await sdk.trigger("mem::routine-freeze", {
-        routineId: "",
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("routineId is required");
-    });
-
-    it("returns error when routine is not found", async () => {
-      const result = (await sdk.trigger("mem::routine-freeze", {
-        routineId: "rtn_nonexistent",
-      })) as { success: boolean; error: string };
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("routine not found");
-    });
-  });
-});

package/test/schema-fingerprint.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { fingerprintId, KV } from "../src/state/schema.js";
-
-describe("fingerprintId", () => {
-  it("returns string with correct prefix", () => {
-    const id = fingerprintId("mem", "some content");
-    expect(id).toMatch(/^mem_/);
-  });
-
-  it("same content produces same ID (deterministic)", () => {
-    const id1 = fingerprintId("obs", "identical content here");
-    const id2 = fingerprintId("obs", "identical content here");
-    expect(id1).toBe(id2);
-  });
-
-  it("different content produces different IDs", () => {
-    const id1 = fingerprintId("obs", "content alpha");
-    const id2 = fingerprintId("obs", "content beta");
-    expect(id1).not.toBe(id2);
-  });
-
-  it("different prefixes produce different IDs", () => {
-    const id1 = fingerprintId("mem", "same content");
-    const id2 = fingerprintId("obs", "same content");
-    expect(id1).not.toBe(id2);
-  });
-
-  it("ID has sufficient length (prefix + underscore + 16 hex chars)", () => {
-    const id = fingerprintId("mem", "test");
-    const parts = id.split("_");
-    expect(parts.length).toBe(2);
-    expect(parts[0]).toBe("mem");
-    expect(parts[1]).toHaveLength(16);
-    expect(parts[1]).toMatch(/^[0-9a-f]{16}$/);
-  });
-
-  it("handles empty content", () => {
-    const id = fingerprintId("x", "");
-    expect(id).toMatch(/^x_[0-9a-f]{16}$/);
-  });
-
-  it("handles long content", () => {
-    const longContent = "a".repeat(10000);
-    const id = fingerprintId("long", longContent);
-    expect(id).toMatch(/^long_[0-9a-f]{16}$/);
-  });
-});
-
-describe("KV scopes", () => {
-  it("has actions scope", () => {
-    expect(KV.actions).toBe("mem:actions");
-  });
-
-  it("has actionEdges scope", () => {
-    expect(KV.actionEdges).toBe("mem:action-edges");
-  });
-
-  it("has leases scope", () => {
-    expect(KV.leases).toBe("mem:leases");
-  });
-
-  it("has routines scope", () => {
-    expect(KV.routines).toBe("mem:routines");
-  });
-
-  it("has routineRuns scope", () => {
-    expect(KV.routineRuns).toBe("mem:routine-runs");
-  });
-
-  it("has signals scope", () => {
-    expect(KV.signals).toBe("mem:signals");
-  });
-
-  it("has checkpoints scope", () => {
-    expect(KV.checkpoints).toBe("mem:checkpoints");
-  });
-
-  it("has mesh scope", () => {
-    expect(KV.mesh).toBe("mem:mesh");
-  });
-});

package/test/schema.test.ts

@@ -1,42 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { KV, STREAM, generateId } from '../src/state/schema.js'
-
-describe('KV', () => {
-  it('has correct session scope', () => {
-    expect(KV.sessions).toBe('mem:sessions')
-  })
-
-  it('generates observation scope with session ID', () => {
-    expect(KV.observations('ses_123')).toBe('mem:obs:ses_123')
-  })
-
-  it('has correct summaries scope', () => {
-    expect(KV.summaries).toBe('mem:summaries')
-  })
-})
-
-describe('STREAM', () => {
-  it('has correct name', () => {
-    expect(STREAM.name).toBe('mem-live')
-  })
-
-  it('group returns session ID', () => {
-    expect(STREAM.group('ses_123')).toBe('ses_123')
-  })
-})
-
-describe('generateId', () => {
-  it('includes prefix', () => {
-    expect(generateId('obs')).toMatch(/^obs_/)
-  })
-
-  it('generates unique IDs', () => {
-    const ids = new Set(Array.from({ length: 100 }, () => generateId('test')))
-    expect(ids.size).toBe(100)
-  })
-
-  it('has sufficient length', () => {
-    const id = generateId('obs')
-    expect(id.length).toBeGreaterThan(15)
-  })
-})