@agentmemory/agentmemory 0.7.2 → 0.7.3

package/test/enrich.test.ts

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

@@ -1,300 +0,0 @@
-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);
-    });
-  });
-});