chore: import upstream snapshot with attribution

test/integration.test.ts

@@ -0,0 +1,301 @@
+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"), {
+        headers: SECRET ? authHeaders() : undefined,
+      });
+      expect(res.status).toBe(200);
+      const body = await res.text();
+      expect(body).toContain("html");
+    });
+  });
+
+  describe("dashboard list endpoints", () => {
+    it("GET /semantic returns { semantic: [...] }", async () => {
+      const res = await fetch(url("/agentmemory/semantic"), {
+        headers: SECRET ? authHeaders() : undefined,
+      });
+      expect(res.status).toBe(200);
+      const body = (await json(res)) as { semantic: unknown[] };
+      expect(Array.isArray(body.semantic)).toBe(true);
+    });
+
+    it("GET /procedural returns { procedural: [...] }", async () => {
+      const res = await fetch(url("/agentmemory/procedural"), {
+        headers: SECRET ? authHeaders() : undefined,
+      });
+      expect(res.status).toBe(200);
+      const body = (await json(res)) as { procedural: unknown[] };
+      expect(Array.isArray(body.procedural)).toBe(true);
+    });
+
+    it("GET /relations returns { relations: [...] }", async () => {
+      const res = await fetch(url("/agentmemory/relations"), {
+        headers: SECRET ? authHeaders() : undefined,
+      });
+      expect(res.status).toBe(200);
+      const body = (await json(res)) as { relations: unknown[] };
+      expect(Array.isArray(body.relations)).toBe(true);
+    });
+  });
+
+  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);
+      });
+
+      it("rejects unauthenticated viewer requests on the API port", async () => {
+        const res = await fetch(url("/agentmemory/viewer"));
+        expect(res.status).toBe(401);
+      });
+    }
+  });
+});