@agentmemory/agentmemory 0.7.0 → 0.7.3

package/test/index-persistence.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { IndexPersistence } from "../src/state/index-persistence.js";
-import { SearchIndex } from "../src/state/search-index.js";
-import { VectorIndex } from "../src/state/vector-index.js";
-import type { CompressedObservation } 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 makeObs(
-  overrides: Partial<CompressedObservation> = {},
-): CompressedObservation {
-  return {
-    id: "obs_1",
-    sessionId: "ses_1",
-    timestamp: new Date().toISOString(),
-    type: "file_edit",
-    title: "Edit auth middleware",
-    subtitle: "JWT validation",
-    facts: ["Added token check"],
-    narrative: "Modified the auth middleware to validate JWT tokens",
-    concepts: ["authentication", "jwt"],
-    files: ["src/middleware/auth.ts"],
-    importance: 7,
-    ...overrides,
-  };
-}
-
-describe("IndexPersistence", () => {
-  let kv: ReturnType<typeof mockKV>;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    kv = mockKV();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("saves and loads BM25 index round-trip", async () => {
-    const bm25 = new SearchIndex();
-    bm25.add(makeObs({ id: "obs_1", title: "auth handler" }));
-
-    const persistence = new IndexPersistence(kv as never, bm25, null);
-    await persistence.save();
-
-    const loaded = await persistence.load();
-    expect(loaded.bm25).not.toBeNull();
-    expect(loaded.bm25!.size).toBe(1);
-    const results = loaded.bm25!.search("auth");
-    expect(results.length).toBe(1);
-  });
-
-  it("saves and loads vector index round-trip", async () => {
-    const bm25 = new SearchIndex();
-    const vector = new VectorIndex();
-    vector.add("obs_1", "ses_1", new Float32Array([0.1, 0.2, 0.3]));
-
-    const persistence = new IndexPersistence(kv as never, bm25, vector);
-    await persistence.save();
-
-    const loaded = await persistence.load();
-    expect(loaded.vector).not.toBeNull();
-    expect(loaded.vector!.size).toBe(1);
-  });
-
-  it("scheduleSave debounces multiple calls", async () => {
-    const bm25 = new SearchIndex();
-    const persistence = new IndexPersistence(kv as never, bm25, null);
-
-    persistence.scheduleSave();
-    persistence.scheduleSave();
-    persistence.scheduleSave();
-
-    await expect(kv.get("mem:index:bm25", "data")).resolves.toBeNull();
-
-    vi.advanceTimersByTime(5000);
-    await vi.runAllTimersAsync();
-
-    const saved = await kv.get<string>("mem:index:bm25", "data");
-    expect(saved).not.toBeNull();
-  });
-
-  it("stop clears the pending timer", async () => {
-    const bm25 = new SearchIndex();
-    bm25.add(makeObs({ id: "obs_1", title: "auth handler" }));
-    const persistence = new IndexPersistence(kv as never, bm25, null);
-
-    persistence.scheduleSave();
-    persistence.stop();
-
-    vi.advanceTimersByTime(10000);
-    const saved = await kv.get<string>("mem:index:bm25", "data");
-    expect(saved).toBeNull();
-  });
-
-  it("returns null indexes when nothing has been saved", async () => {
-    const bm25 = new SearchIndex();
-    const persistence = new IndexPersistence(kv as never, bm25, null);
-
-    const loaded = await persistence.load();
-    expect(loaded.bm25).toBeNull();
-    expect(loaded.vector).toBeNull();
-  });
-});

package/test/integration.test.ts

@@ -1,265 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-
-const BASE_URL = process.env["AGENTMEMORY_URL"] || "http://localhost:3111";
-const SECRET = process.env["AGENTMEMORY_SECRET"] || "";
-
-const SESSION_ID = `test_${Date.now()}`;
-const PROJECT = "/tmp/test-project";
-
-function url(path: string): string {
-  return `${BASE_URL}${path}`;
-}
-
-function authHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
-  if (SECRET) {
-    headers["Authorization"] = `Bearer ${SECRET}`;
-  }
-  return headers;
-}
-
-async function json(res: Response): Promise<unknown> {
-  const text = await res.text();
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-describe("agentmemory integration", () => {
-  beforeAll(async () => {
-    const res = await fetch(url("/agentmemory/health")).catch(() => null);
-    if (!res || !res.ok) {
-      throw new Error(
-        `agentmemory is not running at ${BASE_URL}. Start it with: docker compose up -d && npm start`,
-      );
-    }
-  });
-
-  describe("health", () => {
-    it("returns ok", async () => {
-      const res = await fetch(url("/agentmemory/health"));
-      expect(res.status).toBe(200);
-      const body = (await json(res)) as { status: string; service: string };
-      expect(["ok", "healthy"]).toContain(body.status);
-      expect(body.service).toBe("agentmemory");
-    });
-  });
-
-  describe("session lifecycle", () => {
-    it("starts a session", async () => {
-      const res = await fetch(url("/agentmemory/session/start"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({
-          sessionId: SESSION_ID,
-          project: PROJECT,
-          cwd: PROJECT,
-        }),
-      });
-      expect(res.status).toBe(200);
-      const body = (await json(res)) as {
-        session: { id: string; status: string };
-        context: string;
-      };
-      expect(body.session.id).toBe(SESSION_ID);
-      expect(body.session.status).toBe("active");
-      expect(typeof body.context).toBe("string");
-    });
-
-    it("lists sessions including the new one", async () => {
-      const res = await fetch(url("/agentmemory/sessions"));
-      expect(res.status).toBe(200);
-      const body = (await json(res)) as {
-        sessions: Array<{ id: string }>;
-      };
-      expect(Array.isArray(body.sessions)).toBe(true);
-      const found = body.sessions.find((s) => s.id === SESSION_ID);
-      expect(found).toBeDefined();
-    });
-
-    it("ends the session", async () => {
-      const res = await fetch(url("/agentmemory/session/end"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({ sessionId: SESSION_ID }),
-      });
-      expect(res.status).toBe(200);
-      const body = (await json(res)) as { success: boolean };
-      expect(body.success).toBe(true);
-    });
-
-    it("session is marked completed", async () => {
-      const res = await fetch(url("/agentmemory/sessions"));
-      const body = (await json(res)) as {
-        sessions: Array<{ id: string; status: string; endedAt?: string }>;
-      };
-      const session = body.sessions.find((s) => s.id === SESSION_ID);
-      expect(session).toBeDefined();
-      expect(session!.status).toBe("completed");
-      expect(session!.endedAt).toBeDefined();
-    });
-  });
-
-  describe("observations", () => {
-    const OBS_SESSION = `test_obs_${Date.now()}`;
-
-    beforeAll(async () => {
-      await fetch(url("/agentmemory/session/start"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({
-          sessionId: OBS_SESSION,
-          project: PROJECT,
-          cwd: PROJECT,
-        }),
-      });
-    });
-
-    afterAll(async () => {
-      await fetch(url("/agentmemory/session/end"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({ sessionId: OBS_SESSION }),
-      });
-    });
-
-    it("captures an observation", async () => {
-      const res = await fetch(url("/agentmemory/observe"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({
-          hookType: "post_tool_use",
-          sessionId: OBS_SESSION,
-          project: PROJECT,
-          cwd: PROJECT,
-          timestamp: new Date().toISOString(),
-          data: {
-            tool: "Edit",
-            file: "src/auth.ts",
-            content: "Added JWT token validation middleware",
-          },
-        }),
-      });
-      expect(res.status).toBe(201);
-    });
-
-    it("captures a second observation", async () => {
-      const res = await fetch(url("/agentmemory/observe"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({
-          hookType: "post_tool_use",
-          sessionId: OBS_SESSION,
-          project: PROJECT,
-          cwd: PROJECT,
-          timestamp: new Date().toISOString(),
-          data: {
-            tool: "Bash",
-            command: "npm test",
-            output: "Tests: 12 passed, 0 failed",
-          },
-        }),
-      });
-      expect(res.status).toBe(201);
-    });
-
-    it("lists observations for the session", async () => {
-      const res = await fetch(
-        url(`/agentmemory/observations?sessionId=${OBS_SESSION}`),
-      );
-      expect(res.status).toBe(200);
-      const body = (await json(res)) as {
-        observations: Array<{ id: string; sessionId: string }>;
-      };
-      expect(Array.isArray(body.observations)).toBe(true);
-    });
-
-    it("returns 400 without sessionId", async () => {
-      const res = await fetch(url("/agentmemory/observations"));
-      expect(res.status).toBe(400);
-      const body = (await json(res)) as { error: string };
-      expect(body.error).toBe("sessionId required");
-    });
-  });
-
-  describe("search", () => {
-    it("searches observations", async () => {
-      const res = await fetch(url("/agentmemory/search"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({ query: "auth", limit: 5 }),
-      });
-      expect(res.status).toBe(200);
-      const body = await json(res);
-      expect(body).toBeDefined();
-    });
-
-    it("returns results for empty limit", async () => {
-      const res = await fetch(url("/agentmemory/search"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({ query: "test" }),
-      });
-      expect(res.status).toBe(200);
-    });
-  });
-
-  describe("context", () => {
-    it("generates context for a project", async () => {
-      const res = await fetch(url("/agentmemory/context"), {
-        method: "POST",
-        headers: authHeaders(),
-        body: JSON.stringify({
-          sessionId: "ctx-test",
-          project: PROJECT,
-        }),
-      });
-      expect(res.status).toBe(200);
-      const body = (await json(res)) as { context: string };
-      expect(typeof body.context).toBe("string");
-    });
-  });
-
-  describe("viewer", () => {
-    it("serves the viewer HTML", async () => {
-      const res = await fetch(url("/agentmemory/viewer"));
-      expect(res.status).toBe(200);
-      const body = await res.text();
-      expect(body).toContain("html");
-    });
-  });
-
-  describe("auth", () => {
-    it("health endpoint is always public", async () => {
-      const res = await fetch(url("/agentmemory/health"));
-      expect(res.status).toBe(200);
-    });
-
-    if (SECRET) {
-      it("rejects unauthenticated requests", async () => {
-        const res = await fetch(url("/agentmemory/search"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ query: "test" }),
-        });
-        expect(res.status).toBe(401);
-      });
-
-      it("rejects wrong bearer token", async () => {
-        const res = await fetch(url("/agentmemory/search"), {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: "Bearer wrong-token",
-          },
-          body: JSON.stringify({ query: "test" }),
-        });
-        expect(res.status).toBe(401);
-      });
-    }
-  });
-});