@agentmemory/agentmemory 0.7.0

package/test/enrich.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+  getContext: () => ({
+    logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+  }),
+}));
+
+import { registerEnrichFunction } from "../src/functions/enrich.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 makeMemory(overrides: Partial<Memory> = {}): Memory {
+  return {
+    id: "mem_1",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    type: "bug",
+    title: "Known bug",
+    content: "Null pointer in handler",
+    concepts: ["bug"],
+    files: ["src/handler.ts"],
+    sessionIds: ["ses_1"],
+    strength: 5,
+    version: 1,
+    isLatest: true,
+    ...overrides,
+  };
+}
+
+function mockSdk() {
+  const functions = new Map<string, Function>();
+  const triggerOverrides = new Map<string, Function>();
+  return {
+    registerFunction: (opts: { id: string }, handler: Function) => {
+      functions.set(opts.id, handler);
+    },
+    registerTrigger: () => {},
+    trigger: async (id: string, data: unknown) => {
+      if (triggerOverrides.has(id)) {
+        return triggerOverrides.get(id)!(data);
+      }
+      const fn = functions.get(id);
+      if (!fn) throw new Error(`No function: ${id}`);
+      return fn(data);
+    },
+    overrideTrigger: (id: string, handler: Function) => {
+      triggerOverrides.set(id, handler);
+    },
+    getFunction: (id: string) => functions.get(id),
+  };
+}
+
+describe("Enrich Function", () => {
+  let sdk: ReturnType<typeof mockSdk>;
+  let kv: ReturnType<typeof mockKV>;
+
+  beforeEach(() => {
+    sdk = mockSdk();
+    kv = mockKV();
+    registerEnrichFunction(sdk as never, kv as never);
+  });
+
+  it("returns file context and relevant memories", async () => {
+    sdk.overrideTrigger(
+      "mem::file-context",
+      async () => ({ context: "File was edited in session ses_1" }),
+    );
+    sdk.overrideTrigger("mem::search", async () => ({
+      results: [
+        { observation: { narrative: "User fixed a bug in handler" } },
+      ],
+    }));
+
+    const bugMem = makeMemory({
+      id: "bug_1",
+      files: ["src/handler.ts"],
+      type: "bug",
+    });
+    await kv.set("mem:memories", "bug_1", bugMem);
+
+    const result = (await sdk.trigger("mem::enrich", {
+      sessionId: "ses_1",
+      files: ["src/handler.ts"],
+    })) as { context: string; truncated: boolean };
+
+    expect(result.context).toContain("File was edited in session ses_1");
+    expect(result.context).toContain("agentmemory-relevant-context");
+    expect(result.context).toContain("agentmemory-past-errors");
+    expect(result.truncated).toBe(false);
+  });
+
+  it("extracts terms from Grep/Glob pattern for search", async () => {
+    let capturedQuery = "";
+    sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));
+    sdk.overrideTrigger("mem::search", async (data: any) => {
+      capturedQuery = data.query;
+      return { results: [] };
+    });
+
+    await sdk.trigger("mem::enrich", {
+      sessionId: "ses_1",
+      files: ["src/utils.ts"],
+      terms: ["handleError"],
+      toolName: "Grep",
+    });
+
+    expect(capturedQuery).toContain("handleError");
+  });
+
+  it("truncates context at 4000 chars", async () => {
+    const longContext = "x".repeat(5000);
+    sdk.overrideTrigger(
+      "mem::file-context",
+      async () => ({ context: longContext }),
+    );
+    sdk.overrideTrigger("mem::search", async () => ({ results: [] }));
+
+    const result = (await sdk.trigger("mem::enrich", {
+      sessionId: "ses_1",
+      files: ["src/big.ts"],
+    })) as { context: string; truncated: boolean };
+
+    expect(result.context.length).toBe(4000);
+    expect(result.truncated).toBe(true);
+  });
+
+  it("returns empty context when no data found", async () => {
+    sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));
+    sdk.overrideTrigger("mem::search", async () => ({ results: [] }));
+
+    const result = (await sdk.trigger("mem::enrich", {
+      sessionId: "ses_1",
+      files: ["src/new-file.ts"],
+    })) as { context: string; truncated: boolean };
+
+    expect(result.context).toBe("");
+    expect(result.truncated).toBe(false);
+  });
+
+  it("handles failed triggers without crashing", async () => {
+    sdk.overrideTrigger("mem::file-context", async () => {
+      throw new Error("file-context failed");
+    });
+    sdk.overrideTrigger("mem::search", async () => {
+      throw new Error("search failed");
+    });
+
+    const result = (await sdk.trigger("mem::enrich", {
+      sessionId: "ses_1",
+      files: ["src/handler.ts"],
+    })) as { context: string; truncated: boolean };
+
+    expect(result.context).toBeDefined();
+    expect(result.truncated).toBe(false);
+  });
+
+  it("includes bug memories that overlap with requested files", async () => {
+    sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));
+    sdk.overrideTrigger("mem::search", async () => ({ results: [] }));
+
+    const bugMem = makeMemory({
+      id: "bug_match",
+      type: "bug",
+      title: "Race condition",
+      content: "Race condition in worker pool",
+      files: ["src/worker.ts"],
+      isLatest: true,
+    });
+    const nonBugMem = makeMemory({
+      id: "pattern_1",
+      type: "pattern",
+      title: "Code pattern",
+      content: "Singleton pattern used",
+      files: ["src/worker.ts"],
+      isLatest: true,
+    });
+    await kv.set("mem:memories", "bug_match", bugMem);
+    await kv.set("mem:memories", "pattern_1", nonBugMem);
+
+    const result = (await sdk.trigger("mem::enrich", {
+      sessionId: "ses_1",
+      files: ["src/worker.ts"],
+    })) as { context: string; truncated: boolean };
+
+    expect(result.context).toContain("Race condition");
+    expect(result.context).not.toContain("Singleton pattern");
+  });
+});

package/test/eval.test.ts

@@ -0,0 +1,300 @@
+import { describe, it, expect } from "vitest";
+import {
+  ObserveInputSchema,
+  CompressOutputSchema,
+  SummaryOutputSchema,
+  SearchInputSchema,
+  ContextInputSchema,
+  RememberInputSchema,
+} from "../src/eval/schemas.js";
+import { validateInput, validateOutput } from "../src/eval/validator.js";
+import {
+  scoreCompression,
+  scoreSummary,
+  scoreContextRelevance,
+} from "../src/eval/quality.js";
+
+describe("Zod Schemas", () => {
+  describe("ObserveInputSchema", () => {
+    it("accepts valid input", () => {
+      const result = ObserveInputSchema.safeParse({
+        hookType: "post_tool_use",
+        sessionId: "ses_abc",
+        project: "my-project",
+        cwd: "/home/user",
+        timestamp: "2026-01-01T00:00:00Z",
+        data: { tool_name: "Read" },
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("rejects missing sessionId", () => {
+      const result = ObserveInputSchema.safeParse({
+        hookType: "post_tool_use",
+        project: "my-project",
+        cwd: "/home/user",
+        timestamp: "2026-01-01T00:00:00Z",
+        data: {},
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects invalid hookType", () => {
+      const result = ObserveInputSchema.safeParse({
+        hookType: "invalid_hook",
+        sessionId: "ses_abc",
+        project: "my-project",
+        cwd: "/home/user",
+        timestamp: "2026-01-01T00:00:00Z",
+        data: {},
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("CompressOutputSchema", () => {
+    it("accepts valid output", () => {
+      const result = CompressOutputSchema.safeParse({
+        type: "file_edit",
+        title: "Edit auth module",
+        facts: ["Added JWT validation"],
+        narrative: "Modified the auth middleware to validate tokens",
+        concepts: ["auth"],
+        files: ["src/auth.ts"],
+        importance: 7,
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("rejects empty facts array", () => {
+      const result = CompressOutputSchema.safeParse({
+        type: "file_edit",
+        title: "Edit auth module",
+        facts: [],
+        narrative: "Modified the auth middleware to validate tokens",
+        concepts: [],
+        files: [],
+        importance: 5,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects title over 120 chars", () => {
+      const result = CompressOutputSchema.safeParse({
+        type: "file_edit",
+        title: "x".repeat(121),
+        facts: ["fact"],
+        narrative: "A narrative that is long enough",
+        concepts: [],
+        files: [],
+        importance: 5,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects importance outside 1-10", () => {
+      const result = CompressOutputSchema.safeParse({
+        type: "file_edit",
+        title: "Test",
+        facts: ["fact"],
+        narrative: "A valid narrative here",
+        concepts: [],
+        files: [],
+        importance: 11,
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it("rejects narrative under 10 chars", () => {
+      const result = CompressOutputSchema.safeParse({
+        type: "file_edit",
+        title: "Test",
+        facts: ["fact"],
+        narrative: "short",
+        concepts: [],
+        files: [],
+        importance: 5,
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("SummaryOutputSchema", () => {
+    it("accepts valid summary", () => {
+      const result = SummaryOutputSchema.safeParse({
+        title: "Session Summary",
+        narrative: "This session focused on implementing authentication features and fixing bugs",
+        keyDecisions: ["Use JWT"],
+        filesModified: ["auth.ts"],
+        concepts: ["auth"],
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("rejects short narrative", () => {
+      const result = SummaryOutputSchema.safeParse({
+        title: "Summary",
+        narrative: "Too short",
+        keyDecisions: [],
+        filesModified: [],
+        concepts: [],
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("SearchInputSchema", () => {
+    it("accepts valid search", () => {
+      expect(SearchInputSchema.safeParse({ query: "auth" }).success).toBe(true);
+    });
+
+    it("accepts search with limit", () => {
+      expect(
+        SearchInputSchema.safeParse({ query: "auth", limit: 10 }).success,
+      ).toBe(true);
+    });
+
+    it("rejects empty query", () => {
+      expect(SearchInputSchema.safeParse({ query: "" }).success).toBe(false);
+    });
+  });
+
+  describe("ContextInputSchema", () => {
+    it("accepts valid input", () => {
+      expect(
+        ContextInputSchema.safeParse({
+          sessionId: "ses_1",
+          project: "proj",
+        }).success,
+      ).toBe(true);
+    });
+  });
+
+  describe("RememberInputSchema", () => {
+    it("accepts valid input", () => {
+      expect(
+        RememberInputSchema.safeParse({
+          content: "Always use TypeScript",
+          type: "preference",
+        }).success,
+      ).toBe(true);
+    });
+
+    it("rejects empty content", () => {
+      expect(
+        RememberInputSchema.safeParse({ content: "" }).success,
+      ).toBe(false);
+    });
+  });
+});
+
+describe("Validator", () => {
+  it("returns valid with correct data", () => {
+    const result = validateInput(SearchInputSchema, { query: "test" }, "search");
+    expect(result.valid).toBe(true);
+    if (result.valid) {
+      expect(result.data.query).toBe("test");
+    }
+  });
+
+  it("returns invalid with error details", () => {
+    const result = validateInput(SearchInputSchema, { query: "" }, "search");
+    expect(result.valid).toBe(false);
+    if (!result.valid) {
+      expect(result.result.functionId).toBe("search");
+      expect(result.result.errors.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("validateOutput works same as validateInput", () => {
+    const result = validateOutput(
+      CompressOutputSchema,
+      {
+        type: "file_edit",
+        title: "Test",
+        facts: ["a"],
+        narrative: "A long enough narrative",
+        concepts: [],
+        files: [],
+        importance: 5,
+      },
+      "compress",
+    );
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe("Quality Scoring", () => {
+  describe("scoreCompression", () => {
+    it("returns 0 for empty object", () => {
+      expect(scoreCompression({})).toBe(0);
+    });
+
+    it("returns 100 for perfect observation", () => {
+      const score = scoreCompression({
+        type: "file_edit",
+        title: "A good title",
+        facts: ["fact 1", "fact 2", "fact 3"],
+        narrative: "A narrative that is definitely more than fifty characters long and provides good context",
+        concepts: ["auth", "jwt"],
+        importance: 7,
+      });
+      expect(score).toBe(100);
+    });
+
+    it("scores partial observations between 0 and 100", () => {
+      const score = scoreCompression({
+        title: "Test",
+        facts: ["one"],
+        narrative: "Short but valid narrative",
+      });
+      expect(score).toBeGreaterThan(0);
+      expect(score).toBeLessThan(100);
+    });
+  });
+
+  describe("scoreSummary", () => {
+    it("returns 0 for empty object", () => {
+      expect(scoreSummary({})).toBe(0);
+    });
+
+    it("returns high score for complete summary", () => {
+      const score = scoreSummary({
+        title: "Session Summary Title",
+        narrative:
+          "This is a detailed narrative about what happened during the session with enough content to be meaningful and complete for review purposes",
+        keyDecisions: ["Used JWT for auth", "Chose PostgreSQL"],
+        filesModified: ["src/auth.ts", "src/db.ts"],
+        concepts: ["authentication", "database"],
+      });
+      expect(score).toBeGreaterThanOrEqual(90);
+    });
+  });
+
+  describe("scoreContextRelevance", () => {
+    it("returns 0 for empty context", () => {
+      expect(scoreContextRelevance("", "proj")).toBe(0);
+    });
+
+    it("scores higher when project is mentioned", () => {
+      const withProject = scoreContextRelevance(
+        "<context>This is for my-project with details</context>",
+        "my-project",
+      );
+      const without = scoreContextRelevance(
+        "<context>Some generic context details</context>",
+        "my-project",
+      );
+      expect(withProject).toBeGreaterThan(without);
+    });
+
+    it("scores higher with more XML sections", () => {
+      const multi = scoreContextRelevance(
+        "<summary>A</summary><observations>B</observations><memories>C</memories><patterns>D</patterns>",
+        "test",
+      );
+      const single = scoreContextRelevance("<summary>A</summary>", "test");
+      expect(multi).toBeGreaterThan(single);
+    });
+  });
+});