@sesamespace/hivemind 0.2.0 → 0.3.0

package/packages/runtime/src/__tests__/fleet.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Integration tests for the worker protocol (Phase 3, Task 3.1).
+ *
+ * Spins up a real WorkerServer and exercises the PrimaryClient against it.
+ */
+
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { PrimaryClient } from "../fleet/primary-client.js";
+import { WorkerServer } from "../fleet/worker-server.js";
+import type {
+  WorkerRegistrationRequest,
+  WorkerHealthResponse,
+  WorkerStatusReport,
+} from "../fleet/worker-protocol.js";
+
+const TEST_PORT = 19876;
+const WORKER_URL = `http://localhost:${TEST_PORT}`;
+
+describe("Worker Protocol", () => {
+  let primary: PrimaryClient;
+  let worker: WorkerServer;
+  let workerId: string;
+
+  before(async () => {
+    worker = new WorkerServer({
+      workerId: "test-worker-1",
+      port: TEST_PORT,
+      maxContexts: 2,
+      memoryDaemonUrl: "http://localhost:9999",
+      ollamaUrl: "http://localhost:11434",
+    });
+    await worker.start();
+
+    primary = new PrimaryClient();
+  });
+
+  after(async () => {
+    primary.stopHealthPolling();
+    await worker.stop();
+  });
+
+  describe("Registration", () => {
+    it("should register a worker and return an ID", () => {
+      const req: WorkerRegistrationRequest = {
+        url: WORKER_URL,
+        capabilities: {
+          max_contexts: 2,
+          has_ollama: true,
+          has_memory_daemon: true,
+          available_models: ["nomic-embed-text"],
+        },
+      };
+
+      const resp = primary.handleRegistration(req);
+      workerId = resp.worker_id;
+
+      assert.ok(workerId.startsWith("worker-"));
+      assert.ok(resp.registered_at);
+    });
+
+    it("should list the registered worker", () => {
+      const workers = primary.getWorkers();
+      assert.equal(workers.length, 1);
+      assert.equal(workers[0].id, workerId);
+      assert.equal(workers[0].url, WORKER_URL);
+    });
+
+    it("should get a worker by ID", () => {
+      const w = primary.getWorker(workerId);
+      assert.ok(w);
+      assert.equal(w.id, workerId);
+    });
+  });
+
+  describe("Health Checks", () => {
+    it("should get a healthy response from worker", async () => {
+      const health = await primary.checkHealth(workerId);
+      assert.ok(health);
+      assert.equal(health.worker_id, "test-worker-1");
+      assert.equal(health.status, "healthy");
+      assert.ok(health.uptime_seconds >= 0);
+      assert.equal(health.memory_daemon_ok, true);
+      assert.equal(health.ollama_ok, true);
+    });
+
+    it("should return null for unknown worker", async () => {
+      const health = await primary.checkHealth("nonexistent");
+      assert.equal(health, null);
+    });
+
+    it("should poll all workers", async () => {
+      const results = await primary.checkAllHealth();
+      assert.equal(results.size, 1);
+      assert.equal(results.get(workerId), "healthy");
+    });
+  });
+
+  describe("Context Assignment", () => {
+    it("should assign a context to a worker", async () => {
+      const resp = await primary.assignContext(workerId, "project-alpha", "Alpha project");
+      assert.equal(resp.accepted, true);
+      assert.equal(resp.context_name, "project-alpha");
+    });
+
+    it("should track the assigned context on primary", () => {
+      const w = primary.getWorker(workerId);
+      assert.ok(w);
+      assert.ok(w.assigned_contexts.includes("project-alpha"));
+    });
+
+    it("should find worker for context", () => {
+      const w = primary.findWorkerForContext("project-alpha");
+      assert.ok(w);
+      assert.equal(w.id, workerId);
+    });
+
+    it("should return undefined for unassigned context", () => {
+      const w = primary.findWorkerForContext("nonexistent");
+      assert.equal(w, undefined);
+    });
+
+    it("should track the assigned context on worker", () => {
+      const contexts = worker.getAssignedContexts();
+      assert.ok(contexts.includes("project-alpha"));
+    });
+
+    it("should assign a second context", async () => {
+      const resp = await primary.assignContext(workerId, "project-beta", "Beta project");
+      assert.equal(resp.accepted, true);
+    });
+
+    it("should reject when at capacity", async () => {
+      const resp = await primary.assignContext(workerId, "project-gamma", "Too many");
+      assert.equal(resp.accepted, false);
+      assert.ok(resp.reason?.includes("capacity"));
+    });
+
+    it("should unassign a context", async () => {
+      const ok = await primary.unassignContext(workerId, "project-beta");
+      assert.equal(ok, true);
+
+      const w = primary.getWorker(workerId);
+      assert.ok(w);
+      assert.ok(!w.assigned_contexts.includes("project-beta"));
+    });
+  });
+
+  describe("Status Reporting", () => {
+    it("should report idle status when no task", async () => {
+      const resp = await fetch(`${WORKER_URL}/status`);
+      const body = (await resp.json()) as WorkerStatusReport;
+      assert.equal(body.activity, "idle");
+      assert.equal(body.current_context, null);
+      assert.equal(body.current_task, null);
+    });
+
+    it("should reflect active context and task", async () => {
+      worker.setActiveContext("project-alpha");
+      worker.setCurrentTask("task-42");
+
+      const resp = await fetch(`${WORKER_URL}/status`);
+      const body = (await resp.json()) as WorkerStatusReport;
+      assert.equal(body.activity, "working");
+      assert.equal(body.current_context, "project-alpha");
+      assert.equal(body.current_task, "task-42");
+    });
+
+    it("should handle status report on primary side", () => {
+      const report: WorkerStatusReport = {
+        activity: "working",
+        current_context: "project-alpha",
+        current_task: "task-42",
+      };
+
+      const status = primary.handleStatusReport(workerId, report);
+      assert.ok(status);
+      assert.equal(status.worker_id, workerId);
+      assert.equal(status.activity, "working");
+      assert.equal(status.current_context, "project-alpha");
+    });
+
+    it("should return null for unknown worker status report", () => {
+      const report: WorkerStatusReport = {
+        activity: "idle",
+        current_context: null,
+        current_task: null,
+      };
+
+      const status = primary.handleStatusReport("nonexistent", report);
+      assert.equal(status, null);
+    });
+  });
+
+  describe("Deregistration", () => {
+    it("should deregister a worker", () => {
+      const ok = primary.deregister(workerId);
+      assert.equal(ok, true);
+      assert.equal(primary.getWorkers().length, 0);
+    });
+
+    it("should return false for unknown worker", () => {
+      const ok = primary.deregister("nonexistent");
+      assert.equal(ok, false);
+    });
+  });
+});

package/packages/runtime/src/__tests__/integration.test.ts

@@ -0,0 +1,434 @@
+import { describe, it, before, after, mock } from "node:test";
+import assert from "node:assert/strict";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+
+/**
+ * Integration tests for Hivemind memory architecture.
+ *
+ * These tests mock the memory daemon HTTP API to verify:
+ * - Context creation and isolation
+ * - Episode storage scoped to contexts
+ * - Search isolation (context A doesn't leak into B)
+ * - Cross-context search returns labeled results
+ * - Global context accessible from all contexts
+ * - Task engine CRUD
+ */
+
+// In-memory mock state
+interface MockEpisode {
+  id: string;
+  timestamp: string;
+  context_name: string;
+  role: string;
+  content: string;
+  access_count: number;
+  layer: string;
+}
+
+interface MockTask {
+  id: string;
+  context_name: string;
+  title: string;
+  description: string;
+  status: string;
+  blocked_by: string[];
+  created_at: string;
+  updated_at: string;
+}
+
+let episodes: MockEpisode[] = [];
+let contexts: Map<string, { name: string; description: string; created_at: string }> = new Map();
+let tasks: MockTask[] = [];
+let nextId = 1;
+
+function resetState() {
+  episodes = [];
+  contexts = new Map();
+  tasks = [];
+  nextId = 1;
+}
+
+function parseBody(req: IncomingMessage): Promise<any> {
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk: Buffer) => (data += chunk));
+    req.on("end", () => resolve(data ? JSON.parse(data) : {}));
+  });
+}
+
+function mockHandler(req: IncomingMessage, res: ServerResponse) {
+  const url = new URL(req.url!, `http://localhost`);
+  const path = url.pathname;
+  const method = req.method!;
+
+  res.setHeader("Content-Type", "application/json");
+
+  // Health check
+  if (path === "/health" && method === "GET") {
+    res.end(JSON.stringify({ status: "ok" }));
+    return;
+  }
+
+  // POST /episodes
+  if (path === "/episodes" && method === "POST") {
+    parseBody(req).then((body) => {
+      const ep: MockEpisode = {
+        id: `ep-${nextId++}`,
+        timestamp: new Date().toISOString(),
+        context_name: body.context_name || "global",
+        role: body.role,
+        content: body.content,
+        access_count: 0,
+        layer: "L2",
+      };
+      episodes.push(ep);
+      res.end(JSON.stringify(ep));
+    });
+    return;
+  }
+
+  // GET /search — scoped to context param
+  if (path === "/search" && method === "GET") {
+    const ctx = url.searchParams.get("context");
+    const q = url.searchParams.get("q") || "";
+    const limit = parseInt(url.searchParams.get("limit") || "10");
+    let results = episodes;
+    if (ctx) results = results.filter((e) => e.context_name === ctx || e.context_name === "global");
+    // Simple text matching for mock
+    if (q) results = results.filter((e) => e.content.toLowerCase().includes(q.toLowerCase()));
+    const scored = results.slice(0, limit).map((e, i) => ({
+      ...e,
+      score: 1 - i * 0.1,
+    }));
+    res.end(JSON.stringify({ episodes: scored }));
+    return;
+  }
+
+  // GET /search/cross-context
+  if (path === "/search/cross-context" && method === "GET") {
+    const q = url.searchParams.get("q") || "";
+    const limit = parseInt(url.searchParams.get("limit") || "10");
+    const matched = episodes.filter((e) => e.content.toLowerCase().includes(q.toLowerCase()));
+    const byContext = new Map<string, any[]>();
+    for (const e of matched.slice(0, limit)) {
+      const list = byContext.get(e.context_name) || [];
+      list.push({ ...e, score: 0.9, source_context: e.context_name });
+      byContext.set(e.context_name, list);
+    }
+    const results = Array.from(byContext.entries()).map(([context, eps]) => ({
+      context,
+      episodes: eps,
+    }));
+    res.end(JSON.stringify({ results }));
+    return;
+  }
+
+  // POST /contexts
+  if (path === "/contexts" && method === "POST") {
+    parseBody(req).then((body) => {
+      contexts.set(body.name, {
+        name: body.name,
+        description: body.description || "",
+        created_at: new Date().toISOString(),
+      });
+      res.end(JSON.stringify({ ok: true }));
+    });
+    return;
+  }
+
+  // GET /contexts
+  if (path === "/contexts" && method === "GET") {
+    const list = Array.from(contexts.values()).map((c) => ({
+      ...c,
+      episode_count: episodes.filter((e) => e.context_name === c.name).length,
+    }));
+    res.end(JSON.stringify({ contexts: list }));
+    return;
+  }
+
+  // GET /contexts/:name
+  const ctxMatch = path.match(/^\/contexts\/([^/]+)$/);
+  if (ctxMatch && method === "GET") {
+    const name = decodeURIComponent(ctxMatch[1]);
+    const eps = episodes.filter((e) => e.context_name === name);
+    res.end(JSON.stringify(eps));
+    return;
+  }
+
+  // POST /tasks
+  if (path === "/tasks" && method === "POST") {
+    parseBody(req).then((body) => {
+      const task: MockTask = {
+        id: `task-${nextId++}`,
+        context_name: body.context_name,
+        title: body.title,
+        description: body.description || "",
+        status: body.status || "planned",
+        blocked_by: body.blocked_by || [],
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+      tasks.push(task);
+      res.end(JSON.stringify(task));
+    });
+    return;
+  }
+
+  // GET /tasks
+  if (path === "/tasks" && method === "GET") {
+    const ctx = url.searchParams.get("context") || "";
+    const status = url.searchParams.get("status");
+    let result = tasks.filter((t) => t.context_name === ctx);
+    if (status) result = result.filter((t) => t.status === status);
+    res.end(JSON.stringify({ tasks: result }));
+    return;
+  }
+
+  // PATCH /tasks/:id
+  const taskMatch = path.match(/^\/tasks\/([^/]+)$/);
+  if (taskMatch && method === "PATCH") {
+    parseBody(req).then((body) => {
+      const id = decodeURIComponent(taskMatch[1]);
+      const task = tasks.find((t) => t.id === id);
+      if (!task) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: "not found" }));
+        return;
+      }
+      Object.assign(task, body, { updated_at: new Date().toISOString() });
+      res.end(JSON.stringify(task));
+    });
+    return;
+  }
+
+  // GET /tasks/next
+  if (path === "/tasks/next" && method === "GET") {
+    const ctx = url.searchParams.get("context") || "";
+    const next = tasks.find(
+      (t) =>
+        t.context_name === ctx &&
+        t.status === "planned" &&
+        t.blocked_by.every((dep) => tasks.find((d) => d.id === dep)?.status === "complete"),
+    );
+    if (!next) {
+      res.statusCode = 404;
+      res.end(JSON.stringify({ error: "no tasks" }));
+      return;
+    }
+    res.end(JSON.stringify(next));
+    return;
+  }
+
+  res.statusCode = 404;
+  res.end(JSON.stringify({ error: "not found" }));
+}
+
+let server: ReturnType<typeof createServer>;
+let port: number;
+
+describe("Hivemind Memory Integration", () => {
+  before(async () => {
+    server = createServer(mockHandler);
+    await new Promise<void>((resolve) => {
+      server.listen(0, () => {
+        port = (server.address() as any).port;
+        resolve();
+      });
+    });
+  });
+
+  after(() => {
+    server.close();
+  });
+
+  describe("Context Isolation", () => {
+    before(() => resetState());
+
+    it("should create two independent contexts", async () => {
+      const base = `http://localhost:${port}`;
+
+      // Create contexts
+      await fetch(`${base}/contexts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "project-alpha", description: "Alpha project" }),
+      });
+      await fetch(`${base}/contexts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "project-beta", description: "Beta project" }),
+      });
+
+      const listResp = await fetch(`${base}/contexts`);
+      const { contexts: ctxList } = (await listResp.json()) as any;
+      assert.equal(ctxList.length, 2);
+    });
+
+    it("should store episodes in separate contexts", async () => {
+      const base = `http://localhost:${port}`;
+
+      await fetch(`${base}/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-alpha", role: "user", content: "Alpha auth uses JWT tokens" }),
+      });
+      await fetch(`${base}/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-beta", role: "user", content: "Beta uses cookie-based sessions" }),
+      });
+
+      const alphaEps = await (await fetch(`${base}/contexts/project-alpha`)).json() as any[];
+      const betaEps = await (await fetch(`${base}/contexts/project-beta`)).json() as any[];
+
+      assert.equal(alphaEps.length, 1);
+      assert.equal(betaEps.length, 1);
+      assert.ok(alphaEps[0].content.includes("JWT"));
+      assert.ok(betaEps[0].content.includes("cookie"));
+    });
+
+    it("should NOT return project-beta results when searching project-alpha", async () => {
+      const base = `http://localhost:${port}`;
+
+      const resp = await fetch(`${base}/search?q=cookie&context=project-alpha`);
+      const { episodes: results } = (await resp.json()) as any;
+      assert.equal(results.length, 0, "Alpha search should not find Beta's episodes");
+    });
+
+    it("should return results from both contexts in cross-context search", async () => {
+      const base = `http://localhost:${port}`;
+
+      // Store something searchable in both
+      await fetch(`${base}/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-alpha", role: "assistant", content: "Authentication architecture decided" }),
+      });
+      await fetch(`${base}/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-beta", role: "assistant", content: "Authentication middleware complete" }),
+      });
+
+      const resp = await fetch(`${base}/search/cross-context?q=authentication`);
+      const { results } = (await resp.json()) as any;
+
+      const contextNames = results.map((r: any) => r.context);
+      assert.ok(contextNames.includes("project-alpha"), "Should include alpha");
+      assert.ok(contextNames.includes("project-beta"), "Should include beta");
+
+      // Verify results are labeled by source
+      for (const r of results) {
+        assert.ok(r.context, "Each result group should have a context label");
+        for (const ep of r.episodes) {
+          assert.ok(ep.source_context, "Each episode should have source_context");
+        }
+      }
+    });
+  });
+
+  describe("Global Context Accessibility", () => {
+    before(() => resetState());
+
+    it("should make global episodes visible from any context search", async () => {
+      const base = `http://localhost:${port}`;
+
+      // Store a global episode
+      await fetch(`${base}/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "global", role: "system", content: "Agent identity: I am Aidan Hivemind" }),
+      });
+
+      // Search from a project context — global should be included
+      const resp = await fetch(`${base}/search?q=identity&context=project-x`);
+      const { episodes: results } = (await resp.json()) as any;
+      assert.ok(results.length > 0, "Global episode should be visible from project context");
+      assert.ok(results[0].content.includes("Aidan"));
+    });
+  });
+
+  describe("Task Engine", () => {
+    before(() => resetState());
+
+    it("should create and list tasks per context", async () => {
+      const base = `http://localhost:${port}`;
+
+      await fetch(`${base}/tasks`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-alpha", title: "Set up CI", description: "Configure GitHub Actions" }),
+      });
+      await fetch(`${base}/tasks`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-alpha", title: "Write README", description: "" }),
+      });
+      await fetch(`${base}/tasks`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "project-beta", title: "Deploy staging", description: "" }),
+      });
+
+      const alphaResp = await fetch(`${base}/tasks?context=project-alpha`);
+      const { tasks: alphaTasks } = (await alphaResp.json()) as any;
+      assert.equal(alphaTasks.length, 2);
+
+      const betaResp = await fetch(`${base}/tasks?context=project-beta`);
+      const { tasks: betaTasks } = (await betaResp.json()) as any;
+      assert.equal(betaTasks.length, 1);
+    });
+
+    it("should update task status", async () => {
+      const base = `http://localhost:${port}`;
+
+      const listResp = await fetch(`${base}/tasks?context=project-alpha`);
+      const { tasks: list } = (await listResp.json()) as any;
+      const taskId = list[0].id;
+
+      const patchResp = await fetch(`${base}/tasks/${taskId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ status: "complete" }),
+      });
+      const updated = await patchResp.json() as any;
+      assert.equal(updated.status, "complete");
+    });
+
+    it("should get next available task respecting dependencies", async () => {
+      const base = `http://localhost:${port}`;
+      resetState();
+
+      // Create task A (no deps)
+      const respA = await fetch(`${base}/tasks`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "proj", title: "Task A", description: "" }),
+      });
+      const taskA = await respA.json() as any;
+
+      // Create task B (blocked by A)
+      await fetch(`${base}/tasks`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ context_name: "proj", title: "Task B", description: "", blocked_by: [taskA.id] }),
+      });
+
+      // Next should be A (B is blocked)
+      const nextResp = await fetch(`${base}/tasks/next?context=proj`);
+      const next = await nextResp.json() as any;
+      assert.equal(next.title, "Task A");
+
+      // Complete A, now B should be next
+      await fetch(`${base}/tasks/${taskA.id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ status: "complete" }),
+      });
+
+      const nextResp2 = await fetch(`${base}/tasks/next?context=proj`);
+      const next2 = await nextResp2.json() as any;
+      assert.equal(next2.title, "Task B");
+    });
+  });
+});