@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/diagnostics.test.ts

@@ -1,638 +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 { registerDiagnosticsFunction } from "../src/functions/diagnostics.js";
-import type {
-  Action,
-  ActionEdge,
-  DiagnosticCheck,
-  Lease,
-  Sentinel,
-  Sketch,
-  Signal,
-  Session,
-  Memory,
-  MeshPeer,
-} from "../src/types.js";
-import { KV } from "../src/state/schema.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 {
-  return {
-    id: `act_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    title: "Test action",
-    description: "",
-    status: "pending",
-    priority: 5,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    createdBy: "agent-1",
-    tags: [],
-    sourceObservationIds: [],
-    sourceMemoryIds: [],
-    ...overrides,
-  };
-}
-
-function makeLease(overrides: Partial<Lease> = {}): Lease {
-  return {
-    id: `lease_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    actionId: "act_missing",
-    agentId: "agent-1",
-    acquiredAt: new Date().toISOString(),
-    expiresAt: new Date(Date.now() + 60_000).toISOString(),
-    status: "active",
-    ...overrides,
-  };
-}
-
-function makeEdge(overrides: Partial<ActionEdge> = {}): ActionEdge {
-  return {
-    id: `ae_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    type: "requires",
-    sourceActionId: "src",
-    targetActionId: "tgt",
-    createdAt: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-function makeSentinel(overrides: Partial<Sentinel> = {}): Sentinel {
-  return {
-    id: `sen_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    name: "Test sentinel",
-    type: "timer",
-    status: "watching",
-    config: {},
-    createdAt: new Date().toISOString(),
-    linkedActionIds: [],
-    ...overrides,
-  };
-}
-
-function makeSketch(overrides: Partial<Sketch> = {}): Sketch {
-  return {
-    id: `sk_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    title: "Test sketch",
-    description: "",
-    status: "active",
-    actionIds: [],
-    createdAt: new Date().toISOString(),
-    expiresAt: new Date(Date.now() + 60_000).toISOString(),
-    ...overrides,
-  };
-}
-
-function makeSignal(overrides: Partial<Signal> = {}): Signal {
-  return {
-    id: `sig_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    from: "agent-1",
-    type: "info",
-    content: "test",
-    createdAt: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-function makeSession(overrides: Partial<Session> = {}): Session {
-  return {
-    id: `ses_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    project: "test",
-    cwd: "/tmp",
-    startedAt: new Date().toISOString(),
-    status: "active",
-    observationCount: 0,
-    ...overrides,
-  };
-}
-
-function makeMemory(overrides: Partial<Memory> = {}): Memory {
-  return {
-    id: `mem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    type: "fact",
-    title: "Test memory",
-    content: "content",
-    concepts: [],
-    files: [],
-    sessionIds: [],
-    strength: 1,
-    version: 1,
-    isLatest: true,
-    ...overrides,
-  };
-}
-
-function makePeer(overrides: Partial<MeshPeer> = {}): MeshPeer {
-  return {
-    id: `peer_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-    url: "http://localhost:3111",
-    name: "Test peer",
-    status: "connected",
-    sharedScopes: [],
-    ...overrides,
-  };
-}
-
-describe("Diagnostics Functions", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerDiagnosticsFunction(sdk as never, kv as never);
-  });
-
-  describe("mem::diagnose", () => {
-    it("empty system passes all checks", async () => {
-      const result = (await sdk.trigger("mem::diagnose", {})) as {
-        success: boolean;
-        checks: DiagnosticCheck[];
-        summary: { pass: number; warn: number; fail: number; fixable: number };
-      };
-
-      expect(result.success).toBe(true);
-      expect(result.summary.pass).toBe(8);
-      expect(result.summary.warn).toBe(0);
-      expect(result.summary.fail).toBe(0);
-      expect(result.summary.fixable).toBe(0);
-      expect(result.checks.every((c) => c.status === "pass")).toBe(true);
-    });
-
-    it("active action with no lease produces warn", async () => {
-      const action = makeAction({ status: "active" });
-      await kv.set(KV.actions, action.id, action);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["actions"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("active-no-lease:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("warn");
-      expect(check!.fixable).toBe(false);
-    });
-
-    it("blocked action with all deps done produces fail (fixable)", async () => {
-      const dep = makeAction({ status: "done" });
-      const blocked = makeAction({ status: "blocked" });
-      const edge = makeEdge({
-        sourceActionId: blocked.id,
-        targetActionId: dep.id,
-        type: "requires",
-      });
-      await kv.set(KV.actions, dep.id, dep);
-      await kv.set(KV.actions, blocked.id, blocked);
-      await kv.set(KV.actionEdges, edge.id, edge);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["actions"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("blocked-deps-done:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("pending action with unsatisfied deps produces fail (fixable)", async () => {
-      const dep = makeAction({ status: "active" });
-      const pending = makeAction({ status: "pending" });
-      const edge = makeEdge({
-        sourceActionId: pending.id,
-        targetActionId: dep.id,
-        type: "requires",
-      });
-      await kv.set(KV.actions, dep.id, dep);
-      await kv.set(KV.actions, pending.id, pending);
-      await kv.set(KV.actionEdges, edge.id, edge);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["actions"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("pending-unsatisfied-deps:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("expired active lease produces fail (fixable)", async () => {
-      const action = makeAction({ status: "active" });
-      const lease = makeLease({
-        actionId: action.id,
-        status: "active",
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.actions, action.id, action);
-      await kv.set(KV.leases, lease.id, lease);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["leases"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("expired-lease:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("orphaned lease (action gone) produces fail (fixable)", async () => {
-      const lease = makeLease({
-        actionId: "act_gone",
-        status: "active",
-        expiresAt: new Date(Date.now() + 60_000).toISOString(),
-      });
-      await kv.set(KV.leases, lease.id, lease);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["leases"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("orphaned-lease:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("expired watching sentinel produces fail (fixable)", async () => {
-      const sentinel = makeSentinel({
-        status: "watching",
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.sentinels, sentinel.id, sentinel);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["sentinels"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("expired-sentinel:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("sentinel referencing missing action produces warn", async () => {
-      const sentinel = makeSentinel({
-        linkedActionIds: ["act_nonexistent"],
-      });
-      await kv.set(KV.sentinels, sentinel.id, sentinel);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["sentinels"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("sentinel-missing-action:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("warn");
-      expect(check!.fixable).toBe(false);
-    });
-
-    it("expired active sketch produces fail (fixable)", async () => {
-      const sketch = makeSketch({
-        status: "active",
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.sketches, sketch.id, sketch);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["sketches"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("expired-sketch:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("expired signal produces fail (fixable)", async () => {
-      const signal = makeSignal({
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.signals, signal.id, signal);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["signals"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("expired-signal:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("active session older than 24h produces warn", async () => {
-      const session = makeSession({
-        status: "active",
-        startedAt: new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString(),
-      });
-      await kv.set(KV.sessions, session.id, session);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["sessions"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("abandoned-session:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("warn");
-      expect(check!.fixable).toBe(false);
-    });
-
-    it("memory with stale isLatest produces fail (fixable)", async () => {
-      const oldMemory = makeMemory({ isLatest: true });
-      const newMemory = makeMemory({ supersedes: [oldMemory.id] });
-      await kv.set(KV.memories, oldMemory.id, oldMemory);
-      await kv.set(KV.memories, newMemory.id, newMemory);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["memories"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("memory-stale-latest:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("fail");
-      expect(check!.fixable).toBe(true);
-    });
-
-    it("memory superseding non-existent produces warn", async () => {
-      const memory = makeMemory({ supersedes: ["mem_gone"] });
-      await kv.set(KV.memories, memory.id, memory);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["memories"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("memory-missing-supersedes:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("warn");
-      expect(check!.fixable).toBe(false);
-    });
-
-    it("stale mesh peer produces warn", async () => {
-      const peer = makePeer({
-        lastSyncAt: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
-      });
-      await kv.set(KV.mesh, peer.id, peer);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["mesh"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("stale-peer:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("warn");
-      expect(check!.fixable).toBe(false);
-    });
-
-    it("error mesh peer produces warn", async () => {
-      const peer = makePeer({ status: "error" });
-      await kv.set(KV.mesh, peer.id, peer);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["mesh"],
-      })) as { checks: DiagnosticCheck[] };
-
-      const check = result.checks.find((c) =>
-        c.name.startsWith("error-peer:"),
-      );
-      expect(check).toBeDefined();
-      expect(check!.status).toBe("warn");
-      expect(check!.fixable).toBe(false);
-    });
-
-    it("filters by categories", async () => {
-      const action = makeAction({ status: "active" });
-      await kv.set(KV.actions, action.id, action);
-
-      const signal = makeSignal({
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.signals, signal.id, signal);
-
-      const result = (await sdk.trigger("mem::diagnose", {
-        categories: ["signals"],
-      })) as { checks: DiagnosticCheck[] };
-
-      expect(result.checks.every((c) => c.category === "signals")).toBe(true);
-      expect(
-        result.checks.some((c) => c.category === "actions"),
-      ).toBe(false);
-    });
-  });
-
-  describe("mem::heal", () => {
-    it("unblocks stuck blocked action", async () => {
-      const dep = makeAction({ status: "done" });
-      const blocked = makeAction({ status: "blocked", title: "Stuck task" });
-      const edge = makeEdge({
-        sourceActionId: blocked.id,
-        targetActionId: dep.id,
-        type: "requires",
-      });
-      await kv.set(KV.actions, dep.id, dep);
-      await kv.set(KV.actions, blocked.id, blocked);
-      await kv.set(KV.actionEdges, edge.id, edge);
-
-      const result = (await sdk.trigger("mem::heal", {
-        categories: ["actions"],
-      })) as { success: boolean; fixed: number; details: string[] };
-
-      expect(result.success).toBe(true);
-      expect(result.fixed).toBe(1);
-      expect(result.details[0]).toContain("Unblocked");
-
-      const updated = await kv.get<Action>(KV.actions, blocked.id);
-      expect(updated!.status).toBe("pending");
-    });
-
-    it("blocks pending action with unsatisfied deps", async () => {
-      const dep = makeAction({ status: "active" });
-      const pending = makeAction({
-        status: "pending",
-        title: "Should be blocked",
-      });
-      const edge = makeEdge({
-        sourceActionId: pending.id,
-        targetActionId: dep.id,
-        type: "requires",
-      });
-      await kv.set(KV.actions, dep.id, dep);
-      await kv.set(KV.actions, pending.id, pending);
-      await kv.set(KV.actionEdges, edge.id, edge);
-
-      const result = (await sdk.trigger("mem::heal", {
-        categories: ["actions"],
-      })) as { success: boolean; fixed: number; details: string[] };
-
-      expect(result.success).toBe(true);
-      expect(result.fixed).toBe(1);
-      expect(result.details[0]).toContain("Blocked");
-
-      const updated = await kv.get<Action>(KV.actions, pending.id);
-      expect(updated!.status).toBe("blocked");
-    });
-
-    it("expires stale lease and resets action", async () => {
-      const action = makeAction({
-        status: "active",
-        assignedTo: "agent-1",
-      });
-      const lease = makeLease({
-        actionId: action.id,
-        agentId: "agent-1",
-        status: "active",
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.actions, action.id, action);
-      await kv.set(KV.leases, lease.id, lease);
-
-      const result = (await sdk.trigger("mem::heal", {
-        categories: ["leases"],
-      })) as { success: boolean; fixed: number; details: string[] };
-
-      expect(result.success).toBe(true);
-      expect(result.fixed).toBe(1);
-      expect(result.details[0]).toContain("Expired lease");
-
-      const updatedLease = await kv.get<Lease>(KV.leases, lease.id);
-      expect(updatedLease!.status).toBe("expired");
-
-      const updatedAction = await kv.get<Action>(KV.actions, action.id);
-      expect(updatedAction!.status).toBe("pending");
-      expect(updatedAction!.assignedTo).toBeUndefined();
-    });
-
-    it("deletes orphaned lease", async () => {
-      const lease = makeLease({
-        actionId: "act_gone",
-        status: "released",
-        expiresAt: new Date(Date.now() + 60_000).toISOString(),
-      });
-      await kv.set(KV.leases, lease.id, lease);
-
-      const result = (await sdk.trigger("mem::heal", {
-        categories: ["leases"],
-      })) as { success: boolean; fixed: number; details: string[] };
-
-      expect(result.success).toBe(true);
-      expect(result.fixed).toBe(1);
-      expect(result.details[0]).toContain("Deleted orphaned lease");
-
-      const deleted = await kv.get<Lease>(KV.leases, lease.id);
-      expect(deleted).toBeNull();
-    });
-
-    it("expires stale sentinel", async () => {
-      const sentinel = makeSentinel({
-        status: "watching",
-        name: "Stale watcher",
-        expiresAt: new Date(Date.now() - 60_000).toISOString(),
-      });
-      await kv.set(KV.sentinels, sentinel.id, sentinel);
-
-      const result = (await sdk.trigger("mem::heal", {
-        categories: ["sentinels"],
-      })) as { success: boolean; fixed: number; details: string[] };
-
-      expect(result.success).toBe(true);
-      expect(result.fixed).toBe(1);
-      expect(result.details[0]).toContain("Expired sentinel");
-
-      const updated = await kv.get<Sentinel>(KV.sentinels, sentinel.id);
-      expect(updated!.status).toBe("expired");
-    });
-
-    it("dry run reports but does not fix", async () => {
-      const dep = makeAction({ status: "done" });
-      const blocked = makeAction({ status: "blocked", title: "Stuck task" });
-      const edge = makeEdge({
-        sourceActionId: blocked.id,
-        targetActionId: dep.id,
-        type: "requires",
-      });
-      await kv.set(KV.actions, dep.id, dep);
-      await kv.set(KV.actions, blocked.id, blocked);
-      await kv.set(KV.actionEdges, edge.id, edge);
-
-      const result = (await sdk.trigger("mem::heal", {
-        categories: ["actions"],
-        dryRun: true,
-      })) as { success: boolean; fixed: number; details: string[] };
-
-      expect(result.success).toBe(true);
-      expect(result.fixed).toBe(1);
-      expect(result.details[0]).toContain("[dry-run]");
-
-      const unchanged = await kv.get<Action>(KV.actions, blocked.id);
-      expect(unchanged!.status).toBe("blocked");
-    });
-  });
-});

package/test/embedding-provider.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createEmbeddingProvider } from "../src/providers/embedding/index.js";
-import { GeminiEmbeddingProvider } from "../src/providers/embedding/gemini.js";
-import { OpenAIEmbeddingProvider } from "../src/providers/embedding/openai.js";
-
-describe("createEmbeddingProvider", () => {
-  const originalEnv = { ...process.env };
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-    delete process.env["GEMINI_API_KEY"];
-    delete process.env["OPENAI_API_KEY"];
-    delete process.env["VOYAGE_API_KEY"];
-    delete process.env["COHERE_API_KEY"];
-    delete process.env["OPENROUTER_API_KEY"];
-    delete process.env["EMBEDDING_PROVIDER"];
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  it("returns null when no API keys are set", () => {
-    const provider = createEmbeddingProvider();
-    expect(provider).toBeNull();
-  });
-
-  it("returns GeminiEmbeddingProvider when GEMINI_API_KEY is set", () => {
-    process.env["GEMINI_API_KEY"] = "test-key-123";
-    const provider = createEmbeddingProvider();
-    expect(provider).toBeInstanceOf(GeminiEmbeddingProvider);
-    expect(provider!.name).toBe("gemini");
-  });
-
-  it("returns OpenAIEmbeddingProvider when OPENAI_API_KEY is set", () => {
-    process.env["OPENAI_API_KEY"] = "test-key-456";
-    const provider = createEmbeddingProvider();
-    expect(provider).toBeInstanceOf(OpenAIEmbeddingProvider);
-    expect(provider!.name).toBe("openai");
-  });
-
-  it("EMBEDDING_PROVIDER override takes precedence", () => {
-    process.env["GEMINI_API_KEY"] = "test-key-123";
-    process.env["OPENAI_API_KEY"] = "test-key-456";
-    process.env["EMBEDDING_PROVIDER"] = "openai";
-    const provider = createEmbeddingProvider();
-    expect(provider).toBeInstanceOf(OpenAIEmbeddingProvider);
-  });
-});