@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/sliding-window.test.ts

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

@@ -1,169 +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 { 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

@@ -1,165 +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() },
-  }),
-}));
-
-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

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