@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/privacy.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { stripPrivateData } from "../src/functions/privacy.js";
-
-describe("stripPrivateData", () => {
-  it("strips private tags", () => {
-    expect(stripPrivateData("hello <private>secret</private> world")).toBe(
-      "hello [REDACTED] world",
-    );
-  });
-
-  it("strips private tags case-insensitive", () => {
-    expect(stripPrivateData("<Private>data</Private>")).toBe("[REDACTED]");
-  });
-
-  it("strips API keys", () => {
-    expect(stripPrivateData("api_key=sk-ant-1234567890abcdefghij")).toBe(
-      "[REDACTED_SECRET]",
-    );
-  });
-
-  it("strips GitHub PATs", () => {
-    expect(
-      stripPrivateData("token: ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefgh"),
-    ).toBe("[REDACTED_SECRET]");
-  });
-
-  it("strips standalone GitHub PATs", () => {
-    expect(
-      stripPrivateData("found ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghij here"),
-    ).toBe("found [REDACTED_SECRET] here");
-  });
-
-  it("strips Slack tokens", () => {
-    expect(stripPrivateData("xoxb-123456-789012-abcdef")).toBe(
-      "[REDACTED_SECRET]",
-    );
-  });
-
-  it("strips AWS access keys", () => {
-    expect(stripPrivateData("key=AKIAIOSFODNN7EXAMPLE")).toBe(
-      "key=[REDACTED_SECRET]",
-    );
-  });
-
-  it("strips JWT tokens", () => {
-    expect(
-      stripPrivateData(
-        "eyJhbGciOiJIUzI1.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0.SflKxwRJSMeKKF2QT4fwpM",
-      ),
-    ).toBe("[REDACTED_SECRET]");
-  });
-
-  it("strips sk- prefixed keys", () => {
-    expect(stripPrivateData("sk-1234567890abcdefghijklmnopqr")).toBe(
-      "[REDACTED_SECRET]",
-    );
-  });
-
-  it("handles multiple secrets in one string", () => {
-    const input =
-      "sk-abcdefghijklmnopqrstuv and ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghij";
-    const result = stripPrivateData(input);
-    expect(result).not.toContain("sk-");
-    expect(result).not.toContain("ghp_");
-  });
-
-  it("does not strip short strings", () => {
-    expect(stripPrivateData("api_key=short")).toBe("api_key=short");
-  });
-
-  it("returns empty string unchanged", () => {
-    expect(stripPrivateData("")).toBe("");
-  });
-
-  it("handles no secrets gracefully", () => {
-    expect(stripPrivateData("normal text without secrets")).toBe(
-      "normal text without secrets",
-    );
-  });
-
-  it("works correctly on consecutive calls (no regex statefulness)", () => {
-    const input = "sk-ABCDEFGHIJKLMNOPQRSTUVWXYZabc";
-    expect(stripPrivateData(input)).toBe("[REDACTED_SECRET]");
-    expect(stripPrivateData(input)).toBe("[REDACTED_SECRET]");
-    expect(stripPrivateData(input)).toBe("[REDACTED_SECRET]");
-  });
-});

package/test/profile.test.ts

@@ -1,161 +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 { registerProfileFunction } from "../src/functions/profile.js";
-import type {
-  CompressedObservation,
-  Session,
-  ProjectProfile,
-} 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("Profile Function", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(async () => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerProfileFunction(sdk as never, kv as never);
-
-    const session: Session = {
-      id: "ses_1",
-      project: "my-project",
-      cwd: "/tmp/my-project",
-      startedAt: "2026-02-01T00:00:00Z",
-      status: "completed",
-      observationCount: 3,
-    };
-    await kv.set("mem:sessions", "ses_1", session);
-
-    const obs1: CompressedObservation = {
-      id: "obs_1",
-      sessionId: "ses_1",
-      timestamp: "2026-02-01T10:00:00Z",
-      type: "file_edit",
-      title: "Edit auth module",
-      facts: [],
-      narrative: "Auth changes",
-      concepts: ["typescript", "authentication"],
-      files: ["/project/src/auth.ts", "/project/src/middleware.ts"],
-      importance: 8,
-    };
-    const obs2: CompressedObservation = {
-      id: "obs_2",
-      sessionId: "ses_1",
-      timestamp: "2026-02-01T11:00:00Z",
-      type: "file_edit",
-      title: "Update database",
-      facts: [],
-      narrative: "DB changes",
-      concepts: ["typescript", "database"],
-      files: ["/project/src/db.ts"],
-      importance: 6,
-    };
-    const obs3: CompressedObservation = {
-      id: "obs_3",
-      sessionId: "ses_1",
-      timestamp: "2026-02-01T12:00:00Z",
-      type: "error",
-      title: "Connection timeout",
-      facts: [],
-      narrative: "Error occurred",
-      concepts: ["error"],
-      files: ["/project/src/db.ts"],
-      importance: 4,
-    };
-
-    await kv.set("mem:obs:ses_1", "obs_1", obs1);
-    await kv.set("mem:obs:ses_1", "obs_2", obs2);
-    await kv.set("mem:obs:ses_1", "obs_3", obs3);
-  });
-
-  it("generates profile with topConcepts sorted by frequency", async () => {
-    const result = (await sdk.trigger("mem::profile", {
-      project: "my-project",
-    })) as { profile: ProjectProfile; cached: boolean };
-
-    expect(result.cached).toBe(false);
-    expect(result.profile.topConcepts[0].concept).toBe("typescript");
-    expect(result.profile.topConcepts[0].frequency).toBe(2);
-  });
-
-  it("generates profile with topFiles sorted by frequency", async () => {
-    const result = (await sdk.trigger("mem::profile", {
-      project: "my-project",
-    })) as { profile: ProjectProfile };
-
-    expect(result.profile.topFiles[0].file).toBe("/project/src/db.ts");
-    expect(result.profile.topFiles[0].frequency).toBe(2);
-  });
-
-  it("extracts conventions from file patterns", async () => {
-    const result = (await sdk.trigger("mem::profile", {
-      project: "my-project",
-    })) as { profile: ProjectProfile };
-
-    expect(result.profile.conventions).toContain("TypeScript project");
-    expect(result.profile.conventions).toContain(
-      "Standard src/ directory structure",
-    );
-  });
-
-  it("returns cached profile if fresh", async () => {
-    await sdk.trigger("mem::profile", { project: "my-project" });
-
-    const result = (await sdk.trigger("mem::profile", {
-      project: "my-project",
-    })) as { profile: ProjectProfile; cached: boolean };
-
-    expect(result.cached).toBe(true);
-  });
-
-  it("returns null profile for unknown project", async () => {
-    const result = (await sdk.trigger("mem::profile", {
-      project: "nonexistent",
-    })) as { profile: null; reason: string };
-
-    expect(result.profile).toBeNull();
-    expect(result.reason).toBe("no_sessions");
-  });
-});

package/test/query-expansion.test.ts

@@ -1,154 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import type { MemoryProvider } from "../src/types.js";
-
-vi.mock("iii-sdk", () => ({
-  getContext: () => ({
-    logger: {
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-    },
-  }),
-}));
-
-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;
-    },
-  };
-}
-
-describe("QueryExpansion", () => {
-  it("imports without errors", async () => {
-    const mod = await import("../src/functions/query-expansion.js");
-    expect(mod.registerQueryExpansionFunction).toBeDefined();
-    expect(mod.extractEntitiesFromQuery).toBeDefined();
-  });
-
-  it("extracts entities from capitalized words", async () => {
-    const { extractEntitiesFromQuery } = await import(
-      "../src/functions/query-expansion.js"
-    );
-    const entities = extractEntitiesFromQuery(
-      'What happened with React and the Vue migration?',
-    );
-    expect(entities).toContain("React");
-    expect(entities).toContain("Vue");
-    expect(entities).not.toContain("What");
-  });
-
-  it("extracts quoted entities", async () => {
-    const { extractEntitiesFromQuery } = await import(
-      "../src/functions/query-expansion.js"
-    );
-    const entities = extractEntitiesFromQuery(
-      'Find memories about "auth middleware" changes',
-    );
-    expect(entities).toContain("auth middleware");
-  });
-
-  it("expands queries via LLM", async () => {
-    const { registerQueryExpansionFunction } = await import(
-      "../src/functions/query-expansion.js"
-    );
-
-    const response = `<expansion>
-  <reformulations>
-    <query>Authentication middleware modifications</query>
-    <query>JWT token validation changes</query>
-    <query>Security layer updates</query>
-  </reformulations>
-  <temporal>
-    <query>Auth changes in the past 7 days</query>
-  </temporal>
-  <entities>
-    <entity>auth middleware</entity>
-    <entity>JWT</entity>
-  </entities>
-</expansion>`;
-
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn().mockResolvedValue(response),
-      summarize: vi.fn().mockResolvedValue(response),
-    };
-
-    const sdk = mockSdk();
-    registerQueryExpansionFunction(sdk as never, provider);
-
-    const result = (await sdk.trigger("mem::expand-query", {
-      query: "What changed in auth?",
-    })) as { success: boolean; expansion: any };
-
-    expect(result.success).toBe(true);
-    expect(result.expansion.original).toBe("What changed in auth?");
-    expect(result.expansion.reformulations.length).toBe(3);
-    expect(result.expansion.entityExtractions).toContain("auth middleware");
-    expect(result.expansion.temporalConcretizations.length).toBe(1);
-  });
-
-  it("returns empty expansion on LLM failure", async () => {
-    const { registerQueryExpansionFunction } = await import(
-      "../src/functions/query-expansion.js"
-    );
-
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn().mockRejectedValue(new Error("LLM down")),
-      summarize: vi.fn().mockRejectedValue(new Error("LLM down")),
-    };
-
-    const sdk = mockSdk();
-    registerQueryExpansionFunction(sdk as never, provider);
-
-    const result = (await sdk.trigger("mem::expand-query", {
-      query: "test query",
-    })) as { success: boolean; expansion: any };
-
-    expect(result.success).toBe(true);
-    expect(result.expansion.original).toBe("test query");
-    expect(result.expansion.reformulations).toEqual([]);
-  });
-
-  it("respects maxReformulations limit", async () => {
-    const { registerQueryExpansionFunction } = await import(
-      "../src/functions/query-expansion.js"
-    );
-
-    const response = `<expansion>
-  <reformulations>
-    <query>Query A</query>
-    <query>Query B</query>
-    <query>Query C</query>
-    <query>Query D</query>
-    <query>Query E</query>
-    <query>Query F</query>
-  </reformulations>
-  <temporal></temporal>
-  <entities></entities>
-</expansion>`;
-
-    const provider: MemoryProvider = {
-      name: "test",
-      compress: vi.fn().mockResolvedValue(response),
-      summarize: vi.fn().mockResolvedValue(response),
-    };
-
-    const sdk = mockSdk();
-    registerQueryExpansionFunction(sdk as never, provider);
-
-    const result = (await sdk.trigger("mem::expand-query", {
-      query: "test",
-      maxReformulations: 3,
-    })) as { success: boolean; expansion: any };
-
-    expect(result.expansion.reformulations.length).toBe(3);
-  });
-});

package/test/relations.test.ts

@@ -1,198 +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 { registerRelationsFunction } from "../src/functions/relations.js";
-import type { 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>();
-  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);
-    },
-    getFunction: (id: string) => functions.get(id),
-  };
-}
-
-function makeMemory(overrides: Partial<Memory> = {}): Memory {
-  return {
-    id: "mem_1",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    type: "pattern",
-    title: "Test memory",
-    content: "This is a test memory",
-    concepts: ["test"],
-    files: [],
-    sessionIds: ["ses_1"],
-    strength: 5,
-    version: 1,
-    isLatest: true,
-    ...overrides,
-  };
-}
-
-describe("Relations Functions", () => {
-  let sdk: ReturnType<typeof mockSdk>;
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    sdk = mockSdk();
-    kv = mockKV();
-    registerRelationsFunction(sdk as never, kv as never);
-  });
-
-  describe("mem::relate", () => {
-    it("creates a relation between two memories", async () => {
-      const mem1 = makeMemory({ id: "mem_1" });
-      const mem2 = makeMemory({ id: "mem_2" });
-      await kv.set("mem:memories", "mem_1", mem1);
-      await kv.set("mem:memories", "mem_2", mem2);
-
-      const result = await sdk.trigger("mem::relate", {
-        sourceId: "mem_1",
-        targetId: "mem_2",
-        type: "related",
-      });
-
-      expect((result as { success: boolean }).success).toBe(true);
-
-      const updated1 = await kv.get<Memory>("mem:memories", "mem_1");
-      const updated2 = await kv.get<Memory>("mem:memories", "mem_2");
-      expect(updated1!.relatedIds).toContain("mem_2");
-      expect(updated2!.relatedIds).toContain("mem_1");
-    });
-
-    it("returns error when source memory not found", async () => {
-      const mem2 = makeMemory({ id: "mem_2" });
-      await kv.set("mem:memories", "mem_2", mem2);
-
-      const result = await sdk.trigger("mem::relate", {
-        sourceId: "mem_missing",
-        targetId: "mem_2",
-        type: "related",
-      });
-
-      expect((result as { success: boolean }).success).toBe(false);
-    });
-
-    it("does not duplicate relatedIds on repeated calls", async () => {
-      const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2"] });
-      const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });
-      await kv.set("mem:memories", "mem_1", mem1);
-      await kv.set("mem:memories", "mem_2", mem2);
-
-      await sdk.trigger("mem::relate", {
-        sourceId: "mem_1",
-        targetId: "mem_2",
-        type: "related",
-      });
-
-      const updated1 = await kv.get<Memory>("mem:memories", "mem_1");
-      expect(updated1!.relatedIds!.filter((id) => id === "mem_2").length).toBe(1);
-    });
-  });
-
-  describe("mem::evolve", () => {
-    it("marks old memory as not latest and creates new version", async () => {
-      const original = makeMemory({ id: "mem_old", version: 1 });
-      await kv.set("mem:memories", "mem_old", original);
-
-      const result = (await sdk.trigger("mem::evolve", {
-        memoryId: "mem_old",
-        newContent: "Updated content",
-        newTitle: "Updated title",
-      })) as { success: boolean; memory: Memory; previousId: string };
-
-      expect(result.success).toBe(true);
-      expect(result.memory.version).toBe(2);
-      expect(result.memory.content).toBe("Updated content");
-      expect(result.memory.title).toBe("Updated title");
-      expect(result.memory.parentId).toBe("mem_old");
-      expect(result.memory.isLatest).toBe(true);
-
-      const old = await kv.get<Memory>("mem:memories", "mem_old");
-      expect(old!.isLatest).toBe(false);
-    });
-
-    it("returns error when memory not found", async () => {
-      const result = await sdk.trigger("mem::evolve", {
-        memoryId: "mem_missing",
-        newContent: "Updated content",
-      });
-
-      expect((result as { success: boolean }).success).toBe(false);
-    });
-  });
-
-  describe("mem::get-related", () => {
-    it("retrieves related memories within 1 hop", async () => {
-      const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2"] });
-      const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1", "mem_3"] });
-      const mem3 = makeMemory({ id: "mem_3", relatedIds: ["mem_2"] });
-      await kv.set("mem:memories", "mem_1", mem1);
-      await kv.set("mem:memories", "mem_2", mem2);
-      await kv.set("mem:memories", "mem_3", mem3);
-
-      const result = (await sdk.trigger("mem::get-related", {
-        memoryId: "mem_1",
-        maxHops: 1,
-      })) as { results: Array<{ memory: Memory; hop: number }> };
-
-      expect(result.results.length).toBe(1);
-      expect(result.results[0].memory.id).toBe("mem_2");
-      expect(result.results[0].hop).toBe(1);
-    });
-
-    it("retrieves related memories within 2 hops", async () => {
-      const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2"] });
-      const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1", "mem_3"] });
-      const mem3 = makeMemory({ id: "mem_3", relatedIds: ["mem_2"] });
-      await kv.set("mem:memories", "mem_1", mem1);
-      await kv.set("mem:memories", "mem_2", mem2);
-      await kv.set("mem:memories", "mem_3", mem3);
-
-      const result = (await sdk.trigger("mem::get-related", {
-        memoryId: "mem_1",
-        maxHops: 2,
-      })) as { results: Array<{ memory: Memory; hop: number }> };
-
-      expect(result.results.length).toBe(2);
-      const ids = result.results.map((r) => r.memory.id);
-      expect(ids).toContain("mem_2");
-      expect(ids).toContain("mem_3");
-    });
-  });
-});