@agentmemory/agentmemory 0.7.0

package/test/sliding-window.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import type { CompressedObservation, MemoryProvider } from "../src/types.js";
+
+function makeObs(
+  id: string,
+  title: string,
+  narrative: string,
+  overrides: Partial<CompressedObservation> = {},
+): CompressedObservation {
+  return {
+    id,
+    sessionId: "ses_1",
+    timestamp: new Date().toISOString(),
+    type: "file_edit",
+    title,
+    subtitle: "",
+    facts: [],
+    narrative,
+    concepts: [],
+    files: [],
+    importance: 5,
+    ...overrides,
+  };
+}
+
+function mockKV(observations: CompressedObservation[] = []) {
+  const store = new Map<string, Map<string, unknown>>();
+  const obsMap = new Map<string, unknown>();
+  for (const obs of observations) {
+    obsMap.set(obs.id, obs);
+  }
+  store.set("mem:obs:ses_1", obsMap);
+
+  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 }, fn: Function) => {
+      functions.set(opts.id, fn);
+    },
+    trigger: async (id: string, data: unknown) => {
+      const fn = functions.get(id);
+      if (fn) return fn(data);
+      return null;
+    },
+    triggerVoid: () => {},
+  };
+}
+
+function mockProvider(response: string): MemoryProvider {
+  return {
+    name: "test",
+    compress: vi.fn().mockResolvedValue(response),
+    summarize: vi.fn().mockResolvedValue(response),
+  };
+}
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: {
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    },
+  }),
+}));
+
+describe("SlidingWindow", () => {
+  it("imports without errors", async () => {
+    const mod = await import("../src/functions/sliding-window.js");
+    expect(mod.registerSlidingWindowFunction).toBeDefined();
+  });
+
+  it("registers both functions", async () => {
+    const { registerSlidingWindowFunction } = await import(
+      "../src/functions/sliding-window.js"
+    );
+    const sdk = mockSdk();
+    const kv = mockKV();
+    const provider = mockProvider("");
+    registerSlidingWindowFunction(sdk as never, kv as never, provider);
+
+    expect(sdk.trigger).toBeDefined();
+  });
+
+  it("enriches observation with sliding window context", async () => {
+    const { registerSlidingWindowFunction } = await import(
+      "../src/functions/sliding-window.js"
+    );
+
+    const obs1 = makeObs(
+      "obs_1",
+      "User discussed React framework",
+      "The user mentioned they are working with React for their frontend.",
+      { timestamp: "2024-01-01T00:00:00Z" },
+    );
+    const obs2 = makeObs(
+      "obs_2",
+      "Framework frustration",
+      "The user said they hate that framework and find it hard to debug.",
+      { timestamp: "2024-01-01T00:01:00Z" },
+    );
+    const obs3 = makeObs(
+      "obs_3",
+      "Switching to Vue",
+      "The user decided to switch to Vue for the project.",
+      { timestamp: "2024-01-01T00:02:00Z" },
+    );
+
+    const kv = mockKV([obs1, obs2, obs3]);
+    const sdk = mockSdk();
+
+    const enrichedXml = `<enriched>
+  <content>The user (working with React for frontend) expressed strong frustration with React framework, finding it difficult to debug.</content>
+  <resolved_entities>
+    <entity original="that framework" resolved="React"/>
+  </resolved_entities>
+  <preferences>
+    <preference>User dislikes React due to debugging difficulty</preference>
+  </preferences>
+  <context_bridges>
+    <bridge>User was working with React before expressing frustration</bridge>
+  </context_bridges>
+</enriched>`;
+
+    const provider = mockProvider(enrichedXml);
+    registerSlidingWindowFunction(sdk as never, kv as never, provider);
+
+    const result = (await sdk.trigger("mem::enrich-window", {
+      observationId: "obs_2",
+      sessionId: "ses_1",
+      lookback: 1,
+      lookahead: 1,
+    })) as { success: boolean; enriched: any };
+
+    expect(result.success).toBe(true);
+    expect(result.enriched).toBeDefined();
+    expect(result.enriched.resolvedEntities["that framework"]).toBe("React");
+    expect(result.enriched.preferences).toContain(
+      "User dislikes React due to debugging difficulty",
+    );
+    expect(result.enriched.contextBridges.length).toBeGreaterThan(0);
+  });
+
+  it("returns null enrichment when no adjacent observations", async () => {
+    const { registerSlidingWindowFunction } = await import(
+      "../src/functions/sliding-window.js"
+    );
+    const obs = makeObs("obs_solo", "Solo observation", "Just one.");
+    const kv = mockKV([obs]);
+    const sdk = mockSdk();
+    const provider = mockProvider("");
+    registerSlidingWindowFunction(sdk as never, kv as never, provider);
+
+    const result = (await sdk.trigger("mem::enrich-window", {
+      observationId: "obs_solo",
+      sessionId: "ses_1",
+    })) as { success: boolean; enriched: any; reason: string };
+
+    expect(result.success).toBe(true);
+    expect(result.enriched).toBeNull();
+  });
+
+  it("returns error for missing observation", async () => {
+    const { registerSlidingWindowFunction } = await import(
+      "../src/functions/sliding-window.js"
+    );
+    const kv = mockKV([]);
+    const sdk = mockSdk();
+    const provider = mockProvider("");
+    registerSlidingWindowFunction(sdk as never, kv as never, provider);
+
+    const result = (await sdk.trigger("mem::enrich-window", {
+      observationId: "nonexistent",
+      sessionId: "ses_1",
+    })) as { success: boolean; error: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("Observation not found");
+  });
+});

package/test/smart-search.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerSmartSearchFunction } from "../src/functions/smart-search.js";
+import type {
+  CompressedObservation,
+  HybridSearchResult,
+  CompactSearchResult,
+  Session,
+} 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 makeObs(
+  overrides: Partial<CompressedObservation> = {},
+): CompressedObservation {
+  return {
+    id: "obs_1",
+    sessionId: "ses_1",
+    timestamp: "2026-02-01T10:00:00Z",
+    type: "file_edit",
+    title: "Edit auth handler",
+    facts: [],
+    narrative: "Modified auth",
+    concepts: ["auth"],
+    files: ["src/auth.ts"],
+    importance: 7,
+    ...overrides,
+  };
+}
+
+describe("Smart Search Function", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+  let searchResults: HybridSearchResult[];
+
+  beforeEach(async () => {
+    sdk = mockSdk();
+    kv = mockKV();
+
+    const obs1 = makeObs({ id: "obs_1", sessionId: "ses_1", title: "Auth handler" });
+    const obs2 = makeObs({ id: "obs_2", sessionId: "ses_1", title: "Database setup" });
+
+    searchResults = [
+      {
+        observation: obs1,
+        bm25Score: 0.8,
+        vectorScore: 0,
+        combinedScore: 0.8,
+        sessionId: "ses_1",
+      },
+      {
+        observation: obs2,
+        bm25Score: 0.3,
+        vectorScore: 0,
+        combinedScore: 0.3,
+        sessionId: "ses_1",
+      },
+    ];
+
+    const session: Session = {
+      id: "ses_1",
+      project: "my-project",
+      cwd: "/tmp",
+      startedAt: "2026-02-01T00:00:00Z",
+      status: "completed",
+      observationCount: 2,
+    };
+    await kv.set("mem:sessions", "ses_1", session);
+    await kv.set("mem:obs:ses_1", "obs_1", obs1);
+    await kv.set("mem:obs:ses_1", "obs_2", obs2);
+
+    const searchFn = async (_query: string, _limit: number) => searchResults;
+    registerSmartSearchFunction(sdk as never, kv as never, searchFn);
+  });
+
+  it("compact mode returns CompactSearchResult array", async () => {
+    const result = (await sdk.trigger("mem::smart-search", {
+      query: "auth",
+    })) as { mode: string; results: CompactSearchResult[] };
+
+    expect(result.mode).toBe("compact");
+    expect(result.results.length).toBe(2);
+    expect(result.results[0]).toHaveProperty("obsId");
+    expect(result.results[0]).toHaveProperty("title");
+    expect(result.results[0]).toHaveProperty("type");
+    expect(result.results[0]).toHaveProperty("score");
+    expect(result.results[0]).toHaveProperty("timestamp");
+    expect(result.results[0]).not.toHaveProperty("narrative");
+  });
+
+  it("expand mode returns full observations for given IDs", async () => {
+    const result = (await sdk.trigger("mem::smart-search", {
+      expandIds: ["obs_1"],
+    })) as { mode: string; results: Array<{ obsId: string; observation: CompressedObservation }> };
+
+    expect(result.mode).toBe("expanded");
+    expect(result.results.length).toBe(1);
+    expect(result.results[0].observation.title).toBe("Auth handler");
+  });
+
+  it("returns error when query is missing and no expandIds", async () => {
+    const result = (await sdk.trigger("mem::smart-search", {})) as {
+      mode: string;
+      error: string;
+    };
+
+    expect(result.mode).toBe("compact");
+    expect(result.error).toBe("query is required");
+    expect((result as { results: unknown[] }).results).toEqual([]);
+  });
+
+  it("respects limit parameter in compact mode", async () => {
+    const result = (await sdk.trigger("mem::smart-search", {
+      query: "auth",
+      limit: 1,
+    })) as { mode: string; results: CompactSearchResult[] };
+
+    expect(result.results.length).toBeLessThanOrEqual(2);
+  });
+
+  it("expand returns empty for nonexistent observation IDs", async () => {
+    const result = (await sdk.trigger("mem::smart-search", {
+      expandIds: ["obs_nonexistent_ses_xxx"],
+    })) as { mode: string; results: unknown[] };
+
+    expect(result.mode).toBe("expanded");
+    expect(result.results.length).toBe(0);
+  });
+});

package/test/snapshot.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+vi.mock("node:child_process", () => ({
+  execFile: vi.fn(
+    (_cmd: string, _args: string[], _opts: unknown, cb: Function) => {
+      cb(null, { stdout: "abc1234\n", stderr: "" });
+    },
+  ),
+}));
+
+vi.mock("node:util", async () => {
+  const actual = (await vi.importActual("node:util")) as Record<
+    string,
+    unknown
+  >;
+  return {
+    ...actual,
+    promisify: () => async () => ({ stdout: "abc1234\n", stderr: "" }),
+  };
+});
+
+vi.mock("node:fs", () => ({
+  existsSync: vi.fn().mockReturnValue(true),
+  mkdirSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  readFileSync: vi
+    .fn()
+    .mockReturnValue('{"version":"0.4.0","sessions":[],"memories":[]}'),
+}));
+
+import { registerSnapshotFunction } from "../src/functions/snapshot.js";
+import type { Session, Memory, SnapshotMeta } 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("Snapshot Functions", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+  const snapshotDir = "/tmp/agentmemory-snapshots";
+
+  beforeEach(async () => {
+    sdk = mockSdk();
+    kv = mockKV();
+    vi.clearAllMocks();
+    registerSnapshotFunction(sdk as never, kv as never, snapshotDir);
+
+    const session: Session = {
+      id: "ses_1",
+      project: "test",
+      cwd: "/tmp",
+      startedAt: "2026-02-01T00:00:00Z",
+      status: "completed",
+      observationCount: 1,
+    };
+    await kv.set("mem:sessions", "ses_1", session);
+
+    const mem: Memory = {
+      id: "mem_1",
+      createdAt: "2026-02-01T00:00:00Z",
+      updatedAt: "2026-02-01T00:00:00Z",
+      type: "pattern",
+      title: "Test pattern",
+      content: "Always test",
+      concepts: [],
+      files: [],
+      sessionIds: ["ses_1"],
+      strength: 5,
+      version: 1,
+      isLatest: true,
+    };
+    await kv.set("mem:memories", "mem_1", mem);
+  });
+
+  it("snapshot-create serializes state and returns meta", async () => {
+    const result = (await sdk.trigger("mem::snapshot-create", {
+      message: "Test snapshot",
+    })) as { success: boolean; snapshot: SnapshotMeta };
+
+    expect(result.success).toBe(true);
+    expect(result.snapshot).toBeDefined();
+    expect(result.snapshot.commitHash).toBe("abc1234");
+    expect(result.snapshot.message).toBe("Test snapshot");
+    expect(result.snapshot.stats.sessions).toBe(1);
+    expect(result.snapshot.stats.memories).toBe(1);
+  });
+
+  it("snapshot-list returns snapshots from git log", async () => {
+    const result = (await sdk.trigger("mem::snapshot-list", {})) as {
+      snapshots: Array<{
+        commitHash: string;
+        createdAt: string;
+        message: string;
+      }>;
+    };
+
+    expect(result.snapshots).toBeDefined();
+    expect(Array.isArray(result.snapshots)).toBe(true);
+  });
+
+  it("snapshot-restore requires commitHash", async () => {
+    const result = (await sdk.trigger("mem::snapshot-restore", {})) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("commitHash");
+  });
+
+  it("snapshot-restore loads state from commit", async () => {
+    const result = (await sdk.trigger("mem::snapshot-restore", {
+      commitHash: "abc1234",
+    })) as { success: boolean; commitHash: string };
+
+    expect(result.success).toBe(true);
+    expect(result.commitHash).toBe("abc1234");
+  });
+
+  it("snapshot-create records an audit entry", async () => {
+    await sdk.trigger("mem::snapshot-create", { message: "Audit test" });
+
+    const audits = await kv.list("mem:audit");
+    expect(audits.length).toBe(1);
+  });
+});

package/test/team.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerTeamFunction } from "../src/functions/team.js";
+import type { Memory, TeamConfig, TeamSharedItem, TeamProfile } 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);
+    },
+  };
+}
+
+const teamConfig: TeamConfig = {
+  teamId: "test-team",
+  userId: "user-1",
+  mode: "shared" as const,
+};
+
+const testMemory: Memory = {
+  id: "mem_1",
+  createdAt: "2026-02-01T00:00:00Z",
+  updatedAt: "2026-02-01T00:00:00Z",
+  type: "pattern",
+  title: "Auth pattern",
+  content: "Always validate tokens",
+  concepts: ["auth", "security"],
+  files: ["src/auth.ts"],
+  sessionIds: ["ses_1"],
+  strength: 5,
+  version: 1,
+  isLatest: true,
+};
+
+describe("Team Functions", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(async () => {
+    sdk = mockSdk();
+    kv = mockKV();
+    registerTeamFunction(sdk as never, kv as never, teamConfig);
+    await kv.set("mem:memories", "mem_1", testMemory);
+  });
+
+  it("team-share stores item in team namespace", async () => {
+    const result = (await sdk.trigger("mem::team-share", {
+      itemId: "mem_1",
+      itemType: "memory",
+    })) as { success: boolean; sharedItem: TeamSharedItem };
+
+    expect(result.success).toBe(true);
+    expect(result.sharedItem.sharedBy).toBe("user-1");
+    expect(result.sharedItem.type).toBe("memory");
+    expect(result.sharedItem.visibility).toBe("shared");
+
+    const items = await kv.list<TeamSharedItem>("mem:team:test-team:shared");
+    expect(items.length).toBe(1);
+  });
+
+  it("team-share fails for missing itemId", async () => {
+    const result = (await sdk.trigger("mem::team-share", {
+      itemType: "memory",
+    })) as { success: boolean; error: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("required");
+  });
+
+  it("team-feed returns shared items sorted by date", async () => {
+    await sdk.trigger("mem::team-share", {
+      itemId: "mem_1",
+      itemType: "memory",
+    });
+
+    const mem2: Memory = { ...testMemory, id: "mem_2", title: "Second pattern" };
+    await kv.set("mem:memories", "mem_2", mem2);
+
+    await new Promise((r) => setTimeout(r, 10));
+    await sdk.trigger("mem::team-share", {
+      itemId: "mem_2",
+      itemType: "memory",
+    });
+
+    const result = (await sdk.trigger("mem::team-feed", {})) as {
+      items: TeamSharedItem[];
+      total: number;
+    };
+
+    expect(result.items.length).toBe(2);
+    expect(result.total).toBe(2);
+    expect(
+      new Date(result.items[0].sharedAt).getTime(),
+    ).toBeGreaterThanOrEqual(new Date(result.items[1].sharedAt).getTime());
+  });
+
+  it("team-profile aggregates concepts and files", async () => {
+    await sdk.trigger("mem::team-share", {
+      itemId: "mem_1",
+      itemType: "pattern",
+    });
+
+    const result = (await sdk.trigger("mem::team-profile", {})) as TeamProfile;
+
+    expect(result.teamId).toBe("test-team");
+    expect(result.members).toContain("user-1");
+    expect(result.totalSharedItems).toBe(1);
+    expect(result.topConcepts.length).toBeGreaterThan(0);
+    expect(result.topConcepts.some((c) => c.concept === "auth")).toBe(true);
+    expect(result.topFiles.some((f) => f.file === "src/auth.ts")).toBe(true);
+  });
+
+  it("team-share fails when item not found in KV", async () => {
+    const result = (await sdk.trigger("mem::team-share", {
+      itemId: "nonexistent",
+      itemType: "memory",
+    })) as { success: boolean; error: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("not found");
+  });
+});